void app_loop(bool threaded) { DECLARE_SYS_HEALTH(ENTERED_WLAN_Loop); if (!threaded) Spark_Idle(); static uint8_t SPARK_WIRING_APPLICATION = 0; if(threaded || SPARK_WLAN_SLEEP || !SPARK_CLOUD_CONNECT || SPARK_CLOUD_CONNECTED || SPARK_WIRING_APPLICATION || (system_mode()!=AUTOMATIC)) { if(threaded || !SPARK_FLASH_UPDATE) { if ((SPARK_WIRING_APPLICATION != 1)) { //Execute user application setup only once DECLARE_SYS_HEALTH(ENTERED_Setup); if (system_mode()!=SAFE_MODE) setup(); SPARK_WIRING_APPLICATION = 1; } //Execute user application loop DECLARE_SYS_HEALTH(ENTERED_Loop); if (system_mode()!=SAFE_MODE) { loop(); DECLARE_SYS_HEALTH(RAN_Loop); #if !MODULAR_FIRMWARE serialEventRun(); #endif } } } }
int system_sleep_pin_impl(uint16_t wakeUpPin, uint16_t edgeTriggerMode, long seconds, uint32_t param, void* reserved) { SYSTEM_THREAD_CONTEXT_SYNC(system_sleep_pin_impl(wakeUpPin, edgeTriggerMode, seconds, param, reserved)); // If we're connected to the cloud, make sure all // confirmable UDP messages are sent before sleeping if (spark_cloud_flag_connected()) { Spark_Sleep(); } bool network_sleep = network_sleep_flag(param); if (network_sleep) { network_suspend(); } LED_Off(LED_RGB); HAL_Core_Enter_Stop_Mode(wakeUpPin, edgeTriggerMode, seconds); if (network_sleep) { network_resume(); // asynchronously bring up the network/cloud } // if single-threaded, managed mode then reconnect to the cloud (for up to 60 seconds) auto mode = system_mode(); if (system_thread_get_state(nullptr)==spark::feature::DISABLED && (mode==AUTOMATIC || mode==SEMI_AUTOMATIC) && spark_cloud_flag_auto_connect()) { waitFor(spark_cloud_flag_connected, 60000); } if (spark_cloud_flag_connected()) { Spark_Wake(); } return 0; }
/******************************************************************************* * Function Name : main. * Description : main routine. * Input : None. * Output : None. * Return : None. *******************************************************************************/ void app_setup_and_loop(void) { system_part2_post_init(); HAL_Core_Init(); // We have running firmware, otherwise we wouldn't have gotten here DECLARE_SYS_HEALTH(ENTERED_Main); PMIC().begin(); FuelGauge().wakeup(); DEBUG("Hello from Particle!"); String s = spark_deviceID(); INFO("Device %s started", s.c_str()); manage_safe_mode(); #if defined (START_DFU_FLASHER_SERIAL_SPEED) || defined (START_YMODEM_FLASHER_SERIAL_SPEED) USB_USART_LineCoding_BitRate_Handler(system_lineCodingBitRateHandler); #endif bool threaded = system_thread_get_state(NULL) != spark::feature::DISABLED && (system_mode()!=SAFE_MODE); Network_Setup(threaded); #if PLATFORM_THREADING if (threaded) { SystemThread.start(); ApplicationThread.start(); } else { SystemThread.setCurrentThread(); ApplicationThread.setCurrentThread(); } #endif if(!threaded) { /* Main loop */ while (1) { app_loop(false); } } }
/******************************************************************************* * Function Name : HAL_SysTick_Handler * Description : Decrements the various Timing variables related to SysTick. * Input : None * Output : None. * Return : None. ************************************************ *******************************/ extern "C" void HAL_SysTick_Handler(void) { if (LED_RGB_IsOverRidden()) { #ifndef SPARK_NO_CLOUD if (LED_Spark_Signal != 0) { LED_Signaling_Override(); } #endif } else if (TimingLED != 0x00) { TimingLED--; } else if(SPARK_FLASH_UPDATE || Spark_Error_Count || network.listening()) { //Do nothing } else if (SYSTEM_POWEROFF) { LED_SetRGBColor(RGB_COLOR_GREY); LED_On(LED_RGB); } else if(SPARK_LED_FADE && (!SPARK_CLOUD_CONNECTED || system_cloud_active())) { LED_Fade(LED_RGB); TimingLED = 20;//Breathing frequency kept constant } else if(SPARK_CLOUD_CONNECTED) { LED_SetRGBColor(system_mode()==SAFE_MODE ? RGB_COLOR_MAGENTA : RGB_COLOR_CYAN); LED_On(LED_RGB); SPARK_LED_FADE = 1; } else { LED_Toggle(LED_RGB); if(SPARK_CLOUD_SOCKETED || ( network.connected() && !network.ready())) TimingLED = 50; //50ms else TimingLED = 100; //100ms } if(SPARK_FLASH_UPDATE) { #ifndef SPARK_NO_CLOUD if (TimingFlashUpdateTimeout >= TIMING_FLASH_UPDATE_TIMEOUT) { //Reset is the only way now to recover from stuck OTA update HAL_Core_System_Reset(); } else { TimingFlashUpdateTimeout++; } #endif } else if(network.listening() && HAL_Core_Mode_Button_Pressed(10000)) { network.listen_command(); } // determine if the button press needs to change the state (and hasn't done so already)) else if(!network.listening() && HAL_Core_Mode_Button_Pressed(3000) && !wasListeningOnButtonPress) { if (network.connecting()) { network.connect_cancel(true, true); } // fire the button event to the user, then enter listening mode (so no more button notifications are sent) // there's a race condition here - the HAL_notify_button_state function should // be thread safe, but currently isn't. HAL_Notify_Button_State(0, false); network.listen(); HAL_Notify_Button_State(0, true); } #ifdef IWDG_RESET_ENABLE if (TimingIWDGReload >= TIMING_IWDG_RELOAD) { TimingIWDGReload = 0; /* Reload WDG counter */ HAL_Notify_WDT(); DECLARE_SYS_HEALTH(CLEARED_WATCHDOG); } else { TimingIWDGReload++; } #endif }
int system_sleep_pin_impl(const uint16_t* pins, size_t pins_count, const InterruptMode* modes, size_t modes_count, long seconds, uint32_t param, void* reserved) { SYSTEM_THREAD_CONTEXT_SYNC(system_sleep_pin_impl(pins, pins_count, modes, modes_count, seconds, param, reserved)); // If we're connected to the cloud, make sure all // confirmable UDP messages are sent before sleeping if (spark_cloud_flag_connected()) { Spark_Sleep(); } bool network_sleep = network_sleep_flag(param); if (network_sleep) { network_suspend(); } #if HAL_PLATFORM_CELLULAR if (!network_sleep_flag(param)) { // Pause the modem Serial cellular_pause(nullptr); } #endif // HAL_PLATFORM_CELLULAR #if HAL_PLATFORM_MESH // FIXME: We are still going to turn off OpenThread with SLEEP_NETWORK_STANDBY, otherwise // there are various issues with sleep if (!network_sleep_flag(param)) { network_off(NETWORK_INTERFACE_MESH, 0, 0, nullptr); } #endif // HAL_PLATFORM_MESH led_set_update_enabled(0, nullptr); // Disable background LED updates LED_Off(LED_RGB); system_power_management_sleep(); int ret = HAL_Core_Enter_Stop_Mode_Ext(pins, pins_count, modes, modes_count, seconds, nullptr); led_set_update_enabled(1, nullptr); // Enable background LED updates #if HAL_PLATFORM_CELLULAR if (!network_sleep_flag(param)) { // Pause the modem Serial cellular_resume(nullptr); } #endif // HAL_PLATFORM_CELLULAR #if HAL_PLATFORM_MESH // FIXME: we need to bring Mesh interface back up because we've turned it off // despite SLEEP_NETWORK_STANDBY if (!network_sleep_flag(param)) { network_on(NETWORK_INTERFACE_MESH, 0, 0, nullptr); } #endif // HAL_PLATFORM_MESH if (network_sleep) { network_resume(); // asynchronously bring up the network/cloud } // if single-threaded, managed mode then reconnect to the cloud (for up to 60 seconds) auto mode = system_mode(); if (system_thread_get_state(nullptr)==spark::feature::DISABLED && (mode==AUTOMATIC || mode==SEMI_AUTOMATIC) && spark_cloud_flag_auto_connect()) { waitFor(spark_cloud_flag_connected, 60000); } if (spark_cloud_flag_connected()) { Spark_Wake(); } return ret; }