AMiRo-OS

/*

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

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

*/

#ifndef _AMIROOS_H_

#define _AMIROOS_H_

/**

 * @brief   AMiRo-OS identification macro.

 */

#define _AMIRO_OS_

/**

 * @name   AMiRo-OS version and relase information.

 * @{

 */

/**

 * @brief   The type of this version.

 * @note    Is one of "pre-alpha", "alpha", "beta", "release candidate", "release".

 */

#define AMIROOS_RELEASE_TYPE          "beta"

/**

 * @brief   The operating system major version.

 * @note    Changes of the major version imply incompatibilities.

 */

#define AMIROOS_VERSION_MAJOR         2

/**

 * @brief   The operating system minor version.

 * @note    A higher minor version implies new functionalty, but all old interfaces are still available.

 */

#define AMIROOS_VERSION_MINOR         0

/**

 * @brief   The operating system patch level.

 */

#define AMIROOS_VERSION_PATCH         0

/** @} */

/* subsystems headers */

#include <aosconf.h>

#include <hal.h>

#if defined(HAL_USE_QEI) && (HAL_USE_QEI == TRUE)

#include <hal_qei.h>

#endif

#include <ch.h>

/* configuration check */

#if !defined(_AMIRO_OS_CFG_)

#error "invalid AMiRo-OS configuration file"

#endif

#if (_AMIRO_OS_CFG_VERSION_MAJOR_ != AMIROOS_VERSION_MAJOR) || (_AMIRO_OS_CFG_VERSION_MINOR_ < AMIROOS_VERSION_MINOR)

#error "incompatible AMiRo-OS configuration file"

#endif

#include "core/inc/aos_confcheck.h"

/* core headers */

#include "core/inc/aos_debug.h"

#include <core/inc/aos_iostream.h>

#include "core/inc/aos_shell.h"

#include "core/inc/aos_system.h"

#include "core/inc/aos_thread.h"

#include "core/inc/aos_time.h"

#include "core/inc/aos_timer.h"

#include "core/inc/aos_types.h"

#include "core/inc/aos_unittest.h"

#endif /* _AMIROOS_H_ */

################################################################################

# AMiRo-OS is an operating system designed for the Autonomous Mini Robot       #

# (AMiRo) platform.                                                            #

# Copyright (C) 2016..2018  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/>.        #

#                                                                              #

# This research/work was supported by the Cluster of Excellence Cognitive      #

# Interaction Technology 'CITEC' (EXC 277) at Bielefeld University, which is   #

# funded by the German Research Foundation (DFG).                              #

################################################################################

# absolute path to this directory

AMIROOS_CORE_DIR := $(dir $(lastword $(MAKEFILE_LIST)))

# include paths

AMIROOSCOREINC = $(AMIROOS_CORE_DIR)inc

# C source files

AMIROOSCORECSRC = $(AMIROOS_CORE_DIR)src/aos_debug.c \

                  $(AMIROOS_CORE_DIR)src/aos_iostream.c \

                  $(AMIROOS_CORE_DIR)src/aos_shell.c \

                  $(AMIROOS_CORE_DIR)src/aos_system.c \

                  $(AMIROOS_CORE_DIR)src/aos_thread.c \

                  $(AMIROOS_CORE_DIR)src/aos_time.c \

                  $(AMIROOS_CORE_DIR)src/aos_timer.c \

                  $(AMIROOS_CORE_DIR)src/aos_unittest.c

# C++ source files

AMIROOSCORECPPSRC = $(AMIROOS_CORE_DIR)src/aos_main.cpp

/*

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

Copyright (C) 2016..2018  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_confcheck.h

 * @brief   Header that checks whether all necessary configurations are correct.

 *

 * @addtogroup aos_system

 * @{

 */

#ifndef _AMIROOS_CONFCHECK_H_

#define _AMIROOS_CONFCHECK_H_

#include <aosconf.h>

/*

 * Kernel parameters and options

 */

#ifndef AMIROOS_CFG_DBG

  #error "AMIROOS_CFG_DBG not defined in aosconf.h"

#endif

#ifndef AMIROOS_CFG_TESTS_ENABLE

  #error "AMIROOS_CFG_TESTS_ENABLE not defined in aosconf.h"

#endif

#ifndef AMIROOS_CFG_PROFILE

  #error "AMIROOS_CFG_PROFILE not defined in aosconf.h"

#endif

#ifndef AMIROOS_CFG_MAIN_LOOP_TIMEOUT

  #error "AMIROOS_CFG_MAIN_LOOP_TIMEOUT not defined in aosconf.h"

#endif

/*

 * SSSP parameters and options

 */

#ifndef AMIROOS_CFG_SSSP_MASTER

  #error "AMIROOS_CFG_SSSP_MASTER not defined in aosconf.h"

#endif

#ifndef AMIROOS_CFG_SSSP_STACK_START

  #error "AMIROOS_CFG_SSSP_STACK_START not defined in aosconf.h"

#endif

#ifndef AMIROOS_CFG_SSSP_STACK_END

  #error "AMIROOS_CFG_SSSP_STACK_END not defined in aosconf.h"

#endif

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

  #endif

#endif

#ifndef AMIROOS_CFG_SSSP_SIGNALDELAY

  #error "AMIROOS_CFG_SSSP_SIGNALDELAY not defined in aosconf.h"

#endif

#ifndef AMIROOS_CFG_SSSP_SYSSYNCPERIOD

  #error "AMIROOS_CFG_SSSP_SYSSYNCPERIOD not defined in aosconf.h"

#endif

/*

 * System shell options

 */

#ifndef AMIROOS_CFG_SHELL_ENABLE

  #error "AMIROOS_CFG_SHELL_ENABLE not defined in aosconf.h"

#endif

#if (AMIROOS_CFG_SHELL_ENABLE == true)

  #ifndef AMIROOS_CFG_SHELL_STACKSIZE

    #error "AMIROOS_CFG_SHELL_STACKSIZE not defined in aosconf.h"

  #endif

  #ifndef AMIROOS_CFG_SHELL_THREADPRIO

    #error "AMIROOS_CFG_SHELL_THREADPRIO not defined in aosconf.h"

  #endif

  #ifndef AMIROOS_CFG_SHELL_LINEWIDTH

    #error "AMIROOS_CFG_SHELL_LINEWIDTH not defined in aosconf.h"

  #endif

  #ifndef AMIROOS_CFG_SHELL_MAXARGS

    #error "AMIROOS_CFG_SHELL_MAXARGS not defined in aosconf.h"

  #endif

#endif /* AMIROOS_CFG_SHELL_ENABLE == true */

#endif /* _AMIROOS_CONFCHECK_H_ */

/** @} */

/*

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

Copyright (C) 2016..2018  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_debug.h

 * @brief   Macros used for debugging.

 *

 * @addtogroup aos_debug

 * @{

 */

#ifndef _AMIROOS_DEBUG_H_

#define _AMIROOS_DEBUG_H_

#include <aosconf.h>

#include <ch.h>

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

/**

 * @brief   Function parameters check.

 * @details If the condition check fails, the kernel panics and halts.

 *

 * @param[in] c The condition to be verified to be true.

 */

#define aosDbgCheck(c)                chDbgCheck(c)

/**

 * @brief   Condition assertion.

 * @details If the condition check fails, the kernel panics with a message and halts.

 * @note    As a limitation of ChibiOS, the remark string is not currently used.

 *

 * @param[in] c The condition to be verified to be true.

 */

#define aosDbgAssert(c)               chDbgAssert(c, "__FILE__(__LINE__): aosDbgAssert failed")

/**

 * @brief   Condition assertion.

 * @details If the condition check fails, the kernel panics with a message and halts.

 * @note    As a limitation of ChibiOS, the remark string is not currently used.

 *

 * @param[in] c The condition to be verified to be true.

 * @param[in] r A custom remark string.

 */

#define aosDbgAssertMsg(c, r) {                           \

  (void)r;                                                \

  chDbgAssert(c, r);                                      \

}

/**

 * @brief   Printf function for messages only printed in debug builds.

 *

 * @param[in] fmt   Formatted string to print.

 */

#define aosDbgPrintf(fmt, ...)           chprintf((BaseSequentialStream*)&aos.iostream, fmt, ##__VA_ARGS__)

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

#define aosDbgCheck(c) {                                  \

  (void)(c);                                              \

  }

#define aosDbgAssert(c) {                                 \

  (void)(c);                                              \

}

#define aosDbgAssertMsg(c, r) {                           \

  (void)(c);                                              \

  (void)(r);                                              \

}

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

  (void)(fmt);                                            \

}

#endif

#ifdef __cplusplus

extern "C" {

#endif

  void aosPrintHaltErrorCode(const char* reason);

#ifdef __cplusplus

}

#endif

#endif /* _AMIROOS_DEBUG_H_ */

/** @} */

/*

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

Copyright (C) 2016..2018  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_iostream.h

 * @brief   Stream and channel macros and structures.

 *

 * @addtogroup aos_stream

 * @{

 */

#ifndef _AMIROOS_IOSTREAM_H_

#define _AMIROOS_IOSTREAM_H_

#include <hal.h>

#include <aos_types.h>

#include <stdarg.h>

/**

 * @brief   Channel flag to indicate whether the channel is attached to a stream.

 */

#define AOS_IOCHANNEL_ATTACHED                  (1 << 0)

/**

 * @brief   Channel flag to indicate whether the channel is set as input.

 */

#define AOS_IOCHANNEL_INPUT_ENABLE              (1 << 1)

/**

 * @brief   Channel flag to indicate whether the channel is set as output.

 */

#define AOS_IOCHANNEL_OUTPUT_ENABLE             (1 << 2)

/*

 * forward definitions

 */

typedef struct aos_iochannel AosIOChannel;

typedef struct aos_ostream AosIOStream;

/**

 * @brief   AosI=Channel specific methods.

 */

#define _aos_iochannel_methods                                              \

  _base_asynchronous_channel_methods

/**

 * @brief   AosIOChannel specific data.

 */

#define _aos_iochannel_data                                                 \

  /* pointer to a BaseAsynchronousChannel object */                         \

  BaseAsynchronousChannel* asyncchannel;                                    \

  /* pointer to the next channel in a AosIOStream */                        \

  AosIOChannel* next;                                                       \

  /* flags related to the channel */                                        \

  uint8_t flags;

/**

 * @extends BaseAsynchronousChannelVMT

 *

 * @brief   AosIOChannel virtual methods table.

 */

struct AosIOChannelVMT {

  _aos_iochannel_methods

};

/**

 * @extends BaseAsynchronousChannel

 *

 * @brief   I/O Channel class.

 * @details This class implements an asynchronous I/O channel.

 */

struct aos_iochannel {

  /** @brief Virtual Methods Table. */

  const struct AosIOChannelVMT* vmt;

  _aos_iochannel_data

};

/**

 * @brief   AosIOStream methods.

 */

#define _aos_iostream_methods                                               \

  _base_sequential_stream_methods

/**

 * @brief   AosIOStream data.

 */

#define _aos_iostream_data                                                  \

  /* Pointer to the first channel in a list. */                             \

  AosIOChannel* channel;

/**

 * @extends BaseSequentialStream

 *

 * @brief   AosIOStream virtual methods table.

 */

struct AosIOStreamVMT {

  _aos_iostream_methods

};

/**

 * @extends BaseSequentialStream

 *

 * @brief   I/O Stream class.

 * @details This class implements an base sequential stream.

 * @todo    So far only output but no input is supported.

 */

struct aos_ostream {

  const struct AosIOStreamVMT* vmt;

  _aos_iostream_data

};

#ifdef __cplusplus

extern "C" {

#endif

  void aosIOStreamInit(AosIOStream* stream);

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

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

  aos_status_t aosIOStreamRemoveChannel(AosIOStream* stream, AosIOChannel* channel);

  void aosIOChannelInputEnable(AosIOChannel* channel);

  void aosIOChannelInputDisable(AosIOChannel* channel);

  void aosIOChannelOutputEnable(AosIOChannel* channel);

  void aosIOChannelOutputDisable(AosIOChannel* channel);

#ifdef __cplusplus

}

#endif

#endif /* _AMIROOS_IOSTREAM_H_ */

/** @} */

/*

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

Copyright (C) 2016..2018  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_shell.h

 * @brief   Shell macros and structures.

 *

 * @addtogroup aos_shell

 * @{

 */

#ifndef _AMIROOS_SHELL_H_

#define _AMIROOS_SHELL_H_

#include <aosconf.h>

#if (AMIROOS_CFG_SHELL_ENABLE == true)

#include <hal.h>

#include <aos_types.h>

/**

 * @brief   Shell event flag that is emitted when the thread starts.

 */

#define AOS_SHELL_EVTFLAG_START                   ((eventflags_t)(1 << 0))

/**

 * @brief   Shell event flag that is emitted when a command is executed.

 */

#define AOS_SHELL_EVTFLAG_EXEC                    ((eventflags_t)(1 << 1))

/**

 * @brief   Shell event flag that is emitted when a command execution finished.

 */

#define AOS_SHELL_EVTFLAG_DONE                    ((eventflags_t)(1 << 2))

/**

 * @brief   Shell event flag that is emitted when the shread stops.

 */

#define AOS_SHELL_EVTFLAG_EXIT                    ((eventflags_t)(1 << 3))

/**

 * @brief   Shell event flag that is emitted when an I/O error occurred.

 */

#define AOS_SHELL_EVTFLAG_IOERROR                 ((eventflags_t)(1 << 4))

/**

 * @brief   Shell input configuration for replacing content by user input.

 */

#define AOS_SHELL_CONFIG_INPUT_OVERWRITE          (1 << 0)

/**

 * @brief   Shell prompt configuration print a minimalistic prompt.

 */

#define AOS_SHELL_CONFIG_PROMPT_MINIMAL           (1 << 1)

/**

 * @brief   Shell prompt configuration to additionally print the system uptime with the prompt.

 */

#define AOS_SHELL_CONFIG_PROMPT_UPTIME            (1 << 2)

/**

 * @brief   Shell prompt configuration to additionally print the date and time with the prompt.

 */

#define AOS_SHELL_CONFIG_PROMPT_DATETIME          (2 << 2)

/**

 * @brief   Shell prompt configuration to additionally print the system uptime with the prompt.

 */

#define AOS_SHELL_CONFIG_MATCH_CASE               (1 << 4)

/**

 * @brief   Shell I/O channel flag whether the channel is attached to a list.

 */

#define AOS_SHELLCHANNEL_ATTACHED                 (1 << 0)

/**

 * @brief   Shell I/O channel flag whether the channel is enabled as input.

 */

#define AOS_SHELLCHANNEL_INPUT_ENABLED            (1 << 1)

/**

 * @brief   Shell I/O channel flag whether the channel is enabled as output.

 */

#define AOS_SHELLCHANNEL_OUTPUT_ENABLED           (1 << 2)

/*

 * forward definitions

 */

typedef struct aos_shellchannel AosShellChannel;

typedef struct aos_shellstream AosShellStream;

/**

 * @brief   AosShellChannel specific methods.

 */

#define _aos_shell_channel_methods                                          \

  _base_asynchronous_channel_methods

/**

 * @brief   AosShellChannel specific data.

 */

#define _aos_shell_channel_data                                             \

  /* pointer to a BaseAsynchronousChannel object */                         \

  BaseAsynchronousChannel* asyncchannel;                                    \

  /* event listener for the associated BaseAsynchronousChannel */           \

  event_listener_t listener;                                                \

  /* pointer to the next chennal in a AosShellStream */                     \

  AosShellChannel* next;                                                    \

  /* flags related to the channel */                                        \

  uint8_t flags;

/**

 * @extends BaseAsynchronousChannelVMT

 *

 * @brief   AosShellChannel virtual methods table.

 */

struct AosShellChannelVMT {

  _aos_shell_channel_methods

};

/**

 * @extends BaseAsynchronousChannel

 *

 * @brief   Shell channel class.

 * @details This class implements an asynchronous I/O channel.

 */

struct aos_shellchannel {

  /** @brief Virtual Methods Table. */

  const struct AosShellChannelVMT* vmt;

  _aos_shell_channel_data

};

/**

 * @brief   AosShellStream methods.

 */

#define _aos_shellstream_methods                                            \

  _base_sequential_stream_methods

/**

 * @brief   AosShellStream data.

 */

#define _aos_shellstream_data                                               \

  /* Pointer to the first channel in a list. */                             \

  AosShellChannel* channel;

/**

 * @extends BaseSequentialStream

 *

 * @brief   AosShellStream virtual methods table.

 */

struct AosShellStreamVMT {

  _aos_shellstream_methods

};

/**

 * @extends BaseSequentialStream

 *

 * @brief   Shell Stream class.

 * @details This class implements an base sequential stream.

 * @todo    So far only output but no input is supported.

 */

struct aos_shellstream {

  const struct AosShellStreamVMT* vmt;

  _aos_shellstream_data

};

/**

 * @brief   Shell command calback type.

 */

typedef int (*aos_shellcmdcb_t)(BaseSequentialStream* stream, int argc, char* argv[]);

/**

 * @brief   Shell command structure.

 */

typedef struct aos_shellcommand {

  /**

   * @brief   Command name.

   */

  const char* name;

  /**

   * @brief   Callback function.

   */

  aos_shellcmdcb_t callback;

  /**

   * @brief   Pointer to next command in a singly linked list.

   */

  struct aos_shellcommand* next;

} aos_shellcommand_t;

/**

 * @brief   Execution status of a shell command.

 */

typedef struct aos_shellexecstatus {

  /**

   * @brief   Pointer to the command that was executed.

   */

  aos_shellcommand_t* command;

  /**

   * @brief   Return value of the executed command.

   */

  int retval;

} aos_shellexecstatus_t;

/**

 * @brief   Enumerator to encode shell actions.

 */

typedef enum aos_shellaction {

  AOS_SHELL_ACTION_NONE,

  AOS_SHELL_ACTION_READCHAR,

  AOS_SHELL_ACTION_AUTOFILL,

  AOS_SHELL_ACTION_SUGGEST,

  AOS_SHELL_ACTION_INSERTTOGGLE,

  AOS_SHELL_ACTION_DELETEFORWARD,

  AOS_SHELL_ACTION_DELETEBACKWARD,

  AOS_SHELL_ACTION_RECALLLAST,

  AOS_SHELL_ACTION_CLEAR,

  AOS_SHELL_ACTION_CURSOR2START,

  AOS_SHELL_ACTION_CURSOR2END,

  AOS_SHELL_ACTION_CURSORLEFT,

  AOS_SHELL_ACTION_CURSORRIGHT,

  AOS_SHELL_ACTION_EXECUTE,

  AOS_SHELL_ACTION_ESCSTART,

} aos_shellaction_t;

/**

 * @brief   Shell structure.

 */

typedef struct aos_shell {

  /**

   * @brief   Pointer to the thread object.

   */

  thread_t* thread;

  /**

   * @brief   Event source.

   */

  event_source_t eventSource;

  /**

   * @brief   Struct for OS related events

   */

  struct {

    /**

     * @brief   Pointer to the OS' event source.

     */

    event_source_t* eventSource;

    /**

     * @brief   Listener for OS related events.

     */

    event_listener_t eventListener;

  } os;

  /**

     * @brief   Pointer to the first I/O channel.

     */

  AosShellStream stream;

  /**

   * @brief   String to printed as prompt.

   */

  const char* prompt;

  /**

   * @brief   Pointer to the first element of the singly linked list of commands.

   * @details Commands are ordered alphabetically in the list.

   */

  aos_shellcommand_t* commands;

  /**

   * @brief   Execution status of the most recent command.

   */

  aos_shellexecstatus_t execstatus;

  /**

   * @brief   Input buffer.

   */

  char* line;

  /**

   * @brief   Size of the input buffer.

   */

  size_t linesize;

  /**

   * @brief   Structure containing data for internal input parsing.

   */

  struct {

    /**

     * @brief   The last action executed by the shell.

     */

    aos_shellaction_t lastaction;

    /**

     * @brief   Number of character in the current escape sequence.

     */

    uint8_t escp;

    /**

     * @brief   Buffer to store an escape sequence.

     */

    char escseq[5];

    /**

     * @brief   Current curso position.

     */

    size_t cursorpos;

    /**

     * @brief   Current line width.

     */

    size_t lineend;

    /**

     * @brief   Flag whether there was input since the prompt was printed the last time.

     */

    bool noinput;

  } inputdata;

  /**

   * @brief   Argument buffer.

   */

  char** arglist;

  /**

   * @brief   Size of the argument buffer.

   */

  size_t arglistsize;

  /**

   * @brief   Configuration flags.

   */

  uint8_t config;

} aos_shell_t;

#ifdef __cplusplus

extern "C" {

#endif

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

  aos_status_t aosShellAddCommand(aos_shell_t* shell, aos_shellcommand_t* cmd);

  aos_status_t aosShellRemoveCommand(aos_shell_t* shell, char* cmd, aos_shellcommand_t** removed);

  void aosShellStreamAddChannel(AosShellStream* stream, AosShellChannel* channel);

  aos_status_t aosShellStreamRemoveChannel(AosShellStream* stream, AosShellChannel* channel);

  void aosShellChannelInputEnable(AosShellChannel* channel);

  void aosShellChannelInputDisable( AosShellChannel* channel);

  void aosShellChannelOutputEnable(AosShellChannel* channel);

  void aosShellChannelOutputDisable(AosShellChannel* channel);

  THD_FUNCTION(aosShellThread, shell);

#ifdef __cplusplus

}

#endif

#endif /* AMIROOS_CFG_SHELL_ENABLE == true */

#endif /* _AMIROOS_SHELL_H_ */

/** @} */

/*

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

Copyright (C) 2016..2018  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_system.h

 * @brief   System macros and structures.

 *

 * @addtogroup aos_system

 * @{

 */

#ifndef _AMIROOS_SYSTEM_H_

#define _AMIROOS_SYSTEM_H_

#include <aos_iostream.h>

#include <amiro-lld.h>

#include <aos_shell.h>

#include <aos_time.h>

#include <chprintf.h>

/**

 * @brief   Resolution of the system time measurement.

 */

#define AOS_SYSTEM_TIME_RESOLUTION              ((MICROSECONDS_PER_SECOND + CH_CFG_ST_FREQUENCY - 1) / CH_CFG_ST_FREQUENCY)

/**

 * @brief   System event flag which is emitted when a shutdown was initiated.

 */

#define AOS_SYSTEM_EVENTFLAGS_SHUTDOWN          (eventflags_t)(1 << 0)

/**

 * @brief   System event flag which is emitted when a shutdown to transportation mode was initiated.

 */

#define AOS_SYSTEM_EVENTFLAGS_TRANSPORTATION    (AOS_SYSTEM_EVENTFLAGS_SHUTDOWN | (eventflags_t)(1 << 1))

/**

 * @brief   System event flag which is emitted when a shutdown to deepsleep mode was initiated.

 */

#define AOS_SYSTEM_EVENTFLAGS_DEEPSLEEP         (AOS_SYSTEM_EVENTFLAGS_SHUTDOWN | (eventflags_t)(1 << 2))

/**

 * @brief   System event flag which is emitted when a shutdown to hibernate mode was initiated.

 */

#define AOS_SYSTEM_EVENTFLAGS_HIBERNATE         (AOS_SYSTEM_EVENTFLAGS_SHUTDOWN | (eventflags_t)(1 << 3))

/**

 * @brief   System event flag which is emitted when a system restart was initiated.

 */

#define AOS_SYSTEM_EVENTFLAGS_RESTART           (AOS_SYSTEM_EVENTFLAGS_SHUTDOWN | (eventflags_t)(1 << 4))

/**

 * @brief   Major version of the implemented SSSP.

 */

#define AOS_SYSTEM_SSSP_VERSION_MAJOR           1

/**

 * @brief   Minor version of the implemented SSSP.

 */

#define AOS_SYSTEM_SSSP_VERSION_MINOR           4

/**

 * @brief   Timeout delay according to SSSP.

 * @details SSSP defines timeouts to be ten times longer than the signal delay time.

 */

#define AOS_SYSTEM_SSSP_TIMEOUT                 (10 * AMIROOS_CFG_SSSP_SIGNALDELAY)

/**

 * @brief   Enumerator to identify shutdown types.

 */

typedef enum aos_shutdown {

  AOS_SHUTDOWN_NONE,            /**< Default value if no shutdown action was initiated */

  AOS_SHUTDOWN_PASSIVE,         /**< Passive shutdown (initiated by another module). */

  AOS_SHUTDOWN_HIBERNATE,       /**< Active shutdown to hibernate mode. */

  AOS_SHUTDOWN_DEEPSLEEP,       /**< Active shutdown to deepsleep mode. */

  AOS_SHUTDOWN_TRANSPORTATION,  /**< Active shutdown to transportation mode. */

  AOS_SHUTDOWN_RESTART,         /**< Active saystem restart request. */

} aos_shutdown_t;

/**

 * @brief   Enumerator of the several stages of SSSP.

 */

typedef enum aos_ssspstage {

  AOS_SSSP_STARTUP_1_1  = 0x10, /**< Identifier of SSSP startup phase stage 1-1. */

  AOS_SSSP_STARTUP_1_2  = 0x11, /**< Identifier of SSSP startup phase stage 1-2. */

  AOS_SSSP_STARTUP_1_3  = 0x12, /**< Identifier of SSSP startup phase stage 1-3. */

  AOS_SSSP_STARTUP_2_1  = 0x14, /**< Identifier of SSSP startup phase stage 2-1. */

  AOS_SSSP_STARTUP_2_2  = 0x15, /**< Identifier of SSSP startup phase stage 2-2. */

  AOS_SSSP_STARTUP_3_1  = 0x18, /**< Identifier of SSSP startup phase stage 3-1. */

  AOS_SSSP_STARTUP_3_2  = 0x19, /**< Identifier of SSSP startup phase stage 3-2. */

  AOS_SSSP_STARTUP_3_3  = 0x1A, /**< Identifier of SSSP startup phase stage 3-3. */

  AOS_SSSP_STARTUP_3_4  = 0x1B, /**< Identifier of SSSP startup phase stage 3-4. */

  AOS_SSSP_OPERATION    = 0x20, /**< Identifier of SSSP operation pahse. */

  AOS_SSSP_SHUTDOWN_1_1 = 0x30, /**< Identifier of SSSP shutdown phase stage 1-1. */

  AOS_SSSP_SHUTDOWN_1_2 = 0x31, /**< Identifier of SSSP shutdown phase stage 1-2. */

  AOS_SSSP_SHUTDOWN_1_3 = 0x32, /**< Identifier of SSSP shutdown phase stage 1-3. */

  AOS_SSSP_SHUTDOWN_2_1 = 0x34, /**< Identifier of SSSP shutdown phase stage 2-1. */

  AOS_SSSP_SHUTDOWN_2_2 = 0x35, /**< Identifier of SSSP shutdown phase stage 2-2. */

  AOS_SSSP_SHUTDOWN_3   = 0x38, /**< Identifier of SSSP shutdown phase stage 3. */

} aos_ssspstage_t;

/**

 * @brief   Type to represent module IDs.

 */

typedef uint16_t aos_ssspmoduleid_t;

/**

 * @brief   AMiRo-OS base system structure.

 */

typedef struct aos_system {

  /**

   * @brief   SSSP relevant data.

   */

  struct {

    /**

     * @brief   Current SSSP stage of the system.

     */

    aos_ssspstage_t stage;

    /**

     * @brief   Module identifier.

     * @details A value of 0 indicates an uninitialized ID.

     *          The vlaues 0 and ~0 are reserved und must not be set.

     */

    aos_ssspmoduleid_t moduleId;

  } sssp;

  /**

   * @brief   System I/O stream.

   */

  AosIOStream iostream;

  /**

   * @brief   Event structure.

   */

  struct {

    /**

     * @brief   I/O event source.

     */

    event_source_t io;

    /**

     * @brief   OS event source.

     */

    event_source_t os;

  } events;

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

  /**

   * @brief   Pointer to the shell object.

   */

  aos_shell_t shell;

#endif

} aos_system_t;

/**

 * @brief   Global system object.

 */

extern aos_system_t aos;

/**

 * @brief   Printf function that uses the default system I/O stream.

 *

 * @param[in] fmt   Formatted string to print.

 */

#define aosprintf(fmt, ...)                     chprintf((BaseSequentialStream*)&aos.iostream, fmt, ##__VA_ARGS__)

#ifdef __cplusplus

extern "C" {

#endif

#if (AMIROOS_CFG_SHELL_ENABLE == true)

  void aosSysInit(const char* shellPrompt);

#else

  void aosSysInit(void);

#endif

  void aosSysStart(void);

  eventmask_t aosSysSsspStartupOsInitSyncCheck(event_listener_t* syncEvtListener);

  void aosSysGetUptimeX(aos_timestamp_t* ut);

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

#ifdef __cplusplus

}

#endif

/**

 * @brief   Retrieves the system uptime.

 *

 * @param[out] ut   The system uptime.

 */

static inline void aosSysGetUptime(aos_timestamp_t* ut)

{

  aosDbgCheck(ut != NULL);

  chSysLock();

  aosSysGetUptimeX(ut);

  chSysUnlock();

  return;

}

#endif /* _AMIROOS_SYSTEM_H_ */

/** @} */

/*

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

Copyright (C) 2016..2018  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_thread.h

 * @brief   Thread macros and inline functions.

 *

 * @addtogroup aos_threads

 * @{

 */

#ifndef _AMIROOS_THREAD_H_

#define _AMIROOS_THREAD_H_

#include <aos_time.h>

#include <aos_system.h>

/**

 * @brief   Minimum thread priority.

 */

#define AOS_THD_LOWPRIO_MIN           ((tprio_t)(LOWPRIO))

/**

 * @brief   Maximum priority for background threads.

 */

#define AOS_THD_LOWPRIO_MAX           ((tprio_t)(LOWPRIO + ((NORMALPRIO - LOWPRIO) / 2)))

/**

 * @brief   Minimum priority for normal/standard threads.

 */

#define AOS_THD_NORMALPRIO_MIN        ((tprio_t)(AOS_THD_LOWPRIO_MAX + 1))

/**

 * @brief   Maximum priority for normal/standard threads.

 */

#define AOS_THD_NORMALPRIO_MAX        ((tprio_t)(NORMALPRIO))

/**

 * @brief   Minimum priority for important threads.

 */

#define AOS_THD_HIGHPRIO_MIN          ((tprio_t)(NORMALPRIO + 1))

/**

 * @brief   Maximum priority for important threads.

 */

#define AOS_THD_HIGHPRIO_MAX          ((tprio_t)(NORMALPRIO + ((HIGHPRIO - NORMALPRIO) / 2)))

/**

 * @brief   Minimum priority for real-time threads.

 */

#define AOS_THD_RTPRIO_MIN            ((tprio_t)(AOS_THD_HIGHPRIO_MAX + 1))

/**

 * @brief   Maximum priority for real-time threads.

 */

#define AOS_THD_RTPRIO_MAX            ((tprio_t)(HIGHPRIO - 1))

/**

 * @brief   Priority for the system control thread.

 */

#define AOS_THD_CTRLPRIO              ((tprio_t)(HIGHPRIO))

/**

 * @brief   Maximum timeframe that can be slept in system ticks.

 */

#define AOS_THD_MAX_SLEEP_ST          TIME_MAX_INTERVAL

/**

 * @brief   Maximum timeframe that can be slept in seconds.

 */

#define AOS_THD_MAX_SLEEP_S           (chTimeI2S(AOS_THD_MAX_SLEEP_ST) - 1)

/**

 * @brief   Maximum timeframe that can be slept in milliseconds.

 */

#define AOS_THD_MAX_SLEEP_MS          (chTimeI2MS(AOS_THD_MAX_SLEEP_ST) - 1)

/**

 * @brief   Maximum timeframe that can be slept in microseconds.

 */

#define AOS_THD_MAX_SLEEP_US          (chTimeI2US(AOS_THD_MAX_SLEEP_ST) - 1)

#ifdef __cplusplus

extern "C" {

#endif

  void aosThdSleepUntilS(const aos_timestamp_t* t);

#ifdef __cplusplus

}

#endif

/**

 * @brief   Lets the calling thread sleep the specified amount of microseconds.

 *

 * @param[in] us    Time to sleep in microseconds.

 */

static inline void aosThdUSleepS(const aos_interval_t us)

{

  aos_timestamp_t ut;

  aosSysGetUptimeX(&ut);

  ut += us;

  aosThdSleepUntilS(&ut);

  return;

}

/**

 * @brief   Lets the calling thread sleep the specified amount of milliseconds.

 *

 * @param[in] ms    Time to sleep in milliseconds.

 */

static inline void aosThdMSleepS(const uint32_t ms)

{

  aos_timestamp_t ut;

  aosSysGetUptimeX(&ut);

  ut += (aos_timestamp_t)ms * MICROSECONDS_PER_MILLISECOND;

  aosThdSleepUntilS(&ut);

  return;

}

/**

 * @brief   Lets the calling thread sleep the specified amount of seconds.

 *

 * @param[in] s     Time to sleep in seconds.

 */

static inline void aosThdSSleepS(const uint32_t s)

{

  aos_timestamp_t ut;

  aosSysGetUptimeX(&ut);

  ut += (aos_timestamp_t)s * MICROSECONDS_PER_SECOND;

  aosThdSleepUntilS(&ut);

  return;

}

/**

 * @brief   Lets the calling thread sleep the specified amount of seconds.

 *

 * @param[in] s     Time to sleep in seconds.

 */

static inline void aosThdSleepS(const float s)

{

  aos_timestamp_t ut;

  aosSysGetUptimeX(&ut);

  ut += (aos_timestamp_t)(s * MICROSECONDS_PER_SECOND);

  aosThdSleepUntilS(&ut);

  return;

}

/**

 * @brief   Lets the calling thread sleep the specified amount of microseconds.

 *

 * @param[in] us    Time to sleep in microseconds.

 */

static inline void aosThdUSleep(const uint32_t us)

{

  chSysLock();

  aosThdUSleepS(us);

  chSysUnlock();

  return;

}

/**

 * @brief   Lets the calling thread sleep the specified amount of milliseconds.

 *

 * @param[in] ms    Time to sleep in milliseconds.

 */

static inline void aosThdMSleep(const uint32_t ms)

{

  chSysLock();

  aosThdMSleepS(ms);

  chSysUnlock();

  return;

}

/**

 * @brief   Lets the calling thread sleep the specified amount of seconds.

 *

 * @param[in] s     Time to sleep in seconds.

 */

static inline void aosThdSSleep(const uint32_t s)

{

  chSysLock();

  aosThdSSleepS(s);

  chSysUnlock();

  return;

}

/**

 * @brief   Lets the calling thread sleep the specified amount of seconds.

 *

 * @param[in] s     Time to sleep in seconds.

 */

static inline void aosThdSleep(const float s)

{

  chSysLock();

  aosThdSleepS(s);

  chSysUnlock();

  return;

}

/**

 * @brief   Lets the calling thread sleep until the specifide system uptime.

 *

 * @param[in] t     Deadline until the thread will sleep.

 */

static inline void aosThdSleepUntil(const aos_timestamp_t* t)

{

  chSysLock();

  aosThdSleepUntilS(t);

  chSysUnlock();

  return;

}

#endif /* _AMIROOS_THREAD_H_ */

/** @} */

/*

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

Copyright (C) 2016..2018  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_time.h

 * @brief   Time related constants and data types.

 *

 * @addtogroup aos_time

 * @{

 */

#ifndef _AMIROOS_TIME_H_

#define _AMIROOS_TIME_H_

#include <stdint.h>

/**

 * @brief   Generic time to represent long time frames at high precision.

 * @note    By definition the temporal resolution is 1us.

 */

typedef uint64_t aos_timestamp_t;

/**

 * @brief   generic time to represent medium length time frames at high precision.

 * @note    By definition the temporal resolution is 1us.

 */

typedef uint32_t aos_interval_t;

/**

 * @brief   Generic time to represent long time frames at high precision.

 * @note    By definition the temporal resolution is 1us.

 */

typedef aos_timestamp_t aos_longinterval_t;

#define MICROSECONDS_PER_MICROSECOND  ((uint8_t)  (1))

#define MILLISECONDS_PER_MILLISECOND  ((uint8_t)  (1))

#define SECONDS_PER_SECOND            ((uint8_t)  (1))

#define MINUTES_PER_MINUTE            ((uint8_t)  (1))

#define HOURS_PER_HOUR                ((uint8_t)  (1))

#define DAYS_PER_DAY                  ((uint8_t)  (1))

#define WEEKS_PER_WEEK                ((uint8_t)  (1))

#define MONTHS_PER_MONTH              ((uint8_t)  (1))

#define YEARS_PER_YEAR                ((uint8_t)  (1))

#define DECADES_PER_DECADE            ((uint8_t)  (1))

#define CENTURIES_PER_CENTURY         ((uint8_t)  (1))

#define MILLENIUMS_PER_MILLENIUM      ((uint8_t)  (1))

#define MICROSECONDS_PER_MILLISECOND  ((uint16_t) (1000))

#define MILLISECONDS_PER_SECOND       ((uint16_t) (1000))

#define SECONDS_PER_MINUTE            ((uint8_t)  (60))

#define MINUTES_PER_HOUR              ((uint8_t)  (60))

#define HOURS_PER_DAY                 ((uint8_t)  (24))

#define DAYS_PER_WEEK                 ((uint8_t)  (7))

#define DAYS_PER_YEAR                 ((float)    (365.25f))

#define MONTHS_PER_YEAR               ((uint8_t)  (12))

#define YEARS_PER_DECADE              ((uint8_t)  (10))

#define DECADES_PER_CENTURY           ((uint8_t)  (10))

#define CENTURIES_PER_MILLENIUM       ((uint8_t)  (10))

#define MICROSECONDS_PER_SECOND       ((uint32_t) ((uint32_t)MICROSECONDS_PER_MILLISECOND * (uint32_t)MILLISECONDS_PER_SECOND))

#define MILLISECONDS_PER_MINUTE       ((uint16_t) ((uint16_t)MILLISECONDS_PER_SECOND * (uint16_t)SECONDS_PER_MINUTE))

#define SECONDS_PER_HOUR              ((uint16_t) ((uint16_t)SECONDS_PER_MINUTE * (uint16_t)MINUTES_PER_HOUR))

#define MINUTES_PER_DAY               ((uint16_t) ((uint16_t)MINUTES_PER_HOUR * (uint16_t)HOURS_PER_DAY))

#define HOURS_PER_WEEK                ((uint8_t)  (HOURS_PER_DAY * DAYS_PER_WEEK))

#define HOURS_PER_YEAR                ((uint16_t) ((float)HOURS_PER_DAY * DAYS_PER_YEAR))

#define DAYS_PER_MONTH                ((float)    (DAYS_PER_YEAR / (float)MONTHS_PER_YEAR))

#define DAYS_PER_DECADE               ((float)    (DAYS_PER_YEAR * (float)YEARS_PER_DECADE))

#define WEEKS_PER_YEAR                ((float)    (DAYS_PER_YEAR / (float)DAYS_PER_WEEK))

#define MONTHS_PER_DECADE             ((uint8_t)  (MONTHS_PER_YEAR * YEARS_PER_DECADE))

#define YEARS_PER_CENTURY             ((uint8_t)  (YEARS_PER_DECADE * DECADES_PER_CENTURY))

#define DECADES_PER_MILLENIUM         ((uint8_t)  (DECADES_PER_CENTURY * CENTURIES_PER_MILLENIUM))

#define MICROSECONDS_PER_MINUTE       ((uint32_t) ((uint32_t)MICROSECONDS_PER_MILLISECOND * (uint32_t)MILLISECONDS_PER_MINUTE))

#define MILLISECONDS_PER_HOUR         ((uint32_t) ((uint32_t)MILLISECONDS_PER_SECOND * (uint32_t)SECONDS_PER_HOUR))

#define SECONDS_PER_DAY               ((uint32_t) ((uint32_t)SECONDS_PER_MINUTE * (uint32_t)MINUTES_PER_DAY))

#define MINUTES_PER_WEEK              ((uint16_t) ((uint16_t)MINUTES_PER_HOUR * (uint16_t)HOURS_PER_WEEK))

#define HOURS_PER_MONTH               ((float)    ((float)HOURS_PER_DAY * DAYS_PER_MONTH))

#define HOURS_PER_DECADE              ((uint32_t) ((float)HOURS_PER_DAY * DAYS_PER_DECADE))

#define MINUTES_PER_YEAR              ((uint32_t) ((uint32_t)MINUTES_PER_HOUR * (uint32_t)HOURS_PER_YEAR))

#define DAYS_PER_CENTURY              ((uint16_t) (DAYS_PER_YEAR * (float)YEARS_PER_CENTURY))

#define WEEKS_PER_MONTH               ((float)    (DAYS_PER_MONTH / (float)DAYS_PER_WEEK))

#define WEEKS_PER_DECADE              ((float)    (DAYS_PER_DECADE / (float)DAYS_PER_WEEK))

#define MONTHS_PER_CENTURY            ((uint16_t) ((uint16_t)MONTHS_PER_YEAR * (uint16_t)YEARS_PER_CENTURY))

#define YEARS_PER_MILLENIUM           ((uint16_t) ((uint16_t)YEARS_PER_DECADE * (uint16_t)DECADES_PER_MILLENIUM))

#define MICROSECONDS_PER_HOUR         ((uint32_t) ((uint32_t)MICROSECONDS_PER_MILLISECOND * MILLISECONDS_PER_HOUR))

#define MILLISECONDS_PER_DAY          ((uint32_t) ((uint32_t)MILLISECONDS_PER_SECOND * SECONDS_PER_DAY))

#define SECONDS_PER_WEEK              ((uint32_t) (SECONDS_PER_MINUTE * (uint32_t)MINUTES_PER_WEEK))

#define SECONDS_PER_YEAR              ((uint32_t) (SECONDS_PER_MINUTE * MINUTES_PER_YEAR))

#define MINUTES_PER_MONTH             ((uint16_t) ((float)MINUTES_PER_HOUR * HOURS_PER_MONTH))

#define MINUTES_PER_DECADE            ((uint32_t) ((uint32_t)MINUTES_PER_HOUR * HOURS_PER_DECADE))

#define HOURS_PER_CENTURY             ((uint32_t) ((uint32_t)HOURS_PER_DAY * (uint32_t)DAYS_PER_CENTURY))

#define DAYS_PER_MILLENIUM            ((uint32_t) (DAYS_PER_YEAR * (float)YEARS_PER_MILLENIUM))