AMiRo-OS

    aosprintf("CTRL: unexpected/unknown event received. mask: 0x%08X; flags: 0x%08X\n", mask, flags);

    (void)(mask);

    (void)(flags);

    return;

    aosDbgCheck(par != NULL);

    chSysLockFromISR();

    chEvtBroadcastI((event_source_t*)par);

    chSysUnlockFromISR();

    return;

    aosDbgCheck(dst != NULL);

    aosDbgCheck(n > 0 && n <= 8);

    for (uint8_t byte = 0; byte < n; ++byte) {

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

    }

    return;

    aosDbgCheck(src != NULL);

    aosDbgCheck(n > 0 && n <= 8);

    uint64_t result = 0;

    for (uint8_t byte = 0; byte < n; ++byte) {

        result |= ((uint64_t)src[byte]) << (byte * 8);

    }

    return result;

    aosDbgCheck(src != NULL);

    return (((uint64_t)(src->tm_sec  & 0x0000003F) << (0))               |

            ((uint64_t)(src->tm_min  & 0x0000003F) << (6))               |

            ((uint64_t)(src->tm_hour & 0x0000001F) << (12))              |

            ((uint64_t)(src->tm_mday & 0x0000001F) << (17))              |

            ((uint64_t)(src->tm_mon  & 0x0000000F) << (22))              |

            ((uint64_t)(src->tm_year & 0x00FFFFFF) << (26))              |

            ((uint64_t)(src->tm_wday & 0x00000007) << (50))              |

            ((uint64_t)(src->tm_yday & 0x000001FF) << (53))              |

            ((uint64_t)((src->tm_isdst == 0) ? 0 : (src->tm_isdst > 0) ? 1 : 2) << (62)));

    aosDbgCheck(dst != NULL);

    dst->tm_sec  = (src >> 0)  & 0x0000003F;

    dst->tm_min  = (src >> 6)  & 0x0000003F;

    dst->tm_hour = (src >> 12) & 0x0000001F;

    dst->tm_mday = (src >> 17) & 0x0000001F;

    dst->tm_mon  = (src >> 22) & 0x0000000F;

    dst->tm_year = (src >> 26) & 0x00FFFFFF;

    dst->tm_wday = (src >> 50) & 0x00000007;

    dst->tm_yday = (src >> 53) & 0x000001FF;

    dst->tm_isdst = (((src >> 62) & 0x03) == 0) ? 0 : (((src >> 62) & 0x03) > 0) ? 1 : -1;

    return;

    // local types

    /**

    typedef enum {

        STAGE_3_1,                  /**< Initiation of SSSP startup stage 3. */

        STAGE_3_2,                  /**< Starting the sequence and broadcasting the first ID. */

        STAGE_3_3_WAITFORFIRSTID,   /**< Waiting for first ID after initiation. */

        STAGE_3_3_WAITFORIDORSIG,   /**< Waiting for next ID or activation of neighbor signal. */

        STAGE_3_3_WAITFORID,        /**< Waiting for next ID (after the module has set its own ID). */

        STAGE_3_4_FINISH,           /**< Successful finish of stage 3. */

        STAGE_3_4_ABORT_ACTIVE,     /**< Aborting stage 3 (active). */

        STAGE_3_4_ABORT,            /**< Aborting stage 3 (passive). */

    } sssp_modulestackinitstage_t;

    typedef struct {

        bool loop     : 1;

        bool wfe      : 1;

        bool wfe_next : 1;

    } flags_t;

    // local variables

    aos_shutdown_t shutdown = AOS_SHUTDOWN_NONE;

    sssp_modulestackinitstage_t stage = STAGE_3_1;

    eventmask_t eventmask = 0;

    eventflags_t ioflags;

    event_source_t eventSourceTimeout;

    event_source_t eventSourceDelay;

    event_listener_t eventListenerTimeout;

    event_listener_t eventListenerDelay;

    event_listener_t eventListenerCan;

    virtual_timer_t timerTimeout;

    virtual_timer_t timerDelay;

    CANTxFrame canTxFrame;

    CANRxFrame canRxFrame;

    aos_ssspmoduleid_t lastid = 0;

#endif

    flags_t flags;

    // initialize local varibles

    chEvtObjectInit(&eventSourceTimeout);

    chEvtObjectInit(&eventSourceDelay);

    chVTObjectInit(&timerTimeout);

    chVTObjectInit(&timerDelay);

    canTxFrame.RTR = CAN_RTR_DATA;

    canTxFrame.IDE = CAN_IDE_STD;

    flags.loop = true;

    flags.wfe = false; // do not wait for events in the initial iteration of the FSM loop

    flags.wfe_next = true;

    // initialize system variables

    aos.sssp.stage = AOS_SSSP_STARTUP_3_1;

    aos.sssp.moduleId = 0;

    // listen to events (timout, delay, CAN receive)

    chEvtRegisterMask(&eventSourceTimeout, &eventListenerTimeout, TIMEOUTEVENT_MASK);

    chEvtRegisterMask(&eventSourceDelay, &eventListenerDelay, DELAYEVENT_MASK);

    chEvtRegisterMask(&MODULE_HAL_CAN.rxfull_event, &eventListenerCan, CANEVENT_MASK);

    /*

    aosDbgPrintf("SSSP stack initialization sequence:\n");

    while (flags.loop) {

        switch (stage) {

        case STAGE_3_1:

            aosDbgPrintf(">>> 3-1\n");

            break;

        case STAGE_3_2:

            aosDbgPrintf(">>> 3-2\n");

            break;

        case STAGE_3_3_WAITFORFIRSTID:

            aosDbgPrintf(">>> 3-3 (1st ID)\n");

            break;

        case STAGE_3_3_WAITFORIDORSIG:

            aosDbgPrintf(">>> 3-3 (ID/sig)\n");

            break;

        case STAGE_3_3_WAITFORID:

            aosDbgPrintf(">>> 3-3 (ID)\n");

            break;

        case STAGE_3_4_FINISH:

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

            break;

        case STAGE_3_4_ABORT_ACTIVE:

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

            break;

        case STAGE_3_4_ABORT:

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

            break;

        }

        // reset wfe flag for the next iteration

        flags.wfe_next = true;

        // waiting for events may be skipped

        if (flags.wfe) {

            // wait for any event to occur

            aosDbgPrintf("WFE...");

            eventmask = chEvtWaitAnyTimeout(ALL_EVENTS, chTimeUS2I(AOS_SYSTEM_SSSP_TIMEOUT));

            aosDbgPrintf("\t0x%08X", eventmask);

        } else {

            aosDbgPrintf("WFE skipped");

        }

        aos_timestamp_t uptime;

        aosSysGetUptime(&uptime);

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

        /*

        // no event occurred at all

        if ((flags.wfe) && (eventmask == 0)) {

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

            // enforce timeout event

            chEvtBroadcast(&eventSourceTimeout);

            continue;

        // if an IO event occurred

        if (eventmask & _eventListenerIO.events) {

            ioflags = chEvtGetAndClearFlags(&_eventListenerIO);

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

            // a power-down event occurred

            if (ioflags & MODULE_SSSP_EVENTFLAGS_PD) {

                aosDbgPrintf("PD evt\n");

                // deactivate S and UP

                apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_OFF);

#if (AMIROOS_CFG_SSSP_STACK_END != true)

                apalControlGpioSet(&moduleSsspGpioUp, APAL_GPIO_OFF);

#endif

                // set shutdown flag and exit the loop

                shutdown = AOS_SHUTDOWN_PASSIVE;

                break;

            }

            // the S signal was deactivated

            if (ioflags & MODULE_SSSP_EVENTFLAGS_SYNC) {

                apalControlGpioState_t sstate;

                apalControlGpioGet(&moduleSsspGpioSync, &sstate);

                if (sstate == APAL_GPIO_OFF) {

                    aosDbgPrintf("-S evt\n");

                    // either finish or abort

                    if ((stage == STAGE_3_3_WAITFORID) && (aos.sssp.moduleId != 0)) {

                        stage = STAGE_3_4_FINISH;

                    } else if (stage != STAGE_3_4_ABORT) {

                        stage = STAGE_3_4_ABORT_ACTIVE;