/ - Diff - AMiRo-OS - Research for Cognitive Interaction

Revision ba516b61

     #include "core/inc/aos_confcheck.h"
     #include "core/inc/aos_debug.h"
     #include <core/inc/aos_iostream.h>
     #include "core/inc/aos_shell.h"
     #include "core/inc/aos_ssm.h"
     #include "core/inc/aos_system.h"
     #include "core/inc/aos_thread.h"
     #include "core/inc/aos_time.h"

     # 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_ssm.c \
                       $(AMIROOS_CORE_DIR)src/aos_system.c \
                       $(AMIROOS_CORE_DIR)src/aos_thread.c \
                       $(AMIROOS_CORE_DIR)src/aos_timer.c \

     /*
     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_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 output.
      */
     #define AOS_IOCHANNEL_OUTPUT_ENABLE             (1 << 1)
     /*
      * 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 aosIOChannelOutputEnable(AosIOChannel* channel);
       void aosIOChannelOutputDisable(AosIOChannel* channel);
     #ifdef __cplusplus
+    }
     #endif
     #endif /* _AMIROOS_IOSTREAM_H_ */

     #ifndef _AMIROOS_SHELL_H_
     #define _AMIROOS_SHELL_H_
     #include <aosconf.h>
     #if (AMIROOS_CFG_SHELL_ENABLE == true)
     #include <hal.h>
     #include <aos_types.h>
     #include <aos_iostream.h>
     /**
      * @brief   Shell event flag that is emitted when the thread starts.
      */
     #define AOS_SHELL_EVTFLAG_START                 ((eventflags_t)(1 << 0))
     #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))
     #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))
     #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))
     #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))
     #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)
     #define AOS_SHELL_CONFIG_INPUT_OVERWRITE          (1 << 0)
     /**
      * @brief   Shell prompt configuration print a minimalistic prompt.
      */
     #define AOS_SHELL_CONFIG_PROMPT_MINIMAL         (1 << 1)
     #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)
     #define AOS_SHELL_CONFIG_PROMPT_UPTIME            (1 << 2)
     /**
      * @brief   Shell prompt configuration to additionally print the system uptime with the prompt.
      */
     #define AOS_SHELL_CONFIG_MATCH_CASE             (1 << 3)
     #define AOS_SHELL_CONFIG_MATCH_CASE               (1 << 3)
     /**
      * @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 AosIOChannel object */                                    \
       AosIOChannel* iochannel;                                                  \
       /* 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.
-...
        * @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 {
       aos_shellcommand_t* command;  /**< Pointer to the command that was executed. */
       int retval;                   /**< Return value of the executed command. */
       /**
        * @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_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_SHELL_ACTION_NONE,
     } aos_shellaction_t;
     /**
      * @brief   Shell structure.
      */
     typedef struct aos_shell {
-...
       event_source_t eventSource;
       /**
        * @brief   Stream for user I/O.
        * @brief   Struct for OS related events
        */
       BaseSequentialStream* stream;
       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.
-...
       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;
-...
     #ifdef __cplusplus
     extern "C" {
     #endif
       void aosShellInit(aos_shell_t* shell, BaseSequentialStream* stream, const char* prompt, char* line, size_t linesize, char** arglist, size_t arglistsize);
       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, AosIOChannel* iochannel);
       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/>.
     */
     #ifndef _AMIROOS_SSM_H_
     #define _AMIROOS_SSM_H_
     #include <hal.h>
     #include <aos_types.h>
     #include <aos_debug.h>
     /**
      * @brief   Sequential Stream Multiplexer output structure.
      */
     typedef struct ssm_output {
       /**
        * @brief   Pointer to a BaseSequentialStream object.
        */
       BaseSequentialStream* stream;
       /**
        * @brief   Pointer to the next element in a singly linked list.
        */
       struct ssm_output* next;
       /**
        * @brief   Flags related to the output.
        */
       uint8_t flags;
     } ssm_output_t;
     /**
      * @brief   Output flag to indicate whether the output is attached to a SSM list.
      */
     #define SSM_OUTPUT_FLAG_ATTACHED                (1 << 0)
     /**
      * @brief   Output flag to indicate whether the output is enabled.
      */
     #define SSM_OUTPUT_FLAG_ENABLED                 (1 << 1)
     /**
      * @brief   Sequential Stream Multiplexer specific methods.
      */
     #define _sequential_stream_mux_methods          \
       _base_sequential_stream_methods               \
     /**
      * @brief   Sequential Stream Multiplexer specific data.
      */
     #define _sequential_stream_mux_data             \
       _base_sequential_stream_data                  \
       ssm_output_t* outputs;                        \
       BaseSequentialStream* input;                  \
     /**
      * @brief   Sequential Stream Multiplexer virtual methods table.
      */
     struct SequentialStreamMuxVMT {
       _sequential_stream_mux_methods
     };
     /**
      * @brief   Sequential Stream Multiplexer structure.
      */
     typedef struct {
       /**
        * @brief   Virtual methods table.
        */
       const struct SequentialStreamMuxVMT *vmt;
       /**
        * @brief   Data fields.
        */
       _sequential_stream_mux_data
     } SequentialStreamMux;
     #ifdef __cplusplus
     extern "C" {
     #endif
       void ssmObjectInit(SequentialStreamMux* ssmp);
       void ssmOutputInit(ssm_output_t* op, BaseSequentialStream* stream);
       void ssmAddOutput(SequentialStreamMux* ssmp, ssm_output_t* output);
       aos_status_t ssmRemoveOutput(SequentialStreamMux* ssmp, BaseSequentialStream* stream, ssm_output_t** removed);
       aos_status_t ssmEnableOutput(SequentialStreamMux* ssmp, BaseSequentialStream* stream);
       aos_status_t ssmDisableOutput(SequentialStreamMux* ssmp, BaseSequentialStream* stream);
     #ifdef __cplusplus
+    }
     #endif
     /**
      * @brief   Set the input stream
+     *
      * @param[in] ssmp    pointer to the @p SequentialStreamMux object
      * @param[in] stream  pointer to a @p BaseSequentialStream or NULL to disable input
      */
     static inline void ssmSetInput(SequentialStreamMux* ssmp, BaseSequentialStream* stream)
+    {
       aosDbgCheck(ssmp != NULL);
       ssmp->input = stream;
       return;
+    }
     #endif /* _AMIROOS_SSM_H_ */

     #ifndef _AMIROOS_SYSTEM_H_
     #define _AMIROOS_SYSTEM_H_
     #include <aos_ssm.h>
     #include <aos_iostream.h>
     #include <amiro-lld.h>
     #include <aos_shell.h>
     #include <aos_time.h>
     #include <chprintf.h>
     /**
      * @brief   Default system I/O stream.
      */
     #define AOS_SYSTEM_STDIO                        ((BaseSequentialStream*)aos.ssm)
     /**
      * @brief   Printf function that uses the default system I/O stream.
      * @brief   Resolution of the system time measurement.
      */
     #define aosprintf(fmt, ...)                     chprintf((BaseSequentialStream*)AOS_SYSTEM_STDIO, fmt, ##__VA_ARGS__)
     #define AOS_SYSTEM_TIME_RESOLUTION              ((MICROSECONDS_PER_SECOND + CH_CFG_ST_FREQUENCY - 1) / CH_CFG_ST_FREQUENCY)
     /**
      * @brief   Resolution of the system time measurement.
      * @brief   System event flag which is emitted when a shutdown was initiated.
      */
     #define AOS_SYSTEM_TIME_RESOLUTION              ((MICROSECONDS_PER_SECOND + CH_CFG_ST_FREQUENCY - 1) / CH_CFG_ST_FREQUENCY)
     #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    (eventflags_t)(1 << 0)
     #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         (eventflags_t)(1 << 1)
     #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         (eventflags_t)(1 << 2)
     #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           (eventflags_t)(1 << 3)
     #define AOS_SYSTEM_EVENTFLAGS_RESTART           (AOS_SYSTEM_EVENTFLAGS_SHUTDOWN | (eventflags_t)(1 << 4))
     /**
      * @brief   Major version of the implemented SSSP.
-...
       aos_ssspstage_t ssspStage;
       /**
        * @brief   System I/O stream.
        */
       AosIOStream iostream;
       /**
        * @brief   Event structure.
        */
       struct {
-...
         } os;
       } events;
       /**
        * @brief   Sequentiel Stream Multiplexer for system I/O
        */
       SequentialStreamMux* ssm;
     #if (AMIROOS_CFG_SHELL_ENABLE == true) || defined(__DOXYGEN__)
       /**
        * @brief   Pointer to the shell object.
-...
      */
     extern aos_system_t aos;
     /**
      * @brief   Printf function that uses the default system I/O stream.
      */
     #define aosprintf(fmt, ...)                     chprintf((BaseSequentialStream*)&aos.iostream, fmt, ##__VA_ARGS__)
     #ifdef __cplusplus
     extern "C" {
     #endif

     /*
     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/>.
     */
     #include <aos_iostream.h>
     #include <aos_debug.h>
     #include <chprintf.h>
     /**
      * @brief   Implementation of the BaseAsynchronousChannel write() method (inherited from BaseSequentialStream).
      */
     static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n)
+    {
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_OUTPUT_ENABLE) {
         return streamWrite(((AosIOChannel*)instance)->asyncchannel, bp, n);
       } else {
         return 0;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronousChannel read() method (inherited from BaseSequentialStream).
      */
     static size_t _channelread(void *instance, uint8_t *bp, size_t n)
+    {
       return streamRead(((AosIOChannel*)instance)->asyncchannel, bp, n);
+    }
     /**
      * @brief   Implementation of the BaseAsynchronousChannel put() method (inherited from BaseSequentialStream).
      */
     static msg_t _channelput(void *instance, uint8_t b)
+    {
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_OUTPUT_ENABLE) {
         return streamPut(((AosIOChannel*)instance)->asyncchannel, b);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronousChannel get() method (inherited from BaseSequentialStream).
      */
     static msg_t _channelget(void *instance)
+    {
       return streamGet(((AosIOChannel*)instance)->asyncchannel);
+    }
     /**
      * @brief   Implementation of the BaseAsynchronousChannel putt() method.
      */
     static msg_t _channelputt(void *instance, uint8_t b, systime_t time)
+    {
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_OUTPUT_ENABLE) {
         return chnPutTimeout(((AosIOChannel*)instance)->asyncchannel, b, time);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronousChannel gett() method.
      */
     static msg_t _channelgett(void *instance, systime_t time)
+    {
       return chnGetTimeout(((AosIOChannel*)instance)->asyncchannel, time);
+    }
     /**
      * @brief   Implementation of the BaseAsynchronousChannel writet() method.
      */
     static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, systime_t time)
+    {
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_OUTPUT_ENABLE) {
         return chnWriteTimeout(((AosIOChannel*)instance)->asyncchannel, bp, n, time);
       } else {
         return 0;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronousChannel readt() method.
      */
     static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, systime_t time)
+    {
       return chnReadTimeout(((AosIOChannel*)instance)->asyncchannel, bp, n, time);
+    }
     /**
      * @brief   Virtual methods table for all AosIOChannel objects.
      */
     static const struct AosIOChannelVMT _channelvmt = {
       _channelwrite,
       _channelread,
       _channelput,
       _channelget,
       _channelputt,
       _channelgett,
       _channelwritet,
       _channelreadt,
     };
     /**
      * @brief   Implementation of the BaseSequentialStream write() method.
      */
     static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n)
+    {
       aosDbgCheck(instance != NULL);
       // local variables
       AosIOChannel* channel = ((AosIOStream*)instance)->channel;
       size_t bytes;
       size_t maxbytes = 0;
       // iterate through the list of channels
       while (channel != NULL) {
         bytes = streamWrite(channel, bp, n);
         maxbytes = (bytes > maxbytes) ? bytes : maxbytes;
         channel = channel->next;
+      }
       return maxbytes;
+    }
     /**
      * @brief   Implementation of the BaseSequentialStream read() method.
      */
     static size_t _stremread(void *instance, uint8_t *bp, size_t n)
+    {
       (void)instance;
       (void)bp;
       (void)n;
       return 0;
+    }
     /**
      * @brief   Implementation of the BaseSequentialStream put() method.
      */
     static msg_t _streamput(void *instance, uint8_t b)
+    {
       aosDbgCheck(instance != NULL);
       // local variables
       AosIOChannel* channel = ((AosIOStream*)instance)->channel;
       msg_t ret;
       // iterate through the list of channels
       while (channel != NULL) {
         ret = streamPut(channel, b);
         if (ret != MSG_OK) {
           return ret;
+        }
         channel = channel->next;
+      }
       return MSG_OK;
+    }
     /**
      * @brief   Implementation of the BaseSequentialStream get() method.
      */
     static msg_t _streamget(void *instance)
+    {
       (void)instance;
       return 0;
+    }
     /**
      * @brief   Virtual methods table for all AosIOStream objects.
      */
     static const struct AosIOStreamVMT _streamvmt = {
       _streamwrite,
       _stremread,
       _streamput,
       _streamget,
     };
     /**
      * @brief   Initializes an aos_iostream_t object.
+     *
      * @param[in] stream    Th aos_iostream_t object to initialize.
      */
     void aosIOStreamInit(AosIOStream* stream)
+    {
       aosDbgCheck(stream != NULL);
       stream->vmt = &_streamvmt;
       stream->channel = NULL;
       return;
+    }
     /**
      * @brief   Initializes an aos_iostream_channel_t object.
+     *
      * @param[in] channel       The aos_iostream_channel_t to initialize.
      * @param[in] asyncchannel  The BaseAsynchronousChannel object to associate with te channel.
      */
     void aosIOChannelInit(AosIOChannel *channel, BaseAsynchronousChannel *asyncchannel)
+    {
       aosDbgCheck(channel != NULL);
       aosDbgCheck(asyncchannel != NULL);
       channel->vmt = &_channelvmt;
       channel->asyncchannel = asyncchannel;
       channel->next = NULL;
       channel->flags = 0;
       return;
+    }
     /**
      * @brief   Adds a channel to a stream.
+     *
      * @param[in] stream    The stream to be expanded.
      * @param[in] channel   The channel to be added.
      */
     void aosIOStreamAddChannel(AosIOStream *stream, AosIOChannel* channel)
+    {
       aosDbgCheck(stream != NULL);
       aosDbgCheck(channel != NULL && channel->asyncchannel != NULL && channel->next == NULL && (channel->flags & AOS_IOCHANNEL_ATTACHED) == 0);
       // prepend the new channel
       chSysLock();
       channel->flags |= AOS_IOCHANNEL_ATTACHED;
       channel->next = stream->channel;
       stream->channel = channel;
       chSysUnlock();
       return;
+    }
     /**
      * @brief   Removes a channel from a stream.
+     *
      * @param[in] stream        The stream to remove the channel from.
      * @param[in] asyncchannel  The BaseAsynchronousChannel to remove.
      * @param[out] removed      Pointer to the removed aos_iostream_channel_t.
      * @return
      */
     aos_status_t aosIOStreamRemoveChannel(AosIOStream* stream, AosIOChannel* channel)
+    {
       aosDbgCheck(stream != NULL);
       aosDbgCheck(channel != NULL);
       // local variables
       AosIOChannel* prev = NULL;
       AosIOChannel* curr = stream->channel;
       // iterate through the list and search for the specified channel
       while (curr != NULL) {
         // if the channel was found, remove it
         if (curr == channel) {
           chSysLock();
           // special case: the first channel matches (prev is NULL)
           if (prev == NULL) {
             stream->channel = curr->next;
           } else {
             prev->next = curr->next;
+          }
           curr->next = NULL;
           curr->flags &= ~AOS_IOCHANNEL_ATTACHED;
           chSysUnlock();
           return AOS_SUCCESS;
+        }
         // iterate to the next channel
         else {
           prev = curr;
           curr = curr->next;
+        }
+      }
       // if the channel was not found, return an error
       return AOS_ERROR;
+    }
     /**
      * @brief   Enable output for a AosIOChannel.
+     *
      * @param[in] channel   The AosIOChannel to enable as output.
      */
     void aosIOChannelOutputEnable(AosIOChannel* channel)
+    {
       aosDbgCheck(channel != NULL);
       channel->flags |= AOS_IOCHANNEL_OUTPUT_ENABLE;
       return;
+    }
     /**
      * @brief   Disable output for a AosIOChannel.
+     *
      * @param[in] channel   The AosIOChannel to disable as output.
      */
     void aosIOChannelOutputDisable(AosIOChannel* channel)
+    {
       aosDbgCheck(channel != NULL);
       channel->flags &= ~AOS_IOCHANNEL_OUTPUT_ENABLE;
       return;
+    }

     #include <aos_shell.h>
     #if (AMIROOS_CFG_SHELL_ENABLE == true)
     #include <aos_debug.h>
     #include <aos_time.h>
     #include <aos_system.h>
-...
     #include <string.h>
     #include <aos_thread.h>
     /**
      * @brief   Event mask to be set on OS related events.
      */
     #define AOS_SHELL_EVENTMASK_OS                  EVENT_MASK(0)
     /**
      * @brief   Event mask to be set on a input event.
      */
     #define AOS_SHELL_EVENTMASK_INPUT               EVENT_MASK(1)
     /**
      * @brief   Implementation of the BaseAsynchronous write() method (inherited from BaseSequentialStream).
      */
     static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n)
+    {
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
         return streamWrite(((AosShellChannel*)instance)->iochannel->asyncchannel, bp, n);
       } else {
         return 0;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronous read() method (inherited from BaseSequentialStream).
      */
     static size_t _channelread(void *instance, uint8_t *bp, size_t n)
+    {
       return streamRead(((AosShellChannel*)instance)->iochannel->asyncchannel, bp, n);
+    }
     /**
      * @brief   Implementation of the BaseAsynchronous put() method (inherited from BaseSequentialStream).
      */
     static msg_t _channelput(void *instance, uint8_t b)
+    {
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
         return streamPut(((AosShellChannel*)instance)->iochannel->asyncchannel, b);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronous get() method (inherited from BaseSequentialStream).
      */
     static msg_t _channelget(void *instance)
+    {
       return streamGet(((AosShellChannel*)instance)->iochannel->asyncchannel);
+    }
     /**
      * @brief   Implementation of the BaseAsynchronous putt() method.
      */
     static msg_t _channelputt(void *instance, uint8_t b, systime_t time)
+    {
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
         return chnPutTimeout(((AosShellChannel*)instance)->iochannel->asyncchannel, b, time);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronous gett() method.
      */
     static msg_t _channelgett(void *instance, systime_t time)
+    {
       return chnGetTimeout(((AosShellChannel*)instance)->iochannel->asyncchannel, time);
+    }
     /**
      * @brief   Implementation of the BaseAsynchronous writet() method.
      */
     static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, systime_t time)
+    {
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
         return chnWriteTimeout(((AosShellChannel*)instance)->iochannel->asyncchannel, bp, n, time);
       } else {
         return 0;
+      }
+    }
     /**
      * @brief   Implementation of the BaseAsynchronous readt() method.
      */
     static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, systime_t time)
+    {
       return chnReadTimeout(((AosShellChannel*)instance)->iochannel->asyncchannel, bp, n, time);
+    }
     static const struct AosShellChannelVMT _channelvmt = {
       _channelwrite,
       _channelread,
       _channelput,
       _channelget,
       _channelputt,
       _channelgett,
       _channelwritet,
       _channelreadt,
     };
     static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n)
+    {
       aosDbgCheck(instance != NULL);
       // local variables
       AosShellChannel* channel = ((AosShellStream*)instance)->channel;
       size_t bytes;
       size_t maxbytes = 0;
       // iterate through the list of channels
       while (channel != NULL) {
         bytes = streamWrite(channel, bp, n);
         maxbytes = (bytes > maxbytes) ? bytes : maxbytes;
         channel = channel->next;
+      }
       return maxbytes;
+    }
     static size_t _stremread(void *instance, uint8_t *bp, size_t n)
+    {
       (void)instance;
       (void)bp;
       (void)n;
       return 0;
+    }
     static msg_t _streamput(void *instance, uint8_t b)
+    {
       aosDbgCheck(instance != NULL);
       // local variables
       AosShellChannel* channel = ((AosShellStream*)instance)->channel;
       msg_t ret;
       // iterate through the list of channels
       while (channel != NULL) {
         ret = streamPut(channel, b);
         if (ret != MSG_OK) {
           return ret;
+        }
         channel = channel->next;
+      }
       return MSG_OK;
+    }
     static msg_t _streamget(void *instance)
+    {
       (void)instance;
       return 0;
+    }
     static const struct AosShellStreamVMT _streamvmt = {
       _streamwrite,
       _stremread,
       _streamput,
       _streamget,
     };
     /**
      * @brief   Enumerator of special keyboard keys.
      */
-...
     static void _printPrompt(aos_shell_t* shell)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(shell->stream != NULL);
       // print the system uptime before prompt is configured
       if (shell->config & AOS_SHELL_CONFIG_PROMPT_UPTIME) {
-...
         aos_timestamp_t uptime;
         aosSysGetUptime(&uptime);
         chprintf(shell->stream, "[%01u:%02u:%02u:%02u:%03u:%03u] ",
                (uint32_t)(uptime / MICROSECONDS_PER_DAY),
                (uint8_t)(uptime % MICROSECONDS_PER_DAY / MICROSECONDS_PER_HOUR),
                (uint8_t)(uptime % MICROSECONDS_PER_HOUR / MICROSECONDS_PER_MINUTE),
                (uint8_t)(uptime % MICROSECONDS_PER_MINUTE / MICROSECONDS_PER_SECOND),
                (uint16_t)(uptime % MICROSECONDS_PER_SECOND / MICROSECONDS_PER_MILLISECOND),
                (uint16_t)(uptime % MICROSECONDS_PER_MILLISECOND / MICROSECONDS_PER_MICROSECOND));
         chprintf((BaseSequentialStream*)&shell->stream, "[%01u:%02u:%02u:%02u:%03u:%03u] ",
                  (uint32_t)(uptime / MICROSECONDS_PER_DAY),
                  (uint8_t)(uptime % MICROSECONDS_PER_DAY / MICROSECONDS_PER_HOUR),
                  (uint8_t)(uptime % MICROSECONDS_PER_HOUR / MICROSECONDS_PER_MINUTE),
                  (uint8_t)(uptime % MICROSECONDS_PER_MINUTE / MICROSECONDS_PER_SECOND),
                  (uint16_t)(uptime % MICROSECONDS_PER_SECOND / MICROSECONDS_PER_MILLISECOND),
                  (uint16_t)(uptime % MICROSECONDS_PER_MILLISECOND / MICROSECONDS_PER_MICROSECOND));
+      }
       // print the actual prompt string
       if (shell->prompt && !(shell->config & AOS_SHELL_CONFIG_PROMPT_MINIMAL)) {
         chprintf(shell->stream, "%s$ ", shell->prompt);
         chprintf((BaseSequentialStream*)&shell->stream, "%s$ ", shell->prompt);
       } else {
         chprintf(shell->stream, "%>$ ");
         chprintf((BaseSequentialStream*)&shell->stream, "%>$ ");
+      }
       return;
-...
     static int _moveCursor(aos_shell_t* shell, const size_t from, const size_t to)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(shell->stream != NULL);
       // local variables
       size_t pos = from;
       // move cursor left by printing backspaces
       while (pos > to) {
         streamPut(shell->stream, '\b');
         streamPut(&shell->stream, '\b');
         --pos;
+      }
       // move cursor right by printing line content
       while (pos < to) {
         streamPut(shell->stream, shell->line[pos]);
         streamPut(&shell->stream, shell->line[pos]);
         ++pos;
+      }
-...
     static inline size_t _printLine(aos_shell_t* shell, const size_t from, const size_t to)
+    {
       aosDbgCheck(shell != NULL);
       aosDbgCheck(shell->stream != NULL);
       // local variables
       size_t cnt;
       for (cnt = 0; from + cnt < to; ++cnt) {
         streamPut(shell->stream, shell->line[from + cnt]);
         streamPut(&shell->stream, shell->line[from + cnt]);
+      }
       return cnt;
-...
       return _mapAscii2Custom(str1[i]) - _mapAscii2Custom(str2[i]);
+    }
     /**
      * @brief   Reads a line from input stream
      * @details The line is directly written to the given shell object.
+     *
      * @param[in] shell   Pointer to the shell object.
+     *
      * @return              A status indicator.
      * @retval AOS_SUCCESS  Input sucessfully read, line is valid.
      * @retval AOS_ERROR    An I/O error occurred.
      */
     static aos_status_t _readLine(aos_shell_t* shell)
     static aos_status_t _readChannel(aos_shell_t* shell, AosShellChannel* channel, size_t* n)
+    {
       aosDbgCheck(shell != NULL);
       /*
        * Enumerator to encode a function.
        */
       typedef enum {
         READ_CHAR,
         AUTOFILL,
         SUGGEST,
         INS_TOGGLE,
         DELETE_FORWARD,
         DELETE_BACKWARD,
         RECALL_LAST,
         CLEAR,
         CURSOR2START,
         CURSOR2END,
         CURSOR_LEFT,
         CURSOR_RIGHT,
         EXECUTE,
         ESC_START,
         NONE,
       } func_t;
       aosDbgCheck(channel != NULL);
       aosDbgCheck(n != NULL);
       // local variables
       func_t func = NONE;
       func_t lastfunc = NONE;
       bool noinput = true;
       size_t lineend = 0;
       size_t cursorpos = 0;
       aos_shellaction_t action = AOS_SHELL_ACTION_NONE;
       char c;
       uint8_t escp = 0;
       char escseq[5] = {'\0'};
       // read character by character from stream
       while (streamRead(shell->stream, (uint8_t*)&c, 1)) {
       // initialize output variables
       *n = 0;
       // read character by character from the channel
       while (chnReadTimeout(channel, (uint8_t*)&c, 1, TIME_IMMEDIATE)) {
         special_key_t key = KEY_UNKNOWN;
         // parse escape sequence
         if (escp > 0) {
           escseq[escp] = c;
           ++escp;
           key = _interpreteEscapeSequence(escseq);
         if (shell->inputdata.escp > 0) {
           shell->inputdata.escseq[shell->inputdata.escp] = c;
           ++shell->inputdata.escp;
           key = _interpreteEscapeSequence(shell->inputdata.escseq);
           if (key == KEY_AMBIGUOUS) {
             // read next byte to resolve ambiguity
             continue;
           } else {
             // if the escape sequence could either be parsed sucessfully
             // or there is no match (KEY_UNKNOWN),
             // reset the sequence variables and interprete key/character
             escp = 0;
             memset(escseq, '\0', sizeof(escseq));
             /*
              * If the escape sequence could either be parsed sucessfully
              * or there is no match (KEY_UNKNOWN),
              * reset the sequence variable and interprete key/character
              */
             shell->inputdata.escp = 0;
             memset(shell->inputdata.escseq, '\0', sizeof(shell->inputdata.escseq)*sizeof(shell->inputdata.escseq[0]));
+          }
+        }
         // interprete keys or characters
         /* interprete keys or character */
+        {
           func = NONE; // default
           if (key == KEY_UNKNOWN &&
               (/* printable character */ c >= '\x20' && c <= '\x7E') ) {
             func = READ_CHAR;
           } else if (key == KEY_TAB ||
                      /* horizontal tab ('\t') */ c == '\x09') {
             // pressing tab once applies auto fill,
             // presing a second time prints suggestions
             if (lastfunc == AUTOFILL || lastfunc == SUGGEST) {
               func = SUGGEST;
           // default
           action = AOS_SHELL_ACTION_NONE;
           // printable character
           if (key == KEY_UNKNOWN && c >= '\x20' && c <= '\x7E') {
             action = AOS_SHELL_ACTION_READCHAR;
+          }
           // tab key or character
           else if (key == KEY_TAB || c == '\x09') {
             /*
              * pressing tab once applies auto fill
              * pressing tab a second time prints suggestions
              */
             if (shell->inputdata.lastaction == AOS_SHELL_ACTION_AUTOFILL || shell->inputdata.lastaction == AOS_SHELL_ACTION_SUGGEST) {
               action = AOS_SHELL_ACTION_SUGGEST;
             } else {
               func = AUTOFILL;
               action = AOS_SHELL_ACTION_AUTOFILL;
+            }
           } else if (key == KEY_INSERT) {
             func = INS_TOGGLE;
           } else if (key == KEY_DELETE ||
                      /* [DEL] */ c == '\x7F') {
             // ignore of cursor is very right
             if (cursorpos < lineend) {
               func = DELETE_FORWARD;
+          }
           // INS key
           else if (key == KEY_INSERT) {
             action = AOS_SHELL_ACTION_INSERTTOGGLE;
+          }
           // DEL key or character
           else if (key == KEY_DELETE || c == '\x7F') {
             // ignore if cursor is at very right
             if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
               action = AOS_SHELL_ACTION_DELETEFORWARD;
+            }
           } else if (key == KEY_BACKSPACE ||
                      /* backpace ('\b') */c == '\x08') {
             // ignore if cursor is very left
             if (cursorpos > 0) {
               func = DELETE_BACKWARD;
+          }
           // backspace key or character
           else if (key == KEY_BACKSPACE || c == '\x08') {
             // ignore if cursor is at very left
             if (shell->inputdata.cursorpos > 0) {
               action = AOS_SHELL_ACTION_DELETEBACKWARD;
+            }
           } else if (key == KEY_PAGE_UP ||
                      key == KEY_ARROW_UP) {
+          }
           // 'page up' of 'arrow up' key
           else if (key == KEY_PAGE_UP || key == KEY_ARROW_UP) {
             // ignore if there was some input
             if (noinput) {
               func = RECALL_LAST;
             if (shell->inputdata.noinput) {
               action = AOS_SHELL_ACTION_RECALLLAST;
+            }
           } else if (key == KEY_PAGE_DOWN ||
                      key == KEY_ARROW_DOWN ||
                      /* end of test */ c == '\x03' ||
                      /* end of transmission */ c == '\x04') {
+          }
           // 'page down' key, 'arrow done' key, 'end of test' character or 'end of transmission' character
           else if (key == KEY_PAGE_DOWN || key == KEY_ARROW_DOWN || c == '\x03' || c == '\x03') {
             // ignore if line is empty
             if (lineend > 0) {
               func = CLEAR;
             if (shell->inputdata.lineend > 0) {
               action = AOS_SHELL_ACTION_CLEAR;
+            }
           } else if (key == KEY_HOME) {
+          }
           // 'home' key
           else if (key == KEY_HOME) {
             // ignore if cursor is very left
             if (cursorpos > 0) {
               func = CURSOR2START;
             if (shell->inputdata.cursorpos > 0) {
               action = AOS_SHELL_ACTION_CURSOR2START;
+            }
           } else if (key == KEY_END) {
             // ignore if cursor is very right
             if (cursorpos < lineend) {
               func = CURSOR2END;
+          }
           // 'end' key
           else if (key == KEY_END) {
             // ignore if cursos is very right
             if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
               action = AOS_SHELL_ACTION_CURSOR2END;
+            }
           } else if (key == KEY_ARROW_LEFT) {
+          }

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff