diff --git a/gpio/Makefile b/gpio/Makefile old mode 100644 new mode 100755 index f41a005..0b43204 --- a/gpio/Makefile +++ b/gpio/Makefile @@ -30,6 +30,9 @@ ifneq ($V,1) Q ?= @ endif +# BRAND_NAME = Pi +BRAND_NAME = Odroid + #DEBUG = -g -O0 DEBUG = -O2 CC = gcc @@ -41,9 +44,16 @@ LIBS = -lwiringPi -lwiringPiDev -lpthread -lrt -lm -lcrypt # May not need to alter anything below this line ############################################################################### +ifeq ($(BRAND_NAME), Odroid) + +SRC = gpio_odroid.c readall_odroid.c pins.c + +else SRC = gpio.c readall.c pins.c +endif + OBJ = $(SRC:.c=.o) all: gpio diff --git a/gpio/gpio_odroid.c b/gpio/gpio_odroid.c new file mode 100755 index 0000000..6fd71f8 --- /dev/null +++ b/gpio/gpio_odroid.c @@ -0,0 +1,1535 @@ +/* + * gpio.c: + * Swiss-Army-Knife, Set-UID command-line interface to the Raspberry + * Pi's GPIO. + * Copyright (c) 2012-2017 Gordon Henderson + *********************************************************************** + * This file is part of wiringPi: + * https://projects.drogon.net/raspberry-pi/wiringpi/ + * + * wiringPi is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * wiringPi is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with wiringPi. If not, see . + *********************************************************************** + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "../version.h" + +extern int wiringPiDebug ; + +// External functions I can't be bothered creating a separate .h file for: + +extern void doReadall (void) ; +extern void doAllReadall (void) ; +extern void doPins (void) ; + +#ifndef TRUE +# define TRUE (1==1) +# define FALSE (1==2) +#endif + +#define PI_USB_POWER_CONTROL 38 +#define I2CDETECT "/usr/sbin/i2cdetect" +#define MODPROBE "/sbin/modprobe" +#define RMMOD "/sbin/rmmod" + +int wpMode ; + +char *usage = "Usage: gpio -v\n" + " gpio -h\n" + " gpio [-g|-1] ...\n" + " gpio [-d] ...\n" + " [-x extension:params] [[ -x ...]] ...\n" + " gpio [-p] ...\n" + " gpio ...\n" + " gpio \n" + " gpio readall/reset\n" + " gpio unexportall/exports\n" + " gpio export/edge/unexport ...\n" + " gpio wfi \n" + " gpio drive \n" + " gpio pwm-bal/pwm-ms \n" + " gpio pwmr \n" + " gpio pwmc \n" + " gpio load spi/i2c\n" + " gpio unload spi/i2c\n" + " gpio i2cd/i2cdetect\n" + " gpio rbx/rbd\n" + " gpio wb \n" + " gpio usbp high/low\n" + " gpio gbr \n" + " gpio gbw " ; // No trailing newline needed here. + + +#ifdef NOT_FOR_NOW +/* + * decodePin: + * Decode a pin "number" which can actually be a pin name to represent + * one of the Pi's on-board pins. + ********************************************************************************* + */ + +static int decodePin (const char *str) +{ + +// The first case - see if it's a number: + + if (isdigit (str [0])) + return atoi (str) ; + + return 0 ; +} +#endif + + +/* + * findExecutable: + * Code to locate the path to the given executable. We have a fixed list + * of locations to try which completely overrides any $PATH environment. + * This may be detrimental, however it avoids the reliance on $PATH + * which may be a security issue when this program is run a set-uid-root. + ********************************************************************************* + */ + +static const char *searchPath [] = +{ + "/sbin", + "/usr/sbin", + "/bin", + "/usr/bin", + NULL, +} ; + +static char *findExecutable (const char *progName) +{ + static char *path = NULL ; + int len = strlen (progName) ; + int i = 0 ; + struct stat statBuf ; + + for (i = 0 ; searchPath [i] != NULL ; ++i) + { + path = malloc (strlen (searchPath [i]) + len + 2) ; + sprintf (path, "%s/%s", searchPath [i], progName) ; + + if (stat (path, &statBuf) == 0) + return path ; + free (path) ; + } + + return NULL ; +} + + +/* + * changeOwner: + * Change the ownership of the file to the real userId of the calling + * program so we can access it. + ********************************************************************************* + */ + +static void changeOwner (char *cmd, char *file) +{ + uid_t uid = getuid () ; + uid_t gid = getgid () ; + + if (chown (file, uid, gid) != 0) + { + +// Removed (ignoring) the check for not existing as I'm fed-up with morons telling me that +// the warning message is an error. + + if (errno != ENOENT) + fprintf (stderr, "%s: Unable to change ownership of %s: %s\n", cmd, file, strerror (errno)) ; + } +} + + +/* + * moduleLoaded: + * Return true/false if the supplied module is loaded + ********************************************************************************* + */ + +static int moduleLoaded (char *modName) +{ + int len = strlen (modName) ; + int found = FALSE ; + FILE *fd = fopen ("/proc/modules", "r") ; + char line [80] ; + + if (fd == NULL) + { + fprintf (stderr, "gpio: Unable to check /proc/modules: %s\n", strerror (errno)) ; + exit (1) ; + } + + while (fgets (line, 80, fd) != NULL) + { + if (strncmp (line, modName, len) != 0) + continue ; + + found = TRUE ; + break ; + } + + fclose (fd) ; + + return found ; +} + + +/* + * doLoad: + * Load either the spi or i2c modules and change device ownerships, etc. + ********************************************************************************* + */ + +static void checkDevTree (char *argv []) +{ + struct stat statBuf ; + + if (stat ("/proc/device-tree", &statBuf) == 0) // We're on a devtree system ... + { + fprintf (stderr, +"%s: Unable to load/unload modules as this Pi has the device tree enabled.\n" +" You need to run the raspi-config program (as root) and select the\n" +" modules (SPI or I2C) that you wish to load/unload there and reboot.\n" +" There is more information here:\n" +" https://www.raspberrypi.org/forums/viewtopic.php?f=28&t=97314\n", argv [0]) ; + exit (1) ; + } +} + +static void _doLoadUsage (char *argv []) +{ + fprintf (stderr, "Usage: %s load [I2C baudrate in Kb/sec]\n", argv [0]) ; + exit (1) ; +} + +static void doLoad (int argc, char *argv []) +{ + char *module1, *module2 ; + char cmd [80] ; + char *file1, *file2 ; + char args1 [32], args2 [32] ; + + checkDevTree (argv) ; + + if (argc < 3) + _doLoadUsage (argv) ; + + args1 [0] = args2 [0] = 0 ; + + /**/ if (strcasecmp (argv [2], "spi") == 0) + { + module1 = "spidev" ; + module2 = "spi_bcm2708" ; + file1 = "/dev/spidev0.0" ; + file2 = "/dev/spidev0.1" ; + if (argc == 4) + { + fprintf (stderr, "%s: Unable to set the buffer size now. Load aborted. Please see the man page.\n", argv [0]) ; + exit (1) ; + } + else if (argc > 4) + _doLoadUsage (argv) ; + } + else if (strcasecmp (argv [2], "i2c") == 0) + { + module1 = "i2c_dev" ; + module2 = "i2c_bcm2708" ; + file1 = "/dev/i2c-0" ; + file2 = "/dev/i2c-1" ; + if (argc == 4) + sprintf (args2, " baudrate=%d", atoi (argv [3]) * 1000) ; + else if (argc > 4) + _doLoadUsage (argv) ; + } + else + _doLoadUsage (argv) ; + + if (findExecutable ("modprobe") == NULL) + printf ("No found\n") ; + + if (!moduleLoaded (module1)) + { + sprintf (cmd, "%s %s%s", findExecutable (MODPROBE), module1, args1) ; + system (cmd) ; + } + + if (!moduleLoaded (module2)) + { + sprintf (cmd, "%s %s%s", findExecutable (MODPROBE), module2, args2) ; + system (cmd) ; + } + + if (!moduleLoaded (module2)) + { + fprintf (stderr, "%s: Unable to load %s\n", argv [0], module2) ; + exit (1) ; + } + + sleep (1) ; // To let things get settled + + changeOwner (argv [0], file1) ; + changeOwner (argv [0], file2) ; +} + + +/* + * doUnLoad: + * Un-Load either the spi or i2c modules and change device ownerships, etc. + ********************************************************************************* + */ + +static void _doUnLoadUsage (char *argv []) +{ + fprintf (stderr, "Usage: %s unload \n", argv [0]) ; + exit (1) ; +} + +static void doUnLoad (int argc, char *argv []) +{ + char *module1, *module2 ; + char cmd [80] ; + + checkDevTree (argv) ; + + if (argc != 3) + _doUnLoadUsage (argv) ; + + /**/ if (strcasecmp (argv [2], "spi") == 0) + { + module1 = "spidev" ; + module2 = "spi_bcm2708" ; + } + else if (strcasecmp (argv [2], "i2c") == 0) + { + module1 = "i2c_dev" ; + module2 = "i2c_bcm2708" ; + } + else + _doUnLoadUsage (argv) ; + + if (moduleLoaded (module1)) + { + sprintf (cmd, "%s %s", findExecutable (RMMOD), module1) ; + system (cmd) ; + } + + if (moduleLoaded (module2)) + { + sprintf (cmd, "%s %s", findExecutable (RMMOD), module2) ; + system (cmd) ; + } +} + + +/* + * doI2Cdetect: + * Run the i2cdetect command with the right runes for this Pi revision + ********************************************************************************* + */ + +static void doI2Cdetect (UNU int argc, char *argv []) +{ + int port = piGpioLayout () == 1 ? 0 : 1 ; + char *c, *command ; + + if ((c = findExecutable (I2CDETECT)) == NULL) + { + fprintf (stderr, "%s: Unable to find i2cdetect command: %s\n", argv [0], strerror (errno)) ; + return ; + } + + if (!moduleLoaded ("i2c_dev")) + { + fprintf (stderr, "%s: The I2C kernel module(s) are not loaded.\n", argv [0]) ; + return ; + } + + command = malloc (strlen (c) + 16) ; + sprintf (command, "%s -y %d", c, port) ; + if (system (command) < 0) + fprintf (stderr, "%s: Unable to run i2cdetect: %s\n", argv [0], strerror (errno)) ; + +} + + +/* + * doExports: + * List all GPIO exports + ********************************************************************************* + */ + +static void doExports (UNU int argc, UNU char *argv []) +{ + int fd ; + int i, l, first ; + char fName [128] ; + char buf [16] ; + + for (first = 0, i = 0 ; i < 64 ; ++i) // Crude, but effective + { + +// Try to read the direction + + sprintf (fName, "/sys/class/gpio/gpio%d/direction", i) ; + if ((fd = open (fName, O_RDONLY)) == -1) + continue ; + + if (first == 0) + { + ++first ; + printf ("GPIO Pins exported:\n") ; + } + + printf ("%4d: ", i) ; + + if ((l = read (fd, buf, 16)) == 0) + sprintf (buf, "%s", "?") ; + + buf [l] = 0 ; + if ((buf [strlen (buf) - 1]) == '\n') + buf [strlen (buf) - 1] = 0 ; + + printf ("%-3s", buf) ; + + close (fd) ; + +// Try to Read the value + + sprintf (fName, "/sys/class/gpio/gpio%d/value", i) ; + if ((fd = open (fName, O_RDONLY)) == -1) + { + printf ("No Value file (huh?)\n") ; + continue ; + } + + if ((l = read (fd, buf, 16)) == 0) + sprintf (buf, "%s", "?") ; + + buf [l] = 0 ; + if ((buf [strlen (buf) - 1]) == '\n') + buf [strlen (buf) - 1] = 0 ; + + printf (" %s", buf) ; + +// Read any edge trigger file + + sprintf (fName, "/sys/class/gpio/gpio%d/edge", i) ; + if ((fd = open (fName, O_RDONLY)) == -1) + { + printf ("\n") ; + continue ; + } + + if ((l = read (fd, buf, 16)) == 0) + sprintf (buf, "%s", "?") ; + + buf [l] = 0 ; + if ((buf [strlen (buf) - 1]) == '\n') + buf [strlen (buf) - 1] = 0 ; + + printf (" %-8s\n", buf) ; + + close (fd) ; + } +} + + +/* + * doExport: + * gpio export pin mode + * This uses the /sys/class/gpio device interface. + ********************************************************************************* + */ + +void doExport (int argc, char *argv []) +{ + FILE *fd ; + int pin ; + char *mode ; + char fName [128] ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s export pin mode\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + mode = argv [3] ; + + if ((fd = fopen ("/sys/class/gpio/export", "w")) == NULL) + { + fprintf (stderr, "%s: Unable to open GPIO export interface: %s\n", argv [0], strerror (errno)) ; + exit (1) ; + } + + fprintf (fd, "%d\n", pin) ; + fclose (fd) ; + + sprintf (fName, "/sys/class/gpio/gpio%d/direction", pin) ; + if ((fd = fopen (fName, "w")) == NULL) + { + fprintf (stderr, "%s: Unable to open GPIO direction interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ; + exit (1) ; + } + + /**/ if ((strcasecmp (mode, "in") == 0) || (strcasecmp (mode, "input") == 0)) + fprintf (fd, "in\n") ; + else if ((strcasecmp (mode, "out") == 0) || (strcasecmp (mode, "output") == 0)) + fprintf (fd, "out\n") ; + else if ((strcasecmp (mode, "high") == 0) || (strcasecmp (mode, "up") == 0)) + fprintf (fd, "high\n") ; + else if ((strcasecmp (mode, "low") == 0) || (strcasecmp (mode, "down") == 0)) + fprintf (fd, "low\n") ; + else + { + fprintf (stderr, "%s: Invalid mode: %s. Should be in, out, high or low\n", argv [1], mode) ; + exit (1) ; + } + + fclose (fd) ; + +// Change ownership so the current user can actually use it + + sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ; + changeOwner (argv [0], fName) ; + + sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ; + changeOwner (argv [0], fName) ; + +} + + +/* + * doWfi: + * gpio wfi pin mode + * Wait for Interrupt on a given pin. + * Slight cheat here - it's easier to actually use ISR now (which calls + * gpio to set the pin modes!) then we simply sleep, and expect the thread + * to exit the program. Crude but effective. + ********************************************************************************* + */ + +static void wfi (void) + { exit (0) ; } + +void doWfi (int argc, char *argv []) +{ + int pin, mode ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s wfi pin mode\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + /**/ if (strcasecmp (argv [3], "rising") == 0) mode = INT_EDGE_RISING ; + else if (strcasecmp (argv [3], "falling") == 0) mode = INT_EDGE_FALLING ; + else if (strcasecmp (argv [3], "both") == 0) mode = INT_EDGE_BOTH ; + else + { + fprintf (stderr, "%s: wfi: Invalid mode: %s. Should be rising, falling or both\n", argv [1], argv [3]) ; + exit (1) ; + } + + if (wiringPiISR (pin, mode, &wfi) < 0) + { + fprintf (stderr, "%s: wfi: Unable to setup ISR: %s\n", argv [1], strerror (errno)) ; + exit (1) ; + } + + for (;;) + delay (9999) ; +} + + + +/* + * doEdge: + * gpio edge pin mode + * Easy access to changing the edge trigger on a GPIO pin + * This uses the /sys/class/gpio device interface. + ********************************************************************************* + */ + +void doEdge (int argc, char *argv []) +{ + FILE *fd ; + int pin ; + char *mode ; + char fName [128] ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s edge pin mode\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + mode = argv [3] ; + +// Export the pin and set direction to input + + if ((fd = fopen ("/sys/class/gpio/export", "w")) == NULL) + { + fprintf (stderr, "%s: Unable to open GPIO export interface: %s\n", argv [0], strerror (errno)) ; + exit (1) ; + } + + fprintf (fd, "%d\n", pin) ; + fclose (fd) ; + + sprintf (fName, "/sys/class/gpio/gpio%d/direction", pin) ; + if ((fd = fopen (fName, "w")) == NULL) + { + fprintf (stderr, "%s: Unable to open GPIO direction interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ; + exit (1) ; + } + + fprintf (fd, "in\n") ; + fclose (fd) ; + + sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ; + if ((fd = fopen (fName, "w")) == NULL) + { + fprintf (stderr, "%s: Unable to open GPIO edge interface for pin %d: %s\n", argv [0], pin, strerror (errno)) ; + exit (1) ; + } + + /**/ if (strcasecmp (mode, "none") == 0) fprintf (fd, "none\n") ; + else if (strcasecmp (mode, "rising") == 0) fprintf (fd, "rising\n") ; + else if (strcasecmp (mode, "falling") == 0) fprintf (fd, "falling\n") ; + else if (strcasecmp (mode, "both") == 0) fprintf (fd, "both\n") ; + else + { + fprintf (stderr, "%s: Invalid mode: %s. Should be none, rising, falling or both\n", argv [1], mode) ; + exit (1) ; + } + +// Change ownership of the value and edge files, so the current user can actually use it! + + sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ; + changeOwner (argv [0], fName) ; + + sprintf (fName, "/sys/class/gpio/gpio%d/edge", pin) ; + changeOwner (argv [0], fName) ; + + fclose (fd) ; +} + + +/* + * doUnexport: + * gpio unexport pin + * This uses the /sys/class/gpio device interface. + ********************************************************************************* + */ + +void doUnexport (int argc, char *argv []) +{ + FILE *fd ; + int pin ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s unexport pin\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + if ((fd = fopen ("/sys/class/gpio/unexport", "w")) == NULL) + { + fprintf (stderr, "%s: Unable to open GPIO export interface\n", argv [0]) ; + exit (1) ; + } + + fprintf (fd, "%d\n", pin) ; + fclose (fd) ; +} + + +/* + * doUnexportAll: + * gpio unexportall + * Un-Export all the GPIO pins. + * This uses the /sys/class/gpio device interface. + ********************************************************************************* + */ + +void doUnexportall (char *progName) +{ + FILE *fd ; + int pin ; + + for (pin = 0 ; pin < 63 ; ++pin) + { + if ((fd = fopen ("/sys/class/gpio/unexport", "w")) == NULL) + { + fprintf (stderr, "%s: Unable to open GPIO export interface\n", progName) ; + exit (1) ; + } + fprintf (fd, "%d\n", pin) ; + fclose (fd) ; + } +} + + +/* + * doReset: + * Reset the GPIO pins - as much as we can do + ********************************************************************************* + */ + +static void doReset (UNU char *progName) +{ + printf ("GPIO Reset is dangerous and has been removed from the gpio command.\n") ; + printf (" - Please write a shell-script to reset the GPIO pins into the state\n") ; + printf (" that you need them in for your applications.\n") ; +} + + +/* + * doMode: + * gpio mode pin mode ... + ********************************************************************************* + */ + +void doMode (int argc, char *argv []) +{ + int pin ; + char *mode ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s mode pin mode\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + mode = argv [3] ; + + /**/ if (strcasecmp (mode, "in") == 0) pinMode (pin, INPUT) ; + else if (strcasecmp (mode, "input") == 0) pinMode (pin, INPUT) ; + else if (strcasecmp (mode, "out") == 0) pinMode (pin, OUTPUT) ; + else if (strcasecmp (mode, "output") == 0) pinMode (pin, OUTPUT) ; + else if (strcasecmp (mode, "pwm") == 0) pinMode (pin, PWM_OUTPUT) ; + else if (strcasecmp (mode, "pwmTone") == 0) pinMode (pin, PWM_TONE_OUTPUT) ; + else if (strcasecmp (mode, "clock") == 0) pinMode (pin, GPIO_CLOCK) ; + else if (strcasecmp (mode, "up") == 0) pullUpDnControl (pin, PUD_UP) ; + else if (strcasecmp (mode, "down") == 0) pullUpDnControl (pin, PUD_DOWN) ; + else if (strcasecmp (mode, "tri") == 0) pullUpDnControl (pin, PUD_OFF) ; + else if (strcasecmp (mode, "off") == 0) pullUpDnControl (pin, PUD_OFF) ; + else if (strcasecmp (mode, "alt0") == 0) pinModeAlt (pin, 0b100) ; + else if (strcasecmp (mode, "alt1") == 0) pinModeAlt (pin, 0b101) ; + else if (strcasecmp (mode, "alt2") == 0) pinModeAlt (pin, 0b110) ; + else if (strcasecmp (mode, "alt3") == 0) pinModeAlt (pin, 0b111) ; + else if (strcasecmp (mode, "alt4") == 0) pinModeAlt (pin, 0b011) ; + else if (strcasecmp (mode, "alt5") == 0) pinModeAlt (pin, 0b010) ; + else + { + fprintf (stderr, "%s: Invalid mode: %s. Should be in/out/pwm/clock/up/down/tri\n", argv [1], mode) ; + exit (1) ; + } +} + + +/* + * doPadDrive: + * gpio drive group value + ********************************************************************************* + */ + +static void doPadDrive (int argc, char *argv []) +{ + int group, val ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s drive group value\n", argv [0]) ; + exit (1) ; + } + + group = atoi (argv [2]) ; + val = atoi (argv [3]) ; + + if ((group < 0) || (group > 2)) + { + fprintf (stderr, "%s: drive group not 0, 1 or 2: %d\n", argv [0], group) ; + exit (1) ; + } + + if ((val < 0) || (val > 7)) + { + fprintf (stderr, "%s: drive value not 0-7: %d\n", argv [0], val) ; + exit (1) ; + } + + setPadDrive (group, val) ; +} + + +/* + * doUsbP: + * Control USB Power - High (1.2A) or Low (600mA) + * gpio usbp high/low + ********************************************************************************* + */ + +static void doUsbP (int argc, char *argv []) +{ + int model, rev, mem, maker, overVolted ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s usbp high|low\n", argv [0]) ; + exit (1) ; + } + +// Make sure we're on a B+ + + piBoardId (&model, &rev, &mem, &maker, &overVolted) ; + + if (!((model == PI_MODEL_BP) || (model == PI_MODEL_2))) + { + fprintf (stderr, "USB power contol is applicable to B+ and v2 boards only.\n") ; + exit (1) ; + } + +// Make sure we start in BCM_GPIO mode + + wiringPiSetupGpio () ; + + if ((strcasecmp (argv [2], "high") == 0) || (strcasecmp (argv [2], "hi") == 0)) + { + digitalWrite (PI_USB_POWER_CONTROL, 1) ; + pinMode (PI_USB_POWER_CONTROL, OUTPUT) ; + printf ("Switched to HIGH current USB (1.2A)\n") ; + return ; + } + + if ((strcasecmp (argv [2], "low") == 0) || (strcasecmp (argv [2], "lo") == 0)) + { + digitalWrite (PI_USB_POWER_CONTROL, 0) ; + pinMode (PI_USB_POWER_CONTROL, OUTPUT) ; + printf ("Switched to LOW current USB (600mA)\n") ; + return ; + } + + fprintf (stderr, "Usage: %s usbp high|low\n", argv [0]) ; + exit (1) ; +} + + +/* + * doGbw: + * gpio gbw channel value + * Gertboard Write - To the Analog output + ********************************************************************************* + */ + +static void doGbw (int argc, char *argv []) +{ + int channel, value ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s gbw \n", argv [0]) ; + exit (1) ; + } + + channel = atoi (argv [2]) ; + value = atoi (argv [3]) ; + + if ((channel < 0) || (channel > 1)) + { + fprintf (stderr, "%s: gbw: Channel number must be 0 or 1\n", argv [0]) ; + exit (1) ; + } + + if ((value < 0) || (value > 255)) + { + fprintf (stderr, "%s: gbw: Value must be from 0 to 255\n", argv [0]) ; + exit (1) ; + } + + if (gertboardAnalogSetup (64) < 0) + { + fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ; + exit (1) ; + } + + analogWrite (64 + channel, value) ; +} + + +/* + * doGbr: + * gpio gbr channel + * From the analog input + ********************************************************************************* + */ + +static void doGbr (int argc, char *argv []) +{ + int channel ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s gbr \n", argv [0]) ; + exit (1) ; + } + + channel = atoi (argv [2]) ; + + if ((channel < 0) || (channel > 1)) + { + fprintf (stderr, "%s: gbr: Channel number must be 0 or 1\n", argv [0]) ; + exit (1) ; + } + + if (gertboardAnalogSetup (64) < 0) + { + fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ; + exit (1) ; + } + + printf ("%d\n", analogRead (64 + channel)) ; +} + + +/* + * doWrite: + * gpio write pin value + ********************************************************************************* + */ + +static void doWrite (int argc, char *argv []) +{ + int pin, val ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s write pin value\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + /**/ if ((strcasecmp (argv [3], "up") == 0) || (strcasecmp (argv [3], "on") == 0)) + val = 1 ; + else if ((strcasecmp (argv [3], "down") == 0) || (strcasecmp (argv [3], "off") == 0)) + val = 0 ; + else + val = atoi (argv [3]) ; + + /**/ if (val == 0) + digitalWrite (pin, LOW) ; + else + digitalWrite (pin, HIGH) ; +} + + +/* + * doAwriterite: + * gpio awrite pin value + ********************************************************************************* + */ + +static void doAwrite (int argc, char *argv []) +{ + int pin, val ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s awrite pin value\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + val = atoi (argv [3]) ; + + analogWrite (pin, val) ; +} + + +/* + * doWriteByte: + * gpio wb value + ********************************************************************************* + */ + +static void doWriteByte (int argc, char *argv []) +{ + int val ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s wb value\n", argv [0]) ; + exit (1) ; + } + + val = (int)strtol (argv [2], NULL, 0) ; + + digitalWriteByte (val) ; +} + + +/* + * doReadByte: + * gpio rbx|rbd value + ********************************************************************************* + */ + +static void doReadByte (int argc, char *argv [], int printHex) +{ + int val ; + + if (argc != 2) + { + fprintf (stderr, "Usage: %s rbx|rbd\n", argv [0]) ; + exit (1) ; + } + + val = digitalReadByte () ; + if (printHex) + printf ("%02X\n", val) ; + else + printf ("%d\n", val) ; +} + + +/* + * doRead: + * Read a pin and return the value + ********************************************************************************* + */ + +void doRead (int argc, char *argv []) +{ + int pin, val ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s read pin\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + val = digitalRead (pin) ; + + printf ("%s\n", val == 0 ? "0" : "1") ; +} + + +/* + * doAread: + * Read an analog pin and return the value + ********************************************************************************* + */ + +void doAread (int argc, char *argv []) +{ + if (argc != 3) + { + fprintf (stderr, "Usage: %s aread pin\n", argv [0]) ; + exit (1) ; + } + + printf ("%d\n", analogRead (atoi (argv [2]))) ; +} + + +/* + * doToggle: + * Toggle an IO pin + ********************************************************************************* + */ + +void doToggle (int argc, char *argv []) +{ + int pin ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s toggle pin\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + digitalWrite (pin, !digitalRead (pin)) ; +} + + +/* + * doBlink: + * Blink an IO pin + ********************************************************************************* + */ + +void doBlink (int argc, char *argv []) +{ + int pin ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s blink pin\n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + pinMode (pin, OUTPUT) ; + for (;;) + { + digitalWrite (pin, !digitalRead (pin)) ; + delay (500) ; + } + +} + + +/* + * doPwmTone: + * Output a tone in a PWM pin + ********************************************************************************* + */ + +void doPwmTone (int argc, char *argv []) +{ + int pin, freq ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s pwmTone \n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + freq = atoi (argv [3]) ; + + pwmToneWrite (pin, freq) ; +} + + +/* + * doClock: + * Output a clock on a pin + ********************************************************************************* + */ + +void doClock (int argc, char *argv []) +{ + int pin, freq ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s clock \n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + freq = atoi (argv [3]) ; + + gpioClockSet (pin, freq) ; +} + + +/* + * doPwm: + * Output a PWM value on a pin + ********************************************************************************* + */ + +void doPwm (int argc, char *argv []) +{ + int pin, val ; + + if (argc != 4) + { + fprintf (stderr, "Usage: %s pwm \n", argv [0]) ; + exit (1) ; + } + + pin = atoi (argv [2]) ; + + val = atoi (argv [3]) ; + + pwmWrite (pin, val) ; +} + + +/* + * doPwmMode: doPwmRange: doPwmClock: + * Change the PWM mode, range and clock divider values + ********************************************************************************* + */ + +static void doPwmMode (int mode) +{ + pwmSetMode (mode) ; +} + +static void doPwmRange (int argc, char *argv []) +{ + unsigned int range ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s pwmr \n", argv [0]) ; + exit (1) ; + } + + range = (unsigned int)strtoul (argv [2], NULL, 10) ; + + if (range == 0) + { + fprintf (stderr, "%s: range must be > 0\n", argv [0]) ; + exit (1) ; + } + + pwmSetRange (range) ; +} + +static void doPwmClock (int argc, char *argv []) +{ + unsigned int clock ; + + if (argc != 3) + { + fprintf (stderr, "Usage: %s pwmc \n", argv [0]) ; + exit (1) ; + } + + clock = (unsigned int)strtoul (argv [2], NULL, 10) ; + + if ((clock < 1) || (clock > 4095)) + { + fprintf (stderr, "%s: clock must be between 0 and 4096\n", argv [0]) ; + exit (1) ; + } + + pwmSetClock (clock) ; +} + + +/* + * doVersion: + * Handle the ever more complicated version command and print out + * some usefull information. + ********************************************************************************* + */ + +static void doVersion (char *argv []) +{ + int model, rev, mem, maker, warranty ; + struct stat statBuf ; + char name [80] ; + FILE *fd ; + + int vMaj, vMin ; + + wiringPiVersion (&vMaj, &vMin) ; + printf ("gpio version: %d.%d\n", vMaj, vMin) ; + printf ("Copyright (c) 2012-2017 Gordon Henderson\n") ; + printf ("This is free software with ABSOLUTELY NO WARRANTY.\n") ; + printf ("For details type: %s -warranty\n", argv [0]) ; + printf ("\n") ; + piBoardId (&model, &rev, &mem, &maker, &warranty) ; + + printf ("Raspberry Pi Details:\n") ; + printf (" Type: %s, Revision: %s, Memory: %dMB, Maker: %s %s\n", + piModelNames [model], piRevisionNames [rev], piMemorySize [mem], piMakerNames [maker], warranty ? "[Out of Warranty]" : "") ; + +// Check for device tree + + if (stat ("/proc/device-tree", &statBuf) == 0) // We're on a devtree system ... + printf (" * Device tree is enabled.\n") ; + + if (stat ("/proc/device-tree/model", &statBuf) == 0) // Output Kernel idea of board type + { + if ((fd = fopen ("/proc/device-tree/model", "r")) != NULL) + { + fgets (name, 80, fd) ; + fclose (fd) ; + printf (" *--> %s\n", name) ; + } + } + + if (stat ("/dev/gpiomem", &statBuf) == 0) // User level GPIO is GO + printf (" * This Raspberry Pi supports user-level GPIO access.\n") ; + else + printf (" * Root or sudo required for GPIO access.\n") ; +} + + +/* + * main: + * Start here + ********************************************************************************* + */ + +int main (int argc, char *argv []) +{ + int i ; + + if (getenv ("WIRINGPI_DEBUG") != NULL) + { + printf ("gpio: wiringPi debug mode enabled\n") ; + wiringPiDebug = TRUE ; + } + + if (argc == 1) + { + fprintf (stderr, "%s\n", usage) ; + return 1 ; + } + +// Help + + if (strcasecmp (argv [1], "-h") == 0) + { + printf ("%s: %s\n", argv [0], usage) ; + return 0 ; + } + +// Version & Warranty +// Wish I could remember why I have both -R and -V ... + + if ((strcmp (argv [1], "-R") == 0) || (strcmp (argv [1], "-V") == 0)) + { + printf ("%d\n", piGpioLayout ()) ; + return 0 ; + } + +// Version and information + + if (strcmp (argv [1], "-v") == 0) + { + doVersion (argv) ; + return 0 ; + } + + if (strcasecmp (argv [1], "-warranty") == 0) + { + printf ("gpio version: %s\n", VERSION) ; + printf ("Copyright (c) 2012-2017 Gordon Henderson\n") ; + printf ("\n") ; + printf (" This program is free software; you can redistribute it and/or modify\n") ; + printf (" it under the terms of the GNU Leser General Public License as published\n") ; + printf (" by the Free Software Foundation, either version 3 of the License, or\n") ; + printf (" (at your option) any later version.\n") ; + printf ("\n") ; + printf (" This program is distributed in the hope that it will be useful,\n") ; + printf (" but WITHOUT ANY WARRANTY; without even the implied warranty of\n") ; + printf (" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n") ; + printf (" GNU Lesser General Public License for more details.\n") ; + printf ("\n") ; + printf (" You should have received a copy of the GNU Lesser General Public License\n") ; + printf (" along with this program. If not, see .\n") ; + printf ("\n") ; + return 0 ; + } + + if (geteuid () != 0) + { + fprintf (stderr, "%s: Must be root to run. Program should be suid root. This is an error.\n", argv [0]) ; + return 1 ; + } + +// Initial test for /sys/class/gpio operations: + + /**/ if (strcasecmp (argv [1], "exports" ) == 0) { doExports (argc, argv) ; return 0 ; } + else if (strcasecmp (argv [1], "export" ) == 0) { doExport (argc, argv) ; return 0 ; } + else if (strcasecmp (argv [1], "edge" ) == 0) { doEdge (argc, argv) ; return 0 ; } + else if (strcasecmp (argv [1], "unexport" ) == 0) { doUnexport (argc, argv) ; return 0 ; } + else if (strcasecmp (argv [1], "unexportall") == 0) { doUnexportall (argv [0]) ; return 0 ; } + +// Check for load command: + + if (strcasecmp (argv [1], "load" ) == 0) { doLoad (argc, argv) ; return 0 ; } + if (strcasecmp (argv [1], "unload" ) == 0) { doUnLoad (argc, argv) ; return 0 ; } + +// Check for usb power command + + if (strcasecmp (argv [1], "usbp" ) == 0) { doUsbP (argc, argv) ; return 0 ; } + +// Gertboard commands + + if (strcasecmp (argv [1], "gbr" ) == 0) { doGbr (argc, argv) ; return 0 ; } + if (strcasecmp (argv [1], "gbw" ) == 0) { doGbw (argc, argv) ; return 0 ; } + +// Check for allreadall command, force Gpio mode + + if (strcasecmp (argv [1], "allreadall") == 0) + { + wiringPiSetupGpio () ; + doAllReadall () ; + return 0 ; + } + +// Check for -g argument + + /**/ if (strcasecmp (argv [1], "-g") == 0) + { + wiringPiSetupGpio () ; + + for (i = 2 ; i < argc ; ++i) + argv [i - 1] = argv [i] ; + --argc ; + wpMode = WPI_MODE_GPIO ; + } + +// Check for -1 argument + + else if (strcasecmp (argv [1], "-1") == 0) + { + wiringPiSetupPhys () ; + + for (i = 2 ; i < argc ; ++i) + argv [i - 1] = argv [i] ; + --argc ; + wpMode = WPI_MODE_PHYS ; + } + +// Check for -p argument for PiFace + + else if (strcasecmp (argv [1], "-p") == 0) + { + piFaceSetup (200) ; + + for (i = 2 ; i < argc ; ++i) + argv [i - 1] = argv [i] ; + --argc ; + wpMode = WPI_MODE_PIFACE ; + } + +// Check for -z argument so we don't actually initialise wiringPi + + else if (strcasecmp (argv [1], "-z") == 0) + { + for (i = 2 ; i < argc ; ++i) + argv [i - 1] = argv [i] ; + --argc ; + wpMode = WPI_MODE_UNINITIALISED ; + } + +// Default to wiringPi mode + + else + { + wiringPiSetup () ; + wpMode = WPI_MODE_PINS ; + } + +// Check for -x argument to load in a new extension +// -x extension:base:args +// Can load many modules, but unless daemon mode we can only send one +// command at a time. + + while (strcasecmp (argv [1], "-x") == 0) + { + if (argc < 3) + { + fprintf (stderr, "%s: -x missing extension command.\n", argv [0]) ; + exit (EXIT_FAILURE) ; + } + + if (!loadWPiExtension (argv [0], argv [2], TRUE)) + { + fprintf (stderr, "%s: Extension load failed: %s\n", argv [0], strerror (errno)) ; + exit (EXIT_FAILURE) ; + } + +// Shift args down by 2 + + for (i = 3 ; i < argc ; ++i) + argv [i - 2] = argv [i] ; + argc -= 2 ; + } + + if (argc <= 1) + { + fprintf (stderr, "%s: no command given\n", argv [0]) ; + exit (EXIT_FAILURE) ; + } + +// Core wiringPi functions + + /**/ if (strcasecmp (argv [1], "mode" ) == 0) doMode (argc, argv) ; + else if (strcasecmp (argv [1], "read" ) == 0) doRead (argc, argv) ; + else if (strcasecmp (argv [1], "write" ) == 0) doWrite (argc, argv) ; + else if (strcasecmp (argv [1], "pwm" ) == 0) doPwm (argc, argv) ; + else if (strcasecmp (argv [1], "awrite" ) == 0) doAwrite (argc, argv) ; + else if (strcasecmp (argv [1], "aread" ) == 0) doAread (argc, argv) ; + +// GPIO Nicies + + else if (strcasecmp (argv [1], "toggle" ) == 0) doToggle (argc, argv) ; + else if (strcasecmp (argv [1], "blink" ) == 0) doBlink (argc, argv) ; + +// Pi Specifics + + else if (strcasecmp (argv [1], "pwm-bal" ) == 0) doPwmMode (PWM_MODE_BAL) ; + else if (strcasecmp (argv [1], "pwm-ms" ) == 0) doPwmMode (PWM_MODE_MS) ; + else if (strcasecmp (argv [1], "pwmr" ) == 0) doPwmRange (argc, argv) ; + else if (strcasecmp (argv [1], "pwmc" ) == 0) doPwmClock (argc, argv) ; + else if (strcasecmp (argv [1], "pwmTone" ) == 0) doPwmTone (argc, argv) ; + else if (strcasecmp (argv [1], "drive" ) == 0) doPadDrive (argc, argv) ; + else if (strcasecmp (argv [1], "readall" ) == 0) doReadall () ; + else if (strcasecmp (argv [1], "nreadall" ) == 0) doReadall () ; + else if (strcasecmp (argv [1], "pins" ) == 0) doPins () ; + else if (strcasecmp (argv [1], "i2cdetect") == 0) doI2Cdetect (argc, argv) ; + else if (strcasecmp (argv [1], "i2cd" ) == 0) doI2Cdetect (argc, argv) ; + else if (strcasecmp (argv [1], "reset" ) == 0) doReset (argv [0]) ; + else if (strcasecmp (argv [1], "wb" ) == 0) doWriteByte (argc, argv) ; + else if (strcasecmp (argv [1], "rbx" ) == 0) doReadByte (argc, argv, TRUE) ; + else if (strcasecmp (argv [1], "rbd" ) == 0) doReadByte (argc, argv, FALSE) ; + else if (strcasecmp (argv [1], "clock" ) == 0) doClock (argc, argv) ; + else if (strcasecmp (argv [1], "wfi" ) == 0) doWfi (argc, argv) ; + else + { + fprintf (stderr, "%s: Unknown command: %s.\n", argv [0], argv [1]) ; + exit (EXIT_FAILURE) ; + } + return 0 ; +} diff --git a/gpio/readall_odroid.c b/gpio/readall_odroid.c new file mode 100755 index 0000000..1af675a --- /dev/null +++ b/gpio/readall_odroid.c @@ -0,0 +1,396 @@ +/* + * readall.c: + * The readall functions - getting a bit big, so split them out. + * Copyright (c) 2012-2017 Gordon Henderson + *********************************************************************** + * This file is part of wiringPi: + * https://projects.drogon.net/raspberry-pi/wiringpi/ + * + * wiringPi is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * wiringPi is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with wiringPi. If not, see . + *********************************************************************** + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +/*----------------------------------------------------------------------------*/ +#include + +extern int wpMode ; + +/*----------------------------------------------------------------------------*/ +#ifndef TRUE +# define TRUE (1==1) +# define FALSE (1==2) +#endif + +/*----------------------------------------------------------------------------*/ +/* + * doReadallExternal: + * A relatively crude way to read the pins on an external device. + * We don't know the input/output mode of pins, but we can tell + * if it's an analog pin or a digital one... + */ +/*----------------------------------------------------------------------------*/ +static void doReadallExternal (void) +{ + int pin ; + + printf ("+------+---------+--------+\n") ; + printf ("| Pin | Digital | Analog |\n") ; + printf ("+------+---------+--------+\n") ; + + for (pin = wiringPiNodes->pinBase ; pin <= wiringPiNodes->pinMax ; ++pin) + printf ("| %4d | %4d | %4d |\n", pin, digitalRead (pin), analogRead (pin)) ; + + printf ("+------+---------+--------+\n") ; +} + +/*----------------------------------------------------------------------------*/ +static const char *alts [] = +{ + "IN", "OUT", "ALT" +} ; + +/*----------------------------------------------------------------------------*/ +static const int physToWpi [64] = +{ + -1, // 0 + -1, -1, // 1, 2 + 8, -1, + 9, -1, + 7, 15, + -1, 16, + 0, 1, + 2, -1, + 3, 4, + -1, 5, + 12, -1, + 13, 6, + 14, 10, + -1, 11, // 25, 26 + 30, 31, // Actually I2C, but not used + 21, -1, + 22, 26, + 23, -1, + 24, 27, + 25, 28, + -1, 29, + -1, -1, + -1, -1, + -1, -1, + -1, -1, + -1, -1, + 17, 18, + 19, 20, + -1, -1, -1, -1, -1, -1, -1, -1, -1 +} ; + +/*----------------------------------------------------------------------------*/ +static const char *physNamesOdroidC1 [64] = +{ + NULL, + + " 3.3V", "5V ", + " SDA.1", "5V ", + " SCL.1", "GND(0V) ", + "GPIO. 83", "TxD1 ", + " GND(0V)", "RxD1 ", + "GPIO. 88", "GPIO. 87", + "GPIO.116", "GND(0V) ", + "GPIO.115", "GPIO.104", + " 3.3V", "GPIO.102", + " MOSI", "GND(0V) ", + " MISO", "GPIO.103", + " SCLK", "CE0 ", + " GND(0V)", "GPIO.118", + " SDA.2", "SCL.2 ", + "GPIO.101", "GND(0V) ", + "GPIO.100", "GPIO. 99", + "GPIO.108", "GND(0V) ", + "GPIO.97 ", "GPIO. 98", + " AIN.1", "1V8 ", + " GND(0V)", "AIN.0 ", + + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL, +} ; + +/*----------------------------------------------------------------------------*/ +static const char *physNamesOdroidC2_Rev2 [64] = +{ + NULL, + + " 3.3V", "5V ", + " SDA.1", "5V ", + " SCL.1", "GND(0V) ", + "GPIO.249", "TxD1 ", + " GND(0V)", "RxD1 ", + "GPIO.247", "GPIO.238", + "GPIO.239", "GND(0V) ", + "GPIO.237", "GPIO.236", + " 3.3V", "GPIO.233", + "GPIO.235", "GND(0V) ", + "GPIO.232", "GPIO.231", + "GPIO.230", "GPIO.229", + " GND(0V)", "GPIO.225", + " SDA.2", "SCL.2 ", + "GPIO.228", "GND(0V) ", + "GPIO.219", "GPIO.224", + "GPIO.234", "GND(0V) ", + "GPIO.214", "GPIO.218", + " AIN.1", "1V8 ", + " GND(0V)", "AIN.0 ", + + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL, +} ; + +/*----------------------------------------------------------------------------*/ +static const char *physNamesOdroidC2_Rev1 [64] = +{ + NULL, + + " 3.3V", "5V ", + " SDA.1", "5V ", + " SCL.1", "GND(0V) ", + "GPIO.214", "--------", + " GND(0V)", "--------", + "GPIO.219", "GPIO.218", + "GPIO.247", "GND(0V) ", + "--------", "GPIO.235", + " 3.3V", "GPIO.233", + "GPIO.238", "GND(0V) ", + "GPIO.237", "GPIO.234", + "GPIO.236", "GPIO.248", + " GND(0V)", "GPIO.249", + " SDA.2", "SCL.2 ", + "GPIO.232", "GND(0V) ", + "GPIO.231", "GPIO.230", + "GPIO.239", "GND(0V) ", + "GPIO.228", "GPIO.229", + " AIN.1", "1V8 ", + " GND(0V)", "AIN.0 ", + + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL, +} ; + +/*----------------------------------------------------------------------------*/ +static const char *physNamesOdroidXU3 [64] = +{ + NULL, + + " 3.3V", "5V ", + "I2C1.SDA", "5V ", + "I2C1.SCL", "GND(0V) ", + "GPIO. 18", "UART0.TX", + " GND(0V)", "UART0.RX", + "GPIO.174", "GPIO.173", + "GPIO. 21", "GND(0V) ", + "GPIO. 22", "GPIO. 19", + " 3.3V", "GPIO. 23", + " MOSI", "GND(0V) ", + " MISO", "GPIO. 24", + " SCLK", "CE0 ", + " GND(0V)", "GPIO. 25", + "I2C5.SDA", "I2C5.SCL", + "GPIO. 28", "GND(0V) ", + "GPIO. 30", "GPIO. 29", + "GPIO. 31", "GND(0V) ", + "POWER ON", "GPIO. 33", + " AIN.0", "1V8 ", + " GND(0V)", "AIN.3 ", + + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL, +} ; + +/*----------------------------------------------------------------------------*/ +static const char *physNamesOdroidN1 [64] = +{ + NULL, + + " 3.3V", "5V ", + "I2C1.SDA", "5V ", + "I2C1.SCL", "GND(0V) ", + "GPIO. 18", "UART0.TX", + " GND(0V)", "UART0.RX", + "GPIO.174", "GPIO.173", + "GPIO. 21", "GND(0V) ", + "GPIO. 22", "GPIO. 19", + " 3.3V", "GPIO. 23", + " MOSI", "GND(0V) ", + " MISO", "GPIO. 24", + " SCLK", "CE0 ", + " GND(0V)", "GPIO. 25", + "I2C5.SDA", "I2C5.SCL", + "GPIO. 28", "GND(0V) ", + "GPIO. 30", "GPIO. 29", + "GPIO. 31", "GND(0V) ", + "POWER ON", "GPIO. 33", + " AIN.0", "1V8 ", + " GND(0V)", "AIN.3 ", + + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, + NULL,NULL,NULL, +} ; + +/*----------------------------------------------------------------------------*/ +static void readallPhysOdroid (int model, int rev, int physPin, const char *physNames[]) +{ + int pin ; + + if ((physPinToGpio (physPin) == -1) && (physToWpi [physPin] == -1)) + printf (" | | ") ; + else if (physPinToGpio (physPin) != -1) + printf (" | %3d | %3d", physPinToGpio (physPin), physToWpi [physPin]); + else + printf (" | | %3d", physToWpi [physPin]); + + printf (" | %s", physNames [physPin]) ; + + if ((physToWpi [physPin] == -1) || (physPinToGpio (physPin) == -1)) + printf (" | | ") ; + else { + if (wpMode == WPI_MODE_GPIO) + pin = physPinToGpio (physPin); + else if (wpMode == WPI_MODE_PHYS) + pin = physPin ; + else + pin = physToWpi [physPin]; + + printf (" | %4s", alts [getAlt (pin)]) ; + printf (" | %d", digitalRead (pin)) ; + } + + // Pin numbers: + printf (" | %2d", physPin) ; + ++physPin ; + printf (" || %-2d", physPin) ; + + // Same, reversed + if ((physToWpi [physPin] == -1) || (physPinToGpio (physPin) == -1)) + printf (" | | ") ; + else { + if (wpMode == WPI_MODE_GPIO) + pin = physPinToGpio (physPin); + else if (wpMode == WPI_MODE_PHYS) + pin = physPin ; + else + pin = physToWpi [physPin]; + + printf (" | %d", digitalRead (pin)); + printf (" | %-4s", alts [getAlt (pin)]); + } + + printf (" | %-6s", physNames [physPin]); + + if ((physPinToGpio (physPin) == -1) && (physToWpi [physPin] == -1)) + printf (" | | ") ; + else if (physPinToGpio (physPin) != -1) + printf (" | %-3d | %-3d", physToWpi [physPin], physPinToGpio (physPin)); + else + printf (" | %-3d | ", physToWpi [physPin]); + + printf (" |\n") ; +} + +/*----------------------------------------------------------------------------*/ +void ReadallOdroid (int model, int rev, const char *physNames[]) +{ + int pin ; + + printf (" | GPIO | wPi | Name | Mode | V | Physical | V | Mode | Name | wPi | GPIO |\n") ; + printf (" +------+-----+----------+------+---+----++----+---+------+----------+-----+------+\n") ; + for (pin = 1 ; pin <= 40 ; pin += 2) + readallPhysOdroid (model, rev, pin, physNames) ; + printf (" +------+-----+----------+------+---+----++----+---+------+----------+-----+------+\n") ; +} + +/*----------------------------------------------------------------------------*/ +/* + * doReadall: + * Read all the GPIO pins + * We also want to use this to read the state of pins on an externally + * connected device, so we need to do some fiddling with the internal + * wiringPi node structures - since the gpio command can only use + * one external device at a time, we'll use that to our advantage... + */ +/*----------------------------------------------------------------------------*/ +void doReadall (void) +{ + int model, rev, mem, maker, overVolted; + const char (*physNames)[]; + + // External readall + if (wiringPiNodes != NULL) { + doReadallExternal (); + return ; + } + + piBoardId (&model, &rev, &mem, &maker, &overVolted) ; + + switch (model) { + case MODEL_ODROID_C1: + printf (" +------+-----+----------+------+- Model ODROID-C -+------+----------+-----+------+\n") ; + physNames = physNamesOdroidC1; + break; + case MODEL_ODROID_C2: + printf (" +------+-----+----------+------+ Model ODROID-C2 +------+----------+-----+------+\n") ; + if (rev == 1) + physNames = physNamesOdroidC2_Rev1; + else + physNames = physNamesOdroidC2_Rev2; + break; + case MODEL_ODROID_XU3: + printf (" +------+-----+----------+------ Model ODROID-XU3/4 ------+----------+-----+------+\n") ; + physNames = physNamesOdroidXU3; + break; + case MODEL_ODROID_N1: + physNames = physNamesOdroidN1; + break; + default: + printf ("Oops - unable to determine board type... model: %d\n", model) ; + return; + } + ReadallOdroid(model, rev, physNames); +} + +/*----------------------------------------------------------------------------*/ +/* + * doAllReadall: + * Force reading of all pins regardless of Pi model + */ +/*----------------------------------------------------------------------------*/ +void doAllReadall (void) +{ + doReadall(); +} + +/*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/