core/cmd/cmd.c

   1 /*******************************************************************
   2     Copyright (C) 2009 FreakLabs
   3     All rights reserved.
   4
   5     Redistribution and use in source and binary forms, with or without
   6     modification, are permitted provided that the following conditions
   7     are met:
   8
   9     1. Redistributions of source code must retain the above copyright
  10        notice, this list of conditions and the following disclaimer.
  11     2. Redistributions in binary form must reproduce the above copyright
  12        notice, this list of conditions and the following disclaimer in the
  13        documentation and/or other materials provided with the distribution.
  14     3. Neither the name of the the copyright holder nor the names of its contributors
  15        may be used to endorse or promote products derived from this software
  16        without specific prior written permission.
  17
  18     THIS SOFTWARE IS PROVIDED BY THE THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
  19     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21     ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  22     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24     OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27     OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28     SUCH DAMAGE.
  29
  30     Originally written by Christopher Wang aka Akiba.
  31     Please post support questions to the FreakLabs forum.
  32 *******************************************************************/
  33
  34 /**************************************************************************/
  35 /*!
  36     @file     cmd.c
  37     @author   Christopher Wang (Freaklabs)
  38               Modified by: K. Townsend (microBuilder.eu)
  39     @date     19 May 2010
  40
  41     Original code taken from the FreakUSB Open Source USB Device Stack
  42     http://freaklabs.org/index.php/FreakUSB-Open-Source-USB-Device-Stack.html
  43
  44     If it works well, you can thank Akiba at Freaklabs.  If it fails
  45     miserably, you can blame me (since parts of it it were rather
  46     ungraciously modified). :-)
  47
  48 */
  49 /**************************************************************************/
  50
  51 #include <stdio.h>
  52 #include <string.h>
  53
  54 #include "cmd.h"
  55 #include "project/cmd_tbl.h"
  56
  57 #ifdef CFG_PRINTF_UART
  58 #include "core/uart/uart.h"
  59 #endif
  60
  61 #ifdef CFG_PRINTF_USBCDC
  62   #include "core/usbcdc/cdcuser.h"
  63   static char usbcdcBuf [32];
  64 #endif
  65
  66 #if CFG_INTERFACE_ENABLEIRQ == 1
  67   #include "core/gpio/gpio.h"
  68 #endif
  69
  70 static uint8_t msg[CFG_INTERFACE_MAXMSGSIZE];
  71 static uint8_t *msg_ptr;
  72
  73 /**************************************************************************/
  74 /*!
  75     @brief  Polls the relevant incoming message queue to see if anything
  76             is waiting to be processed.
  77 */
  78 /**************************************************************************/
  79 void cmdPoll()
  80 {
  81   #if defined CFG_PRINTF_UART
  82   while (uartRxBufferDataPending())
  83   {
  84     uint8_t c = uartRxBufferRead();
  85     cmdRx(c);
  86   }
  87   #endif
  88
  89   #if defined CFG_PRINTF_USBCDC
  90     int  numBytesToRead, numBytesRead, numAvailByte;
  91
  92     CDC_OutBufAvailChar (&numAvailByte);
  93     if (numAvailByte > 0)
  94     {
  95       numBytesToRead = numAvailByte > 32 ? 32 : numAvailByte;
  96       numBytesRead = CDC_RdOutBuf (&usbcdcBuf[0], &numBytesToRead);
  97       int i;
  98       for (i = 0; i < numBytesRead; i++)
  99       {
 100         cmdRx(usbcdcBuf[i]);
 101       }
 102     }
 103   #endif
 104 }
 105
 106 /**************************************************************************/
 107 /*!
 108     @brief  Handles a single incoming character.  If a new line is
 109             detected, the entire command will be passed to the command
 110             parser.  If a text character is detected, it will be added to
 111             the message buffer until a new line is detected (up to the
 112             maximum queue size, CFG_INTERFACE_MAXMSGSIZE).
 113
 114     @param[in]  c
 115                 The character to parse.
 116 */
 117 /**************************************************************************/
 118 void cmdRx(uint8_t c)
 119 {
 120   // read out the data in the buffer and echo it back to the host.
 121   switch (c)
 122   {
 123     case '\r':
 124       #if CFG_INTERFACE_DROPCR == 1
 125       break;
 126       #endif
 127     case '\n':
 128         // terminate the msg and reset the msg ptr. then send
 129         // it to the handler for processing.
 130         *msg_ptr = '\0';
 131         #if CFG_INTERFACE_SILENTMODE == 0
 132         printf("%s", CFG_PRINTF_NEWLINE);
 133         #endif
 134         cmdParse((char *)msg);
 135         msg_ptr = msg;
 136         break;
 137
 138     case '\b':
 139         #if CFG_INTERFACE_SILENTMODE == 0
 140         printf("%c",c);
 141         #endif
 142         if (msg_ptr > msg)
 143         {
 144             msg_ptr--;
 145         }
 146         break;
 147
 148     default:
 149         #if CFG_INTERFACE_SILENTMODE == 0
 150         printf("%c",c);
 151         #endif
 152         *msg_ptr++ = c;
 153         break;
 154   }
 155 }
 156
 157 /**************************************************************************/
 158 /*!
 159     @brief  Displays the command prompt.  The text that appears is defined
 160             in projectconfig.h.
 161 */
 162 /**************************************************************************/
 163 static void cmdMenu()
 164 {
 165   #if CFG_INTERFACE_SILENTMODE == 0
 166   printf(CFG_PRINTF_NEWLINE);
 167   printf(CFG_INTERFACE_PROMPT);
 168   #endif
 169   #if CFG_INTERFACE_CONFIRMREADY == 1
 170   printf("%s%s", CFG_INTERFACE_CONFIRMREADY_TEXT, CFG_PRINTF_NEWLINE);
 171   #endif
 172 }
 173
 174 /**************************************************************************/
 175 /*!
 176     @brief  Parse the command line. This function tokenizes the command
 177             input, then searches for the command table entry associated
 178             with the commmand. Once found, it will jump to the
 179             corresponding function.
 180
 181     @param[in]  cmd
 182                 The entire command string to be parsed
 183 */
 184 /**************************************************************************/
 185 void cmdParse(char *cmd)
 186 {
 187   size_t argc, i = 0;
 188   char *argv[30];
 189
 190   argv[i] = strtok(cmd, " ");
 191   do
 192   {
 193       argv[++i] = strtok(NULL, " ");
 194   } while ((i < 30) && (argv[i] != NULL));
 195
 196   argc = i;
 197   for (i=0; i < CMD_COUNT; i++)
 198   {
 199       if (!strcmp(argv[0], cmd_tbl[i].command))
 200       {
 201         if ((argc == 2) && !strcmp (argv [1], "?"))
 202         {
 203           // Display parameter help menu on 'command ?'
 204           printf ("%s%s%s", cmd_tbl[i].description, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
 205           printf ("%s%s", cmd_tbl[i].parameters, CFG_PRINTF_NEWLINE);
 206         }
 207         else if ((argc - 1) < cmd_tbl[i].minArgs)
 208         {
 209           // Too few arguments supplied
 210           #if CFG_INTERFACE_SHORTERRORS == 1
 211           printf ("%s%s", CFG_INTERFACE_SHORTERRORS_TOOFEWARGS, CFG_PRINTF_NEWLINE);
 212           #else
 213           printf ("Too few arguments (%d expected)%s", cmd_tbl[i].minArgs, CFG_PRINTF_NEWLINE);
 214           printf ("%sType '%s ?' for more information%s%s", CFG_PRINTF_NEWLINE, cmd_tbl[i].command, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
 215           #endif
 216         }
 217         else if ((argc - 1) > cmd_tbl[i].maxArgs)
 218         {
 219           // Too many arguments supplied
 220           #if CFG_INTERFACE_SHORTERRORS == 1
 221           printf ("%s%s", CFG_INTERFACE_SHORTERRORS_TOOMANYARGS, CFG_PRINTF_NEWLINE);
 222           #else
 223           printf ("Too many arguments (%d maximum)%s", cmd_tbl[i].maxArgs, CFG_PRINTF_NEWLINE);
 224           printf ("%sType '%s ?' for more information%s%s", CFG_PRINTF_NEWLINE, cmd_tbl[i].command, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
 225           #endif
 226         }
 227         else
 228         {
 229           #if CFG_INTERFACE_ENABLEIRQ != 0
 230           // Set the IRQ pin high at start of a command
 231           gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 1);
 232           #endif
 233           // Dispatch command to the appropriate function
 234           cmd_tbl[i].func(argc - 1, &argv [1]);
 235           #if CFG_INTERFACE_ENABLEIRQ  != 0
 236           // Set the IRQ pin low to signal the end of a command
 237           gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 0);
 238           #endif
 239         }
 240
 241         // Refresh the command prompt
 242         cmdMenu();
 243         return;
 244       }
 245   }
 246   // Command not recognized
 247   #if CFG_INTERFACE_SHORTERRORS == 1
 248   printf ("%s%s", CFG_INTERFACE_SHORTERRORS_UNKNOWNCOMMAND, CFG_PRINTF_NEWLINE);
 249   #else
 250   printf("Command not recognized: '%s'%s%s", cmd, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
 251   #if CFG_INTERFACE_SILENTMODE == 0
 252   printf("Type '?' for a list of all available commands%s", CFG_PRINTF_NEWLINE);
 253   #endif
 254   #endif
 255
 256   cmdMenu();
 257 }
 258
 259 /**************************************************************************/
 260 /*!
 261     @brief Initialises the command line using the appropriate interface
 262 */
 263 /**************************************************************************/
 264 void cmdInit()
 265 {
 266   #if defined CFG_INTERFACE && defined CFG_INTERFACE_UART
 267     // Check if UART is already initialised
 268     uart_pcb_t *pcb = uartGetPCB();
 269     if (!pcb->initialised)
 270     {
 271       uartInit(CFG_UART_BAUDRATE);
 272     }
 273   #endif
 274
 275   #if CFG_INTERFACE_ENABLEIRQ != 0
 276     // Set IRQ pin as output
 277     gpioSetDir(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, gpioDirection_Output);
 278     gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 1);
 279   #endif
 280
 281   // init the msg ptr
 282   msg_ptr = msg;
 283
 284   // Show the menu
 285   cmdMenu();
 286
 287   // Set the IRQ pin low by default
 288   #if CFG_INTERFACE_ENABLEIRQ  != 0
 289     gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 0);
 290   #endif
 291 }
 292
 293 /**************************************************************************/
 294 /*!
 295     'help' command handler
 296 */
 297 /**************************************************************************/
 298 void cmd_help(uint8_t argc, char **argv)
 299 {
 300   size_t i;
 301
 302   printf("Command      Description%s", CFG_PRINTF_NEWLINE);
 303   printf("-------      -----------%s", CFG_PRINTF_NEWLINE);
 304
 305   // Display full command list
 306   for (i=0; i < CMD_COUNT; i++)
 307   {
 308     if (!cmd_tbl[i].hidden)
 309     {
 310       printf ("%-10s   %s%s", cmd_tbl[i].command, cmd_tbl[i].description, CFG_PRINTF_NEWLINE);
 311     }
 312   }
 313
 314   printf("%sCommand parameters can be seen by entering: <command-name> ?%s", CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
 315 }