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

Revision dd8738ea

     #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 << 1)
     #define AOS_IOCHANNEL_OUTPUT_ENABLE             (1 << 2)
     /*
      * forward definitions
-...
       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

     #include <hal.h>
     #include <aos_types.h>
     #include <aos_iostream.h>
     //#include <aos_iostream.h>
     /**
      * @brief   Shell event flag that is emitted when the thread starts.
-...
      * @brief   AosShellChannel specific data.
      */
     #define _aos_shell_channel_data                                             \
       /* pointer to a AosIOChannel object */                                    \
       AosIOChannel* iochannel;                                                  \
       /* 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 */                     \
-...
      * @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_CURSORRIGHT,
       AOS_SHELL_ACTION_EXECUTE,
       AOS_SHELL_ACTION_ESCSTART,
       AOS_SHELL_ACTION_NONE,
     } aos_shellaction_t;
     /**
-...
     #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, AosIOChannel* iochannel);
       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);

      */
     static size_t _channelread(void *instance, uint8_t *bp, size_t n)
+    {
       return streamRead(((AosIOChannel*)instance)->asyncchannel, bp, n);
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_INPUT_ENABLE) {
         return streamRead(((AosIOChannel*)instance)->asyncchannel, bp, n);
       } else {
         return 0;
+      }
+    }
     /**
-...
      */
     static msg_t _channelget(void *instance)
+    {
       return streamGet(((AosIOChannel*)instance)->asyncchannel);
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_INPUT_ENABLE) {
         return streamGet(((AosIOChannel*)instance)->asyncchannel);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
-...
      */
     static msg_t _channelgett(void *instance, systime_t time)
+    {
       return chnGetTimeout(((AosIOChannel*)instance)->asyncchannel, time);
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_INPUT_ENABLE) {
         return chnGetTimeout(((AosIOChannel*)instance)->asyncchannel, time);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
-...
      */
     static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, systime_t time)
+    {
       return chnReadTimeout(((AosIOChannel*)instance)->asyncchannel, bp, n, time);
       if (((AosIOChannel*)instance)->flags & AOS_IOCHANNEL_INPUT_ENABLE) {
         return chnReadTimeout(((AosIOChannel*)instance)->asyncchannel, bp, n, time);
       } else {
         return 0;
+      }
+    }
     /**
-...
       // local variables
       AosIOChannel* channel = ((AosIOStream*)instance)->channel;
       msg_t ret;
       msg_t ret = MSG_OK;
       // iterate through the list of channels
       while (channel != NULL) {
         ret = streamPut(channel, b);
         if (ret != MSG_OK) {
           return ret;
+        }
         msg_t ret_ = streamPut(channel, b);
         ret = (ret_ < ret) ? ret_ : ret;
         channel = channel->next;
+      }
       return MSG_OK;
       return ret;
+    }
     /**
-...
+    }
     /**
      * @brief   Enable input for a AosIOChannel.
+     *
      * @param[in] channel   The AosIOChannel to enable as input.
      */
     void aosIOChannelInputEnable(AosIOChannel* channel)
+    {
       aosDbgCheck(channel != NULL);
       channel->flags |= AOS_IOCHANNEL_INPUT_ENABLE;
       return;
+    }
     /**
      * @brief   Disable input for a AosIOChannel.
+     *
      * @param[in] channel   The AosIOChannel to disable as input.
      */
     void aosIOChannelInputDisable(AosIOChannel* channel)
+    {
       aosDbgCheck(channel != NULL);
       channel->flags &= ~AOS_IOCHANNEL_INPUT_ENABLE;
       return;
+    }
     /**
      * @brief   Enable output for a AosIOChannel.
+     *
      * @param[in] channel   The AosIOChannel to enable as output.

     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);
         return streamWrite(((AosShellChannel*)instance)->asyncchannel, bp, n);
       } else {
         return 0;
+      }
-...
      */
     static size_t _channelread(void *instance, uint8_t *bp, size_t n)
+    {
       return streamRead(((AosShellChannel*)instance)->iochannel->asyncchannel, bp, n);
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
         return streamRead(((AosShellChannel*)instance)->asyncchannel, bp, n);
       } else {
         return 0;
+      }
+    }
     /**
-...
     static msg_t _channelput(void *instance, uint8_t b)
+    {
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
         return streamPut(((AosShellChannel*)instance)->iochannel->asyncchannel, b);
         return streamPut(((AosShellChannel*)instance)->asyncchannel, b);
       } else {
         return MSG_RESET;
+      }
-...
      */
     static msg_t _channelget(void *instance)
+    {
       return streamGet(((AosShellChannel*)instance)->iochannel->asyncchannel);
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
         return streamGet(((AosShellChannel*)instance)->asyncchannel);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
-...
     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);
         return chnPutTimeout(((AosShellChannel*)instance)->asyncchannel, b, time);
       } else {
         return MSG_RESET;
+      }
-...
      */
     static msg_t _channelgett(void *instance, systime_t time)
+    {
       return chnGetTimeout(((AosShellChannel*)instance)->iochannel->asyncchannel, time);
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
         return chnGetTimeout(((AosShellChannel*)instance)->asyncchannel, time);
       } else {
         return MSG_RESET;
+      }
+    }
     /**
-...
     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);
         return chnWriteTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
       } else {
         return 0;
+      }
-...
      */
     static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, systime_t time)
+    {
       return chnReadTimeout(((AosShellChannel*)instance)->iochannel->asyncchannel, bp, n, time);
       if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
         return chnReadTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
       } else {
         return 0;
+      }
+    }
     static const struct AosShellChannelVMT _channelvmt = {
-...
       // local variables
       AosShellChannel* channel = ((AosShellStream*)instance)->channel;
       msg_t ret;
       msg_t ret = MSG_OK;
       // iterate through the list of channels
       while (channel != NULL) {
         ret = streamPut(channel, b);
         if (ret != MSG_OK) {
           return ret;
+        }
         msg_t ret_ = streamPut(channel, b);
         ret = (ret_ < ret) ? ret_ : ret;
         channel = channel->next;
+      }
       return MSG_OK;
       return ret;
+    }
     static msg_t _streamget(void *instance)
-...
       // local variables
       aos_shellaction_t action = AOS_SHELL_ACTION_NONE;
       char c;
       special_key_t key;
       // 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;
         key = KEY_UNKNOWN;
         // parse escape sequence
         if (shell->inputdata.escp > 0) {
-...
     /**
      * @brief   Initialize an AosShellChannel object with the specified parameters.
+     *
      * @param[in] channel     The AosShellChannel to initialize.
      * @param[in] iochannel   An AosIOChannel this AosShellChannel is associated with.
      * @param[in] channel       The AosShellChannel to initialize.
      * @param[in] asyncchannel  An BaseAsynchronousChannel this AosShellChannel is associated with.
      */
     void aosShellChannelInit(AosShellChannel* channel, AosIOChannel* iochannel)
     void aosShellChannelInit(AosShellChannel* channel, BaseAsynchronousChannel* asyncchannel)
+    {
       aosDbgCheck(channel != NULL);
       aosDbgCheck(iochannel != NULL && iochannel->asyncchannel != NULL);
       aosDbgCheck(asyncchannel != NULL);
       channel->vmt = &_channelvmt;
       channel->iochannel = iochannel;
       channel->asyncchannel = asyncchannel;
       channel->listener.wflags = 0;
       channel->next = NULL;
       channel->flags = 0;
-...
     void aosShellStreamAddChannel(AosShellStream* stream, AosShellChannel* channel)
+    {
       aosDbgCheck(stream != NULL);
       aosDbgCheck(channel != NULL && channel->iochannel != NULL && channel->iochannel->asyncchannel != NULL && channel->next == NULL && (channel->flags & AOS_SHELLCHANNEL_ATTACHED) == 0);
       aosDbgCheck(channel != NULL && channel->asyncchannel != NULL && channel->next == NULL && (channel->flags & AOS_SHELLCHANNEL_ATTACHED) == 0);
       // prepend the new channel
       chSysLock();
-...
     aos_status_t aosShellStreamRemoveChannel(AosShellStream* stream, AosShellChannel* channel)
+    {
       aosDbgCheck(stream != NULL);
       aosDbgCheck(channel != NULL && channel->iochannel != NULL && channel->iochannel->asyncchannel != NULL && channel->flags & AOS_SHELLCHANNEL_ATTACHED);
       aosDbgCheck(channel != NULL && channel->asyncchannel != NULL && channel->flags & AOS_SHELLCHANNEL_ATTACHED);
       // local varibales
       AosShellChannel* prev = NULL;
-...
      */
     void aosShellChannelInputEnable(AosShellChannel* channel)
+    {
       aosDbgCheck(channel != NULL && channel->iochannel != NULL && channel->iochannel->asyncchannel != NULL);
       aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
       chSysLock();
       channel->listener.wflags |= CHN_INPUT_AVAILABLE;
-...
      */
     void aosShellChannelInputDisable( AosShellChannel* channel)
+    {
       aosDbgCheck(channel != NULL && channel->iochannel != NULL && channel->iochannel->asyncchannel != NULL);
       aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
       chSysLock();
       channel->listener.wflags &= ~CHN_INPUT_AVAILABLE;
-...
      */
     void aosShellChannelOutputEnable(AosShellChannel* channel)
+    {
       aosDbgCheck(channel != NULL && channel->iochannel != NULL && channel->iochannel->asyncchannel != NULL);
       aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
       channel->flags |= AOS_SHELLCHANNEL_OUTPUT_ENABLED;
-...
      */
     void aosShellChannelOutputDisable(AosShellChannel* channel)
+    {
       aosDbgCheck(channel != NULL && channel->iochannel != NULL && channel->iochannel->asyncchannel != NULL);
       aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
       channel->flags &= ~AOS_SHELLCHANNEL_OUTPUT_ENABLED;
-...
       chEvtRegisterMask(((aos_shell_t*)shell)->os.eventSource, &(((aos_shell_t*)shell)->os.eventListener), AOS_SHELL_EVENTMASK_OS);
       // register events to all input channels
       for (channel = ((aos_shell_t*)shell)->stream.channel; channel != NULL; channel = channel->next) {
         chEvtRegisterMaskWithFlags(&(channel->iochannel->asyncchannel->event), &(channel->listener), AOS_SHELL_EVENTMASK_INPUT, channel->listener.wflags);
         chEvtRegisterMaskWithFlags(&(channel->asyncchannel->event), &(channel->listener), AOS_SHELL_EVENTMASK_INPUT, channel->listener.wflags);
+      }
       // fire start event
-...
               eventflags = chEvtGetAndClearFlags(&channel->listener);
               // if there is new input
               if (eventflags & CHN_INPUT_AVAILABLE) {
                 // if the channel is configured as input
                 if (channel->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
                   // read input from channel
                   readeval = _readChannel((aos_shell_t*)shell, channel, &nchars);
                   // parse input line to argument list only if the input shall be executed
                   nargs = (readeval == AOS_SUCCESS && nchars > 0) ? _parseArguments((aos_shell_t*)shell) : 0;
                   // check number of arguments
                   if (nargs > ((aos_shell_t*)shell)->arglistsize) {
                     // error too many arguments
                     chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\ttoo many arguments\n");
                   } else if (nargs > 0) {
                     // search command list for arg[0] and execute callback
                     cmd = ((aos_shell_t*)shell)->commands;
                     while (cmd != NULL) {
                       if (strcmp(((aos_shell_t*)shell)->arglist[0], cmd->name) == 0) {
                         ((aos_shell_t*)shell)->execstatus.command = cmd;
                         chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXEC);
                         ((aos_shell_t*)shell)->execstatus.retval = cmd->callback((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, nargs, ((aos_shell_t*)shell)->arglist);
                         chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_DONE);
                         // notify if the command was not successful
                         if (((aos_shell_t*)shell)->execstatus.retval != 0) {
                           chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "command returned exit status %d\n", ((aos_shell_t*)shell)->execstatus.retval);
+                        }
                         break;
                 // read input from channel
                 readeval = _readChannel((aos_shell_t*)shell, channel, &nchars);
                 // parse input line to argument list only if the input shall be executed
                 nargs = (readeval == AOS_SUCCESS && nchars > 0) ? _parseArguments((aos_shell_t*)shell) : 0;
                 // check number of arguments
                 if (nargs > ((aos_shell_t*)shell)->arglistsize) {
                   // error too many arguments
                   chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\ttoo many arguments\n");
                 } else if (nargs > 0) {
                   // search command list for arg[0] and execute callback
                   cmd = ((aos_shell_t*)shell)->commands;
                   while (cmd != NULL) {
                     if (strcmp(((aos_shell_t*)shell)->arglist[0], cmd->name) == 0) {
                       ((aos_shell_t*)shell)->execstatus.command = cmd;
                       chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXEC);
                       ((aos_shell_t*)shell)->execstatus.retval = cmd->callback((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, nargs, ((aos_shell_t*)shell)->arglist);
                       chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_DONE);
                       // notify if the command was not successful
                       if (((aos_shell_t*)shell)->execstatus.retval != 0) {
                         chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "command returned exit status %d\n", ((aos_shell_t*)shell)->execstatus.retval);
+                      }
                       cmd = cmd->next;
                     } /* end of while */
                     // if no matching command was found, print an error
                     if (cmd == NULL) {
                       chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "%s: command not found\n", ((aos_shell_t*)shell)->arglist[0]);
                       break;
+                    }
+                  }
                     cmd = cmd->next;
                   } /* end of while */
                   // rreset some internal variables and eprint a new prompt
                   if (readeval == AOS_SUCCESS && !chThdShouldTerminateX()) {
                     ((aos_shell_t*)shell)->inputdata.cursorpos = 0;
                     ((aos_shell_t*)shell)->inputdata.lineend = 0;
                     _printPrompt((aos_shell_t*)shell);
                   // if no matching command was found, print an error
                   if (cmd == NULL) {
                     chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "%s: command not found\n", ((aos_shell_t*)shell)->arglist[0]);
+                  }
+                }
                 // if the channel is not configured as input
                 else {
                   // read but drop all data
                   uint8_t c;
                   while (chnReadTimeout(channel, &c, 1, TIME_IMMEDIATE)) {
                     continue;
+                  }
                 // reset some internal variables and eprint a new prompt
                 if (readeval == AOS_SUCCESS && !chThdShouldTerminateX()) {
                   ((aos_shell_t*)shell)->inputdata.cursorpos = 0;
                   ((aos_shell_t*)shell)->inputdata.lineend = 0;
                   _printPrompt((aos_shell_t*)shell);
+                }
+              }

       aosIOChannelOutputEnable(&_stdiochannel);
       aosIOStreamAddChannel(&aos.iostream, &_stdiochannel);
     #if (AMIROOS_CFG_SHELL_ENABLE == true)
       aosShellChannelInit(&_stdshellchannel, &_stdiochannel);
       aosShellChannelInit(&_stdshellchannel, (BaseAsynchronousChannel*)&MODULE_HAL_PROGIF);
       aosShellChannelInputEnable(&_stdshellchannel);
       aosShellChannelOutputEnable(&_stdshellchannel);
       aosShellStreamAddChannel(&aos.shell->stream, &_stdshellchannel);

Also available in: Unified diff