kopia lustrzana https://github.com/pimoroni/pimoroni-pico
Partial micropython bindings for RV3028
ZodiusInfuser
Phil Howard
rodzic
80eddb24c7
commit
2be5528ec7
|
|
@ -77,6 +77,26 @@ namespace pimoroni {
|
|||
return true;
|
||||
}
|
||||
|
||||
void RV3028::reset() {
|
||||
set_bit(RV3028_CTRL2, CTRL2_RESET);
|
||||
}
|
||||
|
||||
i2c_inst_t* RV3028::get_i2c() const {
|
||||
return i2c;
|
||||
}
|
||||
|
||||
int RV3028::get_sda() const {
|
||||
return sda;
|
||||
}
|
||||
|
||||
int RV3028::get_scl() const {
|
||||
return scl;
|
||||
}
|
||||
|
||||
int RV3028::get_int() const {
|
||||
return interrupt;
|
||||
}
|
||||
|
||||
bool RV3028::setup(bool set_24Hour, bool disable_TrickleCharge, bool set_LevelSwitchingMode) {
|
||||
sleep_ms(1000);
|
||||
if(set_24Hour) {
|
||||
|
|
@ -215,14 +235,14 @@ namespace pimoroni {
|
|||
|
||||
//Returns a pointer to array of chars that are the date in mm/dd/yyyy format because they're weird
|
||||
char* RV3028::string_date_usa() {
|
||||
static char date[11]; //Max of mm/dd/yyyy with \0 terminator
|
||||
static char date[11 + 3]; //Max of mm/dd/yyyy with \0 terminator (plus extra for worst case conversion)
|
||||
sprintf(date, "%02hhu/%02hhu/20%02hhu", bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_YEAR]));
|
||||
return date;
|
||||
}
|
||||
|
||||
//Returns a pointer to array of chars that are the date in dd/mm/yyyy format
|
||||
char* RV3028::string_date() {
|
||||
static char date[11]; //Max of dd/mm/yyyy with \0 terminator
|
||||
static char date[11 + 3]; //Max of dd/mm/yyyy with \0 terminator (plus extra for worst case conversion)
|
||||
sprintf(date, "%02hhu/%02hhu/20%02hhu", bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_YEAR]));
|
||||
return date;
|
||||
}
|
||||
|
|
@ -230,7 +250,7 @@ namespace pimoroni {
|
|||
//Returns a pointer to array of chars that represents the time in hh:mm:ss format
|
||||
//Adds AM/PM if in 12 hour mode
|
||||
char* RV3028::string_time() {
|
||||
static char time[11]; //Max of hh:mm:ssXM with \0 terminator
|
||||
static char time[11 + 3]; //Max of hh:mm:ssXM with \0 terminator (plus extra for worst case conversion)
|
||||
|
||||
if(is_12_hour() == true) {
|
||||
char half = 'A';
|
||||
|
|
@ -245,18 +265,18 @@ namespace pimoroni {
|
|||
}
|
||||
|
||||
char* RV3028::string_time_stamp() {
|
||||
static char timeStamp[25]; //Max of yyyy-mm-ddThh:mm:ss.ss with \0 terminator
|
||||
static char time_stamp[25 + 4]; //Max of yyyy-mm-ddThh:mm:ss.ss with \0 terminator (plus extra for worst case conversion)
|
||||
|
||||
if(is_12_hour() == true) {
|
||||
char half = 'A';
|
||||
if(is_pm()) half = 'P';
|
||||
|
||||
sprintf(timeStamp, "20%02hhu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu%cM", bcd_to_dec(times[TIME_YEAR]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]), half);
|
||||
sprintf(time_stamp, "20%02hhu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu%cM", bcd_to_dec(times[TIME_YEAR]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]), half);
|
||||
}
|
||||
else
|
||||
sprintf(timeStamp, "20%02hhu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu", bcd_to_dec(times[TIME_YEAR]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]));
|
||||
sprintf(time_stamp, "20%02hhu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu", bcd_to_dec(times[TIME_YEAR]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]));
|
||||
|
||||
return timeStamp;
|
||||
return time_stamp;
|
||||
}
|
||||
|
||||
uint8_t RV3028::get_seconds() {
|
||||
|
|
@ -394,7 +414,7 @@ namespace pimoroni {
|
|||
7: All disabled <EFBFBD> Default value
|
||||
If you want to set a weekday alarm (setWeekdayAlarm_not_Date = true), set 'date_or_weekday' from 0 (Sunday) to 6 (Saturday)
|
||||
********************************/
|
||||
void RV3028::enable_alarm_interrupt(uint8_t min, uint8_t hour, uint8_t date_or_weekday, bool setWeekdayAlarm_not_Date, uint8_t mode, bool enable_clock_output) {
|
||||
void RV3028::enable_alarm_interrupt(uint8_t min, uint8_t hour, uint8_t date_or_weekday, bool set_weekday_alarm_not_date, uint8_t mode, bool enable_clock_output) {
|
||||
//disable Alarm Interrupt to prevent accidental interrupts during configuration
|
||||
disable_alarm_interrupt();
|
||||
clear_alarm_interrupt_flag();
|
||||
|
|
@ -403,7 +423,7 @@ namespace pimoroni {
|
|||
set_24_hour();
|
||||
|
||||
//Set WADA bit (Weekday/Date Alarm)
|
||||
if(setWeekdayAlarm_not_Date)
|
||||
if(set_weekday_alarm_not_date)
|
||||
clear_bit(RV3028_CTRL1, CTRL1_WADA);
|
||||
else
|
||||
set_bit(RV3028_CTRL1, CTRL1_WADA);
|
||||
|
|
@ -467,10 +487,12 @@ namespace pimoroni {
|
|||
uint8_t ctrl1_val = read_register(RV3028_CTRL1);
|
||||
if(timer_repeat) {
|
||||
ctrl1_val |= 1 << CTRL1_TRPT;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
ctrl1_val &= ~(1 << CTRL1_TRPT);
|
||||
}
|
||||
switch (timer_frequency) {
|
||||
|
||||
switch(timer_frequency) {
|
||||
case 4096: // 4096Hz (default) // up to 122us error on first time
|
||||
ctrl1_val &= ~3; // Clear both the bits
|
||||
break;
|
||||
|
|
@ -505,10 +527,10 @@ namespace pimoroni {
|
|||
clear_bit(RV3028_INT_MASK, IMT_MASK_CTIE);
|
||||
}
|
||||
|
||||
uint16_t RV3028::get_timer_count(void) {
|
||||
uint16_t RV3028::get_timer_count() {
|
||||
// Reads the number of remaining timer ticks
|
||||
uint8_t r0 = read_register(RV3028_TIMERSTAT_0);
|
||||
return(r0 + (read_register(RV3028_TIMERSTAT_1) << 8));
|
||||
return (r0 + (read_register(RV3028_TIMERSTAT_1) << 8));
|
||||
}
|
||||
|
||||
void RV3028::enable_timer_interrupt() {
|
||||
|
|
@ -542,12 +564,10 @@ namespace pimoroni {
|
|||
disable_periodic_update_interrupt();
|
||||
clear_periodic_update_interrupt_flag();
|
||||
|
||||
if(every_second) {
|
||||
if(every_second)
|
||||
clear_bit(RV3028_CTRL1, CTRL1_USEL);
|
||||
}
|
||||
else { // every minute
|
||||
else // every minute
|
||||
set_bit(RV3028_CTRL1, CTRL1_USEL);
|
||||
}
|
||||
|
||||
set_bit(RV3028_CTRL2, CTRL2_UIE);
|
||||
|
||||
|
|
@ -686,7 +706,6 @@ namespace pimoroni {
|
|||
clear_bit(RV3028_STATUS, STATUS_CLKF);
|
||||
}
|
||||
|
||||
|
||||
//Returns the status byte
|
||||
uint8_t RV3028::status(void) {
|
||||
return(read_register(RV3028_STATUS));
|
||||
|
|
@ -696,46 +715,6 @@ namespace pimoroni {
|
|||
write_register(RV3028_STATUS, 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// i2c functions
|
||||
|
||||
int RV3028::write_bytes(uint8_t reg, uint8_t *buf, int len) {
|
||||
uint8_t buffer[len + 1];
|
||||
buffer[0] = reg;
|
||||
for(int x = 0; x < len; x++) {
|
||||
buffer[x + 1] = buf[x];
|
||||
}
|
||||
return i2c_write_blocking(i2c, address, buffer, len + 1, false);
|
||||
};
|
||||
|
||||
int RV3028::read_bytes(uint8_t reg, uint8_t *buf, int len) {
|
||||
i2c_write_blocking(i2c, address, ®, 1, true);
|
||||
i2c_read_blocking(i2c, address, buf, len, false);
|
||||
return len;
|
||||
};
|
||||
|
||||
uint8_t RV3028::get_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
||||
uint8_t value;
|
||||
read_bytes(reg, &value, 1);
|
||||
return value & (mask << shift);
|
||||
}
|
||||
|
||||
void RV3028::set_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
||||
uint8_t value;
|
||||
read_bytes(reg, &value, 1);
|
||||
value |= mask << shift;
|
||||
write_bytes(reg, &value, 1);
|
||||
}
|
||||
|
||||
void RV3028::clear_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
||||
uint8_t value;
|
||||
read_bytes(reg, &value, 1);
|
||||
value &= ~(mask << shift);
|
||||
write_bytes(reg, &value, 1);
|
||||
}
|
||||
|
||||
/*********************************
|
||||
FOR INTERNAL USE
|
||||
********************************/
|
||||
|
|
@ -750,7 +729,7 @@ namespace pimoroni {
|
|||
|
||||
uint8_t RV3028::read_register(uint8_t addr) {
|
||||
uint8_t b1[2];
|
||||
if( 1 == RV3028::read_bytes(addr, b1, 1))
|
||||
if(1 == RV3028::read_bytes(addr, b1, 1))
|
||||
return b1[0];
|
||||
else
|
||||
return 0xFF; //Error
|
||||
|
|
@ -849,10 +828,6 @@ namespace pimoroni {
|
|||
|
||||
}
|
||||
|
||||
void RV3028::reset() {
|
||||
set_bit(RV3028_CTRL2, CTRL2_RESET);
|
||||
}
|
||||
|
||||
void RV3028::set_bit(uint8_t reg_addr, uint8_t bit_num) {
|
||||
RV3028::set_bits(reg_addr, bit_num, 0x01);
|
||||
}
|
||||
|
|
@ -865,4 +840,41 @@ namespace pimoroni {
|
|||
uint8_t value = RV3028::get_bits(reg_addr, bit_num, 0x01);
|
||||
return value;
|
||||
}
|
||||
|
||||
// i2c functions
|
||||
int RV3028::write_bytes(uint8_t reg, uint8_t *buf, int len) {
|
||||
uint8_t buffer[len + 1];
|
||||
buffer[0] = reg;
|
||||
for(int x = 0; x < len; x++) {
|
||||
buffer[x + 1] = buf[x];
|
||||
}
|
||||
return i2c_write_blocking(i2c, address, buffer, len + 1, false);
|
||||
};
|
||||
|
||||
int RV3028::read_bytes(uint8_t reg, uint8_t *buf, int len) {
|
||||
i2c_write_blocking(i2c, address, ®, 1, true);
|
||||
i2c_read_blocking(i2c, address, buf, len, false);
|
||||
return len;
|
||||
};
|
||||
|
||||
uint8_t RV3028::get_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
||||
uint8_t value;
|
||||
read_bytes(reg, &value, 1);
|
||||
return value & (mask << shift);
|
||||
}
|
||||
|
||||
void RV3028::set_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
||||
uint8_t value;
|
||||
read_bytes(reg, &value, 1);
|
||||
value |= mask << shift;
|
||||
write_bytes(reg, &value, 1);
|
||||
}
|
||||
|
||||
void RV3028::clear_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
||||
uint8_t value;
|
||||
read_bytes(reg, &value, 1);
|
||||
value &= ~(mask << shift);
|
||||
write_bytes(reg, &value, 1);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -230,6 +230,12 @@ namespace pimoroni {
|
|||
//--------------------------------------------------
|
||||
public:
|
||||
bool init();
|
||||
void reset();
|
||||
|
||||
i2c_inst_t* get_i2c() const;
|
||||
int get_sda() const;
|
||||
int get_scl() const;
|
||||
int get_int() const;
|
||||
|
||||
bool setup(bool set_24Hour = true, bool disable_TrickleCharge = true, bool set_LevelSwitchingMode = true);
|
||||
bool set_time(uint8_t sec, uint8_t min, uint8_t hour, uint8_t weekday, uint8_t date, uint8_t month, uint16_t year);
|
||||
|
|
@ -243,7 +249,7 @@ namespace pimoroni {
|
|||
bool set_year(uint16_t value);
|
||||
bool set_to_compiler_time(); //Uses the hours, mins, etc from compile time to set RTC
|
||||
|
||||
bool update_time(); //Update the local array with the RTC registers
|
||||
bool update_time(); //Update the local array with the RTC registers
|
||||
|
||||
char* string_date_usa(); //Return date in mm-dd-yyyy
|
||||
char* string_date(); //Return date in dd-mm-yyyy
|
||||
|
|
@ -258,23 +264,22 @@ namespace pimoroni {
|
|||
uint8_t get_month();
|
||||
uint16_t get_year();
|
||||
|
||||
|
||||
bool is_12_hour(); //Returns true if 12hour bit is set
|
||||
bool is_pm(); //Returns true if is12Hour and PM bit is set
|
||||
bool is_12_hour(); //Returns true if 12hour bit is set
|
||||
bool is_pm(); //Returns true if is12Hour and PM bit is set
|
||||
void set_12_hour();
|
||||
void set_24_hour();
|
||||
|
||||
bool set_unix(uint32_t value); //Set the UNIX Time (Real Time and UNIX Time are INDEPENDENT!)
|
||||
uint32_t get_unix();
|
||||
|
||||
void enable_alarm_interrupt(uint8_t min, uint8_t hour, uint8_t date_or_weekday, bool setWeekdayAlarm_not_Date, uint8_t mode, bool enable_clock_output = false);
|
||||
void enable_alarm_interrupt(uint8_t min, uint8_t hour, uint8_t date_or_weekday, bool set_weekday_alarm_not_date, uint8_t mode, bool enable_clock_output = false);
|
||||
void enable_alarm_interrupt();
|
||||
void disable_alarm_interrupt();
|
||||
bool read_alarm_interrupt_flag();
|
||||
void clear_alarm_interrupt_flag();
|
||||
|
||||
void set_timer(bool timer_repeat, uint16_t timer_frequency, uint16_t timer_value, bool setInterrupt, bool start_timer, bool enable_clock_output = false);
|
||||
uint16_t get_timer_count(void);
|
||||
void set_timer(bool timer_repeat, uint16_t timer_frequency, uint16_t timer_value, bool set_interrupt, bool start_timer, bool enable_clock_output = false);
|
||||
uint16_t get_timer_count();
|
||||
void enable_timer();
|
||||
void disable_timer();
|
||||
void enable_timer_interrupt();
|
||||
|
|
@ -300,6 +305,7 @@ namespace pimoroni {
|
|||
uint8_t status(); //Returns the status byte
|
||||
void clear_interrupts();
|
||||
|
||||
private:
|
||||
//Values in RTC are stored in Binary Coded Decimal. These functions convert to/from Decimal
|
||||
uint8_t bcd_to_dec(uint8_t val);
|
||||
uint8_t dec_to_bcd(uint8_t val);
|
||||
|
|
@ -312,13 +318,11 @@ namespace pimoroni {
|
|||
bool write_config_eeprom_ram_mirror(uint8_t eepromaddr, uint8_t val);
|
||||
uint8_t read_config_eeprom_ram_mirror(uint8_t eepromaddr);
|
||||
bool wait_for_eeprom();
|
||||
void reset();
|
||||
|
||||
void set_bit(uint8_t reg_addr, uint8_t bit_num);
|
||||
void clear_bit(uint8_t reg_addr, uint8_t bit_num);
|
||||
bool read_bit(uint8_t reg_addr, uint8_t bit_num);
|
||||
|
||||
private:
|
||||
// From i2cdevice
|
||||
int write_bytes(uint8_t reg, uint8_t *buf, int len);
|
||||
int read_bytes(uint8_t reg, uint8_t *buf, int len);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,163 @@
|
|||
#include "breakout_rtc.h"
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// BreakoutRTC Class
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/***** Methods *****/
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_reset_obj, BreakoutRTC_reset);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_setup_obj, BreakoutRTC_setup);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_time_obj, 8, BreakoutRTC_set_time);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_seconds_obj, 2, BreakoutRTC_set_seconds);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_minutes_obj, 2, BreakoutRTC_set_minutes);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_hours_obj, 2, BreakoutRTC_set_hours);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_weekday_obj, 2, BreakoutRTC_set_weekday);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_date_obj, 2, BreakoutRTC_set_date);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_month_obj, 2, BreakoutRTC_set_month);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_year_obj, 2, BreakoutRTC_set_year);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_set_to_compiler_time_obj, BreakoutRTC_set_to_compiler_time);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_update_time_obj, BreakoutRTC_update_time);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_string_date_usa_obj, BreakoutRTC_string_date_usa);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_string_date_obj, BreakoutRTC_string_date);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_string_time_obj, BreakoutRTC_string_time);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_string_time_stamp_obj, BreakoutRTC_string_time_stamp);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_seconds_obj, BreakoutRTC_get_seconds);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_minutes_obj, BreakoutRTC_get_minutes);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_hours_obj, BreakoutRTC_get_hours);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_weekday_obj, BreakoutRTC_get_weekday);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_date_obj, BreakoutRTC_get_date);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_month_obj, BreakoutRTC_get_month);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_year_obj, BreakoutRTC_get_year);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_is_12_hour_obj, BreakoutRTC_is_12_hour);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_is_pm_obj, BreakoutRTC_is_pm);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_set_12_hour_obj, BreakoutRTC_set_12_hour);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_set_24_hour_obj, BreakoutRTC_set_24_hour);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_unix_obj, 2, BreakoutRTC_set_unix);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_unix_obj, BreakoutRTC_get_unix);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_enable_alarm_interrupt_obj, 6, BreakoutRTC_enable_alarm_interrupt);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_disable_alarm_interrupt_obj, BreakoutRTC_disable_alarm_interrupt);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_read_alarm_interrupt_flag_obj, BreakoutRTC_read_alarm_interrupt_flag);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_clear_alarm_interrupt_flag_obj, BreakoutRTC_clear_alarm_interrupt_flag);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_timer_obj, 6, BreakoutRTC_set_timer);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_get_timer_count_obj, BreakoutRTC_get_timer_count);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_enable_timer_obj, BreakoutRTC_enable_timer);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_disable_timer_obj, BreakoutRTC_disable_timer);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_enable_timer_interupt_obj, BreakoutRTC_enable_timer_interupt);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_disable_timer_interrupt_obj, BreakoutRTC_disable_timer_interrupt);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_read_timer_interrupt_flag_obj, BreakoutRTC_read_timer_interrupt_flag);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_clear_timer_interrupt_flag_obj, BreakoutRTC_clear_timer_interrupt_flag);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_enable_periodic_update_interrupt_obj, 2, BreakoutRTC_enable_periodic_update_interrupt);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_disable_periodic_update_interrupt_obj, BreakoutRTC_disable_periodic_update_interrupt);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_read_periodic_update_interrupt_flag_obj, BreakoutRTC_read_periodic_update_interrupt_flag);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_clear_periodic_update_interrupt_flag_obj, BreakoutRTC_clear_periodic_update_interrupt_flag);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_enable_trickle_charge_obj, 2, BreakoutRTC_enable_trickle_charge);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_disable_trickle_charge_obj, BreakoutRTC_disable_trickle_charge);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_set_backup_switchover_mode_obj, 2, BreakoutRTC_set_backup_switchover_mode);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_enable_clock_out_obj, 2, BreakoutRTC_enable_clock_out);
|
||||
MP_DEFINE_CONST_FUN_OBJ_KW(BreakoutRTC_enable_interrupt_controlled_clockout_obj, 2, BreakoutRTC_enable_interrupt_controlled_clockout);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_disable_clock_out_obj, BreakoutRTC_disable_clock_out);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_read_clock_output_interrupt_flag_obj, BreakoutRTC_read_clock_output_interrupt_flag);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_clear_clock_output_interrupt_flag_obj, BreakoutRTC_clear_clock_output_interrupt_flag);
|
||||
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_status_obj, BreakoutRTC_status);
|
||||
MP_DEFINE_CONST_FUN_OBJ_1(BreakoutRTC_clear_interrupts_obj, BreakoutRTC_clear_interrupts);
|
||||
|
||||
/***** Binding of Methods *****/
|
||||
STATIC const mp_rom_map_elem_t BreakoutRTC_locals_dict_table[] = {
|
||||
{ MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR(&BreakoutRTC_reset_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_setup), MP_ROM_PTR(&BreakoutRTC_setup_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_time), MP_ROM_PTR(&BreakoutRTC_set_time_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_seconds), MP_ROM_PTR(&BreakoutRTC_set_seconds_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_minutes), MP_ROM_PTR(&BreakoutRTC_set_minutes_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_hours), MP_ROM_PTR(&BreakoutRTC_set_hours_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_weekday), MP_ROM_PTR(&BreakoutRTC_set_weekday_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_date), MP_ROM_PTR(&BreakoutRTC_set_date_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_month), MP_ROM_PTR(&BreakoutRTC_set_month_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_year), MP_ROM_PTR(&BreakoutRTC_set_year_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_to_compiler_time), MP_ROM_PTR(&BreakoutRTC_set_to_compiler_time_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_update_time), MP_ROM_PTR(&BreakoutRTC_update_time_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_string_date_usa), MP_ROM_PTR(&BreakoutRTC_string_date_usa_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_string_date), MP_ROM_PTR(&BreakoutRTC_string_date_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_string_time), MP_ROM_PTR(&BreakoutRTC_string_time_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_string_time_stamp), MP_ROM_PTR(&BreakoutRTC_string_time_stamp_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_seconds), MP_ROM_PTR(&BreakoutRTC_get_seconds_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_minutes), MP_ROM_PTR(&BreakoutRTC_get_minutes_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_hours), MP_ROM_PTR(&BreakoutRTC_get_hours_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_weekday), MP_ROM_PTR(&BreakoutRTC_get_weekday_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_date), MP_ROM_PTR(&BreakoutRTC_get_date_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_month), MP_ROM_PTR(&BreakoutRTC_get_month_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_year), MP_ROM_PTR(&BreakoutRTC_get_year_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_is_12_hour), MP_ROM_PTR(&BreakoutRTC_is_12_hour_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_is_pm), MP_ROM_PTR(&BreakoutRTC_is_pm_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_12_hour), MP_ROM_PTR(&BreakoutRTC_set_12_hour_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_24_hour), MP_ROM_PTR(&BreakoutRTC_set_24_hour_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_unix), MP_ROM_PTR(&BreakoutRTC_set_unix_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_unix), MP_ROM_PTR(&BreakoutRTC_get_unix_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_enable_alarm_interrupt), MP_ROM_PTR(&BreakoutRTC_enable_alarm_interrupt_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_disable_alarm_interrupt), MP_ROM_PTR(&BreakoutRTC_disable_alarm_interrupt_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_read_alarm_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_read_alarm_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_clear_alarm_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_clear_alarm_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_timer), MP_ROM_PTR(&BreakoutRTC_set_timer_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_timer_count), MP_ROM_PTR(&BreakoutRTC_get_timer_count_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_enable_timer), MP_ROM_PTR(&BreakoutRTC_enable_timer_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_disable_timer), MP_ROM_PTR(&BreakoutRTC_disable_timer_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_enable_timer_interrupt), MP_ROM_PTR(&BreakoutRTC_enable_timer_interupt_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_disable_timer_interrupt), MP_ROM_PTR(&BreakoutRTC_disable_timer_interrupt_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_read_timer_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_read_timer_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_clear_timer_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_clear_timer_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_enable_periodic_update_interrupt), MP_ROM_PTR(&BreakoutRTC_enable_periodic_update_interrupt_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_disable_periodic_update_interrupt), MP_ROM_PTR(&BreakoutRTC_disable_periodic_update_interrupt_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_read_periodic_update_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_read_periodic_update_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_clear_periodic_update_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_clear_periodic_update_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_enable_trickle_charge), MP_ROM_PTR(&BreakoutRTC_enable_trickle_charge_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_disable_trickle_charge), MP_ROM_PTR(&BreakoutRTC_disable_trickle_charge_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_set_backup_switchover_mode), MP_ROM_PTR(&BreakoutRTC_set_backup_switchover_mode_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_enable_clock_out), MP_ROM_PTR(&BreakoutRTC_enable_clock_out_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_enable_interrupt_controlled_clockout), MP_ROM_PTR(&BreakoutRTC_enable_interrupt_controlled_clockout_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_disable_clock_out), MP_ROM_PTR(&BreakoutRTC_disable_clock_out_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_read_clock_output_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_read_clock_output_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_clear_clock_output_interrupt_flag), MP_ROM_PTR(&BreakoutRTC_clear_clock_output_interrupt_flag_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_get_status), MP_ROM_PTR(&BreakoutRTC_status_obj) },
|
||||
{ MP_ROM_QSTR(MP_QSTR_clear_interrupts), MP_ROM_PTR(&BreakoutRTC_clear_interrupts_obj) },
|
||||
};
|
||||
STATIC MP_DEFINE_CONST_DICT(BreakoutRTC_locals_dict, BreakoutRTC_locals_dict_table);
|
||||
|
||||
/***** Class Definition *****/
|
||||
const mp_obj_type_t breakout_rtc_BreakoutRTC_type = {
|
||||
{ &mp_type_type },
|
||||
.name = MP_QSTR_breakout_rtc,
|
||||
.print = BreakoutRTC_print,
|
||||
.make_new = BreakoutRTC_make_new,
|
||||
.locals_dict = (mp_obj_dict_t*)&BreakoutRTC_locals_dict,
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// breakout_rtc Module
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/***** Globals Table *****/
|
||||
STATIC const mp_map_elem_t breakout_rtc_globals_table[] = {
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_breakout_rtc) },
|
||||
{ MP_OBJ_NEW_QSTR(MP_QSTR_BreakoutRTC), (mp_obj_t)&breakout_rtc_BreakoutRTC_type },
|
||||
};
|
||||
STATIC MP_DEFINE_CONST_DICT(mp_module_breakout_rtc_globals, breakout_rtc_globals_table);
|
||||
|
||||
/***** Module Definition *****/
|
||||
const mp_obj_module_t breakout_rtc_user_cmodule = {
|
||||
.base = { &mp_type_module },
|
||||
.globals = (mp_obj_dict_t*)&mp_module_breakout_rtc_globals,
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
MP_REGISTER_MODULE(MP_QSTR_breakout_rtc, breakout_rtc_user_cmodule, MODULE_BREAKOUT_RTC_ENABLED);
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -0,0 +1,760 @@
|
|||
#include "../../../libraries/breakout_rtc/breakout_rtc.hpp"
|
||||
|
||||
#define MP_OBJ_TO_PTR2(o, t) ((t *)(uintptr_t)(o))
|
||||
|
||||
// SDA/SCL on even/odd pins, I2C0/I2C1 on even/odd pairs of pins.
|
||||
#define IS_VALID_SCL(i2c, pin) (((pin) & 1) == 1 && (((pin) & 2) >> 1) == (i2c))
|
||||
#define IS_VALID_SDA(i2c, pin) (((pin) & 1) == 0 && (((pin) & 2) >> 1) == (i2c))
|
||||
|
||||
|
||||
using namespace pimoroni;
|
||||
|
||||
|
||||
extern "C" {
|
||||
#include "breakout_rtc.h"
|
||||
|
||||
/***** Variables Struct *****/
|
||||
typedef struct _breakout_rtc_BreakoutRTC_obj_t {
|
||||
mp_obj_base_t base;
|
||||
BreakoutRTC *breakout;
|
||||
} breakout_rtc_BreakoutRTC_obj_t;
|
||||
|
||||
/***** Print *****/
|
||||
void BreakoutRTC_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
||||
(void)kind; //Unused input parameter
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
BreakoutRTC* breakout = self->breakout;
|
||||
mp_print_str(print, "BreakoutRTC(");
|
||||
|
||||
mp_print_str(print, "i2c = ");
|
||||
mp_obj_print_helper(print, mp_obj_new_int((breakout->get_i2c() == i2c0) ? 0 : 1), PRINT_REPR);
|
||||
|
||||
mp_print_str(print, ", sda = ");
|
||||
mp_obj_print_helper(print, mp_obj_new_int(breakout->get_sda()), PRINT_REPR);
|
||||
|
||||
mp_print_str(print, ", scl = ");
|
||||
mp_obj_print_helper(print, mp_obj_new_int(breakout->get_scl()), PRINT_REPR);
|
||||
|
||||
mp_print_str(print, ", int = ");
|
||||
mp_obj_print_helper(print, mp_obj_new_int(breakout->get_int()), PRINT_REPR);
|
||||
|
||||
mp_print_str(print, ")");
|
||||
}
|
||||
|
||||
/***** Constructor *****/
|
||||
mp_obj_t BreakoutRTC_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = nullptr;
|
||||
|
||||
if(n_args == 0) {
|
||||
mp_arg_check_num(n_args, n_kw, 0, 0, true);
|
||||
self = m_new_obj(breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->base.type = &breakout_rtc_BreakoutRTC_type;
|
||||
self->breakout = new BreakoutRTC();
|
||||
}
|
||||
else {
|
||||
enum { ARG_i2c, ARG_sda, ARG_scl, ARG_interrupt };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_i2c, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_sda, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_scl, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_interrupt, MP_ARG_INT, {.u_int = BreakoutRTC::PIN_UNUSED} },
|
||||
};
|
||||
|
||||
// Parse args.
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
// Get I2C bus.
|
||||
int i2c_id = args[ARG_i2c].u_int;
|
||||
if(i2c_id < 0 || i2c_id > 1) {
|
||||
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), i2c_id);
|
||||
}
|
||||
|
||||
int sda = args[ARG_sda].u_int;
|
||||
if (!IS_VALID_SDA(i2c_id, sda)) {
|
||||
mp_raise_ValueError(MP_ERROR_TEXT("bad SDA pin"));
|
||||
}
|
||||
|
||||
int scl = args[ARG_scl].u_int;
|
||||
if (!IS_VALID_SCL(i2c_id, scl)) {
|
||||
mp_raise_ValueError(MP_ERROR_TEXT("bad SCL pin"));
|
||||
}
|
||||
|
||||
self = m_new_obj(breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->base.type = &breakout_rtc_BreakoutRTC_type;
|
||||
|
||||
i2c_inst_t *i2c = (i2c_id == 0) ? i2c0 : i2c1;
|
||||
self->breakout = new BreakoutRTC(i2c, sda, scl, args[ARG_interrupt].u_int);
|
||||
}
|
||||
|
||||
self->breakout->init();
|
||||
|
||||
return MP_OBJ_FROM_PTR(self);
|
||||
}
|
||||
|
||||
// mp_obj_t picoscroll_init() {
|
||||
// scroll.init();
|
||||
// return mp_const_none;
|
||||
// }
|
||||
|
||||
// mp_obj_t picoscroll_get_width() {
|
||||
// return mp_obj_new_int(PicoScroll::WIDTH);
|
||||
// }
|
||||
|
||||
// mp_obj_t picoscroll_get_height() {
|
||||
// return mp_obj_new_int(PicoScroll::HEIGHT);
|
||||
// }
|
||||
|
||||
// mp_obj_t picoscroll_update() {
|
||||
// scroll.update();
|
||||
// return mp_const_none;
|
||||
// }
|
||||
|
||||
// mp_obj_t picoscroll_set_pixel(mp_obj_t x_obj, mp_obj_t y_obj, mp_obj_t v_obj) {
|
||||
// int x = mp_obj_get_int(x_obj);
|
||||
// int y = mp_obj_get_int(y_obj);
|
||||
// int val = mp_obj_get_int(v_obj);
|
||||
|
||||
// if(x < 0 || x >= PicoScroll::WIDTH || y < 0 || y >= PicoScroll::HEIGHT)
|
||||
// mp_raise_ValueError("x or y out of range.");
|
||||
// else
|
||||
// {
|
||||
// if(val < 0 || val > 255)
|
||||
// mp_raise_ValueError("val out of range. Expected 0 to 255");
|
||||
// else
|
||||
// scroll.set_pixel(x, y, val);
|
||||
// }
|
||||
|
||||
// return mp_const_none;
|
||||
// }
|
||||
|
||||
// mp_obj_t picoscroll_clear() {
|
||||
// scroll.clear();
|
||||
// return mp_const_none;
|
||||
// }
|
||||
|
||||
// mp_obj_t picoscroll_is_pressed(mp_obj_t button_obj) {
|
||||
// int buttonID = mp_obj_get_int(button_obj);
|
||||
|
||||
// bool buttonPressed = false;
|
||||
// switch(buttonID)
|
||||
// {
|
||||
// case 0:
|
||||
// buttonPressed = scroll.is_pressed(PicoScroll::A);
|
||||
// break;
|
||||
|
||||
// case 1:
|
||||
// buttonPressed = scroll.is_pressed(PicoScroll::B);
|
||||
// break;
|
||||
|
||||
// case 2:
|
||||
// buttonPressed = scroll.is_pressed(PicoScroll::X);
|
||||
// break;
|
||||
|
||||
// case 3:
|
||||
// buttonPressed = scroll.is_pressed(PicoScroll::Y);
|
||||
// break;
|
||||
|
||||
// default:
|
||||
// mp_raise_ValueError("button not valid. Expected 0 to 3");
|
||||
// break;
|
||||
// }
|
||||
|
||||
// return buttonPressed ? mp_const_true : mp_const_false;
|
||||
// }
|
||||
|
||||
mp_obj_t BreakoutRTC_reset(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->reset();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_setup(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->setup();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_time(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_sec, ARG_min, ARG_hour, ARG_weekday, ARG_date, ARG_month, ARG_year };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_sec, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_min, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_hour, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_weekday, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_date, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_month, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_year, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int sec = args[ARG_sec].u_int;
|
||||
int min = args[ARG_min].u_int;
|
||||
int hour = args[ARG_hour].u_int;
|
||||
int weekday = args[ARG_weekday].u_int;
|
||||
int date = args[ARG_date].u_int;
|
||||
int month = args[ARG_month].u_int;
|
||||
int year = args[ARG_year].u_int;
|
||||
|
||||
if(sec < 0 || sec > 59)
|
||||
mp_raise_ValueError("sec out of range. Expected 0 to 59");
|
||||
else if(min < 0 || min > 59)
|
||||
mp_raise_ValueError("min out of range. Expected 0 to 59");
|
||||
else if(hour < 0 || hour > 23)
|
||||
mp_raise_ValueError("hour out of range. Expected 0 to 23");
|
||||
else if(weekday < 0 || weekday > 6)
|
||||
mp_raise_ValueError("weekday out of range. Expected 0 to 6");
|
||||
else if(date < 1 || date > 31)
|
||||
mp_raise_ValueError("date out of range. Expected 1 to 31");
|
||||
else if(month < 1 || month > 12)
|
||||
mp_raise_ValueError("month out of range. Expected 1 to 12");
|
||||
else if(year < 0 || year > 99)
|
||||
mp_raise_ValueError("year out of range. Expected 0 to 99");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_time(sec, min, hour, weekday, date, month, year));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_seconds(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_sec};
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_sec, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int sec = args[ARG_sec].u_int;
|
||||
|
||||
if(sec < 0 || sec > 59)
|
||||
mp_raise_ValueError("sec out of range. Expected 0 to 59");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_seconds(sec));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_minutes(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_min };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_min, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int min = args[ARG_min].u_int;
|
||||
|
||||
if(min < 0 || min > 59)
|
||||
mp_raise_ValueError("min out of range. Expected 0 to 59");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_minutes(min));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_hours(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_hour };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_hour, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int hour = args[ARG_hour].u_int;
|
||||
|
||||
if(hour < 0 || hour > 23)
|
||||
mp_raise_ValueError("hour out of range. Expected 0 to 23");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_hours(hour));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_weekday(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_weekday };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_weekday, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int weekday = args[ARG_weekday].u_int;
|
||||
|
||||
if(weekday < 0 || weekday > 6)
|
||||
mp_raise_ValueError("weekday out of range. Expected 0 to 6");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_weekday(weekday));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_date(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_date };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_date, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int date = args[ARG_date].u_int;
|
||||
|
||||
if(date < 1 || date > 31)
|
||||
mp_raise_ValueError("date out of range. Expected 1 to 31");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_date(date));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_month(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_month };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_month, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int month = args[ARG_month].u_int;
|
||||
|
||||
if(month < 1 || month > 12)
|
||||
mp_raise_ValueError("month out of range. Expected 1 to 12");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_month(month));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_year(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_year };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_year, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int year = args[ARG_year].u_int;
|
||||
|
||||
if(year < 0 || year > 99)
|
||||
mp_raise_ValueError("year out of range. Expected 0 to 99");
|
||||
else
|
||||
return mp_obj_new_bool(self->breakout->set_year(year));
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_to_compiler_time(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_bool(self->breakout->set_to_compiler_time());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_update_time(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_bool(self->breakout->update_time());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_string_date_usa(mp_obj_t self_in) {
|
||||
//TODO
|
||||
//breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_string_date(mp_obj_t self_in) {
|
||||
//TODO
|
||||
//breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_string_time(mp_obj_t self_in) {
|
||||
//TODO
|
||||
//breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_string_time_stamp(mp_obj_t self_in) {
|
||||
//TODO
|
||||
//breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_seconds(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_seconds());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_minutes(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_minutes());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_hours(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_hours());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_weekday(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_weekday());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_date(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_date());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_month(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_month());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_year(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_year());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_is_12_hour(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_bool(self->breakout->is_12_hour());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_is_pm(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_bool(self->breakout->is_pm());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_12_hour(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->set_12_hour();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_24_hour(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->set_24_hour();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_unix(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_value };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_value, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int value = args[ARG_value].u_int;
|
||||
|
||||
return mp_obj_new_bool(self->breakout->set_unix((uint32_t)value));
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_unix(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_unix());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_enable_alarm_interrupt(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
if(n_args == 1) {
|
||||
enum { ARG_self };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
self->breakout->enable_alarm_interrupt();
|
||||
}
|
||||
else {
|
||||
enum { ARG_self, ARG_min, ARG_hour, ARG_date_or_weekday, ARG_set_weekday_alarm_not_date, ARG_mode, ARG_enable_clock_output };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_min, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_hour, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_date_or_weekday, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_set_weekday_alarm_not_date, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
{ MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT },
|
||||
{ MP_QSTR_enable_clock_output, MP_ARG_BOOL, {.u_bool = false} },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(args[ARG_self].u_obj, breakout_rtc_BreakoutRTC_obj_t);
|
||||
|
||||
int min = args[ARG_min].u_int;
|
||||
int hour = args[ARG_hour].u_int;
|
||||
int date_or_weekday = args[ARG_date_or_weekday].u_int;
|
||||
bool set_weekday_alarm_not_date = args[ARG_set_weekday_alarm_not_date].u_bool;
|
||||
int mode = args[ARG_mode].u_int;
|
||||
bool enable_clock_output = args[ARG_enable_clock_output].u_bool;
|
||||
|
||||
if(min < 0 || min > 59)
|
||||
mp_raise_ValueError("min out of range. Expected 0 to 59");
|
||||
else if(hour < 0 || hour > 23)
|
||||
mp_raise_ValueError("hour out of range. Expected 0 to 23");
|
||||
else {
|
||||
if(set_weekday_alarm_not_date) {
|
||||
if(date_or_weekday < 0 || date_or_weekday > 6)
|
||||
mp_raise_ValueError("date_or_weekday out of range. Expected 0 to 6");
|
||||
}
|
||||
else {
|
||||
if(date_or_weekday < 1 || date_or_weekday > 31)
|
||||
mp_raise_ValueError("date_or_weekday out of range. Expected 1 to 31");
|
||||
}
|
||||
self->breakout->enable_alarm_interrupt(min, hour, date_or_weekday, set_weekday_alarm_not_date, mode, enable_clock_output);
|
||||
}
|
||||
}
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_disable_alarm_interrupt(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->disable_alarm_interrupt();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_read_alarm_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_bool(self->breakout->read_alarm_interrupt_flag());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_clear_alarm_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->clear_alarm_interrupt_flag();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_timer(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
//TODO
|
||||
enum { ARG_self, ARG_light, ARG_proximity };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_light, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
{ MP_QSTR_proximity, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_get_timer_count(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->get_timer_count());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_enable_timer(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->enable_timer();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_disable_timer(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->disable_timer();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_enable_timer_interupt(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->enable_timer_interrupt();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_disable_timer_interrupt(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->disable_timer_interrupt();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_read_timer_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_bool(self->breakout->read_timer_interrupt_flag());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_clear_timer_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->clear_timer_interrupt_flag();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_enable_periodic_update_interrupt(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
//TODO
|
||||
enum { ARG_self, ARG_light, ARG_proximity };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_light, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
{ MP_QSTR_proximity, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_disable_periodic_update_interrupt(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->disable_periodic_update_interrupt();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_read_periodic_update_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_bool(self->breakout->read_periodic_update_interrupt_flag());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_clear_periodic_update_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->clear_periodic_update_interrupt_flag();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_enable_trickle_charge(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
//TODO
|
||||
enum { ARG_self, ARG_light, ARG_proximity };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_light, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
{ MP_QSTR_proximity, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_disable_trickle_charge(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->disable_trickle_charge();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_set_backup_switchover_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_light, ARG_proximity };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_light, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
{ MP_QSTR_proximity, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_enable_clock_out(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_light, ARG_proximity };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_light, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
{ MP_QSTR_proximity, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_enable_interrupt_controlled_clockout(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
||||
enum { ARG_self, ARG_light, ARG_proximity };
|
||||
static const mp_arg_t allowed_args[] = {
|
||||
{ MP_QSTR_, MP_ARG_REQUIRED | MP_ARG_OBJ },
|
||||
{ MP_QSTR_light, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
{ MP_QSTR_proximity, MP_ARG_REQUIRED | MP_ARG_BOOL },
|
||||
};
|
||||
|
||||
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
||||
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_disable_clock_out(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->disable_clock_out();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_read_clock_output_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->read_clock_output_interrupt_flag());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_clear_clock_output_interrupt_flag(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->clear_clock_output_interrupt_flag();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_status(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
return mp_obj_new_int(self->breakout->status());
|
||||
}
|
||||
|
||||
mp_obj_t BreakoutRTC_clear_interrupts(mp_obj_t self_in) {
|
||||
breakout_rtc_BreakoutRTC_obj_t *self = MP_OBJ_TO_PTR2(self_in, breakout_rtc_BreakoutRTC_obj_t);
|
||||
self->breakout->clear_interrupts();
|
||||
|
||||
return mp_const_none;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
// Include MicroPython API.
|
||||
#include "py/runtime.h"
|
||||
#include "py/objstr.h"
|
||||
|
||||
/***** Extern of Class Definition *****/
|
||||
extern const mp_obj_type_t breakout_rtc_BreakoutRTC_type;
|
||||
|
||||
/***** Extern of Class Methods *****/
|
||||
extern void BreakoutRTC_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind);
|
||||
extern mp_obj_t BreakoutRTC_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_reset(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_setup(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_set_time(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_seconds(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_minutes(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_hours(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_weekday(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_date(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_month(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_year(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_set_to_compiler_time(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_update_time(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_string_date_usa(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_string_date(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_string_time(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_string_time_stamp(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_get_seconds(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_get_minutes(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_get_hours(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_get_weekday(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_get_date(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_get_month(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_get_year(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_is_12_hour(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_is_pm(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_set_12_hour(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_set_24_hour(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_set_unix(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_get_unix(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_enable_alarm_interrupt(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_disable_alarm_interrupt(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_read_alarm_interrupt_flag(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_clear_alarm_interrupt_flag(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_set_timer(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_get_timer_count(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_enable_timer(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_disable_timer(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_enable_timer_interupt(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_disable_timer_interrupt(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_read_timer_interrupt_flag(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_clear_timer_interrupt_flag(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_enable_periodic_update_interrupt(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_disable_periodic_update_interrupt(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_read_periodic_update_interrupt_flag(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_clear_periodic_update_interrupt_flag(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_enable_trickle_charge(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_disable_trickle_charge(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_set_backup_switchover_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_enable_clock_out(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_enable_interrupt_controlled_clockout(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
|
||||
extern mp_obj_t BreakoutRTC_disable_clock_out(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_read_clock_output_interrupt_flag(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_clear_clock_output_interrupt_flag(mp_obj_t self_in);
|
||||
|
||||
extern mp_obj_t BreakoutRTC_status(mp_obj_t self_in);
|
||||
extern mp_obj_t BreakoutRTC_clear_interrupts(mp_obj_t self_in);
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
set(MOD_NAME breakout_rtc)
|
||||
string(TOUPPER ${MOD_NAME} MOD_NAME_UPPER)
|
||||
add_library(usermod_${MOD_NAME} INTERFACE)
|
||||
|
||||
target_sources(usermod_${MOD_NAME} INTERFACE
|
||||
${CMAKE_CURRENT_LIST_DIR}/${MOD_NAME}.c
|
||||
${CMAKE_CURRENT_LIST_DIR}/${MOD_NAME}.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/../../../libraries/${MOD_NAME}/${MOD_NAME}.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/../../../drivers/rv3028/rv3028.cpp
|
||||
)
|
||||
|
||||
target_include_directories(usermod_${MOD_NAME} INTERFACE
|
||||
${CMAKE_CURRENT_LIST_DIR}
|
||||
)
|
||||
|
||||
target_compile_definitions(usermod_${MOD_NAME} INTERFACE
|
||||
-DMODULE_${MOD_NAME_UPPER}_ENABLED=1
|
||||
)
|
||||
|
||||
target_link_libraries(usermod INTERFACE usermod_${MOD_NAME})
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
set(MOD_NAME breakout_rtc)
|
||||
BREAKOUT_MOD_DIR := $(USERMOD_DIR)
|
||||
|
||||
# Add our source files to the respective variables.
|
||||
SRC_USERMOD += $(BREAKOUT_MOD_DIR)/${MOD_NAME}.c
|
||||
SRC_USERMOD_CXX += $(BREAKOUT_MOD_DIR)/${MOD_NAME}.cpp
|
||||
|
||||
# Add our module directory to the include path.
|
||||
CFLAGS_USERMOD += -I$(BREAKOUT_MOD_DIR)
|
||||
CXXFLAGS_USERMOD += -I$(BREAKOUT_MOD_DIR)
|
||||
|
||||
# We use C++ features so have to link against the standard library.
|
||||
LDFLAGS_USERMOD += -lstdc++
|
||||
|
|
@ -12,6 +12,7 @@ include(${CMAKE_CURRENT_LIST_DIR}/breakout_matrix11x7/micropython.cmake)
|
|||
include(${CMAKE_CURRENT_LIST_DIR}/breakout_msa301/micropython.cmake)
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/breakout_mics6814/micropython.cmake)
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/breakout_potentiometer/micropython.cmake)
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/breakout_rtc/micropython.cmake)
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/breakout_trackball/micropython.cmake)
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/breakout_sgp30/micropython.cmake)
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/breakout_colourlcd240x240/micropython.cmake)
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue