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;
}
