static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state) { static char err_readtime[] __initdata = KERN_ERR "PM: can't read %s time, err %d\n"; static char err_wakealarm [] __initdata = KERN_ERR "PM: can't set %s wakealarm, err %d\n"; static char err_suspend[] __initdata = KERN_ERR "PM: suspend test failed, error %d\n"; static char info_test[] __initdata = KERN_INFO "PM: test RTC wakeup from '%s' suspend\n"; unsigned long now; struct rtc_wkalrm alm; int status; /* this may fail if the RTC hasn't been initialized */ status = rtc_read_time(rtc, &alm.time); if (status < 0) { printk(err_readtime, dev_name(&rtc->dev), status); return; } rtc_tm_to_time(&alm.time, &now); memset(&alm, 0, sizeof alm); rtc_time_to_tm(now + TEST_SUSPEND_SECONDS, &alm.time); alm.enabled = true; status = rtc_set_alarm(rtc, &alm); if (status < 0) { printk(err_wakealarm, dev_name(&rtc->dev), status); return; } if (state == PM_SUSPEND_MEM) { printk(info_test, pm_states[state]); status = pm_suspend(state); if (status == -ENODEV) state = PM_SUSPEND_STANDBY; } if (state == PM_SUSPEND_STANDBY) { printk(info_test, pm_states[state]); status = pm_suspend(state); } if (status < 0) printk(err_suspend, status); /* Some platforms can't detect that the alarm triggered the * wakeup, or (accordingly) disable it after it afterwards. * It's supposed to give oneshot behavior; cope. */ alm.enabled = false; rtc_set_alarm(rtc, &alm); }
static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state) { static char err_readtime[] __initdata = KERN_ERR "PM: can't read %s time, err %d\n"; static char err_wakealarm [] __initdata = KERN_ERR "PM: can't set %s wakealarm, err %d\n"; static char err_suspend[] __initdata = KERN_ERR "PM: suspend test failed, error %d\n"; static char info_test[] __initdata = KERN_INFO "PM: test RTC wakeup from '%s' suspend\n"; unsigned long now; struct rtc_wkalrm alm; int status; status = rtc_read_time(rtc, &alm.time); if (status < 0) { printk(err_readtime, dev_name(&rtc->dev), status); return; } rtc_tm_to_time(&alm.time, &now); memset(&alm, 0, sizeof alm); rtc_time_to_tm(now + TEST_SUSPEND_SECONDS, &alm.time); alm.enabled = true; status = rtc_set_alarm(rtc, &alm); if (status < 0) { printk(err_wakealarm, dev_name(&rtc->dev), status); return; } if (state == PM_SUSPEND_MEM) { printk(info_test, pm_states[state]); status = pm_suspend(state); if (status == -ENODEV) state = PM_SUSPEND_STANDBY; } if (state == PM_SUSPEND_STANDBY) { printk(info_test, pm_states[state]); status = pm_suspend(state); } if (status < 0) printk(err_suspend, status); alm.enabled = false; rtc_set_alarm(rtc, &alm); }
static int bq2419x_wakealarm(struct bq2419x_chip *bq2419x, int time_sec) { int ret; unsigned long now; struct rtc_wkalrm alm; int alarm_time = time_sec; if (!alarm_time) return 0; alm.enabled = true; ret = rtc_read_time(bq2419x->rtc, &alm.time); if (ret < 0) { dev_err(bq2419x->dev, "RTC read time failed %d\n", ret); return ret; } rtc_tm_to_time(&alm.time, &now); rtc_time_to_tm(now + alarm_time, &alm.time); ret = rtc_set_alarm(bq2419x->rtc, &alm); if (ret < 0) { dev_err(bq2419x->dev, "RTC set alarm failed %d\n", ret); alm.enabled = false; return ret; } alm.enabled = false; return 0; }
/** * \brief Initialize timeout * * Initializes timeout counter for desired tick rate and starts it. The device * interrupt controller should be initialized prior to calling this function, * and global interrupts must be enabled. * * \note If the service is configured to use the asynchronous RTC32 module, * there are restrictions on the timeout period that can be used - see * to \ref rtc32_min_alarm_time for details. */ void timeout_init(void) { rtc_init(); rtc_set_callback(tick_handler); rtc_set_time(0); rtc_set_alarm(TIMEOUT_COMP); }
void alarm_set_power_on(struct timespec new_pwron_time, bool logo) { unsigned long pwron_time; struct rtc_wkalrm alm; struct rtc_device *alarm_rtc_dev; alarm_dbg(INFO, "alarm set power on\n"); #ifdef RTC_PWRON_SEC /* round down the second */ new_pwron_time.tv_sec = (new_pwron_time.tv_sec / 60) * 60; #endif if (new_pwron_time.tv_sec > 0) { pwron_time = new_pwron_time.tv_sec; #ifdef RTC_PWRON_SEC pwron_time += RTC_PWRON_SEC; #endif alm.enabled = (logo ? 3 : 2); } else { pwron_time = 0; alm.enabled = 4; } alarm_rtc_dev = alarmtimer_get_rtcdev(); rtc_time_to_tm(pwron_time, &alm.time); rtc_set_alarm(alarm_rtc_dev, &alm); rtc_set_alarm_poweron(alarm_rtc_dev, &alm); }
void set_power_on_alarm(long secs, bool enable) { int rc; struct timespec wall_time; long rtc_secs, alarm_time, alarm_delta; struct rtc_time rtc_time; struct rtc_wkalrm alarm; rc = mutex_lock_interruptible(&power_on_alarm_lock); if (rc != 0) return; if (enable) { power_on_alarm = secs; } else { if (power_on_alarm == secs) power_on_alarm = 0; else goto exit; } if (!power_on_alarm) goto disable_alarm; rtc_read_time(rtcdev, &rtc_time); getnstimeofday(&wall_time); rtc_tm_to_time(&rtc_time, &rtc_secs); alarm_delta = wall_time.tv_sec - rtc_secs; alarm_time = power_on_alarm - alarm_delta; /* *Substract ALARM_DELTA from actual alarm time *to power up the device before actual alarm *expiration */ #ifdef CONFIG_ZTEMT_PON_ALARM_DELTA if ((alarm_time - ALARM_DELTA) > rtc_secs) alarm_time -= ALARM_DELTA; else goto disable_alarm; #else if (alarm_time <= rtc_secs) goto disable_alarm; #endif rtc_time_to_tm(alarm_time, &alarm.time); alarm.enabled = 1; rc = rtc_set_alarm(rtcdev, &alarm); if (rc) goto disable_alarm; mutex_unlock(&power_on_alarm_lock); return; disable_alarm: power_on_alarm = 0; rtc_alarm_irq_enable(rtcdev, 0); exit: mutex_unlock(&power_on_alarm_lock); }
PROCESS_THREAD(rtctest_process, ev, data) { static struct etimer et; PROCESS_BEGIN(); printf("RTC init\r\n"); rtc_init(); //Alarm counter rtc_set_alarm(200); while(1) { etimer_set(&et, CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); if (rtc_read() > 100 && rtc_read() < 150) { leds_off(LEDS_ALL); pm_stop_mode(0); } if (rtc_read() > 200) { leds_toggle(LEDS_ALL); } rtc_sync(); printf("1s tick.. %d rtc alarm flag %d\r\n", rtc_read(), (RTC->CRL & RTC_CRL_ALRF)); } PROCESS_END(); }
/* * Test command to set RTC Alarm time, and start RTC: rtc alarm <rtc_alarm_time> * * @param[in] argc Number of arguments in the Test Command (including group and name) * @param[in] argv Table of null-terminated buffers containing the arguments * @param[in] ctx The context to pass back to responses */ void rtc_alarm_tcmd(int argc, char *argv[], struct tcmd_handler_ctx *ctx) { struct rtc_config config = { 0 }; struct device *rtc_dev; uint32_t keys = 0; if (argc == RTC_ARG_NO && isdigit(argv[RTC_TIME_IDX][0])) { keys = irq_lock(); tcmd_user_alarm_rtc_val = (uint32_t)strtoul(argv[RTC_TIME_IDX], NULL, 10); test_rtc = 0; config.alarm_val = tcmd_user_alarm_rtc_val; config.alarm_enable = true; config.cb_fn = test_rtc_interrupt_fn; alarm_pending = true; irq_unlock(keys); rtc_dev = device_get_binding(RTC_DRV_NAME); assert(rtc_dev != NULL); rtc_dev->driver_data = (void *)ctx; rtc_enable(rtc_dev); rtc_set_config(rtc_dev, &config); rtc_set_alarm(rtc_dev, config.alarm_val); } else { TCMD_RSP_ERROR(ctx, "Usage: rtc alarm <alarm_time>"); } }
void test_rtc_interrupt_fn(struct device *rtc_dev) { u32_t now = rtc_read(rtc_dev); printk("Alarm\n"); rtc_set_alarm(rtc_dev, now + ALARM); }
static int suspend_autotest_suspend(struct device *dev) { unsigned long now; struct rtc_wkalrm alm; int status; int need_test = 0; unsigned long alarm_time; /* if test isn't enabled, no need to proceed below code */ if ((!test_enable) || (test_mode != SUSPEND)) return 0; /* read alarm time */ status = rtc_read_alarm(rtc, &alm); if (status) { pr_info("%s: rtc_read_alarm fail\n", __func__); return status; } rtc_tm_to_time(&alm.time, &alarm_time); /* if alarm is set already, alarm time should be compared. * if no alarm is set, test alarm can be done. */ if (alm.enabled) need_test = 0; else need_test = 1; status = rtc_read_time(rtc, &alm.time); if (status < 0) { pr_info("%s: rtc_read_time fail\n", __func__); return status; } rtc_tm_to_time(&alm.time, &now); /* if alarm will be expired in TEST_SUSPEND_SECONDS, * don't set test alarm time */ if (!need_test && alarm_time < (now + TEST_SUSPEND_SECONDS)) { pr_info("%s: no setting of test alarm\n", __func__); return 0; } memset(&alm, 0, sizeof alm); rtc_time_to_tm(now + TEST_SUSPEND_SECONDS, &alm.time); alm.enabled = true; status = rtc_set_alarm(rtc, &alm); if (status < 0) { pr_info("%s: rtc_set_alarm fail\n",__func__); return status; } test_alarm_set = 1; pr_info("%s: test alarm will be envoked after about %d sec.\n", __func__, TEST_SUSPEND_SECONDS); return 0; }
static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) { struct rtc_time *tm = &alrm->time; void __iomem *base = s3c_rtc_base; unsigned int alrm_en; #ifdef CONFIG_RTC_DRV_S5M struct rtc_device *rtc1; #endif //pr_debug printk("s3c_rtc_setalarm: %d, %04d.%02d.%02d %02d:%02d:%02d\n", alrm->enabled, 1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN; writeb(0x00, base + S3C2410_RTCALM); if (tm->tm_sec < 60 && tm->tm_sec >= 0) { alrm_en |= S3C2410_RTCALM_SECEN; writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC); } if (tm->tm_min < 60 && tm->tm_min >= 0) { alrm_en |= S3C2410_RTCALM_MINEN; writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN); } if (tm->tm_hour < 24 && tm->tm_hour >= 0) { alrm_en |= S3C2410_RTCALM_HOUREN; writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR); } pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en); writeb(alrm_en, base + S3C2410_RTCALM); s3c_rtc_setaie(dev, alrm->enabled); /*Cellon add start, Devin Yuan, 2012/10/11, for off-mode alarm*/ #ifdef S5M8767_OFF_ALARM #ifdef CONFIG_RTC_DRV_S5M rtc1 = rtc_class_open("rtc1"); if(rtc1 == NULL) { printk("!!!!!! %s: unable to open rtc1 device!!!!!\n", __FILE__); } else { rtc_set_alarm(rtc1, alrm); rtc_class_close(rtc1); } #endif #endif /*Cellon add end, Devin Yuan, 2012/10/11, for off-mode alarm*/ return 0; }
int exec_alarm(void) { leds_toggle(LED_RED); alarm.date = rtc_time() + 5; alarm.exec_cb = exec_alarm; rtc_set_alarm(&alarm); return 0; }
static void _prepare_next_alarm(void) { struct tm time; rtc_get_time(&time); /* set initial alarm */ time.tm_sec += PERIOD; mktime(&time); rtc_set_alarm(&time, rtc_cb, NULL); }
/** * Initialize the system controller. In particular: * - Load settings * - Setup the log interval alarm. */ Controller::Controller() { m_sleeping=false; m_powerup=false; //m_log_interval_seconds = 60*30; m_log_interval_seconds = 0; // default set to zero to save power rtc_clear_alarmed(); rtc_enable_alarm(RTC); m_interval_stored = rtc_get_time(RTC); m_counts_stored = 0; m_alarm_log = false; system_controller = this; m_last_switch_state = true; m_never_dim = false; bool sstate = switch_state(); m_last_switch_state = sstate; m_warning_raised = false; m_dim_off = false; m_cpm_cps_switch = false; m_current_units = 2; m_cpm_cps_threshold = 1100.0; m_cps_cpm_threshold = 1000.0; // Get warning cpm from flash m_warncpm = 0; const char *swarncpm = flashstorage_keyval_get("WARNCPM"); if(swarncpm != 0) { int32_t c; sscanf(swarncpm, "%"PRIu32"", &c); m_warncpm = c; } // Get never dim from flash m_warncpm = -1; const char *sneverdim = flashstorage_keyval_get("NEVERDIM"); if(sneverdim != 0) { if(strcmp(sneverdim,"true") == 0) m_never_dim=true; else m_never_dim=false; } else m_never_dim=false; if(m_never_dim) tick_item("Never Dim" ,true); // Get logging interval from flash const char *sloginter = flashstorage_keyval_get("LOGINTERVAL"); if(sloginter != 0) { int32_t c; sscanf(sloginter, "%"PRIu32"", &c); m_log_interval_seconds = c; } else { // m_log_interval_seconds = 30*60; m_log_interval_seconds = 0; // default set to zero to save power } rtc_set_alarm(RTC,rtc_get_time(RTC)+m_log_interval_seconds); }
static void _rtc_setalarm(char **argv) { struct tm now; if (_parse_time(argv, &now) == 0) { if (rtc_set_alarm(&now, _alarm_handler, NULL) == -1) { puts("rtc: error setting alarm"); } } }
static ssize_t rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr, const char *buf, size_t n) { ssize_t retval; unsigned long now, alarm; struct rtc_wkalrm alm; struct rtc_device *rtc = to_rtc_device(dev); char *buf_ptr; int adjust = 0; printk("%s \n", __func__); /* Only request alarms that trigger in the future. Disable them * by writing another time, e.g. 0 meaning Jan 1 1970 UTC. */ retval = rtc_read_time(rtc, &alm.time); sys_out("retval is %d \n", retval); if (retval < 0) return retval; rtc_tm_to_time(&alm.time, &now); buf_ptr = (char *)buf; if (*buf_ptr == '+') { buf_ptr++; adjust = 1; } alarm = simple_strtoul(buf_ptr, NULL, 0); if (adjust) { alarm += now; } if (alarm > now) { /* Avoid accidentally clobbering active alarms; we can't * entirely prevent that here, without even the minimal * locking from the /dev/rtcN api. */ retval = rtc_read_alarm(rtc, &alm); if (retval < 0) return retval; if (alm.enabled) return -EBUSY; alm.enabled = 1; } else { alm.enabled = 0; /* Provide a valid future alarm time. Linux isn't EFI, * this time won't be ignored when disabling the alarm. */ alarm = now + 300; } rtc_time_to_tm(alarm, &alm.time); retval = rtc_set_alarm(rtc, &alm); printk("set_alarm retval: %d\n",retval); return (retval < 0) ? retval : n; }
static void enable_wake_event(void) { u32_t now = rtc_read(rtc_dev); u32_t alarm; alarm = (rtc_read(rtc_dev) + ALARM); rtc_set_alarm(rtc_dev, alarm); /* Wait a few ticks to ensure the alarm value gets loaded */ while (rtc_read(rtc_dev) < now + 5) ; }
void main(void) { struct device *rtc_dev; struct rtc_config config; u32_t now; printk("LMT: Quark SE PM Multicore Demo\n"); k_fifo_init(&fifo); build_suspend_device_list(); ipm = device_get_binding("alarm_notification"); if (!ipm) { printk("Error: Failed to get IPM device\n"); return; } rtc_dev = device_get_binding("RTC_0"); if (!rtc_dev) { printk("Error: Failed to get RTC device\n"); return; } rtc_enable(rtc_dev); /* In QMSI, in order to save the alarm callback we must set * 'alarm_enable = 1' during configuration. However, this * automatically triggers the alarm underneath. So, to avoid * the alarm being fired any time soon, we set the 'init_val' * to 1 and the 'alarm_val' to 0. */ config.init_val = 1; config.alarm_val = 0; config.alarm_enable = 1; config.cb_fn = alarm_handler; rtc_set_config(rtc_dev, &config); while (1) { /* Simulate some task handling by busy waiting. */ printk("LMT: busy\n"); k_busy_wait(TASK_TIME_IN_SEC * 1000 * 1000); now = rtc_read(rtc_dev); rtc_set_alarm(rtc_dev, now + (RTC_ALARM_SECOND * IDLE_TIME_IN_SEC)); printk("LMT: idle\n"); k_fifo_get(&fifo, K_FOREVER); } }
static void set_rtc_alarm(void) { u32_t now = rtc_read(rtc_dev); u32_t alarm = now + (RTC_ALARM_SECOND * (TIMEOUT - 1)); rtc_set_alarm(rtc_dev, alarm); /* Wait a few ticks to ensure the 'Counter Match Register' was loaded * with the 'alarm' value. * Refer to the documentation in qm_rtc.h for more details. */ while (rtc_read(rtc_dev) < now + 5) ; }
static int restore_wakealarm(void) { struct rtc_wkalrm alm; struct rtc_device *rtc = NULL; rtc = rtc_class_open(CONFIG_WAKEALARM_RTC); if (!rtc) { return -1; } alm.enabled = false; rtc_set_alarm(rtc, &alm); rtc_class_close(rtc); return 0; }
/** * Append a new entry to the log if necessary. Checks the * state of m_alarm_log to determine if we should append a log * entry. */ void Controller::do_logging() { if(rtc_alarmed()) { m_alarm_log = true; m_last_alarm_time = rtc_get_time(RTC); #ifndef DISABLE_ACCEL accel_read_state(&m_accel_x_stored,&m_accel_y_stored,&m_accel_z_stored); #endif //m_magsensor_stored = gpio_read_bit(PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit); // set new alarm for log_interval_seconds from now. rtc_clear_alarmed(); } if(m_alarm_log == true) { if(system_geiger->is_cpm30_valid()) { log_data_t data; #ifndef DISABLE_ACCEL accel_read_state(&data.accel_x_end,&data.accel_y_end,&data.accel_z_end); #endif //data.magsensor_end = gpio_read_bit(PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit); data.time = rtc_get_time(RTC); data.cpm = system_geiger->get_cpm30(); data.accel_x_start = m_accel_x_stored; data.accel_y_start = m_accel_y_stored; data.accel_z_start = m_accel_z_stored; //data.magsensor_start = m_magsensor_stored; data.log_type = UINT_MAX; flashstorage_log_pushback((uint8_t *) &data,sizeof(log_data_t)); bool full = flashstorage_log_isfull(); if((full == true) && (!m_sleeping)) { m_gui->show_dialog("Flash Log","is full",0,0,0,43,44,255,255); } m_alarm_log = false; rtc_set_alarm(RTC,m_last_alarm_time+m_log_interval_seconds); rtc_enable_alarm(RTC); if(m_sleeping) { power_standby(); } } } }
int alarm_set_rtc_ring(struct timespec alarm_time) { struct rtc_wkalrm rtc_alarm; unsigned long rtc_alarm_time; if (pwr_rtc_dev != NULL) { rtc_alarm_time = alarm_time.tv_sec; pr_alarm(INT, "%s, alarm time: %lu\n", __func__, rtc_alarm_time); rtc_time_to_tm(rtc_alarm_time, &rtc_alarm.time); rtc_alarm.enabled = 1; rtc_set_alarm(pwr_rtc_dev, &rtc_alarm); } return 0; }
static int set_wakealarm(void) { int retval = 0; unsigned long now, alarm; struct rtc_wkalrm alm; struct rtc_device *rtc; rtc = rtc_class_open(CONFIG_WAKEALARM_RTC); if (!rtc) { return -1; } /* Only request alarms that trigger in the future. Disable them * by writing another time, e.g. 0 meaning Jan 1 1970 UTC. */ retval = rtc_read_time(rtc, &alm.time); if (retval < 0) goto close_rtc; rtc_tm_to_time(&alm.time, &now); alarm = now + sleep_time; if (alarm > now) { /* Avoid accidentally clobbering active alarms; we can't * entirely prevent that here, without even the minimal * locking from the /dev/rtcN api. */ retval = rtc_read_alarm(rtc, &alm); if (retval < 0) goto close_rtc; alm.enabled = 1; } else { alm.enabled = 0; /* Provide a valid future alarm time. Linux isn't EFI, * this time won't be ignored when disabling the alarm. */ alarm = now + 300; } rtc_time_to_tm(alarm, &alm.time); retval = rtc_set_alarm(rtc, &alm); close_rtc: rtc_class_close(rtc); return retval; }
static ssize_t rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr, const char *buf, size_t n) { ssize_t retval; unsigned long now, alarm; struct rtc_wkalrm alm; struct rtc_device *rtc = to_rtc_device(dev); char *buf_ptr; int adjust = 0; retval = rtc_read_time(rtc, &alm.time); if (retval < 0) return retval; rtc_tm_to_time(&alm.time, &now); buf_ptr = (char *)buf; if (*buf_ptr == '+') { buf_ptr++; adjust = 1; } alarm = simple_strtoul(buf_ptr, NULL, 0); if (adjust) { alarm += now; } if (alarm > now) { retval = rtc_read_alarm(rtc, &alm); if (retval < 0) return retval; if (alm.enabled) return -EBUSY; alm.enabled = 1; } else { alm.enabled = 0; alarm = now + 300; } rtc_time_to_tm(alarm, &alm.time); retval = rtc_set_alarm(rtc, &alm); return (retval < 0) ? retval : n; }
static ssize_t rtc_sysfs_set_wakealarm(struct class_device *dev, const char *buf, size_t n) { ssize_t retval; unsigned long now, alarm; struct rtc_wkalrm alm; /* Only request alarms that trigger in the future. Disable them * by writing another time, e.g. 0 meaning Jan 1 1970 UTC. */ retval = rtc_read_time(dev, &alm.time); if (retval < 0) return retval; rtc_tm_to_time(&alm.time, &now); alarm = simple_strtoul(buf, NULL, 0); if (alarm > now) { /* Avoid accidentally clobbering active alarms; we can't * entirely prevent that here, without even the minimal * locking from the /dev/rtcN api. */ retval = rtc_read_alarm(dev, &alm); if (retval < 0) return retval; if (alm.enabled) return -EBUSY; alm.enabled = 1; } else { alm.enabled = 0; /* Provide a valid future alarm time. Linux isn't EFI, * this time won't be ignored when disabling the alarm. */ alarm = now + 300; } rtc_time_to_tm(alarm, &alm.time); retval = rtc_set_alarm(dev, &alm); return (retval < 0) ? retval : n; }
void Controller::save_loginterval() { int l1 = m_gui->get_item_state_uint8("LOGINTER1"); int l2 = m_gui->get_item_state_uint8("LOGINTER2"); int l3 = m_gui->get_item_state_uint8("LOGINTER3"); int32_t log_interval_mins = (l1*100) + (l2*10) + l3; m_log_interval_seconds = log_interval_mins*60; char sloginterval[50]; sprintf(sloginterval,"%"PRIu32"",m_log_interval_seconds); flashstorage_keyval_set("LOGINTERVAL",sloginterval); uint32_t current_time = realtime_get_unixtime(); if(m_log_interval_seconds > 0){ rtc_set_alarm(RTC,current_time+m_log_interval_seconds); }else{ rtc_disable_alarm(RTC); } m_gui->jump_to_screen(0); }
/** * \brief Callback function for RTC compare interrupt handler * * The function executes when the RTC compare interrupt occurs and loop * through all timeout channels. The timeout_array[channel_index] which * contains the remaining ticks before timeout is decremented and the timeout * active/expired masks are updated. */ static void tick_handler(uint32_t time) { uint8_t i; /* Loop through all timeout channels */ for (i = 0; i < TIMEOUT_COUNT; i++) { /* Skip processing on current channel if not active */ if (!(timeout_active & (1 << i))) { continue; } /* Decrement current channel with one tick */ timeout_array[i].count--; /* Skip further processing on current channel if not expired */ if (timeout_array[i].count) { continue; } else { /* Update expired bit mask with current channel */ timeout_expired |= 1 << i; /* If Periodic timer, reset timeout counter to period * time */ if (timeout_array[i].period) { timeout_array[i].count = timeout_array[i].period; } /* If not periodic timeout, set current channel to * in-active */ else { timeout_active &= ~(1 << i); } } } /* Reset RTC before next tick */ rtc_set_time(0); rtc_set_alarm(TIMEOUT_COMP); }
void Controller::save_date() { int d1 = m_gui->get_item_state_uint8("DATEDAY1"); int d2 = m_gui->get_item_state_uint8("DATEDAY2"); int m1 = m_gui->get_item_state_uint8("DATEMON1"); int m2 = m_gui->get_item_state_uint8("DATEMON2"); int y1 = m_gui->get_item_state_uint8("DATEYEAR1"); int y2 = m_gui->get_item_state_uint8("DATEYEAR2"); int new_day = d2 + (d1*10); int new_mon = m2 + (m1*10); int new_year = y2 + (y1*10); uint8_t hours,min,sec,day,month; uint16_t year; realtime_getdate(hours,min,sec,day,month,year); day = new_day; month = new_mon-1; year = (2000+new_year)-1900; realtime_setdate(hours,min,sec,day,month,year); rtc_set_alarm(RTC,rtc_get_time(RTC)+m_log_interval_seconds); flashstorage_log_userchange(); m_gui->jump_to_screen(0); }
void Controller::save_time() { int h1 = m_gui->get_item_state_uint8("TIMEHOUR1"); int h2 = m_gui->get_item_state_uint8("TIMEHOUR2"); int m1 = m_gui->get_item_state_uint8("TIMEMIN1"); int m2 = m_gui->get_item_state_uint8("TIMEMIN2"); int s1 = m_gui->get_item_state_uint8("TIMESEC1"); int s2 = m_gui->get_item_state_uint8("TIMESEC2"); int new_hours = h2 + (h1*10); int new_min = m2 + (m1*10); int new_sec = s2 + (s1*10); uint8_t hours,min,sec,day,month; uint16_t year; realtime_getdate(hours,min,sec,day,month,year); hours = new_hours; min = new_min; sec = new_sec; realtime_setdate(hours,min,sec,day,month,year); rtc_set_alarm(RTC,rtc_get_time(RTC)+m_log_interval_seconds); flashstorage_log_userchange(); m_gui->jump_to_screen(0); }
void serial_process_command(char *line) { if(in_displayparams) { serial_displayparams_run(line); in_displayparams = false; } if(in_setdevicetag) { serial_setdevicetag_run(line); in_setdevicetag = false; } if(in_setrtc) { serial_setrtc_run(line); in_setrtc = false; } if(in_setkeyval) { serial_setkeyval_run(line); in_setkeyval = false; } serial_write_string("\r\n"); if(strcmp(line,"HELLO") == 0) { serial_write_string("GREETINGS PROFESSOR FALKEN.\r\n"); } else if(strcmp(line,"LIST GAMES") == 0) { serial_write_string("I'M KIND OF BORED OF GAMES, TURNS OUT THE ONLY WAY TO WIN IS NOT TO PLAY...\r\n"); } else if(strcmp(line,"LOGXFER") == 0) { serial_sendlog(); } else if(strcmp(line,"DISPLAYPARAMS") == 0) { serial_displayparams(); } else if(strcmp(line,"HELP") == 0) { serial_write_string("Available commands: HELP, LOGXFER, DISPLAYTEST, HELLO"); } else if(strcmp(line,"DISPLAYTEST") == 0) { display_test(); } else if(strcmp(line,"LOGTEST") == 0) { char stemp[100]; sprintf(stemp,"Raw log data\r\n"); serial_write_string(stemp); uint8_t *flash_log = flashstorage_log_get(); for(int n=0;n<1024;n++) { sprintf(stemp,"%u ",flash_log[n]); serial_write_string(stemp); if(n%64 == 0) serial_write_string("\r\n"); } serial_write_string("\r\n"); log_data_t data; data.time = 0; data.cpm = 1; data.accel_x_start = 2; data.accel_y_start = 3; data.accel_z_start = 4; data.accel_x_end = 5; data.accel_y_end = 6; data.accel_z_end = 7; data.log_type = UINT_MAX; sprintf(stemp,"Log size: %u\r\n",flashstorage_log_size()); serial_write_string(stemp); sprintf(stemp,"Writing test log entry of size: %u\r\n",sizeof(log_data_t)); serial_write_string(stemp); flashstorage_log_pushback((uint8 *) &data,sizeof(log_data_t)); sprintf(stemp,"Log size: %u\r\n",flashstorage_log_size()); serial_write_string(stemp); } else if(strcmp(line,"VERSION") == 0) { char stemp[50]; sprintf(stemp,"Version: %s\r\n",OS100VERSION); serial_write_string(stemp); } else if(strcmp(line,"GETDEVICETAG") == 0) { const char *devicetag = flashstorage_keyval_get("DEVICETAG"); if(devicetag != 0) { char stemp[100]; sprintf(stemp,"Devicetag: %s\r\n",devicetag); serial_write_string(stemp); } else { serial_write_string("No device tag set"); } } else if(strcmp(line,"SETDEVICETAG") == 0) { serial_setdevicetag(); } else if(strcmp(line,"READPRIVATEKEY") == 0) { // serial_readprivatekey(); // removed for production } else if(strcmp(line,"WRITEPRIVATEKEY") == 0) { // serial_writeprivatekey(); // maybe this should be removed for production? } else if(strcmp(line,"MAGREAD") == 0) { gpio_set_mode (PIN_MAP[41].gpio_device,PIN_MAP[41].gpio_bit, GPIO_OUTPUT_PP); // MAGPOWER gpio_set_mode (PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit, GPIO_INPUT_PU); // MAGSENSE // Power up magsense gpio_write_bit(PIN_MAP[41].gpio_device,PIN_MAP[41].gpio_bit,1); // wait... delay_us(1000); // Read magsense int magsense = gpio_read_bit(PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit); char magsenses[50]; sprintf(magsenses,"%u\r\n",magsense); serial_write_string(magsenses); } else if(strcmp(line,"WRITEDAC") == 0) { dac_init(DAC,DAC_CH2); int8_t idelta=1; uint8_t i=0; for(int n=0;n<1000000;n++) { if(i == 254) idelta = -1; if(i == 0 ) idelta = 1; i += idelta; dac_write_channel(DAC,2,i); } serial_write_string("WRITEDACFIN"); } else if(strcmp(line,"TESTHP") == 0) { gpio_set_mode (PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit, GPIO_OUTPUT_PP); // HP_COMBINED for(int n=0;n<100000;n++) { gpio_write_bit(PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit,1); delay_us(100); gpio_write_bit(PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit,0); delay_us(100); } } else if(strcmp(line,"READADC") == 0) { adc_init(PIN_MAP[12].adc_device); // all on ADC1 adc_set_extsel(PIN_MAP[12].adc_device, ADC_SWSTART); adc_set_exttrig(PIN_MAP[12].adc_device, true); adc_enable(PIN_MAP[12].adc_device); adc_calibrate(PIN_MAP[12].adc_device); adc_set_sample_rate(PIN_MAP[12].adc_device, ADC_SMPR_55_5); gpio_set_mode (PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit, GPIO_INPUT_ANALOG); gpio_set_mode (PIN_MAP[19].gpio_device,PIN_MAP[19].gpio_bit, GPIO_INPUT_ANALOG); gpio_set_mode (PIN_MAP[20].gpio_device,PIN_MAP[20].gpio_bit, GPIO_INPUT_ANALOG); int n=0; uint16 value1 = adc_read(PIN_MAP[12].adc_device,PIN_MAP[12].adc_channel); uint16 value2 = adc_read(PIN_MAP[19].adc_device,PIN_MAP[19].adc_channel); uint16 value3 = adc_read(PIN_MAP[20].adc_device,PIN_MAP[20].adc_channel); char values[50]; sprintf(values,"PA6 ADC Read: %u\r\n",value1); serial_write_string(values); sprintf(values,"PC4 ADC Read: %u\r\n",value2); serial_write_string(values); sprintf(values,"PC5 ADC Read: %u\r\n",value3); serial_write_string(values); } else if(strcmp(line,"SETMICREVERSE") == 0) { gpio_set_mode (PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit, GPIO_OUTPUT_PP); // MICREVERSE gpio_set_mode (PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit, GPIO_OUTPUT_PP); // MICIPHONE gpio_write_bit(PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit,1); // MICREVERSE gpio_write_bit(PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit,0); // MICIPHONE serial_write_string("Set MICREVERSE to 1, MICIPHONE to 0\r\n"); } else if(strcmp(line,"SETMICIPHONE") == 0) { gpio_set_mode (PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit, GPIO_OUTPUT_PP); // MICREVERSE gpio_set_mode (PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit, GPIO_OUTPUT_PP); // MICIPHONE gpio_write_bit(PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit,0); // MICREVERSE gpio_write_bit(PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit,1); // MICIPHONE serial_write_string("Set MICREVERSE to 0, MICIPHONE to 1\r\n"); } else if(strcmp(line,"TESTSIGN") == 0) { serial_signing_test(); } else if(strcmp(line,"PUBKEY") == 0) { signing_printPubKey(); serial_write_string("\n\r"); } else if(strcmp(line,"GUID") == 0) { signing_printGUID(); serial_write_string("\n\r"); } else if(strcmp(line,"KEYVALID") == 0) { if( signing_isKeyValid() == 1 ) serial_write_string("uu_valid VALID KEY\r\n"); else serial_write_string("uu_valid IMPROPER OR UNINITIALIZED KEY\r\n"); } else if(strcmp(line,"LOGSIG") == 0) { signing_hashLog(); serial_write_string("\n\r"); } else if(strcmp(line,"LOGPAUSE") == 0) { flashstorage_log_pause(); } else if(strcmp(line,"LOGRESUME") == 0) { flashstorage_log_resume(); } else if(strcmp(line,"LOGCLEAR") == 0) { serial_write_string("Clearing flash log\r\n"); flashstorage_log_clear(); serial_write_string("Cleared\r\n"); } else if(strcmp(line,"KEYVALDUMP") == 0) { serial_keyvaldump(); } else if(strcmp(line,"KEYVALSET") == 0) { serial_setkeyval(); } else if(strcmp(line,"SETRTC") == 0) { serial_setrtc(); } else if(strcmp(line,"RTCALARM") == 0) { serial_write_string("Alarm triggered for 10s\r\n"); rtc_set_alarm(RTC,rtc_get_time(RTC)+10); } serial_write_string("\r\n>"); }