gpio/gpio.c

   1 /*
   2  * gpio.c:
   3  *      Swiss-Army-Knife, Set-UID command-line interface to the Raspberry
   4  *      Pi's GPIO.
   5  *      Copyright (c) 2012 Gordon Henderson
   6  ***********************************************************************
   7  * This file is part of wiringPi:
   8  *      https://projects.drogon.net/raspberry-pi/wiringpi/
   9  *
  10  *    wiringPi is free software: you can redistribute it and/or modify
  11  *    it under the terms of the GNU Lesser General Public License as published by
  12  *    the Free Software Foundation, either version 3 of the License, or
  13  *    (at your option) any later version.
  14  *
  15  *    wiringPi is distributed in the hope that it will be useful,
  16  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *    GNU Lesser General Public License for more details.
  19  *
  20  *    You should have received a copy of the GNU Lesser General Public License
  21  *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
  22  ***********************************************************************
  23  */
  24
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <stdint.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <sys/types.h>
  33 #include <fcntl.h>
  34
  35 #include <wiringPi.h>
  36 #include <gertboard.h>
  37
  38 extern int wiringPiDebug ;
  39
  40 #ifndef TRUE
  41 #  define       TRUE    (1==1)
  42 #  define       FALSE   (1==2)
  43 #endif
  44
  45 #define VERSION "1.10"
  46
  47 static int wpMode ;
  48
  49 char *usage = "Usage: gpio -v\n"
  50               "       gpio -h\n"
  51               "       gpio [-g] <read/write/wb/pwm/mode> ...\n"
  52               "       gpio [-p] <read/write/wb> ...\n"
  53               "       gpio readall\n"
  54               "       gpio unexportall/exports ...\n"
  55               "       gpio export/edge/unexport ...\n"
  56               "       gpio drive <group> <value>\n"
  57               "       gpio pwm-bal/pwm-ms \n"
  58               "       gpio pwmr <range> \n"
  59               "       gpio pwmc <divider> \n"
  60               "       gpio load spi/i2c\n"
  61               "       gpio gbr <channel>\n"
  62               "       gpio gbw <channel> <value>" ;     // No trailing newline needed here.
  63
  64
  65 /*
  66  * changeOwner:
  67  *      Change the ownership of the file to the real userId of the calling
  68  *      program so we can access it.
  69  *********************************************************************************
  70  */
  71
  72 static void changeOwner (char *cmd, char *file)
  73 {
  74   uid_t uid = getuid () ;
  75   uid_t gid = getgid () ;
  76
  77   if (chown (file, uid, gid) != 0)
  78   {
  79     if (errno == ENOENT)        // Warn that it's not there
  80       fprintf (stderr, "%s: Warning: File not present: %s\n", cmd, file) ;
  81     else
  82     {
  83       fprintf (stderr, "%s: Unable to change ownership of %s: %s\n", cmd, file, strerror (errno)) ;
  84       exit (1) ;
  85     }
  86   }
  87 }
  88
  89
  90 /*
  91  * moduleLoaded:
  92  *      Return true/false if the supplied module is loaded
  93  *********************************************************************************
  94  */
  95
  96 static int moduleLoaded (char *modName)
  97 {
  98   int len   = strlen (modName) ;
  99   int found = FALSE ;
 100   FILE *fd = fopen ("/proc/modules", "r") ;
 101   char line [80] ;
 102
 103   if (fd == NULL)
 104   {
 105     fprintf (stderr, "gpio: Unable to check modules: %s\n", strerror (errno)) ;
 106     exit (1) ;
 107   }
 108
 109   while (fgets (line, 80, fd) != NULL)
 110   {
 111     if (strncmp (line, modName, len) != 0)
 112       continue ;
 113
 114     found = TRUE ;
 115     break ;
 116   }
 117
 118   fclose (fd) ;
 119
 120   return found ;
 121 }
 122
 123
 124 /*
 125  * doLoad:
 126  *      Load either the spi or i2c modules and change device ownerships, etc.
 127  *********************************************************************************
 128  */
 129
 130 static void _doLoadUsage (char *argv [])
 131 {
 132   fprintf (stderr, "Usage: %s load <spi/i2c> [SPI bufferSize in KB | I2C baudrate in Kb/sec]\n", argv [0]) ;
 133   exit (1) ;
 134 }
 135
 136 static void doLoad (int argc, char *argv [])
 137 {
 138   char *module1, *module2 ;
 139   char cmd [80] ;
 140   char *file1, *file2 ;
 141   char args1 [32], args2 [32] ;
 142
 143   if (argc < 3)
 144     _doLoadUsage (argv) ;
 145
 146   args1 [0] = args2 [0] = 0 ;
 147
 148   /**/ if (strcasecmp (argv [2], "spi") == 0)
 149   {
 150     module1 = "spidev" ;
 151     module2 = "spi_bcm2708" ;
 152     file1  = "/dev/spidev0.0" ;
 153     file2  = "/dev/spidev0.1" ;
 154     if (argc == 4)
 155       sprintf (args1, " bufsize=%d", atoi (argv [3]) * 1024) ;
 156     else if (argc > 4)
 157       _doLoadUsage (argv) ;
 158   }
 159   else if (strcasecmp (argv [2], "i2c") == 0)
 160   {
 161     module1 = "i2c_dev" ;
 162     module2 = "i2c_bcm2708" ;
 163     file1  = "/dev/i2c-0" ;
 164     file2  = "/dev/i2c-1" ;
 165     if (argc == 4)
 166       sprintf (args2, " baudrate=%d", atoi (argv [3]) * 1000) ;
 167     else if (argc > 4)
 168       _doLoadUsage (argv) ;
 169   }
 170   else
 171     _doLoadUsage (argv) ;
 172
 173   if (!moduleLoaded (module1))
 174   {
 175     sprintf (cmd, "modprobe %s%s", module1, args1) ;
 176     system (cmd) ;
 177   }
 178
 179   if (!moduleLoaded (module2))
 180   {
 181     sprintf (cmd, "modprobe %s%s", module2, args2) ;
 182     system (cmd) ;
 183   }
 184
 185   if (!moduleLoaded (module2))
 186   {
 187     fprintf (stderr, "%s: Unable to load %s\n", argv [0], module2) ;
 188     exit (1) ;
 189   }
 190
 191   sleep (1) ;   // To let things get settled
 192
 193   changeOwner (argv [0], file1) ;
 194   changeOwner (argv [0], file2) ;
 195 }
 196
 197
 198 /*
 199  * doReadall:
 200  *      Read all the GPIO pins
 201  *********************************************************************************
 202  */
 203
 204 static char *pinNames [] =
 205 {
 206   "GPIO 0", "GPIO 1", "GPIO 2", "GPIO 3", "GPIO 4", "GPIO 5", "GPIO 6", "GPIO 7",
 207   "SDA   ", "SCL   ",
 208   "CE0   ", "CE1   ", "MOSI  ", "MISO  ", "SCLK  ",
 209   "TxD   ", "RxD   ",
 210   "GPIO 8", "GPIO 9", "GPIO10", "GPIO11",
 211 } ;
 212
 213 static char *alts [] =
 214 {
 215   "IN  ", "OUT ", "ALT0", "ALT1", "ALT2", "ALT3", "ALT4", "ALT5", "XXXX"
 216 } ;
 217
 218 static void doReadall (void)
 219 {
 220   int pin ;
 221
 222   printf ("+----------+------+--------+------+-------+\n") ;
 223   printf ("| wiringPi | GPIO | Name   | Mode | Value |\n") ;
 224   printf ("+----------+------+--------+------+-------+\n") ;
 225
 226   for (pin = 0 ; pin < 64 ; ++pin)
 227   {
 228     if (wpiPinToGpio (pin) == -1)
 229       continue ;
 230
 231     printf ("| %6d   | %3d  | %s | %s | %s  |\n",
 232         pin, wpiPinToGpio (pin),
 233         pinNames [pin],
 234         alts [getAlt (pin)],
 235         digitalRead (pin) == HIGH ? "High" : "Low ") ;
 236   }
 237
 238   printf ("+----------+------+--------+------+-------+\n") ;
 239 }
 240
 241
 242 /*
 243  * doExports:
 244  *      List all GPIO exports
 245  *********************************************************************************
 246  */
 247
 248 static void doExports (int argc, char *argv [])
 249 {
 250   int fd ;
 251   int i, l, first ;
 252   char fName [128] ;
 253   char buf [16] ;
 254
 255 // Rather crude, but who knows what others are up to...
 256
 257   for (first = 0, i = 0 ; i < 64 ; ++i)
 258   {
 259
 260 // Try to read the direction
 261
 262     sprintf (fName, "/sys/class/gpio/gpio%d/direction", i) ;
 263     if ((fd = open (fName, O_RDONLY)) == -1)
 264       continue ;
 265
 266     if (first == 0)
 267     {
 268       ++first ;
 269       printf ("GPIO Pins exported:\n") ;
 270     }
 271
 272     printf ("%4d: ", i) ;
 273
 274     if ((l = read (fd, buf, 16)) == 0)
 275       sprintf (buf, "%s", "?") ;
 276
 277     buf [l] = 0 ;
 278     if ((buf [strlen (buf) - 1]) == '\n')
 279       buf [strlen (buf) - 1] = 0 ;
 280
 281     printf ("%-3s", buf) ;
 282
 283     close (fd) ;
 284
 285 // Try to Read the value
 286
 287     sprintf (fName, "/sys/class/gpio/gpio%d/value", i) ;
 288     if ((fd = open (fName, O_RDONLY)) == -1)
 289     {
 290       printf ("No Value file (huh?)\n") ;
 291       continue ;
 292     }
 293
 294     if ((l = read (fd, buf, 16)) == 0)
 295       sprintf (buf, "%s", "?") ;
 296
 297     buf [l] = 0 ;
 298     if ((buf [strlen (buf) - 1]) == '\n')
 299       buf [strlen (buf) - 1] = 0 ;
 300
 301     printf ("  %s", buf) ;
 302
 303 // Read any edge trigger file
 304
 305     sprintf (fName, "/sys/class/gpio/gpio%d/edge", i) ;
 306     if ((fd = open (fName, O_RDONLY)) == -1)
 307     {
 308       printf ("\n") ;
 309       continue ;
 310     }
 311
 312     if ((l = read (fd, buf, 16)) == 0)
 313       sprintf (buf, "%s", "?") ;
 314
 315     buf [l] = 0 ;
 316     if ((buf [strlen (buf) - 1]) == '\n')
 317       buf [strlen (buf) - 1] = 0 ;
 318
 319     printf ("  %-8s\n", buf) ;
 320
 321     close (fd) ;
 322   }
 323 }
 324
 325
 326 /*
 327  * doExport:
 328  *      gpio export pin mode
 329  *      This uses the /sys/class/gpio device interface.
 330  *********************************************************************************
 331  */
 332
 333 void doExport (int argc, char *argv [])
 334 {
 335   FILE *fd ;
 336   int pin ;
 337   char *mode ;
 338   char fName [128] ;
 339
 340   if (argc != 4)
 341   {
 342     fprintf (stderr, "Usage: %s export pin mode\n", argv [0]) ;
 343     exit (1) ;
 344   }
 345
 346   pin = atoi (argv [2]) ;
 347
 348   mode = argv [3] ;
 349
 350   if ((fd = fopen ("/sys/class/gpio/export", "w")) == NULL)
 351   {
 352     fprintf (stderr, "%s: Unable to open GPIO export interface: %s\n", argv [0], strerror (errno)) ;
 353     exit (1) ;
 354   }
 355
 356   fprintf (fd, "%d\n", pin) ;
 357   fclose (fd) ;
 358
 359   sprintf (fName, "/sys/class/gpio/gpio%d/direction", pin) ;
 360   if ((fd = fopen (fName, "w")) == NULL)
 361   {
 362     fprintf (stderr, "%s: Unable to open GPIO direction interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ;
 363     exit (1) ;
 364   }
 365
 366   /**/ if ((strcasecmp (mode, "in")  == 0) || (strcasecmp (mode, "input")  == 0))
 367     fprintf (fd, "in\n") ;
 368   else if ((strcasecmp (mode, "out") == 0) || (strcasecmp (mode, "output") == 0))
 369     fprintf (fd, "out\n") ;
 370   else
 371   {
 372     fprintf (stderr, "%s: Invalid mode: %s. Should be in or out\n", argv [1], mode) ;
 373     exit (1) ;
 374   }
 375
 376   fclose (fd) ;
 377
 378 // Change ownership so the current user can actually use it!
 379
 380   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
 381   changeOwner (argv [0], fName) ;
 382
 383   sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ;
 384   changeOwner (argv [0], fName) ;
 385
 386 }
 387
 388
 389 /*
 390  * doEdge:
 391  *      gpio edge pin mode
 392  *      Easy access to changing the edge trigger on a GPIO pin
 393  *      This uses the /sys/class/gpio device interface.
 394  *********************************************************************************
 395  */
 396
 397 void doEdge (int argc, char *argv [])
 398 {
 399   FILE *fd ;
 400   int pin ;
 401   char *mode ;
 402   char fName [128] ;
 403
 404   if (argc != 4)
 405   {
 406     fprintf (stderr, "Usage: %s edge pin mode\n", argv [0]) ;
 407     exit (1) ;
 408   }
 409
 410   pin  = atoi (argv [2]) ;
 411   mode = argv [3] ;
 412
 413 // Export the pin and set direction to input
 414
 415   if ((fd = fopen ("/sys/class/gpio/export", "w")) == NULL)
 416   {
 417     fprintf (stderr, "%s: Unable to open GPIO export interface: %s\n", argv [0], strerror (errno)) ;
 418     exit (1) ;
 419   }
 420
 421   fprintf (fd, "%d\n", pin) ;
 422   fclose (fd) ;
 423
 424   sprintf (fName, "/sys/class/gpio/gpio%d/direction", pin) ;
 425   if ((fd = fopen (fName, "w")) == NULL)
 426   {
 427     fprintf (stderr, "%s: Unable to open GPIO direction interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ;
 428     exit (1) ;
 429   }
 430
 431   fprintf (fd, "in\n") ;
 432   fclose (fd) ;
 433
 434   sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ;
 435   if ((fd = fopen (fName, "w")) == NULL)
 436   {
 437     fprintf (stderr, "%s: Unable to open GPIO edge interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ;
 438     exit (1) ;
 439   }
 440
 441   /**/ if (strcasecmp (mode, "none")    == 0) fprintf (fd, "none\n") ;
 442   else if (strcasecmp (mode, "rising")  == 0) fprintf (fd, "rising\n") ;
 443   else if (strcasecmp (mode, "falling") == 0) fprintf (fd, "falling\n") ;
 444   else if (strcasecmp (mode, "both")    == 0) fprintf (fd, "both\n") ;
 445   else
 446   {
 447     fprintf (stderr, "%s: Invalid mode: %s. Should be none, rising, falling or both\n", argv [1], mode) ;
 448     exit (1) ;
 449   }
 450
 451 // Change ownership of the value and edge files, so the current user can actually use it!
 452
 453   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
 454   changeOwner (argv [0], fName) ;
 455
 456   sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ;
 457   changeOwner (argv [0], fName) ;
 458
 459   fclose (fd) ;
 460 }
 461
 462
 463 /*
 464  * doUnexport:
 465  *      gpio unexport pin
 466  *      This uses the /sys/class/gpio device interface.
 467  *********************************************************************************
 468  */
 469
 470 void doUnexport (int argc, char *argv [])
 471 {
 472   FILE *fd ;
 473   int pin ;
 474
 475   if (argc != 3)
 476   {
 477     fprintf (stderr, "Usage: %s unexport pin\n", argv [0]) ;
 478     exit (1) ;
 479   }
 480
 481   pin = atoi (argv [2]) ;
 482
 483   if ((fd = fopen ("/sys/class/gpio/unexport", "w")) == NULL)
 484   {
 485     fprintf (stderr, "%s: Unable to open GPIO export interface\n", argv [0]) ;
 486     exit (1) ;
 487   }
 488
 489   fprintf (fd, "%d\n", pin) ;
 490   fclose (fd) ;
 491 }
 492
 493
 494 /*
 495  * doUnexportAll:
 496  *      gpio unexportall
 497  *      Un-Export all the GPIO pins.
 498  *      This uses the /sys/class/gpio device interface.
 499  *********************************************************************************
 500  */
 501
 502 void doUnexportall (int argc, char *argv [])
 503 {
 504   FILE *fd ;
 505   int pin ;
 506
 507   for (pin = 0 ; pin < 63 ; ++pin)
 508   {
 509     if ((fd = fopen ("/sys/class/gpio/unexport", "w")) == NULL)
 510     {
 511       fprintf (stderr, "%s: Unable to open GPIO export interface\n", argv [0]) ;
 512       exit (1) ;
 513     }
 514     fprintf (fd, "%d\n", pin) ;
 515     fclose (fd) ;
 516   }
 517 }
 518
 519
 520 /*
 521  * doMode:
 522  *      gpio mode pin mode ...
 523  *********************************************************************************
 524  */
 525
 526 void doMode (int argc, char *argv [])
 527 {
 528   int pin ;
 529   char *mode ;
 530
 531   if (argc != 4)
 532   {
 533     fprintf (stderr, "Usage: %s mode pin mode\n", argv [0]) ;
 534     exit (1) ;
 535   }
 536
 537   pin = atoi (argv [2]) ;
 538
 539   if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
 540     return ;
 541
 542   mode = argv [3] ;
 543
 544   /**/ if (strcasecmp (mode, "in")   == 0) pinMode         (pin, INPUT) ;
 545   else if (strcasecmp (mode, "out")  == 0) pinMode         (pin, OUTPUT) ;
 546   else if (strcasecmp (mode, "pwm")  == 0) pinMode         (pin, PWM_OUTPUT) ;
 547   else if (strcasecmp (mode, "up")   == 0) pullUpDnControl (pin, PUD_UP) ;
 548   else if (strcasecmp (mode, "down") == 0) pullUpDnControl (pin, PUD_DOWN) ;
 549   else if (strcasecmp (mode, "tri")  == 0) pullUpDnControl (pin, PUD_OFF) ;
 550   else
 551   {
 552     fprintf (stderr, "%s: Invalid mode: %s. Should be in/out/pwm/up/down/tri\n", argv [1], mode) ;
 553     exit (1) ;
 554   }
 555 }
 556
 557
 558 /*
 559  * doPadDrive:
 560  *      gpio drive group value
 561  *********************************************************************************
 562  */
 563
 564 static void doPadDrive (int argc, char *argv [])
 565 {
 566   int group, val ;
 567
 568   if (argc != 4)
 569   {
 570     fprintf (stderr, "Usage: %s drive group value\n", argv [0]) ;
 571     exit (1) ;
 572   }
 573
 574   group = atoi (argv [2]) ;
 575   val   = atoi (argv [3]) ;
 576
 577   if ((group < 0) || (group > 2))
 578   {
 579     fprintf (stderr, "%s: drive group not 0, 1 or 2: %d\n", argv [0], group) ;
 580     exit (1) ;
 581   }
 582
 583   if ((val < 0) || (val > 7))
 584   {
 585     fprintf (stderr, "%s: drive value not 0-7: %d\n", argv [0], val) ;
 586     exit (1) ;
 587   }
 588
 589   setPadDrive (group, val) ;
 590 }
 591
 592
 593 /*
 594  * doGbw:
 595  *      gpio gbw channel value
 596  *      Gertboard Write - To the Analog output
 597  *********************************************************************************
 598  */
 599
 600 static void doGbw (int argc, char *argv [])
 601 {
 602   int channel, value ;
 603
 604   if (argc != 4)
 605   {
 606     fprintf (stderr, "Usage: %s gbr <channel> <value>\n", argv [0]) ;
 607     exit (1) ;
 608   }
 609
 610   channel = atoi (argv [2]) ;
 611   value   = atoi (argv [3]) ;
 612
 613   if ((channel < 0) || (channel > 1))
 614   {
 615     fprintf (stderr, "%s: channel must be 0 or 1\n", argv [0]) ;
 616     exit (1) ;
 617   }
 618
 619   if ((value < 0) || (value > 1023))
 620   {
 621     fprintf (stderr, "%s: value must be from 0 to 255\n", argv [0]) ;
 622     exit (1) ;
 623   }
 624
 625   if (gertboardSPISetup () == -1)
 626   {
 627     fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ;
 628     exit (1) ;
 629   }
 630
 631   gertboardAnalogWrite (channel, value) ;
 632 }
 633
 634
 635 /*
 636  * doGbr:
 637  *      gpio gbr channel
 638  *      From the analog input
 639  *********************************************************************************
 640  */
 641
 642 static void doGbr (int argc, char *argv [])
 643 {
 644   int channel ;
 645
 646   if (argc != 3)
 647   {
 648     fprintf (stderr, "Usage: %s gbr <channel>\n", argv [0]) ;
 649     exit (1) ;
 650   }
 651
 652   channel = atoi (argv [2]) ;
 653
 654   if ((channel < 0) || (channel > 1))
 655   {
 656     fprintf (stderr, "%s: channel must be 0 or 1\n", argv [0]) ;
 657     exit (1) ;
 658   }
 659
 660   if (gertboardSPISetup () == -1)
 661   {
 662     fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ;
 663     exit (1) ;
 664   }
 665
 666   printf ("%d\n",gertboardAnalogRead (channel)) ;
 667 }
 668
 669
 670
 671 /*
 672  * doWrite:
 673  *      gpio write pin value
 674  *********************************************************************************
 675  */
 676
 677 static void doWrite (int argc, char *argv [])
 678 {
 679   int pin, val ;
 680
 681   if (argc != 4)
 682   {
 683     fprintf (stderr, "Usage: %s write pin value\n", argv [0]) ;
 684     exit (1) ;
 685   }
 686
 687   pin = atoi (argv [2]) ;
 688
 689   if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
 690     return ;
 691
 692   /**/ if ((strcasecmp (argv [3], "up") == 0) || (strcasecmp (argv [3], "on") == 0))
 693     val = 1 ;
 694   else if ((strcasecmp (argv [3], "down") == 0) || (strcasecmp (argv [3], "off") == 0))
 695     val = 0 ;
 696   else
 697     val = atoi (argv [3]) ;
 698
 699   /**/ if (val == 0)
 700     digitalWrite (pin, LOW) ;
 701   else
 702     digitalWrite (pin, HIGH) ;
 703 }
 704
 705 /*
 706  * doWriteByte:
 707  *      gpio write value
 708  *********************************************************************************
 709  */
 710
 711 static void doWriteByte (int argc, char *argv [])
 712 {
 713   int val ;
 714
 715   if (argc != 3)
 716   {
 717     fprintf (stderr, "Usage: %s wb value\n", argv [0]) ;
 718     exit (1) ;
 719   }
 720
 721   val = (int)strtol (argv [2], NULL, 0) ;
 722
 723   digitalWriteByte (val) ;
 724 }
 725
 726
 727 /*
 728  * doRead:
 729  *      Read a pin and return the value
 730  *********************************************************************************
 731  */
 732
 733 void doRead (int argc, char *argv [])
 734 {
 735   int pin, val ;
 736
 737   if (argc != 3)
 738   {
 739     fprintf (stderr, "Usage: %s read pin\n", argv [0]) ;
 740     exit (1) ;
 741   }
 742
 743   pin = atoi (argv [2]) ;
 744
 745   if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
 746   {
 747     printf ("0\n") ;
 748     return ;
 749   }
 750
 751   val = digitalRead (pin) ;
 752
 753   printf ("%s\n", val == 0 ? "0" : "1") ;
 754 }
 755
 756
 757 /*
 758  * doPwm:
 759  *      Output a PWM value on a pin
 760  *********************************************************************************
 761  */
 762
 763 void doPwm (int argc, char *argv [])
 764 {
 765   int pin, val ;
 766
 767   if (argc != 4)
 768   {
 769     fprintf (stderr, "Usage: %s pwm <pin> <value>\n", argv [0]) ;
 770     exit (1) ;
 771   }
 772
 773   pin = atoi (argv [2]) ;
 774
 775   if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
 776     return ;
 777
 778   val = atoi (argv [3]) ;
 779
 780   pwmWrite (pin, val) ;
 781 }
 782
 783
 784 /*
 785  * doPwmMode: doPwmRange: doPwmClock:
 786  *      Change the PWM mode, range and clock divider values
 787  *********************************************************************************
 788  */
 789
 790 static void doPwmMode (int mode)
 791 {
 792   pwmSetMode (mode) ;
 793 }
 794
 795 static void doPwmRange (int argc, char *argv [])
 796 {
 797   unsigned int range ;
 798
 799   if (argc != 3)
 800   {
 801     fprintf (stderr, "Usage: %s pwmr <range>\n", argv [0]) ;
 802     exit (1) ;
 803   }
 804
 805   range = (unsigned int)strtoul (argv [2], NULL, 10) ;
 806
 807   if (range == 0)
 808   {
 809     fprintf (stderr, "%s: range must be > 0\n", argv [0]) ;
 810     exit (1) ;
 811   }
 812
 813   pwmSetRange (range) ;
 814 }
 815
 816 static void doPwmClock (int argc, char *argv [])
 817 {
 818   unsigned int clock ;
 819
 820   if (argc != 3)
 821   {
 822     fprintf (stderr, "Usage: %s pwmc <clock>\n", argv [0]) ;
 823     exit (1) ;
 824   }
 825
 826   clock = (unsigned int)strtoul (argv [2], NULL, 10) ;
 827
 828   if ((clock < 1) || (clock > 4095))
 829   {
 830     fprintf (stderr, "%s: clock must be between 0 and 4096\n", argv [0]) ;
 831     exit (1) ;
 832   }
 833
 834   pwmSetClock (clock) ;
 835 }
 836
 837
 838 /*
 839  * main:
 840  *      Start here
 841  *********************************************************************************
 842  */
 843
 844 int main (int argc, char *argv [])
 845 {
 846   int i ;
 847
 848   if (getenv ("WIRINGPI_DEBUG") != NULL)
 849   {
 850     printf ("gpio: wiringPi debug mode enabled\n") ;
 851     wiringPiDebug = TRUE ;
 852   }
 853
 854   if (argc == 1)
 855   {
 856     fprintf (stderr, "%s\n", usage) ;
 857     return 1 ;
 858   }
 859
 860   if (strcasecmp (argv [1], "-h") == 0)
 861   {
 862     printf ("%s: %s\n", argv [0], usage) ;
 863     return 0 ;
 864   }
 865
 866   if (strcasecmp (argv [1], "-v") == 0)
 867   {
 868     printf ("gpio version: %s\n", VERSION) ;
 869     printf ("Copyright (c) 2012 Gordon Henderson\n") ;
 870     printf ("This is free software with ABSOLUTELY NO WARRANTY.\n") ;
 871     printf ("For details type: %s -warranty\n", argv [0]) ;
 872     printf ("\n") ;
 873     printf ("This Raspberry Pi is a revision %d board.\n", piBoardRev ()) ;
 874     return 0 ;
 875   }
 876
 877   if (strcasecmp (argv [1], "-warranty") == 0)
 878   {
 879     printf ("gpio version: %s\n", VERSION) ;
 880     printf ("Copyright (c) 2012 Gordon Henderson\n") ;
 881     printf ("\n") ;
 882     printf ("    This program is free software; you can redistribute it and/or modify\n") ;
 883     printf ("    it under the terms of the GNU Leser General Public License as published\n") ;
 884     printf ("    by the Free Software Foundation, either version 3 of the License, or\n") ;
 885     printf ("    (at your option) any later version.\n") ;
 886     printf ("\n") ;
 887     printf ("    This program is distributed in the hope that it will be useful,\n") ;
 888     printf ("    but WITHOUT ANY WARRANTY; without even the implied warranty of\n") ;
 889     printf ("    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n") ;
 890     printf ("    GNU Lesser General Public License for more details.\n") ;
 891     printf ("\n") ;
 892     printf ("    You should have received a copy of the GNU Lesser General Public License\n") ;
 893     printf ("    along with this program. If not, see <http://www.gnu.org/licenses/>.\n") ;
 894     printf ("\n") ;
 895     return 0 ;
 896   }
 897
 898   if (geteuid () != 0)
 899   {
 900     fprintf (stderr, "%s: Must be root to run. Program should be suid root. This is an error.\n", argv [0]) ;
 901     return 1 ;
 902   }
 903
 904 // Initial test for /sys/class/gpio operations:
 905
 906   /**/ if (strcasecmp (argv [1], "exports"    ) == 0)   { doExports     (argc, argv) ;  return 0 ; }
 907   else if (strcasecmp (argv [1], "export"     ) == 0)   { doExport      (argc, argv) ;  return 0 ; }
 908   else if (strcasecmp (argv [1], "edge"       ) == 0)   { doEdge        (argc, argv) ;  return 0 ; }
 909   else if (strcasecmp (argv [1], "unexportall") == 0)   { doUnexportall (argc, argv) ;  return 0 ; }
 910   else if (strcasecmp (argv [1], "unexport"   ) == 0)   { doUnexport    (argc, argv) ;  return 0 ; }
 911
 912 // Check for load command:
 913
 914   if (strcasecmp (argv [1], "load" ) == 0)      { doLoad     (argc, argv) ; return 0 ; }
 915
 916 // Gertboard commands
 917
 918   if (strcasecmp (argv [1], "gbr" ) == 0)       { doGbr (argc, argv) ; return 0 ; }
 919   if (strcasecmp (argv [1], "gbw" ) == 0)       { doGbw (argc, argv) ; return 0 ; }
 920
 921 // Check for -g argument
 922
 923   if (strcasecmp (argv [1], "-g") == 0)
 924   {
 925     if (wiringPiSetupGpio () == -1)
 926     {
 927       fprintf (stderr, "%s: Unable to initialise GPIO mode.\n", argv [0]) ;
 928       exit (1) ;
 929     }
 930
 931     for (i = 2 ; i < argc ; ++i)
 932       argv [i - 1] = argv [i] ;
 933     --argc ;
 934     wpMode = WPI_MODE_GPIO ;
 935   }
 936
 937 // Check for -p argument for PiFace
 938
 939   else if (strcasecmp (argv [1], "-p") == 0)
 940   {
 941     if (wiringPiSetupPiFaceForGpioProg () == -1)
 942     {
 943       fprintf (stderr, "%s: Unable to initialise PiFace.\n", argv [0]) ;
 944       exit (1) ;
 945     }
 946
 947     for (i = 2 ; i < argc ; ++i)
 948       argv [i - 1] = argv [i] ;
 949     --argc ;
 950     wpMode = WPI_MODE_PIFACE ;
 951   }
 952
 953 // Default to wiringPi mode
 954
 955   else
 956   {
 957     if (wiringPiSetup () == -1)
 958     {
 959       fprintf (stderr, "%s: Unable to initialise wiringPi mode\n", argv [0]) ;
 960       exit (1) ;
 961     }
 962     wpMode = WPI_MODE_PINS ;
 963   }
 964
 965 // Check for PWM or Pad Drive operations
 966
 967   if (wpMode != WPI_MODE_PIFACE)
 968   {
 969     if (strcasecmp (argv [1], "pwm-bal") == 0)  { doPwmMode  (PWM_MODE_BAL) ;   return 0 ; }
 970     if (strcasecmp (argv [1], "pwm-ms")  == 0)  { doPwmMode  (PWM_MODE_MS) ;    return 0 ; }
 971     if (strcasecmp (argv [1], "pwmr")    == 0)  { doPwmRange (argc, argv) ;     return 0 ; }
 972     if (strcasecmp (argv [1], "pwmc")    == 0)  { doPwmClock (argc, argv) ;     return 0 ; }
 973     if (strcasecmp (argv [1], "drive")   == 0)  { doPadDrive (argc, argv) ;     return 0 ; }
 974   }
 975
 976 // Check for wiring commands
 977
 978   /**/ if (strcasecmp (argv [1], "readall" ) == 0) doReadall   () ;
 979   else if (strcasecmp (argv [1], "read" )    == 0) doRead      (argc, argv) ;
 980   else if (strcasecmp (argv [1], "write")    == 0) doWrite     (argc, argv) ;
 981   else if (strcasecmp (argv [1], "wb")       == 0) doWriteByte (argc, argv) ;
 982   else if (strcasecmp (argv [1], "pwm"  )    == 0) doPwm       (argc, argv) ;
 983   else if (strcasecmp (argv [1], "mode" )    == 0) doMode      (argc, argv) ;
 984   else
 985   {
 986     fprintf (stderr, "%s: Unknown command: %s.\n", argv [0], argv [1]) ;
 987     exit (1) ;
 988   }
 989   return 0 ;
 990 }