AMiRo-OS

 *          this value.

 */

#if (AMIROOS_CFG_TESTS_ENABLE != true) || defined(__DOXYGEN__)

#else

#define CH_CFG_ST_TIMEDELTA                 2

#endif

 */

#define MODULE_SSSP_EVENTFLAGS_UP               MODULE_OS_IOEVENTFLAGS_SYSUARTUP

/** @} */

/*===========================================================================*/

 *          this value.

 */

#if (AMIROOS_CFG_TESTS_ENABLE != true) || defined(__DOXYGEN__)

#else

#define CH_CFG_ST_TIMEDELTA                 2

#endif

 */

#define MODULE_SSSP_EVENTFLAGS_DN               MODULE_OS_IOEVENTFLAGS_SYSUARTDN

/** @} */

/*===========================================================================*/

 *          The value one is not valid, timeouts are rounded up to

 *          this value.

 */

/** @} */

 */

#define MODULE_SSSP_EVENTFLAGS_DN               MODULE_OS_IOEVENTFLAGS_SYSUARTDN

/** @} */

/*===========================================================================*/

#define SSSP_STACKINIT_CANMSGID_ABORT           0x001

/**

 * @brief   Listener object for I/O events.

 */

static event_listener_t _eventListenerIO;

}

/**

 *

 * @param[out]  dst   Pointer to the output buffer.

 */

{

  aosDbgCheck(dst != NULL);

    dst[byte] = (uint8_t)((src >> (byte * 8)) & 0xFF);

  }

}

/**

 *

 * @param[in] src   Pointer to the buffer of data to be deserialzed.

 *

 * @return    The deserialized 32 bit data.

 */

{

  aosDbgCheck(src != NULL);

}

/**

        aosDbgPrintf(">>> 3-4 (finish)\n");

        break;

      case STAGE_3_4_ABORT_ACTIVE:

        break;

      case STAGE_3_4_ABORT:

        aosDbgPrintf(">>> 3-4 (abort)\n");

      continue;

    }

    // if an IO event occurred

      ioflags = chEvtGetAndClearFlags(&_eventListenerIO);

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

      // a power-down event occurred

      }

    }

    // an OS event occurred

      aosDbgPrintf("WARN: OS evt\n");

      // get the flags

      eventflags_t oseventflags = chEvtGetAndClearFlags(&_eventListenerOS);

#endif

    }

    // if a CAN event occurred

      // fetch message

      if (flags.wfe) {

        canReceiveTimeout(&MODULE_HAL_CAN, CAN_ANY_MAILBOX, &canRxFrame, TIME_IMMEDIATE);

      // any further pending messages are fetched at the end of the loop

    }

    // if a timeout event occurred

      // is handled at the end of the loop (or must be cleared by FSM)

    }

    // if a delay event occurred

      // is handled by FSM

    }

#if (AMIROOS_CFG_SSSP_MASTER != true)

        // a CAN message was received

          // if an initiation message was received

          if (canRxFrame.DLC == 0 &&

              canRxFrame.RTR == CAN_RTR_DATA &&

            aosDbgPrintf("init msg\n");

            // reset the timeout timer and clear pending flags

            chVTReset(&timerTimeout);

            // activate S

            aosDbgPrintf("S+\n");

            apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_ON);

          aosDbgPrintf("CAN -> ID (%u)\n", aos.sssp.moduleId);

          canTxFrame.DLC = 4;

          canTxFrame.SID = SSSP_STACKINIT_CANMSGID_MODULEID;

          if (canTransmitTimeout(&MODULE_HAL_CAN, CAN_ANY_MAILBOX, &canTxFrame, TIME_IMMEDIATE) != MSG_OK) {

            chEvtBroadcast(&eventSourceTimeout);

            break;

        }

        // if a delay event occurred

          // activate UP

          aosDbgPrintf("UP+\n");

          apalControlGpioSet(&moduleSsspGpioUp, APAL_GPIO_ON);

          aosDbgPrintf("S-\n");

          apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_OFF);

          // explicitely clear timeout event flag

          // proceed

          stage = STAGE_3_3_WAITFORID;

        }

        aos.sssp.stage = AOS_SSSP_STARTUP_3_3;

        // a CAN message was received

          // if an ID message was received

          if (canRxFrame.DLC == 4 &&

              canRxFrame.RTR == CAN_RTR_DATA &&

              canRxFrame.IDE == CAN_IDE_STD &&

              canRxFrame.SID == SSSP_STACKINIT_CANMSGID_MODULEID) {

            // validate received ID

              // store received ID

              // restart timeout timer

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

              // proceed

              flags.wfe_next = false;

            }

            // explicitely clear timeout event flag

          }

        }

#endif

        aos.sssp.stage = AOS_SSSP_STARTUP_3_3;

        // a CAN message was received

          // if an ID message was received

          if (canRxFrame.DLC == 4 &&

              canRxFrame.RTR == CAN_RTR_DATA &&

              canRxFrame.IDE == CAN_IDE_STD &&

              canRxFrame.SID == SSSP_STACKINIT_CANMSGID_MODULEID) {

            // validate received ID

              // store received ID

              // restart timeout timer

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

            } else {

              flags.wfe_next = false;

            }

            // explicitely clear timeout event flag

          }

        }

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

          aosDbgPrintf("DN <-\n");

          // reset timeout timer

          chVTReset(&timerTimeout);

          // increment and broadcast ID

          aos.sssp.moduleId = lastid + 1;

          aosDbgPrintf("CAN -> ID (%u)\n", aos.sssp.moduleId);

          canTxFrame.DLC = 4;

          canTxFrame.SID = SSSP_STACKINIT_CANMSGID_MODULEID;

          if (canTransmitTimeout(&MODULE_HAL_CAN, CAN_ANY_MAILBOX, &canTxFrame, TIME_IMMEDIATE) != MSG_OK) {

            chEvtBroadcast(&eventSourceTimeout);

            break;

        }

        // if a delay event occurred

#if (AMIROOS_CFG_SSSP_STACK_END != true)

          // activate UP

          aosDbgPrintf("UP+\n");

          apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_OFF);

          // reset the timeout timer

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

          // proceed

          stage = STAGE_3_3_WAITFORID;

        }

#if (AMIROOS_CFG_SSSP_STACK_END != true)

        // a CAN message was received

          // if an ID message was received

          if (canRxFrame.DLC == 4 &&

              canRxFrame.RTR == CAN_RTR_DATA &&

              canRxFrame.SID == SSSP_STACKINIT_CANMSGID_MODULEID) {

#if (AMIROOS_CFG_SSSP_STACK_START != true) || (AMIROOS_CFG_DBG == true)

            // Plausibility of the received ID is not checked at this point but is done by other modules still in a previous stage.

            aosDbgPrintf("ID (%u)\n", lastid);

#endif

            // restart timeout timer

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

          }

        }

#endif

        aos.sssp.stage = AOS_SSSP_STARTUP_3_4;

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

          // reset the timeout timer

          chVTReset(&timerTimeout);

          //set the delay timer

          chVTSet(&timerDelay, LL_US2ST(AOS_SYSTEM_SSSP_TIMEOUT), _ssspTimerCallback, &eventSourceDelay);

        }

        // if a CAN event was received

          // if an abort message was received

          if (canRxFrame.SID == SSSP_STACKINIT_CANMSGID_ABORT) {

            aosDbgPrintf("abort msg\n");

            // reset the delay timer

            chVTReset(&timerDelay);

            // proceed

            stage = STAGE_3_4_ABORT;

          }

        }

        // if a delay timer event occurred

          aosDbgPrintf("sequence sucessful\n");

          // sequence finished sucessfully

          flags.loop = false;

        canTransmitTimeout(&MODULE_HAL_CAN, CAN_ANY_MAILBOX, &canTxFrame, TIME_INFINITE);

        aosDbgPrintf("CAN -> abort\n");

        // clear timeout flag

        // proceed immediately

        stage = STAGE_3_4_ABORT;

        flags.wfe_next = false;

        aos.sssp.moduleId = 0;

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

          aosDbgPrintf("sequence aborted\n");

          // exit the sequence

          flags.loop = false;

    }

    // fetch pending CAN message (if any)

      aosDbgPrintf("CAN <- 0x%03X\n", canRxFrame.SID);

      flags.wfe_next = false;

    }

    // handle unhandled timeout events

      aosDbgPrintf("ERR: timeout evt\n");

      // abort

      flags.wfe_next = false;

#endif

#if (AMIROOS_CFG_TESTS_ENABLE == true)

  MODULE_INIT_TESTS();

#endif

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_4)

#endif

  /* 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).

     */

    if (eventmask & _eventListenerIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerIO);

#ifdef MODULE_SSSP_STARTUP_2_2_IOEVENT_HOOK

#else

#endif

    }

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

  /*

   */

  /* SSSP startup stage 3 (module stack initialization) */

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_8)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_8_ARGS)

  while (shutdown == AOS_SHUTDOWN_NONE) {

    // wait for an event

#if (AMIROOS_CFG_MAIN_LOOP_TIMEOUT != 0)

#else

    eventmask = chEvtWaitOne(ALL_EVENTS);

#endif

  aos_timestamp_t uptime;

  chSysLockFromISR();

    }

  }

  // broadcast event

  aos_timestamp_t uptime;

  chSysLockFromISR();

  apalControlGpioGet(&moduleSsspGpioSync, &s_state);

  // 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

  // update the system SSSP stage

  aos.sssp.stage = AOS_SSSP_OPERATION;

  // print system information;

  _printSystemInfo((BaseSequentialStream*)&aos.iostream);

  aosprintf("\n");

      f == MODULE_SSSP_EVENTFLAGS_SYNC &&

      s == APAL_GPIO_OFF) {

    chSysLock();

    // start the uptime counter

    _synctime = chVTGetSystemTimeX();

    _uptime = 0;