heuzef
/
WiringPi
镜像自地址 https://github.com/WiringPi/WiringPi.git
1
0
派生 0
代码 工单 0 版本发布 9 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
295 提交
10 分支
26 MiB
 
 
 
 
 
目录树: 7fa40ba6f8
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 '7fa40ba6f8'
${ noResults }
WiringPi/gpio/gpio.c

1432 行
35 KiB
原始文件 Blame 文件历史 

  1. /*

  2.  * gpio.c:

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

  4.  *	Pi's GPIO.

  5.  *	Copyright (c) 2012-2024 Gordon Henderson and contributors

  6.  ***********************************************************************

  7.  * This file is part of wiringPi:

  8.  *	https://github.com/WiringPi/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. int gpioDebug ;

  47. 

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

  49. 

  50. extern void doReadall    (void) ;

  51. extern void doAllReadall (void) ;

  52. extern void doQmode      (int argc, char *argv []) ;

  53. 

  54. #ifndef TRUE

  55. #  define	TRUE	(1==1)

  56. #  define	FALSE	(1==2)

  57. #endif

  58. 

  59. #define	PI_USB_POWER_CONTROL	38

  60. #define	I2CDETECT		"i2cdetect"

  61. #define	MODPROBE		"modprobe"

  62. #define	RMMOD			"rmmod"

  63. 

  64. int wpMode ;

  65. 

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

  67.               "       gpio -h\n"

  68.               "       gpio [-g|-1] ...\n"

  69.               "       gpio [-d] ...\n"

  70.               "       [-x extension:params] [[ -x ...]] ...\n"

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

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

  73.               "       gpio <toggle/blink> <pin>\n"

  74. 	      "       gpio readall\n"

  75. //	      "       gpio unexportall/exports\n"

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

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

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

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

  80. 	      "       gpio pwmr <range> \n"

  81. 	      "       gpio pwmc <divider> \n"

  82. 	      "       gpio load spi/i2c\n"

  83. 	      "       gpio unload spi/i2c\n"

  84. 	      "       gpio i2cd/i2cdetect\n"

  85. 	      "       gpio rbx/rbd\n"

  86. 	      "       gpio wb <value>\n"

  87. 	      "       gpio usbp high/low\n"

  88. 	      "       gpio gbr <channel>\n"

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

  90. 

  91. 

  92. #ifdef	NOT_FOR_NOW

  93. /*

  94.  * decodePin:

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

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

  97.  *********************************************************************************

  98.  */

  99. 

  100. static int decodePin (const char *str)

  101. {

  102. 

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

  104. 

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

  106.     return atoi (str) ;

  107. 

  108.   return 0 ;

  109. }

  110. #endif

  111. 

  112. 

  113. /*

  114.  * findExecutable:

  115.  *	Code to locate the path to the given executable. We have a fixed list

  116.  *	of locations to try which completely overrides any $PATH environment.

  117.  *	This may be detrimental, however it avoids the reliance on $PATH

  118.  *	which may be a security issue when this program is run a set-uid-root.

  119.  *********************************************************************************

  120.  */

  121. 

  122. static const char *searchPath [] =

  123. {

  124.   "/sbin",

  125.   "/usr/sbin",

  126.   "/bin",

  127.   "/usr/bin",

  128.   NULL,

  129. } ;

  130. 

  131. static char *findExecutable (const char *progName)

  132. {

  133.   static char *path = NULL ;

  134.   int len = strlen (progName) ;

  135.   int i = 0 ;

  136.   struct stat statBuf ;

  137. 

  138.   for (i = 0 ; searchPath [i] != NULL ; ++i)

  139.   {

  140.     path = malloc (strlen (searchPath [i]) + len + 2) ;

  141.     sprintf (path, "%s/%s", searchPath [i], progName) ;

  142. 

  143.     if (stat (path, &statBuf) == 0)

  144.       return path ;

  145.     free (path) ;

  146.   }

  147. 

  148.   return NULL ;

  149. }

  150. 

  151. 

  152. /*

  153.  * changeOwner:

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

  155.  *	program so we can access it.

  156.  *********************************************************************************

  157.  */

  158. 

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

  160. {

  161.   uid_t uid = getuid () ;

  162.   uid_t gid = getgid () ;

  163. 

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

  165.   {

  166. 

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

  168. //	the warning message is an error.

  169. 

  170.     if (errno != ENOENT)

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

  172.   }

  173. }

  174. 

  175. 

  176. /*

  177.  * moduleLoaded:

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

  179.  *********************************************************************************

  180.  */

  181. 

  182. static int moduleLoaded (char *modName)

  183. {

  184.   int len   = strlen (modName) ;

  185.   int found = FALSE ;

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

  187.   char line [80] ;

  188. 

  189.   if (fd == NULL)

  190.   {

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

  192.     exit (1) ;

  193.   }

  194. 

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

  196.   {

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

  198.       continue ;

  199. 

  200.     found = TRUE ;

  201.     break ;

  202.   }

  203. 

  204.   fclose (fd) ;

  205. 

  206.   return found ;

  207. }

  208. 

  209. 

  210. /*

  211.  * doLoad:

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

  213.  *********************************************************************************

  214.  */

  215. 

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

  217. {

  218.   struct stat statBuf ;

  219. 

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

  221.   {

  222.     fprintf (stderr,

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

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

  225. "  modules (SPI or I2C) that you wish to load/unload there and reboot.\n", argv [0]) ;

  226.     exit (1) ;

  227.   }

  228. }

  229. 

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

  231. {

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

  233.   exit (1) ;

  234. }

  235. 

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

  237. {

  238.   char *module1, *module2 ;

  239.   char cmd [80] ;

  240.   char *file1, *file2 ;

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

  242. 

  243.   checkDevTree (argv) ;

  244. 

  245.   if (argc < 3)

  246.     _doLoadUsage (argv) ;

  247. 

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

  249. 

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

  251.   {

  252.     module1 = "spidev" ;

  253.     module2 = "spi_bcm2708" ;

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

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

  256.     if (argc == 4)

  257.     {

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

  259.       exit (1) ;

  260.     }

  261.     else if (argc > 4)

  262.       _doLoadUsage (argv) ;

  263.   }

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

  265.   {

  266.     module1 = "i2c_dev" ;

  267.     module2 = "i2c_bcm2708" ;

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

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

  270.     if (argc == 4)

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

  272.     else if (argc > 4)

  273.       _doLoadUsage (argv) ;

  274.   }

  275.   else

  276.     _doLoadUsage (argv) ;

  277. 

  278.   if (findExecutable ("modprobe") == NULL)

  279.     printf ("No found\n") ;

  280. 

  281.   if (!moduleLoaded (module1))

  282.   {

  283.     sprintf (cmd, "%s %s%s", findExecutable (MODPROBE), module1, args1) ;

  284.     int ret = system(cmd);

  285.     if (ret == -1) {

  286.       perror("Error executing command");

  287.     } else if (WIFEXITED(ret)) {

  288.       int exit_status = WEXITSTATUS(ret);

  289.       if (exit_status != 0) {

  290.         fprintf(stderr, "Command failed with exit status %d\n", exit_status);

  291.       }

  292.     } else {

  293.       fprintf(stderr, "Command terminated by signal\n");

  294.     }

  295.   }

  296. 

  297.   if (!moduleLoaded (module2))

  298.   {

  299.     sprintf (cmd, "%s %s%s", findExecutable (MODPROBE), module2, args2) ;

  300.     int ret = system(cmd);

  301.     if (ret == -1) {

  302.       perror("Error executing command");

  303.     } else if (WIFEXITED(ret)) {

  304.       int exit_status = WEXITSTATUS(ret);

  305.       if (exit_status != 0) {

  306.         fprintf(stderr, "Command failed with exit status %d\n", exit_status);

  307.       }

  308.     } else {

  309.       fprintf(stderr, "Command terminated by signal\n");

  310.     }

  311.   }

  312. 

  313.   if (!moduleLoaded (module2))

  314.   {

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

  316.     exit (1) ;

  317.   }

  318. 

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

  320. 

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

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

  323. }

  324. 

  325. 

  326. /*

  327.  * doUnLoad:

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

  329.  *********************************************************************************

  330.  */

  331. 

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

  333. {

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

  335.   exit (1) ;

  336. }

  337. 

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

  339. {

  340.   char *module1, *module2 ;

  341.   char cmd [80] ;

  342. 

  343.   checkDevTree (argv) ;

  344. 

  345.   if (argc != 3)

  346.     _doUnLoadUsage (argv) ;

  347. 

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

  349.   {

  350.     module1 = "spidev" ;

  351.     module2 = "spi_bcm2708" ;

  352.   }

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

  354.   {

  355.     module1 = "i2c_dev" ;

  356.     module2 = "i2c_bcm2708" ;

  357.   }

  358.   else

  359.     _doUnLoadUsage (argv) ;

  360. 

  361.   if (moduleLoaded (module1))

  362.   {

  363.     sprintf (cmd, "%s %s", findExecutable (RMMOD), module1) ;

  364.     int ret = system(cmd);

  365.     if (ret == -1) {

  366.       perror("Error executing command");

  367.     } else if (WIFEXITED(ret)) {

  368.       int exit_status = WEXITSTATUS(ret);

  369.       if (exit_status != 0) {

  370.         fprintf(stderr, "Command failed with exit status %d\n", exit_status);

  371.       }

  372.     } else {

  373.       fprintf(stderr, "Command terminated by signal\n");

  374.     }

  375.   }

  376. 

  377.   if (moduleLoaded (module2))

  378.   {

  379.     sprintf (cmd, "%s %s", findExecutable (RMMOD), module2) ;

  380.     int ret = system(cmd);

  381.     if (ret == -1) {

  382.       perror("Error executing command");

  383.     } else if (WIFEXITED(ret)) {

  384.       int exit_status = WEXITSTATUS(ret);

  385.       if (exit_status != 0) {

  386.         fprintf(stderr, "Command failed with exit status %d\n", exit_status);

  387.       }

  388.     } else {

  389.       fprintf(stderr, "Command terminated by signal\n");

  390.     }

  391.   }

  392. }

  393. 

  394. 

  395. /*

  396.  * doI2Cdetect:

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

  398.  *********************************************************************************

  399.  */

  400. 

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

  402. {

  403.   int port = piGpioLayout () == GPIO_LAYOUT_PI1_REV1 ? 0 : 1 ;

  404.   char *c, *command ;

  405. 

  406.   if ((c = findExecutable (I2CDETECT)) == NULL)

  407.   {

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

  409.     return ;

  410.   }

  411. 

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

  413.   {

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

  415.     return ;

  416.   }

  417. 

  418.   command = malloc (strlen (c) + 16) ;

  419.   sprintf (command, "%s -y %d", c, port) ;

  420.   if (system (command) < 0)

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

  422. 

  423. }

  424. 

  425. 

  426. void SYSFS_DEPRECATED(const char *progName) {

  427.   fprintf(stderr, "%s: GPIO Sysfs Interface for Userspace is deprecated (https://www.kernel.org/doc/Documentation/gpio/sysfs.txt).\n Function is now useless and empty.\n\n", progName);

  428. }

  429. 

  430. /*

  431.  * doExports:  -> deprecated, removed

  432.  *	List all GPIO exports

  433.  *********************************************************************************

  434.  */

  435. 

  436. /*

  437.  * doExport:  -> deprecated, removed

  438.  *	gpio export pin mode

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

  440.  *********************************************************************************

  441.  */

  442. 

  443. 

  444. /*

  445.  * doWfi:

  446.  *	gpio wfi pin mode

  447.  *	Wait for Interrupt on a given pin.

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

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

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

  451.  *********************************************************************************

  452.  */

  453. 

  454. static volatile int iterations ;

  455. static volatile int globalCounter ;

  456. 

  457. void printgpioflush(const char* text) {

  458.   if (gpioDebug) {

  459.     printf("%s", text); 

  460.     fflush(stdout);

  461.   }

  462. }

  463. 

  464. void printgpio(const char* text) {

  465.   if (gpioDebug) {

  466.     printf("%s", text);

  467.   }

  468. }

  469. 

  470. static void wfi (void) { 

  471.   globalCounter++;

  472.   if(globalCounter>=iterations) {

  473.     printgpio("finished\n");

  474.     exit (0) ; 

  475.   } else {

  476.     printgpioflush("I");

  477.   }

  478. }

  479. 

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

  481. {

  482.   int pin, mode;

  483.   int timeoutSec = 2147483647;

  484. 

  485.   iterations = 1;

  486.   globalCounter = 0;

  487.   if (argc != 4 && argc != 5 && argc != 6)

  488.   {

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

  490.     exit (1) ;

  491.   }

  492. 

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

  494. 

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

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

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

  498.   else

  499.   {

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

  501.     exit (1) ;

  502.   }

  503.   if (argc>=5) {

  504.     iterations = atoi(argv [4]);

  505.   }

  506.   if (argc>=6) {

  507.     timeoutSec = atoi(argv [5]);

  508.   }

  509. 

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

  511.   {

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

  513.     exit (1) ;

  514.   }

  515. 

  516.   printgpio("wait for interrupt function call\n");

  517.   for (int Sec=0; Sec<timeoutSec; ++Sec) {

  518.     printgpioflush(".");

  519.     delay (999);

  520.   }

  521.   printgpio("\nstopping wait for interrupt\n");

  522.   wiringPiISRStop (pin); 

  523. }

  524. 

  525. 

  526. /*

  527.  * doEdge:  -> deprecated, removed

  528.  *	gpio edge pin mode

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

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

  531.  *********************************************************************************

  532.  */

  533. 

  534. /*

  535.  * doUnexport: -> deprecated, removed

  536.  *	gpio unexport pin

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

  538.  *********************************************************************************

  539.  */

  540. 

  541. /*

  542.  * doUnexportAll: -> deprecated, removed

  543.  *	gpio unexportall

  544.  *	Un-Export all the GPIO pins.

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

  546.  *********************************************************************************

  547.  */

  548. 

  549. 

  550. /*

  551.  * doReset:

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

  553.  *********************************************************************************

  554.  */

  555. 

  556. static void doReset (UNU char *progName)

  557. {

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

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

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

  561. }

  562. 

  563. 

  564. /*

  565.  * doMode:

  566.  *	gpio mode pin mode ...

  567.  *********************************************************************************

  568.  */

  569. 

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

  571. {

  572.   int pin ;

  573.   char *mode ;

  574. 

  575.   if (argc != 4)

  576.   {

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

  578.     exit (1) ;

  579.   }

  580. 

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

  582. 

  583.   mode = argv [3] ;

  584. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  602.   else

  603.   {

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

  605.     exit (1) ;

  606.   }

  607. }

  608. 

  609. 

  610. /*

  611.  * doPadDrive:

  612.  *	gpio drive group value

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

  614.  */

  615. 

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

  617. {

  618. 

  619.   if (argc != 4) {

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

  621.     exit (1) ;

  622.   }

  623. 

  624.   int pin = atoi (argv [2]) ;

  625.   int val = atoi (argv [3]) ;

  626. 

  627.   if ((pin < 0) || (pin > 27)) {

  628.     fprintf (stderr, "%s: drive pin not 0-27: %d\n", argv [0], pin) ;

  629.     exit (1) ;

  630.   }

  631. 

  632.   if ((val < 0) || (val > 3)) {

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

  634.     exit (1) ;

  635.   }

  636. 

  637.   setPadDrivePin (pin, val) ;

  638. }

  639. 

  640. 

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

  642. {

  643.   int group, val ;

  644. 

  645.   if (argc != 4)

  646.   {

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

  648.     exit (1) ;

  649.   }

  650. 

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

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

  653. 

  654.   if ((group < -1) || (group > 2))  //-1 hidden feature for read and print values

  655.   {

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

  657.     exit (1) ;

  658.   }

  659. 

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

  661.   {

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

  663.     exit (1) ;

  664.   }

  665. 

  666.   setPadDrive (group, val) ;

  667. }

  668. 

  669. 

  670. /*

  671.  * doUsbP:

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

  673.  *	gpio usbp high/low

  674.  *********************************************************************************

  675.  */

  676. 

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

  678. {

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

  680. 

  681.   if (argc != 3)

  682.   {

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

  684.     exit (1) ;

  685.   }

  686. 

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

  688. 

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

  690. 

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

  692.   {

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

  694.     exit (1) ;

  695.   }

  696.     

  697. // Make sure we start in BCM_GPIO mode

  698. 

  699.   wiringPiSetupGpio () ;

  700. 

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

  702.   {

  703.     digitalWrite (PI_USB_POWER_CONTROL, 1) ;

  704.     pinMode (PI_USB_POWER_CONTROL, OUTPUT) ;

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

  706.     return ;

  707.   }

  708. 

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

  710.   {

  711.     digitalWrite (PI_USB_POWER_CONTROL, 0) ;

  712.     pinMode (PI_USB_POWER_CONTROL, OUTPUT) ;

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

  714.     return ;

  715.   }

  716. 

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

  718.   exit (1) ;

  719. }

  720. 

  721. 

  722. /*

  723.  * doGbw:

  724.  *	gpio gbw channel value

  725.  *	Gertboard Write - To the Analog output

  726.  *********************************************************************************

  727.  */

  728. 

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

  730. {

  731.   int channel, value ;

  732. 

  733.   if (argc != 4)

  734.   {

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

  736.     exit (1) ;

  737.   }

  738. 

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

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

  741. 

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

  743.   {

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

  745.     exit (1) ;

  746.   }

  747. 

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

  749.   {

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

  751.     exit (1) ;

  752.   }

  753. 

  754.   if (gertboardAnalogSetup (64) < 0)

  755.   {

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

  757.     exit (1) ;

  758.   }

  759. 

  760.   analogWrite (64 + channel, value) ;

  761. }

  762. 

  763. 

  764. /*

  765.  * doGbr:

  766.  *	gpio gbr channel

  767.  *	From the analog input

  768.  *********************************************************************************

  769.  */

  770. 

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

  772. {

  773.   int channel ;

  774. 

  775.   if (argc != 3)

  776.   {

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

  778.     exit (1) ;

  779.   }

  780. 

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

  782. 

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

  784.   {

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

  786.     exit (1) ;

  787.   }

  788. 

  789.   if (gertboardAnalogSetup (64) < 0)

  790.   {

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

  792.     exit (1) ;

  793.   }

  794. 

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

  796. }

  797. 

  798. 

  799. /*

  800.  * doWrite:

  801.  *	gpio write pin value

  802.  *********************************************************************************

  803.  */

  804. 

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

  806. {

  807.   int pin, val ;

  808. 

  809.   if (argc != 4)

  810.   {

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

  812.     exit (1) ;

  813.   }

  814. 

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

  816. 

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

  818.     val = 1 ;

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

  820.     val = 0 ;

  821.   else

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

  823. 

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

  825.     digitalWrite (pin, LOW) ;

  826.   else

  827.     digitalWrite (pin, HIGH) ;

  828. }

  829. 

  830. 

  831. /*

  832.  * doAwriterite:

  833.  *	gpio awrite pin value

  834.  *********************************************************************************

  835.  */

  836. 

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

  838. {

  839.   int pin, val ;

  840. 

  841.   if (argc != 4)

  842.   {

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

  844.     exit (1) ;

  845.   }

  846. 

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

  848. 

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

  850. 

  851.   analogWrite (pin, val) ;

  852. }

  853. 

  854. 

  855. /*

  856.  * doWriteByte:

  857.  *	gpio wb value

  858.  *********************************************************************************

  859.  */

  860. 

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

  862. {

  863.   int val ;

  864. 

  865.   if (argc != 3)

  866.   {

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

  868.     exit (1) ;

  869.   }

  870. 

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

  872. 

  873.   digitalWriteByte (val) ;

  874. }

  875. 

  876. 

  877. /*

  878.  * doReadByte:

  879.  *	gpio rbx|rbd value

  880.  *********************************************************************************

  881.  */

  882. 

  883. static void doReadByte (int argc, char *argv [], int printHex)

  884. {

  885.   int val ;

  886. 

  887.   if (argc != 2)

  888.   {

  889.     fprintf (stderr, "Usage: %s rbx|rbd\n", argv [0]) ;

  890.     exit (1) ;

  891.   }

  892. 

  893.   val = digitalReadByte () ;

  894.   if (printHex)

  895.     printf ("%02X\n", val) ;

  896.   else

  897.     printf ("%d\n", val) ;

  898. }

  899. 

  900. 

  901. /*

  902.  * doRead:

  903.  *	Read a pin and return the value

  904.  *********************************************************************************

  905.  */

  906. 

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

  908. {

  909.   int pin, val ;

  910. 

  911.   if (argc != 3)

  912.   {

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

  914.     exit (1) ;

  915.   }

  916. 

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

  918.   val = digitalRead (pin) ;

  919. 

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

  921. }

  922. 

  923. 

  924. /*

  925.  * doAread:

  926.  *	Read an analog pin and return the value

  927.  *********************************************************************************

  928.  */

  929. 

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

  931. {

  932.   if (argc != 3)

  933.   {

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

  935.     exit (1) ;

  936.   }

  937. 

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

  939. }

  940. 

  941. 

  942. /*

  943.  * doToggle:

  944.  *	Toggle an IO pin

  945.  *********************************************************************************

  946.  */

  947. 

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

  949. {

  950.   int pin ;

  951. 

  952.   if (argc != 3)

  953.   {

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

  955.     exit (1) ;

  956.   }

  957. 

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

  959. 

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

  961. }

  962. 

  963. 

  964. /*

  965.  * doBlink:

  966.  *	Blink an IO pin

  967.  *********************************************************************************

  968.  */

  969. 

  970. void doBlink (int argc, char *argv [])

  971. {

  972.   int pin ;

  973. 

  974.   if (argc != 3)

  975.   {

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

  977.     exit (1) ;

  978.   }

  979. 

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

  981. 

  982.   pinMode (pin, OUTPUT) ;

  983.   for (;;)

  984.   {

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

  986.     delay (500) ;

  987.   }

  988. 

  989. }

  990. 

  991. 

  992. /*

  993.  * doPwmTone:

  994.  *	Output a tone in a PWM pin

  995.  *********************************************************************************

  996.  */

  997. 

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

  999. {

  1000.   int pin, freq ;

  1001. 

  1002.   if (argc != 4)

  1003.   {

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

  1005.     exit (1) ;

  1006.   }

  1007. 

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

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

  1010. 

  1011.   pwmToneWrite (pin, freq) ;

  1012. }

  1013. 

  1014. 

  1015. /*

  1016.  * doClock:

  1017.  *	Output a clock on a pin

  1018.  *********************************************************************************

  1019.  */

  1020. 

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

  1022. {

  1023.   int pin, freq ;

  1024. 

  1025.   if (argc != 4)

  1026.   {

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

  1028.     exit (1) ;

  1029.   }

  1030. 

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

  1032. 

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

  1034. 

  1035.   gpioClockSet (pin, freq) ;

  1036. }

  1037. 

  1038. 

  1039. /*

  1040.  * doPwm:

  1041.  *	Output a PWM value on a pin

  1042.  *********************************************************************************

  1043.  */

  1044. 

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

  1046. {

  1047.   int pin, val ;

  1048. 

  1049.   if (argc != 4)

  1050.   {

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

  1052.     exit (1) ;

  1053.   }

  1054. 

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

  1056. 

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

  1058. 

  1059.   pwmWrite (pin, val) ;

  1060. }

  1061. 

  1062. 

  1063. /*

  1064.  * doPwmMode: doPwmRange: doPwmClock:

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

  1066.  *********************************************************************************

  1067.  */

  1068. 

  1069. static void doPwmMode (int mode)

  1070. {

  1071.   pwmSetMode (mode) ;

  1072. }

  1073. 

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

  1075. {

  1076.   unsigned int range ;

  1077. 

  1078.   if (argc != 3)

  1079.   {

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

  1081.     exit (1) ;

  1082.   }

  1083. 

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

  1085. 

  1086.   if (range == 0)

  1087.   {

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

  1089.     exit (1) ;

  1090.   }

  1091. 

  1092.   pwmSetRange (range) ;

  1093. }

  1094. 

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

  1096. {

  1097.   unsigned int clock ;

  1098. 

  1099.   if (argc != 3)

  1100.   {

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

  1102.     exit (1) ;

  1103.   }

  1104. 

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

  1106. 

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

  1108.   {

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

  1110.     exit (1) ;

  1111.   }

  1112. 

  1113.   pwmSetClock (clock) ;

  1114. }

  1115. 

  1116. 

  1117. /*

  1118.  * doVersion:

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

  1120.  *	some usefull information.

  1121.  *********************************************************************************

  1122.  */

  1123. 

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

  1125. {

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

  1127.   struct stat statBuf ;

  1128.   char name [80] ;

  1129.   FILE *fd ;

  1130. 

  1131.   int vMaj, vMin ;

  1132. 

  1133.   wiringPiVersion (&vMaj, &vMin) ;

  1134.   printf ("gpio version: %d.%d\n", vMaj, vMin) ;

  1135.   printf ("Copyright (c) 2012-2024 Gordon Henderson and contributors\n") ;

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

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

  1138.   printf ("\n") ;

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

  1140. 

  1141.   printf ("Hardware details:\n") ;

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

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

  1144. 

  1145. // Check for device tree

  1146.   printf ("\nSystem details:\n") ;

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

  1148.     printf ("  * Device tree present.\n") ;

  1149.   }

  1150.   if (stat ("/proc/device-tree/model", &statBuf) == 0)	// Output Kernel idea of board type

  1151.   {

  1152.     if ((fd = fopen ("/proc/device-tree/model", "r")) != NULL)

  1153.     {

  1154.       if (fgets(name, sizeof(name), fd) == NULL) {

  1155.         // Handle error or end of file condition

  1156.         perror("Error reading /proc/device-tree/model");

  1157.       }

  1158.       fclose (fd) ;

  1159.       printf ("      Model: %s\n", name) ;

  1160.     }

  1161.   }

  1162. 

  1163.   int bGlobalAccess = wiringPiGlobalMemoryAccess();		// User level GPIO is GO

  1164.   switch(bGlobalAccess) {

  1165.     case 0:

  1166.         printf ("  * Does not support basic user-level GPIO access via memory.\n") ;

  1167.         break;

  1168.     case 1:

  1169.         printf ("  * Supports basic user-level GPIO access via /dev/mem.\n") ;

  1170.         break;

  1171.     case 2:

  1172.         printf ("  * Supports full  user-level GPIO access via memory.\n") ;

  1173.         break;

  1174.   }

  1175.   if (wiringPiUserLevelAccess()) {

  1176.         printf ("  * Supports basic user-level GPIO access via /dev/gpiomem.\n") ;

  1177.   } else  {

  1178.         printf ("  * Does not support basic user-level GPIO access via /dev/gpiomem.\n") ;

  1179.     if(0==bGlobalAccess) {

  1180.         printf ("  * root or sudo may be required for direct GPIO access.\n") ;

  1181.     }

  1182.   }

  1183.   if (wiringPiGpioDeviceGetFd()>0) {

  1184.     printf ("  * Supports basic user-level GPIO access via /dev/gpiochip (slow).\n") ;

  1185.   }

  1186. 

  1187. }

  1188. 

  1189. 

  1190. /*

  1191.  * main:

  1192.  *	Start here

  1193.  *********************************************************************************

  1194.  */

  1195. 

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

  1197. {

  1198.   int i ;

  1199. 

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

  1201.   {

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

  1203.     wiringPiDebug = TRUE ;

  1204.   }

  1205.   if (getenv ("GPIO_DEBUG") != NULL)

  1206.   {

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

  1208.     gpioDebug = TRUE ;

  1209.   }

  1210. 

  1211.   if (argc == 1)

  1212.   {

  1213.     fprintf (stderr,

  1214. "%s: At your service!\n"

  1215. "  Type: gpio -h for full details and\n"

  1216. "        gpio readall for a quick printout of your connector details\n", argv [0]) ;

  1217.     exit (EXIT_FAILURE) ;

  1218.   }

  1219. 

  1220. // Help

  1221. 

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

  1223.   {

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

  1225.     exit (EXIT_SUCCESS) ;

  1226.   }

  1227. 

  1228. // Version & Warranty

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

  1230. 

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

  1232.   {

  1233.     printf ("%d\n", piGpioLayout ()) ;

  1234.     exit (EXIT_SUCCESS) ;

  1235.   }

  1236. 

  1237. // Version and information

  1238. 

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

  1240.   {

  1241.     doVersion (argv) ;

  1242.     exit (EXIT_SUCCESS) ;

  1243.   }

  1244. 

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

  1246.   {

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

  1248.     printf ("Copyright (c) 2012-2024 Gordon Henderson and contributors\n") ;

  1249.     printf ("\n") ;

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

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

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

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

  1254.     printf ("\n") ;

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

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

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

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

  1259.     printf ("\n") ;

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

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

  1262.     printf ("\n") ;

  1263.     exit (EXIT_SUCCESS) ;

  1264.   }

  1265. 

  1266.   if (geteuid () != 0)

  1267.   {

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

  1269.     exit (EXIT_FAILURE) ;

  1270.   }

  1271. 

  1272. // Initial test for /sys/class/gpio operations:  - -> deprecated, empty but still there

  1273. 

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

  1275.   else if (strcasecmp (argv [1], "export"     ) == 0)	{ SYSFS_DEPRECATED(argv[0]);	return 0 ; }

  1276.   else if (strcasecmp (argv [1], "edge"       ) == 0)	{ SYSFS_DEPRECATED(argv[0]);	return 0 ; }

  1277.   else if (strcasecmp (argv [1], "unexport"   ) == 0)	{ SYSFS_DEPRECATED(argv[0]);	return 0 ; }

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

  1279. 

  1280. // Check for load command:

  1281. 

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

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

  1284. 

  1285. // Check for usb power command

  1286. 

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

  1288. 

  1289. // Gertboard commands

  1290. 

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

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

  1293. 

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

  1295. 

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

  1297.   {

  1298.     wiringPiSetupGpio () ;

  1299.     doAllReadall      () ;

  1300.     return 0 ;

  1301.   }

  1302. 

  1303. // Check for -g argument

  1304. 

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

  1306.   {

  1307.     wiringPiSetupGpio () ;

  1308. 

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

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

  1311.     --argc ;

  1312.     wpMode = WPI_MODE_GPIO ;

  1313.   }

  1314. 

  1315. // Check for -1 argument

  1316. 

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

  1318.   {

  1319.     wiringPiSetupPhys () ;

  1320. 

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

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

  1323.     --argc ;

  1324.     wpMode = WPI_MODE_PHYS ;

  1325.   }

  1326. 

  1327. // Check for -p argument for PiFace

  1328. 

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

  1330.   {

  1331.     piFaceSetup (200) ;

  1332. 

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

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

  1335.     --argc ;

  1336.     wpMode = WPI_MODE_PIFACE ;

  1337.   }

  1338. 

  1339. // Check for -z argument so we don't actually initialise wiringPi

  1340. 

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

  1342.   {

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

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

  1345.     --argc ;

  1346.     wpMode = WPI_MODE_UNINITIALISED ;

  1347.   }

  1348. 

  1349. // Default to wiringPi mode

  1350. 

  1351.   else

  1352.   {

  1353.     wiringPiSetup () ;

  1354.     wpMode = WPI_MODE_PINS ;

  1355.   }

  1356. 

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

  1358. //	-x extension:base:args

  1359. //	Can load many modules, but unless daemon mode we can only send one

  1360. //	command at a time.

  1361. 

  1362.   while (strcasecmp (argv [1], "-x") == 0)

  1363.   {

  1364.     if (argc < 3)

  1365.     {

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

  1367.       exit (EXIT_FAILURE) ;

  1368.     }

  1369. 

  1370.     if (!loadWPiExtension (argv [0], argv [2], TRUE))

  1371.     {

  1372.       fprintf (stderr, "%s: Extension load failed: %s\n", argv [0], strerror (errno)) ;

  1373.       exit (EXIT_FAILURE) ;

  1374.     }

  1375. 

  1376. // Shift args down by 2

  1377. 

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

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

  1380.     argc -= 2 ;

  1381.   }

  1382. 

  1383.   if (argc <= 1)

  1384.   {

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

  1386.     exit (EXIT_FAILURE) ;

  1387.   }

  1388. 

  1389. // Core wiringPi functions

  1390. 

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

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

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

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

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

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

  1397. 

  1398. // GPIO Nicies

  1399. 

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

  1401.   else if (strcasecmp (argv [1], "blink"  ) == 0) doBlink     (argc, argv) ;

  1402. 

  1403. // Pi Specifics

  1404. 

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

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

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

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

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

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

  1411.   else if (strcasecmp (argv [1], "drivepin" ) == 0) doPadDrivePin(argc, argv) ;

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

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

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

  1415.   else if (strcasecmp (argv [1], "qmode"    ) == 0) doQmode      (argc, argv) ;

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

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

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

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

  1420.   else if (strcasecmp (argv [1], "rbx"      ) == 0) doReadByte   (argc, argv, TRUE) ;

  1421.   else if (strcasecmp (argv [1], "rbd"      ) == 0) doReadByte   (argc, argv, FALSE) ;

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

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

  1424.   else

  1425.   {

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

  1427.     exit (EXIT_FAILURE) ;

  1428.   }

  1429. 

  1430.   return 0 ;

  1431. }