AMiRo-OS

  struct {

    /**

     */

    /**

     * @brief   OS event source.

  void aosSysStop(void);

  void aosSysDeinit(void);

  void aosSysShutdownFinal(aos_shutdown_t shutdown);

#if defined(__cplusplus)

}

#endif /* defined(__cplusplus) */

/**

 * @brief   Converts a GPIO pad number to a unique event flag.

 */

/******************************************************************************/

/* EXTERN DECLARATIONS                                                        */

/******************************************************************************/

/**

 */

/**

 * @brief   Event mask to identify OS events.

/******************************************************************************/

/**

 */

/**

 * @brief   Listener object for OS events.

static event_listener_t _eventListenerOS;

#if defined(MODULE_HAL_PROGIF) || defined(__DOXYGEN__)

/**

 * @brief   I/O channel for the programmer interface.

 */

      continue;

    }

    // if an IO event occurred

      aosDbgPrintf("INFO: IO evt (0x%08X)\n", ioflags);

      // a power-down event occurred

        aosDbgPrintf("PD evt\n");

        // deactivate S and UP

        aosDbgPrintf("disabling S\n");

#if (AMIROOS_CFG_SSSP_STACK_END != true)

        aosDbgPrintf("disabling UP\n");

#endif /* (AMIROOS_CFG_SSSP_STACK_END != true) */

        // set shutdown flag and exit the loop

        shutdown = AOS_SHUTDOWN_PASSIVE;

        break;

      }

      // the S signal was deactivated

        apalControlGpioState_t sstate;

        if (sstate == APAL_GPIO_ON) {

          aosDbgPrintf("S evt (enabled)\n");

        } else {

          }

          // activate S

          aosDbgPrintf("enabling S\n");

#if (AMIROOS_CFG_SSSP_STACK_START == true)

          // proceed immediately

          stage = STAGE_3_2;

            eventmask &= ~(eventListenerTimeout.events);

            // activate S

            aosDbgPrintf("enabling S\n");

#if (AMIROOS_CFG_SSSP_STACK_START == true)

            // proceed

            stage = STAGE_3_2;

        if (eventmask & eventListenerDelay.events) {

          // activate UP

          aosDbgPrintf("enabling UP\n");

          // deactivate S

          aosDbgPrintf("disabling S\n");

          // explicitely clear timeout event flag

          chEvtWaitAnyTimeout(eventListenerTimeout.events, TIME_IMMEDIATE);

          eventmask &= ~(eventListenerTimeout.events);

        }

        // if an IO event was received (DN signal)

          aosDbgPrintf("DN evt\n");

          // reset timeout timer

          chVTReset(&timerTimeout);

#if (AMIROOS_CFG_SSSP_STACK_END != true)

          // activate UP

          aosDbgPrintf("enabling UP\n");

#endif /* (AMIROOS_CFG_SSSP_STACK_END != true) */

          // deactivate S

          aosDbgPrintf("disabling S\n");

          // reset the timeout timer

          chVTSet(&timerTimeout, chTimeUS2I(AOS_SYSTEM_SSSP_TIMEOUT), _ssspTimerCallback, &eventSourceTimeout);

          chEvtWaitAnyTimeout(eventListenerTimeout.events, TIME_IMMEDIATE);

        aos.sssp.stage = AOS_SSSP_STARTUP_3_4;

        // if an IO event was received (S signal)

          // reset the timeout timer

          chVTReset(&timerTimeout);

          chEvtWaitAnyTimeout(eventListenerTimeout.events, TIME_IMMEDIATE);

        // deactivate S

        aosDbgPrintf("disabling SYNC\n");

        // invalidate module ID

        aos.sssp.moduleId = 0;

        // if an IO event was received (S signal)

          aosDbgPrintf("sequence aborted\n");

          // exit the sequence

          flags.loop = false;

  // reset all control signals

#if (AMIROOS_CFG_SSSP_STACK_END != true)

  aosDbgPrintf("disabling UP\n");

#endif /* (AMIROOS_CFG_SSSP_STACK_END != true) */

  aosDbgPrintf("disabling S\n");

  aosSysGetUptime(&uptime);

  aosDbgPrintf("done\t%04ums\n", (uint32_t)(uptime / MICROSECONDS_PER_MILLISECOND));

  // local variables

  eventmask_t eventmask = 0;

  eventflags_t eventflags = 0;

  aos_shutdown_t shutdown = AOS_SHUTDOWN_NONE;

#if defined(AMIROOS_CFG_MAIN_EXTRA_THREAD_VARIABLES)

  AMIROOS_CFG_MAIN_EXTRA_THREAD_VARIABLES

  /* event associations */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

#if (AMIROOS_CFG_SSSP_STACK_START != true)

#endif /* (AMIROOS_CFG_SSSP_STACK_START != true) */

#if (AMIROOS_CFG_SSSP_STACK_END != true)

#endif /* (AMIROOS_CFG_SSSP_STACK_END != true) */

#endif /* (AMIROOS_CFG_SSSP_ENABLE == true) */

  }

  chEvtRegisterMask(&aos.events.os, &_eventListenerOS, OSEVENT_MASK);

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  /* SSSP startup OS synchronization phase (end of startup stage 2) */

    /*

     * This code is executed if the received event was not about the SYS_SYNC control signal.

     * The returned event could be caused by any listener (not only the argument).

     */

      // PD event

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

#if defined(MODULE_SSSP_STARTUP_2_2_IOEVENT_HOOK)

#endif /* defined(AMIROOS_CFG_MAIN_LOOP_HOOK_0) */

    switch (eventmask) {

        // evaluate flags

#if (AMIROOS_CFG_SSSP_ENABLE == true)

        // PD event

          shutdown = AOS_SHUTDOWN_PASSIVE;

        }

        // all other events

        else {

        }

#else /* (AMIROOS_CFG_SSSP_ENABLE == true) */

#endif /* (AMIROOS_CFG_SSSP_ENABLE == true) */

        break;

 *

 * @param[in] args   Pointer to the GPIO line identifier.

 */

{

  aosDbgCheck((args != NULL) && (*((ioline_t*)args) != PAL_NOLINE) && (PAL_PAD(*((ioline_t*)args)) < sizeof(eventflags_t) * 8));

  chSysLockFromISR();

  chSysUnlockFromISR();

  return;

  // if the system is in operation phase

  if (aos.sssp.stage == AOS_SSSP_OPERATION) {

    // read signal S

    // if S was toggled from on to off

    if (s_state == APAL_GPIO_OFF) {

      // get current uptime

    }

  }

  // broadcast event

  chSysUnlockFromISR();

  return;

  chSysLockFromISR();

  // toggle and read signal S

  // if S was toggled from off to on

  if (s_state == APAL_GPIO_ON) {

    // reconfigure the timer precisely, because the logically falling edge (next interrupt) snychronizes the system time

  aos.sssp.moduleId = 0;

#endif /* (AMIROOS_CFG_SSSP_ENABLE == true) */

  aosIOStreamInit(&aos.iostream);

  chEvtObjectInit(&aos.events.os);

  /* interrupt setup */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  // PD signal

  // SYNC signal

#if (AMIROOS_CFG_SSSP_MASTER == true)

#else /* (AMIROOS_CFG_SSSP_MASTER == true) */

#endif /* (AMIROOS_CFG_SSSP_MASTER == true) */

#if (AMIROOS_CFG_SSSP_STACK_START != true)

  // DN signal

#endif /* (AMIROOS_CFG_SSSP_STACK_START != true) */

#if (AMIROOS_CFG_SSSP_STACK_END != true)

  // UP signal

#endif /* (AMIROOS_CFG_SSSP_STACK_END != true) */

#endif /* (AMIROOS_CFG_SSSP_ENABLE == true) */

  aos.sssp.stage = AOS_SSSP_STARTUP_2_2;

  // deactivate the sync signal to indicate that the module is ready (SSSPv1 stage 2.1 of startup phase)

  // wait for any event to occur (do not apply any filter in order not to miss any event)

  m = chEvtWaitOne(ALL_EVENTS);

  f = chEvtGetAndClearFlags(syncEvtListener);

  // if the event was a system event,

  //   and it was fired because of the SysSync control signal,

  //   and the SysSync control signal has been deactivated

  if (m & syncEvtListener->events &&

      s == APAL_GPIO_OFF) {

    chSysLock();

    // start the uptime counter

  chSysLock();

  // activate the SYS_PD control signal only, if this module initiated the shutdown

  if (shutdown != AOS_SHUTDOWN_PASSIVE) {

  }

  // activate the SYS_SYNC signal

  chSysUnlock();

#endif /* (AMIROOS_CFG_SSSP_ENABLE == true) */

 *

 * @return  Pointer to the callback function.

 */

{

}

/** @} */

#endif /* !defined(OS_CFG_PROFILE) */

/**

 * @note    Any mandatory events (e.g. for SSSP) are enabled implicitely despite this configuration.

 */

/**

 * @brief   Timeout value when waiting for events in the main loop in microseconds.

/**

 * @brief   Event flag to be set on a SYS_SYNC interrupt.

 */

/**

 * @brief   Event flag to be set on a SYS_WARMRST interrupt.

 */

/**

 * @brief   Event flag to be set on a PATH_DCSTAT interrupt.

 */