AMiRo-OS

/* kernel parameters and options */

  #error "AMIROOS_CFG_DBG not defined in aosconf.h"

  #error "AMIROOS_CFG_TESTS_ENABLE not defined in aosconf.h"

  #error "AMIROOS_CFG_PROFILE not defined in aosconf.h"

  #error "AMIROOS_CFG_MAIN_LOOP_TIMEOUT not defined in aosconf.h"

/* SSSP parameters and options */

  #error "AMIROOS_CFG_SSSP_ENABLE not defined in aosconf.h"

# if (AMIROOS_CFG_SSSP_ENABLE == true)

    #error "AMIROOS_CFG_SSSP_MASTER not defined in aosconf.h"

    #error "AMIROOS_CFG_SSSP_STACK_START not defined in aosconf.h"

    #error "AMIROOS_CFG_SSSP_STACK_END not defined in aosconf.h"

  #if (AMIROOS_CFG_SSSP_STACK_START == true) && (AMIROOS_CFG_SSSP_STACK_END == true)

    #warning "AMIROOS_CFG_SSSP_STACK_START and AMIROOS_CFG_SSSP_STACK_END both enabled in aosconf.h"

    #if (AMIROOS_CFG_SSSP_MASTER != true)

      #error "AMIROOS_CFG_SSSP_MASTER must be enabled in this case"

    #error "AMIROOS_CFG_SSSP_SIGNALDELAY not defined in aosconf.h"

    #error "AMIROOS_CFG_SSSP_SYSSYNCPERIOD not defined in aosconf.h"

/* system shell options */

  #error "AMIROOS_CFG_SHELL_ENABLE not defined in aosconf.h"

#if (AMIROOS_CFG_SHELL_ENABLE == true)

    #error "AMIROOS_CFG_SHELL_STACKSIZE not defined in aosconf.h"

    #error "AMIROOS_CFG_SHELL_THREADPRIO not defined in aosconf.h"

    #error "AMIROOS_CFG_SHELL_LINEWIDTH not defined in aosconf.h"

    #error "AMIROOS_CFG_SHELL_MAXARGS not defined in aosconf.h"

  #if (AMIROOS_CFG_TESTS_ENABLE == true)

    #pragma message "AMiRo-OS shell enabled implicitely via AMIROOS_CFG_TESTS_ENABLE"

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

/* DATA STRUCTURES AND TYPES                                                  */

  }                                                                           \

}

#define aosDbgPrintf(fmt, ...) {                          \

  (void)(fmt);                                            \

  (void)(r);                                              \

}

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

/* EXTERN DECLARATIONS                                                        */

/* EXTERN DECLARATIONS                                                        */

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

extern "C" {

  void aosIOStreamInit(AosIOStream* stream);

  void aosIOChannelInit(AosIOChannel* channel, BaseAsynchronousChannel* asyncchannel);

  void aosIOStreamAddChannel(AosIOStream* stream, AosIOChannel* channel);

  void aosIOChannelInputDisable(AosIOChannel* channel);

  void aosIOChannelOutputEnable(AosIOChannel* channel);

  void aosIOChannelOutputDisable(AosIOChannel* channel);

}

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

/* INLINE FUNCTIONS                                                           */

/* EXTERN DECLARATIONS                                                        */

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

extern "C" {

  void aosShellInit(aos_shell_t* shell, event_source_t* oseventsource, const char* prompt, char* line, size_t linesize, char** arglist, size_t arglistsize);

  void aosShellStreamInit(AosShellStream* stream);

  void aosShellChannelInit(AosShellChannel* channel, BaseAsynchronousChannel* asyncchannel);

  void aosShellChannelOutputEnable(AosShellChannel* channel);

  void aosShellChannelOutputDisable(AosShellChannel* channel);

  THD_FUNCTION(aosShellThread, shell);

}

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

/* INLINE FUNCTIONS                                                           */

 */

#define AOS_SYSTEM_SSSP_TIMEOUT                 (10 * AMIROOS_CFG_SSSP_SIGNALDELAY)

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

/* SETTINGS                                                                   */

 */

typedef uint16_t aos_ssspmoduleid_t;

/**

 * @brief   AMiRo-OS base system structure.

     */

    aos_ssspmoduleid_t moduleId;

  } sssp;

  /**

   * @brief   System I/O stream.

  } events;

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

  /**

   * @brief   Pointer to the shell object.

   */

  aos_shell_t shell;

} aos_system_t;

 */

extern aos_system_t aos;

extern "C" {

#if (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true)

  void aosSysInit(const char* shellPrompt);

  void aosSysInit(void);

  void aosSysStart(void);

#if (AMIROOS_CFG_SSSP_ENABLE == true) || defined (__DOXYGEN__)

  eventmask_t aosSysSsspStartupOsInitSyncCheck(event_listener_t* syncEvtListener);

  void aosSysGetUptimeX(aos_timestamp_t* ut);

#if (HAL_USE_RTC == TRUE)

  void aosSysGetDateTime(struct tm* dt);

  void aosSysSetDateTime(struct tm* dt);

  void aosSysShutdownInit(aos_shutdown_t shutdown);

  void aosSysStop(void);

  void aosSysDeinit(void);

  void aosSysShutdownFinal(aos_shutdown_t shutdown);

}

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

/* INLINE FUNCTIONS                                                           */

/* EXTERN DECLARATIONS                                                        */

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

extern "C" {

  void aosThdSleepUntilS(const aos_timestamp_t t);

#if (AMIROOS_CFG_DBG == true) && (CH_DBG_FILL_THREADS == TRUE)

  size_t aosThdGetStackPeakUtilization(thread_t* thread);

}

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

/* INLINE FUNCTIONS                                                           */

         ((size_t)PORT_GUARD_PAGE_SIZE + sizeof(struct port_intctx) + sizeof(struct port_extctx) + (size_t)PORT_INT_REQUIRED_STACK);

}

#endif /* AMIROOS_THREAD_H */

/* EXTERN DECLARATIONS                                                        */

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

extern "C" {

  uint8_t aosTimeDayOfWeekFromDate(const uint16_t day, const uint8_t month, const uint16_t year);

}

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

/* INLINE FUNCTIONS                                                           */

/* EXTERN DECLARATIONS                                                        */

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

extern "C" {

  void aosTimerInit(aos_timer_t* timer);

  void aosTimerSetAbsoluteI(aos_timer_t* timer, aos_timestamp_t* uptime, vtfunc_t cb, void* par);

  void aosTimerSetIntervalI(aos_timer_t* timer, aos_interval_t offset, vtfunc_t cb, void* par);

  void aosPeriodicTimerInit(aos_periodictimer_t* ptimer);

  void aosPeriodicTimerSetI(aos_periodictimer_t* ptimer, aos_interval_t interval, vtfunc_t cb, void* par);

  void aosPeriodicTimerSetLongI(aos_periodictimer_t* ptimer, aos_longinterval_t* interval, vtfunc_t cb, void* par);

}

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

/* INLINE FUNCTIONS                                                           */

/* EXTERN DECLARATIONS                                                        */

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

extern "C" {

  uint32_t aosUtResultTotal(aos_utresult_t* result);

  float aosUtResultRatio(aos_utresult_t* result);

  void aosUtResultPrintSummary(BaseSequentialStream* stream, aos_utresult_t* result, char* heading);

  void aosUtFailed(BaseSequentialStream* stream, aos_utresult_t* result);

  void aosUtFailedMsg(BaseSequentialStream* stream, aos_utresult_t* result, const char* fmt, ...);

  void aosUtInfoMsg(BaseSequentialStream* stream, const char* fmt, ...);

}

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

/* INLINE FUNCTIONS                                                           */

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

#endif /* AMIROOS_UNITTEST_H */

 */

#if defined(AMIROOS_CFG_MAIN_EXTRA_INCLUDE_HEADER)

#include AMIROOS_CFG_MAIN_EXTRA_INCLUDE_HEADER

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

/* LOCAL DEFINITIONS                                                          */

 */

#define SSSP_STACKINIT_CANMSGID_ABORT           0x001

/**

 * @brief   Default shutdown mode if SSSP is unavailable.

 */

#define AOS_SHUTDOWN_DEFAULT                    AOS_SHUTDOWN_DEEPSLEEP

/**

 * @brief   CAN message identifier for calender synchronization message.

 */

#if defined(AMIROOS_CFG_MAIN_EXTRA_STATIC_VARIABLES)

AMIROOS_CFG_MAIN_EXTRA_STATIC_VARIABLES

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

/* LOCAL FUNCTIONS                                                            */

{

#if (AMIROOS_CFG_DBG == true)

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

  (void)(mask);

  (void)(flags);

  return;

}

  return;

}

/**

 * @brief   Helper function to serialize data.

  return;

}

#if (AMIROOS_CFG_SSSP_ENABLE == true) || defined(__DOXYGEN__)

/**

  CANRxFrame canRxFrame;

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

  aos_ssspmoduleid_t lastid = 0;

  flags_t flags;

  aos_timestamp_t uptime;

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

        break;

    }

    // reset wfe flag for the next iteration

    flags.wfe_next = true;

#if (AMIROOS_CFG_SSSP_STACK_END != true)

        aosDbgPrintf("disabling UP\n");

        apalControlGpioSet(&moduleSsspGpioUp, APAL_GPIO_OFF);

        // set shutdown flag and exit the loop

        shutdown = AOS_SHUTDOWN_PASSIVE;

        break;

      // get the flags

      eventflags_t oseventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      // there should be no OS events at this point

      MODULE_SSSP_STARTUP_3_OSEVENT_HOOK(eventmask, eventflags);

      _unexpectedEventError(eventmask, oseventflags);

    }

    // if a CAN event occurred

    if ((eventmask & eventListenerCan.events)) {

          // proceed immediately

          stage = STAGE_3_2;

          flags.wfe_next = false;

          // set the timeout timer

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

          // proceed

          stage = STAGE_3_3_WAITFORFIRSTID;

          // set the timeout timer

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

        }

#if (AMIROOS_CFG_SSSP_MASTER != true)

            // proceed

            stage = STAGE_3_2;

            flags.wfe_next = false;

            // set the timeout timer

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

            // proceed

            stage = STAGE_3_3_WAITFORFIRSTID;

          }

        }

        break;

      } /* end of STAGE_3_1 */

            chEvtBroadcast(&eventSourceTimeout);

            break;

          }

          lastid = aos.sssp.moduleId;

#if (AMIROOS_CFG_SSSP_STACK_END == true)

          // sequence is already over

          // deactivate S

          apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_OFF);

          // proceed

          stage = STAGE_3_3_WAITFORID;

          // set the delay timer so the UP signal is activated later

          chVTSet(&timerDelay, chTimeUS2I(AMIROOS_CFG_SSSP_SIGNALDELAY), _ssspTimerCallback, &eventSourceDelay);

        }

        // if a delay event occurred

          // proceed

          stage = STAGE_3_3_WAITFORID;

        }

        break;

      } /* end of STAGE_3_2 */

            eventmask &= ~(eventListenerTimeout.events);

          }

        }

        break;

      } /* end of STAGE_3_3_WAITFORFIRSTID */

          // activate UP

          aosDbgPrintf("enabling UP\n");

          apalControlGpioSet(&moduleSsspGpioUp, APAL_GPIO_ON);

          // deactivate S

          aosDbgPrintf("disabling S\n");

          apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_OFF);

          // proceed

          stage = STAGE_3_3_WAITFORID;

        }

        break;

      } /* end of STAGE_3_3_WAITFORIDORSIG */

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

            lastid = _deserialize(canRxFrame.data8, 4);

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

            // restart timeout timer

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

            chEvtWaitAnyTimeout(eventListenerTimeout.events, TIME_IMMEDIATE);

            eventmask &= ~(eventListenerTimeout.events);

          }

        }

        break;

      } /* end of STAGE_3_3_WAITFORID */

#if (AMIROOS_CFG_SSSP_STACK_END != true)

  aosDbgPrintf("disabling UP\n");

  apalControlGpioSet(&moduleSsspGpioUp, APAL_GPIO_OFF);

  aosDbgPrintf("disabling S\n");

  apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_OFF);

  aosSysGetUptime(&uptime);

  return shutdown;

}

/**

 * @brief   Application entry point.

  aos_shutdown_t shutdown = AOS_SHUTDOWN_NONE;

#if defined(AMIROOS_CFG_MAIN_EXTRA_THREAD_VARIABLES)

  AMIROOS_CFG_MAIN_EXTRA_THREAD_VARIABLES

  /*

   * ##########################################################################

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_0)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_0_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_0(AMIROOS_CFG_MAIN_INIT_HOOK_0_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_0();

  /* hardware, kernel, and operating system initialization */

  // ChibiOS/HAL and custom hal additions (if any)

  halInit();

  MODULE_INIT_HAL_EXTRA();

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_1)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_1_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_1(AMIROOS_CFG_MAIN_INIT_HOOK_1_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_1();

  // ChibiOS/RT kernel and custom kernel additions (if any)

  chSysInit();

  MODULE_INIT_KERNEL_EXTRA();

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_2)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_2_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_2(AMIROOS_CFG_MAIN_INIT_HOOK_2_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_2();

  // AMiRo-OS and custom OS additions (if any)

#if (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true)

  aosSysInit(moduleShellPrompt);

  aosSysInit();

  MODULE_INIT_OS_EXTRA();

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_3)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_3_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_3(AMIROOS_CFG_MAIN_INIT_HOOK_3_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_3();

  /* event associations */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  ioeventflagsmask |= MODULE_SSSP_EVENTFLAGS_PD | MODULE_SSSP_EVENTFLAGS_SYNC;

#if (AMIROOS_CFG_SSSP_STACK_START != true)

  ioeventflagsmask |= MODULE_SSSP_EVENTFLAGS_DN;

#if (AMIROOS_CFG_SSSP_STACK_END != true)

  ioeventflagsmask |= MODULE_SSSP_EVENTFLAGS_UP;

  if (ioeventflagsmask != 0) {

    chEvtRegisterMaskWithFlags(&aos.events.io, &_eventListenerIO, IOEVENT_MASK, ioeventflagsmask);

  }

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_4)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_4_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_4(AMIROOS_CFG_MAIN_INIT_HOOK_4_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_4();

  /* periphery communication initialization */

  // module specific initialization (if any)

  MODULE_INIT_PERIPHERY_COMM();

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  // CAN (mandatory)

  canStart(&MODULE_HAL_CAN, &moduleHalCanConfig);

  // user interface (if any)

  aosIOChannelInit(&_stdiochannel, (BaseAsynchronousChannel*)&MODULE_HAL_PROGIF);

  aosIOChannelOutputEnable(&_stdiochannel);

  aosIOStreamAddChannel(&aos.iostream, &_stdiochannel);

  aosShellChannelInputEnable(&_stdshellchannel);

  aosShellChannelOutputEnable(&_stdshellchannel);

  aosShellStreamAddChannel(&aos.shell.stream, &_stdshellchannel);

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_5)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_5_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_5(AMIROOS_CFG_MAIN_INIT_HOOK_5_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_5();

  /* module is ready -> print welcome prompt */

  aosprintf("\n");

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_6)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_6_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_6(AMIROOS_CFG_MAIN_INIT_HOOK_6_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_6();

#if (AMIROOS_CFG_TESTS_ENABLE == true)

#if defined(MODULE_INIT_TESTS)

  MODULE_INIT_TESTS();

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_7)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_7_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_7(AMIROOS_CFG_MAIN_INIT_HOOK_7_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_7();

#if (AMIROOS_CFG_SSSP_ENABLE == true)

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

      if (eventflags & MODULE_SSSP_EVENTFLAGS_PD) {

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

        MODULE_SSSP_STARTUP_2_2_IOEVENT_HOOK(eventmask, eventflags);

        // ignore any other IO events

      }

    }

    // OS event

  if (shutdown == AOS_SHUTDOWN_NONE) {

    shutdown = _ssspModuleStackInitialization();

  }

  /*

   * There must be no delays at this point, thus no hook is allowed.

    canTransmitTimeout(&MODULE_HAL_CAN, CAN_ANY_MAILBOX, &frame, TIME_IMMEDIATE);

    aosDbgPrintf("done\n");

    CANRxFrame frame;

    uint64_t encoded;

    struct tm t;

#if (AMIROOS_CFG_DBG == true)

    // increase timeout in debug mode due to additional delays introduced by the many prinf() calls

    if (canReceiveTimeout(&MODULE_HAL_CAN, CAN_ANY_MAILBOX, &frame, chTimeUS2I(10 * AOS_SYSTEM_SSSP_TIMEOUT)) == MSG_OK) {

    if (canReceiveTimeout(&MODULE_HAL_CAN, CAN_ANY_MAILBOX, &frame, chTimeUS2I(AOS_SYSTEM_SSSP_TIMEOUT)) == MSG_OK) {

      // validate message

      if (frame.DLC == 8 &&

          frame.RTR == CAN_RTR_DATA &&

    } else {

      aosDbgPrintf("fail (timeout)\n");

    }

    aosDbgPrintf("\n");

  }

#endif /* (AMIROOS_CFG_SSSP_ENABLE == true) && (HAL_USE_RTC == TRUE) */

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_8)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_8_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_8(AMIROOS_CFG_MAIN_INIT_HOOK_8_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_8();

  /* completely start AMiRo-OS */

  if (shutdown == AOS_SHUTDOWN_NONE) {

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_9)

#if defined(AMIROOS_CFG_MAIN_INIT_HOOK_9_ARGS)

  AMIROOS_CFG_MAIN_INIT_HOOK_9(AMIROOS_CFG_MAIN_INIT_HOOK_9_ARGS);

  AMIROOS_CFG_MAIN_INIT_HOOK_9();

  /*

   * ##########################################################################

    // wait for an event

#if (AMIROOS_CFG_MAIN_LOOP_TIMEOUT != 0)

    eventmask = chEvtWaitOneTimeout(ALL_EVENTS, chTimeUS2I(AMIROOS_CFG_MAIN_LOOP_TIMEOUT));

    eventmask = chEvtWaitOne(ALL_EVENTS);

#if defined(AMIROOS_CFG_MAIN_LOOP_HOOK_0)

#if defined(AMIROOS_CFG_MAIN_LOOP_HOOK_0_ARGS)

    AMIROOS_CFG_MAIN_LOOP_HOOK_0(AMIROOS_CFG_MAIN_LOOP_HOOK_0_ARGS);

    AMIROOS_CFG_MAIN_LOOP_HOOK_0();

    switch (eventmask) {

      // if this was an I/O event

          shutdown = AOS_SHUTDOWN_PASSIVE;

        }

        // all other events

        else {

          MODULE_MAIN_LOOP_IO_EVENT(eventflags);

        }

        MODULE_MAIN_LOOP_IO_EVENT(eventflags);

        break;

      // if this was an OS event

          case AOS_SYSTEM_EVENTFLAGS_RESTART:

            shutdown = AOS_SHUTDOWN_RESTART;

            break;

          case AOS_SYSTEM_EVENTFLAGS_SHUTDOWN:

            shutdown = AOS_SHUTDOWN_DEFAULT;

            break;

          default:

            _unexpectedEventError(eventmask, eventflags);

            break;

        eventflags = 0;

#if (AMIROOS_CFG_MAIN_LOOP_TIMEOUT == 0)

        _unexpectedEventError(eventmask, eventflags);

        break;

    }

#if defined(AMIROOS_CFG_MAIN_LOOP_HOOK_1)

#if defined(AMIROOS_CFG_MAIN_LOOP_HOOK_1_ARGS)

    AMIROOS_CFG_MAIN_LOOP_HOOK_1(AMIROOS_CFG_MAIN_LOOP_HOOK_1_ARGS);

    AMIROOS_CFG_MAIN_LOOP_HOOK_1();

  }

  /*

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_0)

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_0_ARGS)

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_0(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_0_ARGS);

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_0();

  // initialize/acknowledge shutdown

  aosSysShutdownInit(shutdown);

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1)

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1_ARGS)

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1_ARGS);

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1();

  // stop system threads

  aosSysStop();

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2)

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2_ARGS)

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2_ARGS);

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2();

  // deinitialize system

  aosSysDeinit();

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3)

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3_ARGS)

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3_ARGS);

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3();

  /* stop all periphery communication */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  // CAN (mandatory)

  canStop(&MODULE_HAL_CAN);

  MODULE_SHUTDOWN_PERIPHERY_COMM();

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4)

#if defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4_ARGS)

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4_ARGS);

    AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4();

  // finally hand over to bootloader

  aosSysShutdownFinal(shutdown);

               dt.tm_min,

               dt.tm_sec);

    }

    else {

      aosDbgAssert(false);

    }

#if (AMIROOS_CFG_TESTS_ENABLE == true)

#include <ch_test.h>

#include <rt_test_root.h>

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

/* LOCAL DEFINITIONS                                                          */

static int _shellcmd_shutdowncb(BaseSequentialStream* stream, int argc, char* argv[]);

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

static int _shellcmd_kerneltestcb(BaseSequentialStream* stream, int argc, char* argv[]);

#endif /* (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true) */

/**

static aos_shellcommand_t _shellcmd_shutdown = {

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  /* name     */ "system:shutdown",

  /* name     */ "module:shutdown",

  /* callback */ _shellcmd_shutdowncb,

  /* next     */ NULL,

};

  /* callback */ _shellcmd_kerneltestcb,

  /* next     */ NULL,

};

#endif /* (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true) */

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

#if (HAL_USE_RTC == TRUE)

  struct tm dt;

  aosSysGetDateTime(&dt);

  // print static information about module and operating system

  _printSystemInfoSeparator(stream, '=', SYSTEM_INFO_WIDTH);

  _printSystemInfoLine(stream, "Module", SYSTEM_INFO_NAMEWIDTH, "%s", BOARD_NAME);

  _printSystemInfoLine(stream, "Platform", SYSTEM_INFO_NAMEWIDTH, "%s", PLATFORM_NAME);

  _printSystemInfoLine(stream, "Core Variant", SYSTEM_INFO_NAMEWIDTH, "%s", PORT_CORE_VARIANT_NAME);

  _printSystemInfoLine(stream, "Architecture", SYSTEM_INFO_NAMEWIDTH, "%s", PORT_ARCHITECTURE_NAME);

  _printSystemInfoSeparator(stream, '-', SYSTEM_INFO_WIDTH);

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  _printSystemInfoLine(stream, "AMiRo-OS" , SYSTEM_INFO_NAMEWIDTH, "%u.%u.%u %s (SSSP %u.%u)", AMIROOS_VERSION_MAJOR, AMIROOS_VERSION_MINOR, AMIROOS_VERSION_PATCH, AMIROOS_RELEASE_TYPE, AOS_SYSTEM_SSSP_VERSION_MAJOR, AOS_SYSTEM_SSSP_VERSION_MINOR);

  _printSystemInfoLine(stream, "AMiRo-OS" , SYSTEM_INFO_NAMEWIDTH, "%u.%u.%u %s", AMIROOS_VERSION_MAJOR, AMIROOS_VERSION_MINOR, AMIROOS_VERSION_PATCH, AMIROOS_RELEASE_TYPE);

  _printSystemInfoLine(stream, "AMiRo-LLD" , SYSTEM_INFO_NAMEWIDTH, "%u.%u.%u %s (periphAL %u.%u)", AMIRO_LLD_VERSION_MAJOR, AMIRO_LLD_VERSION_MINOR, AMIRO_LLD_VERSION_PATCH, AMIRO_LLD_RELEASE_TYPE, PERIPHAL_VERSION_MAJOR, PERIPHAL_VERSION_MINOR);

  _printSystemInfoLine(stream, "ChibiOS/RT" , SYSTEM_INFO_NAMEWIDTH, "%u.%u.%u %s", CH_KERNEL_MAJOR, CH_KERNEL_MINOR, CH_KERNEL_PATCH, (CH_KERNEL_STABLE == 1) ? "stable" : "non-stable");

  _printSystemInfoLine(stream, "ChibiOS/HAL", SYSTEM_INFO_NAMEWIDTH, "%u.%u.%u %s", CH_HAL_MAJOR, CH_HAL_MINOR, CH_HAL_PATCH, (CH_HAL_STABLE == 1) ? "stable" : "non-stable");

        aosprintf("WARNING: Bootloader and AMiRo-OS implement incompatible SSSP versions!\n");

      }

    }

    _printSystemInfoLine(stream, "Compiler", SYSTEM_INFO_NAMEWIDTH, "%s %u.%u.%u", (BL_CALLBACK_TABLE_ADDRESS->vCompiler.identifier == BL_VERSION_ID_GCC) ? "GCC" : "<compiler unknown>", BL_CALLBACK_TABLE_ADDRESS->vCompiler.major, BL_CALLBACK_TABLE_ADDRESS->vCompiler.minor, BL_CALLBACK_TABLE_ADDRESS->vCompiler.patch); // TODO: support other compilers than GCC

  } else {

    if (stream) {

  } else {

    _printSystemInfoLine(stream, "Module ID", SYSTEM_INFO_NAMEWIDTH, "not available");

  }

#if (HAL_USE_RTC == TRUE)

  _printSystemInfoLine(stream, "Date", SYSTEM_INFO_NAMEWIDTH, "%s %02u-%02u-%04u", (dt.tm_wday == 0) ? "Sunday" : (dt.tm_wday == 1) ? "Monday" : (dt.tm_wday == 2) ? "Tuesday" : (dt.tm_wday == 3) ? "Wednesday" : (dt.tm_wday == 4) ? "Thursday" : (dt.tm_wday == 5) ? "Friday" : "Saturday",

                       dt.tm_mday,

                       dt.tm_mon + 1,

                       dt.tm_year + 1900);

  _printSystemInfoLine(stream, "Time", SYSTEM_INFO_NAMEWIDTH, "%02u:%02u:%02u", dt.tm_hour, dt.tm_min, dt.tm_sec);

  _printSystemInfoSeparator(stream, '=', SYSTEM_INFO_WIDTH);

      retval = AOS_OK;

    }

  }

  // print help, if required

    chprintf(stream, "      hour\n");

    chprintf(stream, "      minute\n");

    chprintf(stream, "      second\n");

  }

  return (argc > 1 && strcmp(argv[1], "--help") == 0) ? AOS_OK : retval;

  chprintf(stream, "%10u microseconds\n", (uint16_t)(uptime % MICROSECONDS_PER_MILLISECOND / MICROSECONDS_PER_MICROSECOND));

#if (AMIROOS_CFG_SSSP_ENABLE == true) && (AMIROOS_CFG_SSSP_MASTER != true) && (AMIROOS_CFG_PROFILE == true)

  chprintf(stream, "SSSP synchronization offset: %.3fus per %uus\n", _syssyncskew, AMIROOS_CFG_SSSP_SYSSYNCPERIOD);

  _printSystemInfoSeparator(stream, '=', SYSTEM_INFO_WIDTH);

  // print shell info

  chprintf(stream, "\tthread stack size:      %u bytes\n", aosThdGetStacksize(aos.shell.thread));

#if (CH_DBG_FILL_THREADS == TRUE)

  chprintf(stream, "\tstack peak utilization: %u bytes (%.2f%%)\n", aosThdGetStackPeakUtilization(aos.shell.thread), (float)aosThdGetStackPeakUtilization(aos.shell.thread) / (float)aosThdGetStacksize(aos.shell.thread) * 100.0f);

  _printSystemInfoSeparator(stream, '=', SYSTEM_INFO_WIDTH);

  return AOS_OK;

      return AOS_INVALID_ARGUMENTS;

    }

  }

  (void)argv;

  (void)argc;

  chEvtBroadcastFlags(&aos.events.os, AOS_SYSTEM_EVENTFLAGS_SHUTDOWN);

  chThdTerminate(chThdGetSelfX());

  return AOS_OK;

}

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

  return retval;

}

#endif /* (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true) */

// suppress warning in case no interrupt GPIOs are defined

        _uptime -= uptime % AMIROOS_CFG_SSSP_SYSSYNCPERIOD;

#if (AMIROOS_CFG_PROFILE == true)

        _syssyncskew = ((1.0f - SYSTEM_SYSSYNCSKEW_LPFACTOR) * _syssyncskew) + (SYSTEM_SYSSYNCSKEW_LPFACTOR * (uptime % AMIROOS_CFG_SSSP_SYSSYNCPERIOD));

      } else {

        _uptime += AMIROOS_CFG_SSSP_SYSSYNCPERIOD - (uptime % AMIROOS_CFG_SSSP_SYSSYNCPERIOD);

#if (AMIROOS_CFG_PROFILE == true)

        _syssyncskew = ((1.0f - SYSTEM_SYSSYNCSKEW_LPFACTOR) * _syssyncskew) - (SYSTEM_SYSSYNCSKEW_LPFACTOR * (AMIROOS_CFG_SSSP_SYSSYNCPERIOD - (uptime % AMIROOS_CFG_SSSP_SYSSYNCPERIOD)));

      }

    }

  }

 */

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

void aosSysInit(const char* shellPrompt)

void aosSysInit(void)

{

  /* set control thread to maximum priority */

  chThdSetPriority(AOS_THD_CTRLPRIO);

#if (AMIROOS_CFG_SSSP_MASTER == true)

  chVTObjectInit(&_syssynctimer);

  _syssynctime = 0;

#if (AMIROOS_CFG_SSSP_MASTER != true) && (AMIROOS_CFG_PROFILE == true)

  _syssyncskew = 0.0f;

  // start the uptime counter

  chSysLock();

  _synctime = chVTGetSystemTimeX();

  _uptime = 0;

  chVTSetI(&_systimer, SYSTIMER_PERIOD, &_uptimeCallback, NULL);

  chSysUnlock();

  /* initialize aos configuration */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  aos.sssp.stage = AOS_SSSP_STARTUP_2_1;

  aos.sssp.moduleId = 0;

  aosIOStreamInit(&aos.iostream);

  chEvtObjectInit(&aos.events.io);

  chEvtObjectInit(&aos.events.os);

  // SYNC signal

#if (AMIROOS_CFG_SSSP_MASTER == true)

  palSetPadCallback(moduleSsspGpioSync.gpio->port, moduleSsspGpioSync.gpio->pad, _intCallback, &moduleSsspGpioSync.gpio->pad);

  palSetPadCallback(moduleSsspGpioSync.gpio->port, moduleSsspGpioSync.gpio->pad, _signalSyncCallback, &moduleSsspGpioSync.gpio->pad);

  palEnablePadEvent(moduleSsspGpioSync.gpio->port, moduleSsspGpioSync.gpio->pad, APAL2CH_EDGE(moduleSsspGpioSync.meta.edge));

#if (AMIROOS_CFG_SSSP_STACK_START != true)

  // DN signal

  palSetPadCallback(moduleSsspGpioDn.gpio->port, moduleSsspGpioDn.gpio->pad, _intCallback, &moduleSsspGpioDn.gpio->pad);

  palEnablePadEvent(moduleSsspGpioDn.gpio->port, moduleSsspGpioDn.gpio->pad, APAL2CH_EDGE(moduleSsspGpioDn.meta.edge));

#if (AMIROOS_CFG_SSSP_STACK_END != true)

  // UP signal

  palSetPadCallback(moduleSsspGpioUp.gpio->port, moduleSsspGpioUp.gpio->pad, _intCallback, &moduleSsspGpioUp.gpio->pad);

  palEnablePadEvent(moduleSsspGpioUp.gpio->port, moduleSsspGpioUp.gpio->pad, APAL2CH_EDGE(moduleSsspGpioUp.meta.edge));

  // further interrupt signals

  MODULE_INIT_INTERRUPTS();

#if (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true)

  /* init shell */

  aosShellAddCommand(&aos.shell, &_shellcmd_shutdown);

#if (AMIROOS_CFG_TESTS_ENABLE == true)

  aosShellAddCommand(&aos.shell, &_shellcmd_kerneltest);

#endif /* (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true) */

  return;

    chVTSetI(&_syssynctimer, chTimeUS2I((t > (AMIROOS_CFG_SSSP_SYSSYNCPERIOD / 2)) ? (t - (AMIROOS_CFG_SSSP_SYSSYNCPERIOD / 2)) : (t + (AMIROOS_CFG_SSSP_SYSSYNCPERIOD / 2))), _sysSyncTimerCallback, NULL);

    chSysUnlock();

  }

  // print system information;

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

  // start system shell thread

#if (CH_CFG_USE_THREADHIERARCHY == TRUE)

  aos.shell.thread = chThdCreateStatic(_shell_wa, sizeof(_shell_wa), AMIROOS_CFG_SHELL_THREADPRIO, aosShellThread, &aos.shell, &ch.mainthread);

  aos.shell.thread = chThdCreateStatic(_shell_wa, sizeof(_shell_wa), AMIROOS_CFG_SHELL_THREADPRIO, aosShellThread, &aos.shell);

  return;

}

    return m;

  }

}

/**

 * @brief   Retrieves the system uptime.

  return;

}

/**

 * @brief   Initializes/Acknowledges a system shutdown/restart request.

#if (AMIROOS_CFG_SSSP_MASTER == true)

  // deactivate the system synchronization timer

  chVTReset(&_syssynctimer);

  // update the system SSSP stage

  aos.sssp.stage = AOS_SSSP_SHUTDOWN_1_1;

  // activate the SYS_SYNC signal

  apalControlGpioSet(&moduleSsspGpioSync, APAL_GPIO_ON);

  chSysUnlock();

  switch (shutdown) {

    case AOS_SHUTDOWN_PASSIVE:

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  // update the system SSSP stage

  aos.sssp.stage = AOS_SSSP_SHUTDOWN_1_2;

  return;

}

{

#if (AMIROOS_CFG_SHELL_ENABLE == true) || (AMIROOS_CFG_TESTS_ENABLE == true)

  chThdWait(aos.shell.thread);

  return;

}

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  // update the system SSSP stage

  aos.sssp.stage = AOS_SSSP_SHUTDOWN_1_3;

  // validate bootloader

  if ((BL_CALLBACK_TABLE_ADDRESS->magicNumber == BL_MAGIC_NUMBER) &&

  return;

}

/** @} */

 */

#if defined(AMIRO_APPS) && (AMIRO_APPS == true)

  #include <osconf.h>

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

/**

 */

#if !defined(OS_CFG_DBG)

  #define AMIROOS_CFG_DBG                       true

  #define AMIROOS_CFG_DBG                       OS_CFG_DBG