demo/chb_demo.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     \file
  36     \ingroup
  37
  38
  39 */
  40 /**************************************************************************/
  41 #include <avr/pgmspace.h>
  42 #include "chb_demo.h"
  43 #include "freakusb.h"
  44 #include "chb.h"
  45 #include "chb_drvr.h"
  46
  47 FILE file_str = FDEV_SETUP_STREAM(chb_demo_putchar, NULL, _FDEV_SETUP_WRITE);
  48
  49 // static globals
  50 static U8 msg[CHB_MAX_MSG_SIZE];
  51 static U8 *msg_ptr;
  52
  53 // command prototypes
  54 void cmd_parse(char *cmd);
  55 static void cmd_hello(U8 argc, char **argv);
  56 static void cmd_set_short_addr(U8 argc, char **argv);
  57 static void cmd_get_short_addr(U8 argc, char **argv);
  58 static void cmd_set_ieee_addr(U8 argc, char **argv);
  59 static void cmd_get_ieee_addr(U8 argc, char **argv);
  60 static void cmd_tx(U8 argc, char **argv);
  61 static void cmd_reg_read(U8 argc, char **argv);
  62 static void cmd_reg_write(U8 argc, char **argv);
  63 static void cmd_reg_dump(U8 argc, char **argv);
  64
  65 // command table
  66 static chb_cmd_t cmd_tbl[] =
  67 {
  68     {"hello",   cmd_hello},
  69     {"setsaddr", cmd_set_short_addr},
  70     {"getsaddr", cmd_get_short_addr},
  71     {"setiaddr", cmd_set_ieee_addr},
  72     {"getiaddr", cmd_get_ieee_addr},
  73     {"rd", cmd_reg_read},
  74     {"wr", cmd_reg_write},
  75     {"dump", cmd_reg_dump},
  76     {"send", cmd_tx},
  77     {NULL,      NULL}
  78 };
  79
  80 /**************************************************************************/
  81 /*!
  82     This is the putchar function that is used by avr-libc's printf. We need
  83     to hook this function into the stdout file stream using the FDEV_SETUP_STREAM
  84     macro in avr-libc. Once the stream is set up, we hook the stream to stdout
  85     and we can do printfs via USB.
  86 */
  87 /**************************************************************************/
  88 int chb_demo_putchar(char c, FILE *unused)
  89 {
  90     usb_pcb_t *pcb = usb_pcb_get();
  91
  92     if (!(pcb->flags & (1<<ENUMERATED)))
  93     {
  94         return 0;
  95     }
  96
  97     if (c == '\n')
  98     {
  99         usb_buf_write(EP_1, '\n');
 100         usb_buf_write(EP_1, '\r');
 101     }
 102     else
 103     {
 104       usb_buf_write(EP_1, (U8)c);
 105     }
 106     ep_write(EP_1);
 107     return 0;
 108 }
 109
 110 /**************************************************************************/
 111 /*!
 112     This is the rx handling function. It will handle any incoming data from
 113     the USB. This function needs to be registered with the CDC class since
 114     the CDC doesn't know what to do with received data.
 115 */
 116 /**************************************************************************/
 117 void rx()
 118 {
 119     U8 i, c, ep_num, len;
 120     usb_pcb_t *pcb = usb_pcb_get();
 121
 122     // get the ep number of any endpoint with pending rx data
 123     if ((ep_num = usb_buf_data_pending(DIR_OUT)) != 0xFF)
 124     {
 125         // get the length of data in the OUT buffer
 126         len = pcb->fifo[ep_num].len;
 127
 128         // read out the data in the buffer and echo it back to the host.
 129         for (i=0; i<len; i++)
 130         {
 131             c = usb_buf_read(ep_num);
 132
 133             switch (c)
 134             {
 135             case '\r':
 136                 // terminate the msg and reset the msg ptr. then send
 137                 // it to the handler for processing.
 138                 *msg_ptr = '\0';
 139                 printf_P(PSTR("\n\r"));
 140                 cmd_parse((char *)msg);
 141                 msg_ptr = msg;
 142                 break;
 143
 144             case '\b':
 145                 usb_buf_write(EP_1, c);
 146                 if (msg_ptr > msg)
 147                 {
 148                     msg_ptr--;
 149                 }
 150                 break;
 151
 152             default:
 153                 usb_buf_write(EP_1, c);
 154                 *msg_ptr++ = c;
 155                 break;
 156             }
 157         }
 158         pcb->flags |= (1 << TX_DATA_AVAIL);
 159     }
 160 }
 161
 162 /**************************************************************************/
 163 /*!
 164
 165 */
 166 /**************************************************************************/
 167 static void cmd_menu()
 168 {
 169     printf_P(PSTR("\n"));
 170     printf_P(PSTR("********** CHIBI **************\n"));
 171     printf_P(PSTR("CHIBI >> "));
 172 }
 173
 174 /**************************************************************************/
 175 /*!
 176
 177 */
 178 /**************************************************************************/
 179 void cmd_parse(char *cmd)
 180 {
 181     U8 argc, i = 0;
 182     char *argv[30];
 183
 184     fflush(stdout);
 185
 186     argv[i] = strtok(cmd, " ");
 187     do
 188     {
 189         argv[++i] = strtok(NULL, " ");
 190     } while ((i < CHB_MAX_MSG_SIZE) && (argv[i] != NULL));
 191
 192     argc = i;
 193     for (i=0; cmd_tbl[i].cmd != NULL; i++)
 194     {
 195         if (!strcmp(argv[0], cmd_tbl[i].cmd))
 196         {
 197             cmd_tbl[i].func(argc, argv);
 198             cmd_menu();
 199             return;
 200         }
 201     }
 202     printf_P(PSTR("CMD: Command not recognized.\n"));
 203
 204     cmd_menu();
 205 }
 206
 207 /**************************************************************************/
 208 /*!
 209
 210 */
 211 /**************************************************************************/
 212 int main()
 213 {
 214     pcb_t *pcb = chb_get_pcb();
 215     chb_rx_data_t rx_data;
 216
 217     usb_init();
 218     hw_init();
 219
 220     // init the class driver here
 221     cdc_init();
 222
 223     // register the rx handler function with the cdc
 224     cdc_reg_rx_handler(rx);
 225
 226     // hook the putchar function into the printf stdout filestream. This is needed
 227     // for printf to work.
 228     stdout = &file_str;
 229
 230     // init the msg ptr
 231     msg_ptr = msg;
 232
 233     // init chibi stack
 234     chb_init();
 235
 236     // and off we go...
 237     while (1)
 238     {
 239         usb_poll();
 240
 241         if (pcb->data_rcv)
 242         {
 243             rx_data.len = chb_read(&rx_data);
 244             printf_P(PSTR("Message received from node %02X: %s.\n"), rx_data.src_addr, rx_data.data);
 245             pcb->data_rcv = false;
 246         }
 247     }
 248
 249     return 0;
 250 }
 251
 252 /**************************************************************************/
 253 /*!
 254
 255 */
 256 /**************************************************************************/
 257 static void cmd_hello(U8 argc, char **argv)
 258 {
 259     printf_P(PSTR("Hello World!\n"));
 260 }
 261
 262 /**************************************************************************/
 263 /*!
 264
 265 */
 266 /**************************************************************************/
 267 static void cmd_set_short_addr(U8 argc, char **argv)
 268 {
 269     U16 addr = strtol(argv[1], NULL, 16);
 270     chb_set_short_addr(addr);
 271 }
 272
 273 /**************************************************************************/
 274 /*!
 275
 276 */
 277 /**************************************************************************/
 278 static void cmd_get_short_addr(U8 argc, char **argv)
 279 {
 280     U16 addr = chb_get_short_addr();
 281     printf_P(PSTR("Short Addr = %04X.\n"), addr);
 282 }
 283
 284 /**************************************************************************/
 285 /*!
 286
 287 */
 288 /**************************************************************************/
 289 static void cmd_set_ieee_addr(U8 argc, char **argv)
 290 {
 291     U8 i, addr[8];
 292
 293     memset(addr, 0, 8);
 294     for (i=0; i<argc-1; i++)
 295     {
 296         addr[i] = strtol(argv[i+1], NULL, 16);
 297     }
 298     chb_set_ieee_addr(addr);
 299 }
 300
 301 /**************************************************************************/
 302 /*!
 303
 304 */
 305 /**************************************************************************/
 306 static void cmd_get_ieee_addr(U8 argc, char **argv)
 307 {
 308     U8 i, addr[8];
 309
 310     chb_get_ieee_addr(addr);
 311
 312     printf_P(PSTR("IEEE Addr = "));
 313     for (i=8; i>0; i--)
 314     {
 315         printf("%02X", addr[i-1]);
 316     }
 317 }
 318
 319 /**************************************************************************/
 320 /*!
 321
 322 */
 323 /**************************************************************************/
 324 static void cmd_reg_read(U8 argc, char **argv)
 325 {
 326     U8 addr, val;
 327
 328     addr = strtol(argv[1], NULL, 16);
 329     val = chb_reg_read(addr);
 330     printf_P(PSTR("Reg Read: %04X, %02X.\n"), addr, val);
 331 }
 332
 333 /**************************************************************************/
 334 /*!
 335
 336 */
 337 /**************************************************************************/
 338 static void cmd_reg_write(U8 argc, char **argv)
 339 {
 340     U8 addr, val;
 341
 342     addr = strtol(argv[1], NULL, 16);
 343     val = strtol(argv[2], NULL, 16);
 344
 345     chb_reg_write(addr, val);
 346     printf_P(PSTR("Write: %04X, %02X.\n"), addr, val);
 347
 348     val = chb_reg_read(addr);
 349     printf_P(PSTR("Readback: %04X, %02X.\n"), addr, val);
 350 }
 351
 352 /**************************************************************************/
 353 /*!
 354
 355 */
 356 /**************************************************************************/
 357 static void cmd_reg_dump(U8 argc, char **argv)
 358 {
 359     U8 i, val;
 360
 361     for (i=0; i<0x2e; i++)
 362     {
 363         val = chb_reg_read(i);
 364         printf_P(PSTR("Reg Read: %04X, %02X.\n"), i, val);
 365     }
 366 }
 367
 368 /**************************************************************************/
 369 /*!
 370
 371 */
 372 /**************************************************************************/
 373 static void cmd_tx(U8 argc, char **argv)
 374 {
 375     U8 i, len, *data_ptr, data[50];
 376     U16 addr;
 377
 378     addr = strtol(argv[1], NULL, 16);
 379
 380     data_ptr = data;
 381     for (i=0; i<argc-2; i++)
 382     {
 383         len = strlen(argv[i+2]);
 384         strcpy((char *)data_ptr, (char *)argv[i+2]);
 385         data_ptr += len;
 386         *data_ptr++ = ' ';
 387     }
 388     *data_ptr++ = '\0';
 389
 390     chb_write(addr, data, data_ptr - data);
 391 }
 392