AMiRo-OS

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2019  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/**

 * @file    aos_main.cpp

 * @brief   Main function.

 *

 * @addtogroup aos_system

 * @{

 */

#include <amiroos.h>

/*

 * hook to add further includes

 */

#if defined(AMIROOS_CFG_MAIN_EXTRA_INCLUDE_HEADER)

#include AMIROOS_CFG_MAIN_EXTRA_INCLUDE_HEADER

#endif /* defined(AMIROOS_CFG_MAIN_EXTRA_INCLUDE_HEADER) */

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

/* LOCAL DEFINITIONS                                                          */

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

/**

 * @brief   Event mask to identify GPIO events.

 */

#define EVENTMASK_GPIO                          EVENT_MASK(0)

/**

 * @brief   Event mask to identify OS events.

 */

#define EVENTMASK_OS                            EVENT_MASK(1)

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

/**

 * @brief   Event mask to identify SSSP timer events.

 */

#define EVENTMASK_SSSPTIMER                     EVENT_MASK(2)

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

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

/* EXPORTED VARIABLES                                                         */

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

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

/* LOCAL TYPES                                                                */

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

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

/* LOCAL VARIABLES                                                            */

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

/**

 * @brief   Listener object for GPIO events.

 */

static event_listener_t _eventListenerGPIO;

/**

 * @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.

 */

static AosIOChannel _stdiochannel;

#endif /* defined(MODULE_HAL_PROGIF) */

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

/**

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

 */

static AosShellChannel _stdshellchannel;

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

/*

 * hook to add further static variables

 */

#if defined(AMIROOS_CFG_MAIN_EXTRA_STATIC_VARIABLES)

AMIROOS_CFG_MAIN_EXTRA_STATIC_VARIABLES

#endif /* defined(AMIROOS_CFG_MAIN_EXTRA_STATIC_VARIABLES) */

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

/* LOCAL FUNCTIONS                                                            */

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

/**

 * @brief   Prints an error message about an unexpected event.

 *

 * @param[in] mask    The event mask.

 * @param[in] flags   The event flags.

 */

static inline void _unexpectedEventError(const eventmask_t mask, const eventflags_t flags)

{

#if (AMIROOS_CFG_DBG == true)

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

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

  (void)(mask);

  (void)(flags);

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

  return;

}

/**

 * @brief   Helper function to serialize data.

 *

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

 * @param[in]   src   Data to be serialized.

 * @param[in]   n     Number of bytes to serialize.

 */

inline void _serialize(uint8_t* dst, const uint64_t src, const uint8_t n)

{

  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;

}

/**

 * @brief   Helper function to deserialize data.

 *

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

 * @param[in] n     Number of bytes to deserialize.

 *

 * @return    The deserialized 32 bit data.

 */

inline uint64_t _deserialize(uint8_t* src, const uint8_t n)

{

  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;

}

#if (HAL_USE_RTC == TRUE) || defined(__DOXYGEN__)

/**

 * @brief   Converter function to encode a TM value to a single unsigned 64 bit integer.

 *

 * @details Contents of the TM struct are mapped as follows:

 *            bits  |63     62|61      53|52    50|49         26|25     22|21     17|16     12|11      6|5       0|

 *            #bits |       2 |        9 |      3 |          24 |       4 |       5 |       5 |       6 |       6 |

 *            value |   isdst |     yday |   wday |        year |     mon |    mday |    hour |     min |     sec |

 *            range | special | [0, 365] | [0, 6] | [1900, ...] | [0, 11] | [1, 31] | [0, 23] | [0, 59] | [0, 61] |

 *          The Daylight Saving Time Flag (isdsst) is encoded as follows:

 *            DST not in effect         -> 0

 *            DST in effect             -> 1

 *            no information available  -> 2

 *

 * @param[in] src   Pointer to the TM struct to encode.

 *

 * @return  An unsigned 64 bit integer, which holds the encoded time value.

 */

inline uint64_t _TM2U64(struct tm* src)

{

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

}

/**

 * @brief   Converter functiomn to retrieve the encoded TM value from an unsigned 64 bit integer.

 *

 * @details For information on the encoding, please refer to @p _TM2U64 function.

 *

 * @param[out] dst  The TM struct to fill with the decoded values.

 * @param[in]  src  Unsigned 64 bit integer holding the encoded TM value.

 */

inline void _U642TM(struct tm* dst, const uint64_t src)

{

  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;

}

#endif /* (HAL_USE_RTC == TRUE) */

/**

 * @brief   Application entry point.

 */

int main(void)

{

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

#endif /* defined(AMIROOS_CFG_MAIN_EXTRA_THREAD_VARIABLES) */

  /*

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

   * # system initialization                                                  #

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

   */

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

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

  halInit();

#if defined(MODULE_INIT_HAL_EXTRA)

  MODULE_INIT_HAL_EXTRA();

#endif /* defined(MODULE_INIT_HAL_EXTRA) */

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

  chSysInit();

#if defined(MODULE_INIT_KERNEL_EXTRA)

  MODULE_INIT_KERNEL_EXTRA();

#endif /* defined(MODULE_INIT_KERNEL_EXTRA) */

  // AMiRo-OS, additional interrupts and custom OS additions (if any)

#if (AMIROOS_CFG_SHELL_ENABLE == true)

  aosSysInit(moduleShellPrompt);

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

  aosSysInit(NULL);

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

#if defined(MODULE_INIT_INTERRUPTS)

  MODULE_INIT_INTERRUPTS();

#endif

#if defined(MODULE_INIT_OS_EXTRA)

  MODULE_INIT_OS_EXTRA();

#endif /* defined(MODULE_INIT_OS_EXTRA) */

  /* event associations */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  {

    eventflags_t flagsmask = AMIROOS_CFG_MAIN_LOOP_GPIOEVENT_FLAGSMASK | MODULE_SSSP_EVENTFLAG_PD | MODULE_SSSP_EVENTFLAG_S;

#if (AMIROOS_CFG_SSSP_MSI == true)

#if (AMIROOS_CFG_SSSP_STACK_START != true)

    flagsmask |= MODULE_SSSP_EVENTFLAG_DN;

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

#if (AMIROOS_CFG_SSSP_STACK_END != true)

    flagsmask |= MODULE_SSSP_EVENTFLAG_UP;

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

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

    chEvtRegisterMaskWithFlags(&aos.events.gpio, &_eventListenerGPIO, EVENTMASK_GPIO, flagsmask);

  }

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

  if (AMIROOS_CFG_MAIN_LOOP_GPIOEVENT_FLAGSMASK) {

    chEvtRegisterMaskWithFlags(&aos.events.gpio, &_eventListenerGPIO, EVENTMASK_GPIO, AMIROOS_CFG_MAIN_LOOP_GPIOEVENT_FLAGSMASK);

  }

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

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

#if (AMIROOS_CFG_SSSP_ENABLE == true) && (AMIROOS_CFG_SSSP_STARTUP == true)

  /* perform SSSP basic initialization stage */

#if defined(MODULE_SSSP_BASICINIT_HOOK)

#if defined(MODULE_SSSP_BASICINIT_HOOK_ARGS)

  MODULE_SSSP_BASICINIT_HOOK(MODULE_SSSP_BASICINIT_HOOK_ARGS);

#else /* defined(MODULE_SSSP_BASICINIT_HOOK_ARGS) */

  MODULE_SSSP_BASICINIT_HOOK();

#endif /* defined(MODULE_SSSP_BASICINIT_HOOK_ARGS) */

#endif /* defined(MODULE_SSSP_BASICINIT_HOOK) */

  // proceed to startup stage 1.2

#if (AMIROOS_CFG_SSSP_MASTER == true)

  while ((shutdown == AOS_SHUTDOWN_NONE) && (aosSsspProceed(NULL, 0, EVENTMASK_SSSPTIMER, &eventmask) != AOS_SUCCESS)) {

    /*

     * This code is executed if the received event was not about the delay.

     * The received event could be casued by any listener.

     */

    // GPIO event

    if (eventmask & _eventListenerGPIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

      // PD event

      if (eventflags & MODULE_SSSP_EVENTFLAG_PD) {

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

#if defined(MODULE_SSSP_STARTUP_1_1_GPIOEVENT_HOOK)

        MODULE_SSSP_STARTUP_1_1_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_STARTUP_1_1_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_STARTUP_1_1_GPIOEVENT_HOOK) */

      }

    }

    // OS event

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    // unknown event

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

  if (shutdown == AOS_SHUTDOWN_NONE) {

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_STARTUP_1_2);

  }

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

  if (shutdown == AOS_SHUTDOWN_NONE) {

    aosSsspProceed(NULL, 0, 0, NULL);

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_STARTUP_1_2);

  }

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

  // proceed to startup stage 1.3

  while ((shutdown == AOS_SHUTDOWN_NONE) && (aosSsspProceed(&_eventListenerGPIO, MODULE_SSSP_EVENTFLAG_S, EVENTMASK_GPIO, &eventmask) != AOS_SUCCESS)) {

    /*

     * This code is executed if the received event was not about a deactivation of the snychronization signal.

     * The received event could be caused by any listener.

     */

    // GPIO event

    if (eventmask & _eventListenerGPIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

      // PD event

      if (eventflags & MODULE_SSSP_EVENTFLAG_PD) {

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

#if defined(MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK)

        MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK) */

      }

    }

    // OS event

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    // unknown event

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

  if (shutdown == AOS_SHUTDOWN_NONE) {

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_STARTUP_1_3);

  }

  // proceed to startup stage 2.1

#if (AMIROOS_CFG_SSSP_MASTER == true)

  while ((shutdown == AOS_SHUTDOWN_NONE) && (aosSsspProceed(NULL, 0, EVENTMASK_SSSPTIMER, &eventmask) != AOS_SUCCESS)) {

    /*

     * This code is executed if the received event was not about the delay.

     * The received event could be caused by any listener.

     */

    // GPIO event

    if (eventmask & _eventListenerGPIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

      // PD event

      if (eventflags & MODULE_SSSP_EVENTFLAG_PD) {

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

#if defined(MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK)

        MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK) */

      }

    }

    // OS event

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    // unknown event

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

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

  while ((shutdown == AOS_SHUTDOWN_NONE) && (aosSsspProceed(&_eventListenerGPIO, MODULE_SSSP_EVENTFLAG_S, EVENTMASK_GPIO, &eventmask) != AOS_SUCCESS)) {

    /*

     * This code is executed if the received event was not about a deactivation of the snychronization signal.

     * The received event could be caused by any listener.

     */

    // GPIO event

    if (eventmask & _eventListenerGPIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

      // PD event

      if (eventflags & MODULE_SSSP_EVENTFLAG_PD) {

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

#if defined(MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK)

        MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_STARTUP_1_2_GPIOEVENT_HOOK) */

      }

    }

    // OS event

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    // unknown event

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

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

  if (shutdown == AOS_SHUTDOWN_NONE) {

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_STARTUP_2_1);

  }

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

#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);

#else /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_1_ARGS) */

  AMIROOS_CFG_MAIN_INIT_HOOK_1();

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_1_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_1) */

  /* periphery communication interfaces initialization */

#if defined(MODULE_INIT_PERIPHERY_IF)

  // module specific initialization

  MODULE_INIT_PERIPHERY_IF();

#endif /* defined(MODULE_INIT_PERIPHERY_IF) */

#if defined(MODULE_HAL_PROGIF)

  // user interface

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

  aosIOChannelOutputEnable(&_stdiochannel);

  aosIOStreamAddChannel(&aos.iostream, &_stdiochannel);

#if (AMIROOS_CFG_SHELL_ENABLE == true)

  aosShellChannelInit(&_stdshellchannel, (BaseAsynchronousChannel*)&MODULE_HAL_PROGIF);

  aosShellChannelInputEnable(&_stdshellchannel);

  aosShellChannelOutputEnable(&_stdshellchannel);

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

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

#endif /* defined(MODULE_HAL_PROGIF) */

#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);

#else /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_2_ARGS) */

  AMIROOS_CFG_MAIN_INIT_HOOK_2();

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_2_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_2) */

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

  aosprintf("\n");

  aosprintf("######################################################################\n");

  aosprintf("# AMiRo-OS is an operating system designed for the Autonomous Mini   #\n");

  aosprintf("# Robot (AMiRo) platform.                                            #\n");

  aosprintf("# Copyright (C) 2016..2019  Thomas Schöpping et al.                  #\n");

  aosprintf("#                                                                    #\n");

  aosprintf("# This is free software; see the source for copying conditions.      #\n");

  aosprintf("# There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR  #\n");

  aosprintf("# A PARTICULAR PURPOSE.                                              #\n");

  aosprintf("# The development of this software was supported by the Excellence   #\n");

  aosprintf("# Cluster EXC 227 Cognitive Interaction Technology. The Excellence   #\n");

  aosprintf("# Cluster EXC 227 is a grant of the Deutsche Forschungsgemeinschaft  #\n");

  aosprintf("# (DFG) in the context of the German Excellence Initiative.          #\n");

  aosprintf("######################################################################\n");

  aosprintf("\n");

#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);

#else /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_3_ARGS) */

  AMIROOS_CFG_MAIN_INIT_HOOK_3();

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_3_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_3) */

#if (AMIROOS_CFG_TESTS_ENABLE == true)

#if defined(MODULE_INIT_TESTS)

  MODULE_INIT_TESTS();

#else /* defined(MODULE_INIT_TESTS) */

  #warning "AMIROOS_CFG_TESTS_ENABLE set to true, but MODULE_INIT_TESTS() not defined"

#endif /* defined(MODULE_INIT_TESTS) */

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

#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);

#else /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_4_ARGS) */

  AMIROOS_CFG_MAIN_INIT_HOOK_4();

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_4_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_4) */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  // proceed to startup stage 2.2

#if (AMIROOS_CFG_SSSP_MASTER == true)

  while ((shutdown == AOS_SHUTDOWN_NONE) && (aosSsspProceed(NULL, 0, EVENTMASK_SSSPTIMER, &eventmask) != AOS_SUCCESS)) {

    /*

     * This code is executed if the received event was not about the delay.

     * The received event could be caused by any listener.

     */

    // GPIO event

    if (eventmask & _eventListenerGPIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

      // PD event

      if (eventflags & MODULE_SSSP_EVENTFLAG_PD) {

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

#if defined(MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK)

        MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_STARTUP_1_3_GPIOEVENT_HOOK) */

      }

    }

    // OS event

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    // unknown event

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

  if (shutdown == AOS_SHUTDOWN_NONE) {

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_STARTUP_2_2);

  }

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

  if (shutdown == AOS_SHUTDOWN_NONE) {

    aosSsspProceed(NULL, 0, 0, NULL);

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_STARTUP_2_2);

  }

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

  // proceed to startup stage 3 (MSI is enabled), or to operation phase (no MSI)

  while ((shutdown == AOS_SHUTDOWN_NONE) && (aosSsspProceed(&_eventListenerGPIO, MODULE_SSSP_EVENTFLAG_S, EVENTMASK_GPIO, &eventmask) != AOS_SUCCESS)) {

    /*

     * This code is executed if the received event was not about a deactivation of the snychronization signal.

     * The received event could be caused by any listener.

     */

    // GPIO event

    if (eventmask & _eventListenerGPIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

      // PD event

      if (eventflags & MODULE_SSSP_EVENTFLAG_PD) {

        shutdown = AOS_SHUTDOWN_PASSIVE;

      } else {

#if defined(MODULE_SSSP_STARTUP_2_2_GPIOEVENT_HOOK)

        MODULE_SSSP_STARTUP_2_2_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_STARTUP_2_2_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_STARTUP_2_2_GPIOEVENT_HOOK) */

      }

    }

    // OS event

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    // unknown event

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

  if (shutdown == AOS_SHUTDOWN_NONE) {

#if (AMIROOS_CFG_SSSP_MSI == true)

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_STARTUP_3_1);

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

    aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_OPERATION);

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

  }

  /*

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

   */

#if (AMIROOS_CFG_SSSP_MSI == true)

  //TODO: MSI

#if (HAL_USE_RTC == TRUE)

  //TODO: Calendar synchronization

#endif /* (HAL_USE_RTC == TRUE) */

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

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

  /* completely start AMiRo-OS */

  if (shutdown == AOS_SHUTDOWN_NONE) {

    aosSysStart();

  }

#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);

#else /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_5_ARGS) */

  AMIROOS_CFG_MAIN_INIT_HOOK_5();

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_5_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_INIT_HOOK_5) */

  /*

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

   * # infinite loop                                                          #

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

   */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  /* ignore all SSSP signal events, except for PD and configured events */

  eventflags = MODULE_SSSP_EVENTFLAG_S;

#if (AMIROOS_CFG_SSSP_MSI == true)

#if (AMIROOS_CFG_SSSP_STACK_START != true)

  eventflags |= MODULE_SSSP_EVENTFLAG_DN;

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

#if (AMIROOS_CFG_SSSP_STACK_END != true)

  eventflags |= MODULE_SSSP_EVENTFLAG_UP;

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

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

  eventflags &= ~((eventflags_t)AMIROOS_CFG_MAIN_LOOP_GPIOEVENT_FLAGSMASK);

  _eventListenerGPIO.wflags &= ~eventflags;

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

  // sleep until a shutdown event is received

  while (shutdown == AOS_SHUTDOWN_NONE) {

    // wait for an event

#if (AMIROOS_CFG_MAIN_LOOP_TIMEOUT != 0)

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

#else /* (AMIROOS_CFG_MAIN_LOOP_TIMEOUT != 0) */

    eventmask = chEvtWaitOne(ALL_EVENTS);

#endif /* (AMIROOS_CFG_MAIN_LOOP_TIMEOUT != 0) */

#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);

#else /* defined(AMIROOS_CFG_MAIN_LOOP_HOOK_1_ARGS) */

    AMIROOS_CFG_MAIN_LOOP_HOOK_1();

#endif /* defined(AMIROOS_CFG_MAIN_LOOP_HOOK_1_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_LOOP_HOOK_1) */

    switch (eventmask) {

      // if this was an GPIO event

      case EVENTMASK_GPIO:

        // evaluate flags

        eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

#if (AMIROOS_CFG_SSSP_ENABLE == true)

        // PD event

        if (eventflags & MODULE_SSSP_EVENTFLAG_PD) {

          aosSsspShutdownInit(false);

          shutdown = AOS_SHUTDOWN_PASSIVE;

        }

        // all other events

#if defined(MODULE_MAIN_LOOP_GPIOEVENT)

        else {

          MODULE_MAIN_LOOP_GPIOEVENT(eventflags);

        }

#endif /* defined(MODULE_MAIN_LOOP_GPIOEVENT) */

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

#if defined(MODULE_MAIN_LOOP_GPIOEVENT)

        MODULE_MAIN_LOOP_GPIOEVENT(eventflags);

#endif /* defined(MODULE_MAIN_LOOP_GPIOEVENT) */

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

        break;

      // if this was an OS event

      case EVENTMASK_OS:

        // evaluate flags

        eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

        switch (eventflags) {

#if (AMIROOS_CFG_BOOTLOADER == AOS_BOOTLOADER_NONE)

          case AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_MASK:

            shutdown = AOS_SHUTDOWN_ACTIVE;

            break;

#elif (AMIROOS_CFG_BOOTLOADER == AOS_BOOTLOADER_AMiRoBLT)

          case AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_HIBERNATE:

            shutdown = AOS_SHUTDOWN_HIBERNATE;

            break;

          case AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_DEEPSLEEP:

            shutdown = AOS_SHUTDOWN_DEEPSLEEP;

            break;

          case AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_TRANSPORTATION:

            shutdown = AOS_SHUTDOWN_TRANSPORTATION;

            break;

          case AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_RESTART:

            shutdown = AOS_SHUTDOWN_RESTART;

            break;

          case AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_PASSIVE:

            _unexpectedEventError(eventmask, eventflags);

            break;

#endif /* (AMIROOS_CFG_BOOTLOADER == X) */

          default:

            _unexpectedEventError(eventmask, eventflags);

            break;

        }

        break;

      // if this was any other event (should be impossible to occur)

      default:

        eventflags = 0;

#if (AMIROOS_CFG_MAIN_LOOP_TIMEOUT == 0)

        _unexpectedEventError(eventmask, eventflags);

#endif /* (AMIROOS_CFG_MAIN_LOOP_TIMEOUT == 0) */

        break;

    }

#if (AMIROOS_CFG_SSSP_ENABLE == true)

    /*

     * Re-anable the S signal GPIO event.

     * Note that events for the optional signals UP and DN are not enabled as they are not utilized during SSSP shutdown phase.

     */

    chSysLock();

    _eventListenerGPIO.wflags |= MODULE_SSSP_EVENTFLAG_S;

    chSysUnlock();

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

#if defined(AMIROOS_CFG_MAIN_LOOP_HOOK_2)

#if defined(AMIROOS_CFG_MAIN_LOOP_HOOK_2_ARGS)

    AMIROOS_CFG_MAIN_LOOP_HOOK_2(AMIROOS_CFG_MAIN_LOOP_HOOK_2_ARGS);

#else /* defined(AMIROOS_CFG_MAIN_LOOP_HOOK_2_ARGS) */

    AMIROOS_CFG_MAIN_LOOP_HOOK_2();

#endif /* defined(AMIROOS_CFG_MAIN_LOOP_HOOK_2_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_LOOP_HOOK_2) */

  }

  /*

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

   * # system shutdown                                                        #

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

   */

  aosDbgAssert(shutdown != AOS_SHUTDOWN_NONE);

  // initialize/acknowledge shutdown

  aosSysShutdownInit(shutdown);

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_SHUTDOWN_1_2);

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

#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);

#else /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1_ARGS) */

  AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1();

#endif /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_1) */

  // wait for all threads to terminate

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

#else /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2_ARGS) */

  AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2();

#endif /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_2_ARGS) */

#endif /* defined(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);

#else /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3_ARGS) */

  AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3();

#endif /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_3) */

  /* stop all periphery communication interfaces */

#if defined(MODULE_SHUTDOWN_PERIPHERY_IF)

  MODULE_SHUTDOWN_PERIPHERY_IF();

#endif /* defined(MODULE_SHUTDOWN_PERIPHERY_IF) */

#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);

#else /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4_ARGS) */

  AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4();

#endif /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4_ARGS) */

#endif /* defined(AMIROOS_CFG_MAIN_SHUTDOWN_HOOK_4) */

#if (AMIROOS_CFG_SSSP_ENABLE == true)

  // proceed to SSSP shutdown stage 1.3

  aosSsspProceed(NULL, 0, 0, NULL);

  aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_SHUTDOWN_1_3);

#if (AMIROOS_CFG_SSSP_SHUTDOWN == true)

  /* AMiRo-OS performs SSSP shutdown phase

   * NOTE:

   * The initiating module could deactivate PD at this point to indicate a restart rather than a shutdown request.

   * AMiRo-OS does not support restart though, thus the signal is not changed.

   */

  // proceed to SSSP shutdown stage 2.1

  while (aosSsspProceed(&_eventListenerGPIO, MODULE_SSSP_EVENTFLAG_S, EVENTMASK_GPIO, &eventmask) != AOS_SUCCESS) {

    /*

     * This code is executed if the received event was not about a deactivation of the synchronization signal.

     * The received event could be caused by any listener.

     */

    // GPIO event

    if (eventmask & _eventListenerGPIO.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

#if defined(MODULE_SSSP_SHUTDOWN_1_3_GPIOEVENT_HOOK)

        MODULE_SSSP_SHUTDOWN_1_3_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_SHUTDOWN_1_3_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_SHUTDOWN_1_3_GPIOEVENT_HOOK) */

    }

    // OS event

    else if (eventmask & _eventListenerOS.events) {

      eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

      _unexpectedEventError(eventmask, eventflags);

    }

    // unknown event

    else {

      _unexpectedEventError(eventmask, 0);

    }

  }

  aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_SHUTDOWN_2_1);

  // proceed to SSSP shutdown stage 2.2

  aosSsspProceed(NULL, 0, 0, &eventmask);

  aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_SHUTDOWN_2_2);

  if (shutdown == AOS_SHUTDOWN_PASSIVE) {

    aosDbgPrintf("%s request received\n", eventmask ? "shutdown" : "restart");

  }

  /* NOTE:

   * Actually the call of aosSsspProceed() returned an indicator, whether a shutdown or restart has been initiated.

   * Since AMiRo-OS does not support restart, this return value is ignored and shutdown is assumed.

   */

  // the initiating module broadcasts the shutdown identifier

  if (shutdown != AOS_SHUTDOWN_PASSIVE) {

    // since AMiRo-OS does not support multiple ways to shutdown or restart, the special identifier 0 is broadcasted.

    aosSsspShutdownBroadcastIdentifier(0);

  }

  // passive modules receive the broadcasted identifier

  else {

    unsigned int identifier = 0;

    // receive the identifier, which specifies the type of shutdown/restart

    while ((eventmask = aosSsspShutdownWaitForIdentifierPulse(&_eventListenerGPIO, MODULE_SSSP_EVENTFLAG_S, EVENTMASK_SSSPTIMER, &identifier)) != EVENTMASK_SSSPTIMER) {

      // GPIO event

      if (eventmask & _eventListenerGPIO.events) {

        eventflags = chEvtGetAndClearFlags(&_eventListenerGPIO);

#if defined(MODULE_SSSP_SHUTDOWN_2_2_GPIOEVENT_HOOK)

        MODULE_SSSP_SHUTDOWN_2_2_GPIOEVENT_HOOK(eventmask, eventflags);

#else /* defined(MODULE_SSSP_SHUTDOWN_2_2_GPIOEVENT_HOOK) */

        /* silently ignore any other GPIO events */

#endif /* defined(MODULE_SSSP_SHUTDOWN_2_2_GPIOEVENT_HOOK) */

        /* silently ignore any GPIO events */

      }

      // OS event

      else if (eventmask & _eventListenerOS.events) {

        eventflags = chEvtGetAndClearFlags(&_eventListenerOS);

        _unexpectedEventError(eventmask, eventflags);

      }

      // unknown event

      else {

        _unexpectedEventError(eventmask, 0);

      }

    }

    // Since AMiRo-OS does not support multiple ways to shutdown or restart, the identifier is ignored.

  }

  // proceed to SSSP shutdown stage 2.3

  aosSsspProceed(NULL, 0, 0, NULL);

  aosDbgAssert(aos.sssp.stage == AOS_SSSP_STAGE_SHUTDOWN_2_3);

  /*

   * Since AMiRo-OS does only support one basic shutdown and no restart at all, the final shutdown is kept very simple.

   */

  // disable interrupts

  irqDeinit();

  chSysDisable();

  chThdExit(MSG_OK);

  return MSG_OK;

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

  /* hand over to the bootloader to perform SSSP shutdown phase */

  aosSysShutdownToBootloader(shutdown);

  aosDbgAssertMsg(false, "AMiRo-OS must not proceed to this point!");

  chThdExit(MSG_RESET);

  return MSG_RESET;

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

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

  /*

   * Depending on the configured bootloader, trivial shutdown is either executed by AMiRo-OS or by that bootloader.

   */

#if (AMIROOS_CFG_BOOTLOADER == AOS_BOOTLOADER_NONE)

  /* AMiRo-OS performs trivial shutdown */

  // disable interrupts

  irqDeinit();

  chSysDisable();

  chThdExit(MSG_OK);

  return MSG_OK;

#elif (AMIROOS_CFG_BOOTLOADER == AOS_BOOTLOADER_AMiRoBLT)

  /* AMiRo-BLT performns shutdown */

  aosSysShutdownToBootloader(shutdown);

  aosDbgAssertMsg(false, "AMiRo-OS must not proceed to this point!");

  chThdExit(MSG_RESET);

  return MSG_RESET;

#endif /* (AMIROOS_CFG_BOOTLOADER == X) */

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

}

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