/** * 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); }
/** * 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(); } } } }
void root_menu(void) { int previous_browser = GO_TO_FILEBROWSER; int selected = 0; if (global_settings.start_in_screen == 0) next_screen = (int)global_status.last_screen; else next_screen = global_settings.start_in_screen - 2; add_event(PLAYBACK_EVENT_TRACK_CHANGE, false, rootmenu_track_changed_callback); #ifdef HAVE_RTC_ALARM if ( rtc_check_alarm_started(true) ) { rtc_enable_alarm(false); next_screen = GO_TO_WPS; #if CONFIG_TUNER if (global_settings.alarm_wake_up_screen == ALARM_START_FM) next_screen = GO_TO_FM; #endif #ifdef HAVE_RECORDING if (global_settings.alarm_wake_up_screen == ALARM_START_REC) { recording_start_automatic = true; next_screen = GO_TO_RECSCREEN; } #endif } #endif /* HAVE_RTC_ALARM */ #ifdef HAVE_HEADPHONE_DETECTION if (next_screen == GO_TO_WPS && (global_settings.unplug_autoresume && !headphones_inserted() )) next_screen = GO_TO_ROOT; #endif while (true) { switch (next_screen) { case MENU_ATTACHED_USB: case MENU_SELECTED_EXIT: /* fall through */ case GO_TO_ROOT: if (last_screen != GO_TO_ROOT) selected = get_selection(last_screen); #if (CONFIG_PLATFORM&PLATFORM_ANDROID) /* When we are in the main menu we want the hardware BACK * button to be handled by Android instead of rockbox */ android_ignore_back_button(true); #endif next_screen = do_menu(&root_menu_, &selected, NULL, false); #if (CONFIG_PLATFORM&PLATFORM_ANDROID) android_ignore_back_button(false); #endif if (next_screen != GO_TO_PREVIOUS) last_screen = GO_TO_ROOT; break; case GO_TO_PREVIOUS: next_screen = last_screen; break; case GO_TO_PREVIOUS_BROWSER: next_screen = previous_browser; break; case GO_TO_PREVIOUS_MUSIC: next_screen = previous_music; break; case GO_TO_ROOTITEM_CONTEXT: next_screen = load_context_screen(selected); break; #ifdef HAVE_PICTUREFLOW_INTEGRATION case GO_TO_PICTUREFLOW: while ( !tagcache_is_usable() ) { splash(0, str(LANG_TAGCACHE_BUSY)); if ( action_userabort(HZ/5) ) break; } { char pf_path[MAX_PATH]; snprintf(pf_path, sizeof(pf_path), "%s/pictureflow.rock", PLUGIN_DEMOS_DIR); next_screen = load_plugin_screen(pf_path); } previous_browser = GO_TO_PICTUREFLOW; break; #endif default: if (next_screen == GO_TO_FILEBROWSER #ifdef HAVE_TAGCACHE || next_screen == GO_TO_DBBROWSER #endif ) previous_browser = next_screen; if (next_screen == GO_TO_WPS #if CONFIG_TUNER || next_screen == GO_TO_FM #endif ) previous_music = next_screen; next_screen = load_screen(next_screen); break; } /* switch() */ } }
bool alarm_screen(void) { int h, m; bool done = false; struct tm *tm; int togo; int button; bool update = true; bool hour_wrapped = false; struct viewport vp[NB_SCREENS]; rtc_get_alarm(&h, &m); /* After a battery change the RTC values are out of range */ if (m > 60 || h > 24) { m = 0; h = 12; } else { m = m / 5 * 5; /* 5 min accuracy should be enough */ } FOR_NB_SCREENS(i) { viewport_set_defaults(&vp[i], i); } while(!done) { if(update) { FOR_NB_SCREENS(i) { screens[i].set_viewport(&vp[i]); screens[i].clear_viewport(); screens[i].puts(0, 4, str(LANG_ALARM_MOD_KEYS)); } /* Talk when entering the wakeup screen */ speak_time(h, m, true, true); update = false; } FOR_NB_SCREENS(i) { screens[i].set_viewport(&vp[i]); screens[i].putsf(0, 1, str(LANG_ALARM_MOD_TIME)); screens[i].putsf(0, 2, "%02d:%02d", h, m); screens[i].update_viewport(); screens[i].set_viewport(NULL); } button = get_action(CONTEXT_SETTINGS,HZ); switch(button) { case ACTION_STD_OK: /* prevent that an alarm occurs in the shutdown procedure */ /* accept alarms only if they are in 2 minutes or more */ tm = get_time(); togo = (m + h * 60 - tm->tm_min - tm->tm_hour * 60 + 1440) % 1440; if (togo > 1) { rtc_init(); rtc_set_alarm(h,m); rtc_enable_alarm(true); if (global_settings.talk_menu) { talk_id(LANG_ALARM_MOD_TIME_TO_GO, true); talk_value(togo / 60, UNIT_HOUR, true); talk_value(togo % 60, UNIT_MIN, true); talk_force_enqueue_next(); } splashf(HZ*2, str(LANG_ALARM_MOD_TIME_TO_GO), togo / 60, togo % 60); done = true; } else { splash(HZ, ID2P(LANG_ALARM_MOD_ERROR)); update = true; } break; /* inc(m) */ case ACTION_SETTINGS_INC: case ACTION_SETTINGS_INCREPEAT: m += 5; if (m == 60) { h += 1; m = 0; hour_wrapped = true; } if (h == 24) h = 0; speak_time(h, m, hour_wrapped, false); break; /* dec(m) */ case ACTION_SETTINGS_DEC: case ACTION_SETTINGS_DECREPEAT: m -= 5; if (m == -5) { h -= 1; m = 55; hour_wrapped = true; } if (h == -1) h = 23; speak_time(h, m, hour_wrapped, false); break; /* inc(h) */ case ACTION_STD_NEXT: case ACTION_STD_NEXTREPEAT: h = (h+1) % 24; if (global_settings.talk_menu) talk_value(h, UNIT_HOUR, false); break; /* dec(h) */ case ACTION_STD_PREV: case ACTION_STD_PREVREPEAT: h = (h+23) % 24; if (global_settings.talk_menu) talk_value(h, UNIT_HOUR, false); break; case ACTION_STD_CANCEL: rtc_enable_alarm(false); splash(HZ*2, ID2P(LANG_ALARM_MOD_DISABLE)); done = true; break; case ACTION_NONE: hour_wrapped = false; break; default: if(default_event_handler(button) == SYS_USB_CONNECTED) { rtc_enable_alarm(false); return true; } break; } } return false; }
static void power_thread_rtc_process(void) { if (rtc_check_alarm_flag()) rtc_enable_alarm(false); }