3 * Arduino compatable (ish) Wiring library for the Raspberry Pi
4 * Copyright (c) 2012 Gordon Henderson
6 * Thanks to code samples from Gert Jan van Loo and the
7 * BCM2835 ARM Peripherals manual, however it's missing
8 * the clock section /grr/mutter/
9 ***********************************************************************
10 * This file is part of wiringPi:
11 * https://projects.drogon.net/raspberry-pi/wiringpi/
13 * wiringPi is free software: you can redistribute it and/or modify
14 * it under the terms of the GNU Lesser General Public License as
15 * published by the Free Software Foundation, either version 3 of the
16 * License, or (at your option) any later version.
18 * wiringPi is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License for more details.
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with wiringPi.
25 * If not, see <http://www.gnu.org/licenses/>.
26 ***********************************************************************
32 // Added an abstraction layer to the main routines to save a tiny
33 // bit of run-time and make the clode a little cleaner (if a little
35 // Added waitForInterrupt code
39 // Added in support to use the /sys/class/gpio interface.
41 // Fixed a few more bugs to do with range-checking when in GPIO mode.
44 // Added c++ support for the .h file
45 // Added a new function to allow for using my "pin" numbers, or native
47 // Removed my busy-loop delay and replaced it with a call to delayMicroseconds
50 // Added in the 2 UART pins
51 // Change maxPins to numPins to more accurately reflect purpose
53 // Pad drive current fiddling
67 #include <sys/types.h>
74 void (*pinMode) (int pin, int mode) ;
75 void (*pullUpDnControl) (int pin, int pud) ;
76 void (*digitalWrite) (int pin, int value) ;
77 void (*pwmWrite) (int pin, int value) ;
78 void (*setPadDrive) (int group, int value) ;
79 int (*digitalRead) (int pin) ;
80 int (*waitForInterrupt) (int pin, int mS) ;
81 void (*delayMicroseconds) (unsigned int howLong) ;
82 void (*pwmSetMode) (int mode) ;
83 void (*pwmSetRange) (unsigned int range) ;
93 #define BCM_PASSWORD 0x5A000000
96 // Port function select bits
98 #define FSEL_INPT 0b000
99 #define FSEL_OUTP 0b001
100 #define FSEL_ALT0 0b100
101 #define FSEL_ALT0 0b100
102 #define FSEL_ALT1 0b101
103 #define FSEL_ALT2 0b110
104 #define FSEL_ALT3 0b111
105 #define FSEL_ALT4 0b011
106 #define FSEL_ALT5 0b010
108 // Access from ARM Running Linux
109 // Take from Gert/Doms code. Some of this is not in the manual
110 // that I can find )-:
112 #define BCM2708_PERI_BASE 0x20000000
113 #define GPIO_PADS (BCM2708_PERI_BASE + 0x100000)
114 #define CLOCK_BASE (BCM2708_PERI_BASE + 0x101000)
115 #define GPIO_BASE (BCM2708_PERI_BASE + 0x200000)
116 #define GPIO_TIMER (BCM2708_PERI_BASE + 0x00B000)
117 #define GPIO_PWM (BCM2708_PERI_BASE + 0x20C000)
119 #define PAGE_SIZE (4*1024)
120 #define BLOCK_SIZE (4*1024)
124 #define PWM_CONTROL 0
131 #define PWMCLK_CNTL 40
132 #define PWMCLK_DIV 41
134 #define PWM1_MS_MODE 0x8000 // Run in MS mode
135 #define PWM1_USEFIFO 0x2000 // Data from FIFO
136 #define PWM1_REVPOLAR 0x1000 // Reverse polarity
137 #define PWM1_OFFSTATE 0x0800 // Ouput Off state
138 #define PWM1_REPEATFF 0x0400 // Repeat last value if FIFO empty
139 #define PWM1_SERIAL 0x0200 // Run in serial mode
140 #define PWM1_ENABLE 0x0100 // Channel Enable
142 #define PWM0_MS_MODE 0x0080 // Run in MS mode
143 #define PWM0_USEFIFO 0x0020 // Data from FIFO
144 #define PWM0_REVPOLAR 0x0010 // Reverse polarity
145 #define PWM0_OFFSTATE 0x0008 // Ouput Off state
146 #define PWM0_REPEATFF 0x0004 // Repeat last value if FIFO empty
147 #define PWM0_SERIAL 0x0002 // Run in serial mode
148 #define PWM0_ENABLE 0x0001 // Channel Enable
152 #define TIMER_LOAD (0x400 >> 2)
153 #define TIMER_VALUE (0x404 >> 2)
154 #define TIMER_CONTROL (0x408 >> 2)
155 #define TIMER_IRQ_CLR (0x40C >> 2)
156 #define TIMER_IRQ_RAW (0x410 >> 2)
157 #define TIMER_IRQ_MASK (0x414 >> 2)
158 #define TIMER_RELOAD (0x418 >> 2)
159 #define TIMER_PRE_DIV (0x41C >> 2)
160 #define TIMER_COUNTER (0x420 >> 2)
162 // Locals to hold pointers to the hardware
164 static volatile uint32_t *gpio ;
165 static volatile uint32_t *pwm ;
166 static volatile uint32_t *clk ;
167 static volatile uint32_t *pads ;
168 static volatile uint32_t *timer ;
170 static volatile uint32_t *timerIrqRaw ;
172 // The BCM2835 has 54 GPIO pins.
173 // BCM2835 data sheet, Page 90 onwards.
174 // There are 6 control registers, each control the functions of a block
176 // Each control register has 10 sets of 3 bits per GPIO pin:
178 // 000 = GPIO Pin X is an input
179 // 001 = GPIO Pin X is an output
180 // 100 = GPIO Pin X takes alternate function 0
181 // 101 = GPIO Pin X takes alternate function 1
182 // 110 = GPIO Pin X takes alternate function 2
183 // 111 = GPIO Pin X takes alternate function 3
184 // 011 = GPIO Pin X takes alternate function 4
185 // 010 = GPIO Pin X takes alternate function 5
187 // So the 3 bits for port X are:
188 // X / 10 + ((X % 10) * 3)
191 // Map a file descriptor from the /sys/class/gpio/gpioX/value
193 static int sysFds [64] ;
195 // Doing it the Arduino way with lookup tables...
196 // Yes, it's probably more innefficient than all the bit-twidling, but it
197 // does tend to make it all a bit clearer. At least to me!
200 // Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
202 static int pinToGpio [64] =
204 17, 18, 21, 22, 23, 24, 25, 4, // From the Original Wiki - GPIO 0 through 7
205 0, 1, // I2C - SDA0, SCL0
206 8, 7, // SPI - CE1, CE0
207 10, 9, 11, // SPI - MOSI, MISO, SCLK
208 14, 15, // UART - Tx, Rx
212 -1, -1, -1,-1,-1,-1,-1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 31
213 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 47
214 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 63
218 // Map a BCM_GPIO pin to it's control port. (GPFSEL 0-5)
220 static uint8_t gpioToGPFSEL [] =
222 0,0,0,0,0,0,0,0,0,0,
223 1,1,1,1,1,1,1,1,1,1,
224 2,2,2,2,2,2,2,2,2,2,
225 3,3,3,3,3,3,3,3,3,3,
226 4,4,4,4,4,4,4,4,4,4,
227 5,5,5,5,5,5,5,5,5,5,
231 // Define the shift up for the 3 bits per pin in each GPFSEL port
233 static uint8_t gpioToShift [] =
235 0,3,6,9,12,15,18,21,24,27,
236 0,3,6,9,12,15,18,21,24,27,
237 0,3,6,9,12,15,18,21,24,27,
238 0,3,6,9,12,15,18,21,24,27,
239 0,3,6,9,12,15,18,21,24,27,
243 // (Word) offset to the GPIO Set registers for each GPIO pin
245 static uint8_t gpioToGPSET [] =
247 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,
248 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,
252 // (Word) offset to the GPIO Clear registers for each GPIO pin
254 static uint8_t gpioToGPCLR [] =
256 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,
257 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,
261 // (Word) offset to the GPIO Input level registers for each GPIO pin
263 static uint8_t gpioToGPLEV [] =
265 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,
266 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,
271 // (Word) offset to the Event Detect Status
273 static uint8_t gpioToEDS [] =
275 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,
276 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,
280 // (Word) offset to the Rising edgde ENable register
282 static uint8_t gpioToREN [] =
284 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,
285 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,
289 // (Word) offset to the Falling edgde ENable register
291 static uint8_t gpioToFEN [] =
293 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,
294 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,
299 // (Word) offset to the Pull Up Down Clock regsiter
303 static uint8_t gpioToPUDCLK [] =
305 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,
306 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,
310 // the ALT value to put a GPIO pin into PWM mode
312 static uint8_t gpioToPwmALT [] =
314 0, 0, 0, 0, 0, 0, 0, 0, // 0 -> 7
315 0, 0, 0, 0, FSEL_ALT0, FSEL_ALT0, 0, 0, // 8 -> 15
316 0, 0, FSEL_ALT5, FSEL_ALT5, 0, 0, 0, 0, // 16 -> 23
317 0, 0, 0, 0, 0, 0, 0, 0, // 24 -> 31
318 0, 0, 0, 0, 0, 0, 0, 0, // 32 -> 39
319 FSEL_ALT0, FSEL_ALT0, 0, 0, 0, FSEL_ALT0, 0, 0, // 40 -> 47
320 0, 0, 0, 0, 0, 0, 0, 0, // 48 -> 55
321 0, 0, 0, 0, 0, 0, 0, 0, // 56 -> 63
324 static uint8_t gpioToPwmPort [] =
326 0, 0, 0, 0, 0, 0, 0, 0, // 0 -> 7
327 0, 0, 0, 0, PWM0_DATA, PWM1_DATA, 0, 0, // 8 -> 15
328 0, 0, PWM0_DATA, PWM1_DATA, 0, 0, 0, 0, // 16 -> 23
329 0, 0, 0, 0, 0, 0, 0, 0, // 24 -> 31
330 0, 0, 0, 0, 0, 0, 0, 0, // 32 -> 39
331 PWM0_DATA, PWM1_DATA, 0, 0, 0, PWM1_DATA, 0, 0, // 40 -> 47
332 0, 0, 0, 0, 0, 0, 0, 0, // 48 -> 55
333 0, 0, 0, 0, 0, 0, 0, 0, // 56 -> 63
338 // Time for easy calculations
340 static unsigned long long epoch ;
342 //////////////////////////////////////////////////////////////////////////////////
347 * Sets the mode of a pin to be input, output or PWM output
348 *********************************************************************************
351 void pinModeGpio (int pin, int mode)
353 static int pwmRunning = FALSE ;
354 int fSel, shift, alt ;
358 fSel = gpioToGPFSEL [pin] ;
359 shift = gpioToShift [pin] ;
361 /**/ if (mode == INPUT)
362 *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
363 else if (mode == OUTPUT)
364 *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
365 else if (mode == PWM_OUTPUT)
367 if ((alt = gpioToPwmALT [pin]) == 0) // Not a PWM pin
370 // Set pin to PWM mode
372 *(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (alt << shift) ;
374 // We didn't initialise the PWM hardware at setup time - because it's possible that
375 // something else is using the PWM - e.g. the Audio systems! So if we use PWM
376 // here, then we're assuming that nothing else is, otherwise things are going
377 // to sound a bit funny...
382 *(pwm + PWM_CONTROL) = 0 ; // Stop PWM
383 delayMicroseconds (10) ;
386 *(clk + PWMCLK_DIV) = BCM_PASSWORD | (32<<12) ; // set pwm div to 32 (19.2/32 = 600KHz)
387 *(clk + PWMCLK_CNTL) = BCM_PASSWORD | 0x11 ; // Source=osc and enable
389 delayMicroseconds (10) ;
391 *(pwm + PWM0_RANGE) = 0x400 ; delayMicroseconds (10) ;
392 *(pwm + PWM1_RANGE) = 0x400 ; delayMicroseconds (10) ;
396 *(pwm + PWM0_DATA) = 512 ;
397 *(pwm + PWM1_DATA) = 512 ;
399 // Balanced mode (default)
401 *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
408 // When we change mode of any pin, we remove the pull up/downs
409 // Or we used to... Hm. Commented out now because for some wieird reason,
410 // it seems to block subsequent attempts to set the pull up/downs and I've
411 // not quite gotten to the bottom of why this happens
412 // The down-side is that the pull up/downs are rememberd in the SoC between
413 // power cycles, so it's going to be a good idea to explicitly set them in
416 // pullUpDnControl (pin, PUD_OFF) ;
420 void pinModeWPi (int pin, int mode)
422 pinModeGpio (pinToGpio [pin & 63], mode) ;
425 void pinModeSys (int pin, int mode)
433 * Allow the user to control some of the PWM functions
434 *********************************************************************************
437 void pwmSetModeWPi (int mode)
439 if (mode == PWM_MODE_MS)
440 *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE | PWM0_MS_MODE | PWM1_MS_MODE ;
442 *(pwm + PWM_CONTROL) = PWM0_ENABLE | PWM1_ENABLE ;
445 void pwmSetModeSys (int mode)
451 void pwmSetRangeWPi (unsigned int range)
453 *(pwm + PWM0_RANGE) = range ; delayMicroseconds (10) ;
454 *(pwm + PWM1_RANGE) = range ; delayMicroseconds (10) ;
457 void pwmSetRangeSys (unsigned int range)
467 * Enables edge-detect mode on a pin - from a 0 to a 1 or 1 to 0
468 * Pin must already be in input mode with appropriate pull up/downs set.
469 *********************************************************************************
472 void pinEnableED01Pi (int pin)
474 pin = pinToGpio [pin & 63] ;
483 *********************************************************************************
486 void digitalWriteWPi (int pin, int value)
488 pin = pinToGpio [pin & 63] ;
491 *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
493 *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
496 void digitalWriteGpio (int pin, int value)
501 *(gpio + gpioToGPCLR [pin]) = 1 << (pin & 31) ;
503 *(gpio + gpioToGPSET [pin]) = 1 << (pin & 31) ;
506 void digitalWriteSys (int pin, int value)
510 if (sysFds [pin] != -1)
513 write (sysFds [pin], "0\n", 2) ;
515 write (sysFds [pin], "1\n", 2) ;
522 * Set an output PWM value
523 *********************************************************************************
526 void pwmWriteGpio (int pin, int value)
531 port = gpioToPwmPort [pin] ;
533 *(pwm + port) = value ;
536 void pwmWriteWPi (int pin, int value)
538 pwmWriteGpio (pinToGpio [pin & 63], value) ;
541 void pwmWriteSys (int pin, int value)
549 * Set the PAD driver value
550 *********************************************************************************
553 void setPadDriveWPi (int group, int value)
557 if ((group < 0) || (group > 2))
560 wrVal = BCM_PASSWORD | 0x18 | (value & 7) ;
561 *(pads + group + 11) = wrVal ;
564 printf ("setPadDrive: Group: %d, value: %d (%08X)\n", group, value, wrVal) ;
565 printf ("Read : %08X\n", *(pads + group + 11)) ;
569 void setPadDriveGpio (int group, int value)
571 setPadDriveWPi (group, value) ;
574 void setPadDriveSys (int group, int value)
582 * Read the value of a given Pin, returning HIGH or LOW
583 *********************************************************************************
586 int digitalReadWPi (int pin)
588 pin = pinToGpio [pin & 63] ;
590 if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
596 int digitalReadGpio (int pin)
600 if ((*(gpio + gpioToGPLEV [pin]) & (1 << (pin & 31))) != 0)
606 int digitalReadSys (int pin)
612 if (sysFds [pin] == -1)
615 lseek (sysFds [pin], 0L, SEEK_SET) ;
616 read (sysFds [pin], &c, 1) ;
617 return (c == '0') ? 0 : 1 ;
623 * Control the internal pull-up/down resistors on a GPIO pin
624 * The Arduino only has pull-ups and these are enabled by writing 1
625 * to a port when in input mode - this paradigm doesn't quite apply
627 *********************************************************************************
630 void pullUpDnControlGpio (int pin, int pud)
635 *(gpio + GPPUD) = pud ; delayMicroseconds (5) ;
636 *(gpio + gpioToPUDCLK [pin]) = 1 << (pin & 31) ; delayMicroseconds (5) ;
638 *(gpio + GPPUD) = 0 ; delayMicroseconds (5) ;
639 *(gpio + gpioToPUDCLK [pin]) = 0 ; delayMicroseconds (5) ;
642 void pullUpDnControlWPi (int pin, int pud)
644 pullUpDnControlGpio (pinToGpio [pin & 63], pud) ;
647 void pullUpDnControlSys (int pin, int pud)
655 * Wait for Interrupt on a GPIO pin.
656 * This is actually done via the /sys/class/gpio interface regardless of
657 * the wiringPi access mode in-use. Maybe sometime it might get a better
658 * way for a bit more efficiency.
659 *********************************************************************************
662 int waitForInterruptSys (int pin, int mS)
666 struct pollfd polls ;
668 if ((fd = sysFds [pin & 63]) == -1)
673 x = read (fd, buf, 6) ;
679 lseek (fd, 0, SEEK_SET) ;
681 // Setup poll structure
684 polls.events = POLLPRI ; // Urgent data!
688 return poll (&polls, 1, mS) ;
691 int waitForInterruptWPi (int pin, int mS)
693 return waitForInterruptSys (pinToGpio [pin & 63], mS) ;
696 int waitForInterruptGpio (int pin, int mS)
698 return waitForInterruptSys (pin, mS) ;
706 * Wait for some number of milli seconds
707 *********************************************************************************
710 void delay (unsigned int howLong)
712 struct timespec sleeper, dummy ;
714 sleeper.tv_sec = (time_t)(howLong / 1000) ;
715 sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
717 nanosleep (&sleeper, &dummy) ;
723 * This is somewhat intersting. It seems that on the Pi, a single call
724 * to nanosleep takes some 80 to 130 microseconds anyway, so while
725 * obeying the standards (may take longer), it's not always what we
728 * So what I'll do now is if the delay is less than 100uS we'll do it
729 * in a hard loop, watching a built-in counter on the ARM chip. This is
730 * somewhat sub-optimal in that it uses 100% CPU, something not an issue
731 * in a microcontroller, but under a multi-tasking, multi-user OS, it's
732 * wastefull, however we've no real choice )-:
733 *********************************************************************************
736 void delayMicrosecondsSys (unsigned int howLong)
738 struct timespec sleeper, dummy ;
741 sleeper.tv_nsec = (long)(howLong * 1000) ;
743 nanosleep (&sleeper, &dummy) ;
746 void delayMicrosecondsHard (unsigned int howLong)
748 *(timer + TIMER_LOAD) = howLong ;
749 *(timer + TIMER_IRQ_CLR) = 0 ;
751 while (*timerIrqRaw == 0)
755 void delayMicrosecondsWPi (unsigned int howLong)
757 struct timespec sleeper, dummy ;
759 /**/ if (howLong == 0)
761 else if (howLong < 100)
762 delayMicrosecondsHard (howLong) ;
766 sleeper.tv_nsec = (long)(howLong * 1000) ;
767 nanosleep (&sleeper, &dummy) ;
774 * Return a number of milliseconds as an unsigned int.
775 *********************************************************************************
778 unsigned int millis (void)
781 unsigned long long t1 ;
783 gettimeofday (&tv, NULL) ;
785 t1 = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
787 return (uint32_t)(t1 - epoch) ;
793 * Must be called once at the start of your program execution.
795 * Default setup: Initialises the system into wiringPi Pin mode and uses the
796 * memory mapped hardware directly.
797 *********************************************************************************
800 int wiringPiSetup (void)
803 uint8_t *gpioMem, *pwmMem, *clkMem, *padsMem, *timerMem ;
806 pinMode = pinModeWPi ;
807 pullUpDnControl = pullUpDnControlWPi ;
808 digitalWrite = digitalWriteWPi ;
809 pwmWrite = pwmWriteWPi ;
810 setPadDrive = setPadDriveWPi ;
811 digitalRead = digitalReadWPi ;
812 waitForInterrupt = waitForInterruptWPi ;
813 delayMicroseconds = delayMicrosecondsWPi ;
814 pwmSetMode = pwmSetModeWPi ;
815 pwmSetRange = pwmSetRangeWPi ;
817 // Open the master /dev/memory device
819 if ((fd = open ("/dev/mem", O_RDWR | O_SYNC) ) < 0)
821 fprintf (stderr, "wiringPiSetup: Unable to open /dev/mem: %s\n", strerror (errno)) ;
827 // Allocate 2 pages - 1 ...
829 if ((gpioMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
831 fprintf (stderr, "wiringPiSetup: malloc failed: %s\n", strerror (errno)) ;
835 // ... presumably to make sure we can round it up to a whole page size
837 if (((uint32_t)gpioMem % PAGE_SIZE) != 0)
838 gpioMem += PAGE_SIZE - ((uint32_t)gpioMem % PAGE_SIZE) ;
840 gpio = (uint32_t *)mmap((caddr_t)gpioMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_BASE) ;
842 if ((int32_t)gpio < 0)
844 fprintf (stderr, "wiringPiSetup: mmap failed: %s\n", strerror (errno)) ;
850 if ((pwmMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
852 fprintf (stderr, "wiringPiSetup: pwmMem malloc failed: %s\n", strerror (errno)) ;
856 if (((uint32_t)pwmMem % PAGE_SIZE) != 0)
857 pwmMem += PAGE_SIZE - ((uint32_t)pwmMem % PAGE_SIZE) ;
859 pwm = (uint32_t *)mmap(pwmMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PWM) ;
861 if ((int32_t)pwm < 0)
863 fprintf (stderr, "wiringPiSetup: mmap failed (pwm): %s\n", strerror (errno)) ;
867 // Clock control (needed for PWM)
869 if ((clkMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
871 fprintf (stderr, "wiringPiSetup: clkMem malloc failed: %s\n", strerror (errno)) ;
875 if (((uint32_t)clkMem % PAGE_SIZE) != 0)
876 clkMem += PAGE_SIZE - ((uint32_t)clkMem % PAGE_SIZE) ;
878 clk = (uint32_t *)mmap(clkMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, CLOCK_BASE) ;
880 if ((int32_t)clk < 0)
882 fprintf (stderr, "wiringPiSetup: mmap failed (clk): %s\n", strerror (errno)) ;
888 if ((padsMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
890 fprintf (stderr, "wiringPiSetup: padsMem malloc failed: %s\n", strerror (errno)) ;
894 if (((uint32_t)padsMem % PAGE_SIZE) != 0)
895 padsMem += PAGE_SIZE - ((uint32_t)padsMem % PAGE_SIZE) ;
897 pads = (uint32_t *)mmap(padsMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_PADS) ;
899 if ((int32_t)pads < 0)
901 fprintf (stderr, "wiringPiSetup: mmap failed (pads): %s\n", strerror (errno)) ;
906 printf ("Checking pads @ 0x%08X\n", (unsigned int)pads) ;
907 printf (" -> %08X %08X %08X\n", *(pads + 11), *(pads + 12), *(pads + 13)) ;
912 if ((timerMem = malloc (BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
914 fprintf (stderr, "wiringPiSetup: timerMem malloc failed: %s\n", strerror (errno)) ;
918 if (((uint32_t)timerMem % PAGE_SIZE) != 0)
919 timerMem += PAGE_SIZE - ((uint32_t)timerMem % PAGE_SIZE) ;
921 timer = (uint32_t *)mmap(timerMem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd, GPIO_TIMER) ;
923 if ((int32_t)timer < 0)
925 fprintf (stderr, "wiringPiSetup: mmap failed (timer): %s\n", strerror (errno)) ;
929 // Set the timer to free-running, 1MHz.
930 // 0xF9 is 249, the timer divide is base clock / (divide+1)
931 // so base clock is 250MHz / 250 = 1MHz.
933 *(timer + TIMER_CONTROL) = 0x0000280 ;
934 *(timer + TIMER_PRE_DIV) = 0x00000F9 ;
935 timerIrqRaw = timer + TIMER_IRQ_RAW ;
937 // Initialise our epoch for millis()
939 gettimeofday (&tv, NULL) ;
940 epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;
948 * Must be called once at the start of your program execution.
950 * GPIO setup: Initialises the system into GPIO Pin mode and uses the
951 * memory mapped hardware directly.
952 *********************************************************************************
955 int wiringPiSetupGpio (void)
957 int x = wiringPiSetup () ;
962 pinMode = pinModeGpio ;
963 pullUpDnControl = pullUpDnControlGpio ;
964 digitalWrite = digitalWriteGpio ;
965 pwmWrite = pwmWriteGpio ;
966 setPadDrive = setPadDriveGpio ;
967 digitalRead = digitalReadGpio ;
968 waitForInterrupt = waitForInterruptGpio ;
969 delayMicroseconds = delayMicrosecondsWPi ; // Same
970 pwmSetMode = pwmSetModeWPi ;
971 pwmSetRange = pwmSetRangeWPi ;
979 * Must be called once at the start of your program execution.
981 * Initialisation (again), however this time we are using the /sys/class/gpio
982 * interface to the GPIO systems - slightly slower, but always usable as
983 * a non-root user, assuming the devices are already exported and setup correctly.
986 int wiringPiSetupSys (void)
992 pinMode = pinModeSys ;
993 pullUpDnControl = pullUpDnControlSys ;
994 digitalWrite = digitalWriteSys ;
995 pwmWrite = pwmWriteSys ;
996 setPadDrive = setPadDriveSys ;
997 digitalRead = digitalReadSys ;
998 waitForInterrupt = waitForInterruptSys ;
999 delayMicroseconds = delayMicrosecondsSys ;
1000 pwmSetMode = pwmSetModeSys ;
1001 pwmSetRange = pwmSetRangeSys ;
1004 // Open and scan the directory, looking for exported GPIOs, and pre-open
1005 // the 'value' interface to speed things up for later
1007 for (pin = 0 ; pin < 64 ; ++pin)
1009 sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
1010 sysFds [pin] = open (fName, O_RDWR) ;
1013 // Initialise the epoch for mills() ...
1015 gettimeofday (&tv, NULL) ;
1016 epoch = (tv.tv_sec * 1000000 + tv.tv_usec) / 1000 ;