1. Raspberry Pi GPIO Pin naming conventions Using sysfs
Using the Wiring library
Git and Github

2. Pi Overview
So far we have tried to setup a “headless” connection to your Pi in this classroom.
Serial with the FTDI cable
Ethernet on the CS LAN
WiFi in Rhodes-Robinson Hall
a hidden network managed by ITS
You must demonstrate your ability to connect to your Pi using at least two of these three methods in order to receive a passing grade in this class.
This can be done at any point through out the remainder of the semester---I will keep a list on Moodle
There are now over ten workstations configured in the CS lab (RRO 223) to support a monitor, keyboard, and mouse connection.
This is an easier to get things working properly
try it out, but put all the cables back!

3. Pi Overview We’ve learned a little about the Pi
BCM 2835 processor, 3.3V (3V3) power on pins, SD card is like the hard drive,…
We’ve learned a little about Linux
The root directory: / , the super user designation: sudo, change permissions: chmod ugo+x filename, …
We’ve learned a little about networking
ssh
ifconfig
The contents of the file: /etc/network/interfaces
Today, our focus is on using the Pi as an embedded system controller

4. Pi Setup for Today
Will also need a WiFi or an Ethernet connection
Connect to power adapter not the USB port of your computer
Pin 1 is the colored wire-must connect to pin 1 on the Pi
Because the cobbler connector has a notch, you can only put the cable in the right way
But, it is possible to put the cable in upside down on the Raspberry Pi

5. RPi General Purpose IO (GPIO) Pins
17 GPIO pins brought out onto the P1 header
most have alternated functions
two pins for UART; two for I2C; six for SPI
All 17 pins can be GPIO (i.e., INPUT or OUTPUT)
all support interrupts
internal pull-ups & pull-downs for each pin
I2C pins have onboard pull-ups
using them for GPIO may not work
Pins are 3.3V not 5V like on the Arduino
They are connected directly to the Broadcom chip
Sending 5V to a pin may kill the Pi
Maximum permitted current draw from a 3.3V pin is 50mA
Image credit:

6. The Bigger Picture
(image credit:
Diagram includes BCM GPIO references (GPIO.BCM), common
functions, WiringPi pin references, and Pin numbers (GPIO.BOARD).
A cheat nice sheet

7. Using the GPIO Pins
There are two different methods to read or write these pins using Linux
Creating a file-type access in the file system
Write/read memory addresses allocated to the GPIO peripheral of the SoC using pointers
Memory locations can be found in the datasheet for the BCM2835 
We can use the Wiring library to help with both

8. Connect an LED using a resistor between GPIO 17 (P1-11) and GND
The LED will initially be off because the GPIO pins are initialized as inputs at power-on (except for TXD).

9. Using the File System
Create and run the following shell script (blink.sh) using sudo: sudo ./blink.sh
#!/bin/sh echo 17 > /sys/class/gpio/export echo out > /sys/class/gpio/gpio17/direction while true do         echo 1 > /sys/class/gpio/gpio17/value
sleep 1         echo 0 > /sys/class/gpio/gpio17/value
sleep 1 done
Make the pin available for other applications using with the command: echo 17 > /sys/class/gpio/unexport

10. More Detail Create a shell script using nano: nano blink.sh
Cut and paste the previous slide to nano window
Ctrl-w to save then Ctrl-x to exit nano
Change the permissions on blink.sh: chmod 755 blink.sh
Run blink.sh: sudo ./blink.sh (in directory where blink.sh is stored)
After running the script your LED should be blinking endlessly. Give the command: Ctrl-c Ctrl-c to abort the script
All of the commands in the script can be issued one at a time on the command line; beginning by giving the commands: sudo -i to run a root shell---notice the change in the prompt
Look at the files and their contents in directory /sys/class/gpio/ and its subdirectories --- see next slide

11. Understanding /sys/class/gpio/
In Linux everything is a file: /dev/ttyUSB0, /sys/class/net/eth0/address, /dev/mmcblk0p2,…
sysfs in a kernel module providing a virtual file system for device access at /sys/class
provides a way for users (or code in the user-space) to interact with devices at the system (kernel) level
A demo
Advantages / Disadvantage
Allows conventional access to pins from userspace
Always involves mode switch to kernel, action in kernel, mode switch to use, and could have a context switch
Much slower the digitalWrite()/digitalRead() of Arduino

12. A C program to do the same thing
GPIO with sysfs on Raspberry Pi (Part 2)
Code on Github
Beware: the code assumes a Rev1 pinout

13. Github
The heart of GitHub is Git, an open source project started by Linux creator Linus Torvalds
Git manages and stores revisions of projects
Think of it as a filing system for every draft of a document
Git is a command line tool
GitHub provides a Web-based graphical interface
Basic functionality

14. Introducing the WiringPi library
A GPIO access library written in C for the BCM2835
Writes/reads the base address of the memory allocated to the GPIO
Similar to the Wiring library in the Arduino used to make common IO operations easier
Features:
command-line utility gpio
supports analog reading and writing
More
Install the Wiring Pi library following these instructions

15. Wiring Pin Numbers
Image credit:

16. Blinking lights with Wiring
#include <stdio.h>
#include <wiringPi.h>
// LED Pin - wiringPi pin 0 is BCM_GPIO 17.
#define LED 0
int main (void) {
printf ("Raspberry Pi blink\n") ;
wiringPiSetup () ; //  note the setup method chosen
pinMode (LED, OUTPUT) ;
for (;;) {
digitalWrite (LED, HIGH) ; // On
delay (500) ; // mS
digitalWrite (LED, LOW) ; // Off
delay (500) ; }
return 0 ;

17. Running blink Compile and run the blink program
gcc -Wall -o blink blink.c -lwiringPi  compile
sudo ./blink  run
Runs forever---kill with the command ctrl-c ctrl-c
Note: One of the four wiring setup functions must be called at the start of your program or your program will not work correctly

18. Accessing memory allocated to the GPIO
/dev/mem provides user-level access to SoC memory
Offset 0x is a address of BCM peripherals
wiringPi.c writes to that area of memory to control the pins

19. Controlling a Servo with the Pi
Controlling the servos requires PWM, aka Pulse Width Modulation
The Arduino does this very well, the Raspberry Pi does it less well
The Arduino program has complete control of the microcontroller
when it is running loop() nothing else can use the CPU
Except for interrupt handlers written as part of the Arduino program
On the Raspberry Pi, your program runs within a Linux OS
The Linux OS may switch to running another program!
But you can change your program’s scheduling priority
Some ways of getting the Pi to give the impression that it is a real time system and to do PWM ‘properly’:
Gordon Henderson has written about an improvement to the WiringPi library to allow threaded PWM on every GPIO pin taking up 0.1% of the CPU each
Rahul Kar has blogged about using the WiringPi library and PWM
WiringPi recommends ServoBlaster

20. Connect a Parallax Servo
Servo Connector:
Black – Pi’s ground
Red – Pi’s 5V
White – signal on GPIO 17
Image credit:
NOTE: For a single small servo you can take the 5 volts for it from the Pi header, but doing anything non-trivial with four servos connected pulls the 5 volts down far enough to crash the Pi

21. Using WiringPi’s servo example
#include <stdio.h> #include <errno.h> #include <string.h> #include <wiringPi.h> #include <softServo.h> int main () { if (wiringPiSetup () == -1) { // setup to use Wiring pin numbers fprintf (stdout, "oops: %s\n", strerror (errno)) ; return 1 ; } softServoSetup (0, 1, 2, 3, 4, 5, 6, 7) ; // wiringPi pin numbers for (;;) { softServoWrite (0, 0) ; // wiringPi pin 0 is BCM_GPIO 17 delay (1000) ; softServoWrite (0, 500) ; delay (1000); softServoWrite (0, 1000) ;

22. Running servo.c To compile: gcc -Wall -o servo servo.c
wiringPi/wiringPi/softServo.c  compile softServo.c
-IwiringPi/wiringPi  path to softServo.c
-lwiringPi  include wiring library
To run: sudo ./servo
Calling softServoWrite () ;
The 1st input is the pin number
The 2nd input should be from 0 (hard left) to 1000 (hard right).
The 2nd input refers to the number of microseconds of the pulse.
An input of 0 produces a 1000uSec (1mSec) pulse (hard left)
An input of 1000 produces a 2000uSec (2mSec) pulse (hard right)
An input of 500 produces a 1500uSec (1.5 mSec) pulse (stop)

23. Using the gpio utility
The program gpio can be used in scripts to manipulate the GPIO pins
The gpio command is designed to be called by a normal user without using the sudo command or logging in as root
Try at the command line:
gpio mode 0 out
gpio write 0 1
Sets pin 0 as output and then sets the pin to high
More info on the gpio utility

24. And There’s more WiringPi provides support for C programming
There’s a lot of support for programming in Python: