AMiRo-OS

/*

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

Copyright (C) 2016..2020  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.

 */

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

 */

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

 */

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

 */

static inline uint64_t _deserializeU64(uint8_t* src)

{

  aosDbgCheck(src != NULL);

  uint64_t result = 0;

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