recipes/i2c/files/i2c.c

   1 /****************************************************************************
   2 *
   3 *   Copyright (c) 2006 Dave Hylands     <dhylands@gmail.com>
   4 *
   5 *   This program is free software; you can redistribute it and/or modify
   6 *   it under the terms of the GNU General Public License version 2 as
   7 *   published by the Free Software Foundation.
   8 *
   9 *   Alternatively, this software may be distributed under the terms of BSD
  10 *   license.
  11 *
  12 *   See README and COPYING for more details.
  13 *
  14 ****************************************************************************/
  15 /**
  16 *
  17 *   @file   i2c.c
  18 *
  19 *   @brief  This program allows basic i2c commands to be sent out the i2c
  20 *           bus,
  21 *
  22 ****************************************************************************/
  23
  24 // ---- Include Files -------------------------------------------------------
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <getopt.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <signal.h>
  33 #include <unistd.h>
  34 #include <sys/timeb.h>
  35
  36 #include "i2c-dev.h"
  37 #include "i2c-api.h"
  38 #include "i2c-io-api.h"
  39 #include "Log.h"
  40
  41 // #include "svn-version.h"
  42
  43 // ---- Public Variables ----------------------------------------------------
  44 // ---- Private Constants and Types -----------------------------------------
  45
  46 // ---- Private Variables ---------------------------------------------------
  47
  48 enum
  49 {
  50     OPT_MEM_DEFAULT     = 0,
  51
  52     // Options assigned a single character code can use that charater code
  53     // as a short option.
  54
  55     OPT_COUNT           = 'c',
  56
  57     // Options from this point onwards don't have any short option equivalents
  58
  59     OPT_FIRST_LONG_OPT   = 0x80,
  60
  61     OPT_HELP,
  62     OPT_VERSION,
  63 };
  64
  65 enum
  66 {
  67     CMD_DEFAULT,
  68
  69     CMD_READ_BYTE,
  70     CMD_READ_BYTE_2,
  71     CMD_READ_BYTE_4,
  72
  73     CMD_WRITE_BYTE,
  74     CMD_WRITE_BYTE_2,
  75     CMD_WRITE_BYTE_4,
  76
  77     CMD_RECV_BYTE,
  78     CMD_RECV_BYTE_2,
  79     CMD_RECV_BYTE_4,
  80
  81     CMD_SEND_BYTE,
  82     CMD_SEND_BYTE_2,
  83     CMD_SEND_BYTE_4,
  84 };
  85
  86 struct
  87 {
  88     int         cmd;
  89     const char *cmdStr;
  90
  91 } gCmdMap[] =
  92 {
  93     { CMD_READ_BYTE,    "ReadByte" },
  94     { CMD_READ_BYTE,    "rb" },
  95     { CMD_READ_BYTE_2,  "ReadByte2" },
  96     { CMD_READ_BYTE_2,  "rb2" },
  97     { CMD_READ_BYTE_4,  "ReadByte4" },
  98     { CMD_READ_BYTE_4,  "rb4" },
  99
 100     { CMD_WRITE_BYTE,   "WriteByte" },
 101     { CMD_WRITE_BYTE,   "wb" },
 102     { CMD_WRITE_BYTE_2, "WriteByte2" },
 103     { CMD_WRITE_BYTE_2, "wb2" },
 104     { CMD_WRITE_BYTE_4, "WriteByte4" },
 105     { CMD_WRITE_BYTE_4, "wb4" },
 106
 107     { CMD_RECV_BYTE,    "RecvByte" },
 108     { CMD_RECV_BYTE,    "vb" },
 109     { CMD_RECV_BYTE_2,  "RecvByte2" },
 110     { CMD_RECV_BYTE_2,  "vb2" },
 111     { CMD_RECV_BYTE_4,  "RecvByte4" },
 112     { CMD_RECV_BYTE_4,  "vb4" },
 113
 114     { CMD_SEND_BYTE,    "SendByte" },
 115     { CMD_SEND_BYTE,    "sb" },
 116     { CMD_SEND_BYTE_2,  "SendByte2" },
 117     { CMD_SEND_BYTE_2,  "sb2" },
 118     { CMD_SEND_BYTE_4,  "SendByte4" },
 119     { CMD_SEND_BYTE_4,  "sb4" },
 120 };
 121
 122 int gNumCmds = sizeof( gCmdMap ) / sizeof( gCmdMap[ 0 ]);
 123
 124 int gI2cAddr    = -1;
 125 int gByteCount  = 1;
 126
 127 const char *gCmdStr;
 128 int         gCmd        = CMD_DEFAULT;
 129 const char *gAddrStr    = NULL;
 130 const char *gDataStr    = NULL;
 131
 132 struct option gOption[] =
 133 {
 134     { "count",      required_argument,  NULL,           OPT_COUNT },
 135     { "version",    no_argument,        NULL,           OPT_VERSION },
 136     { "verbose",    no_argument,        &gVerbose,      1 },
 137     { "debug",      no_argument,        &gDebug,        1 },
 138     { "help",       no_argument,        NULL,           OPT_HELP },
 139     { NULL }
 140 };
 141
 142 #define TRUE    1
 143 #define FALSE   0
 144
 145 typedef enum
 146 {
 147     NoADC,
 148     AllowADC,
 149
 150 } AllowADC_t;
 151
 152 #define ADC_PORT    8
 153
 154 // ---- Private Function Prototypes -----------------------------------------
 155
 156 static  int  ParseByte( const char *byteStr, uint8_t *byte );
 157 static  int  ParseBytes( const char *byteStr, uint8_t *byte, uint8_t maxBytes, uint8_t *bytesParsed );
 158
 159 static  void ProcessReadByteCommand( int i2cDev, const char *addrStr );
 160 static  void ProcessWriteByteCommand( int i2cDev, const char *addrStr, const char *dataStr );
 161 static  void ProcessRecvByteCommand( int i2cDev );
 162 static  void ProcessSendByteCommand( int i2cDev, const char *dataStr );
 163 static  void Usage( void );
 164
 165 // ---- Functions -----------------------------------------------------------
 166
 167 //***************************************************************************
 168 /**
 169 *   Main entry point
 170 */
 171
 172 int main( int argc, char **argv )
 173 {
 174     char                shortOptsStr[ sizeof( gOption ) / sizeof( gOption[ 0 ] ) + 1 ];
 175     char               *shortOpts = shortOptsStr;
 176     struct option       *scanOpt;
 177     int                 opt;
 178     const char         *i2cDevName = "/dev/i2c-0";
 179     int                 i2cDev;
 180     int                 cmdIdx;
 181
 182     LogInit( stdout );
 183
 184     // Figure out the short options from our options structure
 185
 186     for ( scanOpt = gOption; scanOpt->name != NULL; scanOpt++ )
 187     {
 188         if (( scanOpt->flag == NULL ) && ( scanOpt->val < OPT_FIRST_LONG_OPT ))
 189         {
 190             *shortOpts++ = (char)scanOpt->val;
 191
 192             if ( scanOpt->has_arg != no_argument )
 193             {
 194                 *shortOpts++ = ':';
 195             }
 196         }
 197     }
 198     *shortOpts++ = '\0';
 199
 200     // Parse the command line options
 201
 202     while (( opt = getopt_long( argc, argv, shortOptsStr, gOption, NULL )) != -1 )
 203     {
 204         switch ( opt )
 205         {
 206             case 0:
 207             {
 208                 // getopt_long returns 0 for entries where flag is non-NULL
 209
 210                 break;
 211             }
 212
 213             case OPT_COUNT:
 214             {
 215                 gByteCount = (int)strtol( optarg, NULL, 0 );
 216                 if ( gByteCount <= 0 )
 217                 {
 218                     LogError( "Expecting byte count >= 0, found: '%s'\n", optarg );
 219                     Usage();
 220                     exit( 1 );
 221                 }
 222                 if ( gByteCount > I2C_MAX_DATA_LEN )
 223                 {
 224                     LogError( "Max byte count supported: %d, found %d\n", I2C_MAX_DATA_LEN, gByteCount );
 225                     Usage();
 226                     exit( 1 );
 227                 }
 228                 break;
 229             }
 230
 231 //            case OPT_VERSION:
 232 //            {
 233 //                Log( "i2c SVN Revision: %d\n", SVN_REVISION );
 234 //                exit( 0 );
 235 //                break;
 236 //            }
 237
 238             case '?':
 239             case OPT_HELP:
 240             default:
 241             {
 242                 LogError( "opt:%d\n", opt );
 243                 Usage();
 244                 exit( 1 );
 245             }
 246         }
 247     }
 248     argc -= optind;
 249     argv += optind;
 250
 251     // Verify that an i2c-address was specified
 252
 253     if ( argc < 1 )
 254     {
 255         LogError( "Must specify an i2c address\n\n" );
 256         Usage();
 257         exit( 1 );
 258     }
 259     gI2cAddr = strtol( argv[ 0 ], NULL, 0 );
 260     if (( gI2cAddr <= 0 ) || ( gI2cAddr > 127 ))
 261     {
 262         LogError( "Expecting i2c address in the range of 1-127, Found: %d\n", gI2cAddr );
 263         Usage();
 264         exit( 1 );
 265     }
 266
 267     // Verify that a command has been specified
 268
 269     if ( argc < 2 )
 270     {
 271         LogError( "Must specify a command\n" );
 272         Usage();
 273         exit( 1 );
 274     }
 275     gCmdStr = argv[ 1 ];
 276     for ( cmdIdx = 0; cmdIdx < gNumCmds; cmdIdx++ )
 277     {
 278         if ( strcasecmp( gCmdStr, gCmdMap[ cmdIdx ].cmdStr ) == 0 )
 279         {
 280             gCmd = gCmdMap[ cmdIdx ].cmd;
 281             break;
 282         }
 283     }
 284     if ( gCmd == CMD_DEFAULT )
 285     {
 286         LogError( "Unrecognized command '%s'\n", gCmdStr );
 287         exit( 1 );
 288     }
 289
 290     // Process command specific arguments
 291
 292     if (( gCmd == CMD_READ_BYTE_2  )
 293     ||  ( gCmd == CMD_WRITE_BYTE_2 )
 294     ||  ( gCmd == CMD_RECV_BYTE_2 )
 295     ||  ( gCmd == CMD_SEND_BYTE_2 ))
 296     {
 297         gByteCount = 2;
 298     }
 299     else
 300     if (( gCmd == CMD_READ_BYTE_4  )
 301     ||  ( gCmd == CMD_WRITE_BYTE_4 )
 302     ||  ( gCmd == CMD_RECV_BYTE_4 )
 303     ||  ( gCmd == CMD_SEND_BYTE_4 ))
 304     {
 305         gByteCount = 4;
 306     }
 307
 308     if (( gCmd == CMD_READ_BYTE )
 309     ||  ( gCmd == CMD_READ_BYTE_2 )
 310     ||  ( gCmd == CMD_READ_BYTE_4 ))
 311     {
 312         if ( argc < 3 )
 313         {
 314             LogError( "Expecting address\n" );
 315             Usage();
 316             exit( 1 );
 317         }
 318         if ( argc > 3 )
 319         {
 320             LogError( "Unexpected extra parameters\n" );
 321             Usage();
 322             exit( 1 );
 323         }
 324
 325         gAddrStr = argv[ 2 ];
 326     }
 327     else
 328     if (( gCmd == CMD_WRITE_BYTE )
 329     ||  ( gCmd == CMD_WRITE_BYTE_2 )
 330     ||  ( gCmd == CMD_WRITE_BYTE_4 ))
 331     {
 332         if ( argc < 4 )
 333         {
 334             LogError( "Expecting address and data\n" );
 335             Usage();
 336             exit( 1 );
 337         }
 338         if ( argc > 4 )
 339         {
 340             LogError( "Unexpected extra parameters\n" );
 341             Usage();
 342             exit( 1 );
 343         }
 344
 345         gAddrStr = argv[ 2 ];
 346         gDataStr = argv[ 3 ];
 347     }
 348     else
 349     if (( gCmd == CMD_RECV_BYTE )
 350     ||  ( gCmd == CMD_RECV_BYTE_2 )
 351     ||  ( gCmd == CMD_RECV_BYTE_4 ))
 352     {
 353         if ( argc > 2 )
 354         {
 355             LogError( "Unexpected extra parameters\n" );
 356             Usage();
 357             exit( 1 );
 358         }
 359     }
 360     else
 361     if (( gCmd == CMD_SEND_BYTE )
 362     ||  ( gCmd == CMD_SEND_BYTE_2 )
 363     ||  ( gCmd == CMD_SEND_BYTE_4 ))
 364     {
 365         if ( argc < 3 )
 366         {
 367             LogError( "Expecting data\n" );
 368             Usage();
 369             exit( 1 );
 370         }
 371         if ( argc > 3 )
 372         {
 373             LogError( "Unexpected extra parameters\n" );
 374             Usage();
 375             exit( 1 );
 376         }
 377         gDataStr = argv[ 2 ];
 378     }
 379
 380     if ( gDebug )
 381     {
 382         Log( "i2cAddr:0x%02x Cmd: %s (%d)", gI2cAddr, gCmdStr, gCmd );
 383         if ( gAddrStr != NULL )
 384         {
 385             Log( " Addr: %s", gAddrStr );
 386         }
 387         if ( gDataStr != NULL )
 388         {
 389             Log( " Data: %s", gDataStr );
 390         }
 391         Log( "\n" );
 392     }
 393
 394     // Try to open the i2c device
 395
 396     if (( i2cDev = open( i2cDevName, O_RDWR )) < 0 )
 397     {
 398         LogError( "Error  opening '%s': %s\n", i2cDevName, strerror( errno ));
 399         exit( 1 );
 400     }
 401
 402     // Indicate which slave we wish to speak to
 403
 404     I2cSetSlaveAddress( i2cDev, gI2cAddr, I2C_NO_CRC );
 405
 406     switch ( gCmd )
 407     {
 408         case CMD_READ_BYTE:
 409         case CMD_READ_BYTE_2:
 410         case CMD_READ_BYTE_4:
 411         {
 412             ProcessReadByteCommand( i2cDev, gAddrStr );
 413             break;
 414         }
 415
 416         case CMD_WRITE_BYTE:
 417         case CMD_WRITE_BYTE_2:
 418         case CMD_WRITE_BYTE_4:
 419         {
 420             ProcessWriteByteCommand( i2cDev, gAddrStr, gDataStr );
 421             break;
 422         }
 423
 424         case CMD_RECV_BYTE:
 425         case CMD_RECV_BYTE_2:
 426         case CMD_RECV_BYTE_4:
 427         {
 428             ProcessRecvByteCommand( i2cDev );
 429             break;
 430         }
 431
 432         case CMD_SEND_BYTE:
 433         case CMD_SEND_BYTE_2:
 434         case CMD_SEND_BYTE_4:
 435         {
 436             ProcessSendByteCommand( i2cDev, gDataStr );
 437             break;
 438         }
 439     }
 440
 441     close( i2cDev );
 442
 443     return 0;
 444
 445 } // main
 446
 447 //***************************************************************************
 448 /**
 449 *   Parse a string looking for a single byte.
 450 */
 451
 452 int ParseByte( const char *byteStr, uint8_t *byte )
 453 {
 454     char       *endPtr;
 455
 456     *byte = (uint8_t)strtol( byteStr, &endPtr, 0 );
 457
 458     if ( *endPtr != '\0' )
 459     {
 460         LogError( "Expecting numeric value, found '%s'\n", byteStr );
 461         return FALSE;
 462     }
 463
 464     return TRUE;
 465
 466 } // ParseByte
 467
 468 //***************************************************************************
 469 /**
 470 *   Parse a string looking for an array of bytes.
 471 */
 472
 473 int ParseBytes( const char *byteStr, uint8_t *byte, uint8_t maxBytes, uint8_t *bytesParsed )
 474 {
 475     char       *endPtr;
 476
 477     if (( byteStr[ 0 ] == '0' ) && ( byteStr[ 1 ] == 'x' ))
 478     {
 479         const char *s = &byteStr[ 2 ];
 480         *bytesParsed = 0;
 481
 482         // Could be a multi-byte hex string
 483
 484         while ( *s != '\0' )
 485         {
 486             if ( *bytesParsed >= maxBytes )
 487             {
 488                 LogError( "Too many bytes, max: %d\n", maxBytes );
 489                 return FALSE;
 490             }
 491
 492             (*bytesParsed)++;
 493             *byte = 0;
 494
 495             if (( *s >= 'A' ) && ( *s <= 'F' ))
 496             {
 497                 *byte = *s - 'A' + 10;
 498             }
 499             else
 500             if (( *s >= 'a' ) && ( *s <= 'f' ))
 501             {
 502                 *byte = *s - 'a' + 10;
 503             }
 504             else
 505             if (( *s >= '0' ) && ( *s <= '9' ))
 506             {
 507                 *byte = *s - '0';
 508             }
 509             else
 510             {
 511                 LogError( "Expecting hex digit, found '%c'\n", *s );
 512                 return FALSE;
 513             }
 514             s++;
 515
 516             if ( *s == '\0' )
 517             {
 518                 break;
 519             }
 520
 521             *byte <<= 4;
 522             if (( *s >= 'A' ) && ( *s <= 'F' ))
 523             {
 524                 *byte |= *s - 'A' + 10;
 525             }
 526             else
 527             if (( *s >= 'a' ) && ( *s <= 'f' ))
 528             {
 529                 *byte |= *s - 'a' + 10;
 530             }
 531             else
 532             if (( *s >= '0' ) && ( *s <= '9' ))
 533             {
 534                 *byte |= *s - '0';
 535             }
 536             else
 537             {
 538                 LogError( "Expecting hex digit, found '%c'\n", *s );
 539                 return FALSE;
 540             }
 541             s++;
 542             byte++;
 543         }
 544     }
 545     else
 546     {
 547         // It's decimal or octal - only a single byte
 548
 549         *byte = (uint8_t)strtol( byteStr, &endPtr, 0 );
 550
 551         if ( *endPtr != '\0' )
 552         {
 553             LogError( "Expecting numeric value, found '%s'\n", byteStr );
 554             return FALSE;
 555         }
 556         *bytesParsed = 1;
 557     }
 558
 559     return TRUE;
 560
 561 } // ParseBytes
 562
 563 //***************************************************************************
 564 /**
 565 *   Issues a read byte command to read a byte from a particular address.
 566 */
 567
 568 void ProcessReadByteCommand( int i2cDev, const char *addrStr )
 569 {
 570     uint8_t addr;
 571     uint8_t dataByte[ I2C_MAX_DATA_LEN ];
 572     int     rc;
 573     int     i;
 574
 575     if ( !ParseByte( addrStr, &addr ))
 576     {
 577         return;
 578     }
 579
 580     if (( rc = I2cReadBytes( i2cDev, addr, dataByte, gByteCount )) != 0 )
 581     {
 582         LogError( "I2cReadByte failed: %d\n", rc );
 583         return;
 584     }
 585
 586     Log( "0x", dataByte[0] );
 587
 588     for ( i = 0; i < gByteCount; i++ )
 589     {
 590         Log( "%02x", dataByte[i] );
 591     }
 592     Log( "\n" );
 593
 594 } // ProcessReadByteCommand
 595
 596 //***************************************************************************
 597 /**
 598 *   Issues a recv byte command to read bytes with no address.
 599 */
 600
 601 void ProcessRecvByteCommand( int i2cDev )
 602 {
 603     uint8_t dataByte[ I2C_MAX_DATA_LEN ];
 604     int     rc;
 605     int     i;
 606
 607     if (( rc = I2cReceiveBytes( i2cDev, dataByte, gByteCount )) != 0 )
 608     {
 609         LogError( "I2cRecvBytes failed: %d\n", rc );
 610         return;
 611     }
 612
 613     Log( "0x", dataByte[0] );
 614
 615     for ( i = 0; i < gByteCount; i++ )
 616     {
 617         Log( "%02x", dataByte[i] );
 618     }
 619     Log( "\n" );
 620
 621 } // ProcessRecvByteCommand
 622
 623 //***************************************************************************
 624 /**
 625 *   Issues a write byte command to write a byte to a particular address.
 626 */
 627
 628 void ProcessWriteByteCommand( int i2cDev, const char *addrStr, const char *dataStr )
 629 {
 630     uint8_t addr;
 631     uint8_t dataByte[ I2C_MAX_DATA_LEN ];
 632     uint8_t bytesParsed;
 633     int     rc;
 634
 635     if ( !ParseByte( addrStr, &addr ))
 636     {
 637         return;
 638     }
 639
 640     if ( !ParseBytes( dataStr, dataByte, sizeof( dataByte ), &bytesParsed ))
 641     {
 642         return;
 643     }
 644
 645     if (( rc = I2cWriteBytes( i2cDev, addr, dataByte, bytesParsed )) != 0 )
 646     {
 647         LogError( "I2cWriteBytes failed: %d\n", rc );
 648         return;
 649     }
 650
 651 } // ProcessWriteByteCommand
 652
 653 //***************************************************************************
 654 /**
 655 *   Issues a send byte command to write bytes with no address specified.
 656 */
 657
 658 void ProcessSendByteCommand( int i2cDev, const char *dataStr )
 659 {
 660     uint8_t dataByte[ I2C_MAX_DATA_LEN ];
 661     uint8_t bytesParsed;
 662     int     rc;
 663
 664     if ( !ParseBytes( dataStr, dataByte, sizeof( dataByte ), &bytesParsed ))
 665     {
 666         return;
 667     }
 668
 669     if (( rc = I2cSendBytes( i2cDev, dataByte, bytesParsed )) != 0 )
 670     {
 671         LogError( "I2cSendBytes failed: %d\n", rc );
 672         return;
 673     }
 674
 675 } // ProcessSendByteCommand
 676
 677 //***************************************************************************
 678 /**
 679 *   Usage
 680 */
 681
 682 void Usage( void )
 683 {
 684     fprintf( stderr, "Usage: i2c [options] i2c-addr cmd [cmd-arguments]\n" );
 685     fprintf( stderr, "Send I2C commands\n" );
 686     fprintf( stderr, "\n" );
 687     fprintf( stderr, "The following commands are supported:\n" );
 688     fprintf( stderr, "ReadByte addr         Retrieves byte(s) starting at the indicated address\n" );
 689     fprintf( stderr, "WriteByte addr data   Write byte(s) starting at the indicated address\n" );
 690     fprintf( stderr, "ReadByte2 addr        Retrieves two bytes from the indicated address\n" );
 691     fprintf( stderr, "WriteByte2 addr data  Writes two bytes into the indicated address\n" );
 692     fprintf( stderr, "ReadByte4 addr        Retrieves four bytes from the indicated address\n" );
 693     fprintf( stderr, "WriteByte4 addr data  Writes four bytes into the indicated address\n" );
 694     fprintf( stderr, "RecvByte              Retrieves byte(s)(no address specified)\n" );
 695     fprintf( stderr, "SendByte data         Writes byte(s)(no address specified)\n" );
 696     fprintf( stderr, "RecvByte2             Retrieves 2 bytes (no address specified)\n" );
 697     fprintf( stderr, "SendByte2 data        Writes 2 bytes(no address specified)\n" );
 698     fprintf( stderr, "RecvByte4             Retrieves 4 bytes (no address specified)\n" );
 699     fprintf( stderr, "SendByte4 data        Writes 4 bytes(no address specified)\n" );
 700     fprintf( stderr, "\n" );
 701     fprintf( stderr, "The above commands can be shortened to rb, wb, rb2, wb2, rb4, wb4, vb, sd, vb2 sb2 vb4, and sb4 \n" );
 702     fprintf( stderr, "respectively.\n" );
 703     fprintf( stderr, "\n" );
 704     fprintf( stderr, "The following options may be used:\n" );
 705     fprintf( stderr, "--count=n             Specifies how many bytes to read for ReadByte or RecvByte\n" );
 706     fprintf( stderr, "--version             Prints the SVN version of this program\n" );
 707     fprintf( stderr, "--verbose             Print additional information\n" );
 708     fprintf( stderr, "--help                Prints this information\n" );
 709 }
 710