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

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

/**

 * @brief   Event mask to identify SSSP timeout events (MSI only).

 */

#define EVENTMASK_SSSPTIMEOUT                   EVENT_MASK(2)

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

/**

 * @brief   Event mask to identify SSSP delay events.

 */

#define EVENTMASK_SSSPDELAY                     EVENT_MASK(3)

#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.

 */

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

{

#if (AMIROOS_CFG_DBG == true)

  aosDbgPrintf("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;

}

#if ((AMIROOS_CFG_SSSP_ENABLE == true) && (HAL_USE_RTC == TRUE)) || defined(__DOXYGEN__)

#if (AMIROOS_CFG_SSSP_MASTER == 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   Serializes 64 bit unsigned integer input and stores it in a byte array.

 * @details Serialization is performed in big-endian fashion.

 *

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

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

 */

inline void _serializeU64(uint8_t* dst, const uint64_t src)

{

  aosDbgCheck(dst != NULL);

  for (uint8_t byte = 0; byte < sizeof(uint64_t); ++byte) {

    dst[byte] = ((src >> ((sizeof(uint64_t) - (byte+1)) * 8)) & 0xFF);

  }

  return;

}

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

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

/**

 * @brief   Deserialize 64 bit unsigned integer data from a buffer.

 * @details Data is assumed to be serialized in big-endian fashion.

 *

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

 *

 * @return    Deserialized 64 bit data.

 */

inline uint64_t _deserializeU64(uint8_t* src)

{

  aosDbgCheck(src != NULL);

  uint64_t result = 0;

  for (uint8_t byte = 0; byte < sizeof(uint64_t); ++byte) {

    result |= ((uint64_t)src[byte] << ((sizeof(uint64_t) - (byte+1)) * 8));

  }

  return result;

}

/**

 * @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 /* (AMIROOS_CFG_SSSP_MASTER != true) */

#endif /* (AMIROOS_CFG_SSSP_ENABLE == true) && (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 | moduleSsspEventflagPD() | moduleSsspEventflagS();

#if (AMIROOS_CFG_SSSP_MSI == true)

#if (AMIROOS_CFG_SSSP_STACK_START != true)

    flagsmask |= moduleSsspEventflagDN();

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

#if (AMIROOS_CFG_SSSP_STACK_END != true)

    flagsmask |= moduleSsspEventflagUP();

#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, EVENTMASK_SSSPDELAY, &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 & moduleSsspEventflagPD()) {

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

  }