heuzef
/
WiringPi
kopie van https://github.com/WiringPi/WiringPi.git
1
0
Vork 0
Code Kwesties 0 Publicaties 9 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
127 Commits
10 Branches
53 MiB
 
 
 
 
 
Tree: b6623fd1df
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'b6623fd1df'
${ noResults }
WiringPi/gpio/gpio.c

1412 regels
34 KiB
Ruw Blame Geschiedenis 

  1. /*

  2.  * gpio.c:

  3.  *	Swiss-Army-Knife, Set-UID command-line interface to the Raspberry

  4.  *	Pi's GPIO.

  5.  *	Copyright (c) 2012-2015 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 <ctype.h>

  30. #include <string.h>

  31. #include <unistd.h>

  32. #include <errno.h>

  33. #include <fcntl.h>

  34. #include <sys/types.h>

  35. #include <sys/stat.h>

  36. 

  37. #include <wiringPi.h>

  38. #include <wpiExtensions.h>

  39. 

  40. #include <gertboard.h>

  41. #include <piFace.h>

  42. 

  43. #include "version.h"

  44. 

  45. extern int wiringPiDebug ;

  46. 

  47. // External functions I can't be bothered creating a separate .h file for:

  48. 

  49. extern void doReadall    (void) ;

  50. extern void doAllReadall (void) ;

  51. extern void doPins       (void) ;

  52. 

  53. #ifndef TRUE

  54. #  define	TRUE	(1==1)

  55. #  define	FALSE	(1==2)

  56. #endif

  57. 

  58. #define	PI_USB_POWER_CONTROL	38

  59. #define	I2CDETECT		"/usr/sbin/i2cdetect"

  60. 

  61. int wpMode ;

  62. 

  63. char *usage = "Usage: gpio -v\n"

  64.               "       gpio -h\n"

  65.               "       gpio [-g|-1] [-x extension:params] ...\n"

  66.               "       gpio [-p] <read/write/wb> ...\n"

  67.               "       gpio <read/write/aread/awritewb/pwm/clock/mode> ...\n"

  68. 	      "       gpio readall/reset\n"

  69. 	      "       gpio unexportall/exports\n"

  70. 	      "       gpio export/edge/unexport ...\n"

  71. 	      "       gpio wfi <pin> <mode>\n"

  72. 	      "       gpio drive <group> <value>\n"

  73.         "       gpio mode <pin>\n"

  74.         "       gpio mode <pin> <mode>\n"

  75. 	      "       gpio pwm-bal/pwm-ms \n"

  76. 	      "       gpio pwmr <range> \n"

  77. 	      "       gpio pwmc <divider> \n"

  78. 	      "       gpio load spi/i2c\n"

  79. 	      "       gpio unload spi/i2c\n"

  80. 	      "       gpio i2cd/i2cdetect\n"

  81. 	      "       gpio usbp high/low\n"

  82. 	      "       gpio gbr <channel>\n"

  83. 	      "       gpio gbw <channel> <value>" ;	// No trailing newline needed here.

  84. 

  85. 

  86. #ifdef	NOT_FOR_NOW

  87. /*

  88.  * decodePin:

  89.  *	Decode a pin "number" which can actually be a pin name to represent

  90.  *	one of the Pi's on-board pins.

  91.  *********************************************************************************

  92.  */

  93. 

  94. static int decodePin (const char *str)

  95. {

  96. 

  97. // The first case - see if it's a number:

  98. 

  99.   if (isdigit (str [0]))

  100.     return atoi (str) ;

  101. 

  102.   return 0 ;

  103. }

  104. #endif

  105. 

  106. 

  107. /*

  108.  * changeOwner:

  109.  *	Change the ownership of the file to the real userId of the calling

  110.  *	program so we can access it.

  111.  *********************************************************************************

  112.  */

  113. 

  114. static void changeOwner (char *cmd, char *file)

  115. {

  116.   uid_t uid = getuid () ;

  117.   uid_t gid = getgid () ;

  118. 

  119.   if (chown (file, uid, gid) != 0)

  120.   {

  121. 

  122. // Removed (ignoring) the check for not existing as I'm fed-up with morons telling me that

  123. //	the warning message is an error.

  124. 

  125.     if (errno != ENOENT)

  126.       fprintf (stderr, "%s: Unable to change ownership of %s: %s\n", cmd, file, strerror (errno)) ;

  127.   }

  128. }

  129. 

  130. 

  131. /*

  132.  * moduleLoaded:

  133.  *	Return true/false if the supplied module is loaded

  134.  *********************************************************************************

  135.  */

  136. 

  137. static int moduleLoaded (char *modName)

  138. {

  139.   int len   = strlen (modName) ;

  140.   int found = FALSE ;

  141.   FILE *fd = fopen ("/proc/modules", "r") ;

  142.   char line [80] ;

  143. 

  144.   if (fd == NULL)

  145.   {

  146.     fprintf (stderr, "gpio: Unable to check /proc/modules: %s\n", strerror (errno)) ;

  147.     exit (1) ;

  148.   }

  149. 

  150.   while (fgets (line, 80, fd) != NULL)

  151.   {

  152.     if (strncmp (line, modName, len) != 0)

  153.       continue ;

  154. 

  155.     found = TRUE ;

  156.     break ;

  157.   }

  158. 

  159.   fclose (fd) ;

  160. 

  161.   return found ;

  162. }

  163. 

  164. 

  165. /*

  166.  * doLoad:

  167.  *	Load either the spi or i2c modules and change device ownerships, etc.

  168.  *********************************************************************************

  169.  */

  170. 

  171. static void checkDevTree (char *argv [])

  172. {

  173.   struct stat statBuf ;

  174. 

  175.   if (stat ("/proc/device-tree", &statBuf) == 0)	// We're on a devtree system ...

  176.   {

  177.     fprintf (stderr,

  178. "%s: Unable to load/unload modules as this Pi has the device tree enabled.\n"

  179. "  You need to run the raspi-config program (as root) and select the\n"

  180. "  modules (SPI or I2C) that you wish to load/unload there and reboot.\n"

  181. "  There is more information here:\n"

  182. "      https://www.raspberrypi.org/forums/viewtopic.php?f=28&t=97314\n", argv [0]) ;

  183.     exit (1) ;

  184.   }

  185. }

  186. 

  187. static void _doLoadUsage (char *argv [])

  188. {

  189.   fprintf (stderr, "Usage: %s load <spi/i2c> [I2C baudrate in Kb/sec]\n", argv [0]) ;

  190.   exit (1) ;

  191. }

  192. 

  193. static void doLoad (int argc, char *argv [])

  194. {

  195.   char *module1, *module2 ;

  196.   char cmd [80] ;

  197.   char *file1, *file2 ;

  198.   char args1 [32], args2 [32] ;

  199. 

  200.   checkDevTree (argv) ;

  201. 

  202.   if (argc < 3)

  203.     _doLoadUsage (argv) ;

  204. 

  205.   args1 [0] = args2 [0] = 0 ;

  206. 

  207.   /**/ if (strcasecmp (argv [2], "spi") == 0)

  208.   {

  209.     module1 = "spidev" ;

  210.     module2 = "spi_bcm2708" ;

  211.     file1  = "/dev/spidev0.0" ;

  212.     file2  = "/dev/spidev0.1" ;

  213.     if (argc == 4)

  214.     {

  215.       fprintf (stderr, "%s: Unable to set the buffer size now. Load aborted. Please see the man page.\n", argv [0]) ;

  216.       exit (1) ;

  217.     }

  218.     else if (argc > 4)

  219.       _doLoadUsage (argv) ;

  220.   }

  221.   else if (strcasecmp (argv [2], "i2c") == 0)

  222.   {

  223.     module1 = "i2c_dev" ;

  224.     module2 = "i2c_bcm2708" ;

  225.     file1  = "/dev/i2c-0" ;

  226.     file2  = "/dev/i2c-1" ;

  227.     if (argc == 4)

  228.       sprintf (args2, " baudrate=%d", atoi (argv [3]) * 1000) ;

  229.     else if (argc > 4)

  230.       _doLoadUsage (argv) ;

  231.   }

  232.   else

  233.     _doLoadUsage (argv) ;

  234. 

  235.   if (!moduleLoaded (module1))

  236.   {

  237.     sprintf (cmd, "/sbin/modprobe %s%s", module1, args1) ;

  238.     system (cmd) ;

  239.   }

  240. 

  241.   if (!moduleLoaded (module2))

  242.   {

  243.     sprintf (cmd, "/sbin/modprobe %s%s", module2, args2) ;

  244.     system (cmd) ;

  245.   }

  246. 

  247.   if (!moduleLoaded (module2))

  248.   {

  249.     fprintf (stderr, "%s: Unable to load %s\n", argv [0], module2) ;

  250.     exit (1) ;

  251.   }

  252. 

  253.   sleep (1) ;	// To let things get settled

  254. 

  255.   changeOwner (argv [0], file1) ;

  256.   changeOwner (argv [0], file2) ;

  257. }

  258. 

  259. 

  260. /*

  261.  * doUnLoad:

  262.  *	Un-Load either the spi or i2c modules and change device ownerships, etc.

  263.  *********************************************************************************

  264.  */

  265. 

  266. static void _doUnLoadUsage (char *argv [])

  267. {

  268.   fprintf (stderr, "Usage: %s unload <spi/i2c>\n", argv [0]) ;

  269.   exit (1) ;

  270. }

  271. 

  272. static void doUnLoad (int argc, char *argv [])

  273. {

  274.   char *module1, *module2 ;

  275.   char cmd [80] ;

  276. 

  277.   checkDevTree (argv) ;

  278. 

  279.   if (argc != 3)

  280.     _doUnLoadUsage (argv) ;

  281. 

  282.   /**/ if (strcasecmp (argv [2], "spi") == 0)

  283.   {

  284.     module1 = "spidev" ;

  285.     module2 = "spi_bcm2708" ;

  286.   }

  287.   else if (strcasecmp (argv [2], "i2c") == 0)

  288.   {

  289.     module1 = "i2c_dev" ;

  290.     module2 = "i2c_bcm2708" ;

  291.   }

  292.   else

  293.     _doUnLoadUsage (argv) ;

  294. 

  295.   if (moduleLoaded (module1))

  296.   {

  297.     sprintf (cmd, "/sbin/rmmod %s", module1) ;

  298.     system (cmd) ;

  299.   }

  300. 

  301.   if (moduleLoaded (module2))

  302.   {

  303.     sprintf (cmd, "/sbin/rmmod %s", module2) ;

  304.     system (cmd) ;

  305.   }

  306. }

  307. 

  308. 

  309. /*

  310.  * doI2Cdetect:

  311.  *	Run the i2cdetect command with the right runes for this Pi revision

  312.  *********************************************************************************

  313.  */

  314. 

  315. static void doI2Cdetect (int argc, char *argv [])

  316. {

  317.   int port = piBoardRev () == 1 ? 0 : 1 ;

  318.   char command [128] ;

  319.   struct stat statBuf ;

  320. 

  321.   if (stat (I2CDETECT, &statBuf) < 0)

  322.   {

  323.     fprintf (stderr, "%s: Unable to find i2cdetect command: %s\n", argv [0], strerror (errno)) ;

  324.     return ;

  325.   }

  326. 

  327.   if (!moduleLoaded ("i2c_dev"))

  328.   {

  329.     fprintf (stderr, "%s: The I2C kernel module(s) are not loaded.\n", argv [0]) ;

  330.     return ;

  331.   }

  332. 

  333.   sprintf (command, "%s -y %d", I2CDETECT, port) ;

  334.   if (system (command) < 0)

  335.     fprintf (stderr, "%s: Unable to run i2cdetect: %s\n", argv [0], strerror (errno)) ;

  336. 

  337. }

  338. 

  339. 

  340. /*

  341.  * doExports:

  342.  *	List all GPIO exports

  343.  *********************************************************************************

  344.  */

  345. 

  346. static void doExports (int argc, char *argv [])

  347. {

  348.   int fd ;

  349.   int i, l, first ;

  350.   char fName [128] ;

  351.   char buf [16] ;

  352. 

  353.   for (first = 0, i = 0 ; i < 64 ; ++i)	// Crude, but effective

  354.   {

  355. 

  356. // Try to read the direction

  357. 

  358.     sprintf (fName, "/sys/class/gpio/gpio%d/direction", i) ;

  359.     if ((fd = open (fName, O_RDONLY)) == -1)

  360.       continue ;

  361. 

  362.     if (first == 0)

  363.     {

  364.       ++first ;

  365.       printf ("GPIO Pins exported:\n") ;

  366.     }

  367. 

  368.     printf ("%4d: ", i) ;

  369. 

  370.     if ((l = read (fd, buf, 16)) == 0)

  371.       sprintf (buf, "%s", "?") ;

  372.  

  373.     buf [l] = 0 ;

  374.     if ((buf [strlen (buf) - 1]) == '\n')

  375.       buf [strlen (buf) - 1] = 0 ;

  376. 

  377.     printf ("%-3s", buf) ;

  378. 

  379.     close (fd) ;

  380. 

  381. // Try to Read the value

  382. 

  383.     sprintf (fName, "/sys/class/gpio/gpio%d/value", i) ;

  384.     if ((fd = open (fName, O_RDONLY)) == -1)

  385.     {

  386.       printf ("No Value file (huh?)\n") ;

  387.       continue ;

  388.     }

  389. 

  390.     if ((l = read (fd, buf, 16)) == 0)

  391.       sprintf (buf, "%s", "?") ;

  392. 

  393.     buf [l] = 0 ;

  394.     if ((buf [strlen (buf) - 1]) == '\n')

  395.       buf [strlen (buf) - 1] = 0 ;

  396. 

  397.     printf ("  %s", buf) ;

  398. 

  399. // Read any edge trigger file

  400. 

  401.     sprintf (fName, "/sys/class/gpio/gpio%d/edge", i) ;

  402.     if ((fd = open (fName, O_RDONLY)) == -1)

  403.     {

  404.       printf ("\n") ;

  405.       continue ;

  406.     }

  407. 

  408.     if ((l = read (fd, buf, 16)) == 0)

  409.       sprintf (buf, "%s", "?") ;

  410. 

  411.     buf [l] = 0 ;

  412.     if ((buf [strlen (buf) - 1]) == '\n')

  413.       buf [strlen (buf) - 1] = 0 ;

  414. 

  415.     printf ("  %-8s\n", buf) ;

  416. 

  417.     close (fd) ;

  418.   }

  419. }

  420. 

  421. 

  422. /*

  423.  * doExport:

  424.  *	gpio export pin mode

  425.  *	This uses the /sys/class/gpio device interface.

  426.  *********************************************************************************

  427.  */

  428. 

  429. void doExport (int argc, char *argv [])

  430. {

  431.   FILE *fd ;

  432.   int pin ;

  433.   char *mode ;

  434.   char fName [128] ;

  435. 

  436.   if (argc != 4)

  437.   {

  438.     fprintf (stderr, "Usage: %s export pin mode\n", argv [0]) ;

  439.     exit (1) ;

  440.   }

  441. 

  442.   pin = atoi (argv [2]) ;

  443. 

  444.   mode = argv [3] ;

  445. 

  446.   if ((fd = fopen ("/sys/class/gpio/export", "w")) == NULL)

  447.   {

  448.     fprintf (stderr, "%s: Unable to open GPIO export interface: %s\n", argv [0], strerror (errno)) ;

  449.     exit (1) ;

  450.   }

  451. 

  452.   fprintf (fd, "%d\n", pin) ;

  453.   fclose (fd) ;

  454. 

  455.   sprintf (fName, "/sys/class/gpio/gpio%d/direction", pin) ;

  456.   if ((fd = fopen (fName, "w")) == NULL)

  457.   {

  458.     fprintf (stderr, "%s: Unable to open GPIO direction interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ;

  459.     exit (1) ;

  460.   }

  461. 

  462.   /**/ if ((strcasecmp (mode, "in")   == 0) || (strcasecmp (mode, "input")  == 0))

  463.     fprintf (fd, "in\n") ;

  464.   else if ((strcasecmp (mode, "out")  == 0) || (strcasecmp (mode, "output") == 0))

  465.     fprintf (fd, "out\n") ;

  466.   else if ((strcasecmp (mode, "high") == 0) || (strcasecmp (mode, "up")     == 0))

  467.     fprintf (fd, "high\n") ;

  468.   else if ((strcasecmp (mode, "low")  == 0) || (strcasecmp (mode, "down")   == 0))

  469.     fprintf (fd, "low\n") ;

  470.   else

  471.   {

  472.     fprintf (stderr, "%s: Invalid mode: %s. Should be in, out, high or low\n", argv [1], mode) ;

  473.     exit (1) ;

  474.   }

  475. 

  476.   fclose (fd) ;

  477. 

  478. // Change ownership so the current user can actually use it

  479. 

  480.   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;

  481.   changeOwner (argv [0], fName) ;

  482. 

  483.   sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ;

  484.   changeOwner (argv [0], fName) ;

  485. 

  486. }

  487. 

  488. 

  489. /*

  490.  * doWfi:

  491.  *	gpio wfi pin mode

  492.  *	Wait for Interrupt on a given pin.

  493.  *	Slight cheat here - it's easier to actually use ISR now (which calls

  494.  *	gpio to set the pin modes!) then we simply sleep, and expect the thread

  495.  *	to exit the program. Crude but effective.

  496.  *********************************************************************************

  497.  */

  498. 

  499. static void wfi (void)

  500.   { exit (0) ; }

  501. 

  502. void doWfi (int argc, char *argv [])

  503. {

  504.   int pin, mode ;

  505. 

  506.   if (argc != 4)

  507.   {

  508.     fprintf (stderr, "Usage: %s wfi pin mode\n", argv [0]) ;

  509.     exit (1) ;

  510.   }

  511. 

  512.   pin  = atoi (argv [2]) ;

  513. 

  514.   /**/ if (strcasecmp (argv [3], "rising")  == 0) mode = INT_EDGE_RISING ;

  515.   else if (strcasecmp (argv [3], "falling") == 0) mode = INT_EDGE_FALLING ;

  516.   else if (strcasecmp (argv [3], "both")    == 0) mode = INT_EDGE_BOTH ;

  517.   else

  518.   {

  519.     fprintf (stderr, "%s: wfi: Invalid mode: %s. Should be rising, falling or both\n", argv [1], argv [3]) ;

  520.     exit (1) ;

  521.   }

  522. 

  523.   if (wiringPiISR (pin, mode, &wfi) < 0)

  524.   {

  525.     fprintf (stderr, "%s: wfi: Unable to setup ISR: %s\n", argv [1], strerror (errno)) ;

  526.     exit (1) ;

  527.   }

  528. 

  529.   for (;;)

  530.     delay (9999) ;

  531. }

  532. 

  533. 

  534. 

  535. /*

  536.  * doEdge:

  537.  *	gpio edge pin mode

  538.  *	Easy access to changing the edge trigger on a GPIO pin

  539.  *	This uses the /sys/class/gpio device interface.

  540.  *********************************************************************************

  541.  */

  542. 

  543. void doEdge (int argc, char *argv [])

  544. {

  545.   FILE *fd ;

  546.   int pin ;

  547.   char *mode ;

  548.   char fName [128] ;

  549. 

  550.   if (argc != 4)

  551.   {

  552.     fprintf (stderr, "Usage: %s edge pin mode\n", argv [0]) ;

  553.     exit (1) ;

  554.   }

  555. 

  556.   pin  = atoi (argv [2]) ;

  557.   mode = argv [3] ;

  558. 

  559. // Export the pin and set direction to input

  560. 

  561.   if ((fd = fopen ("/sys/class/gpio/export", "w")) == NULL)

  562.   {

  563.     fprintf (stderr, "%s: Unable to open GPIO export interface: %s\n", argv [0], strerror (errno)) ;

  564.     exit (1) ;

  565.   }

  566. 

  567.   fprintf (fd, "%d\n", pin) ;

  568.   fclose (fd) ;

  569. 

  570.   sprintf (fName, "/sys/class/gpio/gpio%d/direction", pin) ;

  571.   if ((fd = fopen (fName, "w")) == NULL)

  572.   {

  573.     fprintf (stderr, "%s: Unable to open GPIO direction interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ;

  574.     exit (1) ;

  575.   }

  576. 

  577.   fprintf (fd, "in\n") ;

  578.   fclose (fd) ;

  579. 

  580.   sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ;

  581.   if ((fd = fopen (fName, "w")) == NULL)

  582.   {

  583.     fprintf (stderr, "%s: Unable to open GPIO edge interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ;

  584.     exit (1) ;

  585.   }

  586. 

  587.   /**/ if (strcasecmp (mode, "none")    == 0) fprintf (fd, "none\n") ;

  588.   else if (strcasecmp (mode, "rising")  == 0) fprintf (fd, "rising\n") ;

  589.   else if (strcasecmp (mode, "falling") == 0) fprintf (fd, "falling\n") ;

  590.   else if (strcasecmp (mode, "both")    == 0) fprintf (fd, "both\n") ;

  591.   else

  592.   {

  593.     fprintf (stderr, "%s: Invalid mode: %s. Should be none, rising, falling or both\n", argv [1], mode) ;

  594.     exit (1) ;

  595.   }

  596. 

  597. // Change ownership of the value and edge files, so the current user can actually use it!

  598. 

  599.   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;

  600.   changeOwner (argv [0], fName) ;

  601. 

  602.   sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ;

  603.   changeOwner (argv [0], fName) ;

  604. 

  605.   fclose (fd) ;

  606. }

  607. 

  608. 

  609. /*

  610.  * doUnexport:

  611.  *	gpio unexport pin

  612.  *	This uses the /sys/class/gpio device interface.

  613.  *********************************************************************************

  614.  */

  615. 

  616. void doUnexport (int argc, char *argv [])

  617. {

  618.   FILE *fd ;

  619.   int pin ;

  620. 

  621.   if (argc != 3)

  622.   {

  623.     fprintf (stderr, "Usage: %s unexport pin\n", argv [0]) ;

  624.     exit (1) ;

  625.   }

  626. 

  627.   pin = atoi (argv [2]) ;

  628. 

  629.   if ((fd = fopen ("/sys/class/gpio/unexport", "w")) == NULL)

  630.   {

  631.     fprintf (stderr, "%s: Unable to open GPIO export interface\n", argv [0]) ;

  632.     exit (1) ;

  633.   }

  634. 

  635.   fprintf (fd, "%d\n", pin) ;

  636.   fclose (fd) ;

  637. }

  638. 

  639. 

  640. /*

  641.  * doUnexportAll:

  642.  *	gpio unexportall

  643.  *	Un-Export all the GPIO pins.

  644.  *	This uses the /sys/class/gpio device interface.

  645.  *********************************************************************************

  646.  */

  647. 

  648. void doUnexportall (char *progName)

  649. {

  650.   FILE *fd ;

  651.   int pin ;

  652. 

  653.   for (pin = 0 ; pin < 63 ; ++pin)

  654.   {

  655.     if ((fd = fopen ("/sys/class/gpio/unexport", "w")) == NULL)

  656.     {

  657.       fprintf (stderr, "%s: Unable to open GPIO export interface\n", progName) ;

  658.       exit (1) ;

  659.     }

  660.     fprintf (fd, "%d\n", pin) ;

  661.     fclose (fd) ;

  662.   }

  663. }

  664. 

  665. 

  666. /*

  667.  * doReset:

  668.  *	Reset the GPIO pins - as much as we can do

  669.  *********************************************************************************

  670.  */

  671. 

  672. static void doReset (char *progName)

  673. {

  674.   printf ("GPIO Reset is dangerous and has been removed from the gpio command.\n") ;

  675.   printf (" - Please write a shell-script to reset the GPIO pins into the state\n") ;

  676.   printf ("   that you need them in for your applications.\n") ;

  677. }

  678. 

  679. 

  680. /*

  681.  * doMode:

  682.  *	gpio mode pin mode ...

  683.  *  or, gpio mode pin

  684.  *********************************************************************************

  685.  */

  686. 

  687. void doMode (int argc, char *argv [])

  688. {

  689.   int pin ;

  690.   char *mode ;

  691. 

  692.   if (argc > 4)

  693.   {

  694.     fprintf (stderr, "Usage: %s mode pin mode\n", argv [0]) ;

  695.     exit (1) ;

  696.   } else if(argc < 3) {

  697.     fprintf (stderr, "Usage: %s mode pin\n", argv [0]) ;

  698.     exit (1) ;

  699.   }

  700. 

  701.   pin = atoi (argv [2]) ;

  702.   if(argc == 4) {

  703.     mode = argv [3] ;

  704. 

  705.     /**/ if (strcasecmp (mode, "in")      == 0) pinMode         (pin, INPUT) ;

  706.     else if (strcasecmp (mode, "input")   == 0) pinMode         (pin, INPUT) ;

  707.     else if (strcasecmp (mode, "out")     == 0) pinMode         (pin, OUTPUT) ;

  708.     else if (strcasecmp (mode, "output")  == 0) pinMode         (pin, OUTPUT) ;

  709.     else if (strcasecmp (mode, "pwm")     == 0) pinMode         (pin, PWM_OUTPUT) ;

  710.     else if (strcasecmp (mode, "pwmTone") == 0) pinMode         (pin, PWM_TONE_OUTPUT) ;

  711.     else if (strcasecmp (mode, "clock")   == 0) pinMode         (pin, GPIO_CLOCK) ;

  712.     else if (strcasecmp (mode, "up")      == 0) pullUpDnControl (pin, PUD_UP) ;

  713.     else if (strcasecmp (mode, "down")    == 0) pullUpDnControl (pin, PUD_DOWN) ;

  714.     else if (strcasecmp (mode, "tri")     == 0) pullUpDnControl (pin, PUD_OFF) ;

  715.     else if (strcasecmp (mode, "off")     == 0) pullUpDnControl (pin, PUD_OFF) ;

  716.     else if (strcasecmp (mode, "alt0")    == 0) pinModeAlt (pin, 0b100) ;

  717.     else if (strcasecmp (mode, "alt1")    == 0) pinModeAlt (pin, 0b101) ;

  718.     else if (strcasecmp (mode, "alt2")    == 0) pinModeAlt (pin, 0b110) ;

  719.     else if (strcasecmp (mode, "alt3")    == 0) pinModeAlt (pin, 0b111) ;

  720.     else if (strcasecmp (mode, "alt4")    == 0) pinModeAlt (pin, 0b011) ;

  721.     else if (strcasecmp (mode, "alt5")    == 0) pinModeAlt (pin, 0b010) ;

  722.     else

  723.     {

  724.       fprintf (stderr, "%s: Invalid mode: %s. Should be in/out/pwm/clock/up/down/tri\n", argv [1], mode) ;

  725.       exit (1) ;

  726.     }

  727.   } else {

  728.     printf("%s\n", getAltText(pin));

  729.   }

  730. }

  731. 

  732. 

  733. /*

  734.  * doPadDrive:

  735.  *	gpio drive group value

  736.  *********************************************************************************

  737.  */

  738. 

  739. static void doPadDrive (int argc, char *argv [])

  740. {

  741.   int group, val ;

  742. 

  743.   if (argc != 4)

  744.   {

  745.     fprintf (stderr, "Usage: %s drive group value\n", argv [0]) ;

  746.     exit (1) ;

  747.   }

  748. 

  749.   group = atoi (argv [2]) ;

  750.   val   = atoi (argv [3]) ;

  751. 

  752.   if ((group < 0) || (group > 2))

  753.   {

  754.     fprintf (stderr, "%s: drive group not 0, 1 or 2: %d\n", argv [0], group) ;

  755.     exit (1) ;

  756.   }

  757. 

  758.   if ((val < 0) || (val > 7))

  759.   {

  760.     fprintf (stderr, "%s: drive value not 0-7: %d\n", argv [0], val) ;

  761.     exit (1) ;

  762.   }

  763. 

  764.   setPadDrive (group, val) ;

  765. }

  766. 

  767. 

  768. /*

  769.  * doUsbP:

  770.  *	Control USB Power - High (1.2A) or Low (600mA)

  771.  *	gpio usbp high/low

  772.  *********************************************************************************

  773.  */

  774. 

  775. static void doUsbP (int argc, char *argv [])

  776. {

  777.   int model, rev, mem, maker, overVolted ;

  778. 

  779.   if (argc != 3)

  780.   {

  781.     fprintf (stderr, "Usage: %s usbp high|low\n", argv [0]) ;

  782.     exit (1) ;

  783.   }

  784. 

  785. // Make sure we're on a B+

  786. 

  787.   piBoardId (&model, &rev, &mem, &maker, &overVolted) ;

  788. 

  789.   if (!((model == PI_MODEL_BP) || (model == PI_MODEL_2)))

  790.   {

  791.     fprintf (stderr, "USB power contol is applicable to B+ and v2 boards only.\n") ;

  792.     exit (1) ;

  793.   }

  794.     

  795. // Make sure we start in BCM_GPIO mode

  796. 

  797.   wiringPiSetupGpio () ;

  798. 

  799.   if ((strcasecmp (argv [2], "high") == 0) || (strcasecmp (argv [2], "hi") == 0))

  800.   {

  801.     digitalWrite (PI_USB_POWER_CONTROL, 1) ;

  802.     pinMode (PI_USB_POWER_CONTROL, OUTPUT) ;

  803.     printf ("Switched to HIGH current USB (1.2A)\n") ;

  804.     return ;

  805.   }

  806. 

  807.   if ((strcasecmp (argv [2], "low") == 0) || (strcasecmp (argv [2], "lo") == 0))

  808.   {

  809.     digitalWrite (PI_USB_POWER_CONTROL, 0) ;

  810.     pinMode (PI_USB_POWER_CONTROL, OUTPUT) ;

  811.     printf ("Switched to LOW current USB (600mA)\n") ;

  812.     return ;

  813.   }

  814. 

  815.   fprintf (stderr, "Usage: %s usbp high|low\n", argv [0]) ;

  816.   exit (1) ;

  817. }

  818. 

  819. 

  820. /*

  821.  * doGbw:

  822.  *	gpio gbw channel value

  823.  *	Gertboard Write - To the Analog output

  824.  *********************************************************************************

  825.  */

  826. 

  827. static void doGbw (int argc, char *argv [])

  828. {

  829.   int channel, value ;

  830. 

  831.   if (argc != 4)

  832.   {

  833.     fprintf (stderr, "Usage: %s gbw <channel> <value>\n", argv [0]) ;

  834.     exit (1) ;

  835.   }

  836. 

  837.   channel = atoi (argv [2]) ;

  838.   value   = atoi (argv [3]) ;

  839. 

  840.   if ((channel < 0) || (channel > 1))

  841.   {

  842.     fprintf (stderr, "%s: gbw: Channel number must be 0 or 1\n", argv [0]) ;

  843.     exit (1) ;

  844.   }

  845. 

  846.   if ((value < 0) || (value > 255))

  847.   {

  848.     fprintf (stderr, "%s: gbw: Value must be from 0 to 255\n", argv [0]) ;

  849.     exit (1) ;

  850.   }

  851. 

  852.   if (gertboardAnalogSetup (64) < 0)

  853.   {

  854.     fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ;

  855.     exit (1) ;

  856.   }

  857. 

  858.   analogWrite (64 + channel, value) ;

  859. }

  860. 

  861. 

  862. /*

  863.  * doGbr:

  864.  *	gpio gbr channel

  865.  *	From the analog input

  866.  *********************************************************************************

  867.  */

  868. 

  869. static void doGbr (int argc, char *argv [])

  870. {

  871.   int channel ;

  872. 

  873.   if (argc != 3)

  874.   {

  875.     fprintf (stderr, "Usage: %s gbr <channel>\n", argv [0]) ;

  876.     exit (1) ;

  877.   }

  878. 

  879.   channel = atoi (argv [2]) ;

  880. 

  881.   if ((channel < 0) || (channel > 1))

  882.   {

  883.     fprintf (stderr, "%s: gbr: Channel number must be 0 or 1\n", argv [0]) ;

  884.     exit (1) ;

  885.   }

  886. 

  887.   if (gertboardAnalogSetup (64) < 0)

  888.   {

  889.     fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ;

  890.     exit (1) ;

  891.   }

  892. 

  893.   printf ("%d\n", analogRead (64 + channel)) ;

  894. }

  895. 

  896. 

  897. /*

  898.  * doWrite:

  899.  *	gpio write pin value

  900.  *********************************************************************************

  901.  */

  902. 

  903. static void doWrite (int argc, char *argv [])

  904. {

  905.   int pin, val ;

  906. 

  907.   if (argc != 4)

  908.   {

  909.     fprintf (stderr, "Usage: %s write pin value\n", argv [0]) ;

  910.     exit (1) ;

  911.   }

  912. 

  913.   pin = atoi (argv [2]) ;

  914. 

  915.   /**/ if ((strcasecmp (argv [3], "up") == 0) || (strcasecmp (argv [3], "on") == 0))

  916.     val = 1 ;

  917.   else if ((strcasecmp (argv [3], "down") == 0) || (strcasecmp (argv [3], "off") == 0))

  918.     val = 0 ;

  919.   else

  920.     val = atoi (argv [3]) ;

  921. 

  922.   /**/ if (val == 0)

  923.     digitalWrite (pin, LOW) ;

  924.   else

  925.     digitalWrite (pin, HIGH) ;

  926. }

  927. 

  928. 

  929. /*

  930.  * doAwriterite:

  931.  *	gpio awrite pin value

  932.  *********************************************************************************

  933.  */

  934. 

  935. static void doAwrite (int argc, char *argv [])

  936. {

  937.   int pin, val ;

  938. 

  939.   if (argc != 4)

  940.   {

  941.     fprintf (stderr, "Usage: %s awrite pin value\n", argv [0]) ;

  942.     exit (1) ;

  943.   }

  944. 

  945.   pin = atoi (argv [2]) ;

  946. 

  947.   val = atoi (argv [3]) ;

  948. 

  949.   analogWrite (pin, val) ;

  950. }

  951. 

  952. 

  953. /*

  954.  * doWriteByte:

  955.  *	gpio write value

  956.  *********************************************************************************

  957.  */

  958. 

  959. static void doWriteByte (int argc, char *argv [])

  960. {

  961.   int val ;

  962. 

  963.   if (argc != 3)

  964.   {

  965.     fprintf (stderr, "Usage: %s wb value\n", argv [0]) ;

  966.     exit (1) ;

  967.   }

  968. 

  969.   val = (int)strtol (argv [2], NULL, 0) ;

  970. 

  971.   digitalWriteByte (val) ;

  972. }

  973. 

  974. 

  975. /*

  976.  * doRead:

  977.  *	Read a pin and return the value

  978.  *********************************************************************************

  979.  */

  980. 

  981. void doRead (int argc, char *argv []) 

  982. {

  983.   int pin, val ;

  984. 

  985.   if (argc != 3)

  986.   {

  987.     fprintf (stderr, "Usage: %s read pin\n", argv [0]) ;

  988.     exit (1) ;

  989.   }

  990. 

  991.   pin = atoi (argv [2]) ;

  992.   val = digitalRead (pin) ;

  993. 

  994.   printf ("%s\n", val == 0 ? "0" : "1") ;

  995. }

  996. 

  997. 

  998. /*

  999.  * doAread:

  1000.  *	Read an analog pin and return the value

  1001.  *********************************************************************************

  1002.  */

  1003. 

  1004. void doAread (int argc, char *argv []) 

  1005. {

  1006.   if (argc != 3)

  1007.   {

  1008.     fprintf (stderr, "Usage: %s aread pin\n", argv [0]) ;

  1009.     exit (1) ;

  1010.   }

  1011. 

  1012.   printf ("%d\n", analogRead (atoi (argv [2]))) ;

  1013. }

  1014. 

  1015. 

  1016. /*

  1017.  * doToggle:

  1018.  *	Toggle an IO pin

  1019.  *********************************************************************************

  1020.  */

  1021. 

  1022. void doToggle (int argc, char *argv [])

  1023. {

  1024.   int pin ;

  1025. 

  1026.   if (argc != 3)

  1027.   {

  1028.     fprintf (stderr, "Usage: %s toggle pin\n", argv [0]) ;

  1029.     exit (1) ;

  1030.   }

  1031. 

  1032.   pin = atoi (argv [2]) ;

  1033. 

  1034.   digitalWrite (pin, !digitalRead (pin)) ;

  1035. }

  1036. 

  1037. 

  1038. /*

  1039.  * doPwmTone:

  1040.  *	Output a tone in a PWM pin

  1041.  *********************************************************************************

  1042.  */

  1043. 

  1044. void doPwmTone (int argc, char *argv [])

  1045. {

  1046.   int pin, freq ;

  1047. 

  1048.   if (argc != 4)

  1049.   {

  1050.     fprintf (stderr, "Usage: %s pwmTone <pin> <freq>\n", argv [0]) ;

  1051.     exit (1) ;

  1052.   }

  1053. 

  1054.   pin = atoi (argv [2]) ;

  1055.   freq = atoi (argv [3]) ;

  1056. 

  1057.   pwmToneWrite (pin, freq) ;

  1058. }

  1059. 

  1060. 

  1061. /*

  1062.  * doClock:

  1063.  *	Output a clock on a pin

  1064.  *********************************************************************************

  1065.  */

  1066. 

  1067. void doClock (int argc, char *argv [])

  1068. {

  1069.   int pin, freq ;

  1070. 

  1071.   if (argc != 4)

  1072.   {

  1073.     fprintf (stderr, "Usage: %s clock <pin> <freq>\n", argv [0]) ;

  1074.     exit (1) ;

  1075.   }

  1076. 

  1077.   pin = atoi (argv [2]) ;

  1078. 

  1079.   freq = atoi (argv [3]) ;

  1080. 

  1081.   gpioClockSet (pin, freq) ;

  1082. }

  1083. 

  1084. 

  1085. /*

  1086.  * doPwm:

  1087.  *	Output a PWM value on a pin

  1088.  *********************************************************************************

  1089.  */

  1090. 

  1091. void doPwm (int argc, char *argv [])

  1092. {

  1093.   int pin, val ;

  1094. 

  1095.   if (argc != 4)

  1096.   {

  1097.     fprintf (stderr, "Usage: %s pwm <pin> <value>\n", argv [0]) ;

  1098.     exit (1) ;

  1099.   }

  1100. 

  1101.   pin = atoi (argv [2]) ;

  1102. 

  1103.   val = atoi (argv [3]) ;

  1104. 

  1105.   pwmWrite (pin, val) ;

  1106. }

  1107. 

  1108. 

  1109. /*

  1110.  * doPwmMode: doPwmRange: doPwmClock:

  1111.  *	Change the PWM mode, range and clock divider values

  1112.  *********************************************************************************

  1113.  */

  1114. 

  1115. static void doPwmMode (int mode)

  1116. {

  1117.   pwmSetMode (mode) ;

  1118. }

  1119. 

  1120. static void doPwmRange (int argc, char *argv [])

  1121. {

  1122.   unsigned int range ;

  1123. 

  1124.   if (argc != 3)

  1125.   {

  1126.     fprintf (stderr, "Usage: %s pwmr <range>\n", argv [0]) ;

  1127.     exit (1) ;

  1128.   }

  1129. 

  1130.   range = (unsigned int)strtoul (argv [2], NULL, 10) ;

  1131. 

  1132.   if (range == 0)

  1133.   {

  1134.     fprintf (stderr, "%s: range must be > 0\n", argv [0]) ;

  1135.     exit (1) ;

  1136.   }

  1137. 

  1138.   pwmSetRange (range) ;

  1139. }

  1140. 

  1141. static void doPwmClock (int argc, char *argv [])

  1142. {

  1143.   unsigned int clock ;

  1144. 

  1145.   if (argc != 3)

  1146.   {

  1147.     fprintf (stderr, "Usage: %s pwmc <clock>\n", argv [0]) ;

  1148.     exit (1) ;

  1149.   }

  1150. 

  1151.   clock = (unsigned int)strtoul (argv [2], NULL, 10) ;

  1152. 

  1153.   if ((clock < 1) || (clock > 4095))

  1154.   {

  1155.     fprintf (stderr, "%s: clock must be between 0 and 4096\n", argv [0]) ;

  1156.     exit (1) ;

  1157.   }

  1158. 

  1159.   pwmSetClock (clock) ;

  1160. }

  1161. 

  1162. 

  1163. /*

  1164.  * doVersion:

  1165.  *	Handle the ever more complicated version command and print out

  1166.  *	some usefull information.

  1167.  *********************************************************************************

  1168.  */

  1169. 

  1170. static void doVersion (char *argv [])

  1171. {

  1172.   int model, rev, mem, maker, warranty ;

  1173.   struct stat statBuf ;

  1174. 

  1175.   printf ("gpio version: %s\n", VERSION) ;

  1176.   printf ("Copyright (c) 2012-2015 Gordon Henderson\n") ;

  1177.   printf ("This is free software with ABSOLUTELY NO WARRANTY.\n") ;

  1178.   printf ("For details type: %s -warranty\n", argv [0]) ;

  1179.   printf ("\n") ;

  1180.   piBoardId (&model, &rev, &mem, &maker, &warranty) ;

  1181. 

  1182.   printf ("Raspberry Pi Details:\n") ;

  1183.   printf ("  Type: %s, Revision: %s, Memory: %dMB, Maker: %s %s\n", 

  1184.       piModelNames [model], piRevisionNames [rev], piMemorySize [mem], piMakerNames [maker], warranty ? "[Out of Warranty]" : "") ;

  1185. 

  1186. // Check for device tree

  1187. 

  1188.   if (stat ("/proc/device-tree", &statBuf) == 0)	// We're on a devtree system ...

  1189.     printf ("  * Device tree is enabled.\n") ;

  1190. 

  1191.   if (stat ("/dev/gpiomem", &statBuf) == 0)		// User level GPIO is GO

  1192.   {

  1193.     printf ("  * This Raspberry Pi supports user-level GPIO access.\n") ;

  1194.     printf ("    -> See the man-page for more details\n") ;

  1195.     printf ("    -> ie. export WIRINGPI_GPIOMEM=1\n") ;

  1196.   }

  1197.   else

  1198.     printf ("  * Root or sudo required for GPIO access.\n") ;

  1199. }

  1200. 

  1201. 

  1202. /*

  1203.  * main:

  1204.  *	Start here

  1205.  *********************************************************************************

  1206.  */

  1207. 

  1208. int main (int argc, char *argv [])

  1209. {

  1210.   int i ;

  1211. 

  1212.   if (getenv ("WIRINGPI_DEBUG") != NULL)

  1213.   {

  1214.     printf ("gpio: wiringPi debug mode enabled\n") ;

  1215.     wiringPiDebug = TRUE ;

  1216.   }

  1217. 

  1218.   if (argc == 1)

  1219.   {

  1220.     fprintf (stderr, "%s\n", usage) ;

  1221.     return 1 ;

  1222.   }

  1223. 

  1224. // Help

  1225. 

  1226.   if (strcasecmp (argv [1], "-h") == 0)

  1227.   {

  1228.     printf ("%s: %s\n", argv [0], usage) ;

  1229.     return 0 ;

  1230.   }

  1231. 

  1232. // Version & Warranty

  1233. //	Wish I could remember why I have both -R and -V ...

  1234. 

  1235.   if ((strcmp (argv [1], "-R") == 0) || (strcmp (argv [1], "-V") == 0))

  1236.   {

  1237.     printf ("%d\n", piBoardRev ()) ;

  1238.     return 0 ;

  1239.   }

  1240. 

  1241. // Version and information

  1242. 

  1243.   if (strcmp (argv [1], "-v") == 0)

  1244.   {

  1245.     doVersion (argv) ;

  1246.     return 0 ;

  1247.   }

  1248. 

  1249.   if (strcasecmp (argv [1], "-warranty") == 0)

  1250.   {

  1251.     printf ("gpio version: %s\n", VERSION) ;

  1252.     printf ("Copyright (c) 2012-2015 Gordon Henderson\n") ;

  1253.     printf ("\n") ;

  1254.     printf ("    This program is free software; you can redistribute it and/or modify\n") ;

  1255.     printf ("    it under the terms of the GNU Leser General Public License as published\n") ;

  1256.     printf ("    by the Free Software Foundation, either version 3 of the License, or\n") ;

  1257.     printf ("    (at your option) any later version.\n") ;

  1258.     printf ("\n") ;

  1259.     printf ("    This program is distributed in the hope that it will be useful,\n") ;

  1260.     printf ("    but WITHOUT ANY WARRANTY; without even the implied warranty of\n") ;

  1261.     printf ("    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n") ;

  1262.     printf ("    GNU Lesser General Public License for more details.\n") ;

  1263.     printf ("\n") ;

  1264.     printf ("    You should have received a copy of the GNU Lesser General Public License\n") ;

  1265.     printf ("    along with this program. If not, see <http://www.gnu.org/licenses/>.\n") ;

  1266.     printf ("\n") ;

  1267.     return 0 ;

  1268.   }

  1269. 

  1270.   if (geteuid () != 0)

  1271.   {

  1272.     fprintf (stderr, "%s: Must be root to run. Program should be suid root. This is an error.\n", argv [0]) ;

  1273.     return 1 ;

  1274.   }

  1275. 

  1276. // Initial test for /sys/class/gpio operations:

  1277. 

  1278.   /**/ if (strcasecmp (argv [1], "exports"    ) == 0)	{ doExports     (argc, argv) ;	return 0 ; }

  1279.   else if (strcasecmp (argv [1], "export"     ) == 0)	{ doExport      (argc, argv) ;	return 0 ; }

  1280.   else if (strcasecmp (argv [1], "edge"       ) == 0)	{ doEdge        (argc, argv) ;	return 0 ; }

  1281.   else if (strcasecmp (argv [1], "unexport"   ) == 0)	{ doUnexport    (argc, argv) ;	return 0 ; }

  1282.   else if (strcasecmp (argv [1], "unexportall") == 0)	{ doUnexportall (argv [0]) ;	return 0 ; }

  1283. 

  1284. // Check for load command:

  1285. 

  1286.   if (strcasecmp (argv [1], "load"   ) == 0)	{ doLoad   (argc, argv) ; return 0 ; }

  1287.   if (strcasecmp (argv [1], "unload" ) == 0)	{ doUnLoad (argc, argv) ; return 0 ; }

  1288. 

  1289. // Check for usb power command

  1290. 

  1291.   if (strcasecmp (argv [1], "usbp"   ) == 0)	{ doUsbP   (argc, argv) ; return 0 ; }

  1292. 

  1293. // Gertboard commands

  1294. 

  1295.   if (strcasecmp (argv [1], "gbr" ) == 0)	{ doGbr (argc, argv) ; return 0 ; }

  1296.   if (strcasecmp (argv [1], "gbw" ) == 0)	{ doGbw (argc, argv) ; return 0 ; }

  1297. 

  1298. // Check for allreadall command, force Gpio mode

  1299. 

  1300.   if (strcasecmp (argv [1], "allreadall") == 0)

  1301.   {

  1302.     wiringPiSetupGpio () ;

  1303.     doAllReadall      () ;

  1304.     return 0 ;

  1305.   }

  1306. 

  1307. // Check for -g argument

  1308. 

  1309.   /**/ if (strcasecmp (argv [1], "-g") == 0)

  1310.   {

  1311.     wiringPiSetupGpio () ;

  1312. 

  1313.     for (i = 2 ; i < argc ; ++i)

  1314.       argv [i - 1] = argv [i] ;

  1315.     --argc ;

  1316.     wpMode = WPI_MODE_GPIO ;

  1317.   }

  1318. 

  1319. // Check for -1 argument

  1320. 

  1321.   else if (strcasecmp (argv [1], "-1") == 0)

  1322.   {

  1323.     wiringPiSetupPhys () ;

  1324. 

  1325.     for (i = 2 ; i < argc ; ++i)

  1326.       argv [i - 1] = argv [i] ;

  1327.     --argc ;

  1328.     wpMode = WPI_MODE_PHYS ;

  1329.   }

  1330. 

  1331. // Check for -p argument for PiFace

  1332. 

  1333.   else if (strcasecmp (argv [1], "-p") == 0)

  1334.   {

  1335.     piFaceSetup (200) ;

  1336. 

  1337.     for (i = 2 ; i < argc ; ++i)

  1338.       argv [i - 1] = argv [i] ;

  1339.     --argc ;

  1340.     wpMode = WPI_MODE_PIFACE ;

  1341.   }

  1342. 

  1343. // Default to wiringPi mode

  1344. 

  1345.   else

  1346.   {

  1347.     wiringPiSetup () ;

  1348.     wpMode = WPI_MODE_PINS ;

  1349.   }

  1350. 

  1351. // Check for -x argument to load in a new extension

  1352. 

  1353.   if (strcasecmp (argv [1], "-x") == 0)

  1354.   {

  1355.     if (argc < 3)

  1356.     {

  1357.       fprintf (stderr, "%s: -x missing extension specification.\n", argv [0]) ;

  1358.       exit (EXIT_FAILURE) ;

  1359.     }

  1360. 

  1361.     if (!loadWPiExtension (argv [0], argv [2], TRUE))	// Prints its own error messages

  1362.       exit (EXIT_FAILURE) ;

  1363. 

  1364.     for (i = 3 ; i < argc ; ++i)

  1365.       argv [i - 2] = argv [i] ;

  1366.     argc -= 2 ;

  1367.   }

  1368. 

  1369.   if (argc <= 1)

  1370.   {

  1371.     fprintf (stderr, "%s: no command given\n", argv [0]) ;

  1372.     exit (EXIT_FAILURE) ;

  1373.   }

  1374. 

  1375. // Core wiringPi functions

  1376. 

  1377.   /**/ if (strcasecmp (argv [1], "mode"   ) == 0) doMode      (argc, argv) ;

  1378.   else if (strcasecmp (argv [1], "read"   ) == 0) doRead      (argc, argv) ;

  1379.   else if (strcasecmp (argv [1], "write"  ) == 0) doWrite     (argc, argv) ;

  1380.   else if (strcasecmp (argv [1], "pwm"    ) == 0) doPwm       (argc, argv) ;

  1381.   else if (strcasecmp (argv [1], "awrite" ) == 0) doAwrite    (argc, argv) ;

  1382.   else if (strcasecmp (argv [1], "aread"  ) == 0) doAread     (argc, argv) ;

  1383. 

  1384. // GPIO Nicies

  1385. 

  1386.   else if (strcasecmp (argv [1], "toggle" ) == 0) doToggle    (argc, argv) ;

  1387. 

  1388. // Pi Specifics

  1389. 

  1390.   else if (strcasecmp (argv [1], "pwm-bal"  ) == 0) doPwmMode    (PWM_MODE_BAL) ;

  1391.   else if (strcasecmp (argv [1], "pwm-ms"   ) == 0) doPwmMode    (PWM_MODE_MS) ;

  1392.   else if (strcasecmp (argv [1], "pwmr"     ) == 0) doPwmRange   (argc, argv) ;

  1393.   else if (strcasecmp (argv [1], "pwmc"     ) == 0) doPwmClock   (argc, argv) ;

  1394.   else if (strcasecmp (argv [1], "pwmTone"  ) == 0) doPwmTone    (argc, argv) ;

  1395.   else if (strcasecmp (argv [1], "drive"    ) == 0) doPadDrive   (argc, argv) ;

  1396.   else if (strcasecmp (argv [1], "readall"  ) == 0) doReadall    () ;

  1397.   else if (strcasecmp (argv [1], "nreadall" ) == 0) doReadall    () ;

  1398.   else if (strcasecmp (argv [1], "pins"     ) == 0) doPins       () ;

  1399.   else if (strcasecmp (argv [1], "i2cdetect") == 0) doI2Cdetect  (argc, argv) ;

  1400.   else if (strcasecmp (argv [1], "i2cd"     ) == 0) doI2Cdetect  (argc, argv) ;

  1401.   else if (strcasecmp (argv [1], "reset"    ) == 0) doReset      (argv [0]) ;

  1402.   else if (strcasecmp (argv [1], "wb"       ) == 0) doWriteByte  (argc, argv) ;

  1403.   else if (strcasecmp (argv [1], "clock"    ) == 0) doClock      (argc, argv) ;

  1404.   else if (strcasecmp (argv [1], "wfi"      ) == 0) doWfi        (argc, argv) ;

  1405.   else

  1406.   {

  1407.     fprintf (stderr, "%s: Unknown command: %s.\n", argv [0], argv [1]) ;

  1408.     exit (EXIT_FAILURE) ;

  1409.   }

  1410.   return 0 ;

  1411. }