/** * @brief Entry point to start execution at * * This is the main entry point where execution will start. It initializes the * hardware and enters an infinite loop handling any upcoming events not yet * covered. * * @note This function makes use of the attribute "OS_main". For details * refer to [1]. * * [1]: http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html * * @return Should never return anything */ __attribute__((OS_main)) int main() { uart_init(); log_main("Init...\n"); preferences_init(); #if (ENABLE_DCF_SUPPORT == 1) dcf77_init(); #endif display_init(); datetime_init(); ldr_init(); pwm_init(); irmp_init(); timer_init(); user_init(); sei(); pwm_on(); log_main("Init finished\n"); while (1) { brightness_handle(); datetime_handle(); handle_ir_code(); #if (ENABLE_UART_PROTOCOL == 1) uart_protocol_handle(); #endif /* (ENABLE_UART_PROTOCOL == 1) */ #if (ENABLE_DCF_SUPPORT == 1) datetime_t dt; // TODO: Make sure dcf77_getDateTime() validates its result if (dcf77_get_datetime(&dt)) { datetime_set(&dt); } #endif } }
/*--------------------------------------------------------------------------------------------------------------------------------------------------- * MAIN: main routine *--------------------------------------------------------------------------------------------------------------------------------------------------- */ //int main(void) __attribute__((noreturn)); /* saves some Bytes but produces warning */ int main (void) { static DATETIME datetime; uart_init(); // initialize uart log_main("Init...\n"); wcEeprom_init(); # if (DCF_PRESENT == 1) dcf77_init (); // initialize dcf77 # endif display_init (); // initialize display { // local to save stack uint8_t i2c_errorcode; uint8_t i2c_status; if (! i2c_rtc_init (&i2c_errorcode, &i2c_status)) // initialize rtc { log_main("RTC init failed\n"); // TODO: error handling } } ldr_init (); // initialize ldr pwm_init (); // initialize pwm irmp_init (); // initialize irmp timer_init (); // initialize timer user_init(); sei (); // enable interrupts pwm_on (); // switch on pwm //pwm_set_base_brightness_step(MAX_PWM_STEPS-1); /// @todo remove if ldr stuff is working log_main("Init finished\n"); for (;;) { handle_brightness (); handle_datetime (&datetime); // check & display new time, if necessary handle_ir_code (); // handle ir user interaction # if (DCF_PRESENT == 1) if (dcf77_getDateTime (&datetime)) // handle dcf77 examination (enable_dcf77_ISR must be TRUE to enable analysis) { i2c_rtc_write (&datetime); soft_seconds = datetime.ss; user_setNewTime (&datetime); } # endif /** (DCF_PRESENT == 1) */ } }
int main(int argc, const char** argv) { LogWriter logWriter; // argv[1] = path to shared ipc buffer if (argc < 2) { printf("[log_main] No IPC path provided, aborting\n"); return 1; } basic_preinit(B(&logWriter)); return log_main(&logWriter, argv[1]); }
/*--------------------------------------------------------------------------------------------------------------------------------------------------- * MAIN: check date & time * * This function uses a softclock to avoid extensive calls of i2c_rtc_read() by * reading the RTC only READ_DATETIME_INTERVAL seconds. * * fm: This softclock algorithm adjusts itself: * - if the RC oscillator is too slow, handle_datetime() will call i2c_rtc_read() every second in the last part * of a minute in order to reach the next full minute as close as possible. * - if the RC oscillator is too fast, the softclock will be slowdowned by updating the softclock every * READ_DATETIME_INTERVAL - softclock_too_fast_seconds *--------------------------------------------------------------------------------------------------------------------------------------------------- */ static void handle_datetime (DATETIME * datetimep) { static uint8_t last_hour = 0xff; // value of last hour static uint8_t last_minute = 0xff; // value of minutes evaluated last call static uint8_t last_seconds = 0xff; // value of seconds evaluated last call static uint8_t next_read_seconds = 0; // time in seconds when to read RTC again uint8_t softclock_too_fast_seconds = 0; // if softclock is too fast, store difference of seconds uint8_t rtc; if (last_seconds != soft_seconds) // time changed? { // yes... if (soft_seconds >= next_read_seconds) // next time (to read RTC) reached? { // yes... rtc = i2c_rtc_read (datetimep); // read RTC now! } else { // next time not reached... datetimep->ss = soft_seconds; // update only seconds rtc = TRUE; } if (rtc) { if (last_minute != datetimep->mm) // minute change? { // yes... user_setNewTime (datetimep); // display current time last_minute = datetimep->mm; // store current minute as last minute if (last_hour != datetimep->hh) { # if (DCF_PRESENT == 1) enable_dcf77_ISR = TRUE; // enable DCF77 every hour # endif /** (DCF_PRESENT == 1) */ last_hour = datetimep->hh; // store current hour as last hour } } if (last_seconds != 0xff && soft_seconds > datetimep->ss) { softclock_too_fast_seconds = soft_seconds - datetimep->ss; } last_seconds = soft_seconds = datetimep->ss; // store actual value of seconds for softclock if (softclock_too_fast_seconds > 0) { // set next time we have to read RTC again (with correction) next_read_seconds = soft_seconds + READ_DATETIME_INTERVAL - softclock_too_fast_seconds; } else { next_read_seconds = soft_seconds + READ_DATETIME_INTERVAL; // set next time we have to read RTC again } if (next_read_seconds >= 60) // we have to read it in the next minute... { next_read_seconds = 0; // reset next time: read at next full minute } } else { log_main("RTC error\n"); } } else { rtc = TRUE; // time not changed, do nothing } }