Difference between revisions of "RPi Low-level peripherals"

From eLinux.org
Jump to: navigation, search
(General Purpose Input/Output (GPIO): add header note in boldface)
m (pigpio)
(175 intermediate revisions by 47 users not shown)
Line 4: Line 4:
  
 
==Introduction==
 
==Introduction==
In addition to the familiar USB, Ethernet and HDMI ports, the R-Pi offers lower-level interfaces intended to connect more directly with chips and subsystem modules. These GPIO (general purpose I/O) signals on the 2x13 header pins include SPI, I2C, serial UART, 3V3 and 5V power. These interfaces are not "plug and play" but require care to avoid miswiring. The pins use a 3V3 logic level and are not tolerant of 5V levels, such as you might find on a 5V powered Arduino. Not yet software-enabled are the flex cable connectors with CSI (camera serial interface) and DSI (display serial interface), and a serial link inside the HDMI connector called CEC (consumer electronics control).
+
In addition to the familiar USB, Ethernet and HDMI ports, the R-Pi offers lower-level interfaces intended to connect more directly with chips and subsystem modules. These GPIO (general purpose I/O) signals on the 2x13 header pins include SPI, I²C, serial UART, 3V3 and 5V power. These interfaces are not "plug and play" and require care to avoid miswiring. The pins use a 3V3 logic level and are not tolerant of 5V levels, such as you might find on a 5V powered Arduino. CSI (camera serial interface) can be used to connect the 5 MP camera available. Not yet software-enabled is the flex cable connectors with DSI (display serial interface) and a serial link inside the HDMI connector called CEC. (consumer electronics control)
  
 
==General Purpose Input/Output (GPIO)==
 
==General Purpose Input/Output (GPIO)==
[[File:GPIOs.png|thumb|254px|right|The layout of the Raspberry Pi GPIOs, colour coded to the table. [https://sites.google.com/site/burngatehouse/home/drawings/GPIOs2.gif Source] ]]
+
[[File:GPIOs.png|thumb|254px|right|The layout of the Raspberry Pi P1 pin-header seen from the top, containing pins useable for general purpose I/O. Colour coded to the table. Three pins changed between PCB Rev.1 and Rev.2 [https://sites.google.com/site/burngatehouse/home/drawings/GPIOs2.gif Source] ]]
  
 
General Purpose Input/Output (a.k.a. GPIO) is a generic pin on a chip whose behavior (including whether it is an input or output pin) can be controlled (programmed) through software.
 
General Purpose Input/Output (a.k.a. GPIO) is a generic pin on a chip whose behavior (including whether it is an input or output pin) can be controlled (programmed) through software.
Line 13: Line 13:
 
The Raspberry Pi allows peripherals and expansion boards (such as the [[Rpi Gertboard]]) to access the CPU by exposing the inputs and outputs.
 
The Raspberry Pi allows peripherals and expansion boards (such as the [[Rpi Gertboard]]) to access the CPU by exposing the inputs and outputs.
  
For further general information about GPIOs, see:[http://en.wikipedia.org/wiki/GPIO the wikipedia article].
+
For further general information about GPIOs, see: [http://en.wikipedia.org/wiki/General-purpose input/output this wikipedia article].<BR>
 +
For further specific information about the Raspberry Pi's BCM2835 GPIOs, see: [[RPi BCM2835 GPIOs|this wiki article]].<BR>
 +
To connect devices to the serial port (UART), see the [[RPi Serial Connection]] page.<BR>
 +
Sample circuits for interfacing the GPIOs with other electronics are shown on the [[RPi GPIO Interface Circuits]] page.
  
The production Raspberry Pi board has a 26-pin 2.54&nbsp;mm (100&nbsp;mil)<ref>http://www.raspberrypi.org/forum/features-and-requests/easy-gpio-hardware-software/page-3/#p31907</ref> expansion header, marked as P1, arranged in a 2x13 strip. They provide 8 GPIO pins plus access to I²C, SPI, UART), as well as +3.3&nbsp;V, +5&nbsp;V and GND supply lines. Pin one is the pin in the first column and on the bottom row. <ref>http://www.raspberrypi.org/archives/384</ref>
+
The Raspberry Pi Model A and B boards have a 26-pin 2.54&nbsp;mm (100&nbsp;mil)<ref>[http://www.raspberrypi.org/forum/features-and-requests/easy-gpio-hardware-software/page-3/#p31907 raspberrypi.org]</ref> expansion header, marked as P1, arranged in a 2x13 strip. They provide 8 GPIO pins plus access to I²C, SPI, UART), as well as +3.3&nbsp;V, +5&nbsp;V and GND supply lines. Pin one is the pin in the first column and on the bottom row. <ref>[http://www.raspberrypi.org/archives/384 raspberrypi.org]</ref>
 +
[[File:RPi_P1_header.png]]
 +
 
 +
The Raspberry Pi Model A+ and B+ boards have a 40-pin header marked J8, arranged as 2x20 pins. The first 26 pins are the same as P1 on the A/B boards, with the remaining 14 pins providing additional GPIO and ground pins, and an EEPROM ID feature for auto-configuration with add-on "HAT" boards.<ref>[http://www.raspberrypi.org/wp-content/uploads/2014/04/bplus-gpio.png raspberrypi.org]</ref>
 +
<pre>
 +
RPi A+,B+ GPIO: J8 40-pin header
 +
--------------------------------
 +
        +3V3 1  2  +5V
 +
GPIO2  SDA1 3  4  +5V
 +
GPIO3  SCL1 5  6  GND
 +
GPIO4  GCLK 7  8  TXD0  GPIO14
 +
        GND 9  10  RXD0  GPIO15
 +
GPIO17  GEN0 11 12  GEN1  GPIO18
 +
GPIO27  GEN2 13 14  GND
 +
GPIO22  GEN3 15 16  GEN4  GPIO23
 +
        +3V3 17 18  GEN5  GPIO24
 +
GPIO10  MOSI 19 20  GND
 +
GPIO9  MISO 21 22  GEN6  GPIO25
 +
GPIO11  SCLK 23 24  CE0_N GPIO8
 +
        GND 25 26  CE1_N GPIO7
 +
EEPROM ID_SD 27 28  ID_SC EEPROM
 +
GPIO5        29 30  GND
 +
GPIO6        31 32        GPIO12
 +
GPIO13      33 34  GND
 +
GPIO19      35 36        GPIO16
 +
GPIO26      37 38        GPIO20
 +
        GND 39 40        GPIO21
 +
--------------------------------
 +
</pre>
  
 
'''GPIO voltage levels are 3.3&nbsp;V and are not 5&nbsp;V tolerant. There is no over-voltage protection on the board''' - the intention is that people interested in serious interfacing will use an external board with buffers, level conversion and analog I/O rather than soldering directly onto the main board.
 
'''GPIO voltage levels are 3.3&nbsp;V and are not 5&nbsp;V tolerant. There is no over-voltage protection on the board''' - the intention is that people interested in serious interfacing will use an external board with buffers, level conversion and analog I/O rather than soldering directly onto the main board.
  
All the GPIO pins can be reconfigured to provide alternate functions, SPI, PWM, I²C and so. At reset only pins GPIO 14 & 15 are assigned to the alternate function UART, these two can be switched back to GPIO to provide a total of 17 GPIO pins<ref>http://www.raspberrypi.org/archives/384</ref>. Each of their functions and full details of how to access are detailed in the chipset datasheet <ref>http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf</ref>.
+
All the GPIO pins can be reconfigured to provide alternate functions, SPI, [http://en.wikipedia.org/wiki/Pulse-width_modulation PWM], I²C and so. At reset only pins GPIO 14 & 15 are assigned to the alternate function UART, these two can be switched back to GPIO to provide a total of 17 GPIO pins<ref>[http://www.raspberrypi.org/archives/384 raspberrypi.org]</ref>. Each of their functions and full details of how to access are detailed in the chipset datasheet <ref>[http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf raspberrypi.org]</ref>.
  
Each GPIO can interrupt, high/low/rise/fall/change.<ref>http://www.raspberrypi.org/archives/384#comment-5217</ref><ref>http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf</ref> There is currently no support for GPIO interrupts in the official kernel, howewer a patch exists, requiring compilation of modified source tree.<ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?f=44&t=7509</ref>
+
Each GPIO can interrupt, high/low/rise/fall/change.<ref>http://www.raspberrypi.org/archives/384#comment-5217</ref><ref>http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf</ref> There is currently no support for GPIO interrupts in the official kernel, however a patch exists, requiring compilation of modified source tree.<ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?f=44&t=7509</ref> The 'Raspbian "wheezy"' <ref>http://www.raspberrypi.org/downloads</ref> version that is currently recommended for starters already includes GPIO interrupts.
  
 
GPIO input hysteresis (Schmitt trigger) can be on or off, output slew rate can be fast or limited, and source and sink current is configurable from 2&nbsp;mA up to 16&nbsp;mA. Note that chipset GPIO pins 0-27 are in the same block and these properties are set per block, not per pin. See [http://www.scribd.com/doc/101830961/GPIO-Pads-Control2 GPIO Datasheet Addendum - GPIO Pads Control]. Particular attention should be applied to the note regarding SSO (Simultaneous Switching Outputs): to avoid interference, driving currents should be kept as low as possible.
 
GPIO input hysteresis (Schmitt trigger) can be on or off, output slew rate can be fast or limited, and source and sink current is configurable from 2&nbsp;mA up to 16&nbsp;mA. Note that chipset GPIO pins 0-27 are in the same block and these properties are set per block, not per pin. See [http://www.scribd.com/doc/101830961/GPIO-Pads-Control2 GPIO Datasheet Addendum - GPIO Pads Control]. Particular attention should be applied to the note regarding SSO (Simultaneous Switching Outputs): to avoid interference, driving currents should be kept as low as possible.
  
The available [[RPi_BCM2835_GPIOs|alternative functions]] and their corresponding pins are detailed below. These numbers are in reference to the chipset documentation and may not match the numbers exposed in Linux. Only fully usable functions are detailed, for some alternative functions not all the necessary pins are available for the funtionality to be actually used.
+
The available [[RPi BCM2835 GPIOs|alternative functions]] and their corresponding pins are detailed below. These numbers are in reference to the chipset documentation and may not match the numbers exposed in Linux. Only fully usable functions are detailed, for some alternative functions not all the necessary pins are available for the funtionality to be actually used.
  
 
There is also some information on the [[RPi Tutorial Easy GPIO Hardware & Software|Tutorial on Easy GPIO Hardware & Software]].
 
There is also some information on the [[RPi Tutorial Easy GPIO Hardware & Software|Tutorial on Easy GPIO Hardware & Software]].
  
Kernel boot messages go to the [[RPi_Serial_Connection|UART]] at 115200&nbsp;bit/s.
+
Kernel boot messages go to the UART at 115200&nbsp;bit/s - there are more details on the [[RPi Serial Connection|serial port]] page.
  
'''R-Pi PCB Revision 2 UPDATE:''' According to Eben at [http://www.raspberrypi.org/archives/1929#comments] the R-Pi Rev.2 board being rolled out starting in September 2012 adds 4 more GPIO on a new connector called P5, and changes some of the existing P1 GPIO pinouts. On Rev2, GPIO_GEN2 [BCM2835/GPIO27] is routed to P1 pin 13, and changes what was SCL0/SDA0 to SCL1/SDA1: SCL1 [BCM2835/GPIO3] is routed to P1 pin 5, SDA1 [BCM2835/GPIO2] is routed to P1 pin 3. Also the power and ground connections previously marked "Do Not Connect" on P1 will remain as connected, specifically:
+
'''R-Pi PCB Revision 2:''' According to Eben at [http://www.raspberrypi.org/archives/1929#comment-31646] the R-Pi Rev.2 board being rolled out starting in September 2012 adds 4 more GPIO on a new connector called P5, and changes some of the existing P1 GPIO pinouts. On Rev2, GPIO_GEN2 [BCM2835/GPIO27] is routed to P1 pin 13, and changes what was SCL0/SDA0 to SCL1/SDA1: SCL1 [BCM2835/GPIO3] is routed to P1 pin 5, SDA1 [BCM2835/GPIO2] is routed to P1 pin 3. Also the power and ground connections previously marked "Do Not Connect" on P1 will remain as connected, specifically: P1-04:+5V0, P1-09:GND, P1-14:GND, P1-17:+3V3, P1-20:GND, P1-25:GND. According to this comment [http://www.raspberrypi.org/archives/2081#comment-33577] (and confirmed in this post [http://www.raspberrypi.org/archives/2233]) the P1 pinout is not expected to change in future beyond the current Rev.2 layout.
P1-04: +5V0
 
P1-09: GND
 
P1-14: GND
 
P1-17: +3V3
 
P1-20: GND
 
P1-25: GND
 
  
'''Header Pinout, top row:'''
+
===P1 Header pinout, top row===
 
{| border="1" style="text-align:center;"
 
{| border="1" style="text-align:center;"
| '''Pin Number''' || '''Pin Name''' || '''Hardware Notes''' || '''Alt 0 Function''' || '''Other Alternative Functions'''
+
| '''Pin Number''' || '''Pin Name Rev1''' || '''Pin Name Rev2''' || '''Hardware Notes''' || '''Alt 0 Function''' || '''Other Alternative Functions'''
 
|-
 
|-
| P1-02 || bgcolor="red" | <span style="color:white">5V0</span> || Supply through input poly fuse
+
| P1-02 || bgcolor="red"  colspan="2" | <span style="color:white">5V0</span> || Supply through input poly fuse
 +
| &nbsp;
 +
| &nbsp;
 
|-
 
|-
| P1-04 || DNC
+
| P1-04 || bgcolor="red"  colspan="2" | <span style="color:white">5V0</span> || Supply through input poly fuse
 +
| &nbsp;
 +
| &nbsp;
 
|-
 
|-
| P1-06 || bgcolor="black" | <span style="color:white">GND</span>  
+
| P1-06 || bgcolor="black"  colspan="2" | <span style="color:white">GND</span>  
 +
| &nbsp;
 +
| &nbsp;
 +
| &nbsp;
 
|-
 
|-
| P1-08 || bgcolor="lime" | GPIO 14 || Boot to Alt 0 -> || bgcolor="yellow" | UART0_TXD || ALT5 = UART1_TXD
+
| P1-08 || bgcolor="lime"  colspan="2" | GPIO 14 || Boot to Alt 0 -> || bgcolor="yellow" | UART0_TXD || ALT5 = UART1_TXD
 
|-
 
|-
| P1-10 || bgcolor="lime" | GPIO 15 || Boot to Alt 0 -> ||bgcolor="yellow" | UART0_RXD || ALT5 = UART1_RXD
+
| P1-10 || bgcolor="lime"  colspan="2" | GPIO 15 || Boot to Alt 0 -> || bgcolor="yellow" | UART0_RXD || ALT5 = UART1_RXD
 
|-
 
|-
| P1-12 || bgcolor="lime" | GPIO 18 || || || ALT4 SPI1_CE0_N ALT5 = PWM0
+
| P1-12 || bgcolor="lime"  colspan="2" | GPIO 18 ||&nbsp; || PCM_CLK || ALT4 = SPI1_CE0_N ALT5 = PWM0
 
|-
 
|-
| P1-14 || DNC
+
| P1-14 || bgcolor="black"  colspan="2" | <span style="color:white">GND</span>
 +
| &nbsp;
 +
| &nbsp;
 +
| &nbsp; 
 
|-
 
|-
| P1-16 || bgcolor="lime" | GPIO23 || || || ALT3 = SD1_CMD ALT4 = ARM_RTCK
+
| P1-16 || bgcolor="lime"  colspan="2" | GPIO23 || || || ALT3 = SD1_CMD ALT4 = ARM_RTCK
 
|-
 
|-
| P1-18 || bgcolor="lime" | GPIO24 || || || ALT3 = SD1_DATA0 ALT4 = ARM_TDO
+
| P1-18 || bgcolor="lime"  colspan="2" | GPIO24 || || || ALT3 = SD1_DAT0 ALT4 = ARM_TDO
 
|-
 
|-
| P1-20 || DNC
+
| P1-20 || bgcolor="black"  colspan="2" | <span style="color:white">GND</span>
 +
| &bnsp;
 +
| &nbsp;
 +
| &nbsp;
 
|-
 
|-
| P1-22 || bgcolor="lime" | GPIO25 || || || ALT4 = ARM_TCK
+
| P1-22 || bgcolor="lime"  colspan="2" | GPIO25 || || || ALT3 = SD1_DAT1 ALT4 = ARM_TCK
 
|-
 
|-
| P1-24 || bgcolor="lime" | GPIO08 || || bgcolor="purple" | <span style="color:white">SPI0_CE0_N</span> ||
+
| P1-24 || bgcolor="lime"  colspan="2" | GPIO08 || || bgcolor="purple" | <span style="color:white">SPI0_CE0_N</span> ||
 
|-
 
|-
| P1-26 || bgcolor="lime" | GPIO07 || || bgcolor="purple" | <span style="color:white">SPI0_CE1_N</span> ||  
+
| P1-26 || bgcolor="lime"  colspan="2" | GPIO07 || || bgcolor="purple" | <span style="color:white">SPI0_CE1_N</span> ||  
 
|}
 
|}
  
 
+
===P1 Header pinout, bottom row===
'''Header Pinout, bottom row:'''
 
 
{| border="1" style="text-align:center;"
 
{| border="1" style="text-align:center;"
| '''Pin Number''' || '''Pin Name''' || '''Hardware Notes''' || '''Alt 0 Function''' || '''Other Alternative Functions'''
+
| '''Pin Number''' || '''Pin Name Rev1''' || '''Pin Name Rev2''' || '''Hardware Notes''' || '''Alt 0 Function''' || '''Other Alternative Functions'''
 
|-
 
|-
| P1-01 || bgcolor="orange" | 3.3&nbsp;V || 50&nbsp;mA max current draw
+
| P1-01 || bgcolor="orange"  colspan="2" | 3.3&nbsp;V || 50&nbsp;mA max (01 & 17)
 +
| &nbsp;
 +
| &nbsp;
 
|-
 
|-
| P1-03 || bgcolor="lime" | GPIO 0|| 1K8 pull up resistor || bgcolor="cyan" | I2C0_SDA ||   I2C0_SDA
+
| P1-03 || bgcolor="lime" | GPIO 0 || bgcolor="lime" | '''GPIO 2'''|| 1K8 pull up resistor || bgcolor="cyan" | I2C0_SDA / '''I2C1_SDA''' ||
 
|-
 
|-
| P1-05 || bgcolor="lime" | GPIO 1|| 1K8 pull up resistor || bgcolor="cyan" | I2C0_SCL ||   I2C0_SCL
+
| P1-05 || bgcolor="lime" | GPIO 1 || bgcolor="lime" | '''GPIO 3'''|| 1K8 pull up resistor || bgcolor="cyan" | I2C0_SCL / '''I2C1_SCL''' ||
 
|-
 
|-
| P1-07 || bgcolor="lime" | GPIO 4 || || || bgcolor="lime" | GPCLK0
+
| P1-07 || bgcolor="lime"  colspan="2" | GPIO 4 || || GPCLK0 || ALT5 = ARM_TDI
 
|-
 
|-
| P1-09 || DNC
+
| P1-09 || bgcolor="black"  colspan="2" | <span style="color:white">GND</span>
 +
| &nbsp;
 +
| &nbsp;
 +
| &nbsp; 
 
|-
 
|-
| P1-11 || bgcolor="lime" | GPIO17 || || ||| ALT3 = UART0_RTS, ALT5 = UART1_RTS
+
| P1-11 || bgcolor="lime"  colspan="2" | GPIO17 || || ||| ALT3 = UART0_RTS ALT4 = SPI1_CE1_N ALT5 = UART1_RTS
 
|-
 
|-
| P1-13 || bgcolor="lime" | GPIO21 || || PCM_DIN || ALT5 = GPCLK1
+
| P1-13 || bgcolor="lime" | GPIO21 || bgcolor="lime" | '''GPIO27''' || || PCM_DOUT / '''reserved''' || ALT4 = SPI1_SCLK ALT5 = GPCLK1 / '''ALT3 = SD1_DAT3 ALT4 = ARM_TMS'''
 
|-
 
|-
| P1-15 || bgcolor="lime" | GPIO22 || || || ALT3 = SD1_CLK ALT4 = ARM_TRST
+
| P1-15 || bgcolor="lime"  colspan="2" | GPIO22 || || || ALT3 = SD1_CLK ALT4 = ARM_TRST
 
|-
 
|-
| P1-17 || DNC
+
| P1-17 || bgcolor="orange"  colspan="2" | 3.3&nbsp;V || 50&nbsp;mA max (01 & 17)
 +
| &nbsp;
 +
| &nbsp;
 
|-
 
|-
| P1-19 || bgcolor="lime" | GPIO10 || || bgcolor="purple" | <span style="color:white">SPI0_MOSI</span> ||  
+
| P1-19 || bgcolor="lime"  colspan="2" | GPIO10 || || bgcolor="purple" | <span style="color:white">SPI0_MOSI</span> ||  
 
|-
 
|-
| P1-21 || bgcolor="lime" | GPIO9 || || bgcolor="purple" | <span style="color:white">SPI0_MISO</span> ||
+
| P1-21 || bgcolor="lime" colspan="2"  | GPIO9 || || bgcolor="purple" | <span style="color:white">SPI0_MISO</span> ||
 
|-
 
|-
| P1-23 || bgcolor="lime" | GPIO11 || || bgcolor="purple" | <span style="color:white">SPI0_SCLK</span> ||  
+
| P1-23 || bgcolor="lime"  colspan="2" | GPIO11 || || bgcolor="purple" | <span style="color:white">SPI0_SCLK</span> ||  
 
|-
 
|-
| P1-25 || DNC
+
| P1-25 || bgcolor="black"  colspan="2" | <span style="color:white">GND</span>
 +
| &nbsp;
 +
| &nbsp;
 +
| &nbsp;
 
|}
 
|}
  
Line 111: Line 158:
 
|-
 
|-
 
| bgcolor="black" | <span style="color:white">Ground, 0V</span>  
 
| bgcolor="black" | <span style="color:white">Ground, 0V</span>  
|-
 
| Do not connect
 
 
|-
 
|-
 
| bgcolor="yellow" | UART
 
| bgcolor="yellow" | UART
Line 123: Line 168:
 
|}
 
|}
  
KiCad symbol: [[File:Conn-raspberry.lib]]
+
KiCad symbol: [[File:Conn-raspberry.lib]]<ref>http://www.raspberrypi.org/forum/projects-and-collaboration-general/gpio-header-pinout-clarification/page-2</ref>
  
<ref>http://www.raspberrypi.org/forum/projects-and-collaboration-general/gpio-header-pinout-clarification/page-2</ref>
+
Pin 3 (SDA0) and Pin 5 (SCL0) are preset to be used as an I²C interface. So there are 1.8&nbsp;kohm pulls up resistors on the board for these pins.<ref>http://www.raspberrypi.org/forum/features-and-requests/easy-gpio-hardware-software/page-6/#p56480</ref>
  
Pin 3 (SDA0) and Pin 5 (SCL0) are preset to be used as an I²C interface. So there are 1.8&nbsp;kilohm pulls up resistors on the board for these pins.<ref>http://www.raspberrypi.org/forum/features-and-requests/easy-gpio-hardware-software/page-6/#p56480</ref>
+
Pin 12 supports [http://en.wikipedia.org/wiki/Pulse-width_modulation PWM].
  
Pin 12 supports PWM.
+
It is also possible to reconfigure GPIO connector pins P1-7, 15, 16, 18, 22 (chipset GPIOs 4 and 22 to 25) to provide an ARM JTAG interface.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1288.1</ref> However ARM_TMS is not available on the GPIO connector (chipset pin 12 or 27 is needed). Chipset pin 27 is available on S5, the CSI camera interface however.
 
 
It is also possible to reconfigure GPIO connector pins P1-7, 15, 16, 18, 22 (chipset GPIOs 4 and 22 to 25) to provide an ARM JTAG interface.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1288.1</ref> However ARM_TMS isn't available on the GPIO connector (chipset pin 12 or 27 is needed). Chipset pin 27 is available on S5, the CSI camera interface however.
 
  
 
It is also possible to reconfigure GPIO connector pins P1-12 and 13 (chipset GPIO 18 and 21) to provide an I2S (a hardware modification may be required<ref name="I2S">[http://www.raspberrypi.org/forum/features-and-requests/sad-about-removal-of-i2s-why-was-this-change-made Forum:Sad about removal of I2S. Why was this change made?]</ref>) or PCM interface.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1288.2</ref> However, PCM_FS and PCM_DIN (chipset pins 19 and 20) are needed for I2S or PCM.
 
It is also possible to reconfigure GPIO connector pins P1-12 and 13 (chipset GPIO 18 and 21) to provide an I2S (a hardware modification may be required<ref name="I2S">[http://www.raspberrypi.org/forum/features-and-requests/sad-about-removal-of-i2s-why-was-this-change-made Forum:Sad about removal of I2S. Why was this change made?]</ref>) or PCM interface.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1288.2</ref> However, PCM_FS and PCM_DIN (chipset pins 19 and 20) are needed for I2S or PCM.
  
 
A second I²C interface (GPIO02_ALT0 is SDA1 and GPIO03_ALT0 is SCL1) and two further GPIOs (GPIO05_ALT0 is GPCLK1, and GPIO27) are available on S5, the CSI camera interface.
 
A second I²C interface (GPIO02_ALT0 is SDA1 and GPIO03_ALT0 is SCL1) and two further GPIOs (GPIO05_ALT0 is GPCLK1, and GPIO27) are available on S5, the CSI camera interface.
 
===A note about GPIO vs the schematic===
 
 
You may notice that the GPIO connector as documented in the schematic does NOT match with what is on this wiki page. Do NOT update this wiki page. The pins which are marked as DNC should not be used in order to be compatible with possible future designs. The plan is that if a new design comes along and if the layout permits it we will connect additional GPIO pins to those DNC pins. (Gert's first vote is for GPIO 19 and 20. That gives us the second PWM, second SPI, I2S/PCM, slave I²C and slave SPI.)
 
  
 
===Referring to pins on the Expansion header===
 
===Referring to pins on the Expansion header===
 
+
The header is referred to as "The GPIO Connector (P1)".  To avoid nomenclature confusion between Broadcom signal names on the SoC and pin names on the expansion header, the following naming is highly recommended:
The header is referred to as "The GPIO Connector (P1)".  To avoid nomenclature confusion between Broadcom signal names on the SoC and pin names on the expansion header, the following naming is highly recommended.
 
 
 
 
* The expansion header is referred to as "Expansion Header" or "GPIO Connector (P1)"
 
* The expansion header is referred to as "Expansion Header" or "GPIO Connector (P1)"
 
* Pins on the GPIO connector (P1) are referred to as P1-01, etc.
 
* Pins on the GPIO connector (P1) are referred to as P1-01, etc.
 
* Names GPIO0, GPIO1, GPIOx-ALTy, etc. refer to the signal names on the SoC as enumerated in the Broadcom datasheet, where "x" matches BCM2835 number (without leading zero) and "y" is the alternate number column 0 to 5 on page 102-103 of the Broadcom document. For example, depending on what you are describing, use either "GPIO7" to refer to a row of the table, and "GPIO7-ALT0" would refer to a specific cell of the table.
 
* Names GPIO0, GPIO1, GPIOx-ALTy, etc. refer to the signal names on the SoC as enumerated in the Broadcom datasheet, where "x" matches BCM2835 number (without leading zero) and "y" is the alternate number column 0 to 5 on page 102-103 of the Broadcom document. For example, depending on what you are describing, use either "GPIO7" to refer to a row of the table, and "GPIO7-ALT0" would refer to a specific cell of the table.
* When refering to signal names, you should modify the Broadcom name slightly to minimize confusion. The Broadcom SPI bus pin names are fine, such as "SPI0_*" and "SPI1_*", but they didn't do the same on the I²C and UART pins. Instead of using "SDA0" and "SCL0", you should use "I2C0_SDA" and "I2C0_SCL"; and instead of "TX" or "TXD" and "RX" or "RXD", you should use "UART0_TXD" and "UART0_RXD".
+
* When refering to signal names, the Broadcom name should be modified slightly to minimize confusion. The Broadcom SPI bus pin names are fine, such as "SPI0_*" and "SPI1_*", but they did not do the same on the I²C and UART pins. Instead of using "SDA0" and "SCL0", "I2C0_SDA" and "I2C0_SCL" should be used; and "UART0_TXD" and "UART0_RXD" instead of "TX" or "TXD" and "RX" or "RXD".
  
 
===Power pins===
 
===Power pins===
The maximum permitted current draw from the 3.3&nbsp;V pin is 50&nbsp;mA.
+
The maximum permitted current draw from the 3.3&nbsp;V pins is 50&nbsp;mA.
  
 
Maximum permitted current draw from the 5&nbsp;V pin is the USB input current (usually 1&nbsp;A) minus any current draw from the rest of the board.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1536#postid-21841</ref>
 
Maximum permitted current draw from the 5&nbsp;V pin is the USB input current (usually 1&nbsp;A) minus any current draw from the rest of the board.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1536#postid-21841</ref>
 
*Model A: 1000&nbsp;mA - 500&nbsp;mA -> max current draw: 500&nbsp;mA
 
*Model A: 1000&nbsp;mA - 500&nbsp;mA -> max current draw: 500&nbsp;mA
 
*Model B: 1000&nbsp;mA - 700&nbsp;mA -> max current draw: 300&nbsp;mA
 
*Model B: 1000&nbsp;mA - 700&nbsp;mA -> max current draw: 300&nbsp;mA
Be very careful with the 5&nbsp;V pin, because if you short it to any other P1 pin you may permanently damage your RasPi. Before probing P1, it's a good idea to strip a short piece of insulation off a wire and push it over the 5&nbsp;V pin so you don't accidentally touch it with a probe.
+
Be very careful with the 5&nbsp;V pins P1-02 and P1-04, because if you short 5&nbsp;V to any other P1 pin you may permanently damage your RasPi. Before probing P1, it is a good idea to strip short pieces of insulation off a wire and push them over the 5&nbsp;V pins are not accidentally shorted with a probe.
  
 
=== GPIO hardware hacking ===
 
=== GPIO hardware hacking ===
 +
The complete list of [[RPi_BCM2835_GPIOs|chipset GPIO pins]] which are available on the GPIO connector is: <blockquote>[[RPi_BCM2835_GPIOs#GPIO0|0]], [[RPi_BCM2835_GPIOs#GPIO1|1]], [[RPi_BCM2835_GPIOs#GPIO4|4]], [[RPi_BCM2835_GPIOs#GPIO7|7]], [[RPi_BCM2835_GPIOs#GPIO8|8]], [[RPi_BCM2835_GPIOs#GPIO9|9]], [[RPi_BCM2835_GPIOs#GPIO10|10]], [[RPi_BCM2835_GPIOs#GPIO11|11]], [[RPi_BCM2835_GPIOs#GPIO14|14]], [[RPi_BCM2835_GPIOs#GPIO15|15]], [[RPi_BCM2835_GPIOs#GPIO17|17]], [[RPi_BCM2835_GPIOs#GPIO18|18]], [[RPi_BCM2835_GPIOs#GPIO21|21]], [[RPi_BCM2835_GPIOs#GPIO22|22]], [[RPi_BCM2835_GPIOs#GPIO23|23]], [[RPi_BCM2835_GPIOs#GPIO24|24]], [[RPi_BCM2835_GPIOs#GPIO25|25]]</blockquote>
  
The complete list of [[RPi_BCM2835_GPIOs|chipset GPIO pins]] which are available on the GPIO connector is: <blockquote>[[RPi_BCM2835_GPIOs#GPIO0|0]], [[RPi_BCM2835_GPIOs#GPIO1|1]], [[RPi_BCM2835_GPIOs#GPIO4|4]], [[RPi_BCM2835_GPIOs#GPIO7|7]], [[RPi_BCM2835_GPIOs#GPIO8|8]], [[RPi_BCM2835_GPIOs#GPIO9|9]], [[RPi_BCM2835_GPIOs#GPIO10|10]], [[RPi_BCM2835_GPIOs#GPIO11|11]], [[RPi_BCM2835_GPIOs#GPIO14|14]], [[RPi_BCM2835_GPIOs#GPIO15|15]], [[RPi_BCM2835_GPIOs#GPIO17|17]], [[RPi_BCM2835_GPIOs#GPIO18|18]], [[RPi_BCM2835_GPIOs#GPIO21|21]], [[RPi_BCM2835_GPIOs#GPIO22|22]], [[RPi_BCM2835_GPIOs#GPIO23|23]], [[RPi_BCM2835_GPIOs#GPIO24|24]], [[RPi_BCM2835_GPIOs#GPIO25|25]]</blockquote>
+
(on the Revision2.0 RaspberryPis, this list changes to: [[RPi_BCM2835_GPIOs#GPIO2|2]], [[RPi_BCM2835_GPIOs#GPIO3|3]], [[RPi_BCM2835_GPIOs#GPIO4|4]], [[RPi_BCM2835_GPIOs#GPIO7|7]], [[RPi_BCM2835_GPIOs#GPIO8|8]], [[RPi_BCM2835_GPIOs#GPIO9|9]], [[RPi_BCM2835_GPIOs#GPIO10|10]], [[RPi_BCM2835_GPIOs#GPIO11|11]], [[RPi_BCM2835_GPIOs#GPIO14|14]], [[RPi_BCM2835_GPIOs#GPIO15|15]], [[RPi_BCM2835_GPIOs#GPIO17|17]], [[RPi_BCM2835_GPIOs#GPIO18|18]], [[RPi_BCM2835_GPIOs#GPIO22|22]], [[RPi_BCM2835_GPIOs#GPIO23|23]], [[RPi_BCM2835_GPIOs#GPIO24|24]], [[RPi_BCM2835_GPIOs#GPIO25|25]], [[RPi_BCM2835_GPIOs#GPIO27|27]], with [[RPi_BCM2835_GPIOs#GPIO28|28]], [[RPi_BCM2835_GPIOs#GPIO29|29]], [[RPi_BCM2835_GPIOs#GPIO30|30]], [[RPi_BCM2835_GPIOs#GPIO31|31]] additionally available on the [[#P5_header|P5 header]])
  
As noted above, GPIO00 and 01 (SDA0 and SCL0) have 1.8&nbsp;kilohm pull-up resistors to 3.3&nbsp;V.
+
As noted above, P1-03 and P1-05 (SDA0 and SCL0 / SDA1 and SCL1) have 1.8&nbsp;kohm pull-up resistors to 3.3&nbsp;V.
  
If 17 GPIOs aren't sufficient for your project, there are a few other signals potentially available, with varying levels of software and hardware (soldering iron) hackery skills:
+
If 17 GPIOs are not sufficient for a project, there are a few other signals potentially available, with varying levels of software and hardware (soldering iron) hackery skills:
  
 
GPIO02, 03, 05 and 27 are available on S5 (the CSI interface) when a camera peripheral is not connected to that socket, and are configured by default to provide the functions SDA1, SCL1, CAM_CLK and CAM_GPIO respectively.  SDA1 and SCL1 have 1K6 pull-up resistors to 3.3&nbsp;V.
 
GPIO02, 03, 05 and 27 are available on S5 (the CSI interface) when a camera peripheral is not connected to that socket, and are configured by default to provide the functions SDA1, SCL1, CAM_CLK and CAM_GPIO respectively.  SDA1 and SCL1 have 1K6 pull-up resistors to 3.3&nbsp;V.
Line 171: Line 209:
  
 
There are a few other chipset GPIO pins accessible on the PCB but are in use:
 
There are a few other chipset GPIO pins accessible on the PCB but are in use:
 
 
* GPIO16 drives status LED D5 (usually SD card access indicator)
 
* GPIO16 drives status LED D5 (usually SD card access indicator)
* GPIO28-31 are used by the board ID and are connected to resistors R3 to R10.
+
* GPIO28-31 are used by the board ID and are connected to resistors R3 to R10 (only on Rev1.0 boards).
* GPIO40 and 45 are used by analogue audio and support PWM. They connect to the analogue audio circuitry via R21 and R27 respectively.
+
* GPIO40 and 45 are used by analogue audio and support [http://en.wikipedia.org/wiki/Pulse-width_modulation PWM]. They connect to the analogue audio circuitry via R21 and R27 respectively.
 
* GPIO46 is HDMI hotplug detect (goes to pin 6 of IC1).
 
* GPIO46 is HDMI hotplug detect (goes to pin 6 of IC1).
 
* GPIO47 to 53 are used by the SD card interface.  In particular, GPIO47 is SD card detect (this would seem to be a good candidate for re-use).  GPIO47 is connected to the SD card interface card detect switch; GPIO48 to 53 are connected to the SD card interface via resistors R45 to R50.
 
* GPIO47 to 53 are used by the SD card interface.  In particular, GPIO47 is SD card detect (this would seem to be a good candidate for re-use).  GPIO47 is connected to the SD card interface card detect switch; GPIO48 to 53 are connected to the SD card interface via resistors R45 to R50.
  
 
=== P2 header ===
 
=== P2 header ===
 +
The P2 header is the VideoCore JTAG and used only during the production of the board. It cannot be used as the ARM JTAG <ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?f=24&t=5894</ref>. This connector is unpopulated in Rev 2.0 boards.
  
The P2 header is the VideoCore JTAG and used only during the production of the board. It cannot be used as the ARM JTAG <ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?f=24&t=5894</ref>.
+
[[File:RPi_P2_header.png]]
  
 
Useful P2 pins:
 
Useful P2 pins:
 
 
* Pin 1 - 3.3V (same as P1-01, 50 mA max current draw across both of them)
 
* Pin 1 - 3.3V (same as P1-01, 50 mA max current draw across both of them)
 
* Pin 7 - GND
 
* Pin 7 - GND
Line 189: Line 226:
  
 
=== P3 header ===
 
=== P3 header ===
 +
The P3 header, unpopulated, is the LAN9512 JTAG <ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?f=24&t=5894</ref>.
 +
 +
[[File:RPi_P3_header.png]]
 +
 +
Useful P3 pins:
 +
* Pin 7 - GND
 +
 +
=== P5 header ===
 +
The P5 header was added with the release of the Revision 2.0 PCB design.
 +
 +
[[File:RPi_P5_header.png]]
 +
 +
===P5 Header pinout, top row===
 +
As seen from the back of the board:
 +
{| border="1" style="text-align:center;"
 +
| '''Pin Number''' || '''Pin Name Rev2''' || '''Hardware Notes''' || '''Alt 0 Function''' || '''Other Alternative Functions'''
 +
|-
 +
| P5-01 || bgcolor="red" | <span style="color:white">5V0</span> || Supply through input poly fuse
 +
|-
 +
| P5-03 || bgcolor="lime" | GPIO28 || || bgcolor="cyan" | I2C0_SDA || ALT2 = PCM_CLK
 +
|-
 +
| P5-05 || bgcolor="lime" | GPIO30 || || || ALT2 = PCM_DIN ALT3 = UART0_CTS ALT5 = UART1_CTS
 +
|-
 +
| P5-07 || bgcolor="black" | <span style="color:white">GND</span>
 +
|}
  
The P3 header, unpopulated, is the LAN9512 JTAG <ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?f=24&t=5894</ref>.
+
===P5 Header pinout, bottom row===
 +
As seen from the back of the board:
 +
{| border="1" style="text-align:center;"
 +
| '''Pin Number''' || '''Pin Name Rev2''' || '''Hardware Notes''' || '''Alt 0 Function''' || '''Other Alternative Functions'''
 +
|-
 +
| P5-02 || bgcolor="orange" | 3.3&nbsp;V || 50&nbsp;mA max (combined with P1)
 +
|-
 +
| P5-04 || bgcolor="lime" | GPIO29 || || bgcolor="cyan" | I2C0_SCL || ALT2 = PCM_FS
 +
|-
 +
| P5-06 || bgcolor="lime" | GPIO31 || || || ALT2 = PCM_DOUT ALT3 = UART0_RTS ALT5 = UART1_RTS
 +
|-
 +
| P5-08 || bgcolor="black" | <span style="color:white">GND</span>
 +
|}
 +
 
 +
[[File:Male-slanted2small.jpg|150px|thumb|left|Slanted P5 header]]
 +
 
 +
Note that the connector is intended to be mounted on the bottom of the PCB, so that for those who put the connector on the top side, the pin numbers are mirrored. Pin 1 and pin 2 are swapped, pin 3 and 4, etc.
 +
 
 +
An alternative way to attach this header is on top, [http://raspi.tv/2013/the-leaning-header-of-pi5a-how-best-to-solder-a-header-on-p5 at a slant away from the P1 header.]
 +
 
 +
The new header can provide a second I²C channel (SDA + SCL) and handshake lines for the existing UART (TxD and RxD), or it can be used for an I2S (audio codec chip) interface using the PCM signals CLK, FS (Frame Sync), Din and Dout.
 +
 
 +
Note that the connector is placed JUST off-grid with respect to the P1 connector.
 +
 
 +
=== P6 header ===
 +
The P6 header was added with the release of the Revision 2.0 PCB design.
 +
 
 +
[[File:RPi_P6_header.png]]
 +
 
 +
===P6 Pinout===
 +
{| border="1" style="text-align:center;"
 +
| '''Pin Number''' || '''Pin Name Rev2''' || '''Hardware Notes'''
 +
|-
 +
| P6-01 || RUN || Short to ground to reset the BCM2835
 +
|-
 +
| P6-02 || bgcolor="black" | <span style="color:white">GND</span>
 +
|}
 +
 
 +
A reset button can be attached to the P6 header.<ref>[http://raspi.tv/2012/making-a-reset-switch-for-your-rev-2-raspberry-pi raspi.tv]</ref> Momentarily shorting the two pins of P6 together will cause a soft reset of the CPU (which can also 'wake' the Pi from halt/shutdown state).
 +
 
 +
===Internal Pull-Ups & Pull-Downs===
 +
The GPIO ports include the ability to enable and disable internal pull-up or pull-down resistors (see below for code examples/support of this):
 +
* Pull-up is 50 kOhm - 65 kOhm
 +
* Pull-down is 50 kOhm - 60 kOhm
  
 
===Driver support===
 
===Driver support===
 
 
The Foundation will not include a GPIO driver in the initial release, standard Linux GPIO drivers should work with minimal modification.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1278.0</ref>
 
The Foundation will not include a GPIO driver in the initial release, standard Linux GPIO drivers should work with minimal modification.<ref>http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1278.0</ref>
  
The community implemented SPI and I²C drivers <ref>http://www.bootc.net/projects/raspberry-pi-kernel/</ref>, which will be integrated with the new Linux pinctrl concept in a later version of the kernel. A first compiled version as Linux modules is available to install on the 19/04/2012 Debian image, including 1-wire support<ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?p=86172#p86172</ref>. The I²C and SPI driver uses the hardware modules of the microcontroller and interrupts for low CPU usage, the 1-wire support uses bitbanging on the GPIO ports, which results in higher CPU usage.
+
The community implemented SPI and I²C drivers <ref>http://www.bootc.net/projects/raspberry-pi-kernel/</ref>, which will be integrated with the new Linux pinctrl concept in a later version of the kernel. (On Oct. 14 2012, it was already included in the latest raspbian image.) A first compiled version as Linux modules is available to install on the 19/04/2012 Debian image, including 1-wire support<ref>http://www.raspberrypi.org/phpBB3/viewtopic.php?p=86172#p86172</ref>. The I²C and SPI driver uses the hardware modules of the microcontroller and interrupts for low CPU usage, the 1-wire support uses bitbanging on the GPIO ports, which results in higher CPU usage.
  
 
GordonH<ref>http://www.raspberrypi.org/forum/general-discussion/wiring-for-the-raspberry-pis-gpio</ref> wrote a (mostly) Arduino compatible/style [https://projects.drogon.net/raspberry-pi/wiringpi/ WiringPi library] in C for controlling the GPIO pins.
 
GordonH<ref>http://www.raspberrypi.org/forum/general-discussion/wiring-for-the-raspberry-pis-gpio</ref> wrote a (mostly) Arduino compatible/style [https://projects.drogon.net/raspberry-pi/wiringpi/ WiringPi library] in C for controlling the GPIO pins.
Line 204: Line 308:
 
===Graphical User Interfaces===
 
===Graphical User Interfaces===
 
====WebIOPi====
 
====WebIOPi====
[http://code.google.com/p/webiopi/ WebIOPi] allows you to control each GPIO with a simple web interface that you can use with any browser. Available in PHP and Python, they both require root access, but Python version serves HTTP itself. You can setup each GPIO as input or output and change their states (LOW/HIGH). WebIOPi is fully customizable, so you can use it for home remote control. It also work over Internet. UART/SPI/I2C support will be added later. If you need some computing for your GPIO go to code examples below.
+
[http://code.google.com/p/webiopi/ WebIOPi] allows to control each GPIO with a simple web interface that can be used with any browser. Available in PHP and Python, they both require root access, but the Python version serves HTTP itself. Each GPIO pin can be set up as input or output and its LOW/HIGH stae can be changed. WebIOPi is fully customizable, so it can be used for home remote control. It also works over Internet. UART/SPI/I²C support will be added later. See code examples below.
  
===Code examples===
+
==GPIO Code examples==
====GPIO Driving Example (C)====
+
=== C ===
[http://www.raspberrypi.org/forum/educational-applications/gertboard/page-4/#p31555 Gert van Loo & Dom, has provided] some tested code which accesses the GPIO pins through direct GPIO register manipulation in C-code.
+
Examples in different C-Languages.
 +
==== Gert & Dom ====
 +
[http://www.raspberrypi.org/forum/educational-applications/gertboard/page-4/#p31555 Gert van Loo & Dom, have provided] some tested code which accesses the GPIO pins through direct GPIO register manipulation in C-code.
 
(Thanks to Dom for doing the difficult work of finding and testing the mapping.)
 
(Thanks to Dom for doing the difficult work of finding and testing the mapping.)
 
Example GPIO code:
 
Example GPIO code:
  
<pre>
+
<source lang=c>
 
//
 
//
 
//  How to access GPIO registers from C-code on the Raspberry-Pi
 
//  How to access GPIO registers from C-code on the Raspberry-Pi
Line 218: Line 324:
 
//  15-January-2012
 
//  15-January-2012
 
//  Dom and Gert
 
//  Dom and Gert
//
+
// Revised: 15-Feb-2013
  
  
Line 228: Line 334:
  
 
#include <stdio.h>
 
#include <stdio.h>
#include <string.h>
 
 
#include <stdlib.h>
 
#include <stdlib.h>
#include <dirent.h>
 
 
#include <fcntl.h>
 
#include <fcntl.h>
#include <assert.h>
 
 
#include <sys/mman.h>
 
#include <sys/mman.h>
#include <sys/types.h>
 
#include <sys/stat.h>
 
 
 
#include <unistd.h>
 
#include <unistd.h>
  
Line 243: Line 343:
  
 
int  mem_fd;
 
int  mem_fd;
char *gpio_mem, *gpio_map;
+
void *gpio_map;
char *spi0_mem, *spi0_map;
 
 
 
  
 
// I/O access
 
// I/O access
Line 258: Line 356:
 
#define GPIO_SET *(gpio+7)  // sets  bits which are 1 ignores bits which are 0
 
#define GPIO_SET *(gpio+7)  // sets  bits which are 1 ignores bits which are 0
 
#define GPIO_CLR *(gpio+10) // clears bits which are 1 ignores bits which are 0
 
#define GPIO_CLR *(gpio+10) // clears bits which are 1 ignores bits which are 0
 +
 +
#define GET_GPIO(g) (*(gpio+13)&(1<<g)) // 0 if LOW, (1<<g) if HIGH
 +
 +
#define GPIO_PULL *(gpio+37) // Pull up/pull down
 +
#define GPIO_PULLCLK0 *(gpio+38) // Pull up/pull down clock
  
 
void setup_io();
 
void setup_io();
 +
 +
void printButton(int g)
 +
{
 +
  if (GET_GPIO(g)) // !=0 <-> bit is 1 <- port is HIGH=3.3V
 +
    printf("Button pressed!\n");
 +
  else // port is LOW=0V
 +
    printf("Button released!\n");
 +
}
  
 
int main(int argc, char **argv)
 
int main(int argc, char **argv)
{  
+
{
 
   int g,rep;
 
   int g,rep;
  
Line 311: Line 422:
 
   if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
 
   if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
 
       printf("can't open /dev/mem \n");
 
       printf("can't open /dev/mem \n");
       exit (-1);
+
       exit(-1);
 
   }
 
   }
  
 
   /* mmap GPIO */
 
   /* mmap GPIO */
 +
  gpio_map = mmap(
 +
      NULL,            //Any adddress in our space will do
 +
      BLOCK_SIZE,      //Map length
 +
      PROT_READ|PROT_WRITE,// Enable reading & writting to mapped memory
 +
      MAP_SHARED,      //Shared with other processes
 +
      mem_fd,          //File to map
 +
      GPIO_BASE        //Offset to GPIO peripheral
 +
  );
  
   // Allocate MAP block
+
   close(mem_fd); //No need to keep mem_fd open after mmap
  if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE-1))) == NULL) {
 
      printf("allocation error \n");
 
      exit (-1);
 
  }
 
  
  // Make sure pointer is on 4K boundary
+
   if (gpio_map == MAP_FAILED) {
   if ((unsigned long)gpio_mem % PAGE_SIZE)
+
       printf("mmap error %d\n", (int)gpio_map);//errno also set!
    gpio_mem += PAGE_SIZE - ((unsigned long)gpio_mem % PAGE_SIZE);
+
       exit(-1);
 
 
  // Now map it
 
  gpio_map = (unsigned char *)mmap(
 
      (caddr_t)gpio_mem,
 
      BLOCK_SIZE,
 
      PROT_READ|PROT_WRITE,
 
      MAP_SHARED|MAP_FIXED,
 
      mem_fd,
 
      GPIO_BASE
 
  );
 
 
 
  if ((long)gpio_map < 0) {
 
       printf("mmap error %d\n", (int)gpio_map);
 
       exit (-1);
 
 
   }
 
   }
  
Line 347: Line 448:
 
} // setup_io
 
} // setup_io
  
</pre>
+
</source>
 +
 
 +
GPIO Pull Up/Pull Down Register Example
  
====GPIO Pull Up/Pull Down Register Example====
 
 
<pre>
 
<pre>
 
   // enable pull-up on GPIO24&25
 
   // enable pull-up on GPIO24&25
Line 361: Line 463:
 
</pre>
 
</pre>
  
====GPIO Driving Example (Python)====
+
==== wiringPi ====
This uses the Python module available at http://pypi.python.org/pypi/RPi.GPIO
+
Get and install wiringPi: https://projects.drogon.net/raspberry-pi/wiringpi/download-and-install/
Any Python script that controls GPIO must be run as root.
+
 
<pre>import RPi.GPIO as GPIO
+
Save this, and compile with:
 +
<pre>
 +
  gcc -o blink blink.c -lwiringPi
 +
</pre>
 +
and run with:
 +
<pre>
 +
  sudo ./blink
 +
</pre>
 +
 
 +
<source lang=c>
 +
/*
 +
* blink.c:
 +
*      blinks the first LED
 +
*      Gordon Henderson, projects@drogon.net
 +
*/
 +
 
 +
#include <stdio.h>
 +
#include <wiringPi.h>
 +
 
 +
int main (void)
 +
{
 +
  printf ("Raspberry Pi blink\n") ;
 +
 
 +
  if (wiringPiSetup () == -1)
 +
    return 1 ;
 +
 
 +
  pinMode (0, OUTPUT) ;        // aka BCM_GPIO pin 17
 +
 
 +
  for (;;)
 +
  {
 +
    digitalWrite (0, 1) ;      // On
 +
    delay (500) ;              // mS
 +
    digitalWrite (0, 0) ;      // Off
 +
    delay (500) ;
 +
  }
 +
  return 0 ;
 +
}
 +
</source>
 +
 
 +
==== sysfs ====
 +
 
 +
The following example requires no special libraries, it uses the available sysfs interface.
 +
 
 +
<source lang=c>
 +
/* blink.c
 +
*
 +
* Raspberry Pi GPIO example using sysfs interface.
 +
* Guillermo A. Amaral B. <g@maral.me>
 +
*
 +
* This file blinks GPIO 4 (P1-07) while reading GPIO 24 (P1_18).
 +
*/
 +
 
 +
#include <sys/stat.h>
 +
#include <sys/types.h>
 +
#include <fcntl.h>
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <unistd.h>
 +
 
 +
#define IN  0
 +
#define OUT 1
 +
 
 +
#define LOW  0
 +
#define HIGH 1
 +
 
 +
#define PIN  24 /* P1-18 */
 +
#define POUT 4  /* P1-07 */
 +
 
 +
static int
 +
GPIOExport(int pin)
 +
{
 +
#define BUFFER_MAX 3
 +
char buffer[BUFFER_MAX];
 +
ssize_t bytes_written;
 +
int fd;
 +
 
 +
fd = open("/sys/class/gpio/export", O_WRONLY);
 +
if (-1 == fd) {
 +
fprintf(stderr, "Failed to open export for writing!\n");
 +
return(-1);
 +
}
 +
 
 +
bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
 +
write(fd, buffer, bytes_written);
 +
close(fd);
 +
return(0);
 +
}
 +
 
 +
static int
 +
GPIOUnexport(int pin)
 +
{
 +
char buffer[BUFFER_MAX];
 +
ssize_t bytes_written;
 +
int fd;
 +
 
 +
fd = open("/sys/class/gpio/unexport", O_WRONLY);
 +
if (-1 == fd) {
 +
fprintf(stderr, "Failed to open unexport for writing!\n");
 +
return(-1);
 +
}
 +
 
 +
bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
 +
write(fd, buffer, bytes_written);
 +
close(fd);
 +
return(0);
 +
}
 +
 
 +
static int
 +
GPIODirection(int pin, int dir)
 +
{
 +
static const char s_directions_str[]  = "in\0out";
 +
 
 +
#define DIRECTION_MAX 35
 +
char path[DIRECTION_MAX];
 +
int fd;
 +
 
 +
snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/direction", pin);
 +
fd = open(path, O_WRONLY);
 +
if (-1 == fd) {
 +
fprintf(stderr, "Failed to open gpio direction for writing!\n");
 +
return(-1);
 +
}
 +
 
 +
if (-1 == write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3)) {
 +
fprintf(stderr, "Failed to set direction!\n");
 +
return(-1);
 +
}
 +
 
 +
close(fd);
 +
return(0);
 +
}
 +
 
 +
static int
 +
GPIORead(int pin)
 +
{
 +
#define VALUE_MAX 30
 +
char path[VALUE_MAX];
 +
char value_str[3];
 +
int fd;
 +
 
 +
snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
 +
fd = open(path, O_RDONLY);
 +
if (-1 == fd) {
 +
fprintf(stderr, "Failed to open gpio value for reading!\n");
 +
return(-1);
 +
}
 +
 
 +
if (-1 == read(fd, value_str, 3)) {
 +
fprintf(stderr, "Failed to read value!\n");
 +
return(-1);
 +
}
 +
 
 +
close(fd);
 +
 
 +
return(atoi(value_str));
 +
}
 +
 
 +
static int
 +
GPIOWrite(int pin, int value)
 +
{
 +
static const char s_values_str[] = "01";
 +
 
 +
char path[VALUE_MAX];
 +
int fd;
 +
 
 +
snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
 +
fd = open(path, O_WRONLY);
 +
if (-1 == fd) {
 +
fprintf(stderr, "Failed to open gpio value for writing!\n");
 +
return(-1);
 +
}
 +
 
 +
if (1 != write(fd, &s_values_str[LOW == value ? 0 : 1], 1)) {
 +
fprintf(stderr, "Failed to write value!\n");
 +
return(-1);
 +
}
 +
 
 +
close(fd);
 +
return(0);
 +
}
 +
 
 +
int
 +
main(int argc, char *argv[])
 +
{
 +
int repeat = 10;
 +
 
 +
/*
 +
* Enable GPIO pins
 +
*/
 +
if (-1 == GPIOExport(POUT) || -1 == GPIOExport(PIN))
 +
return(1);
 +
 
 +
/*
 +
* Set GPIO directions
 +
*/
 +
if (-1 == GPIODirection(POUT, OUT) || -1 == GPIODirection(PIN, IN))
 +
return(2);
 +
 
 +
do {
 +
/*
 +
* Write GPIO value
 +
*/
 +
if (-1 == GPIOWrite(POUT, repeat % 2))
 +
return(3);
 +
 
 +
/*
 +
* Read GPIO value
 +
*/
 +
printf("I'm reading %d in GPIO %d\n", GPIORead(PIN), PIN);
 +
 
 +
usleep(500 * 1000);
 +
}
 +
while (repeat--);
 +
 
 +
/*
 +
* Disable GPIO pins
 +
*/
 +
if (-1 == GPIOUnexport(POUT) || -1 == GPIOUnexport(PIN))
 +
return(4);
 +
 
 +
return(0);
 +
}
 +
</source>
 +
 
 +
==== bcm2835 ====
 +
This must be done as root. To change to the root user:
 +
<pre>sudo -i</pre>
 +
You must also get and install the bcm2835 library, which supports
 +
GPIO and SPI interfaces. Details and downloads
 +
from  http://www.open.com.au/mikem/bcm2835
 +
 
 +
<source lang=c>
 +
 
 +
// blink.c
 +
//
 +
// Example program for bcm2835 library
 +
// Blinks a pin on an off every 0.5 secs
 +
//
 +
// After installing bcm2835, you can build this
 +
// with something like:
 +
// gcc -o blink -l rt blink.c -l bcm2835
 +
// sudo ./blink
 +
//
 +
// Or you can test it before installing with:
 +
// gcc -o blink -l rt -I ../../src ../../src/bcm2835.c blink.c
 +
// sudo ./blink
 +
//
 +
// Author: Mike McCauley (mikem@open.com.au)
 +
// Copyright (C) 2011 Mike McCauley
 +
// $Id: RF22.h,v 1.21 2012/05/30 01:51:25 mikem Exp $
 +
 
 +
#include <bcm2835.h>
 +
 
 +
// Blinks on RPi pin GPIO 11
 +
#define PIN RPI_GPIO_P1_11
 +
 
 +
int main(int argc, char **argv)
 +
{
 +
    // If you call this, it will not actually access the GPIO
 +
    // Use for testing
 +
//    bcm2835_set_debug(1);
 +
 
 +
    if (!bcm2835_init())
 +
return 1;
 +
 
 +
    // Set the pin to be an output
 +
    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP);
 +
 
 +
    // Blink
 +
    while (1)
 +
    {
 +
// Turn it on
 +
bcm2835_gpio_write(PIN, HIGH);
 +
 +
// wait a bit
 +
delay(500);
 +
 +
// turn it off
 +
bcm2835_gpio_write(PIN, LOW);
 +
 +
// wait a bit
 +
delay(500);
 +
    }
 +
 
 +
    return 0;
 +
}
 +
</source>
 +
 
 +
==== pigpio ====
 +
pigpio provides all the standard gpio features.
 +
 
 +
In addition it provides hardware timed PWM suitable for servos, LEDs, and motors and samples/timestamps gpios 0-31 up to 1 million times per second (default 200 thousand).
 +
 
 +
C documentation: http://abyz.co.uk/rpi/pigpio/cif.html
 +
 
 +
Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html
 +
 
 +
<source lang=c>
 +
/*
 +
  pulse.c
 +
 
 +
  gcc -o pulse pulse.c -lpigpio -lrt -lpthread
 +
 
 +
  sudo ./pulse
 +
*/
 +
 
 +
#include <stdio.h>
 +
 
 +
#include <pigpio.h>
 +
 
 +
int main(int argc, char *argv[])
 +
{
 +
  double start;
 +
 
 +
  if (gpioInitialise() < 0)
 +
  {
 +
      fprintf(stderr, "pigpio initialisation failed\n");
 +
      return 1;
 +
  }
 +
 
 +
  /* set gpio modes */
 +
  gpioSetMode(4, PI_OUTPUT);
 +
  gpioSetMode(17, PI_OUTPUT);
 +
  gpioSetMode(18, PI_OUTPUT);
 +
  gpioSetMode(23, PI_INPUT);
 +
  gpioSetMode(24, PI_OUTPUT);
 +
 
 +
  /* start 1500 us servo pulses on gpio4 */
 +
  gpioServo(4, 1500);
 +
 
 +
  /* start 75% dutycycle PWM on gpio17 */
 +
  gpioPWM(17, 192); /* 192/255 = 75% */
 +
 
 +
  start = time_time();
 +
 
 +
  while ((time_time() - start) < 60.0)
 +
  {
 +
      gpioWrite(18, 1); /* on */
 +
 
 +
      time_sleep(0.5);
 +
 
 +
      gpioWrite(18, 0); /* off */
 +
 
 +
      time_sleep(0.5);
 +
 
 +
      /* mirror gpio24 from gpio23 */
 +
      gpioWrite(24, gpioRead(23));
 +
  }
 +
 
 +
  /* stop DMA, release resources */
 +
  gpioTerminate();
 +
 
 +
  return 0;
 +
}
 +
</source>
 +
 
 +
Compile
 +
<pre>
 +
gcc -o pulse pulse.c -lpigpio -lrt -lpthread
 +
</pre>
 +
 
 +
Run
 +
<pre>
 +
sudo ./pulse
 +
</pre>
 +
 
 +
==== C# ====
 +
RaspberryGPIOManager is a very basic C# library to control the GPIO pins via the GPIOPinDriver object.
 +
See: https://github.com/AlexSartori/RaspberryGPIOManager
 +
 
 +
<source lang=csharp>
 +
using RaspberryGPIOManager;
 +
 
 +
namespace GPIOtest
 +
{
 +
    class Program
 +
    {
 +
        static void Main(string[] args)
 +
        {
 +
            GPIOPinDriver led1;
 +
 
 +
            // Create the object.
 +
            led1 = new GPIOPinDriver(GPIOPinDriver.Pin.GPIO15);
 +
 
 +
            // Set it as an output pin.
 +
            led1.Direction = GPIOPinDriver.GPIODirection.Out
 +
 
 +
            // Give it power.
 +
            led1.State = GPIOPinDriver.GPIOState.High;
 +
        }
 +
    }
 +
}
 +
</source>
 +
 
 +
 
 +
RaspberryPiDotNet library is available at https://github.com/cypherkey/RaspberryPi.Net/.
 +
This more advanced library includes a GPIOFile and GPIOMem class. The GPIOMem requires compiling Mike McCauley's bcm2835 library above in to a shared object.
 +
 
 +
<source lang=csharp>
 +
using System;
 +
using System.Collections.Generic;
 +
using System.Linq;
 +
using System.Text;
 +
using RaspberryPiDotNet;
 +
using System.Threading;
 +
 
 +
namespace RaspPi
 +
{
 +
    class Program
 +
    {
 +
        static void Main(string[] args)
 +
        {
 +
            // Access the GPIO pin using a static method
 +
            GPIOFile.Write(GPIO.GPIOPins.GPIO00, true);
 +
 
 +
            // Create a new GPIO object
 +
            GPIOMem gpio = new GPIOMem(GPIO.GPIOPins.GPIO01);
 +
            gpio.Write(false);
 +
        }
 +
    }
 +
}
 +
</source>
 +
 
 +
=== Ruby ===
 +
 
 +
This example uses the WiringPi Ruby Gem: http://pi.gadgetoid.co.uk/post/015-wiringpi-now-with-serial which you can install on your Pi with "gem install wiringpi"
 +
 
 +
<source lang=ruby>
 +
MY_PIN = 1
 +
 
 +
require 'wiringpi'
 +
io = WiringPi::GPIO.new
 +
io.mode(MY_PIN,OUTPUT)
 +
io.write(MY_PIN,HIGH)
 +
io.read(MY_PIN)
 +
</source>
 +
 
 +
Alternatively the Pi Piper Gem (https://github.com/jwhitehorn/pi_piper) allows for event driven programming:
 +
 
 +
<source lang=ruby>
 +
require 'pi_piper'
 +
include PiPiper
 +
 
 +
watch :pin => 23 do
 +
  puts "Pin changed from #{last_value} to #{value}"
 +
end
 +
 
 +
PiPiper.wait
 +
</source>
 +
 
 +
 
 +
=== Perl ===
 +
This must be done as root. To change to the root user:
 +
<pre>sudo su -</pre>
 +
Supports GPIO and SPI interfaces.
 +
You must also get and install the bcm2835 library. Details and downloads
 +
from  http://www.open.com.au/mikem/bcm2835
 +
You must then get and install the Device::BCM2835 perl library from CPAN
 +
http://search.cpan.org/~mikem/Device-BCM2835-1.0/lib/Device/BCM2835.pm
 +
<source lang=perl>
 +
use Device::BCM2835;
 +
use strict;
 +
 
 +
# call set_debug(1) to do a non-destructive test on non-RPi hardware
 +
#Device::BCM2835::set_debug(1);
 +
Device::BCM2835::init()
 +
|| die "Could not init library";
 +
 
 +
# Blink pin 11:
 +
# Set RPi pin 11 to be an output
 +
Device::BCM2835::gpio_fsel(&Device::BCM2835::RPI_GPIO_P1_11,
 +
                            &Device::BCM2835::BCM2835_GPIO_FSEL_OUTP);
 +
 
 +
while (1)
 +
{
 +
    # Turn it on
 +
    Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 1);
 +
    Device::BCM2835::delay(500); # Milliseconds
 +
    # Turn it off
 +
    Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 0);
 +
    Device::BCM2835::delay(500); # Milliseconds
 +
}
 +
 
 +
 
 +
</source>
 +
 
 +
=== Python ===
 +
==== RPi.GPIO ====
 +
The RPi.GPIO module is installed by default in Raspbian.
 +
Any RPi.GPIO script must be run as root.
 +
<source lang=python>import RPi.GPIO as GPIO
 +
 
 +
# use P1 header pin numbering convention
 +
GPIO.setmode(GPIO.BOARD)
  
 
# Set up the GPIO channels - one input and one output
 
# Set up the GPIO channels - one input and one output
Line 374: Line 969:
  
 
# Output to pin 12
 
# Output to pin 12
GPIO.output(12, True)
+
GPIO.output(12, GPIO.HIGH)
  
 
# The same script as above but using BCM GPIO 00..nn numbers
 
# The same script as above but using BCM GPIO 00..nn numbers
Line 381: Line 976:
 
GPIO.setup(18, GPIO.OUT)
 
GPIO.setup(18, GPIO.OUT)
 
input_value = GPIO.input(17)
 
input_value = GPIO.input(17)
GPIO.output(18, True)</pre>
+
GPIO.output(18, GPIO.HIGH)</source>
 +
 
 +
More documentation is available at http://sourceforge.net/p/raspberry-gpio-python/wiki/Home/
 +
 
 +
==== pigpio ====
 +
 
 +
pigpio Python scripts may be run on Windows, Macs, and Linux machines.  Only the pigpio daemon needs to be running on the Pi.
 +
 
 +
pigpio provides all the standard gpio features.
 +
 
 +
In addition it provides hardware timed PWM suitable for servos, LEDs, and motors and samples/timestamps gpios 0-31 up to 1 million times per second (default 200 thousand).
 +
 
 +
Python documentation: http://abyz.co.uk/rpi/pigpio/python.html
 +
 
 +
Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html
 +
 
 +
<source lang=python>
 +
#!/usr/bin/env python
 +
 
 +
# pulse.py
 +
 
 +
import time
 +
 
 +
import pigpio
 +
 
 +
pi = pigpio.pi() # Connect to local Pi.
 +
 
 +
# set gpio modes
 +
 
 +
pi.set_mode(4, pigpio.OUTPUT)
 +
pi.set_mode(17, pigpio.OUTPUT)
 +
pi.set_mode(18, pigpio.OUTPUT)
 +
pi.set_mode(23, pigpio.INPUT)
 +
pi.set_mode(24, pigpio.OUTPUT)
 +
 
 +
 
 +
# start 1500 us servo pulses on gpio4
 +
 
 +
pi.set_servo_pulsewidth(4, 1500)
 +
 
 +
# start 75% dutycycle PWM on gpio17
 +
 
 +
pi.set_PWM_dutycycle(17, 192) # 192/255 = 75%
 +
 
 +
start = time.time()
 +
 
 +
while (time.time() - start) < 60.0:
 +
 
 +
      pi.write(18, 1) # on
 +
 
 +
      time.sleep(0.5)
 +
 
 +
      pi.write(18, 0) # off
 +
 
 +
      time.sleep(0.5)
 +
 
 +
      # mirror gpio24 from gpio23
 +
 
 +
      pi.write(24, pi.read(23))
 +
 
 +
pi.set_servo_pulsewidth(4, 0) # stop servo pulses
 +
 
 +
pi.set_PWM_dutycycle(17, 0) # stop PWM
 +
 
 +
pi.stop() # terminate connection and release resources
 +
</source>
 +
pigpio scripts require that the pigpio daemon be running.
 +
 
 +
<pre>
 +
sudo pigpiod
 +
</pre>
 +
 
 +
They do not need to be run as root.
 +
<pre>
 +
./pulse.py
 +
</pre>
 +
 
 +
==== RPIO ====
 +
Also available is RPIO at https://pypi.python.org/pypi/RPIO
 +
 
 +
RPIO extends RPi.GPIO with TCP socket interrupts, command line tools and more.
 +
 
 +
=== Scratch===
 +
==== Scratch using the ScratchGPIO  ====
 +
[[File:Blink11.gif|left]]Scratch can be used to control the GPIO pins using a background Python handler available from
 +
http://cymplecy.wordpress.com/2013/04/22/scratch-gpio-version-2-introduction-for-beginners/
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
  
====GPIO Driving Example (Java)====
+
 
This uses the Java library available at http://code.google.com/p/rpi-gpio-java/. Any Java application that controls GPIO must be run as root.
+
 
 +
 
 +
==== Pridopia Scratch Rs-Pi-GPIO driver ====
 +
[[File:pridopia-demo01.jpg|left]]Scratch control GPIO (use GPIO number not P1 pin number can support GPIO 28,29,30,31)
 +
support I²C 23017 8/16/32/64/128 GPIO, I²C TMP102 Temp sensor, I²C RTC DS1307, I²C ADC ADS1015, I²C PWM, I²C EEPROM 24c32, I²C BMP085  Barometric Pressure/Temperature/Altitude Sensor, GPIO input/output, DC motor, Relay, I²C 16x16 LED matrix, I²C 24x16 Matrix, 84x48 pixels LCD, 16x2 character LCD, 20x4 character LCD, 1-Wire 18B20 Temp Sensor, Ultra Sonic distance sensor, available from
 +
 
 +
http://www.pridopia.co.uk/rs-pi-set-scratch.html
 +
 
 +
==== RpiScratchIO ====
 +
Generic interface for GPIO or other I/O operations. The package allows user modules to be easily added and loaded, to interface with any I/O device. The code is written in Python and uses the scratchpy Python package to interface with Scratch.
 +
 
 +
[[File:RpiScratchIO.png|frameless|left|RpiScratchIO based BrickPi driver]]
 +
 
 +
===== RpiScratchIO - Installation =====
 +
To install the package on the latest Raspbian installation type,
 
<pre>
 
<pre>
 +
sudo apt-get install -y python-setuptools python-dev
 +
sudo easy_install pip
 +
sudo pip install RpiScratchIO
 +
</pre>
 +
 +
===== RpiScratchIO - Documentation and examples =====
 +
More information can be found at
 +
https://pypi.python.org/pypi/RpiScratchIO/
 +
The package is also documented in Issues [http://www.themagpi.com/issue/issue-20/ 20] and [http://www.themagpi.com/issue/issue-22/ 22] of [http://www.themagpi.com/ The MagPi].  RpiScratchIO is the basis of a new [https://pypi.python.org/pypi/BrickPi/ BrickPi Scratch handler], which is documented in Issue [http://www.themagpi.com/issue/issue-23/ 23] of The MagPi.
 +
 +
 +
<br style="clear: both" />
 +
 +
=== Java ===
 +
==== Java using the Pi4J Library ====
 +
This uses the Java library available at http://www.pi4j.com/.
 +
(Any Java application that controls GPIO must be run as root.)
 +
 +
Please note that the Pi4J library uses the WiringPi GPIO pin numbering scheme <ref>http://pi4j.com/usage.html#Pin_Numbering</ref> <ref>https://projects.drogon.net/raspberry-pi/wiringpi/pins/</ref>.  Please see the usage documentation for more details: http://pi4j.com/usage.html 
 +
 +
<source lang=java>
  
 
public static void main(String[] args) {
 
public static void main(String[] args) {
  GpioGateway gpio = new GpioGatewayImpl();
 
  
  //set up the GPIO channels - one input and one output
+
    // create gpio controller
  gpio.setup(Boardpin.PIN11_GPIO17, Direction.IN);
+
    GpioController gpio = GpioFactory.getInstance();
  gpio.setup(Boardpin.PIN12_GPIO18, Direction.OUT);
+
       
 +
    // provision gpio pin #01 as an output pin and turn off
 +
    GpioPinDigitalOutput outputPin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLED", PinState.LOW);
 +
   
 +
    // turn output to LOW/OFF state
 +
    outputPin.low();
 +
 
 +
    // turn output to HIGH/ON state
 +
    outputPin.high();
 +
 
 +
 
 +
    // provision gpio pin #02 as an input pin with its internal pull down resistor enabled
 +
    GpioPinDigitalInput inputPin = gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, "MyButton", PinPullResistance.PULL_DOWN);
 +
 
 +
    // get input state from pin 2
 +
    boolean input_value = inputPin.isHigh();
 +
}
 +
</source>
  
  // input from pin 11
+
More complete and detailed examples are included on the Pi4J website at http://www.pi4j.com/.  
  boolean input_value = gpio.getValue(Boardpin.PIN11_GPIO17);
 
  
  // output to pin 12
+
The Pi4J library includes support for:
  gpio.setValue(Boardpin.PIN12_GPIO18, true);              
+
* GPIO Control
 +
* GPIO Listeners
 +
* Serial Communication
 +
* I2C Communication
 +
* SPI Communication
 +
 
 +
==== Java ====
 +
This uses the Java library available at https://github.com/jkransen/framboos. It does not depend on (or use) the wiringPi driver, but uses the same numbering scheme. Instead it uses the default driver under /sys/class/gpio that ships with the distro, so it works out of the box. Any Java application that controls GPIO must be run as root.
 +
<source lang=java>
 +
public static void main(String[] args) {
 +
  // reading from an in pin
 +
  InPin button = new InPin(8);
 +
  boolean isButtonPressed = button.getValue();
 +
  button.close();
 +
 
 +
  // writing to an out pin
 +
  OutPin led = new Outpin(0);
 +
  led.setValue(true);
 +
  led.setValue(false);
 +
  led.close();
 
}
 
}
</pre>
+
</source>
  
====GPIO Driving Example (Java webapp via http)====
+
==== Java Webapp GPIO web control via HTTP ====
This uses the Java webapp available at https://bitbucket.org/sbub/rpi-gpio-webapp. Any Java application that controls GPIO must be run as root.
+
This uses the Java Webapp available at https://bitbucket.org/sbub/raspberry-pi-gpio-web-control/overview. You can control your GPIO over the Internet. Any Java application that controls GPIO must be run as root.
 
<pre>
 
<pre>
  
Line 411: Line 1,166:
 
</pre>
 
</pre>
  
====GPIO Driving Example (Shell script)====
+
=== Shell ===
This must be done as root. To change to the root user:
+
==== sysfs, part of the raspbian operating system ====
 +
The export and unexport of pins must be done as root.  
 +
To change to the root user see below: To change back, the word exit must be entered.
 
<pre>sudo -i</pre>
 
<pre>sudo -i</pre>
<pre>
+
Export creates a new folder for the exported pin, and creates files for each of its control functions (i.e. active_low, direction, edge, power, subsystem, uevent, and value). Upon creation, the control files can be read by all users (not just root), but can only be written to by user root, the file's owner. Nevertheless, once created, it is possible to allow users other than root, to also write inputs to the control files, by changing the ownership or permissions of these files. Changes to the file's ownership or permissions must initially be done as root, as their owner and group is set to root upon creation. Typically you might change the owner to be the (non root) user controlling the GPIO, or you might add write permission, and change the group ownership to one of which the user controlling the GPIO is a member. By such means, using only packages provided in the recommended rasbian distribution, it is possible for Python CGI scripts, which are typically run as user nobody, to be used for control of the GPIO over the internet from a browser at a remote location.
 +
<source lang=bash>
 
#!/bin/sh
 
#!/bin/sh
  
Line 443: Line 1,201:
 
echo "4" > /sys/class/gpio/unexport
 
echo "4" > /sys/class/gpio/unexport
 
echo "7" > /sys/class/gpio/unexport
 
echo "7" > /sys/class/gpio/unexport
</pre>
+
</source>
  
====GPIO Driving Example (Shell script - take 2)====
+
==== wiringPi - gpio utility ====
 
You need the wiringPi library from
 
You need the wiringPi library from
https://projects.drogon.net/raspberry-pi/wiringpi/download-and-install/
+
https://projects.drogon.net/raspberry-pi/wiringpi/download-and-install/. Once installed, there is a new command '''gpio''' which can be used
once installed there is a new command '''gpio''' which can be used
 
 
as a '''non-root''' user to control the GPIO pins.
 
as a '''non-root''' user to control the GPIO pins.
  
Line 461: Line 1,218:
 
</pre>
 
</pre>
  
the '''-g''' flag tells the '''gpio''' program to use the BCM GPIO pin numbering
+
The '''-g''' flag tells the '''gpio''' program to use the BCM GPIO pin numbering
scheme (otherwise it will use the wiringPi numbering scheme by default)
+
scheme (otherwise it will use the wiringPi numbering scheme by default).
  
 
The gpio command can also control the internal pull-up and pull-down
 
The gpio command can also control the internal pull-up and pull-down
Line 471: Line 1,228:
 
</pre>
 
</pre>
  
This sets the pull-up ressitor - however any change of mode, even
+
This sets the pull-up resistor - however any change of mode, even
 
setting a pin that's already set as an input to an input will remove
 
setting a pin that's already set as an input to an input will remove
 
the pull-up/pull-down resistors, so they may need to be reset.
 
the pull-up/pull-down resistors, so they may need to be reset.
Line 489: Line 1,246:
 
and sets it to input.  
 
and sets it to input.  
  
and when done:
+
And when done:
  
 
<pre>
 
<pre>
Line 507: Line 1,264:
  
 
You can then use GPIO-4 as an input in your Python, Shell, Java, etc. programs without the use
 
You can then use GPIO-4 as an input in your Python, Shell, Java, etc. programs without the use
of an external resistor to pull the pin high. (If that's what you were after - e.g. a simple push
+
of an external resistor to pull the pin high. (If that's what you were after - for example, a simple push
button switch taking the pin to ground)
+
button switch taking the pin to ground.)
  
 
A fully working example of a shell script using the GPIO pins
 
A fully working example of a shell script using the GPIO pins
can be found here:
+
can be found at http://project-downloads.drogon.net/files/gpioExamples/tuxx.sh.
http://project-downloads.drogon.net/files/gpioExamples/tuxx.sh
 
  
====GPIO Driving Example (C)====
+
==== pigpio - pigs utility ====
This must be done as root. To change to the root user:
+
 
<pre>sudo -i</pre>
+
pigpio provides a command line utility pigs.
You must also get and install the bcm2835 library, which supports
+
 
GPIO and SPI interfaces. Details and downloads
+
pigs provides all the standard gpio features.
from  http://www.open.com.au/mikem/bcm2835
+
 
 +
In addition it provides hardware timed PWM suitable for servos, LEDs, and motors.
 +
 
 +
Use man pigs or view the pigs documentation at http://abyz.co.uk/rpi/pigpio/pigs.html
 +
 
 +
Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html
  
 +
Additional error information may be reported to /dev/pigerr.  The following command will display any errors.
 
<pre>
 
<pre>
 +
cat /dev/pigerr &
 +
</pre>
 +
Examples
 +
<pre>
 +
pigs modes 4 w # set gpio4 as output (write)
 +
pigs modes 17 w # set gpio17 as output (write)
 +
pigs modes 23 r # set gpio23 as input (read)
 +
pigs modes 24 0 # set gpio24 as ALT0
  
// blink.c
+
pigs servo 4 1500 # start 1500 us servo pulses on gpio4
//
+
 
// Example program for bcm2835 library
+
pigs pwm 17 192 # start 75% dutycycle PWM on gpio17 (192/255 = 75%)
// Blinks a pin on an off every 0.5 secs
 
//
 
// After installing bcm2835, you can build this
 
// with something like:
 
// gcc -o blink blink.c -l bcm2835
 
// sudo ./blink
 
//
 
// Or you can test it before installing with:
 
// gcc -o blink -I ../../src ../../src/bcm2835.c blink.c
 
// sudo ./blink
 
//
 
// Author: Mike McCauley (mikem@open.com.au)
 
// Copyright (C) 2011 Mike McCauley
 
// $Id: RF22.h,v 1.21 2012/05/30 01:51:25 mikem Exp $
 
  
#include <bcm2835.h>
+
pigs r 23 # read gpio23
  
// Blinks on RPi pin GPIO 11
+
pigs w 24 1 # write 1 to gpio 24
#define PIN RPI_GPIO_P1_11
 
  
int main(int argc, char **argv)
+
# servo may be abbreviated to s
{
+
# pwm may be abbreviated to p
    // If you call this, it will not actually access the GPIO
+
# modes may be abbreviated to m
    // Use for testing
 
//    bcm2835_set_debug(1);
 
  
    if (!bcm2835_init())
+
pigs s 4 0 # stop servo pulses
return 1;
 
  
    // Set the pin to be an output
+
pigs p 17 0 # stop pwm
    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP);
+
</pre>
  
    // Blink
+
pigs requires that the pigpio daemon be running.
    while (1)
 
    {
 
// Turn it on
 
bcm2835_gpio_write(PIN, HIGH);
 
 
// wait a bit
 
delay(500);
 
 
// turn it off
 
bcm2835_gpio_write(PIN, LOW);
 
 
// wait a bit
 
delay(500);
 
    }
 
  
    return 0;
+
<pre>
}
+
sudo pigpiod
 
</pre>
 
</pre>
  
====GPIO Driving Example (Perl)====
+
For an example pigs script see x_pigs in the pigpio archive.
This must be done as root. To change to the root user:
+
 
<pre>sudo su -</pre>
+
==== pigpio - /dev/pigpio interface ====
Supports GPIO and SPI interfaces.
+
 
You must also get and install the bcm2835 library. Details and downloads
+
pigpio provides command line access via the /dev/pigpio pipe.
from http://www.open.com.au/mikem/bcm2835
+
 
You must then get and install the Device::BCM2835 perl library from CPAN
+
/dev/pigpio provides all the standard gpio features.
http://search.cpan.org/~mikem/Device-BCM2835-1.0/lib/Device/BCM2835.pm
+
 
 +
In addition it provides hardware timed PWM suitable for servos, LEDs, and motors.
 +
 
 +
The command set is identical to that used by pigsUse man pigs or view the pigs documentation at http://abyz.co.uk/rpi/pigpio/pigs.html
 +
 
 +
Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html
 +
 
 +
The result of /dev/pigpio commands are written to /dev/pigout. The following command will display the results.
 +
<pre>
 +
cat /dev/pigout &
 +
</pre>
 +
Errors are reported to /dev/pigerr.  The following command will display any errors.
 +
<pre>
 +
cat /dev/pigerr &
 +
</pre>
 +
Examples
 
<pre>
 
<pre>
use Device::BCM2835;
+
echo modes 4 w >/dev/pigpio # set gpio4 as output (write)
use strict;
+
echo modes 17 w  >/dev/pigpio # set gpio17 as output (write)
 +
echo modes 23 r  >/dev/pigpio # set gpio23 as input (read)
 +
echo modes 24 0  >/dev/pigpio # set gpio24 as ALT0
 +
 
 +
echo servo 4 1500  >/dev/pigpio # start 1500 us servo pulses on gpio4
 +
 
 +
echo pwm 17 192  >/dev/pigpio # start 75% dutycycle PWM on gpio17 (192/255 = 75%)
 +
 
 +
echo r 23  >/dev/pigpio # read gpio23
 +
 
 +
echo w 24 1  >/dev/pigpio # write 1 to gpio 24
  
# call set_debug(1) to do a non-destructive test on non-RPi hardware
+
# servo may be abbreviated to s
#Device::BCM2835::set_debug(1);
+
# pwm may be abbreviated to p
Device::BCM2835::init()
+
# modes may be abbreviated to m
|| die "Could not init library";
 
  
# Blink pin 11:
+
echo s 4 0  >/dev/pigpio # stop servo pulses
# Set RPi pin 11 to be an output
 
Device::BCM2835::gpio_fsel(&Device::BCM2835::RPI_GPIO_P1_11,
 
                            &Device::BCM2835::BCM2835_GPIO_FSEL_OUTP);
 
  
while (1)
+
echo p 17 0 >/dev/pigpio # stop pwm
{
+
</pre>
    # Turn it on
 
    Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 1);
 
    Device::BCM2835::delay(500); # Milliseconds
 
    # Turn it off
 
    Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 0);
 
    Device::BCM2835::delay(500); # Milliseconds
 
}
 
  
 +
The /dev/pigpio pipe interface requires that the pigpio daemon be running.
  
 +
<pre>
 +
sudo pigpiod
 
</pre>
 
</pre>
  
 +
For an example /dev/pigpio pipe script see x_pipe in the pigpio archive.
 +
 +
=== Lazarus / Free Pascal ===
 +
[[File:RPI GPIO testprogram with lazarus.png|thumb|254px|right|A simple app for controlling GPIO pin 17 with Lazarus]]
 +
 +
The GPIO pins are accessible from [[Lazarus on RPi|Lazarus]] without any third-party software. This is performed by means of  the [http://www.freepascal.org/docs-html/rtl/baseunix/index.html BaseUnix] unit that is part of every distribution of Lazarus and Free Pascal or by invoking Unix shell commands with '''fpsystem'''. The following example uses GPIO pin 17 as output port. It is assumed that you created a form named GPIO17ToggleBox with a TToggleBox and a TMemo named LogMemo (optional, for logging purposes). The program has to be executed with root privileges.
 +
 +
''Unit for controlling the GPIO port:''
 +
<pre>
 +
unit Unit1;
 +
 +
{Demo application for GPIO on Raspberry Pi}
 +
{Inspired by the Python input/output demo application by Gareth Halfacree}
 +
{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
 +
 +
{$mode objfpc}{$H+}
 +
 +
interface
 +
 +
uses
 +
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics,
 +
  Dialogs, StdCtrls, Unix, BaseUnix;
 +
 +
type
 +
 +
  { TForm1 }
 +
 +
  TForm1 = class(TForm)
 +
    LogMemo: TMemo;
 +
    GPIO17ToggleBox: TToggleBox;
 +
    procedure FormActivate(Sender: TObject);
 +
    procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
 +
    procedure GPIO17ToggleBoxChange(Sender: TObject);
 +
  private
 +
    { private declarations }
 +
  public
 +
    { public declarations }
 +
  end;
 +
 +
const
 +
  PIN_17: PChar = '17';
 +
  PIN_ON: PChar = '1';
 +
  PIN_OFF: PChar = '0';
 +
  OUT_DIRECTION: PChar = 'out';
 +
 +
var
 +
  Form1: TForm1;
 +
  gReturnCode: longint; {stores the result of the IO operation}
 +
 +
implementation
  
==== GPIO Driving Example (C#) ====
+
{$R *.lfm}
RaspberryPiDotNet library is available at https://github.com/cypherkey/RaspberryPi.Net/.
+
 
The library includes a GPIOFile and GPIOMem class. The GPIOMem requires compiling Mike McCauley's bcm2835 library above in to a shared object.
+
{ TForm1 }
 +
 
 +
procedure TForm1.FormActivate(Sender: TObject);
 +
var
 +
  fileDesc: integer;
 +
begin
 +
  { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
 +
  try
 +
    fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
 +
    gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
 +
    LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
  finally
 +
    gReturnCode := fpclose(fileDesc);
 +
    LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
  end;
 +
  { Set SoC pin 17 as output: }
 +
  try
 +
    fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
 +
    gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
 +
    LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
  finally
 +
    gReturnCode := fpclose(fileDesc);
 +
    LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
  end;
 +
end;
 +
 
 +
procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
 +
var
 +
  fileDesc: integer;
 +
begin
 +
  { Free SoC pin 17: }
 +
  try
 +
    fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
 +
    gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
 +
    LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
  finally
 +
    gReturnCode := fpclose(fileDesc);
 +
    LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
  end;
 +
end;
 +
 
 +
procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
 +
var
 +
  fileDesc: integer;
 +
begin
 +
  if GPIO17ToggleBox.Checked then
 +
  begin
 +
    { Swith SoC pin 17 on: }
 +
    try
 +
      fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
 +
      gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
 +
      LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
    finally
 +
      gReturnCode := fpclose(fileDesc);
 +
      LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
    end;
 +
  end
 +
  else
 +
  begin
 +
    { Switch SoC pin 17 off: }
 +
    try
 +
      fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
 +
      gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
 +
      LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
    finally
 +
      gReturnCode := fpclose(fileDesc);
 +
      LogMemo.Lines.Add(IntToStr(gReturnCode));
 +
    end;
 +
  end;
 +
end;
 +
 
 +
end.
 +
</pre>
  
 +
''Main program:''
 
<pre>
 
<pre>
using System;
+
program io_test;
using System.Collections.Generic;
+
 
using System.Linq;
+
{$mode objfpc}{$H+}
using System.Text;
+
 
using RaspberryPiDotNet;
+
uses
using System.Threading;
+
  {$IFDEF UNIX}{$IFDEF UseCThreads}
 +
  cthreads,
 +
  {$ENDIF}{$ENDIF}
 +
  Interfaces, // this includes the LCL widgetset
 +
  Forms, Unit1
 +
  { you can add units after this };
  
namespace RaspPi
+
{$R *.res}
{
 
    class Program
 
    {
 
        static void Main(string[] args)
 
        {
 
            // Access the GPIO pin using a static method
 
            GPIOFile.Write(GPIO.GPIOPins.GPIO00, true);
 
  
            // Create a new GPIO object
+
begin
            GPIOMem gpio = new GPIOMem(GPIO.GPIOPins.GPIO01);
+
  Application.Initialize;
            gpio.Write(false);
+
  Application.CreateForm(TForm1, Form1);
        }
+
  Application.Run;
    }
+
end.
}
 
 
</pre>
 
</pre>
  
 +
Alternative way to access the GPIO port with Lazarus / Free Pascal is by using [http://www.lazarus.freepascal.org/index.php/topic,17404.0.html Lazarus wrapper unit for Gordon Henderson's wiringPi C library] or [http://wiki.lazarus.freepascal.org/Lazarus_on_Raspberry_Pi#2._Hardware_access_via_encapsulated_shell_calls encapsulated shell calls].
  
====GPIO Driving Example (Ruby)====
+
The [http://wiki.freepascal.org/Lazarus_on_Raspberry_Pi Lazarus wiki] describes a [http://wiki.freepascal.org/Lazarus_on_Raspberry_Pi#Reading_the_status_of_a_pin demo program] that can read the status of a GPIO pin.
  
This example uses the WiringPi Ruby Gem: http://pi.gadgetoid.co.uk/post/015-wiringpi-now-with-serial which you can install on your Pi with "gem install wiringpi"
+
=== BASIC ===
 +
==== BASIC - Return to BASIC ====
 +
'Return to Basic' (RTB) can be found [https://projects.drogon.net/rtb/ here].
 +
 
 +
It is a new BASIC featuring modern looping constructs, switch statements, named procedures and functions as well as graphics (Cartesian and turtle), file handling and more. It also supports the Pi's on-board GPIO without needing to be run as root. (You do not need any special setup routines either)
  
 +
Sample blink program:
 
<pre>
 
<pre>
MY_PIN = 1
+
// blink.rtb:
 +
//    Blink program in Return to Basic
 +
//    Gordon Henderson, projects@drogon.net
 +
//
 +
PinMode (0, 1) // Output
 +
CYCLE
 +
  DigitalWrite (0, 1) // Pin 0 ON
 +
  WAIT (0.5) // 0.5 seconds
 +
  DigitalWrite (0, 0)
 +
  WAIT (0.5)
 +
REPEAT
 +
END
 +
</pre>
 +
 
 +
==== BASIC ====
 +
=====Bywater BASIC Interpreter=====
 +
The Bywater BASIC Interpreter (bwBASIC) implements a large superset of the ANSI Standard for Minimal BASIC (X3.60-1978) and a significant subset of the ANSI Standard for Full BASIC (X3.113-1987) in C. It also offers shell programming facilities as an extension of BASIC. bwBASIC seeks to be as portable as possible and is downloadable.<ref>[http://packages.debian.org/stable/interpreters/bwbasic packages.debian.org]</ref>
 +
 
 +
======BASIC programming of the I/O======
 +
Setting up a GPIO pin to be used for inputs or for outputs.
 +
 
 +
The control words cannot be loaded directly into the 32 bit ARM registers with 32 bit addresses, as bwBASIC has no POKE and PEEK commands and other versions of BASIC only handle 8 bit registers with 16 bit addresses with these commands. So the GPIO pins need to be exported so that they exist in a file structure which can be accessed from basic with the OPEN command (ref 2).
  
require 'wiringpi'
+
This must be done in Linux root. BASIC must be run in the root too.  
io = WiringPi::GPIO.new
+
<pre>
io.mode(MY_PIN,OUTPUT)
+
sudo -1
io.write(MY_PIN,HIGH)
+
sudo bwbasic
io.read(MY_PIN)
 
 
</pre>
 
</pre>
  
==MIPI CSI-2==
+
Now to export GPIO pin 4 for example, using a Shell command.
 +
<pre>echo "4" >  /sys/class/gpio/export</pre>
 +
 
 +
Whilst bwbasic can accommodate shell commands, and we can store a set of these commands (eg. to export a number of GPIO pins at the outset) as numbered statements in a file that can be loaded with the basic command LOAD "filename" and RUN (ref 2), the shell commands have to run as a separate file, as they cannot be run from within, as part of a basic program.
 +
 
 +
Now the file containing the pin direction setting from BASIC can be accessed.
 +
 
 +
GPIO pin 4 can be set to input or output by OPENing its pin direction file for output and writing "in" or "out" with a PRINT# command.<ref>Ed Beynon, [http://www.ybw.com/forums/showthread.php?t=331320&page=5 ybw.com]</ref>
 +
<syntaxhighlight lang="basic4gl">
 +
10 OPEN O",#1, "/sys/devices/virtual/gpio/gpio4/direction",2
 +
20 PRINT #1,"out"
 +
30 CLOSE #1
 +
</syntaxhighlight>
 +
 
 +
This closes the open direction file, whereupon the system performs the action of setting the direction to "out". The system only carries out the action as the file is closed.<ref>Arthur Kaletzky. Private communication. 25/10/2012</ref>
 +
 
 +
Now the output of the gpio 4 pin can be controlled from BASIC.
 +
 
 +
GPIO 4 pin can be set to 1 or to 0 by OPENing its pin value file for output and writing "1" or "0" with a PRINT# command.
 +
<syntaxhighlight lang="basic4gl">
 +
40 OPEN "O",#4, "/sys/devices/virtual/gpio/gpio4/value",1
 +
50 PRINT #4,"1"
 +
60 CLOSE #4
 +
</syntaxhighlight>
 +
Similarly the output of GPIO pin 4 can be turned off.
 +
<syntaxhighlight lang="basic4gl">OPEN ”O”,#4, “/sys/devices/virtual/gpio/gpio4/value”,1
 +
PRINT #4,”0”
 +
CLOSE #4.
 +
</syntaxhighlight>
 +
 
 +
======Example of an (unstructured) BASIC program======
 +
To read the state of a switch and control the power to two LEDs connected to GPIO pins 8,7 and 4 respectively.
 +
 
 +
Program to set 2 pins as outputs and 1 pin as input and to read the input turning on two different combinations of the two outputs (ie output 0,1 or 1,0) depending on the state of the input (1 or 0).
 +
<syntaxhighlight lang="basic4gl">
 +
sudo –i
 +
sudo bwbasic
 +
LOAD “export.bas”
 +
LIST
 +
REM a set of Shell statements to export the three GPIO pins.
 +
10 echo “4” > /sys/class/gpio/export
 +
20 echo “7” > /sys/class/gpio/export
 +
30 echo “8” > /sys/class/gpio/export
 +
RUN
 +
</syntaxhighlight>
 +
 
 +
NEW clears the export.bas program from memory
 +
<syntaxhighlight lang="basic4gl">
 +
LOAD “demo1.bas”
 +
LIST
 +
10 OPEN ”O”,#1, “/sys/devices/virtual/gpio/gpio4/direction”,2
 +
20 OPEN ”O”,#2, “/sys/devices/virtual/gpio/gpio7/direction”,2
 +
30 OPEN ”O”,#3, “/sys/devices/virtual/gpio/gpio8/direction”,2
 +
REM opens the three pin direction files
 +
40 PRINT #1, “out”
 +
50 PRINT #2, “out”
 +
60 PRINT #3, “in”
 +
REM sets GPIO pins 4 and 7 as outputs and GPIO pin 8 as input.
 +
70 CLOSE #1
 +
80 CLOSE #2
 +
90 CLOSE #3
 +
REM closes all open files, allowing the system to perform the direction settings.
 +
100 OPEN ”I”,#8, “/sys/devices/virtual/gpio/gpio8/value”,1
 +
REM opens the GPIO pin 8 value file
 +
110 INPUT #8,x
 +
REM reads the value of the input pin and stores the value in numerical variable x
 +
120 CLOSE #8
 +
REM closes the open file, allowing the system to read the value of the input pin and store the value in numerical variable x.
 +
130 OPEN “O”,#1, “/sys/devices/virtual/gpio/gpio4/value”,1
 +
140 OPEN “O”,#2, “/sys/devices/virtual/gpio/gpio7/value”,1
 +
REM opens the GPIO pins 4 and value files ready for outputting 1s and 0s.
 +
150 IF x<1 THEN GOTO 160 ELSE GOTO 190
 +
REM tests the state of the switch (1 or0) and directs the program to generate the appropriate outputs
 +
160 PRINT #1,”1”
 +
170 PRINT #2,”0”
 +
180 GOTO 210
 +
190  PRINT#1,"0"
 +
200 PRINT #2,"1"
 +
210 CLOSE #1
 +
220 CLOSE #2
 +
REM Closes the files and allows the outputs to light the LED
 +
230 END.
 +
</syntaxhighlight>
 +
 
 +
When all is done, the GPIO pins should be unexported, to leave the R-Pi as we found it.<ref>This paper RPi Low-level peripherals.</ref>
 +
<syntaxhighlight lang="basic4gl">
 +
NEW
 +
LOAD “unexport.bas”
 +
LIST
 +
REM a set of Shell statements to unexport the three GPIO pins.
 +
10 echo “4” > /sys/class/gpio/unexport
 +
20 echo “7” > /sys/class/gpio/unexport
 +
30 echo “8” > /sys/class/gpio/unexport
 +
RUN
 +
</syntaxhighlight>
 +
A simple circuit to provide the switched input and the two LED outputs.<ref>Ancient Mariner. Dec. 2012</ref>
 +
 
 +
For the two original documents this example has been copied from, see:
 +
# [[Media:GPIO_Driving_Example_(BASIC)_.doc |GPIO_Driving_Example_(BASIC)_.doc]]
 +
# [[Media:Raspberry_Pi_I-O_viii.doc | Raspberry_Pi_I-O_viii.doc]]
 +
 
 +
==SPI==
 +
 
 +
There is one SPI bus brought out to the header: [[RPi_SPI]]
 +
 
 +
==I²C==
 +
 
 +
There are two I²C-buses on the Raspberry Pi: One on P1, and one on P5.
 +
 
 +
Note that there's a bug concerning I²C-clock-stretching, so don't use I²C-devices which use clock-stretching directly with the Raspberry Pi, or use a workaround. Details about this bug can be found at:
  
On the production board<ref>http://www.raspberrypi.org/wp-content/uploads/2012/04/Raspberry-Pi-Schematics-R1.0.pdf</ref>, the Raspberry Pi Foundation design brings out the MIPI CSI-2 (Camera Serial Interface<ref>http://www.mipi.org/specifications/camera-interface</ref>) to a 15-way flat flex connector S5, between the Ethernet and HDMI connectors. A compatible camera has been discussed as working in tests and is planned for release at a later date.<ref>http://www.raspberrypi.org/forum/projects-and-collaboration-general/complex-camera-peripherials#p72602</ref>.
+
* http://www.raspberrypi.org/phpBB3/viewtopic.php?f=44&t=13771
<!-- This is misleading as it implies that cheap cameras from other devices can be used. CSI appears to be a generic interface with secret device-specific requirements so these devices must have drivers to be relevant (and currently only the VideoCore has access to the CSI hardware).
+
* http://www.advamation.com/knowhow/raspberrypi/rpi-i2c-bug.html
  
is Sony sub-LVDS same as MIPI CSI-2? Sony IMX020 5Mbip module is available for $5-7 (SE K850i replacement camera).
+
==MIPI CSI-2==
  
Looks like Nokia N95 uses CSI-2 5Mpix camera module with autofocus. ~$15 replacement part.
+
On the production board<ref>http://www.raspberrypi.org/wp-content/uploads/2012/04/Raspberry-Pi-Schematics-R1.0.pdf</ref>, the Raspberry Pi Foundation design brings out the MIPI CSI-2 (Camera Serial Interface<ref>http://www.mipi.org/specifications/camera-interface</ref>) to a 15-way flat flex connector S5, between the Ethernet and HDMI connectors. A compatible camera<ref>http://elinux.org/Rpi_Camera_Module</ref> with 5 Megapixels and 1080p video resolution was released in May 2013.
-->
 
  
 
==DSI==
 
==DSI==

Revision as of 03:57, 28 February 2015


RaspPi.png Back to the Hub


Hardware & Peripherals:

Hardware - detailed information about the Raspberry Pi boards.

Hardware History - guide to the Raspberry Pi models.

Low-level Peripherals - using the GPIO and other connectors.

Expansion Boards - GPIO plug-in boards providing additional functionality.

Screens - attaching a screen to the Raspberry Pi.

Cases - lots of nice cases to protect the Raspberry Pi.

Other Peripherals - all sorts of peripherals used with the Raspberry Pi.


Introduction

In addition to the familiar USB, Ethernet and HDMI ports, the R-Pi offers lower-level interfaces intended to connect more directly with chips and subsystem modules. These GPIO (general purpose I/O) signals on the 2x13 header pins include SPI, I²C, serial UART, 3V3 and 5V power. These interfaces are not "plug and play" and require care to avoid miswiring. The pins use a 3V3 logic level and are not tolerant of 5V levels, such as you might find on a 5V powered Arduino. CSI (camera serial interface) can be used to connect the 5 MP camera available. Not yet software-enabled is the flex cable connectors with DSI (display serial interface) and a serial link inside the HDMI connector called CEC. (consumer electronics control)

General Purpose Input/Output (GPIO)

The layout of the Raspberry Pi P1 pin-header seen from the top, containing pins useable for general purpose I/O. Colour coded to the table. Three pins changed between PCB Rev.1 and Rev.2 Source

General Purpose Input/Output (a.k.a. GPIO) is a generic pin on a chip whose behavior (including whether it is an input or output pin) can be controlled (programmed) through software.

The Raspberry Pi allows peripherals and expansion boards (such as the Rpi Gertboard) to access the CPU by exposing the inputs and outputs.

For further general information about GPIOs, see: input/output this wikipedia article.
For further specific information about the Raspberry Pi's BCM2835 GPIOs, see: this wiki article.
To connect devices to the serial port (UART), see the RPi Serial Connection page.
Sample circuits for interfacing the GPIOs with other electronics are shown on the RPi GPIO Interface Circuits page.

The Raspberry Pi Model A and B boards have a 26-pin 2.54 mm (100 mil)[1] expansion header, marked as P1, arranged in a 2x13 strip. They provide 8 GPIO pins plus access to I²C, SPI, UART), as well as +3.3 V, +5 V and GND supply lines. Pin one is the pin in the first column and on the bottom row. [2] RPi P1 header.png

The Raspberry Pi Model A+ and B+ boards have a 40-pin header marked J8, arranged as 2x20 pins. The first 26 pins are the same as P1 on the A/B boards, with the remaining 14 pins providing additional GPIO and ground pins, and an EEPROM ID feature for auto-configuration with add-on "HAT" boards.[3]

RPi A+,B+ GPIO: J8 40-pin header
--------------------------------
        +3V3 1  2   +5V
GPIO2   SDA1 3  4   +5V
GPIO3   SCL1 5  6   GND
GPIO4   GCLK 7  8   TXD0  GPIO14
         GND 9  10  RXD0  GPIO15
GPIO17  GEN0 11 12  GEN1  GPIO18
GPIO27  GEN2 13 14  GND
GPIO22  GEN3 15 16  GEN4  GPIO23
        +3V3 17 18  GEN5  GPIO24
GPIO10  MOSI 19 20  GND
GPIO9   MISO 21 22  GEN6  GPIO25
GPIO11  SCLK 23 24  CE0_N GPIO8
         GND 25 26  CE1_N GPIO7
EEPROM ID_SD 27 28  ID_SC EEPROM
GPIO5        29 30  GND
GPIO6        31 32        GPIO12
GPIO13       33 34  GND
GPIO19       35 36        GPIO16
GPIO26       37 38        GPIO20
         GND 39 40        GPIO21
--------------------------------

GPIO voltage levels are 3.3 V and are not 5 V tolerant. There is no over-voltage protection on the board - the intention is that people interested in serious interfacing will use an external board with buffers, level conversion and analog I/O rather than soldering directly onto the main board.

All the GPIO pins can be reconfigured to provide alternate functions, SPI, PWM, I²C and so. At reset only pins GPIO 14 & 15 are assigned to the alternate function UART, these two can be switched back to GPIO to provide a total of 17 GPIO pins[4]. Each of their functions and full details of how to access are detailed in the chipset datasheet [5].

Each GPIO can interrupt, high/low/rise/fall/change.[6][7] There is currently no support for GPIO interrupts in the official kernel, however a patch exists, requiring compilation of modified source tree.[8] The 'Raspbian "wheezy"' [9] version that is currently recommended for starters already includes GPIO interrupts.

GPIO input hysteresis (Schmitt trigger) can be on or off, output slew rate can be fast or limited, and source and sink current is configurable from 2 mA up to 16 mA. Note that chipset GPIO pins 0-27 are in the same block and these properties are set per block, not per pin. See GPIO Datasheet Addendum - GPIO Pads Control. Particular attention should be applied to the note regarding SSO (Simultaneous Switching Outputs): to avoid interference, driving currents should be kept as low as possible.

The available alternative functions and their corresponding pins are detailed below. These numbers are in reference to the chipset documentation and may not match the numbers exposed in Linux. Only fully usable functions are detailed, for some alternative functions not all the necessary pins are available for the funtionality to be actually used.

There is also some information on the Tutorial on Easy GPIO Hardware & Software.

Kernel boot messages go to the UART at 115200 bit/s - there are more details on the serial port page.

R-Pi PCB Revision 2: According to Eben at [1] the R-Pi Rev.2 board being rolled out starting in September 2012 adds 4 more GPIO on a new connector called P5, and changes some of the existing P1 GPIO pinouts. On Rev2, GPIO_GEN2 [BCM2835/GPIO27] is routed to P1 pin 13, and changes what was SCL0/SDA0 to SCL1/SDA1: SCL1 [BCM2835/GPIO3] is routed to P1 pin 5, SDA1 [BCM2835/GPIO2] is routed to P1 pin 3. Also the power and ground connections previously marked "Do Not Connect" on P1 will remain as connected, specifically: P1-04:+5V0, P1-09:GND, P1-14:GND, P1-17:+3V3, P1-20:GND, P1-25:GND. According to this comment [2] (and confirmed in this post [3]) the P1 pinout is not expected to change in future beyond the current Rev.2 layout.

P1 Header pinout, top row

Pin Number Pin Name Rev1 Pin Name Rev2 Hardware Notes Alt 0 Function Other Alternative Functions
P1-02 5V0 Supply through input poly fuse    
P1-04 5V0 Supply through input poly fuse    
P1-06 GND      
P1-08 GPIO 14 Boot to Alt 0 -> UART0_TXD ALT5 = UART1_TXD
P1-10 GPIO 15 Boot to Alt 0 -> UART0_RXD ALT5 = UART1_RXD
P1-12 GPIO 18   PCM_CLK ALT4 = SPI1_CE0_N ALT5 = PWM0
P1-14 GND      
P1-16 GPIO23 ALT3 = SD1_CMD ALT4 = ARM_RTCK
P1-18 GPIO24 ALT3 = SD1_DAT0 ALT4 = ARM_TDO
P1-20 GND &bnsp;    
P1-22 GPIO25 ALT3 = SD1_DAT1 ALT4 = ARM_TCK
P1-24 GPIO08 SPI0_CE0_N
P1-26 GPIO07 SPI0_CE1_N

P1 Header pinout, bottom row

Pin Number Pin Name Rev1 Pin Name Rev2 Hardware Notes Alt 0 Function Other Alternative Functions
P1-01 3.3 V 50 mA max (01 & 17)    
P1-03 GPIO 0 GPIO 2 1K8 pull up resistor I2C0_SDA / I2C1_SDA
P1-05 GPIO 1 GPIO 3 1K8 pull up resistor I2C0_SCL / I2C1_SCL
P1-07 GPIO 4 GPCLK0 ALT5 = ARM_TDI
P1-09 GND      
P1-11 GPIO17 ALT3 = UART0_RTS ALT4 = SPI1_CE1_N ALT5 = UART1_RTS
P1-13 GPIO21 GPIO27 PCM_DOUT / reserved ALT4 = SPI1_SCLK ALT5 = GPCLK1 / ALT3 = SD1_DAT3 ALT4 = ARM_TMS
P1-15 GPIO22 ALT3 = SD1_CLK ALT4 = ARM_TRST
P1-17 3.3 V 50 mA max (01 & 17)    
P1-19 GPIO10 SPI0_MOSI
P1-21 GPIO9 SPI0_MISO
P1-23 GPIO11 SPI0_SCLK
P1-25 GND      


Colour legend
+5 V
+3.3 V
Ground, 0V
UART
GPIO
SPI
I²C

KiCad symbol: File:Conn-raspberry.lib[10]

Pin 3 (SDA0) and Pin 5 (SCL0) are preset to be used as an I²C interface. So there are 1.8 kohm pulls up resistors on the board for these pins.[11]

Pin 12 supports PWM.

It is also possible to reconfigure GPIO connector pins P1-7, 15, 16, 18, 22 (chipset GPIOs 4 and 22 to 25) to provide an ARM JTAG interface.[12] However ARM_TMS is not available on the GPIO connector (chipset pin 12 or 27 is needed). Chipset pin 27 is available on S5, the CSI camera interface however.

It is also possible to reconfigure GPIO connector pins P1-12 and 13 (chipset GPIO 18 and 21) to provide an I2S (a hardware modification may be required[13]) or PCM interface.[14] However, PCM_FS and PCM_DIN (chipset pins 19 and 20) are needed for I2S or PCM.

A second I²C interface (GPIO02_ALT0 is SDA1 and GPIO03_ALT0 is SCL1) and two further GPIOs (GPIO05_ALT0 is GPCLK1, and GPIO27) are available on S5, the CSI camera interface.

Referring to pins on the Expansion header

The header is referred to as "The GPIO Connector (P1)". To avoid nomenclature confusion between Broadcom signal names on the SoC and pin names on the expansion header, the following naming is highly recommended:

  • The expansion header is referred to as "Expansion Header" or "GPIO Connector (P1)"
  • Pins on the GPIO connector (P1) are referred to as P1-01, etc.
  • Names GPIO0, GPIO1, GPIOx-ALTy, etc. refer to the signal names on the SoC as enumerated in the Broadcom datasheet, where "x" matches BCM2835 number (without leading zero) and "y" is the alternate number column 0 to 5 on page 102-103 of the Broadcom document. For example, depending on what you are describing, use either "GPIO7" to refer to a row of the table, and "GPIO7-ALT0" would refer to a specific cell of the table.
  • When refering to signal names, the Broadcom name should be modified slightly to minimize confusion. The Broadcom SPI bus pin names are fine, such as "SPI0_*" and "SPI1_*", but they did not do the same on the I²C and UART pins. Instead of using "SDA0" and "SCL0", "I2C0_SDA" and "I2C0_SCL" should be used; and "UART0_TXD" and "UART0_RXD" instead of "TX" or "TXD" and "RX" or "RXD".

Power pins

The maximum permitted current draw from the 3.3 V pins is 50 mA.

Maximum permitted current draw from the 5 V pin is the USB input current (usually 1 A) minus any current draw from the rest of the board.[15]

  • Model A: 1000 mA - 500 mA -> max current draw: 500 mA
  • Model B: 1000 mA - 700 mA -> max current draw: 300 mA

Be very careful with the 5 V pins P1-02 and P1-04, because if you short 5 V to any other P1 pin you may permanently damage your RasPi. Before probing P1, it is a good idea to strip short pieces of insulation off a wire and push them over the 5 V pins are not accidentally shorted with a probe.

GPIO hardware hacking

The complete list of chipset GPIO pins which are available on the GPIO connector is:

0, 1, 4, 7, 8, 9, 10, 11, 14, 15, 17, 18, 21, 22, 23, 24, 25

(on the Revision2.0 RaspberryPis, this list changes to: 2, 3, 4, 7, 8, 9, 10, 11, 14, 15, 17, 18, 22, 23, 24, 25, 27, with 28, 29, 30, 31 additionally available on the P5 header)

As noted above, P1-03 and P1-05 (SDA0 and SCL0 / SDA1 and SCL1) have 1.8 kohm pull-up resistors to 3.3 V.

If 17 GPIOs are not sufficient for a project, there are a few other signals potentially available, with varying levels of software and hardware (soldering iron) hackery skills:

GPIO02, 03, 05 and 27 are available on S5 (the CSI interface) when a camera peripheral is not connected to that socket, and are configured by default to provide the functions SDA1, SCL1, CAM_CLK and CAM_GPIO respectively. SDA1 and SCL1 have 1K6 pull-up resistors to 3.3 V.

GPIO06 is LAN_RUN and is available on pad 12 of the footprint for IC3 on the Model A. On Model B, it is in use for the Ethernet function.

There are a few other chipset GPIO pins accessible on the PCB but are in use:

  • GPIO16 drives status LED D5 (usually SD card access indicator)
  • GPIO28-31 are used by the board ID and are connected to resistors R3 to R10 (only on Rev1.0 boards).
  • GPIO40 and 45 are used by analogue audio and support PWM. They connect to the analogue audio circuitry via R21 and R27 respectively.
  • GPIO46 is HDMI hotplug detect (goes to pin 6 of IC1).
  • GPIO47 to 53 are used by the SD card interface. In particular, GPIO47 is SD card detect (this would seem to be a good candidate for re-use). GPIO47 is connected to the SD card interface card detect switch; GPIO48 to 53 are connected to the SD card interface via resistors R45 to R50.

P2 header

The P2 header is the VideoCore JTAG and used only during the production of the board. It cannot be used as the ARM JTAG [16]. This connector is unpopulated in Rev 2.0 boards.

RPi P2 header.png

Useful P2 pins:

  • Pin 1 - 3.3V (same as P1-01, 50 mA max current draw across both of them)
  • Pin 7 - GND
  • Pin 8 - GND

P3 header

The P3 header, unpopulated, is the LAN9512 JTAG [17].

RPi P3 header.png

Useful P3 pins:

  • Pin 7 - GND

P5 header

The P5 header was added with the release of the Revision 2.0 PCB design.

RPi P5 header.png

P5 Header pinout, top row

As seen from the back of the board:

Pin Number Pin Name Rev2 Hardware Notes Alt 0 Function Other Alternative Functions
P5-01 5V0 Supply through input poly fuse
P5-03 GPIO28 I2C0_SDA ALT2 = PCM_CLK
P5-05 GPIO30 ALT2 = PCM_DIN ALT3 = UART0_CTS ALT5 = UART1_CTS
P5-07 GND

P5 Header pinout, bottom row

As seen from the back of the board:

Pin Number Pin Name Rev2 Hardware Notes Alt 0 Function Other Alternative Functions
P5-02 3.3 V 50 mA max (combined with P1)
P5-04 GPIO29 I2C0_SCL ALT2 = PCM_FS
P5-06 GPIO31 ALT2 = PCM_DOUT ALT3 = UART0_RTS ALT5 = UART1_RTS
P5-08 GND
Slanted P5 header

Note that the connector is intended to be mounted on the bottom of the PCB, so that for those who put the connector on the top side, the pin numbers are mirrored. Pin 1 and pin 2 are swapped, pin 3 and 4, etc.

An alternative way to attach this header is on top, at a slant away from the P1 header.

The new header can provide a second I²C channel (SDA + SCL) and handshake lines for the existing UART (TxD and RxD), or it can be used for an I2S (audio codec chip) interface using the PCM signals CLK, FS (Frame Sync), Din and Dout.

Note that the connector is placed JUST off-grid with respect to the P1 connector.

P6 header

The P6 header was added with the release of the Revision 2.0 PCB design.

RPi P6 header.png

P6 Pinout

Pin Number Pin Name Rev2 Hardware Notes
P6-01 RUN Short to ground to reset the BCM2835
P6-02 GND

A reset button can be attached to the P6 header.[18] Momentarily shorting the two pins of P6 together will cause a soft reset of the CPU (which can also 'wake' the Pi from halt/shutdown state).

Internal Pull-Ups & Pull-Downs

The GPIO ports include the ability to enable and disable internal pull-up or pull-down resistors (see below for code examples/support of this):

  • Pull-up is 50 kOhm - 65 kOhm
  • Pull-down is 50 kOhm - 60 kOhm

Driver support

The Foundation will not include a GPIO driver in the initial release, standard Linux GPIO drivers should work with minimal modification.[19]

The community implemented SPI and I²C drivers [20], which will be integrated with the new Linux pinctrl concept in a later version of the kernel. (On Oct. 14 2012, it was already included in the latest raspbian image.) A first compiled version as Linux modules is available to install on the 19/04/2012 Debian image, including 1-wire support[21]. The I²C and SPI driver uses the hardware modules of the microcontroller and interrupts for low CPU usage, the 1-wire support uses bitbanging on the GPIO ports, which results in higher CPU usage.

GordonH[22] wrote a (mostly) Arduino compatible/style WiringPi library in C for controlling the GPIO pins.

A useful tutorial on setting up I²C driver support can be found at Robot Electronics - look for the downloadable document rpi_i2c_setup.doc

Graphical User Interfaces

WebIOPi

WebIOPi allows to control each GPIO with a simple web interface that can be used with any browser. Available in PHP and Python, they both require root access, but the Python version serves HTTP itself. Each GPIO pin can be set up as input or output and its LOW/HIGH stae can be changed. WebIOPi is fully customizable, so it can be used for home remote control. It also works over Internet. UART/SPI/I²C support will be added later. See code examples below.

GPIO Code examples

C

Examples in different C-Languages.

Gert & Dom

Gert van Loo & Dom, have provided some tested code which accesses the GPIO pins through direct GPIO register manipulation in C-code. (Thanks to Dom for doing the difficult work of finding and testing the mapping.) Example GPIO code:

//
//  How to access GPIO registers from C-code on the Raspberry-Pi
//  Example program
//  15-January-2012
//  Dom and Gert
//  Revised: 15-Feb-2013


// Access from ARM Running Linux

#define BCM2708_PERI_BASE        0x20000000
#define GPIO_BASE                (BCM2708_PERI_BASE + 0x200000) /* GPIO controller */


#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

#define PAGE_SIZE (4*1024)
#define BLOCK_SIZE (4*1024)

int  mem_fd;
void *gpio_map;

// I/O access
volatile unsigned *gpio;


// GPIO setup macros. Always use INP_GPIO(x) before using OUT_GPIO(x) or SET_GPIO_ALT(x,y)
#define INP_GPIO(g) *(gpio+((g)/10)) &= ~(7<<(((g)%10)*3))
#define OUT_GPIO(g) *(gpio+((g)/10)) |=  (1<<(((g)%10)*3))
#define SET_GPIO_ALT(g,a) *(gpio+(((g)/10))) |= (((a)<=3?(a)+4:(a)==4?3:2)<<(((g)%10)*3))

#define GPIO_SET *(gpio+7)  // sets   bits which are 1 ignores bits which are 0
#define GPIO_CLR *(gpio+10) // clears bits which are 1 ignores bits which are 0

#define GET_GPIO(g) (*(gpio+13)&(1<<g)) // 0 if LOW, (1<<g) if HIGH

#define GPIO_PULL *(gpio+37) // Pull up/pull down
#define GPIO_PULLCLK0 *(gpio+38) // Pull up/pull down clock

void setup_io();

void printButton(int g)
{
  if (GET_GPIO(g)) // !=0 <-> bit is 1 <- port is HIGH=3.3V
    printf("Button pressed!\n");
  else // port is LOW=0V
    printf("Button released!\n");
}

int main(int argc, char **argv)
{
  int g,rep;

  // Set up gpi pointer for direct register access
  setup_io();

  // Switch GPIO 7..11 to output mode

 /************************************************************************\
  * You are about to change the GPIO settings of your computer.          *
  * Mess this up and it will stop working!                               *
  * It might be a good idea to 'sync' before running this program        *
  * so at least you still have your code changes written to the SD-card! *
 \************************************************************************/

  // Set GPIO pins 7-11 to output
  for (g=7; g<=11; g++)
  {
    INP_GPIO(g); // must use INP_GPIO before we can use OUT_GPIO
    OUT_GPIO(g);
  }

  for (rep=0; rep<10; rep++)
  {
     for (g=7; g<=11; g++)
     {
       GPIO_SET = 1<<g;
       sleep(1);
     }
     for (g=7; g<=11; g++)
     {
       GPIO_CLR = 1<<g;
       sleep(1);
     }
  }

  return 0;

} // main


//
// Set up a memory regions to access GPIO
//
void setup_io()
{
   /* open /dev/mem */
   if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
      printf("can't open /dev/mem \n");
      exit(-1);
   }

   /* mmap GPIO */
   gpio_map = mmap(
      NULL,             //Any adddress in our space will do
      BLOCK_SIZE,       //Map length
      PROT_READ|PROT_WRITE,// Enable reading & writting to mapped memory
      MAP_SHARED,       //Shared with other processes
      mem_fd,           //File to map
      GPIO_BASE         //Offset to GPIO peripheral
   );

   close(mem_fd); //No need to keep mem_fd open after mmap

   if (gpio_map == MAP_FAILED) {
      printf("mmap error %d\n", (int)gpio_map);//errno also set!
      exit(-1);
   }

   // Always use volatile pointer!
   gpio = (volatile unsigned *)gpio_map;


} // setup_io

GPIO Pull Up/Pull Down Register Example

   // enable pull-up on GPIO24&25
   GPIO_PULL = 2;
   short_wait();
   // clock on GPIO 24 & 25 (bit 24 & 25 set)
   GPIO_PULLCLK0 = 0x03000000;
   short_wait();
   GPIO_PULL = 0;
   GPIO_PULLCLK0 = 0;

wiringPi

Get and install wiringPi: https://projects.drogon.net/raspberry-pi/wiringpi/download-and-install/

Save this, and compile with:

  gcc -o blink blink.c -lwiringPi

and run with:

  sudo ./blink
/*
 * blink.c:
 *      blinks the first LED
 *      Gordon Henderson, projects@drogon.net
 */

#include <stdio.h>
#include <wiringPi.h>

int main (void)
{
  printf ("Raspberry Pi blink\n") ;

  if (wiringPiSetup () == -1)
    return 1 ;

  pinMode (0, OUTPUT) ;         // aka BCM_GPIO pin 17

  for (;;)
  {
    digitalWrite (0, 1) ;       // On
    delay (500) ;               // mS
    digitalWrite (0, 0) ;       // Off
    delay (500) ;
  }
  return 0 ;
}

sysfs

The following example requires no special libraries, it uses the available sysfs interface.

/* blink.c
 *
 * Raspberry Pi GPIO example using sysfs interface.
 * Guillermo A. Amaral B. <g@maral.me>
 *
 * This file blinks GPIO 4 (P1-07) while reading GPIO 24 (P1_18).
 */

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define IN  0
#define OUT 1

#define LOW  0
#define HIGH 1

#define PIN  24 /* P1-18 */
#define POUT 4  /* P1-07 */

static int
GPIOExport(int pin)
{
#define BUFFER_MAX 3
	char buffer[BUFFER_MAX];
	ssize_t bytes_written;
	int fd;

	fd = open("/sys/class/gpio/export", O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open export for writing!\n");
		return(-1);
	}

	bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
	write(fd, buffer, bytes_written);
	close(fd);
	return(0);
}

static int
GPIOUnexport(int pin)
{
	char buffer[BUFFER_MAX];
	ssize_t bytes_written;
	int fd;

	fd = open("/sys/class/gpio/unexport", O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open unexport for writing!\n");
		return(-1);
	}

	bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
	write(fd, buffer, bytes_written);
	close(fd);
	return(0);
}

static int
GPIODirection(int pin, int dir)
{
	static const char s_directions_str[]  = "in\0out";

#define DIRECTION_MAX 35
	char path[DIRECTION_MAX];
	int fd;

	snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/direction", pin);
	fd = open(path, O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open gpio direction for writing!\n");
		return(-1);
	}

	if (-1 == write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3)) {
		fprintf(stderr, "Failed to set direction!\n");
		return(-1);
	}

	close(fd);
	return(0);
}

static int
GPIORead(int pin)
{
#define VALUE_MAX 30
	char path[VALUE_MAX];
	char value_str[3];
	int fd;

	snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
	fd = open(path, O_RDONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open gpio value for reading!\n");
		return(-1);
	}

	if (-1 == read(fd, value_str, 3)) {
		fprintf(stderr, "Failed to read value!\n");
		return(-1);
	}

	close(fd);

	return(atoi(value_str));
}

static int
GPIOWrite(int pin, int value)
{
	static const char s_values_str[] = "01";

	char path[VALUE_MAX];
	int fd;

	snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
	fd = open(path, O_WRONLY);
	if (-1 == fd) {
		fprintf(stderr, "Failed to open gpio value for writing!\n");
		return(-1);
	}

	if (1 != write(fd, &s_values_str[LOW == value ? 0 : 1], 1)) {
		fprintf(stderr, "Failed to write value!\n");
		return(-1);
	}

	close(fd);
	return(0);
}

int
main(int argc, char *argv[])
{
	int repeat = 10;

	/*
	 * Enable GPIO pins
	 */
	if (-1 == GPIOExport(POUT) || -1 == GPIOExport(PIN))
		return(1);

	/*
	 * Set GPIO directions
	 */
	if (-1 == GPIODirection(POUT, OUT) || -1 == GPIODirection(PIN, IN))
		return(2);

	do {
		/*
		 * Write GPIO value
		 */
		if (-1 == GPIOWrite(POUT, repeat % 2))
			return(3);

		/*
		 * Read GPIO value
		 */
		printf("I'm reading %d in GPIO %d\n", GPIORead(PIN), PIN);

		usleep(500 * 1000);
	}
	while (repeat--);

	/*
	 * Disable GPIO pins
	 */
	if (-1 == GPIOUnexport(POUT) || -1 == GPIOUnexport(PIN))
		return(4);

	return(0);
}

bcm2835

This must be done as root. To change to the root user:

sudo -i

You must also get and install the bcm2835 library, which supports GPIO and SPI interfaces. Details and downloads from http://www.open.com.au/mikem/bcm2835

// blink.c
//
// Example program for bcm2835 library
// Blinks a pin on an off every 0.5 secs
//
// After installing bcm2835, you can build this 
// with something like:
// gcc -o blink -l rt blink.c -l bcm2835
// sudo ./blink
//
// Or you can test it before installing with:
// gcc -o blink -l rt -I ../../src ../../src/bcm2835.c blink.c
// sudo ./blink
//
// Author: Mike McCauley (mikem@open.com.au)
// Copyright (C) 2011 Mike McCauley
// $Id: RF22.h,v 1.21 2012/05/30 01:51:25 mikem Exp $

#include <bcm2835.h>

// Blinks on RPi pin GPIO 11
#define PIN RPI_GPIO_P1_11

int main(int argc, char **argv)
{
    // If you call this, it will not actually access the GPIO
    // Use for testing
//    bcm2835_set_debug(1);

    if (!bcm2835_init())
	return 1;

    // Set the pin to be an output
    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP);

    // Blink
    while (1)
    {
	// Turn it on
	bcm2835_gpio_write(PIN, HIGH);
	
	// wait a bit
	delay(500);
	
	// turn it off
	bcm2835_gpio_write(PIN, LOW);
	
	// wait a bit
	delay(500);
    }

    return 0;
}

pigpio

pigpio provides all the standard gpio features.

In addition it provides hardware timed PWM suitable for servos, LEDs, and motors and samples/timestamps gpios 0-31 up to 1 million times per second (default 200 thousand).

C documentation: http://abyz.co.uk/rpi/pigpio/cif.html

Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html

/*
   pulse.c

   gcc -o pulse pulse.c -lpigpio -lrt -lpthread

   sudo ./pulse
*/

#include <stdio.h>

#include <pigpio.h>

int main(int argc, char *argv[])
{
   double start;

   if (gpioInitialise() < 0)
   {
      fprintf(stderr, "pigpio initialisation failed\n");
      return 1;
   }

   /* set gpio modes */
   gpioSetMode(4, PI_OUTPUT);
   gpioSetMode(17, PI_OUTPUT);
   gpioSetMode(18, PI_OUTPUT);
   gpioSetMode(23, PI_INPUT);
   gpioSetMode(24, PI_OUTPUT);

   /* start 1500 us servo pulses on gpio4 */
   gpioServo(4, 1500);

   /* start 75% dutycycle PWM on gpio17 */
   gpioPWM(17, 192); /* 192/255 = 75% */

   start = time_time();

   while ((time_time() - start) < 60.0)
   {
      gpioWrite(18, 1); /* on */

      time_sleep(0.5);

      gpioWrite(18, 0); /* off */

      time_sleep(0.5);

      /* mirror gpio24 from gpio23 */
      gpioWrite(24, gpioRead(23));
   }

   /* stop DMA, release resources */
   gpioTerminate();

   return 0;
}

Compile

gcc -o pulse pulse.c -lpigpio -lrt -lpthread

Run

sudo ./pulse

C#

RaspberryGPIOManager is a very basic C# library to control the GPIO pins via the GPIOPinDriver object. See: https://github.com/AlexSartori/RaspberryGPIOManager

using RaspberryGPIOManager;

namespace GPIOtest
{
    class Program
    {
        static void Main(string[] args)
        {
            GPIOPinDriver led1;

            // Create the object.
            led1 = new GPIOPinDriver(GPIOPinDriver.Pin.GPIO15);

            // Set it as an output pin.
            led1.Direction = GPIOPinDriver.GPIODirection.Out

            // Give it power.
            led1.State = GPIOPinDriver.GPIOState.High;
        }
    }
}


RaspberryPiDotNet library is available at https://github.com/cypherkey/RaspberryPi.Net/. This more advanced library includes a GPIOFile and GPIOMem class. The GPIOMem requires compiling Mike McCauley's bcm2835 library above in to a shared object.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RaspberryPiDotNet;
using System.Threading;

namespace RaspPi
{
    class Program
    {
        static void Main(string[] args)
        {
            // Access the GPIO pin using a static method
            GPIOFile.Write(GPIO.GPIOPins.GPIO00, true);

            // Create a new GPIO object
            GPIOMem gpio = new GPIOMem(GPIO.GPIOPins.GPIO01);
            gpio.Write(false);
        }
    }
}

Ruby

This example uses the WiringPi Ruby Gem: http://pi.gadgetoid.co.uk/post/015-wiringpi-now-with-serial which you can install on your Pi with "gem install wiringpi"

MY_PIN = 1

require 'wiringpi'
io = WiringPi::GPIO.new
io.mode(MY_PIN,OUTPUT)
io.write(MY_PIN,HIGH)
io.read(MY_PIN)

Alternatively the Pi Piper Gem (https://github.com/jwhitehorn/pi_piper) allows for event driven programming:

require 'pi_piper'
include PiPiper

watch :pin => 23 do
  puts "Pin changed from #{last_value} to #{value}"
end

PiPiper.wait


Perl

This must be done as root. To change to the root user:

sudo su -

Supports GPIO and SPI interfaces. You must also get and install the bcm2835 library. Details and downloads from http://www.open.com.au/mikem/bcm2835 You must then get and install the Device::BCM2835 perl library from CPAN http://search.cpan.org/~mikem/Device-BCM2835-1.0/lib/Device/BCM2835.pm

use Device::BCM2835;
use strict;

# call set_debug(1) to do a non-destructive test on non-RPi hardware
#Device::BCM2835::set_debug(1);
Device::BCM2835::init() 
 || die "Could not init library";

# Blink pin 11:
# Set RPi pin 11 to be an output
Device::BCM2835::gpio_fsel(&Device::BCM2835::RPI_GPIO_P1_11, 
                            &Device::BCM2835::BCM2835_GPIO_FSEL_OUTP);

while (1)
{
    # Turn it on
    Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 1);
    Device::BCM2835::delay(500); # Milliseconds
    # Turn it off
    Device::BCM2835::gpio_write(&Device::BCM2835::RPI_GPIO_P1_11, 0);
    Device::BCM2835::delay(500); # Milliseconds
}

Python

RPi.GPIO

The RPi.GPIO module is installed by default in Raspbian. Any RPi.GPIO script must be run as root.

import RPi.GPIO as GPIO

# use P1 header pin numbering convention
GPIO.setmode(GPIO.BOARD)

# Set up the GPIO channels - one input and one output
GPIO.setup(11, GPIO.IN)
GPIO.setup(12, GPIO.OUT)

# Input from pin 11
input_value = GPIO.input(11)

# Output to pin 12
GPIO.output(12, GPIO.HIGH)

# The same script as above but using BCM GPIO 00..nn numbers
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.IN)
GPIO.setup(18, GPIO.OUT)
input_value = GPIO.input(17)
GPIO.output(18, GPIO.HIGH)

More documentation is available at http://sourceforge.net/p/raspberry-gpio-python/wiki/Home/

pigpio

pigpio Python scripts may be run on Windows, Macs, and Linux machines. Only the pigpio daemon needs to be running on the Pi.

pigpio provides all the standard gpio features.

In addition it provides hardware timed PWM suitable for servos, LEDs, and motors and samples/timestamps gpios 0-31 up to 1 million times per second (default 200 thousand).

Python documentation: http://abyz.co.uk/rpi/pigpio/python.html

Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html

#!/usr/bin/env python

# pulse.py

import time

import pigpio

pi = pigpio.pi() # Connect to local Pi.

# set gpio modes

pi.set_mode(4, pigpio.OUTPUT)
pi.set_mode(17, pigpio.OUTPUT)
pi.set_mode(18, pigpio.OUTPUT)
pi.set_mode(23, pigpio.INPUT)
pi.set_mode(24, pigpio.OUTPUT)


# start 1500 us servo pulses on gpio4

pi.set_servo_pulsewidth(4, 1500)

# start 75% dutycycle PWM on gpio17

pi.set_PWM_dutycycle(17, 192) # 192/255 = 75%

start = time.time()

while (time.time() - start) < 60.0:

      pi.write(18, 1) # on

      time.sleep(0.5)

      pi.write(18, 0) # off

      time.sleep(0.5)

      # mirror gpio24 from gpio23

      pi.write(24, pi.read(23))

pi.set_servo_pulsewidth(4, 0) # stop servo pulses

pi.set_PWM_dutycycle(17, 0) # stop PWM

pi.stop() # terminate connection and release resources

pigpio scripts require that the pigpio daemon be running.

sudo pigpiod

They do not need to be run as root.

./pulse.py

RPIO

Also available is RPIO at https://pypi.python.org/pypi/RPIO

RPIO extends RPi.GPIO with TCP socket interrupts, command line tools and more.

Scratch

Scratch using the ScratchGPIO

Blink11.gif

Scratch can be used to control the GPIO pins using a background Python handler available from

http://cymplecy.wordpress.com/2013/04/22/scratch-gpio-version-2-introduction-for-beginners/






Pridopia Scratch Rs-Pi-GPIO driver

Pridopia-demo01.jpg

Scratch control GPIO (use GPIO number not P1 pin number can support GPIO 28,29,30,31)

support I²C 23017 8/16/32/64/128 GPIO, I²C TMP102 Temp sensor, I²C RTC DS1307, I²C ADC ADS1015, I²C PWM, I²C EEPROM 24c32, I²C BMP085 Barometric Pressure/Temperature/Altitude Sensor, GPIO input/output, DC motor, Relay, I²C 16x16 LED matrix, I²C 24x16 Matrix, 84x48 pixels LCD, 16x2 character LCD, 20x4 character LCD, 1-Wire 18B20 Temp Sensor, Ultra Sonic distance sensor, available from

http://www.pridopia.co.uk/rs-pi-set-scratch.html

RpiScratchIO

Generic interface for GPIO or other I/O operations. The package allows user modules to be easily added and loaded, to interface with any I/O device. The code is written in Python and uses the scratchpy Python package to interface with Scratch.

RpiScratchIO based BrickPi driver
RpiScratchIO - Installation

To install the package on the latest Raspbian installation type,

sudo apt-get install -y python-setuptools python-dev
sudo easy_install pip
sudo pip install RpiScratchIO
RpiScratchIO - Documentation and examples

More information can be found at https://pypi.python.org/pypi/RpiScratchIO/ The package is also documented in Issues 20 and 22 of The MagPi. RpiScratchIO is the basis of a new BrickPi Scratch handler, which is documented in Issue 23 of The MagPi.



Java

Java using the Pi4J Library

This uses the Java library available at http://www.pi4j.com/. (Any Java application that controls GPIO must be run as root.)

Please note that the Pi4J library uses the WiringPi GPIO pin numbering scheme [23] [24]. Please see the usage documentation for more details: http://pi4j.com/usage.html

public static void main(String[] args) {

    // create gpio controller
    GpioController gpio = GpioFactory.getInstance();
        
    // provision gpio pin #01 as an output pin and turn off
    GpioPinDigitalOutput outputPin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLED", PinState.LOW);
    
    // turn output to LOW/OFF state
    outputPin.low();

    // turn output to HIGH/ON state
    outputPin.high();


    // provision gpio pin #02 as an input pin with its internal pull down resistor enabled
    GpioPinDigitalInput inputPin = gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, "MyButton", PinPullResistance.PULL_DOWN);

    // get input state from pin 2
    boolean input_value = inputPin.isHigh();
}

More complete and detailed examples are included on the Pi4J website at http://www.pi4j.com/.

The Pi4J library includes support for:

  • GPIO Control
  • GPIO Listeners
  • Serial Communication
  • I2C Communication
  • SPI Communication

Java

This uses the Java library available at https://github.com/jkransen/framboos. It does not depend on (or use) the wiringPi driver, but uses the same numbering scheme. Instead it uses the default driver under /sys/class/gpio that ships with the distro, so it works out of the box. Any Java application that controls GPIO must be run as root.

public static void main(String[] args) {
  // reading from an in pin
  InPin button = new InPin(8);
  boolean isButtonPressed = button.getValue();
  button.close();

  // writing to an out pin
  OutPin led = new Outpin(0);
  led.setValue(true);
  led.setValue(false);
  led.close();
}

Java Webapp GPIO web control via HTTP

This uses the Java Webapp available at https://bitbucket.org/sbub/raspberry-pi-gpio-web-control/overview. You can control your GPIO over the Internet. Any Java application that controls GPIO must be run as root.


host:~ sb$ curl 'http://raspberrypi:8080/handle?g0=1&g1=0'
{"g1":0,"g0":1}

Shell

sysfs, part of the raspbian operating system

The export and unexport of pins must be done as root. To change to the root user see below: To change back, the word exit must be entered.

sudo -i

Export creates a new folder for the exported pin, and creates files for each of its control functions (i.e. active_low, direction, edge, power, subsystem, uevent, and value). Upon creation, the control files can be read by all users (not just root), but can only be written to by user root, the file's owner. Nevertheless, once created, it is possible to allow users other than root, to also write inputs to the control files, by changing the ownership or permissions of these files. Changes to the file's ownership or permissions must initially be done as root, as their owner and group is set to root upon creation. Typically you might change the owner to be the (non root) user controlling the GPIO, or you might add write permission, and change the group ownership to one of which the user controlling the GPIO is a member. By such means, using only packages provided in the recommended rasbian distribution, it is possible for Python CGI scripts, which are typically run as user nobody, to be used for control of the GPIO over the internet from a browser at a remote location.

#!/bin/sh

# GPIO numbers should be from this list
# 0, 1, 4, 7, 8, 9, 10, 11, 14, 15, 17, 18, 21, 22, 23, 24, 25

# Note that the GPIO numbers that you program here refer to the pins
# of the BCM2835 and *not* the numbers on the pin header. 
# So, if you want to activate GPIO7 on the header you should be 
# using GPIO4 in this script. Likewise if you want to activate GPIO0
# on the header you should be using GPIO17 here.

# Set up GPIO 4 and set to output
echo "4" > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio4/direction

# Set up GPIO 7 and set to input
echo "7" > /sys/class/gpio/export
echo "in" > /sys/class/gpio/gpio7/direction

# Write output
echo "1" > /sys/class/gpio/gpio4/value

# Read from input
cat /sys/class/gpio/gpio7/value 

# Clean up
echo "4" > /sys/class/gpio/unexport
echo "7" > /sys/class/gpio/unexport

wiringPi - gpio utility

You need the wiringPi library from https://projects.drogon.net/raspberry-pi/wiringpi/download-and-install/. Once installed, there is a new command gpio which can be used as a non-root user to control the GPIO pins.

The man page

man gpio

has full details, but briefly:

  gpio -g mode 17 out
  gpio -g mode 18 pwm

  gpio -g write 17 1
  gpio -g pwm 18 512

The -g flag tells the gpio program to use the BCM GPIO pin numbering scheme (otherwise it will use the wiringPi numbering scheme by default).

The gpio command can also control the internal pull-up and pull-down resistors:

  gpio -g mode 17 up

This sets the pull-up resistor - however any change of mode, even setting a pin that's already set as an input to an input will remove the pull-up/pull-down resistors, so they may need to be reset.

Additionally, it can export/un-export the GPIO devices for use by other non-root programms - e.g. Python scripts. (Although you may need to drop the calls to GPIO.Setup() in the Python scripts, and do the setup separately in a little shell script, or call the gpio program from inside Python).

  gpio export 17 out
  gpio export 18 in

These exports GPIO-17 and sets it to output, and exports GPIO-18 and sets it to input.

And when done:

  gpio unexport 17

The export/unexport commands always use the BCM GPIO pin numbers regardless of the presence of the -g flag or not.

If you want to use the internal pull-up/down's with the /sys/class/gpio mechanisms, then you can set them after exporting them. So:

  gpio -g export 4 in
  gpio -g mode 4 up

You can then use GPIO-4 as an input in your Python, Shell, Java, etc. programs without the use of an external resistor to pull the pin high. (If that's what you were after - for example, a simple push button switch taking the pin to ground.)

A fully working example of a shell script using the GPIO pins can be found at http://project-downloads.drogon.net/files/gpioExamples/tuxx.sh.

pigpio - pigs utility

pigpio provides a command line utility pigs.

pigs provides all the standard gpio features.

In addition it provides hardware timed PWM suitable for servos, LEDs, and motors.

Use man pigs or view the pigs documentation at http://abyz.co.uk/rpi/pigpio/pigs.html

Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html

Additional error information may be reported to /dev/pigerr. The following command will display any errors.

cat /dev/pigerr &

Examples

pigs modes 4 w # set gpio4 as output (write)
pigs modes 17 w # set gpio17 as output (write)
pigs modes 23 r # set gpio23 as input (read)
pigs modes 24 0 # set gpio24 as ALT0

pigs servo 4 1500 # start 1500 us servo pulses on gpio4

pigs pwm 17 192 # start 75% dutycycle PWM on gpio17 (192/255 = 75%)

pigs r 23 # read gpio23

pigs w 24 1 # write 1 to gpio 24

# servo may be abbreviated to s
# pwm may be abbreviated to p
# modes may be abbreviated to m

pigs s 4 0 # stop servo pulses

pigs p 17 0 # stop pwm

pigs requires that the pigpio daemon be running.

sudo pigpiod

For an example pigs script see x_pigs in the pigpio archive.

pigpio - /dev/pigpio interface

pigpio provides command line access via the /dev/pigpio pipe.

/dev/pigpio provides all the standard gpio features.

In addition it provides hardware timed PWM suitable for servos, LEDs, and motors.

The command set is identical to that used by pigs. Use man pigs or view the pigs documentation at http://abyz.co.uk/rpi/pigpio/pigs.html

Download and install pigpio: http://abyz.co.uk/rpi/pigpio/download.html

The result of /dev/pigpio commands are written to /dev/pigout. The following command will display the results.

cat /dev/pigout &

Errors are reported to /dev/pigerr. The following command will display any errors.

cat /dev/pigerr &

Examples

echo modes 4 w >/dev/pigpio # set gpio4 as output (write)
echo modes 17 w  >/dev/pigpio # set gpio17 as output (write)
echo modes 23 r  >/dev/pigpio # set gpio23 as input (read)
echo modes 24 0  >/dev/pigpio # set gpio24 as ALT0

echo servo 4 1500  >/dev/pigpio # start 1500 us servo pulses on gpio4

echo pwm 17 192  >/dev/pigpio # start 75% dutycycle PWM on gpio17 (192/255 = 75%)

echo r 23  >/dev/pigpio # read gpio23

echo w 24 1  >/dev/pigpio # write 1 to gpio 24

# servo may be abbreviated to s
# pwm may be abbreviated to p
# modes may be abbreviated to m

echo s 4 0  >/dev/pigpio # stop servo pulses

echo p 17 0  >/dev/pigpio # stop pwm

The /dev/pigpio pipe interface requires that the pigpio daemon be running.

sudo pigpiod

For an example /dev/pigpio pipe script see x_pipe in the pigpio archive.

Lazarus / Free Pascal

A simple app for controlling GPIO pin 17 with Lazarus

The GPIO pins are accessible from Lazarus without any third-party software. This is performed by means of the BaseUnix unit that is part of every distribution of Lazarus and Free Pascal or by invoking Unix shell commands with fpsystem. The following example uses GPIO pin 17 as output port. It is assumed that you created a form named GPIO17ToggleBox with a TToggleBox and a TMemo named LogMemo (optional, for logging purposes). The program has to be executed with root privileges.

Unit for controlling the GPIO port:

unit Unit1;

{Demo application for GPIO on Raspberry Pi}
{Inspired by the Python input/output demo application by Gareth Halfacree}
{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, 
  Dialogs, StdCtrls, Unix, BaseUnix;

type

  { TForm1 }

  TForm1 = class(TForm)
    LogMemo: TMemo;
    GPIO17ToggleBox: TToggleBox;
    procedure FormActivate(Sender: TObject);
    procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
    procedure GPIO17ToggleBoxChange(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;

const
  PIN_17: PChar = '17';
  PIN_ON: PChar = '1';
  PIN_OFF: PChar = '0';
  OUT_DIRECTION: PChar = 'out';

var
  Form1: TForm1;
  gReturnCode: longint; {stores the result of the IO operation}

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormActivate(Sender: TObject);
var
  fileDesc: integer;
begin
  { Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
  try
    fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
    gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
    LogMemo.Lines.Add(IntToStr(gReturnCode));
  finally
    gReturnCode := fpclose(fileDesc);
    LogMemo.Lines.Add(IntToStr(gReturnCode));
  end;
  { Set SoC pin 17 as output: }
  try
    fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
    gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
    LogMemo.Lines.Add(IntToStr(gReturnCode));
  finally
    gReturnCode := fpclose(fileDesc);
    LogMemo.Lines.Add(IntToStr(gReturnCode));
  end;
end;

procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
var
  fileDesc: integer;
begin
  { Free SoC pin 17: }
  try
    fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
    gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
    LogMemo.Lines.Add(IntToStr(gReturnCode));
  finally
    gReturnCode := fpclose(fileDesc);
    LogMemo.Lines.Add(IntToStr(gReturnCode));
  end;
end;

procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
var
  fileDesc: integer;
begin
  if GPIO17ToggleBox.Checked then
  begin
    { Swith SoC pin 17 on: }
    try
      fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
      gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
      LogMemo.Lines.Add(IntToStr(gReturnCode));
    finally
      gReturnCode := fpclose(fileDesc);
      LogMemo.Lines.Add(IntToStr(gReturnCode));
    end;
  end
  else
  begin
    { Switch SoC pin 17 off: }
    try
      fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
      gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
      LogMemo.Lines.Add(IntToStr(gReturnCode));
    finally
      gReturnCode := fpclose(fileDesc);
      LogMemo.Lines.Add(IntToStr(gReturnCode));
    end;
  end;
end;

end.

Main program:

program io_test;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Interfaces, // this includes the LCL widgetset
  Forms, Unit1
  { you can add units after this };

{$R *.res}

begin
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
end.

Alternative way to access the GPIO port with Lazarus / Free Pascal is by using Lazarus wrapper unit for Gordon Henderson's wiringPi C library or encapsulated shell calls.

The Lazarus wiki describes a demo program that can read the status of a GPIO pin.

BASIC

BASIC - Return to BASIC

'Return to Basic' (RTB) can be found here.

It is a new BASIC featuring modern looping constructs, switch statements, named procedures and functions as well as graphics (Cartesian and turtle), file handling and more. It also supports the Pi's on-board GPIO without needing to be run as root. (You do not need any special setup routines either)

Sample blink program:

// blink.rtb:
//    Blink program in Return to Basic
//    Gordon Henderson, projects@drogon.net
//
PinMode (0, 1) // Output
CYCLE 
  DigitalWrite (0, 1) // Pin 0 ON
  WAIT (0.5) // 0.5 seconds
  DigitalWrite (0, 0)
  WAIT (0.5)
REPEAT 
END 

BASIC

Bywater BASIC Interpreter

The Bywater BASIC Interpreter (bwBASIC) implements a large superset of the ANSI Standard for Minimal BASIC (X3.60-1978) and a significant subset of the ANSI Standard for Full BASIC (X3.113-1987) in C. It also offers shell programming facilities as an extension of BASIC. bwBASIC seeks to be as portable as possible and is downloadable.[25]

BASIC programming of the I/O

Setting up a GPIO pin to be used for inputs or for outputs.

The control words cannot be loaded directly into the 32 bit ARM registers with 32 bit addresses, as bwBASIC has no POKE and PEEK commands and other versions of BASIC only handle 8 bit registers with 16 bit addresses with these commands. So the GPIO pins need to be exported so that they exist in a file structure which can be accessed from basic with the OPEN command (ref 2).

This must be done in Linux root. BASIC must be run in the root too.

sudo -1
sudo bwbasic

Now to export GPIO pin 4 for example, using a Shell command.

echo "4" >  /sys/class/gpio/export

Whilst bwbasic can accommodate shell commands, and we can store a set of these commands (eg. to export a number of GPIO pins at the outset) as numbered statements in a file that can be loaded with the basic command LOAD "filename" and RUN (ref 2), the shell commands have to run as a separate file, as they cannot be run from within, as part of a basic program.

Now the file containing the pin direction setting from BASIC can be accessed.

GPIO pin 4 can be set to input or output by OPENing its pin direction file for output and writing "in" or "out" with a PRINT# command.[26]

10 OPEN O",#1, "/sys/devices/virtual/gpio/gpio4/direction",2
20 PRINT #1,"out"
30 CLOSE #1

This closes the open direction file, whereupon the system performs the action of setting the direction to "out". The system only carries out the action as the file is closed.[27]

Now the output of the gpio 4 pin can be controlled from BASIC.

GPIO 4 pin can be set to 1 or to 0 by OPENing its pin value file for output and writing "1" or "0" with a PRINT# command.

40 OPEN "O",#4, "/sys/devices/virtual/gpio/gpio4/value",1
50 PRINT #4,"1"
60 CLOSE #4

Similarly the output of GPIO pin 4 can be turned off.

OPEN O,#4, /sys/devices/virtual/gpio/gpio4/value,1
PRINT #4,0
CLOSE #4.
Example of an (unstructured) BASIC program

To read the state of a switch and control the power to two LEDs connected to GPIO pins 8,7 and 4 respectively.

Program to set 2 pins as outputs and 1 pin as input and to read the input turning on two different combinations of the two outputs (ie output 0,1 or 1,0) depending on the state of the input (1 or 0).

sudo i
sudo bwbasic
LOAD export.bas
LIST
REM a set of Shell statements to export the three GPIO pins.
10 echo 4 > /sys/class/gpio/export
20 echo 7 > /sys/class/gpio/export
30 echo 8 > /sys/class/gpio/export
RUN

NEW clears the export.bas program from memory

LOAD demo1.bas
LIST
10 OPEN O,#1, /sys/devices/virtual/gpio/gpio4/direction,2 
20 OPEN O,#2, /sys/devices/virtual/gpio/gpio7/direction,2 
30 OPEN O,#3, /sys/devices/virtual/gpio/gpio8/direction,2
REM opens the three pin direction files
40 PRINT #1, out
50 PRINT #2, out
60 PRINT #3, in
REM sets GPIO pins 4 and 7 as outputs and GPIO pin 8 as input.
70 CLOSE #1
80 CLOSE #2
90 CLOSE #3
REM closes all open files, allowing the system to perform the direction settings.
100 OPEN I,#8, /sys/devices/virtual/gpio/gpio8/value,1
REM opens the GPIO pin 8 value file
110 INPUT #8,x
REM reads the value of the input pin and stores the value in numerical variable x
120 CLOSE #8
REM closes the open file, allowing the system to read the value of the input pin and store the value in numerical variable x.
130 OPEN O,#1, /sys/devices/virtual/gpio/gpio4/value,1
140 OPEN O,#2, /sys/devices/virtual/gpio/gpio7/value,1
REM opens the GPIO pins 4 and value files ready for outputting 1s and 0s.
150 IF x<1 THEN GOTO 160 ELSE GOTO 190
REM tests the state of the switch (1 or0) and directs the program to generate the appropriate outputs
160 PRINT #1,1
170 PRINT #2,0
180 GOTO 210
190  PRINT#1,"0"
200 PRINT #2,"1"
210 CLOSE #1
220 CLOSE #2
REM Closes the files and allows the outputs to light the LED
230 END.

When all is done, the GPIO pins should be unexported, to leave the R-Pi as we found it.[28]

NEW
LOAD unexport.bas
LIST
REM a set of Shell statements to unexport the three GPIO pins.
10 echo 4 > /sys/class/gpio/unexport
20 echo 7 > /sys/class/gpio/unexport
30 echo 8 > /sys/class/gpio/unexport
RUN

A simple circuit to provide the switched input and the two LED outputs.[29]

For the two original documents this example has been copied from, see:

  1. GPIO_Driving_Example_(BASIC)_.doc
  2. Raspberry_Pi_I-O_viii.doc

SPI

There is one SPI bus brought out to the header: RPi_SPI

I²C

There are two I²C-buses on the Raspberry Pi: One on P1, and one on P5.

Note that there's a bug concerning I²C-clock-stretching, so don't use I²C-devices which use clock-stretching directly with the Raspberry Pi, or use a workaround. Details about this bug can be found at:

MIPI CSI-2

On the production board[30], the Raspberry Pi Foundation design brings out the MIPI CSI-2 (Camera Serial Interface[31]) to a 15-way flat flex connector S5, between the Ethernet and HDMI connectors. A compatible camera[32] with 5 Megapixels and 1080p video resolution was released in May 2013.

DSI

On the production board, the Raspberry Pi Foundation design brings out the DSI (Display Serial Interface[33]) to a 15-way flat flex connector labelled S2, next to Raspberry Pi logo. It has two data lanes and a clock lane, to drive a possible future LCD screen device. Some smart phone screens use DSI[34].

CEC

HDMI-CEC (Consumer Electronics Control for HDMI) is supported by hardware but some driver work will be needed and currently isn't exposed into Linux userland. Eben notes that he has seen CEC demos on the Broadcom SoC they are using.

libCEC with Raspberry Pi support has been included in OpenELEC and will be included in Raspbmc RC4.[35]

For more information about HDMI-CEC and what you could do with it on the Raspberry Pi please see the CEC (Consumer Electronics Control) over HDMI article.

References

  1. raspberrypi.org
  2. raspberrypi.org
  3. raspberrypi.org
  4. raspberrypi.org
  5. raspberrypi.org
  6. http://www.raspberrypi.org/archives/384#comment-5217
  7. http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf
  8. http://www.raspberrypi.org/phpBB3/viewtopic.php?f=44&t=7509
  9. http://www.raspberrypi.org/downloads
  10. http://www.raspberrypi.org/forum/projects-and-collaboration-general/gpio-header-pinout-clarification/page-2
  11. http://www.raspberrypi.org/forum/features-and-requests/easy-gpio-hardware-software/page-6/#p56480
  12. http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1288.1
  13. Forum:Sad about removal of I2S. Why was this change made?
  14. http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1288.2
  15. http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1536#postid-21841
  16. http://www.raspberrypi.org/phpBB3/viewtopic.php?f=24&t=5894
  17. http://www.raspberrypi.org/phpBB3/viewtopic.php?f=24&t=5894
  18. raspi.tv
  19. http://www.raspberrypi.org/forum?mingleforumaction=viewtopic&t=1278.0
  20. http://www.bootc.net/projects/raspberry-pi-kernel/
  21. http://www.raspberrypi.org/phpBB3/viewtopic.php?p=86172#p86172
  22. http://www.raspberrypi.org/forum/general-discussion/wiring-for-the-raspberry-pis-gpio
  23. http://pi4j.com/usage.html#Pin_Numbering
  24. https://projects.drogon.net/raspberry-pi/wiringpi/pins/
  25. packages.debian.org
  26. Ed Beynon, ybw.com
  27. Arthur Kaletzky. Private communication. 25/10/2012
  28. This paper RPi Low-level peripherals.
  29. Ancient Mariner. Dec. 2012
  30. http://www.raspberrypi.org/wp-content/uploads/2012/04/Raspberry-Pi-Schematics-R1.0.pdf
  31. http://www.mipi.org/specifications/camera-interface
  32. http://elinux.org/Rpi_Camera_Module
  33. http://www.mipi.org/specifications/display-interface
  34. http://en.wikipedia.org/wiki/Display_Serial_Interface
  35. http://blog.pulse-eight.com/2012/08/01/libcec-1-8-0-a-firmware-upgrade-and-raspberry-pi-support/