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; }
int system_sleep_impl(Spark_Sleep_TypeDef sleepMode, long seconds, uint32_t param, void* reserved) { SYSTEM_THREAD_CONTEXT_SYNC(system_sleep_impl(sleepMode, seconds, param, reserved)); // TODO - determine if these are valuable: // - Currently publishes will get through with or without #1. // - More data is consumed with #1. // - Session is not resuming after waking from DEEP sleep, // so a full handshake currently outweighs leaving the // modem on for #2. // //---- #1 // If we're connected to the cloud, make sure all // confirmable UDP messages are sent before sleeping // if (spark_cloud_flag_connected()) { // Spark_Sleep(); // } //---- #2 // SLEEP_NETWORK_STANDBY can keep the modem on during DEEP sleep // System.sleep(10) always powers down the network, even if SLEEP_NETWORK_STANDBY flag is used. if (network_sleep_flag(param) || SLEEP_MODE_WLAN == sleepMode) { network_suspend(); } switch (sleepMode) { case SLEEP_MODE_WLAN: if (seconds) { HAL_RTC_Set_UnixAlarm((time_t) seconds); } break; case SLEEP_MODE_DEEP: if (network_sleep_flag(param)) { network_disconnect(0, NETWORK_DISCONNECT_REASON_SLEEP, NULL); network_off(0, 0, 0, NULL); } system_power_management_sleep(); return HAL_Core_Enter_Standby_Mode(seconds, (param & SLEEP_DISABLE_WKP_PIN.value()) ? HAL_STANDBY_MODE_FLAG_DISABLE_WKP_PIN : 0); break; #if Wiring_SetupButtonUX case SLEEP_MODE_SOFTPOWEROFF: network_disconnect(0, NETWORK_DISCONNECT_REASON_SLEEP, NULL); network_off(0, 0, 0, NULL); sleep_fuel_gauge(); system_power_management_sleep(); return HAL_Core_Enter_Standby_Mode(seconds, (param & SLEEP_DISABLE_WKP_PIN.value()) ? HAL_STANDBY_MODE_FLAG_DISABLE_WKP_PIN : 0); break; #endif } return 0; }
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; }