3 * Arduino compatable (ish) Wiring library for the Raspberry Pi
4 * Copyright (c) 2012 Gordon Henderson
5 * Additional code for pwmSetClock by Chris Hall <chris@kchall.plus.com>
7 * Thanks to code samples from Gert Jan van Loo and the
8 * BCM2835 ARM Peripherals manual, however it's missing
9 * the clock section /grr/mutter/
10 ***********************************************************************
11 * This file is part of wiringPi:
12 * https://projects.drogon.net/raspberry-pi/wiringpi/
14 * wiringPi is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License as
16 * published by the Free Software Foundation, either version 3 of the
17 * License, or (at your option) any later version.
19 * wiringPi is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with wiringPi.
26 * If not, see <http://www.gnu.org/licenses/>.
27 ***********************************************************************
33 // Added an abstraction layer to the main routines to save a tiny
34 // bit of run-time and make the clode a little cleaner (if a little
36 // Added waitForInterrupt code
40 // Added in support to use the /sys/class/gpio interface.
42 // Fixed a few more bugs to do with range-checking when in GPIO mode.
45 // Added c++ support for the .h file
46 // Added a new function to allow for using my "pin" numbers, or native
48 // Removed my busy-loop delay and replaced it with a call to delayMicroseconds
51 // Added in the 2 UART pins
52 // Change maxPins to numPins to more accurately reflect purpose
70 #include <sys/ioctl.h>
76 void (*pinMode) (int pin, int mode) ;
77 int (*getAlt) (int pin) ;
78 void (*pullUpDnControl) (int pin, int pud) ;
79 void (*digitalWrite) (int pin, int value) ;
80 void (*digitalWriteByte) (int value) ;
81 void (*pwmWrite) (int pin, int value) ;
82 void (*setPadDrive) (int group, int value) ;
83 int (*digitalRead) (int pin) ;
84 int (*waitForInterrupt) (int pin, int mS) ;
85 void (*pwmSetMode) (int mode) ;
86 void (*pwmSetRange) (unsigned int range) ;
87 void (*pwmSetClock) (int divisor) ;
97 #define BCM_PASSWORD 0x5A000000
100 // Port function select bits
102 #define FSEL_INPT 0b000
103 #define FSEL_OUTP 0b001
104 #define FSEL_ALT0 0b100
105 #define FSEL_ALT0 0b100
106 #define FSEL_ALT1 0b101
107 #define FSEL_ALT2 0b110
108 #define FSEL_ALT3 0b111
109 #define FSEL_ALT4 0b011
110 #define FSEL_ALT5 0b010
112 // Access from ARM Running Linux
113 // Take from Gert/Doms code. Some of this is not in the manual
114 // that I can find )-:
116 #define BCM2708_PERI_BASE 0x20000000
117 #define GPIO_PADS (BCM2708_PERI_BASE + 0x100000)
118 #define CLOCK_BASE (BCM2708_PERI_BASE + 0x101000)
119 #define GPIO_BASE (BCM2708_PERI_BASE + 0x200000)
120 #define GPIO_TIMER (BCM2708_PERI_BASE + 0x00B000)
121 #define GPIO_PWM (BCM2708_PERI_BASE + 0x20C000)
123 #define PAGE_SIZE (4*1024)
124 #define BLOCK_SIZE (4*1024)
128 #define PWM_CONTROL 0
135 #define PWMCLK_CNTL 40
136 #define PWMCLK_DIV 41
138 #define PWM1_MS_MODE 0x8000 // Run in MS mode
139 #define PWM1_USEFIFO 0x2000 // Data from FIFO
140 #define PWM1_REVPOLAR 0x1000 // Reverse polarity
141 #define PWM1_OFFSTATE 0x0800 // Ouput Off state
142 #define PWM1_REPEATFF 0x0400 // Repeat last value if FIFO empty
143 #define PWM1_SERIAL 0x0200 // Run in serial mode
144 #define PWM1_ENABLE 0x0100 // Channel Enable
146 #define PWM0_MS_MODE 0x0080 // Run in MS mode
147 #define PWM0_USEFIFO 0x0020 // Data from FIFO
148 #define PWM0_REVPOLAR 0x0010 // Reverse polarity
149 #define PWM0_OFFSTATE 0x0008 // Ouput Off state
150 #define PWM0_REPEATFF 0x0004 // Repeat last value if FIFO empty
151 #define PWM0_SERIAL 0x0002 // Run in serial mode
152 #define PWM0_ENABLE 0x0001 // Channel Enable
156 #define TIMER_LOAD (0x400 >> 2)
157 #define TIMER_VALUE (0x404 >> 2)
158 #define TIMER_CONTROL (0x408 >> 2)
159 #define TIMER_IRQ_CLR (0x40C >> 2)
160 #define TIMER_IRQ_RAW (0x410 >> 2)
161 #define TIMER_IRQ_MASK (0x414 >> 2)
162 #define TIMER_RELOAD (0x418 >> 2)
163 #define TIMER_PRE_DIV (0x41C >> 2)
164 #define TIMER_COUNTER (0x420 >> 2)
166 // Locals to hold pointers to the hardware
168 static volatile uint32_t *gpio ;
169 static volatile uint32_t *pwm ;
170 static volatile uint32_t *clk ;
171 static volatile uint32_t *pads ;
172 static volatile uint32_t *timer ;
173 static volatile uint32_t *timerIrqRaw ;
175 // Time for easy calculations
177 static uint64_t epochMilli, epochMicro ;
181 static int wiringPiMode = WPI_MODE_UNINITIALISED ;
185 int wiringPiDebug = FALSE ;
187 // The BCM2835 has 54 GPIO pins.
188 // BCM2835 data sheet, Page 90 onwards.
189 // There are 6 control registers, each control the functions of a block
191 // Each control register has 10 sets of 3 bits per GPIO pin:
193 // 000 = GPIO Pin X is an input
194 // 001 = GPIO Pin X is an output
195 // 100 = GPIO Pin X takes alternate function 0
196 // 101 = GPIO Pin X takes alternate function 1
197 // 110 = GPIO Pin X takes alternate function 2
198 // 111 = GPIO Pin X takes alternate function 3
199 // 011 = GPIO Pin X takes alternate function 4
200 // 010 = GPIO Pin X takes alternate function 5
202 // So the 3 bits for port X are:
203 // X / 10 + ((X % 10) * 3)
206 // Map a file descriptor from the /sys/class/gpio/gpioX/value
208 static int sysFds [64] ;
212 static void (*isrFunctions [64])(void) ;
215 // Doing it the Arduino way with lookup tables...
216 // Yes, it's probably more innefficient than all the bit-twidling, but it
217 // does tend to make it all a bit clearer. At least to me!
220 // Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
221 // Cope for 2 different board revieions here
223 static int *pinToGpio ;
225 static int pinToGpioR1 [64] =
227 17, 18, 21, 22, 23, 24, 25, 4, // From the Original Wiki - GPIO 0 through 7
228 0, 1, // I2C - SDA0, SCL0
229 8, 7, // SPI - CE1, CE0
230 10, 9, 11, // SPI - MOSI, MISO, SCLK
231 14, 15, // UART - Tx, Rx
235 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 31
236 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 47
237 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 63
240 static int pinToGpioR2 [64] =
242 17, 18, 27, 22, 23, 24, 25, 4, // From the Original Wiki - GPIO 0 through 7: wpi 0 - 7
243 2, 3, // I2C - SDA0, SCL0 wpi 8 - 9
244 8, 7, // SPI - CE1, CE0 wpi 10 - 11
245 10, 9, 11, // SPI - MOSI, MISO, SCLK wpi 12 - 14
246 14, 15, // UART - Tx, Rx wpi 15 - 16
247 28, 29, 30, 31, // New GPIOs 8 though 11 wpi 17 - 20
251 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 31
252 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 47
253 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 63
258 // Map a BCM_GPIO pin to it's control port. (GPFSEL 0-5)
260 static uint8_t gpioToGPFSEL [] =
262 0,0,0,0,0,0,0,0,0,0,
263 1,1,1,1,1,1,1,1,1,1,
264 2,2,2,2,2,2,2,2,2,2,
265 3,3,3,3,3,3,3,3,3,3,
266 4,4,4,4,4,4,4,4,4,4,
267 5,5,5,5,5,5,5,5,5,5,
272 // Define the shift up for the 3 bits per pin in each GPFSEL port
274 static uint8_t gpioToShift [] =
276 0,3,6,9,12,15,18,21,24,27,
277 0,3,6,9,12,15,18,21,24,27,
278 0,3,6,9,12,15,18,21,24,27,
279 0,3,6,9,12,15,18,21,24,27,
280 0,3,6,9,12,15,18,21,24,27,
285 // (Word) offset to the GPIO Set registers for each GPIO pin
287 static uint8_t gpioToGPSET [] =
289 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
290 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
295 // (Word) offset to the GPIO Clear registers for each GPIO pin
297 static uint8_t gpioToGPCLR [] =
299 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
300 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
305 // (Word) offset to the GPIO Input level registers for each GPIO pin
307 static uint8_t gpioToGPLEV [] =
309 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
310 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,
316 // (Word) offset to the Event Detect Status
318 static uint8_t gpioToEDS [] =
320 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
321 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
325 // (Word) offset to the Rising edgde ENable register
327 static uint8_t gpioToREN [] =
329 19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,
330 20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,
334 // (Word) offset to the Falling edgde ENable register
336 static uint8_t gpioToFEN [] =
338 22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,
339 23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,
345 // (Word) offset to the Pull Up Down Clock regsiter
349 static uint8_t gpioToPUDCLK [] =
351 38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,
352 39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,
357 // the ALT value to put a GPIO pin into PWM mode
359 static uint8_t gpioToPwmALT [] =
361 0, 0, 0, 0, 0, 0, 0, 0, // 0 -> 7
362 0, 0, 0, 0, FSEL_ALT0, FSEL_ALT0, 0, 0, // 8 -> 15
363 0, 0, FSEL_ALT5, FSEL_ALT5, 0, 0, 0, 0, // 16 -> 23
364 0, 0, 0, 0, 0, 0, 0, 0, // 24 -> 31
365 0, 0, 0, 0, 0, 0, 0, 0, // 32 -> 39
366 FSEL_ALT0, FSEL_ALT0, 0, 0, 0, FSEL_ALT0, 0, 0, // 40 -> 47
367 0, 0, 0, 0, 0, 0, 0, 0, // 48 -> 55
368 0, 0, 0, 0, 0, 0, 0, 0, // 56 -> 63
371 static uint8_t gpioToPwmPort [] =
373 0, 0, 0, 0, 0, 0, 0, 0, // 0 -> 7
374 0, 0, 0, 0, PWM0_DATA, PWM1_DATA, 0, 0, // 8 -> 15
375 0, 0, PWM0_DATA, PWM1_DATA, 0, 0, 0, 0, // 16 -> 23
376 0, 0, 0, 0, 0, 0, 0, 0, // 24 -> 31
377 0, 0, 0, 0, 0, 0, 0, 0, // 32 -> 39
378 PWM0_DATA, PWM1_DATA, 0, 0, 0, PWM1_DATA, 0, 0, // 40 -> 47
379 0, 0, 0, 0, 0, 0, 0, 0, // 48 -> 55
380 0, 0, 0, 0, 0, 0, 0, 0, // 56 -> 63
387 *********************************************************************************
393 * Translate a wiringPi Pin number to native GPIO pin number.
394 * (We don't use this here, prefering to just do the lookup directly,
395 * but it's been requested!)
396 *********************************************************************************
399 int wpiPinToGpio (int wpiPin)
401 return pinToGpio [wpiPin & 63] ;
407 * Return a number representing the hardware revision of the board.
408 * Revision is currently 1 or 2. -1 is returned on error.
410 * Much confusion here )-:
411 * Seems there are some boards with 0000 in them (mistake in manufacture)
412 * and some board with 0005 in them (another mistake in manufacture?)
413 * So the distinction between boards that I can see is:
419 * 0005 - Rev 2 (but error)
421 * 000f - Rev 2 + 512MB
423 * A small thorn is the olde style overvolting - that will add in
426 *********************************************************************************
429 static void piBoardRevOops (char *why)
431 fprintf (stderr, "piBoardRev: Unable to determine board revision from /proc/cpuinfo\n") ;
432 fprintf (stderr, " -> %s\n", why) ;
433 fprintf (stderr, " -> You may want to check:\n") ;
434 fprintf (stderr, " -> http://www.raspberrypi.org/phpBB3/viewtopic.php?p=184410#p184410\n") ;
435 exit (EXIT_FAILURE) ;
438 int piBoardRev (void)
443 static int boardRev = -1 ;
445 // No point checking twice...
450 if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
453 while (fgets (line, 120, cpuFd) != NULL)
454 if (strncmp (line, "Revision", 8) == 0)
460 piBoardRevOops ("No \"Revision\" line") ;
462 line [strlen (line) - 1] = 0 ; // Chomp LF
465 printf ("piboardRev: Revision string: %s\n", line) ;
467 for (c = line ; *c ; ++c)
472 piBoardRevOops ("No numeric revision string") ;
474 // If you have overvolted the Pi, then it appears that the revision
475 // has 100000 added to it!
479 printf ("piboardRev: This Pi has/is overvolted!\n") ;
481 lastChar = line [strlen (line) - 1] ;
484 printf ("piboardRev: lastChar is: '%c' (%d, 0x%02X)\n", lastChar, lastChar, lastChar) ;
486 /**/ if ((lastChar == '2') || (lastChar == '3'))
492 printf ("piBoardRev: Returning revision: %d\n", boardRev) ;
501 * Sets the mode of a pin to be input, output or PWM output
502 *********************************************************************************
505 void pinModeGpio (int pin, int mode)
507 // register int barrier ;
509 int fSel, shift, alt ;
513 fSel = gpioToGPFSEL [pin] ;
514 shift = gpioToShift [pin] ;
516 /**/ if (mode == INPUT)
517 *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
518 else if (mode == OUTPUT)
519 *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
520 else if (mode == PWM_OUTPUT)
522 if ((alt = gpioToPwmALT [pin]) == 0) // Not a PWM pin
525 // Set pin to PWM mode
527 *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
529 delayMicroseconds (110) ; // See comments in pwmSetClockWPi
530 *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
532 // Page 107 of the BCM Peripherals manual talks about the GPIO clocks,
533 // but I'm assuming (hoping!) that this applies to other clocks too.
535 *(pwm + PWM_CONTROL) = 0 ; // Stop PWM
537 *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ; // Stop PWM Clock
538 delayMicroseconds (110) ; // See comments in pwmSetClockWPi
540 while ((*(clk + PWMCLK_CNTL) & 0x80) != 0) // Wait for clock to be !BUSY
541 delayMicroseconds (1) ;
543 *(clk + PWMCLK_DIV) = BCM_PASSWORD | (32 << 12) ; // set pwm div to 32 (19.2/32 = 600KHz)
544 *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ; // enable clk
546 delayMicroseconds (110) ; // See comments in pwmSetClockWPi
548 // Default range register of 1024
550 *(pwm + PWM0_RANGE) = 1024 ; delayMicroseconds (10) ;
551 *(pwm + PWM1_RANGE) = 1024 ; delayMicroseconds (10) ;
552 *(pwm + PWM0_DATA) = 0 ; delayMicroseconds (10) ;
553 *(pwm + PWM1_DATA) = 0 ; delayMicroseconds (10) ;
555 // Enable PWMs in balanced mode (default)
557 *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
563 // When we change mode of any pin, we remove the pull up/downs
564 // Or we used to... Hm. Commented out now because for some wieird reason,
565 // it seems to block subsequent attempts to set the pull up/downs and I've
566 // not quite gotten to the bottom of why this happens
567 // The down-side is that the pull up/downs are rememberd in the SoC between
568 // power cycles, so it's going to be a good idea to explicitly set them in
571 // pullUpDnControl (pin, PUD_OFF) ;
575 void pinModeWPi (int pin, int mode)
577 pinModeGpio (pinToGpio [pin & 63], mode) ;
580 void pinModeSys (int pin, int mode)
588 * Returns the ALT bits for a given port. Only really of-use
589 * for the gpio readall command (I think)
590 *********************************************************************************
593 int getAltGpio (int pin)
595 int fSel, shift, alt ;
599 fSel = gpioToGPFSEL [pin] ;
600 shift = gpioToShift [pin] ;
602 alt = (*(gpio + fSel) >> shift) & 7 ;
607 int getAltWPi (int pin)
609 return getAltGpio (pinToGpio [pin & 63]) ;
612 int getAltSys (int pin)
620 * Allow the user to control some of the PWM functions
621 *********************************************************************************
624 void pwmSetModeWPi (int mode)
626 if (mode == PWM_MODE_MS)
627 *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
629 *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
632 void pwmSetModeSys (int mode)
638 void pwmSetRangeWPi (unsigned int range)
640 *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
641 *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
644 void pwmSetRangeSys (unsigned int range)
651 * Set/Change the PWM clock. Originally my code, but changed
652 * (for the better!) by Chris Hall, <chris@kchall.plus.com>
653 * after further study of the manual and testing with a 'scope
654 *********************************************************************************
657 void pwmSetClockWPi (int divisor)
659 uint32_t pwm_control ;
663 printf ("Setting to: %d. Current: 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
665 pwm_control = *(pwm + PWM_CONTROL) ; // preserve PWM_CONTROL
667 // We need to stop PWM prior to stopping PWM clock in MS mode otherwise BUSY
670 *(pwm + PWM_CONTROL) = 0 ; // Stop PWM
672 // Stop PWM clock before changing divisor. The delay after this does need to
673 // this big (95uS occasionally fails, 100uS OK), it's almost as though the BUSY
674 // flag is not working properly in balanced mode. Without the delay when DIV is
675 // adjusted the clock sometimes switches to very slow, once slow further DIV
676 // adjustments do nothing and it's difficult to get out of this mode.
678 *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x01 ; // Stop PWM Clock
679 delayMicroseconds (110) ; // prevents clock going sloooow
681 while ((*(clk + PWMCLK_CNTL) & 0x80) != 0) // Wait for clock to be !BUSY
682 delayMicroseconds (1) ;
684 *(clk + PWMCLK_DIV) = BCM_PASSWORD | (divisor << 12) ;
686 *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ; // Start PWM clock
687 *(pwm + PWM_CONTROL) = pwm_control ; // restore PWM_CONTROL
690 printf ("Set to: %d. Now : 0x%08X\n", divisor, *(clk + PWMCLK_DIV)) ;
693 void pwmSetClockSys (int divisor)
703 * Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
704 * Pin must already be in input mode with appropriate pull up/downs set.
705 *********************************************************************************
708 void pinEnableED01Pi (int pin)
710 pin = pinToGpio [pin & 63] ;
719 *********************************************************************************
722 void digitalWriteWPi (int pin, int value)
724 pin = pinToGpio [pin & 63] ;
727 *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
729 *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
732 void digitalWriteGpio (int pin, int value)
737 *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
739 *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
742 void digitalWriteSys (int pin, int value)
746 if (sysFds [pin] != -1)
749 write (sysFds [pin], "0\n", 2) ;
751 write (sysFds [pin], "1\n", 2) ;
758 * Write an 8-bit byte to the first 8 GPIO pins - try to do it as
760 * However it still needs 2 operations to set the bits, so any external
761 * hardware must not rely on seeing a change as there will be a change
762 * to set the outputs bits to zero, then another change to set the 1's
763 *********************************************************************************
766 void digitalWriteByteGpio (int value)
768 uint32_t pinSet = 0 ;
769 uint32_t pinClr = 0 ;
773 for (pin = 0 ; pin < 8 ; ++pin)
775 if ((value & mask) == 0)
776 pinClr |= (1 << pinToGpio [pin]) ;
778 pinSet |= (1 << pinToGpio [pin]) ;
783 *(gpio + gpioToGPCLR [0]) = pinClr ;
784 *(gpio + gpioToGPSET [0]) = pinSet ;
787 void digitalWriteByteSys (int value)
792 for (pin = 0 ; pin < 8 ; ++pin)
794 digitalWriteSys (pinToGpio [pin], value & mask) ;
802 * Set an output PWM value
803 *********************************************************************************
806 void pwmWriteGpio (int pin, int value)
811 port = gpioToPwmPort [pin] ;
813 *(pwm + port) = value ;
816 void pwmWriteWPi (int pin, int value)
818 pwmWriteGpio (pinToGpio [pin & 63], value) ;
821 void pwmWriteSys (int pin, int value)
829 * Set the PAD driver value
830 *********************************************************************************
833 void setPadDriveWPi (int group, int value)
837 if ((group < 0) || (group > 2))
840 wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
841 *(pads + group + 11) = wrVal ;
845 printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
846 printf ("Read : %08X\n", *(pads + group + 11)) ;
850 void setPadDriveGpio (int group, int value)
852 setPadDriveWPi (group, value) ;
855 void setPadDriveSys (int group, int value)
863 * Read the value of a given Pin, returning HIGH or LOW
864 *********************************************************************************
867 int digitalReadWPi (int pin)
869 pin = pinToGpio [pin & 63] ;
871 if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
877 int digitalReadGpio (int pin)
881 if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
887 int digitalReadSys (int pin)
893 if (sysFds [pin] == -1)
896 lseek (sysFds [pin], 0L, SEEK_SET) ;
897 read (sysFds [pin], &c, 1) ;
898 return (c == '0') ? 0 : 1 ;
904 * Control the internal pull-up/down resistors on a GPIO pin
905 * The Arduino only has pull-ups and these are enabled by writing 1
906 * to a port when in input mode - this paradigm doesn't quite apply
908 *********************************************************************************
911 void pullUpDnControlGpio (int pin, int pud)
916 *(gpio + GPPUD) = pud ; delayMicroseconds (5) ;
917 *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ; delayMicroseconds (5) ;
919 *(gpio + GPPUD) = 0 ; delayMicroseconds (5) ;
920 *(gpio + gpioToPUDCLK [pin]) = 0 ; delayMicroseconds (5) ;
923 void pullUpDnControlWPi (int pin, int pud)
925 pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
928 void pullUpDnControlSys (int pin, int pud)
936 * Wait for Interrupt on a GPIO pin.
937 * This is actually done via the /sys/class/gpio interface regardless of
938 * the wiringPi access mode in-use. Maybe sometime it might get a better
939 * way for a bit more efficiency.
940 *********************************************************************************
943 int waitForInterruptSys (int pin, int mS)
947 struct pollfd polls ;
949 if ((fd = sysFds [pin & 63]) == -1)
952 // Setup poll structure
955 polls.events = POLLPRI ; // Urgent data!
959 x = poll (&polls, 1, mS) ;
961 // Do a dummy read to clear the interrupt
962 // A one character read appars to be enough.
964 (void)read (fd, &c, 1) ;
969 int waitForInterruptWPi (int pin, int mS)
971 return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
974 int waitForInterruptGpio (int pin, int mS)
976 return waitForInterruptSys (pin, mS) ;
982 * This is a thread and gets started to wait for the interrupt we're
983 * hoping to catch. It will call the user-function when the interrupt
985 *********************************************************************************
988 static void *interruptHandler (void *arg)
990 int myPin = *(int *)arg ;
992 (void)piHiPri (55) ; // Only effective if we run as root
995 if (waitForInterruptSys (myPin, -1) > 0)
996 isrFunctions [myPin] () ;
1004 * Take the details and create an interrupt handler that will do a call-
1005 * back to the user supplied function.
1006 *********************************************************************************
1009 int wiringPiISR (int pin, int mode, void (*function)(void))
1011 pthread_t threadId ;
1021 if (wiringPiMode == WPI_MODE_UNINITIALISED)
1023 fprintf (stderr, "wiringPiISR: wiringPi has not been initialised. Unable to continue.\n") ;
1024 exit (EXIT_FAILURE) ;
1026 else if (wiringPiMode == WPI_MODE_PINS)
1027 pin = pinToGpio [pin] ;
1029 // Now export the pin and set the right edge
1030 // We're going to use the gpio program to do this, so it assumes
1031 // a full installation of wiringPi. It's a bit 'clunky', but it
1032 // is a way that will work when we're running in "Sys" mode, as
1033 // a non-root user. (without sudo)
1035 if (mode != INT_EDGE_SETUP)
1037 /**/ if (mode == INT_EDGE_FALLING)
1039 else if (mode == INT_EDGE_RISING)
1044 sprintf (pinS, "%d", pin) ;
1046 if ((pid = fork ()) < 0) // Fail
1049 if (pid == 0) // Child, exec
1051 execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
1052 return -1 ; // Failure ...
1054 else // Parent, wait
1058 // Now pre-open the /sys/class node - it may already be open if
1059 // we are in Sys mode, but this will do no harm.
1061 sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1062 if ((sysFds [pin] = open (fName, O_RDWR)) < 0)
1065 // Clear any initial pending interrupt
1067 ioctl (sysFds [pin], FIONREAD, &count) ;
1068 for (i = 0 ; i < count ; ++i)
1069 read (sysFds [pin], &c, 1) ;
1071 isrFunctions [pin] = function ;
1073 pthread_create (&threadId, NULL, interruptHandler, &pin) ;
1083 * Initialise our start-of-time variable to be the current unix
1084 * time in milliseconds.
1085 *********************************************************************************
1088 static void initialiseEpoch (void)
1092 gettimeofday (&tv, NULL) ;
1093 epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
1094 epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
1099 * Wait for some number of milli seconds
1100 *********************************************************************************
1103 void delay (unsigned int howLong)
1105 struct timespec sleeper, dummy ;
1107 sleeper.tv_sec = (time_t)(howLong / 1000) ;
1108 sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
1110 nanosleep (&sleeper, &dummy) ;
1115 * delayMicroseconds:
1116 * This is somewhat intersting. It seems that on the Pi, a single call
1117 * to nanosleep takes some 80 to 130 microseconds anyway, so while
1118 * obeying the standards (may take longer), it's not always what we
1121 * So what I'll do now is if the delay is less than 100uS we'll do it
1122 * in a hard loop, watching a built-in counter on the ARM chip. This is
1123 * somewhat sub-optimal in that it uses 100% CPU, something not an issue
1124 * in a microcontroller, but under a multi-tasking, multi-user OS, it's
1125 * wastefull, however we've no real choice )-:
1127 * Plan B: It seems all might not be well with that plan, so changing it
1128 * to use gettimeofday () and poll on that instead...
1129 *********************************************************************************
1132 void delayMicrosecondsHard (unsigned int howLong)
1134 struct timeval tNow, tLong, tEnd ;
1136 gettimeofday (&tNow, NULL) ;
1137 tLong.tv_sec = howLong / 1000000 ;
1138 tLong.tv_usec = howLong % 1000000 ;
1139 timeradd (&tNow, &tLong, &tEnd) ;
1141 while (timercmp (&tNow, &tEnd, <))
1142 gettimeofday (&tNow, NULL) ;
1145 void delayMicroseconds (unsigned int howLong)
1147 struct timespec sleeper ;
1149 /**/ if (howLong == 0)
1151 else if (howLong < 100)
1152 delayMicrosecondsHard (howLong) ;
1155 sleeper.tv_sec = 0 ;
1156 sleeper.tv_nsec = (long)(howLong * 1000) ;
1157 nanosleep (&sleeper, NULL) ;
1164 * Return a number of milliseconds as an unsigned int.
1165 *********************************************************************************
1168 unsigned int millis (void)
1173 gettimeofday (&tv, NULL) ;
1174 now = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
1176 return (uint32_t)(now - epochMilli) ;
1182 * Return a number of microseconds as an unsigned int.
1183 *********************************************************************************
1186 unsigned int micros (void)
1191 gettimeofday (&tv, NULL) ;
1192 now = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
1194 return (uint32_t)(now - epochMicro) ;
1200 * Must be called once at the start of your program execution.
1202 * Default setup: Initialises the system into wiringPi Pin mode and uses the
1203 * memory mapped hardware directly.
1204 *********************************************************************************
1207 int wiringPiSetup (void)
1212 if (geteuid () != 0)
1214 fprintf (stderr, "wiringPi:\n Must be root to call wiringPiSetup().\n (Did you forget sudo?)\n") ;
1215 exit (EXIT_FAILURE) ;
1218 if (getenv ("WIRINGPI_DEBUG") != NULL)
1220 printf ("wiringPi: Debug mode enabled\n") ;
1221 wiringPiDebug = TRUE ;
1225 printf ("wiringPi: wiringPiSetup called\n") ;
1227 pinMode = pinModeWPi ;
1228 getAlt = getAltWPi ;
1229 pullUpDnControl = pullUpDnControlWPi ;
1230 digitalWrite = digitalWriteWPi ;
1231 digitalWriteByte = digitalWriteByteGpio ; // Same code
1232 pwmWrite = pwmWriteWPi ;
1233 setPadDrive = setPadDriveWPi ;
1234 digitalRead = digitalReadWPi ;
1235 waitForInterrupt = waitForInterruptWPi ;
1236 pwmSetMode = pwmSetModeWPi ;
1237 pwmSetRange = pwmSetRangeWPi ;
1238 pwmSetClock = pwmSetClockWPi ;
1240 boardRev = piBoardRev () ;
1243 pinToGpio = pinToGpioR1 ;
1245 pinToGpio = pinToGpioR2 ;
1247 // Open the master /dev/memory device
1249 if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
1254 fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
1262 gpio = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_BASE) ;
1263 if ((int32_t)gpio == -1)
1268 fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
1276 pwm = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PWM) ;
1277 if ((int32_t)pwm == -1)
1282 fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
1288 // Clock control (needed for PWM)
1290 clk = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, CLOCK_BASE) ;
1291 if ((int32_t)clk == -1)
1296 fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
1304 pads = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_PADS) ;
1305 if ((int32_t)pads == -1)
1310 fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
1318 timer = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, GPIO_TIMER) ;
1319 if ((int32_t)timer == -1)
1324 fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
1330 // Set the timer to free-running, 1MHz.
1331 // 0xF9 is 249, the timer divide is base clock / (divide+1)
1332 // so base clock is 250MHz / 250 = 1MHz.
1334 *(timer + TIMER_CONTROL) = 0x0000280 ;
1335 *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
1336 timerIrqRaw = timer + TIMER_IRQ_RAW ;
1338 initialiseEpoch () ;
1340 wiringPiMode = WPI_MODE_PINS ;
1347 * wiringPiSetupGpio:
1348 * Must be called once at the start of your program execution.
1350 * GPIO setup: Initialises the system into GPIO Pin mode and uses the
1351 * memory mapped hardware directly.
1352 *********************************************************************************
1355 int wiringPiSetupGpio (void)
1359 if (geteuid () != 0)
1361 fprintf (stderr, "Must be root to call wiringPiSetupGpio(). (Did you forget sudo?)\n") ;
1362 exit (EXIT_FAILURE) ;
1365 if ((x = wiringPiSetup ()) < 0)
1369 printf ("wiringPi: wiringPiSetupGpio called\n") ;
1371 pinMode = pinModeGpio ;
1372 getAlt = getAltGpio ;
1373 pullUpDnControl = pullUpDnControlGpio ;
1374 digitalWrite = digitalWriteGpio ;
1375 digitalWriteByte = digitalWriteByteGpio ;
1376 pwmWrite = pwmWriteGpio ;
1377 setPadDrive = setPadDriveGpio ;
1378 digitalRead = digitalReadGpio ;
1379 waitForInterrupt = waitForInterruptGpio ;
1380 pwmSetMode = pwmSetModeWPi ;
1381 pwmSetRange = pwmSetRangeWPi ;
1382 pwmSetClock = pwmSetClockWPi ;
1384 wiringPiMode = WPI_MODE_GPIO ;
1392 * Must be called once at the start of your program execution.
1394 * Initialisation (again), however this time we are using the /sys/class/gpio
1395 * interface to the GPIO systems - slightly slower, but always usable as
1396 * a non-root user, assuming the devices are already exported and setup correctly.
1399 int wiringPiSetupSys (void)
1405 if (getenv ("WIRINGPI_DEBUG") != NULL)
1406 wiringPiDebug = TRUE ;
1409 printf ("wiringPi: wiringPiSetupSys called\n") ;
1411 pinMode = pinModeSys ;
1412 getAlt = getAltSys ;
1413 pullUpDnControl = pullUpDnControlSys ;
1414 digitalWrite = digitalWriteSys ;
1415 digitalWriteByte = digitalWriteByteSys ;
1416 pwmWrite = pwmWriteSys ;
1417 setPadDrive = setPadDriveSys ;
1418 digitalRead = digitalReadSys ;
1419 waitForInterrupt = waitForInterruptSys ;
1420 pwmSetMode = pwmSetModeSys ;
1421 pwmSetRange = pwmSetRangeSys ;
1422 pwmSetClock = pwmSetClockSys ;
1424 boardRev = piBoardRev () ;
1427 pinToGpio = pinToGpioR1 ;
1429 pinToGpio = pinToGpioR2 ;
1431 // Open and scan the directory, looking for exported GPIOs, and pre-open
1432 // the 'value' interface to speed things up for later
1434 for (pin = 0 ; pin < 64 ; ++pin)
1436 sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1437 sysFds [pin] = open (fName, O_RDWR) ;
1440 initialiseEpoch () ;
1442 wiringPiMode = WPI_MODE_GPIO_SYS ;