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