Updated from git.drogon.net

INSTALL

@@ -30,18 +30,6 @@ To un-install wiringPi:
 
   ./build uninstall
 
-
-I2C:
-
-If your system has the correct i2c-dev libraries and headers installed,
-then the I2C helpers will be compiled into wiringPi. If you want to
-use the I2C helpers and don't have them installed, then under Raspbian,
-issue the command:
-
-  sudo apt-get install libi2c-dev
-
-Consult the documentation for your system if you are not running Raspbian.
-
 Gordon Henderson
 
 projects@drogon.net

People

@@ -25,3 +25,9 @@ CHARLES Thibaut:
 
 Xian Stannard
   Fixing some typos in the man page!
+
+Andre Crone
+  Suggested the __WIRING_PI.H__ round wiringPi.h
+
+Rik Teerling
+  Pointing out some silly mistooks in the I2C code...

README.TXT

@@ -16,7 +16,7 @@ accepted to Github....
 
 Please see
 
-  https://projects.drogon.net/raspberry-pi/wiringpi/
+  http://wiringpi.com/
 
 for the official documentation, etc. and the best way to submit bug reports, etc.
 is by sending an email to projects@drogon.net

VERSION

@@ -0,0 +1 @@
+2.31

build

@@ -1,7 +1,37 @@
-#!/bin/bash
+#!/bin/sh -e
 
-check-make-ok()
-{
+# build
+#	Simple wiringPi build and install script
+#
+#	Copyright (c) 2012-2015 Gordon Henderson
+#################################################################################
+# This file is part of wiringPi:
+#	Wiring Compatable library for the Raspberry Pi
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#################################################################################
+#
+# wiringPi is designed to run on a Raspberry Pi only.
+#	However if you're clever enough to actually look at this script to
+#	see why it's not building for you, then good luck.
+#
+#	To everyone else: Stop using cheap alternatives. Support the
+#	Raspberry Pi Foundation	as they're the only ones putting money
+#	back into education!
+#################################################################################
+
+check_make_ok() {
   if [ $? != 0 ]; then
     echo ""
     echo "Make Failed..."
@@ -13,67 +43,120 @@ check-make-ok()
   fi
 }
 
+sudo=${WIRINGPI_SUDO-sudo}
+
 if [ x$1 = "xclean" ]; then
-  echo Cleaning
-  echo
   cd wiringPi
-  make clean
+  echo -n "wiringPi:   "	; make clean
+  cd ../devLib
+  echo -n "DevLib:     "	; make clean
   cd ../gpio
-  make clean
+  echo -n "gpio:       "	; make clean
   cd ../examples
-  make clean
+  echo -n "Examples:   "	; make clean
+  cd Gertboard
+  echo -n "Gertboard:  "	; make clean
+  cd ../PiFace
+  echo -n "PiFace:     "	; make clean
+  cd ../q2w
+  echo -n "Quick2Wire: "	; make clean
+  cd ../PiGlow
+  echo -n "PiGlow:     "	; make clean
   exit
 fi
 
 if [ x$1 = "xuninstall" ]; then
-  echo Uninstalling
-  echo
-  echo "WiringPi library"
   cd wiringPi
-  sudo make uninstall
-  echo
-  echo "GPIO Utility"
+  echo -n "wiringPi: " ; $sudo make uninstall
+  cd ../devLib
+  echo -n "DevLib:   " ; $sudo make uninstall
   cd ../gpio
-  sudo make uninstall
-  cd ..
+  echo -n "gpio:     " ; $sudo make uninstall
+  exit
+fi
+
+# Only if you know what you're doing!
+
+if [ x$1 = "xdebian" ]; then
+  here=`pwd`
+  cd debian-template/wiringPi
+  rm -rf usr
+  cd $here/wiringPi
+  make install-deb
+  cd $here/devLib
+  make install-deb INCLUDE='-I. -I../wiringPi'
+  cd $here/gpio
+  make install-deb INCLUDE='-I../wiringPi -I../devLib' LDFLAGS=-L../debian-template/wiringPi/usr/lib
+  cd $here/debian-template
+  fakeroot dpkg-deb --build wiringPi
+  mv wiringPi.deb  wiringpi-`cat $here/VERSION`-1.deb
   exit
 fi
 
+if [ x$1 != "x" ]; then
+  echo "Usage: $0 [clean | uninstall]"
+  exit 1
+fi
 
   echo "wiringPi Build script"
   echo "====================="
   echo
 
-# Check for I2C being installed...
-#	... and if-so, then automatically make the I2C helpers
-
-  if [ -f /usr/include/linux/i2c-dev.h ]; then
-    grep -q i2c_smbus_read_byte /usr/include/linux/i2c-dev.h
-    if [ $? = 0 ]; then
-      target=i2c
-      echo "Building wiringPi with the I2C helper libraries."
-    else
-      target=all
-      echo "The wiringPi I2C helper libraries will not be built."
-    fi
-  fi
+  hardware=`fgrep Hardware /proc/cpuinfo | head -1 | awk '{ print $3 }'`
+
+#  if [ x$hardware != "xBCM2708" ]; then
+#    echo ""
+#    echo "   +------------------------------------------------------------+"
+#    echo "   |   wiringPi is designed to run on the Raspberry Pi only.    |"
+#    echo "   |   This processor does not appear to be a Raspberry Pi.     |"
+#    echo "   +------------------------------------------------------------+"
+#    echo "   | In the unlikely event that you think it is a Raspberry Pi, |"
+#    echo "   | then please accept my apologies and email the contents of  |"
+#    echo "   | /proc/cpuinfo to projects@drogon.net.                      |"
+#    echo "   |    - Thanks, Gordon                                        |"
+#    echo "   +------------------------------------------------------------+"
+#    echo ""
+#    exit 1
+#  fi
+
 
   echo
-  echo "WiringPi library"
+  echo "WiringPi Library"
   cd wiringPi
-  sudo make uninstall
-  make $target
-  check-make-ok
-  sudo make install
-  check-make-ok
+  $sudo make uninstall
+  if [ x$1 = "xstatic" ]; then
+    make -j5 static
+    check_make_ok
+    $sudo make install-static
+  else
+    make -j5
+    check_make_ok
+    $sudo make install
+  fi
+  check_make_ok
+
+  echo
+  echo "WiringPi Devices Library"
+  cd ../devLib
+  $sudo make uninstall
+  if [ x$1 = "xstatic" ]; then
+    make -j5 static
+    check_make_ok
+    $sudo make install-static
+  else
+    make -j5
+    check_make_ok
+    $sudo make install
+  fi
+  check_make_ok
 
   echo
   echo "GPIO Utility"
   cd ../gpio
-  make
-  check-make-ok
-  sudo make install
-  check-make-ok
+  make -j5
+  check_make_ok
+  $sudo make install
+  check_make_ok
 
 # echo
 # echo "Examples"
@@ -83,3 +166,11 @@ fi
 
 echo
 echo All Done.
+echo ""
+echo "NOTE: To compile programs with wiringPi, you need to add:"
+echo "    -lwiringPi"
+echo "  to your compile line(s) To use the Gertboard, MaxDetect, etc."
+echo "  code (the devLib), you need to also add:"
+echo "    -lwiringPiDev"
+echo "  to your compile line(s)."
+echo ""

debian-template/wiringPi/DEBIAN/control

@@ -0,0 +1,10 @@
+Package: wiringpi
+Version: 2.31
+Section: libraries
+Priority: optional
+Architecture: armhf
+Depends: libc6
+Maintainer: Gordon Henderson <projects@drogon.net>
+Description: The wiringPi libraries, headers and gpio command
+  Libraries to allow GPIO access on a Raspberry Pi from C and C++
+  programs as well as from the command-line

debian-template/wiringPi/DEBIAN/postinst

@@ -0,0 +1,5 @@
+#!/bin/sh
+set -e
+/bin/chown root.root	/usr/bin/gpio
+/bin/chmod 4755		/usr/bin/gpio
+/sbin/ldconfig

debian-template/wiringPi/DEBIAN/postrm

@@ -0,0 +1,2 @@
+#!/bin/sh
+/sbin/ldconfig

debian/.gitignore

@@ -0,0 +1,9 @@
+*.debhelper.log
+*.substvars
+tmp
+wiringpi
+libwiringpi2
+libwiringpi-dev
+files
+*.postinst.debhelper
+*.postrm.debhelper

debian/changelog

@@ -0,0 +1,6 @@
+wiringpi (2.26~iwj) rpi-unstable; urgency=low
+
+  * Initial version with real Debian source package build.
+
+ -- Ian Jackson <ijackson@chiark.greenend.org.uk>  Sat, 12 Sep 2015 18:31:35 +0100
+

debian/compat

@@ -0,0 +1 @@
+8

debian/control

@@ -0,0 +1,29 @@
+Source: wiringpi
+Section: electronics
+Priority: optional
+Maintainer: Ian Jackson <ijackson@chiark.greenend.org.uk>
+Standards-Version: 3.8.0
+Homepage: http://wiringpi.com/
+Build-Depends: debhelper (>= 8)
+
+Package: libwiringpi2
+Section: libs
+Architecture: armhf
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: GPIO librariees for Raspberry Pi (runtime).
+ Runtime for the popular wiringPi library.
+
+Package: wiringpi
+Architecture: armhf
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: gpio utility for Raspberry Pi
+ The wiringPi gpio command line utility, for GPIO access on a
+ Raspberry Pi from the command line.
+
+Package: libwiringpi-dev
+Architecture: armhf
+Depends: libwiringpi2 (= ${binary:Version}), libc6-dev, ${misc:Depends}
+Suggests: wiringpi
+Description: GPIO development library for Raspberry Pi
+ Development libraries to allow GPIO access on a Raspberry Pi from C
+ and C++ programs.

debian/copyright

@@ -0,0 +1,15 @@
+wiringPi is Copyright (C) 2012-2015 Gordon Henderson.
+
+wiringPi is free software; you can redistribute it and/or modify it
+under the terms of the GNU Lesser General Public License, as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+wiringPi is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+On all Debian and Raspbian systems, a copy of the GNU Lesser General
+Public License version 3 can be found in
+`/usr/share/common-licenses/LGPL-3'.

debian/libwiringpi-dev.dirs

@@ -0,0 +1,2 @@
+usr/lib
+usr/include

debian/libwiringpi-dev.install

@@ -0,0 +1,3 @@
+debian/tmp/usr/include
+debian/tmp/usr/lib/*.so
+examples		usr/share/doc/libwiringpi-dev

debian/libwiringpi2.install

@@ -0,0 +1 @@
+debian/tmp/usr/lib/lib*.so.*

debian/libwiringpi2.shlibs

@@ -0,0 +1,2 @@
+libwiringPi 2 libwiringpi2
+libwiringPiDev 2 libwiringpi2

debian/rules

@@ -0,0 +1,49 @@
+#!/usr/bin/make -f
+
+.PHONY: build
+
+VERSION:=$(shell cat VERSION)
+export VERSION
+
+soname:=$(shell echo $${VERSION%%.*})
+WIRINGPI_SONAME_SUFFIX:=.$(soname)
+export soname
+export WIRINGPI_SONAME_SUFFIX
+
+build:
+	dh $@
+
+override_dh_auto_configure:
+
+override_dh_prep:
+	dh_prep -Xdebian/tmp
+
+dirs:
+	dh_installdirs -A
+	mkdir debian/tmp
+	set -e; for p in `dh_listpackages`; do \
+		(cd debian/$$p; find -type d) | \
+		(cd debian/tmp; xargs mkdir -p) \
+	done
+
+override_dh_clean:
+	dh_clean
+	WIRINGPI_SUDO= bash -xe ./build clean
+
+override_dh_auto_build: dirs
+	V=1 LDCONFIG=: WIRINGPI_SUDO= WIRINGPI_SUID=0 \
+	    DESTDIR=`pwd`/debian/tmp/usr \
+	    PREFIX= WIRINGPI_SUDO= \
+	    bash -xe ./build
+
+override_dh_auto_install:
+	dh_install
+	set -ex; for l in libwiringPi libwiringPiDev; do \
+		ln -sf $$l.so.$${VERSION} \
+			debian/libwiringpi$$soname/usr/lib/$$l.so.$$soname; \
+		ln -sf $$l.so.$${VERSION} \
+			debian/libwiringpi-dev/usr/lib/$$l.so; \
+	done
+
+%:
+	dh $@

debian/wiringpi.dirs

@@ -0,0 +1 @@
+usr/bin

debian/wiringpi.install

@@ -0,0 +1,4 @@
+debian/tmp/usr/bin
+debian/tmp/usr/man	usr/share
+README.TXT		usr/share/doc/wiringpi
+People			usr/share/doc/wiringpi

devLib/Makefile

@@ -0,0 +1,137 @@
+#
+# Makefile:
+#	wiringPi device - Wiring Compatable library for the Raspberry Pi
+#
+#	Copyright (c) 2012-2015 Gordon Henderson
+#################################################################################
+# This file is part of wiringPi:
+#	https://projects.drogon.net/raspberry-pi/wiringpi/
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#################################################################################
+
+VERSION=$(shell cat ../VERSION)
+DESTDIR?=/usr
+PREFIX?=/local
+
+LDCONFIG?=ldconfig
+
+ifneq ($V,1)
+Q ?= @
+endif
+
+STATIC=libwiringPiDev.a
+DYNAMIC=libwiringPiDev.so.$(VERSION)
+
+#DEBUG	= -g -O0
+DEBUG	= -O2
+CC	= gcc
+INCLUDE	= -I.
+DEFS	= -D_GNU_SOURCE
+CFLAGS	= $(DEBUG) $(DEFS) -Wformat=2 -Wall -Winline $(INCLUDE) -pipe -fPIC
+
+LIBS    =
+
+###############################################################################
+
+SRC	=	ds1302.c maxdetect.c  piNes.c		\
+		gertboard.c piFace.c			\
+		lcd128x64.c lcd.c			\
+		piGlow.c
+
+OBJ	=	$(SRC:.c=.o)
+
+HEADERS	=	ds1302.h gertboard.h  lcd128x64.h  lcd.h  maxdetect.h piFace.h  piGlow.h  piNes.h
+
+all:		$(DYNAMIC)
+
+static:		$(STATIC)
+
+$(STATIC):	$(OBJ)
+	$Q echo "[Link (Static)]"
+	$Q ar rcs $(STATIC) $(OBJ)
+	$Q ranlib $(STATIC)
+#	@size   $(STATIC)
+
+$(DYNAMIC):	$(OBJ)
+	$Q echo "[Link (Dynamic)]"
+	$Q $(CC) -shared -Wl,-soname,libwiringPiDev.so$(WIRINGPI_SONAME_SUFFIX) -o libwiringPiDev.so.$(VERSION) -lpthread $(OBJ)
+
+.c.o:
+	$Q echo [Compile] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
+
+.PHONY:	clean
+clean:
+	$Q echo "[Clean]"
+	$Q rm -f $(OBJ) $(OBJ_I2C) *~ core tags Makefile.bak libwiringPiDev.*
+
+.PHONY:	tags
+tags:	$(SRC)
+	$Q echo [ctags]
+	$Q ctags $(SRC)
+
+
+.PHONY:	install
+install:	$(DYNAMIC)
+	$Q echo "[Install Headers]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/include
+	$Q install -m 0644 $(HEADERS)					$(DESTDIR)$(PREFIX)/include
+	$Q echo "[Install Dynamic Lib]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/lib
+	$Q install -m 0755 libwiringPiDev.so.$(VERSION)			$(DESTDIR)$(PREFIX)/lib/libwiringPiDev.so.$(VERSION)
+	$Q ln -sf $(DESTDIR)$(PREFIX)/lib/libwiringPiDev.so.$(VERSION)	$(DESTDIR)/lib/libwiringPiDev.so
+	$Q $(LDCONFIG)
+
+.PHONY:	install-static
+install-static:	$(STATIC)
+	$Q echo "[Install Headers]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/include
+	$Q install -m 0644 $(HEADERS)					$(DESTDIR)$(PREFIX)/include
+	$Q echo "[Install Static Lib]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/lib
+	$Q install -m 0755 libwiringPiDev.a				$(DESTDIR)$(PREFIX)/lib
+
+.PHONY:	install-deb
+install-deb:	$(DYNAMIC)
+	$Q echo "[Install Headers: deb]"
+	$Q install -m 0755 -d							~/wiringPi/debian-template/wiringPi/usr/include
+	$Q install -m 0644 $(HEADERS)						~/wiringPi/debian-template/wiringPi/usr/include
+	$Q echo "[Install Dynamic Lib: deb]"
+	install -m 0755 -d							~/wiringPi/debian-template/wiringPi/usr/lib
+	install -m 0755 libwiringPiDev.so.$(VERSION)				~/wiringPi/debian-template/wiringPi/usr/lib/libwiringPiDev.so.$(VERSION)
+	ln -sf ~/wiringPi/debian-template/wiringPi/usr/lib/libwiringPiDev.so.$(VERSION)	~/wiringPi/debian-template/wiringPi/usr/lib/libwiringPiDev.so
+
+.PHONY:	uninstall
+uninstall:
+	$Q echo "[UnInstall]"
+	$Q cd $(DESTDIR)$(PREFIX)/include/ && rm -f $(HEADERS)
+	$Q cd $(DESTDIR)$(PREFIX)/lib/     && rm -f libwiringPiDev.*
+	$Q $(LDCONFIG)
+
+
+.PHONY:	depend
+depend:
+	makedepend -Y $(SRC)
+
+# DO NOT DELETE
+
+ds1302.o: ds1302.h
+maxdetect.o: maxdetect.h
+piNes.o: piNes.h
+gertboard.o: gertboard.h
+piFace.o: piFace.h
+lcd128x64.o: font.h lcd128x64.h
+lcd.o: lcd.h
+piGlow.o: piGlow.h

devLib/ds1302.c

@@ -0,0 +1,240 @@
+/*
+ * ds1302.c:
+ *	Real Time clock
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+
+#include <wiringPi.h>
+
+#include "ds1302.h"
+
+// Register defines
+
+#define	RTC_SECS	 0
+#define	RTC_MINS	 1
+#define	RTC_HOURS	 2
+#define	RTC_DATE	 3
+#define	RTC_MONTH	 4
+#define	RTC_DAY		 5
+#define	RTC_YEAR	 6
+#define	RTC_WP		 7
+#define	RTC_TC		 8
+#define	RTC_BM		31
+
+
+// Locals
+
+static int dPin, cPin, sPin ;
+
+/*
+ * dsShiftIn:
+ *	Shift a number in from the chip, LSB first. Note that the data is
+ *	sampled on the trailing edge of the last clock, so it's valid immediately.
+ *********************************************************************************
+ */
+
+static unsigned int dsShiftIn (void)
+{
+  uint8_t value = 0 ;
+  int i ;
+
+  pinMode (dPin, INPUT) ;	delayMicroseconds (1) ;
+
+  for (i = 0 ; i < 8 ; ++i)
+  {
+    value |= (digitalRead (dPin) << i) ;
+    digitalWrite (cPin, HIGH) ; delayMicroseconds (1) ;
+    digitalWrite (cPin, LOW) ;	delayMicroseconds (1) ;
+  }
+
+  return value;
+}
+
+
+/*
+ * dsShiftOut:
+ *	A normal LSB-first shift-out, just slowed down a bit - the Pi is
+ *	a bit faster than the chip can handle.
+ *********************************************************************************
+ */
+
+static void dsShiftOut (unsigned int data)
+{
+  int i ;
+
+  pinMode (dPin, OUTPUT) ;
+
+  for (i = 0 ; i < 8 ; ++i)
+  {
+    digitalWrite (dPin, data & (1 << i)) ;	delayMicroseconds (1) ;
+    digitalWrite (cPin, HIGH) ;			delayMicroseconds (1) ;
+    digitalWrite (cPin, LOW) ;			delayMicroseconds (1) ;
+  }
+}
+
+
+/*
+ * ds1302regRead: ds1302regWrite:
+ *	Read/Write a value to an RTC Register or RAM location on the chip
+ *********************************************************************************
+ */
+
+static unsigned int ds1302regRead (const int reg)
+{
+  unsigned int data ;
+
+  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
+    dsShiftOut (reg) ;
+    data = dsShiftIn () ;
+  digitalWrite (sPin, LOW)  ; delayMicroseconds (1) ;
+
+  return data ;
+}
+
+static void ds1302regWrite (const int reg, const unsigned int data)
+{
+  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
+    dsShiftOut (reg) ;
+    dsShiftOut (data) ;
+  digitalWrite (sPin, LOW)  ; delayMicroseconds (1) ;
+}
+
+
+/*
+ * ds1302rtcWrite: ds1302rtcRead:
+ *	Writes/Reads the data to/from the RTC register
+ *********************************************************************************
+ */
+
+unsigned int ds1302rtcRead (const int reg)
+{
+  return ds1302regRead (0x81 | ((reg & 0x1F) << 1)) ;
+}
+
+void ds1302rtcWrite (int reg, unsigned int data)
+{
+  ds1302regWrite (0x80 | ((reg & 0x1F) << 1), data) ;
+}
+
+
+/*
+ * ds1302ramWrite: ds1302ramRead:
+ *	Writes/Reads the data to/from the RTC register
+ *********************************************************************************
+ */
+
+unsigned int ds1302ramRead (const int addr)
+{
+  return ds1302regRead (0xC1 | ((addr & 0x1F) << 1)) ;
+}
+
+void ds1302ramWrite (const int addr, const unsigned int data)
+{
+  ds1302regWrite ( 0xC0 | ((addr & 0x1F) << 1), data) ;
+}
+
+/*
+ * ds1302clockRead:
+ *	Read all 8 bytes of the clock in a single operation
+ *********************************************************************************
+ */
+
+void ds1302clockRead (int clockData [8])
+{
+  int i ;
+  unsigned int regVal = 0x81 | ((RTC_BM & 0x1F) << 1) ;
+
+  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
+
+  dsShiftOut (regVal) ;
+  for (i = 0 ; i < 8 ; ++i)
+    clockData [i] = dsShiftIn () ;
+
+  digitalWrite (sPin, LOW) ;  delayMicroseconds (1) ;
+}
+
+
+/*
+ * ds1302clockWrite:
+ *	Write all 8 bytes of the clock in a single operation
+ *********************************************************************************
+ */
+
+void ds1302clockWrite (const int clockData [8])
+{
+  int i ;
+  unsigned int regVal = 0x80 | ((RTC_BM & 0x1F) << 1) ;
+
+  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
+
+  dsShiftOut (regVal) ;
+  for (i = 0 ; i < 8 ; ++i)
+    dsShiftOut (clockData [i]) ;
+
+  digitalWrite (sPin, LOW) ;  delayMicroseconds (1) ;
+}
+
+
+/*
+ * ds1302trickleCharge:
+ *	Set the bits on the trickle charger.
+ *	Probably best left alone...
+ *********************************************************************************
+ */
+
+void ds1302trickleCharge (const int diodes, const int resistors)
+{
+  if (diodes + resistors == 0)
+    ds1302rtcWrite (RTC_TC, 0x5C) ;	// Disabled
+  else
+    ds1302rtcWrite (RTC_TC, 0xA0 | ((diodes & 3) << 2) | (resistors & 3)) ;
+}
+
+
+
+
+/*
+ * ds1302setup:
+ *	Initialise the chip & remember the pins we're using
+ *********************************************************************************
+ */
+
+void ds1302setup (const int clockPin, const int dataPin, const int csPin)
+{
+  dPin = dataPin ;
+  cPin = clockPin ;
+  sPin = csPin ;
+
+  digitalWrite (dPin, LOW) ;
+  digitalWrite (cPin, LOW) ;
+  digitalWrite (sPin, LOW) ;
+
+  pinMode (dPin, OUTPUT) ;
+  pinMode (cPin, OUTPUT) ;
+  pinMode (sPin, OUTPUT) ;
+
+  ds1302rtcWrite (RTC_WP, 0) ;	// Remove write-protect
+}

devLib/ds1302.h

@@ -0,0 +1,44 @@
+/*
+ * ds1302.h:
+ *	Real Time clock
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern unsigned int ds1302rtcRead       (const int reg) ;
+extern void         ds1302rtcWrite      (const int reg, const unsigned int data) ;
+
+extern unsigned int ds1302ramRead       (const int addr) ;
+extern void         ds1302ramWrite      (const int addr, const unsigned int data) ;
+
+extern void         ds1302clockRead     (int clockData [8]) ;
+extern void         ds1302clockWrite    (const int clockData [8]) ;
+
+extern void         ds1302trickleCharge (const int diodes, const int resistors) ;
+
+extern void         ds1302setup         (const int clockPin, const int dataPin, const int csPin) ;
+
+#ifdef __cplusplus
+}
+#endif

devLib/gertboard.c

@@ -0,0 +1,164 @@
+/*
+ * gertboard.c:
+ *	Access routines for the SPI devices on the Gertboard
+ *	Copyright (c) 2012 Gordon Henderson
+ *
+ *	The Gertboard has:
+ *
+ *		An MCP3002 dual-channel A to D convertor connected
+ *		to the SPI bus, selected by chip-select A, and:
+ *
+ *		An MCP4802 dual-channel D to A convertor connected
+ *		to the SPI bus, selected via chip-select B.
+ *
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#include <stdio.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/spi/spidev.h>
+
+#include <wiringPi.h>
+#include <wiringPiSPI.h>
+
+#include "gertboard.h"
+
+// The A-D convertor won't run at more than 1MHz @ 3.3v
+
+#define	SPI_ADC_SPEED	1000000
+#define	SPI_DAC_SPEED	1000000
+#define	SPI_A2D		      0
+#define	SPI_D2A		      1
+
+
+/*
+ * gertboardAnalogWrite:
+ *	Write an 8-bit data value to the MCP4802 Analog to digital
+ *	convertor on the Gertboard.
+ *********************************************************************************
+ */
+
+void gertboardAnalogWrite (const int chan, const int value)
+{
+  uint8_t spiData [2] ;
+  uint8_t chanBits, dataBits ;
+
+  if (chan == 0)
+    chanBits = 0x30 ;
+  else
+    chanBits = 0xB0 ;
+
+  chanBits |= ((value >> 4) & 0x0F) ;
+  dataBits  = ((value << 4) & 0xF0) ;
+
+  spiData [0] = chanBits ;
+  spiData [1] = dataBits ;
+
+  wiringPiSPIDataRW (SPI_D2A, spiData, 2) ;
+}
+
+
+/*
+ * gertboardAnalogRead:
+ *	Return the analog value of the given channel (0/1).
+ *	The A/D is a 10-bit device
+ *********************************************************************************
+ */
+
+int gertboardAnalogRead (const int chan)
+{
+  uint8_t spiData [2] ;
+
+  uint8_t chanBits ;
+
+  if (chan == 0)
+    chanBits = 0b11010000 ;
+  else
+    chanBits = 0b11110000 ;
+
+  spiData [0] = chanBits ;
+  spiData [1] = 0 ;
+
+  wiringPiSPIDataRW (SPI_A2D, spiData, 2) ;
+
+  return ((spiData [0] << 7) | (spiData [1] >> 1)) & 0x3FF ;
+}
+
+
+/*
+ * gertboardSPISetup:
+ *	Initialise the SPI bus, etc.
+ *********************************************************************************
+ */
+
+int gertboardSPISetup (void)
+{
+  if (wiringPiSPISetup (SPI_A2D, SPI_ADC_SPEED) < 0)
+    return -1 ;
+
+  if (wiringPiSPISetup (SPI_D2A, SPI_DAC_SPEED) < 0)
+    return -1 ;
+
+  return 0 ;
+}
+
+
+/*
+ * New wiringPi node extension methods.
+ *********************************************************************************
+ */
+
+static int myAnalogRead (struct wiringPiNodeStruct *node, const int chan)
+{
+  return gertboardAnalogRead (chan - node->pinBase) ;
+}
+
+static void myAnalogWrite (struct wiringPiNodeStruct *node, const int chan, const int value)
+{
+  gertboardAnalogWrite (chan - node->pinBase, value) ;
+}
+
+
+/*
+ * gertboardAnalogSetup:
+ *	Create a new wiringPi device node for the analog devices on the
+ *	Gertboard. We create one node with 2 pins - each pin being read
+ *	and write - although the operations actually go to different
+ *	hardware devices.
+ *********************************************************************************
+ */
+
+int gertboardAnalogSetup (const int pinBase)
+{
+  struct wiringPiNodeStruct *node ;
+  int    x ;
+
+  if (( x = gertboardSPISetup ()) != 0)
+    return  x;
+
+  node = wiringPiNewNode (pinBase, 2) ;
+  node->analogRead  = myAnalogRead ;
+  node->analogWrite = myAnalogWrite ;
+
+  return 0 ;
+}

devLib/gertboard.h

@@ -0,0 +1,45 @@
+/*
+ * gertboard.h:
+ *	Access routines for the SPI devices on the Gertboard
+ *	Copyright (c) 2012 Gordon Henderson
+ *
+ *	The Gertboard has an MCP4802 dual-channel D to A convertor
+ *	connected to the SPI bus, selected via chip-select B.
+ *
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Old routines
+
+extern void gertboardAnalogWrite (const int chan, const int value) ;
+extern int  gertboardAnalogRead  (const int chan) ;
+extern int  gertboardSPISetup    (void) ;
+
+// New
+
+extern int  gertboardAnalogSetup (const int pinBase) ;
+
+#ifdef __cplusplus
+}
+#endif

devLib/lcd.c

@@ -0,0 +1,495 @@
+/*
+ * lcd.c:
+ *	Text-based LCD driver.
+ *	This is designed to drive the parallel interface LCD drivers
+ *	based in the Hitachi HD44780U controller and compatables.
+ *
+ * Copyright (c) 2012 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#include <wiringPi.h>
+
+#include "lcd.h"
+
+#ifndef	TRUE
+#  define	TRUE	(1==1)
+#  define	FALSE	(1==2)
+#endif
+
+// HD44780U Commands
+
+#define	LCD_CLEAR	0x01
+#define	LCD_HOME	0x02
+#define	LCD_ENTRY	0x04
+#define	LCD_CTRL	0x08
+#define	LCD_CDSHIFT	0x10
+#define	LCD_FUNC	0x20
+#define	LCD_CGRAM	0x40
+#define	LCD_DGRAM	0x80
+
+// Bits in the entry register
+
+#define	LCD_ENTRY_SH		0x01
+#define	LCD_ENTRY_ID		0x02
+
+// Bits in the control register
+
+#define	LCD_BLINK_CTRL		0x01
+#define	LCD_CURSOR_CTRL		0x02
+#define	LCD_DISPLAY_CTRL	0x04
+
+// Bits in the function register
+
+#define	LCD_FUNC_F	0x04
+#define	LCD_FUNC_N	0x08
+#define	LCD_FUNC_DL	0x10
+
+#define	LCD_CDSHIFT_RL	0x04
+
+struct lcdDataStruct
+{
+  int bits, rows, cols ;
+  int rsPin, strbPin ;
+  int dataPins [8] ;
+  int cx, cy ;
+} ;
+
+struct lcdDataStruct *lcds [MAX_LCDS] ;
+
+static int lcdControl ;
+
+// Row offsets
+
+static const int rowOff [4] = { 0x00, 0x40, 0x14, 0x54 } ;
+
+
+/*
+ * strobe:
+ *	Toggle the strobe (Really the "E") pin to the device.
+ *	According to the docs, data is latched on the falling edge.
+ *********************************************************************************
+ */
+
+static void strobe (const struct lcdDataStruct *lcd)
+{
+
+// Note timing changes for new version of delayMicroseconds ()
+
+  digitalWrite (lcd->strbPin, 1) ; delayMicroseconds (50) ;
+  digitalWrite (lcd->strbPin, 0) ; delayMicroseconds (50) ;
+}
+
+
+/*
+ * sentDataCmd:
+ *	Send an data or command byte to the display.
+ *********************************************************************************
+ */
+
+static void sendDataCmd (const struct lcdDataStruct *lcd, unsigned char data)
+{
+  register unsigned char myData = data ;
+  unsigned char          i, d4 ;
+
+  if (lcd->bits == 4)
+  {
+    d4 = (myData >> 4) & 0x0F;
+    for (i = 0 ; i < 4 ; ++i)
+    {
+      digitalWrite (lcd->dataPins [i], (d4 & 1)) ;
+      d4 >>= 1 ;
+    }
+    strobe (lcd) ;
+
+    d4 = myData & 0x0F ;
+    for (i = 0 ; i < 4 ; ++i)
+    {
+      digitalWrite (lcd->dataPins [i], (d4 & 1)) ;
+      d4 >>= 1 ;
+    }
+  }
+  else
+  {
+    for (i = 0 ; i < 8 ; ++i)
+    {
+      digitalWrite (lcd->dataPins [i], (myData & 1)) ;
+      myData >>= 1 ;
+    }
+  }
+  strobe (lcd) ;
+}
+
+
+/*
+ * putCommand:
+ *	Send a command byte to the display
+ *********************************************************************************
+ */
+
+static void putCommand (const struct lcdDataStruct *lcd, unsigned char command)
+{
+  digitalWrite (lcd->rsPin,   0) ;
+  sendDataCmd  (lcd, command) ;
+  delay (2) ;
+}
+
+static void put4Command (const struct lcdDataStruct *lcd, unsigned char command)
+{
+  register unsigned char myCommand = command ;
+  register unsigned char i ;
+
+  digitalWrite (lcd->rsPin,   0) ;
+
+  for (i = 0 ; i < 4 ; ++i)
+  {
+    digitalWrite (lcd->dataPins [i], (myCommand & 1)) ;
+    myCommand >>= 1 ;
+  }
+  strobe (lcd) ;
+}
+
+
+/*
+ *********************************************************************************
+ * User Callable code below here
+ *********************************************************************************
+ */
+
+/*
+ * lcdHome: lcdClear:
+ *	Home the cursor or clear the screen.
+ *********************************************************************************
+ */
+
+void lcdHome (const int fd)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+
+  putCommand (lcd, LCD_HOME) ;
+  lcd->cx = lcd->cy = 0 ;
+  delay (5) ;
+}
+
+void lcdClear (const int fd)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+
+  putCommand (lcd, LCD_CLEAR) ;
+  putCommand (lcd, LCD_HOME) ;
+  lcd->cx = lcd->cy = 0 ;
+  delay (5) ;
+}
+
+
+/*
+ * lcdDisplay: lcdCursor: lcdCursorBlink:
+ *	Turn the display, cursor, cursor blinking on/off
+ *********************************************************************************
+ */
+
+void lcdDisplay (const int fd, int state)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+
+  if (state)
+    lcdControl |=  LCD_DISPLAY_CTRL ;
+  else
+    lcdControl &= ~LCD_DISPLAY_CTRL ;
+
+  putCommand (lcd, LCD_CTRL | lcdControl) ; 
+}
+
+void lcdCursor (const int fd, int state)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+
+  if (state)
+    lcdControl |=  LCD_CURSOR_CTRL ;
+  else
+    lcdControl &= ~LCD_CURSOR_CTRL ;
+
+  putCommand (lcd, LCD_CTRL | lcdControl) ; 
+}
+
+void lcdCursorBlink (const int fd, int state)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+
+  if (state)
+    lcdControl |=  LCD_BLINK_CTRL ;
+  else
+    lcdControl &= ~LCD_BLINK_CTRL ;
+
+  putCommand (lcd, LCD_CTRL | lcdControl) ; 
+}
+
+
+/*
+ * lcdSendCommand:
+ *	Send any arbitary command to the display
+ *********************************************************************************
+ */
+
+void lcdSendCommand (const int fd, unsigned char command)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+  putCommand (lcd, command) ;
+}
+
+
+/*
+ * lcdPosition:
+ *	Update the position of the cursor on the display.
+ *	Ignore invalid locations.
+ *********************************************************************************
+ */
+
+void lcdPosition (const int fd, int x, int y)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+
+  if ((x > lcd->cols) || (x < 0))
+    return ;
+  if ((y > lcd->rows) || (y < 0))
+    return ;
+
+  putCommand (lcd, x + (LCD_DGRAM | rowOff [y])) ;
+
+  lcd->cx = x ;
+  lcd->cy = y ;
+}
+
+
+/*
+ * lcdCharDef:
+ *	Defines a new character in the CGRAM
+ *********************************************************************************
+ */
+
+void lcdCharDef (const int fd, int index, unsigned char data [8])
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+  int i ;
+
+  putCommand (lcd, LCD_CGRAM | ((index & 7) << 3)) ;
+
+  digitalWrite (lcd->rsPin, 1) ;
+  for (i = 0 ; i < 8 ; ++i)
+    sendDataCmd (lcd, data [i]) ;
+}
+
+
+/*
+ * lcdPutchar:
+ *	Send a data byte to be displayed on the display. We implement a very
+ *	simple terminal here - with line wrapping, but no scrolling. Yet.
+ *********************************************************************************
+ */
+
+void lcdPutchar (const int fd, unsigned char data)
+{
+  struct lcdDataStruct *lcd = lcds [fd] ;
+
+  digitalWrite (lcd->rsPin, 1) ;
+  sendDataCmd  (lcd, data) ;
+
+  if (++lcd->cx == lcd->cols)
+  {
+    lcd->cx = 0 ;
+    if (++lcd->cy == lcd->rows)
+      lcd->cy = 0 ;
+    
+    putCommand (lcd, lcd->cx + (LCD_DGRAM | rowOff [lcd->cy])) ;
+  }
+}
+
+
+/*
+ * lcdPuts:
+ *	Send a string to be displayed on the display
+ *********************************************************************************
+ */
+
+void lcdPuts (const int fd, const char *string)
+{
+  while (*string)
+    lcdPutchar (fd, *string++) ;
+}
+
+
+/*
+ * lcdPrintf:
+ *	Printf to an LCD display
+ *********************************************************************************
+ */
+
+void lcdPrintf (const int fd, const char *message, ...)
+{
+  va_list argp ;
+  char buffer [1024] ;
+
+  va_start (argp, message) ;
+    vsnprintf (buffer, 1023, message, argp) ;
+  va_end (argp) ;
+
+  lcdPuts (fd, buffer) ;
+}
+
+
+/*
+ * lcdInit:
+ *	Take a lot of parameters and initialise the LCD, and return a handle to
+ *	that LCD, or -1 if any error.
+ *********************************************************************************
+ */
+
+int lcdInit (const int rows, const int cols, const int bits,
+	const int rs, const int strb,
+	const int d0, const int d1, const int d2, const int d3, const int d4,
+	const int d5, const int d6, const int d7)
+{
+  static int initialised = 0 ;
+
+  unsigned char func ;
+  int i ;
+  int lcdFd = -1 ;
+  struct lcdDataStruct *lcd ;
+
+  if (initialised == 0)
+  {
+    initialised = 1 ;
+    for (i = 0 ; i < MAX_LCDS ; ++i)
+      lcds [i] = NULL ;
+  }
+
+// Simple sanity checks
+
+  if (! ((bits == 4) || (bits == 8)))
+    return -1 ;
+
+  if ((rows < 0) || (rows > 20))
+    return -1 ;
+
+  if ((cols < 0) || (cols > 20))
+    return -1 ;
+
+// Create a new LCD:
+
+  for (i = 0 ; i < MAX_LCDS ; ++i)
+  {
+    if (lcds [i] == NULL)
+    {
+      lcdFd = i ;
+      break ;
+    }
+  }
+
+  if (lcdFd == -1)
+    return -1 ;
+
+  lcd = (struct lcdDataStruct *)malloc (sizeof (struct lcdDataStruct)) ;
+  if (lcd == NULL)
+    return -1 ;
+
+  lcd->rsPin   = rs ;
+  lcd->strbPin = strb ;
+  lcd->bits    = 8 ;		// For now - we'll set it properly later.
+  lcd->rows    = rows ;
+  lcd->cols    = cols ;
+  lcd->cx      = 0 ;
+  lcd->cy      = 0 ;
+
+  lcd->dataPins [0] = d0 ;
+  lcd->dataPins [1] = d1 ;
+  lcd->dataPins [2] = d2 ;
+  lcd->dataPins [3] = d3 ;
+  lcd->dataPins [4] = d4 ;
+  lcd->dataPins [5] = d5 ;
+  lcd->dataPins [6] = d6 ;
+  lcd->dataPins [7] = d7 ;
+
+  lcds [lcdFd] = lcd ;
+
+  digitalWrite (lcd->rsPin,   0) ; pinMode (lcd->rsPin,   OUTPUT) ;
+  digitalWrite (lcd->strbPin, 0) ; pinMode (lcd->strbPin, OUTPUT) ;
+
+  for (i = 0 ; i < bits ; ++i)
+  {
+    digitalWrite (lcd->dataPins [i], 0) ;
+    pinMode      (lcd->dataPins [i], OUTPUT) ;
+  }
+  delay (35) ; // mS
+
+
+// 4-bit mode?
+//	OK. This is a PIG and it's not at all obvious from the documentation I had,
+//	so I guess some others have worked through either with better documentation
+//	or more trial and error... Anyway here goes:
+//
+//	It seems that the controller needs to see the FUNC command at least 3 times
+//	consecutively - in 8-bit mode. If you're only using 8-bit mode, then it appears
+//	that you can get away with one func-set, however I'd not rely on it...
+//
+//	So to set 4-bit mode, you need to send the commands one nibble at a time,
+//	the same three times, but send the command to set it into 8-bit mode those
+//	three times, then send a final 4th command to set it into 4-bit mode, and only
+//	then can you flip the switch for the rest of the library to work in 4-bit
+//	mode which sends the commands as 2 x 4-bit values.
+
+  if (bits == 4)
+  {
+    func = LCD_FUNC | LCD_FUNC_DL ;			// Set 8-bit mode 3 times
+    put4Command (lcd, func >> 4) ; delay (35) ;
+    put4Command (lcd, func >> 4) ; delay (35) ;
+    put4Command (lcd, func >> 4) ; delay (35) ;
+    func = LCD_FUNC ;					// 4th set: 4-bit mode
+    put4Command (lcd, func >> 4) ; delay (35) ;
+    lcd->bits = 4 ;
+  }
+  else
+  {
+    func = LCD_FUNC | LCD_FUNC_DL ;
+    putCommand  (lcd, func     ) ; delay (35) ;
+    putCommand  (lcd, func     ) ; delay (35) ;
+    putCommand  (lcd, func     ) ; delay (35) ;
+  }
+
+  if (lcd->rows > 1)
+  {
+    func |= LCD_FUNC_N ;
+    putCommand (lcd, func) ; delay (35) ;
+  }
+
+// Rest of the initialisation sequence
+
+  lcdDisplay     (lcdFd, TRUE) ;
+  lcdCursor      (lcdFd, FALSE) ;
+  lcdCursorBlink (lcdFd, FALSE) ;
+  lcdClear       (lcdFd) ;
+
+  putCommand (lcd, LCD_ENTRY   | LCD_ENTRY_ID) ;
+  putCommand (lcd, LCD_CDSHIFT | LCD_CDSHIFT_RL) ;
+
+  return lcdFd ;
+}

devLib/lcd.h

@@ -0,0 +1,52 @@
+/*
+ * lcd.h:
+ *	Text-based LCD driver.
+ *	This is designed to drive the parallel interface LCD drivers
+ *	based in the Hitachi HD44780U controller and compatables.
+ *
+ * Copyright (c) 2012 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#define	MAX_LCDS	8
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void lcdHome        (const int fd) ;
+extern void lcdClear       (const int fd) ;
+extern void lcdDisplay     (const int fd, int state) ;
+extern void lcdCursor      (const int fd, int state) ;
+extern void lcdCursorBlink (const int fd, int state) ;
+extern void lcdSendCommand (const int fd, unsigned char command) ;
+extern void lcdPosition    (const int fd, int x, int y) ;
+extern void lcdCharDef     (const int fd, int index, unsigned char data [8]) ;
+extern void lcdPutchar     (const int fd, unsigned char data) ;
+extern void lcdPuts        (const int fd, const char *string) ;
+extern void lcdPrintf      (const int fd, const char *message, ...) ;
+
+extern int  lcdInit (const int rows, const int cols, const int bits,
+	const int rs, const int strb,
+	const int d0, const int d1, const int d2, const int d3, const int d4,
+	const int d5, const int d6, const int d7) ;
+
+#ifdef __cplusplus
+}
+#endif

devLib/lcd128x64.c

@@ -0,0 +1,673 @@
+/*
+ * lcd128x64.c:
+ *	Graphics-based LCD driver.
+ *	This is designed to drive the parallel interface LCD drivers
+ *	based on the generic 12864H chips
+ *
+ *	There are many variations on these chips, however they all mostly
+ *	seem to be similar.
+ *	This implementation has the Pins from the Pi hard-wired into it,
+ *	in particular wiringPi pins 0-7 so that we can use
+ *	digitalWriteByete() to speed things up somewhat.
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <wiringPi.h>
+
+#include "font.h"
+#include "lcd128x64.h"
+
+// Size
+
+#define	LCD_WIDTH	128
+#define	LCD_HEIGHT	 64
+
+// Hardware Pins
+//	Note pins 0-7 are the 8-bit data port
+
+#define	CS1		10
+#define	CS2		11
+#define	STROBE		12
+#define	RS		13
+
+// Software copy of the framebuffer
+//	it's 8-bit deep although the display itself is only 1-bit deep.
+
+static unsigned char frameBuffer [LCD_WIDTH * LCD_HEIGHT] ;
+
+static int maxX,    maxY ;
+static int lastX,   lastY ;
+static int xOrigin, yOrigin ;
+static int lcdOrientation = 0 ;
+
+/*
+ * strobe:
+ *	Toggle the strobe (Really the "E") pin to the device.
+ *	According to the docs, data is latched on the falling edge.
+ *********************************************************************************
+ */
+
+static void strobe (void)
+{
+  digitalWrite (STROBE, 1) ; delayMicroseconds (1) ;
+  digitalWrite (STROBE, 0) ; delayMicroseconds (5) ;
+}
+
+
+/*
+ * sentData:
+ *	Send an data or command byte to the display.
+ *********************************************************************************
+ */
+
+static void sendData (const int data, const int chip)
+{
+  digitalWrite     (chip, 0) ;
+  digitalWriteByte (data) ;
+  strobe           () ;
+  digitalWrite     (chip, 1) ;
+}
+
+
+/*
+ * sendCommand:
+ *	Send a command byte to the display
+ *********************************************************************************
+ */
+
+static void sendCommand (const int command, const int chip)
+{
+  digitalWrite (RS, 0) ;
+  sendData     (command, chip) ;
+  digitalWrite (RS, 1) ;
+}
+
+
+/*
+ * setCol: SetLine:
+ *	Set the column and line addresses
+ *********************************************************************************
+ */
+
+static void setCol  (int col, const int chip)
+  { sendCommand (0x40 | (col  & 0x3F), chip) ; }
+
+static void setLine (int line, const int chip)
+  { sendCommand (0xB8 | (line & 0x07), chip) ; }
+
+
+/*
+ * lcd128x64update:
+ *	Copy our software version to the real display
+ *********************************************************************************
+ */
+
+void lcd128x64update (void)
+{
+  int line, x, y, fbLoc ;
+  unsigned char byte ;
+
+// Left side 
+
+  for (line = 0 ; line < 8 ; ++line)
+  {
+    setCol  (0,    CS1) ;
+    setLine (line, CS1) ;
+
+    for (x = 63 ; x >= 0 ; --x)
+    {
+      byte = 0 ;
+      for (y = 0 ; y < 8 ; ++y)
+      {
+	fbLoc = x + (((7 - line) * 8) + (7 - y)) * LCD_WIDTH ;
+	if (frameBuffer [fbLoc] != 0)
+	  byte |= (1 << y) ;
+      }
+      sendData (byte, CS1) ;
+    }
+  }
+
+// Right side 
+
+  for (line = 0 ; line < 8 ; ++line)
+  {
+    setCol  (0,    CS2) ;
+    setLine (line, CS2) ;
+
+    for (x = 127 ; x >= 64 ; --x)
+    {
+      byte = 0 ;
+      for (y = 0 ; y < 8 ; ++y)
+      {
+	fbLoc = x + (((7 - line) * 8) + (7 - y)) * LCD_WIDTH ;
+	if (frameBuffer [fbLoc] != 0)
+	  byte |= (1 << y) ;
+      }
+      sendData (byte, CS2) ;
+    }
+  }
+}
+
+
+/*
+ * lcd128x64setOrigin:
+ *	Set the display offset origin
+ *********************************************************************************
+ */
+
+void lcd128x64setOrigin (int x, int y)
+{
+  xOrigin = x ;
+  yOrigin = y ;
+}
+
+
+/*
+ * lcd128x64setOrientation:
+ *	Set the display orientation:
+ *	0: Normal, the display is portrait mode, 0,0 is top left
+ *	1: Landscape
+ *	2: Portrait, flipped
+ *	3: Landscape, flipped
+ *********************************************************************************
+ */
+
+void lcd128x64setOrientation (int orientation)
+{
+  lcdOrientation = orientation & 3 ;
+
+  lcd128x64setOrigin (0,0) ;
+
+  switch (lcdOrientation)
+  {
+    case 0:
+      maxX = LCD_WIDTH ;
+      maxY = LCD_HEIGHT ;
+      break ;
+
+    case 1:
+      maxX = LCD_HEIGHT ;
+      maxY = LCD_WIDTH ;
+      break ;
+
+    case 2:
+      maxX = LCD_WIDTH ;
+      maxY = LCD_HEIGHT ;
+      break ;
+
+    case 3:
+      maxX = LCD_HEIGHT ;
+      maxY = LCD_WIDTH ;
+      break ;
+  }
+}
+
+
+/*
+ * lcd128x64orientCoordinates:
+ *	Adjust the coordinates given to the display orientation
+ *********************************************************************************
+ */
+
+void lcd128x64orientCoordinates (int *x, int *y)
+{
+  register int tmp ;
+
+  *x += xOrigin ;
+  *y += yOrigin ;
+  *y  = maxY - *y - 1 ;
+
+  switch (lcdOrientation)
+  {
+    case 0:
+      break;
+
+    case 1:
+      tmp = maxY - *y - 1 ;
+      *y = *x ;
+      *x = tmp ;
+      break;
+
+    case 2:
+      *x = maxX - *x - 1 ;
+      *y = maxY - *y - 1 ;
+      break;
+
+    case 3:
+      *x = maxX - *x - 1 ;
+      tmp = *y ;
+      *y = *x ;
+      *x = tmp ;
+      break ;
+  }
+}
+
+
+/*
+ * lcd128x64getScreenSize:
+ *	Return the max X & Y screen sizes. Needs to be called again, if you 
+ *	change screen orientation.
+ *********************************************************************************
+ */
+
+void lcd128x64getScreenSize (int *x, int *y)
+{
+  *x = maxX ;
+  *y = maxY ;
+}
+
+
+/*
+ *********************************************************************************
+ * Standard Graphical Functions
+ *********************************************************************************
+ */
+
+
+/*
+ * lcd128x64point:
+ *	Plot a pixel.
+ *********************************************************************************
+ */
+
+void lcd128x64point (int x, int y, int colour)
+{
+  lastX = x ;
+  lastY = y ;
+
+  lcd128x64orientCoordinates (&x, &y) ;
+
+  if ((x < 0) || (x >= LCD_WIDTH) || (y < 0) || (y >= LCD_HEIGHT))
+    return ;
+
+  frameBuffer [x + y * LCD_WIDTH] = colour ;
+}
+
+
+/*
+ * lcd128x64line: lcd128x64lineTo:
+ *	Classic Bressenham Line code
+ *********************************************************************************
+ */
+
+void lcd128x64line (int x0, int y0, int x1, int y1, int colour)
+{
+  int dx, dy ;
+  int sx, sy ;
+  int err, e2 ;
+
+  lastX = x1 ;
+  lastY = y1 ;
+
+  dx = abs (x1 - x0) ;
+  dy = abs (y1 - y0) ;
+
+  sx = (x0 < x1) ? 1 : -1 ;
+  sy = (y0 < y1) ? 1 : -1 ;
+
+  err = dx - dy ;
+ 
+  for (;;)
+  {
+    lcd128x64point (x0, y0, colour) ;
+
+    if ((x0 == x1) && (y0 == y1))
+      break ;
+
+    e2 = 2 * err ;
+
+    if (e2 > -dy)
+    {
+      err -= dy ;
+      x0  += sx ;
+    }
+
+    if (e2 < dx)
+    {
+      err += dx ;
+      y0  += sy ;
+    }
+  }
+
+}
+
+void lcd128x64lineTo (int x, int y, int colour)
+{
+  lcd128x64line (lastX, lastY, x, y, colour) ;
+}
+
+
+/*
+ * lcd128x64rectangle:
+ *	A rectangle is a spoilt days fishing
+ *********************************************************************************
+ */
+
+void lcd128x64rectangle (int x1, int y1, int x2, int y2, int colour, int filled)
+{
+  register int x ;
+
+  if (filled)
+  {
+    /**/ if (x1 == x2)
+      lcd128x64line (x1, y1, x2, y2, colour) ;
+    else if (x1 < x2)
+      for (x = x1 ; x <= x2 ; ++x)
+	lcd128x64line (x, y1, x, y2, colour) ;
+    else
+      for (x = x2 ; x <= x1 ; ++x)
+	lcd128x64line (x, y1, x, y2, colour) ;
+  }
+  else
+  {
+    lcd128x64line   (x1, y1, x2, y1, colour) ;
+    lcd128x64lineTo (x2, y2, colour) ;
+    lcd128x64lineTo (x1, y2, colour) ;
+    lcd128x64lineTo (x1, y1, colour) ;
+  }
+}
+
+
+/*
+ * lcd128x64circle:
+ *      This is the midpoint circle algorithm.
+ *********************************************************************************
+ */
+
+void lcd128x64circle (int x, int y, int r, int colour, int filled)
+{
+  int ddF_x = 1 ;
+  int ddF_y = -2 * r ;
+
+  int f = 1 - r ;
+  int x1 = 0 ;
+  int y1 = r ;
+
+  if (filled)
+  {
+    lcd128x64line (x, y + r, x, y - r, colour) ;
+    lcd128x64line (x + r, y, x - r, y, colour) ;
+  }
+  else
+  {
+    lcd128x64point (x, y + r, colour) ;
+    lcd128x64point (x, y - r, colour) ;
+    lcd128x64point (x + r, y, colour) ;
+    lcd128x64point (x - r, y, colour) ;
+  }
+
+  while (x1 < y1)
+  {
+    if (f >= 0)
+    {
+      y1-- ;
+      ddF_y += 2 ;
+      f += ddF_y ;
+    }
+    x1++ ;
+    ddF_x += 2 ;
+    f += ddF_x ;
+    if (filled)
+    {
+      lcd128x64line (x + x1, y + y1, x - x1, y + y1, colour) ;
+      lcd128x64line (x + x1, y - y1, x - x1, y - y1, colour) ;
+      lcd128x64line (x + y1, y + x1, x - y1, y + x1, colour) ;
+      lcd128x64line (x + y1, y - x1, x - y1, y - x1, colour) ;
+    }
+    else
+    {
+      lcd128x64point (x + x1, y + y1, colour) ; lcd128x64point (x - x1, y + y1, colour) ;
+      lcd128x64point (x + x1, y - y1, colour) ; lcd128x64point (x - x1, y - y1, colour) ;
+      lcd128x64point (x + y1, y + x1, colour) ; lcd128x64point (x - y1, y + x1, colour) ;
+      lcd128x64point (x + y1, y - x1, colour) ; lcd128x64point (x - y1, y - x1, colour) ;
+    }
+  }
+}
+
+
+/*
+ * lcd128x64ellipse:
+ *	Fast ellipse drawing algorithm by 
+ *      John Kennedy
+ *	Mathematics Department
+ *	Santa Monica College
+ *	1900 Pico Blvd.
+ *	Santa Monica, CA 90405
+ *	jrkennedy6@gmail.com
+ *	-Confirned in email this algorithm is in the public domain -GH-
+ *********************************************************************************
+ */
+
+static void plot4ellipsePoints (int cx, int cy, int x, int y, int colour, int filled)
+{
+  if (filled)
+  {
+    lcd128x64line (cx + x, cy + y, cx - x, cy + y, colour) ;
+    lcd128x64line (cx - x, cy - y, cx + x, cy - y, colour) ;
+  }
+  else
+  {
+    lcd128x64point (cx + x, cy + y, colour) ;
+    lcd128x64point (cx - x, cy + y, colour) ;
+    lcd128x64point (cx - x, cy - y, colour) ;
+    lcd128x64point (cx + x, cy - y, colour) ;
+  }
+}
+
+void lcd128x64ellipse (int cx, int cy, int xRadius, int yRadius, int colour, int filled)
+{
+  int x, y ;
+  int xChange, yChange, ellipseError ;
+  int twoAsquare, twoBsquare ;
+  int stoppingX, stoppingY ;
+
+  twoAsquare = 2 * xRadius * xRadius ;
+  twoBsquare = 2 * yRadius * yRadius ;
+
+  x = xRadius ;
+  y = 0 ;
+
+  xChange = yRadius * yRadius * (1 - 2 * xRadius) ;
+  yChange = xRadius * xRadius ;
+
+  ellipseError = 0 ;
+  stoppingX    = twoBsquare * xRadius ;
+  stoppingY    = 0 ;
+
+  while (stoppingX >= stoppingY)	// 1st set of points
+  {
+    plot4ellipsePoints (cx, cy, x, y, colour, filled) ;
+    ++y ;
+    stoppingY    += twoAsquare ;
+    ellipseError += yChange ;
+    yChange      += twoAsquare ;
+
+    if ((2 * ellipseError + xChange) > 0 )
+    {
+      --x ;
+      stoppingX    -= twoBsquare ;
+      ellipseError += xChange ;
+      xChange      += twoBsquare ;
+    }
+  }
+
+  x = 0 ;
+  y = yRadius ;
+
+  xChange = yRadius * yRadius ;
+  yChange = xRadius * xRadius * (1 - 2 * yRadius) ;
+
+  ellipseError = 0 ;
+  stoppingX    = 0 ;
+  stoppingY    = twoAsquare * yRadius ;
+
+  while (stoppingX <= stoppingY)	//2nd set of points
+  {
+    plot4ellipsePoints (cx, cy, x, y, colour, filled) ;
+    ++x ;
+    stoppingX    += twoBsquare ;
+    ellipseError += xChange ;
+    xChange      += twoBsquare ;
+
+    if ((2 * ellipseError + yChange) > 0 )
+    {
+      --y ;
+      stoppingY -= twoAsquare ;
+      ellipseError += yChange ;
+      yChange += twoAsquare ;
+    }
+  }
+}
+
+
+/*
+ * lcd128x64putchar:
+ *	Print a single character to the screen
+ *********************************************************************************
+ */
+
+void lcd128x64putchar (int x, int y, int c, int bgCol, int fgCol)
+{
+  int y1, y2 ;
+
+  unsigned char line ;
+  unsigned char *fontPtr ;
+
+// Can't print if we're offscreen
+
+//if ((x < 0) || (x >= (maxX - fontWidth)) || (y < 0) || (y >= (maxY - fontHeight)))
+//  return ;
+
+  fontPtr = font + c * fontHeight ;
+
+  for (y1 = fontHeight - 1 ; y1 >= 0 ; --y1)
+  {
+    y2 = y + y1 ;
+    line = *fontPtr++ ;
+    lcd128x64point (x + 0, y2, (line & 0x80) == 0 ? bgCol : fgCol) ;
+    lcd128x64point (x + 1, y2, (line & 0x40) == 0 ? bgCol : fgCol) ;
+    lcd128x64point (x + 2, y2, (line & 0x20) == 0 ? bgCol : fgCol) ;
+    lcd128x64point (x + 3, y2, (line & 0x10) == 0 ? bgCol : fgCol) ;
+    lcd128x64point (x + 4, y2, (line & 0x08) == 0 ? bgCol : fgCol) ;
+    lcd128x64point (x + 5, y2, (line & 0x04) == 0 ? bgCol : fgCol) ;
+    lcd128x64point (x + 6, y2, (line & 0x02) == 0 ? bgCol : fgCol) ;
+    lcd128x64point (x + 7, y2, (line & 0x01) == 0 ? bgCol : fgCol) ;
+  }
+}
+
+
+/*
+ * lcd128x64puts:
+ *	Send a string to the display. Obeys \n and \r formatting
+ *********************************************************************************
+ */
+
+void lcd128x64puts (int x, int y, const char *str, int bgCol, int fgCol)
+{
+  int c, mx, my ;
+
+  mx = x ; my = y ;
+
+  while (*str)
+  {
+    c = *str++ ;
+
+    if (c == '\r')
+    {
+      mx = x ;
+      continue ;
+    }
+
+    if (c == '\n')
+    {
+      mx  = x ;
+      my -= fontHeight ;
+      continue ;
+    }
+
+    lcd128x64putchar (mx, my, c, bgCol, fgCol) ;
+
+    mx += fontWidth ;
+    if (mx >= (maxX - fontWidth))
+    {
+      mx  = 0 ;
+      my -= fontHeight ;
+    }
+  }
+}
+
+
+/*
+ * lcd128x64clear:
+ *	Clear the display to the given colour.
+ *********************************************************************************
+ */
+
+void lcd128x64clear (int colour)
+{
+  register int i ;
+  register unsigned char *ptr = frameBuffer ;
+
+  for (i = 0 ; i < (maxX * maxY) ; ++i)
+    *ptr++ = colour ;
+}
+
+
+
+
+/*
+ * lcd128x64setup:
+ *	Initialise the display and GPIO.
+ *********************************************************************************
+ */
+
+int lcd128x64setup (void)
+{
+  int i ;
+
+  for (i = 0 ; i < 8 ; ++i)
+    pinMode (i, OUTPUT) ;
+
+  digitalWrite (CS1,    1) ;
+  digitalWrite (CS2,    1) ;
+  digitalWrite (STROBE, 0) ;
+  digitalWrite (RS,     1) ;
+
+  pinMode (CS1,    OUTPUT) ;
+  pinMode (CS2,    OUTPUT) ;
+  pinMode (STROBE, OUTPUT) ;
+  pinMode (RS,     OUTPUT) ;
+
+  sendCommand (0x3F, CS1) ;	// Display ON
+  sendCommand (0xC0, CS1) ;	// Set display start line to 0
+
+  sendCommand (0x3F, CS2) ;	// Display ON
+  sendCommand (0xC0, CS2) ;	// Set display start line to 0
+
+  lcd128x64clear          (0) ;
+  lcd128x64setOrientation (0) ;
+  lcd128x64update         () ;
+
+  return 0 ;
+}

devLib/lcd128x64.h

@@ -0,0 +1,39 @@
+/*
+ * lcd128x64.h:
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+extern void lcd128x64setOrigin         (int x, int y) ;
+extern void lcd128x64setOrientation    (int orientation) ;
+extern void lcd128x64orientCoordinates (int *x, int *y) ;
+extern void lcd128x64getScreenSize     (int *x, int *y) ;
+extern void lcd128x64point             (int  x, int  y, int colour) ;
+extern void lcd128x64line              (int x0, int y0, int x1, int y1, int colour) ;
+extern void lcd128x64lineTo            (int  x, int  y, int colour) ;
+extern void lcd128x64rectangle         (int x1, int y1, int x2, int y2, int colour, int filled) ;
+extern void lcd128x64circle            (int  x, int  y, int  r, int colour, int filled) ;
+extern void lcd128x64ellipse           (int cx, int cy, int xRadius, int yRadius, int colour, int filled) ;
+extern void lcd128x64putchar           (int  x, int  y, int c, int bgCol, int fgCol) ;
+extern void lcd128x64puts              (int  x, int  y, const char *str, int bgCol, int fgCol) ;
+extern void lcd128x64update            (void) ;
+extern void lcd128x64clear             (int colour) ;
+
+extern int  lcd128x64setup             (void) ;

devLib/maxdetect.c

@@ -0,0 +1,165 @@
+/*
+ * maxdetect.c:
+ *	Driver for the MaxDetect series sensors
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+//#include <stdio.h>
+//#include <stdlib.h>
+//#include <unistd.h>
+
+#include <wiringPi.h>
+
+#include "maxdetect.h"
+
+#ifndef	TRUE
+#  define	TRUE	(1==1)
+#  define	FALSE	(1==2)
+#endif
+
+
+/*
+ * maxDetectLowHighWait:
+ *	Wait for a transition from high to low on the bus
+ *********************************************************************************
+ */
+
+static void maxDetectLowHighWait (const int pin)
+{
+  unsigned int timeOut = millis () + 2000 ;
+
+  while (digitalRead (pin) == HIGH)
+    if (millis () > timeOut)
+      return ;
+
+  while (digitalRead (pin) == LOW)
+    if (millis () > timeOut)
+      return ;
+}
+
+
+/*
+ * maxDetectClockByte:
+ *	Read in a single byte from the MaxDetect bus
+ *********************************************************************************
+ */
+
+static unsigned int maxDetectClockByte (const int pin)
+{
+  unsigned int byte = 0 ;
+  int bit ;
+
+  for (bit = 0 ; bit < 8 ; ++bit)
+  {
+    maxDetectLowHighWait (pin) ;
+
+// bit starting now - we need to time it.
+
+    delayMicroseconds (30) ;
+    byte <<= 1 ;
+    if (digitalRead (pin) == HIGH)	// It's a 1
+      byte |= 1 ;
+  }
+
+  return byte ;
+}
+
+
+/*
+ * maxDetectRead:
+ *	Read in and return the 4 data bytes from the MaxDetect sensor.
+ *	Return TRUE/FALSE depending on the checksum validity
+ *********************************************************************************
+ */
+
+int maxDetectRead (const int pin, unsigned char buffer [4])
+{
+  int i ;
+  unsigned int checksum ;
+  unsigned char localBuf [5] ;
+
+// Wake up the RHT03 by pulling the data line low, then high
+//	Low for 10mS, high for 40uS.
+
+  pinMode      (pin, OUTPUT) ;
+  digitalWrite (pin, 0) ; delay             (10) ;
+  digitalWrite (pin, 1) ; delayMicroseconds (40) ;
+  pinMode      (pin, INPUT) ;
+
+// Now wait for sensor to pull pin low
+
+  maxDetectLowHighWait (pin) ;
+
+// and read in 5 bytes (40 bits)
+
+  for (i = 0 ; i < 5 ; ++i)
+    localBuf [i] = maxDetectClockByte (pin) ;
+
+  checksum = 0 ;
+  for (i = 0 ; i < 4 ; ++i)
+  {
+    buffer [i] = localBuf [i] ;
+    checksum += localBuf [i] ;
+  }
+  checksum &= 0xFF ;
+
+  return checksum == localBuf [4] ;
+}
+
+
+/*
+ * readRHT03:
+ *	Read the Temperature & Humidity from an RHT03 sensor
+ *********************************************************************************
+ */
+
+int readRHT03 (const int pin, int *temp, int *rh)
+{
+  static unsigned int nextTime   = 0 ;
+  static          int lastTemp   = 0 ;
+  static          int lastRh     = 0 ;
+  static          int lastResult = TRUE ;
+
+  unsigned char buffer [4] ;
+
+// Don't read more than once a second
+
+  if (millis () < nextTime)
+  {
+    *temp = lastTemp ;
+    *rh   = lastRh ;
+    return lastResult ;
+  }
+  
+  lastResult = maxDetectRead (pin, buffer) ;
+
+  if (lastResult)
+  {
+    *temp      = lastTemp   = (buffer [2] * 256 + buffer [3]) ;
+    *rh        = lastRh     = (buffer [0] * 256 + buffer [1]) ;
+    nextTime   = millis () + 2000 ;
+    return TRUE ;
+  }
+  else
+  {
+    return FALSE ;
+  }
+}

devLib/maxdetect.h

@@ -0,0 +1,40 @@
+/*
+ * maxdetect.h:
+ *	Driver for the MaxDetect series sensors
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Main generic function
+
+int maxDetectRead (const int pin, unsigned char buffer [4]) ;
+
+// Individual sensors
+
+int readRHT03 (const int pin, int *temp, int *rh) ;
+
+#ifdef __cplusplus
+}
+#endif

devLib/piFace.c

@@ -0,0 +1,112 @@
+/*
+ * piFace.:
+ *	This file to interface with the PiFace peripheral device which
+ *	has an MCP23S17 GPIO device connected via the SPI bus.
+ *
+ *	Copyright (c) 2012-2013 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include <wiringPi.h>
+#include <mcp23s17.h>
+
+#include "piFace.h"
+
+
+/*
+ * myDigitalWrite:
+ *	Perform the digitalWrite function on the PiFace board
+ *********************************************************************************
+ */
+
+void myDigitalWrite (struct wiringPiNodeStruct *node, int pin, int value)
+{
+  digitalWrite (pin + 16, value) ;
+}
+
+
+/*
+ * myDigitalRead:
+ *	Perform the digitalRead function on the PiFace board
+ *	With a slight twist - if we read from base + 8, then we
+ *	read from the output latch...
+ *********************************************************************************
+ */
+
+int myDigitalRead (struct wiringPiNodeStruct *node, int pin)
+{
+  if ((pin - node->pinBase) >= 8)
+    return digitalRead (pin + 8) ;
+  else
+    return digitalRead (pin + 16 + 8) ;
+}
+
+
+/*
+ * myPullUpDnControl:
+ *	Perform the pullUpDnControl function on the PiFace board
+ *********************************************************************************
+ */
+
+void myPullUpDnControl (struct wiringPiNodeStruct *node, int pin, int pud)
+{
+  pullUpDnControl (pin + 16 + 8, pud) ;
+}
+
+
+/*
+ * piFaceSetup
+ *	We're going to create an instance of the mcp23s17 here, then
+ *	provide our own read/write routines on-top of it...
+ *	The supplied PiFace code (in Pithon) treats it as an 8-bit device
+ *	where you write the output ports and read the input port using the
+ *	same pin numbers, however I have had a request to be able to read
+ *	the output port, so reading 8..15 will read the output latch.
+ *********************************************************************************
+ */
+
+int piFaceSetup (const int pinBase)
+{
+  int    i ;
+  struct wiringPiNodeStruct *node ;
+
+// Create an mcp23s17 instance:
+
+   mcp23s17Setup (pinBase + 16, 0, 0) ;
+
+// Set the direction bits
+
+  for (i = 0 ; i < 8 ; ++i)
+  {
+    pinMode (pinBase + 16 +     i, OUTPUT) ;	// Port A is the outputs
+    pinMode (pinBase + 16 + 8 + i, INPUT) ;	// Port B inputs.
+  }
+
+  node = wiringPiNewNode (pinBase, 16) ;
+  node->digitalRead     = myDigitalRead ;
+  node->digitalWrite    = myDigitalWrite ;
+  node->pullUpDnControl = myPullUpDnControl ;
+
+  return 0 ;
+}

devLib/piFace.h

@@ -0,0 +1,32 @@
+/*
+ * piFace.h:
+ *	Control the PiFace Interface board for the Raspberry Pi
+ *	Copyright (c) 2012-2013 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int  piFaceSetup (const int pinBase) ;
+
+#ifdef __cplusplus
+}
+#endif

devLib/piFaceOld.c

@@ -0,0 +1,178 @@
+/*
+ * piFace.:
+ *	Arduino compatable (ish) Wiring library for the Raspberry Pi
+ *	Copyright (c) 2012-2013 Gordon Henderson
+ *
+ *	This file to interface with the PiFace peripheral device which
+ *	has an MCP23S17 GPIO device connected via the SPI bus.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include <wiringPi.h>
+#include <wiringPiSPI.h>
+
+#include "../wiringPi/mcp23x0817.h"
+
+#include "piFace.h"
+
+#define	PIFACE_SPEED	4000000
+#define	PIFACE_DEVNO	0
+
+
+
+/*
+ * writeByte:
+ *	Write a byte to a register on the MCP23S17 on the SPI bus.
+ *********************************************************************************
+ */
+
+static void writeByte (uint8_t reg, uint8_t data)
+{
+  uint8_t spiData [4] ;
+
+  spiData [0] = CMD_WRITE ;
+  spiData [1] = reg ;
+  spiData [2] = data ;
+
+  wiringPiSPIDataRW (PIFACE_DEVNO, spiData, 3) ;
+}
+
+/*
+ * readByte:
+ *	Read a byte from a register on the MCP23S17 on the SPI bus.
+ *********************************************************************************
+ */
+
+static uint8_t readByte (uint8_t reg)
+{
+  uint8_t spiData [4] ;
+
+  spiData [0] = CMD_READ ;
+  spiData [1] = reg ;
+
+  wiringPiSPIDataRW (PIFACE_DEVNO, spiData, 3) ;
+
+  return spiData [2] ;
+}
+
+
+/*
+ * myDigitalWrite:
+ *	Perform the digitalWrite function on the PiFace board
+ *********************************************************************************
+ */
+
+void myDigitalWrite (struct wiringPiNodeStruct *node, int pin, int value)
+{
+  uint8_t mask, old ;
+
+  pin -= node->pinBase ;
+  mask = 1 << pin ;
+  old  = readByte (MCP23x17_GPIOA) ;
+
+  if (value == 0)
+    old &= (~mask) ;
+  else
+    old |=   mask ;
+
+  writeByte (MCP23x17_GPIOA, old) ;
+}
+
+
+/*
+ * myDigitalRead:
+ *	Perform the digitalRead function on the PiFace board
+ *********************************************************************************
+ */
+
+int myDigitalRead (struct wiringPiNodeStruct *node, int pin)
+{
+  uint8_t mask, reg ;
+
+  mask = 1 << ((pin - node->pinBase) & 7) ;
+
+  if (pin < 8)
+    reg = MCP23x17_GPIOB ;	// Input regsiter
+  else
+    reg = MCP23x17_OLATA ;	// Output latch regsiter
+
+  if ((readByte (reg) & mask) != 0)
+    return HIGH ;
+  else
+    return LOW ;
+}
+
+
+/*
+ * myPullUpDnControl:
+ *	Perform the pullUpDnControl function on the PiFace board
+ *********************************************************************************
+ */
+
+void myPullUpDnControl (struct wiringPiNodeStruct *node, int pin, int pud)
+{
+  uint8_t mask, old ;
+
+  mask = 1 << (pin - node->pinBase) ;
+  old  = readByte (MCP23x17_GPPUB) ;
+
+  if (pud == 0)
+    old &= (~mask) ;
+  else
+    old |=   mask ;
+
+  writeByte (MCP23x17_GPPUB, old) ;
+}
+
+
+/*
+ * piFaceSetup
+ *	Setup the SPI interface and initialise the MCP23S17 chip
+ *	We create one node with 16 pins - each if the first 8 pins being read
+ *	and write - although the operations actually go to different
+ *	hardware ports. The top 8 let you read the state of the output register.
+ *********************************************************************************
+ */
+
+int piFaceSetup (const int pinBase)
+{
+  int    x ;
+  struct wiringPiNodeStruct *node ;
+
+  if ((x = wiringPiSPISetup (PIFACE_DEVNO, PIFACE_SPEED)) < 0)
+    return x ;
+
+// Setup the MCP23S17
+
+  writeByte (MCP23x17_IOCON,  IOCON_INIT) ;
+  writeByte (MCP23x17_IODIRA, 0x00) ;		// Port A -> Outputs
+  writeByte (MCP23x17_IODIRB, 0xFF) ;		// Port B -> Inputs
+
+  node = wiringPiNewNode (pinBase, 16) ;
+  node->digitalRead     = myDigitalRead ;
+  node->digitalWrite    = myDigitalWrite ;
+  node->pullUpDnControl = myPullUpDnControl ;
+
+  return 0 ;
+}

devLib/piGlow.c

@@ -0,0 +1,118 @@
+/*
+ * piGlow.c:
+ *	Easy access to the Pimoroni PiGlow board.
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <wiringPi.h>
+#include <sn3218.h>
+
+#include "piGlow.h"
+
+#define	PIGLOW_BASE	577
+
+static int leg0 [6] = {  6,  7,  8,  5,  4,  9 } ;
+static int leg1 [6] = { 17, 16, 15, 13, 11, 10 } ;
+static int leg2 [6] = {  0,  1,  2,  3, 14, 12 } ;
+
+
+/*
+ * piGlow1:
+ *	Light up an individual LED
+ *********************************************************************************
+ */
+
+void piGlow1 (const int leg, const int ring, const int intensity)
+{
+  int *legLeds ;
+
+  if ((leg  < 0) || (leg  > 2)) return ;
+  if ((ring < 0) || (ring > 5)) return ;
+
+  /**/ if (leg == 0)
+    legLeds = leg0 ;
+  else if (leg == 1)
+    legLeds = leg1 ;
+  else
+    legLeds = leg2 ;
+
+  analogWrite (PIGLOW_BASE + legLeds [ring], intensity) ;
+}
+
+/*
+ * piGlowLeg:
+ *	Light up all 6 LEDs on a leg
+ *********************************************************************************
+ */
+
+void piGlowLeg (const int leg, const int intensity)
+{
+  int  i ;
+  int *legLeds ;
+
+  if ((leg < 0) || (leg > 2))
+    return ;
+
+  /**/ if (leg == 0)
+    legLeds = leg0 ;
+  else if (leg == 1)
+    legLeds = leg1 ;
+  else
+    legLeds = leg2 ;
+
+  for (i = 0 ; i < 6 ; ++i)
+    analogWrite (PIGLOW_BASE + legLeds [i], intensity) ;
+}
+
+
+/*
+ * piGlowRing:
+ *	Light up 3 LEDs in a ring. Ring 0 is the outermost, 5 the innermost
+ *********************************************************************************
+ */
+
+void piGlowRing (const int ring, const int intensity)
+{
+  if ((ring < 0) || (ring > 5))
+    return ;
+
+  analogWrite (PIGLOW_BASE + leg0 [ring], intensity) ;
+  analogWrite (PIGLOW_BASE + leg1 [ring], intensity) ;
+  analogWrite (PIGLOW_BASE + leg2 [ring], intensity) ;
+}
+
+/*
+ * piGlowSetup:
+ *	Initialise the board & remember the pins we're using
+ *********************************************************************************
+ */
+
+void piGlowSetup (int clear)
+{
+  sn3218Setup (PIGLOW_BASE) ;
+
+  if (clear)
+  {
+    piGlowLeg (0, 0) ;
+    piGlowLeg (1, 0) ;
+    piGlowLeg (2, 0) ;
+  }
+}

devLib/piGlow.h

@@ -0,0 +1,45 @@
+/*
+ * piglow.h:
+ *	Easy access to the Pimoroni PiGlow board.
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#define	PIGLOW_RED	0
+#define	PIGLOW_ORANGE	1
+#define	PIGLOW_YELLOW	2
+#define	PIGLOW_GREEN	3
+#define	PIGLOW_BLUE	4
+#define	PIGLOW_WHITE	5
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void piGlow1     (const int leg,  const int ring, const int intensity) ;
+extern void piGlowLeg   (const int leg,  const int intensity) ;
+extern void piGlowRing  (const int ring, const int intensity) ;
+extern void piGlowSetup (int clear) ;
+
+#ifdef __cplusplus
+}
+#endif

devLib/piNes.c

@@ -0,0 +1,113 @@
+/*
+ * piNes.c:
+ *	Driver for the NES Joystick controller on the Raspberry Pi
+ *	Copyright (c) 2012 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <wiringPi.h>
+
+#include "piNes.h"
+
+#define	MAX_NES_JOYSTICKS	8
+
+#define	NES_RIGHT	0x01
+#define	NES_LEFT	0x02
+#define	NES_DOWN	0x04
+#define	NES_UP		0x08
+#define	NES_START	0x10
+#define	NES_SELECT	0x20
+#define	NES_B		0x40
+#define	NES_A		0x80
+
+
+#define	PULSE_TIME	25
+
+// Data to store the pins for each controller
+
+struct nesPinsStruct
+{
+  unsigned int cPin, dPin, lPin ;
+} ;
+
+static struct nesPinsStruct nesPins [MAX_NES_JOYSTICKS] ;
+
+static int joysticks = 0 ;
+
+
+/*
+ * setupNesJoystick:
+ *	Create a new NES joystick interface, program the pins, etc.
+ *********************************************************************************
+ */
+
+int setupNesJoystick (int dPin, int cPin, int lPin)
+{
+  if (joysticks == MAX_NES_JOYSTICKS)
+    return -1 ;
+
+  nesPins [joysticks].dPin = dPin ;
+  nesPins [joysticks].cPin = cPin ;
+  nesPins [joysticks].lPin = lPin ;
+
+  digitalWrite (lPin, LOW) ;
+  digitalWrite (cPin, LOW) ;
+
+  pinMode (lPin, OUTPUT) ;
+  pinMode (cPin, OUTPUT) ;
+  pinMode (dPin, INPUT) ;
+
+  return joysticks++ ;
+}
+
+
+/*
+ * readNesJoystick:
+ *	Do a single scan of the NES Joystick.
+ *********************************************************************************
+ */
+
+unsigned int readNesJoystick (int joystick)
+{
+  unsigned int value = 0 ;
+  int  i ;
+
+  struct nesPinsStruct *pins = &nesPins [joystick] ;
+ 
+// Toggle Latch - which presents the first bit
+
+  digitalWrite (pins->lPin, HIGH) ; delayMicroseconds (PULSE_TIME) ;
+  digitalWrite (pins->lPin, LOW)  ; delayMicroseconds (PULSE_TIME) ;
+
+// Read first bit
+
+  value = digitalRead (pins->dPin) ;
+
+// Now get the next 7 bits with the clock
+
+  for (i = 0 ; i < 7 ; ++i)
+  {
+    digitalWrite (pins->cPin, HIGH) ; delayMicroseconds (PULSE_TIME) ;
+    digitalWrite (pins->cPin, LOW)  ; delayMicroseconds (PULSE_TIME) ;
+    value = (value << 1) | digitalRead (pins->dPin) ;
+  }
+
+  return value ^ 0xFF ;
+}

devLib/piNes.h

@@ -0,0 +1,45 @@
+/*
+ * piNes.h:
+ *	Driver for the NES Joystick controller on the Raspberry Pi
+ *	Copyright (c) 2012 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#define	MAX_NES_JOYSTICKS	8
+
+#define	NES_RIGHT	0x01
+#define	NES_LEFT	0x02
+#define	NES_DOWN	0x04
+#define	NES_UP		0x08
+#define	NES_START	0x10
+#define	NES_SELECT	0x20
+#define	NES_B		0x40
+#define	NES_A		0x80
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int          setupNesJoystick (int dPin, int cPin, int lPin) ;
+extern unsigned int  readNesJoystick (int joystick) ;
+
+#ifdef __cplusplus
+}
+#endif

examples/Gertboard/7segments.c

@@ -0,0 +1,221 @@
+/*
+ * 7segments.c:
+ *	Simple test program to see if we can drive a 7-segment LED
+ *	display using the GPIO and little else on the Raspberry Pi
+ *
+ *	Copyright (c) 2013 Gordon Henderson
+ ***********************************************************************
+ */
+
+#undef	PHOTO_HACK
+
+#include <wiringPi.h>
+
+#include <stdio.h>
+#include <time.h>
+#include <ctype.h>
+#include <string.h>
+
+/*
+ *  Segment mapping
+ *
+ *	 --a--
+ *	|     |
+ *	f     b
+ *	|     |
+ *	 --g--
+ *	|     |
+ *	e     c
+ *	|     |
+ *	 --d--  p
+ */
+
+// GPIO Pin Mapping
+
+static int digits   [6] = {  7, 11, 10, 13, 12, 14    } ;
+static int segments [7] = {  6,  5,  4,  3,  2,  1, 0 } ;
+
+
+static const int segmentDigits [] =
+{
+// a  b  c  d  e  f  g     Segments
+// 6  5  4  3  2  1  0,	// wiringPi pin No.
+
+   1, 1, 1, 1, 1, 1, 0,	// 0
+   0, 1, 1, 0, 0, 0, 0,	// 1
+   1, 1, 0, 1, 1, 0, 1,	// 2
+   1, 1, 1, 1, 0, 0, 1,	// 3
+   0, 1, 1, 0, 0, 1, 1,	// 4
+   1, 0, 1, 1, 0, 1, 1,	// 5
+   1, 0, 1, 1, 1, 1, 1,	// 6
+   1, 1, 1, 0, 0, 0, 0,	// 7
+   1, 1, 1, 1, 1, 1, 1,	// 8
+   1, 1, 1, 1, 0, 1, 1,	// 9
+   1, 1, 1, 0, 1, 1, 1,	// A
+   0, 0, 1, 1, 1, 1, 1,	// b
+   1, 0, 0, 1, 1, 1, 0,	// C
+   0, 1, 1, 1, 1, 0, 1,	// d
+   1, 0, 0, 1, 1, 1, 1,	// E
+   1, 0, 0, 0, 1, 1, 1,	// F
+   0, 0, 0, 0, 0, 0, 0,	// blank
+} ;
+ 
+
+// display:
+//	A global variable which is written to by the main program and
+//	read from by the thread that updates the display. Only the first
+//	6 characters are used.
+
+char display [8] ;
+
+
+/*
+ * displayDigits:
+ *	This is our thread that's run concurrently with the main program.
+ *	Essentially sit in a loop, parsing and displaying the data held in
+ *	the "display" global.
+ *********************************************************************************
+ */
+
+PI_THREAD (displayDigits)
+{
+  int digit, segment ;
+  int index, d, segVal ;
+
+  piHiPri (50) ;
+
+  for (;;)
+  {
+    for (digit = 0 ; digit < 6 ; ++digit)
+    {
+      for (segment = 0 ; segment < 7 ; ++segment)
+      {
+	d = toupper (display [digit]) ;
+	/**/ if ((d >= '0') && (d <= '9'))	// Digit
+	  index = d - '0' ;
+	else if ((d >= 'A') && (d <= 'F'))	// Hex
+	  index = d - 'A' + 10 ;
+	else
+	  index = 16 ;				// Blank
+
+	segVal = segmentDigits [index * 7 + segment] ;
+
+	digitalWrite (segments [segment], segVal) ;
+      }
+      digitalWrite (digits [digit], 1) ;
+      delay (2) ;
+      digitalWrite (digits [digit], 0) ;
+    }
+  }
+}
+
+
+/*
+ * setup:
+ *	Initialise the hardware and start the thread
+ *********************************************************************************
+ */
+
+void setup (void)
+{
+  int i, c ;
+
+  wiringPiSetup () ;
+
+// 7 segments
+
+  for (i = 0 ; i < 7 ; ++i)
+    { digitalWrite (segments [i], 0) ; pinMode (segments [i], OUTPUT) ; }
+
+// 6 digits
+
+  for (i = 0 ; i < 6 ; ++i)
+    { digitalWrite (digits [i], 0) ;   pinMode (digits [i],   OUTPUT) ; }
+
+  strcpy (display, "      ") ;
+  piThreadCreate (displayDigits) ;
+  delay (10) ; // Just to make sure it's started
+
+// Quick countdown LED test sort of thing
+
+  c = 999999 ;
+  for (i = 0 ; i < 10 ; ++i)
+  {
+    sprintf (display, "%06d", c) ;
+    delay (400) ;
+    c -= 111111 ;
+  }
+
+  strcpy (display, "      ") ;
+  delay (400) ;
+
+#ifdef PHOTO_HACK
+  sprintf (display, "%s", "123456") ;
+  for (;;)
+    delay (1000) ;
+#endif
+
+}
+
+
+/*
+ * teenager:
+ *	No explanation needed. (Nor one given!)
+ *********************************************************************************
+ */
+
+void teenager (void)
+{
+  char *message = "      feedbeef      babe      cafe      b00b      " ;
+  int i ;
+
+  for (i = 0 ; i < strlen (message) - 4 ; ++i)
+  {
+    strncpy (display, &message [i], 6) ;
+    delay (200) ;
+  }
+  delay (1000) ;
+  for (i = 0 ; i < 3 ; ++i)
+  {
+    strcpy (display, "    ") ;
+    delay (150) ;
+    strcpy (display, " b00b ") ;
+    delay (250) ;
+  }
+  delay (1000) ;
+  strcpy (display, "      ") ;
+  delay (1000) ;
+}
+
+
+/*
+ *********************************************************************************
+ * main:
+ *	Let the fun begin
+ *********************************************************************************
+ */
+
+int main (void)
+{
+  struct tm *t ;
+  time_t     tim ;
+
+  setup    () ;
+  teenager () ;
+
+  tim = time (NULL) ;
+  for (;;)
+  {
+    while (time (NULL) == tim)
+      delay (5) ;
+
+    tim = time (NULL) ;
+    t   = localtime (&tim) ;
+
+    sprintf (display, "%02d%02d%02d", t->tm_hour, t->tm_min, t->tm_sec) ;
+
+    delay (500) ;
+  }
+
+  return 0 ;
+}

examples/Gertboard/Makefile

@@ -0,0 +1,78 @@
+#
+# Makefile:
+#	Gertboard - Examples using wiringPi
+#
+#	Copyright (c) 2013 Gordon Henderson
+#################################################################################
+
+ifneq ($V,1)
+Q ?= @
+endif
+
+#DEBUG	= -g -O0
+DEBUG	= -O3
+CC	= gcc
+INCLUDE	= -I/usr/local/include
+CFLAGS	= $(DEBUG) -Wall $(INCLUDE) -Winline -pipe
+
+LDFLAGS	= -L/usr/local/lib
+LDLIBS    = -lwiringPi -lwiringPiDev -lpthread -lm
+
+# Should not alter anything below this line
+###############################################################################
+
+SRC	=	gertboard.c				\
+		buttons.c 7segments.c			\
+		voltmeter.c temperature.c vumeter.c	\
+		record.c
+
+OBJ	=	$(SRC:.c=.o)
+
+BINS	=	$(SRC:.c=)
+
+all:	$(BINS)
+
+gertboard:	gertboard.o
+	$Q echo [link]
+	$Q $(CC) -o $@ gertboard.o $(LDFLAGS) $(LDLIBS)
+
+buttons:	buttons.o
+	$Q echo [link]
+	$Q $(CC) -o $@ buttons.o $(LDFLAGS) $(LDLIBS)
+
+7segments:	7segments.o
+	$Q echo [link]
+	$Q $(CC) -o $@ 7segments.o $(LDFLAGS) $(LDLIBS)
+
+voltmeter:	voltmeter.o
+	$Q echo [link]
+	$Q $(CC) -o $@ voltmeter.o $(LDFLAGS) $(LDLIBS)
+
+temperature:	temperature.o
+	$Q echo [link]
+	$Q $(CC) -o $@ temperature.o $(LDFLAGS) $(LDLIBS)
+
+vumeter:	vumeter.o
+	$Q echo [link]
+	$Q $(CC) -o $@ vumeter.o $(LDFLAGS) $(LDLIBS)
+
+record:	record.o
+	$Q echo [link]
+	$Q $(CC) -o $@ record.o $(LDFLAGS) $(LDLIBS)
+
+.c.o:
+	$Q echo [CC] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
+
+clean:
+	$Q echo [Clean]
+	$Q rm -f $(OBJ) *~ core tags $(BINS)
+
+tags:	$(SRC)
+	$Q echo [ctags]
+	$Q ctags $(SRC)
+
+depend:
+	makedepend -Y $(SRC)
+
+# DO NOT DELETE

examples/Gertboard/buttons.c

@@ -0,0 +1,83 @@
+/*
+ * buttons.c:
+ *	Read the Gertboard buttons. Each one will act as an on/off
+ *	tiggle switch for 3 different LEDs
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+
+// Array to keep track of our LEDs
+
+int leds [] = { 0, 0, 0 } ;
+
+// scanButton:
+//	See if a button is pushed, if so, then flip that LED and
+//	wait for the button to be let-go
+
+void scanButton (int button)
+{
+  if (digitalRead (button) == HIGH)	// Low is pushed
+    return ;
+
+  leds [button] ^= 1 ; // Invert state
+  digitalWrite (4 + button, leds [button]) ;
+
+  while (digitalRead (button) == LOW)	// Wait for release
+    delay (10) ;
+}
+
+int main (void)
+{
+  int i ;
+
+  printf ("Raspberry Pi Gertboard Button Test\n") ;
+
+  wiringPiSetup () ;
+
+// Setup the outputs:
+//	Pins 3, 4, 5, 6 and 7 output:
+//	We're not using 3 or 4, but make sure they're off anyway
+//	(Using same hardware config as blink12.c)
+
+  for (i = 3 ; i < 8 ; ++i)
+  {
+    pinMode      (i, OUTPUT) ;
+    digitalWrite (i, 0) ;
+  }
+
+// Setup the inputs
+
+  for (i = 0 ; i < 3 ; ++i)
+  {
+    pinMode         (i, INPUT) ;
+    pullUpDnControl (i, PUD_UP) ;
+    leds [i] = 0 ;
+  }
+
+  for (;;)
+  {
+    for (i = 0 ; i < 3 ; ++i)
+      scanButton (i) ;
+    delay (1) ;
+  }
+}

examples/Gertboard/gertboard.c

@@ -0,0 +1,96 @@
+/*
+ * gertboard.c:
+ *	Simple test for the SPI bus on the Gertboard
+ *
+ *	Hardware setup:
+ *		D/A port 0 jumpered to A/D port 0.
+ *
+ *	We output a sine wave on D/A port 0 and sample A/D port 0. We then
+ *	plot the input value on the terminal as a sort of vertical scrolling
+ *	oscilloscipe.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <math.h>
+
+// Gertboard D to A is an 8-bit unit.
+
+#define	B_SIZE	256
+
+#include <wiringPi.h>
+#include <gertboard.h>
+
+int main (void)
+{
+  double angle ;
+  int i, inputValue ;
+  int  buffer [B_SIZE] ;
+  int   cols ;
+  struct winsize w ;
+
+
+  printf ("Raspberry Pi Gertboard SPI test program\n") ;
+  printf ("=======================================\n") ;
+
+  ioctl (fileno (stdin), TIOCGWINSZ, &w);
+  cols = w.ws_col - 2 ;
+
+// Always initialise wiringPi. Use wiringPiSys() if you don't need
+//	(or want) to run as root
+
+  wiringPiSetupSys () ;
+
+// Initialise the Gertboard analog hardware at pin 100
+
+  gertboardAnalogSetup (100) ;
+
+// Generate a Sine Wave and store in our buffer
+
+  for (i = 0 ; i < B_SIZE ; ++i)
+  {
+    angle = ((double)i / (double)B_SIZE) * M_PI * 2.0 ;
+    buffer [i] = (int)rint ((sin (angle)) * 127.0 + 128.0) ;
+  }
+
+// Loop, output the sine wave on analog out port 0, read it into A-D port 0
+//	and display it on the screen
+
+  for (;;)
+  {
+    for (i = 0 ; i < B_SIZE ; ++i)
+    {
+      analogWrite (100, buffer [i]) ;
+
+      inputValue = analogRead (100) ;
+
+// We don't need to wory about the scale or sign - the analog hardware is
+//	a 10-bit value, so 0-1023. Just scale this to our terminal
+
+      printf ("%*s\n", (inputValue * cols) / 1023, "*") ;
+      delay (2) ;
+    }
+  }
+
+  return 0 ;
+}

examples/Gertboard/record.c

@@ -0,0 +1,60 @@
+/*
+ * record.c:
+ *	Record some audio via the Gertboard
+ *
+ *	Copyright (c) 2013 Gordon Henderson
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <sys/time.h>
+
+#include <wiringPi.h>
+#include <gertboard.h>
+
+#define	B_SIZE	40000
+
+int main ()
+{
+  int i ;
+  struct timeval tStart, tEnd, tTaken ;
+  unsigned char buffer [B_SIZE] ;
+
+  printf ("\n") ;
+  printf ("Gertboard demo: Recorder\n") ;
+  printf ("========================\n") ;
+
+// Always initialise wiringPi. Use wiringPiSys() if you don't need
+//	(or want) to run as root
+
+  wiringPiSetupSys () ;
+
+// Initialise the Gertboard analog hardware at pin 100
+
+  gertboardAnalogSetup (100) ;
+
+  gettimeofday (&tStart, NULL) ;
+
+  for (i = 0 ; i < B_SIZE ; ++i)
+    buffer [i] = analogRead (100) >> 2 ;
+
+  gettimeofday (&tEnd, NULL) ;
+  
+  timersub (&tEnd, &tStart, &tTaken) ;
+
+  printf ("Time taken for %d  reads: %ld.%ld\n", B_SIZE, tTaken.tv_sec, tTaken.tv_usec) ;
+
+  gettimeofday (&tStart, NULL) ;
+
+  for (i = 0 ; i < B_SIZE ; ++i)
+   analogWrite (100, buffer [i]) ;
+
+  gettimeofday (&tEnd, NULL) ;
+  
+  timersub (&tEnd, &tStart, &tTaken) ;
+
+  printf ("Time taken for %d writes: %ld.%ld\n", B_SIZE, tTaken.tv_sec, tTaken.tv_usec) ;
+
+  return 0 ;
+}
+

examples/Gertboard/temperature.c

@@ -0,0 +1,78 @@
+/*
+ * temperature.c:
+ *	Demonstrate use of the Gertboard A to D converter to make
+ *	a simple thermometer using the LM35.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+
+#include <wiringPi.h>
+#include <gertboard.h>
+
+int main ()
+{
+  int x1, x2 ;
+  double v1, v2 ;
+
+  printf ("\n") ;
+  printf ("Gertboard demo: Simple Thermemeter\n") ;
+  printf ("==================================\n") ;
+
+// Always initialise wiringPi. Use wiringPiSys() if you don't need
+//	(or want) to run as root
+
+  wiringPiSetupSys () ;
+
+// Initialise the Gertboard analog hardware at pin 100
+
+  gertboardAnalogSetup (100) ;
+
+  printf ("\n") ;
+  printf ("| Channel 0 | Channel 1 | Temperature 1 | Temperature 2 |\n") ;
+
+  for (;;)
+  {
+
+// Read the 2 channels:
+
+    x1 = analogRead (100) ;
+    x2 = analogRead (101) ;
+
+// Convert to a voltage:
+
+    v1 = (double)x1 / 1023.0 * 3.3 ;
+    v2 = (double)x2 / 1023.0 * 3.3 ;
+
+// Print
+
+    printf ("|    %6.3f |    %6.3f |", v1, v2) ;
+
+// Print Temperature of both channels by converting the LM35 reading
+//	to a temperature. Fortunately these are easy: 0.01 volts per C.
+
+    printf ("          %4.1f |          %4.1f |\r", v1 * 100.0, v2 * 100.0) ;
+    fflush (stdout) ;
+  }
+
+  return 0 ;
+}
+

examples/Gertboard/voltmeter.c

@@ -0,0 +1,73 @@
+/*
+ * voltmeter.c:
+ *	Demonstrate use of the Gertboard A to D converter to make
+ *	a simple voltmeter.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+
+#include <wiringPi.h>
+#include <gertboard.h>
+
+int main ()
+{
+  int x1, x2 ;
+  double v1, v2 ;
+
+  printf ("\n") ;
+  printf ("Gertboard demo: Simple Voltmeters\n") ;
+  printf ("=================================\n") ;
+
+// Always initialise wiringPi. Use wiringPiSys() if you don't need
+//	(or want) to run as root
+
+  wiringPiSetupSys () ;
+
+// Initialise the Gertboard analog hardware at pin 100
+
+  gertboardAnalogSetup (100) ;
+
+  printf ("\n") ;
+  printf ("| Channel 0 | Channel 1 |\n") ;
+
+  for (;;)
+  {
+
+// Read the 2 channels:
+
+    x1 = analogRead (100) ;
+    x2 = analogRead (101) ;
+
+// Convert to a voltage:
+
+    v1 = (double)x1 / 1023.0 * 3.3 ;
+    v2 = (double)x2 / 1023.0 * 3.3 ;
+
+// Print
+
+    printf ("|    %6.3f |    %6.3f |\r", v1, v2) ;
+    fflush (stdout) ;
+  }
+
+  return 0 ;
+}
+

examples/Gertboard/vumeter.c

@@ -0,0 +1,152 @@
+/*
+ * vumeter.c:
+ *	Simple VU meter
+ *
+ * Heres the theory:
+ *	We will sample at 4000 samples/sec and put the data into a
+ *	low-pass filter with a depth of 1000 samples. This will give
+ *	us 1/4 a second of lag on the signal, but I think it might
+ *	produce a more pleasing output.
+ *
+ *	The input of the microphone should be at mid-pont with no
+ *	sound input, but we might have to sample that too, to get
+ *	our reference zero...
+ *
+ *	Copyright (c) 2013 Gordon Henderson
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#include <wiringPi.h>
+#include <gertboard.h>
+
+#ifndef	TRUE
+#define	TRUE	(1==1)
+#define	FALSE	(!TRUE)
+#endif
+
+#define	B_SIZE	1000
+#define	S_SIZE	 128
+
+static int buffer [B_SIZE] ;
+static int bPtr = 0 ;
+
+/*
+ * ledPercent:
+ *	Output the given value as a percentage on the LEDs
+ *********************************************************************************
+ */
+
+static void ledPercent (int percent)
+{
+  unsigned int output = 0 ;
+
+  if (percent > 11) output |= 0x01 ;
+  if (percent > 22) output |= 0x02 ;
+  if (percent > 33) output |= 0x04 ;
+  if (percent > 44) output |= 0x08 ;
+  if (percent > 55) output |= 0x10 ;
+  if (percent > 66) output |= 0x20 ;
+  if (percent > 77) output |= 0x40 ;
+  if (percent > 88) output |= 0x80 ;
+
+  digitalWriteByte (output) ;
+}
+
+static unsigned int tPeriod, tNextSampleTime ;
+
+/*
+ * sample:
+ *	Get a sample from the Gertboard. If not enough time has elapsed
+ *	since the last sample, then wait...
+ *********************************************************************************
+ */
+
+static void sample (void)
+{
+  unsigned int tFuture ;
+
+// Calculate the future sample time
+
+  tFuture = tPeriod + tNextSampleTime ;
+
+// Wait until the next sample time
+
+  while (micros () < tNextSampleTime)
+    ;
+  
+  buffer [bPtr] = gertboardAnalogRead (0) ;
+
+  tNextSampleTime = tFuture ;
+}
+
+
+int main ()
+{
+  int quietLevel, min, max ;
+  int i, sum ;
+  unsigned int tStart, tEnd ;
+
+  printf ("\n") ;
+  printf ("Gertboard demo: VU Meter\n") ;
+  printf ("========================\n") ;
+
+  wiringPiSetup     () ;
+  gertboardSPISetup () ;
+
+  ledPercent (0) ;
+  for (i = 0 ; i < 8 ; ++i)
+    pinMode (i, OUTPUT) ;
+
+  for (bPtr = 0 ; bPtr < B_SIZE ; ++bPtr)
+    buffer [bPtr] = 99 ;
+
+  tPeriod = 1000000 / 1000 ;
+
+  printf ("Shhhh.... ") ; fflush (stdout) ;
+  delay (1000) ;
+  printf ("Sampling quiet... ") ; fflush (stdout) ;
+
+  tStart = micros () ;
+
+  tNextSampleTime = micros () ;
+  for (bPtr = 0 ; bPtr < B_SIZE ; ++bPtr)
+    sample () ;
+
+  tEnd = micros () ;
+
+  quietLevel = 0 ;
+  max =    0 ;
+  min = 1024 ;
+  for (i = 0 ; i < B_SIZE ; ++i)
+  {
+    quietLevel += buffer [i] ;
+    if (buffer [i] > max) max = buffer [i] ;
+    if (buffer [i] < min) min = buffer [i] ;
+  }
+  quietLevel /= B_SIZE ;
+
+  printf ("Done. Quiet level is: %d [%d:%d] [%d:%d]\n", quietLevel, min, max, quietLevel - min, max - quietLevel) ;
+
+  printf ("Time taken for %d reads: %duS\n", B_SIZE, tEnd - tStart) ;
+
+  for (bPtr = 0 ;;)
+  {
+    sample () ;
+    sum = 0 ;
+    for (i = 0 ; i < S_SIZE ; ++i)
+      sum += buffer [i] ;
+    sum /= S_SIZE ;
+    sum = abs (quietLevel - sum) ;
+    sum = (sum * 1000) / quietLevel ;
+    ledPercent (sum) ;
+    if (++bPtr > S_SIZE)
+      bPtr = 0 ;
+  }
+
+
+  return 0 ;
+}

examples/Makefile

@@ -3,7 +3,7 @@
 #	wiringPi - Wiring Compatable library for the Raspberry Pi
 #	https://projects.drogon.net/wiring-pi
 #
-#	Copyright (c) 2012 Gordon Henderson
+#	Copyright (c) 2012-2015 Gordon Henderson
 #################################################################################
 # This file is part of wiringPi:
 #	Wiring Compatable library for the Raspberry Pi
@@ -22,6 +22,9 @@
 #    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
 #################################################################################
 
+ifneq ($V,1)
+Q ?= @
+endif
 
 #DEBUG	= -g -O0
 DEBUG	= -O3
@@ -30,110 +33,137 @@ INCLUDE	= -I/usr/local/include
 CFLAGS	= $(DEBUG) -Wall $(INCLUDE) -Winline -pipe
 
 LDFLAGS	= -L/usr/local/lib
-LDLIBS    = -lwiringPi -lpthread -lm
+LDLIBS    = -lwiringPi -lwiringPiDev -lpthread -lm
 
 # Should not alter anything below this line
 ###############################################################################
 
-SRC	=	blink.c test1.c test2.c speed.c lcd.c wfi.c isr.c isr-osc.c	\
-		piface.c gertboard.c nes.c					\
-		pwm.c tone.c servo.c						\
-		delayTest.c serialRead.c serialTest.c okLed.c
+SRC	=	blink.c blink8.c blink12.c					\
+		blink12drcs.c							\
+		pwm.c								\
+		speed.c wfi.c isr.c isr-osc.c					\
+		lcd.c lcd-adafruit.c clock.c					\
+		nes.c								\
+		softPwm.c softTone.c 						\
+		delayTest.c serialRead.c serialTest.c okLed.c ds1302.c		\
+		lowPower.c							\
+		max31855.c							\
+		rht03.c
 
 OBJ	=	$(SRC:.c=.o)
 
 BINS	=	$(SRC:.c=)
 
 all:	
-	@cat README.TXT
-	@echo "    $(BINS)" | fmt
-	@echo ""
+	$Q cat README.TXT
+	$Q echo "    $(BINS)" | fmt
+	$Q echo ""
 
 really-all:	$(BINS)
 
 blink:	blink.o
-	@echo [link]
-	@$(CC) -o $@ blink.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ blink.o $(LDFLAGS) $(LDLIBS)
 
-test1:	test1.o
-	@echo [link]
-	@$(CC) -o $@ test1.o $(LDFLAGS) $(LDLIBS)
-	
-test2:	test2.o
-	@echo [link]
-	@$(CC) -o $@ test2.o $(LDFLAGS) $(LDLIBS)
+blink8:	blink8.o
+	$Q echo [link]
+	$Q $(CC) -o $@ blink8.o $(LDFLAGS) $(LDLIBS)
+
+blink12drcs:	blink12drcs.o
+	$Q echo [link]
+	$Q $(CC) -o $@ blink12drcs.o $(LDFLAGS) $(LDLIBS)
+
+blink12:	blink12.o
+	$Q echo [link]
+	$Q $(CC) -o $@ blink12.o $(LDFLAGS) $(LDLIBS)
 
 speed:	speed.o
-	@echo [link]
-	@$(CC) -o $@ speed.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ speed.o $(LDFLAGS) $(LDLIBS)
 
 lcd:	lcd.o
-	@echo [link]
-	@$(CC) -o $@ lcd.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ lcd.o $(LDFLAGS) $(LDLIBS)
+
+lcd-adafruit:	lcd-adafruit.o
+	$Q echo [link]
+	$Q $(CC) -o $@ lcd-adafruit.o $(LDFLAGS) $(LDLIBS)
+
+clock:	clock.o
+	$Q echo [link]
+	$Q $(CC) -o $@ clock.o $(LDFLAGS) $(LDLIBS)
 
 wfi:	wfi.o
-	@echo [link]
-	@$(CC) -o $@ wfi.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ wfi.o $(LDFLAGS) $(LDLIBS)
 
 isr:	isr.o
-	@echo [link]
-	@$(CC) -o $@ isr.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ isr.o $(LDFLAGS) $(LDLIBS)
 
 isr-osc:	isr-osc.o
-	@echo [link]
-	@$(CC) -o $@ isr-osc.o $(LDFLAGS) $(LDLIBS)
-
-piface:	piface.o
-	@echo [link]
-	@$(CC) -o $@ piface.o $(LDFLAGS) $(LDLIBS)
-
-gertboard:	gertboard.o
-	@echo [link]
-	@$(CC) -o $@ gertboard.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ isr-osc.o $(LDFLAGS) $(LDLIBS)
 
 nes:	nes.o
-	@echo [link]
-	@$(CC) -o $@ nes.o $(LDFLAGS) $(LDLIBS) 
+	$Q echo [link]
+	$Q $(CC) -o $@ nes.o $(LDFLAGS) $(LDLIBS) 
+
+rht03:	rht03.o
+	$Q echo [link]
+	$Q $(CC) -o $@ rht03.o $(LDFLAGS) $(LDLIBS) 
 
 pwm:	pwm.o
-	@echo [link]
-	@$(CC) -o $@ pwm.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ pwm.o $(LDFLAGS) $(LDLIBS)
+
+softPwm:	softPwm.o
+	$Q echo [link]
+	$Q $(CC) -o $@ softPwm.o $(LDFLAGS) $(LDLIBS)
+
+softTone:	softTone.o
+	$Q echo [link]
+	$Q $(CC) -o $@ softTone.o $(LDFLAGS) $(LDLIBS)
 
 delayTest:	delayTest.o
-	@echo [link]
-	@$(CC) -o $@ delayTest.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ delayTest.o $(LDFLAGS) $(LDLIBS)
 
 serialRead:	serialRead.o
-	@echo [link]
-	@$(CC) -o $@ serialRead.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ serialRead.o $(LDFLAGS) $(LDLIBS)
 
 serialTest:	serialTest.o
-	@echo [link]
-	@$(CC) -o $@ serialTest.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ serialTest.o $(LDFLAGS) $(LDLIBS)
 
 okLed:	okLed.o
-	@echo [link]
-	@$(CC) -o $@ okLed.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ okLed.o $(LDFLAGS) $(LDLIBS)
 
 tone:	tone.o
-	@echo [link]
-	@$(CC) -o $@ tone.o $(LDFLAGS) $(LDLIBS)
+	$Q echo [link]
+	$Q $(CC) -o $@ tone.o $(LDFLAGS) $(LDLIBS)
 
-servo:	servo.o
-	@echo [link]
-	@$(CC) -o $@ servo.o $(LDFLAGS) $(LDLIBS)
+ds1302:	ds1302.o
+	$Q echo [link]
+	$Q $(CC) -o $@ ds1302.o $(LDFLAGS) $(LDLIBS)
 
+max31855:	max31855.o
+	$Q echo [link]
+	$Q $(CC) -o $@ max31855.o $(LDFLAGS) $(LDLIBS)
 
 .c.o:
-	@echo [CC] $<
-	@$(CC) -c $(CFLAGS) $< -o $@
+	$Q echo [CC] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
 
 clean:
-	rm -f $(OBJ) *~ core tags $(BINS)
+	$Q echo "[Clean]"
+	$Q rm -f $(OBJ) *~ core tags $(BINS)
 
 tags:	$(SRC)
-	@echo [ctags]
-	@ctags $(SRC)
+	$Q echo [ctags]
+	$Q ctags $(SRC)
 
 depend:
 	makedepend -Y $(SRC)

examples/PiFace/Makefile

@@ -0,0 +1,88 @@
+#
+# Makefile:
+#	wiringPi - Wiring Compatable library for the Raspberry Pi
+#	https://projects.drogon.net/wiring-pi
+#
+#	Copyright (c) 2012 Gordon Henderson
+#################################################################################
+# This file is part of wiringPi:
+#	Wiring Compatable library for the Raspberry Pi
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#################################################################################
+
+ifneq ($V,1)
+Q ?= @
+endif
+
+#DEBUG	= -g -O0
+DEBUG	= -O3
+CC	= gcc
+INCLUDE	= -I/usr/local/include
+CFLAGS	= $(DEBUG) -Wall $(INCLUDE) -Winline -pipe
+
+LDFLAGS	= -L/usr/local/lib
+LDLIBS    = -lwiringPi -lwiringPiDev -lpthread -lm
+
+# Should not alter anything below this line
+###############################################################################
+
+SRC	=	blink.c buttons.c reaction.c ladder.c metro.c motor.c
+
+OBJ	=	$(SRC:.c=.o)
+
+BINS	=	$(SRC:.c=)
+
+all:	$(BINS)
+
+blink:	blink.o
+	$Q echo [link]
+	$Q $(CC) -o $@ blink.o $(LDFLAGS) $(LDLIBS)
+
+buttons:	buttons.o
+	$Q echo [link]
+	$Q $(CC) -o $@ buttons.o $(LDFLAGS) $(LDLIBS)
+
+reaction:	reaction.o
+	$Q echo [link]
+	$Q $(CC) -o $@ reaction.o $(LDFLAGS) $(LDLIBS)
+
+ladder:	ladder.o
+	$Q echo [link]
+	$Q $(CC) -o $@ ladder.o $(LDFLAGS) $(LDLIBS)
+
+metro:	metro.o
+	$Q echo [link]
+	$Q $(CC) -o $@ metro.o $(LDFLAGS) $(LDLIBS)
+
+motor:	motor.o
+	$Q echo [link]
+	$Q $(CC) -o $@ motor.o $(LDFLAGS) $(LDLIBS)
+
+.c.o:
+	$Q echo [CC] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
+
+clean:
+	$Q echo "[Clean]"
+	$Q rm -f $(OBJ) *~ core tags $(BINS)
+
+tags:	$(SRC)
+	$Q echo [ctags]
+	$Q ctags $(SRC)
+
+depend:
+	makedepend -Y $(SRC)
+
+# DO NOT DELETE

examples/PiFace/blink.c

@@ -0,0 +1,59 @@
+/*
+ * blink.c:
+ *	Simple "blink" test for the PiFace interface board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+
+#include <wiringPi.h>
+#include <piFace.h>
+
+// Use 200 as the pin-base for the PiFace board, and pick a pin
+//	for the LED that's not connected to a relay
+
+#define	PIFACE	200
+#define	LED	(PIFACE+2)
+
+int main (int argc, char *argv [])
+{
+  printf ("Raspberry Pi PiFace Blink\n") ;
+  printf ("=========================\n") ;
+
+// Always initialise wiringPi. Use wiringPiSys() if you don't need
+//	(or want) to run as root
+
+  wiringPiSetupSys () ;
+
+// Setup the PiFace board
+
+  piFaceSetup (PIFACE) ;
+
+  for (;;)
+  {
+    digitalWrite (LED, HIGH) ;	// On
+    delay (500) ;		// mS
+    digitalWrite (LED, LOW) ;	// Off
+    delay (500) ;
+  }
+
+  return 0 ;
+}

examples/PiFace/buttons.c

@@ -0,0 +1,103 @@
+/*
+ * buttons.c:
+ *	Simple test for the PiFace interface board.
+ *
+ *	Read the buttons and output the same to the LEDs
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+
+#include <wiringPi.h>
+#include <piFace.h>
+
+int outputs [4] = { 0,0,0,0 } ;
+
+// Use 200 as the pin-base for the PiFace board
+
+#define	PIFACE_BASE	200
+
+
+/*
+ * scanButton:
+ *	Read the guiven button - if it's pressed, then flip the state
+ *	of the correspoinding output pin
+ *********************************************************************************
+ */
+
+void scanButton (int button)
+{
+  if (digitalRead (PIFACE_BASE + button) == LOW)
+  {
+    outputs [button] ^= 1 ;
+    digitalWrite (PIFACE_BASE + button, outputs [button]) ;
+    printf ("Button %d pushed - output now: %s\n",
+		button, (outputs [button] == 0) ? "Off" : "On") ;
+  }
+
+  while (digitalRead (PIFACE_BASE + button) == LOW)
+    delay (1) ;
+}
+
+
+/*
+ * start here
+ *********************************************************************************
+ */
+
+int main (void)
+{
+  int pin, button ;
+
+  printf ("Raspberry Pi wiringPi + PiFace test program\n") ;
+  printf ("===========================================\n") ;
+  printf ("\n") ;
+  printf (
+"This program reads the buttons and uses them to toggle the first 4\n"
+"outputs. Push a button once to turn an output on, and push it again to\n"
+"turn it off again.\n\n") ;
+
+// Always initialise wiringPi. Use wiringPiSys() if you don't need
+//	(or want) to run as root
+
+  wiringPiSetupSys () ;
+
+  piFaceSetup (PIFACE_BASE) ;
+
+// Enable internal pull-ups & start with all off
+
+  for (pin = 0 ; pin < 8 ; ++pin)
+  {
+    pullUpDnControl (PIFACE_BASE + pin, PUD_UP) ;
+    digitalWrite    (PIFACE_BASE + pin, 0) ;
+  }
+
+// Loop, scanning the buttons
+
+  for (;;)
+  {
+    for (button = 0 ; button < 4 ; ++button)
+      scanButton (button) ;
+    delay (5) ;
+  }
+
+  return 0 ;
+}

examples/PiFace/ladder.c

@@ -0,0 +1,337 @@
+/*
+ * ladder.c:
+ *
+ *	Gordon Henderson, June 2012
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+
+#include <wiringPi.h>
+#include <piFace.h>
+
+#ifndef	TRUE
+#  define	TRUE	(1==1)
+#  define	FALSE	(1==2)
+#endif
+
+#undef	DEBUG
+
+#define	NUM_LEDS	 8
+
+
+// Map the LEDs to the hardware pins
+//	using PiFace pin numbers here
+
+#define	PIFACE	200
+
+const int ledMap [NUM_LEDS] =
+{
+//  0, 1, 2, 3, 4, 5, 6, 7, 8
+    200, 201, 202, 203, 204, 205, 206, 207
+} ;
+
+
+// Some constants for our circuit simulation
+
+const double vBatt      =      9.0 ;	// Volts (ie. a PP3)
+const double capacitor  =      0.001 ;	// 1000uF
+const double rCharge    =   2200.0 ;	// ohms
+const double rDischarge =  68000.0 ;	// ohms
+const double timeInc    =      0.01 ;	// Seconds
+
+double vCharge, vCap, vCapLast ;
+
+
+
+/*
+ * setup:
+ *	Program the GPIO correctly and initialise the lamps
+ ***********************************************************************
+ */
+
+void setup (void)
+{
+  int i ;
+
+  wiringPiSetupSys () ;
+
+  if (piFaceSetup (200) == -1)
+    exit (1) ;
+
+// Enable internal pull-ups
+
+  for (i = 0 ; i < 8 ; ++i)
+    pullUpDnControl (PIFACE + i, PUD_UP) ;
+
+// Calculate the actual charging voltage - standard calculation of
+//	vCharge = r2 / (r1 + r2) * vBatt
+//
+//
+//   -----+--- vBatt
+//        |
+//        R1
+//        |
+//        +---+---- vCharge
+//        |   |
+//        R2  C
+//        |   |
+//   -----+---+-----
+
+  vCharge = rDischarge / (rCharge + rDischarge) * vBatt ;
+
+// Start with no charge
+
+  vCap    = vCapLast = 0.0 ;
+}
+
+
+/*
+ * introLeds
+ *	Put a little pattern on the LEDs to start with
+ *********************************************************************************
+ */
+
+void introLeds (void)
+{
+  int i, j ;
+
+
+  printf ("Pi Ladder\n") ;
+  printf ("=========\n\n") ;
+  printf ("       vBatt: %6.2f volts\n", vBatt) ;
+  printf ("     rCharge: %6.0f ohms\n", rCharge) ;
+  printf ("  rDischarge: %6.0f ohms\n", rDischarge) ;
+  printf ("     vCharge: %6.2f volts\n", vCharge) ;
+  printf ("   capacitor: %6.0f uF\n", capacitor * 1000.0) ;
+
+// Flash 3 times:
+
+  for (j = 0 ; j < 3 ; ++j)
+  {
+    for (i = 0 ; i < NUM_LEDS ; ++i)
+      digitalWrite (ledMap [i], 1) ;
+    delay (500) ;
+    for (i = 0 ; i < NUM_LEDS ; ++i)
+      digitalWrite (ledMap [i], 0) ;
+    delay (100) ;
+  }
+
+// All On
+
+  for (i = 0 ; i < NUM_LEDS ; ++i)
+    digitalWrite (ledMap [i], 1) ;
+  delay (500) ;
+
+// Countdown...
+
+  for (i = NUM_LEDS - 1 ; i >= 0 ; --i)
+  {
+    digitalWrite (ledMap [i], 0) ;
+    delay (100) ;
+  }
+  delay (500) ;
+}
+
+
+/*
+ * winningLeds
+ *	Put a little pattern on the LEDs to start with
+ *********************************************************************************
+ */
+
+void winningLeds (void)
+{
+  int i, j ;
+
+// Flash 3 times:
+
+  for (j = 0 ; j < 3 ; ++j)
+  {
+    for (i = 0 ; i < NUM_LEDS ; ++i)
+      digitalWrite (ledMap [i], 1) ;
+    delay (500) ;
+    for (i = 0 ; i < NUM_LEDS ; ++i)
+      digitalWrite (ledMap [i], 0) ;
+    delay (100) ;
+  }
+
+// All On
+
+  for (i = 0 ; i < NUM_LEDS ; ++i)
+    digitalWrite (ledMap [i], 1) ;
+  delay (500) ;
+
+// Countup...
+
+  for (i = 0 ; i < NUM_LEDS ; ++i)
+  {
+    digitalWrite (ledMap [i], 0) ;
+    delay (100) ;
+  }
+  delay (500) ;
+}
+
+
+/*
+ * chargeCapacitor: dischargeCapacitor:
+ *	Add or remove charge to the capacitor.
+ *	Standard capacitor formulae.
+ *********************************************************************************
+ */
+
+void chargeCapacitor (void)
+{
+  vCap = (vCapLast - vCharge) *
+	exp (- timeInc / (rCharge * capacitor)) + vCharge ;
+
+#ifdef	DEBUG
+  printf ("+vCap: %7.4f\n", vCap) ;
+#endif
+
+  vCapLast = vCap ;
+}
+
+void dischargeCapacitor (void)
+{
+  vCap = vCapLast *
+	exp (- timeInc / (rDischarge * capacitor)) ;
+
+#ifdef	DEBUG
+  printf ("-vCap: %7.4f\n", vCap) ;
+#endif
+
+  vCapLast = vCap ;
+}
+
+
+/*
+ * ledBargraph:
+ *	Output the supplied number as a bargraph on the LEDs
+ *********************************************************************************
+ */
+
+void ledBargraph (double value, int topLedOn)
+{
+  int topLed = (int)floor (value / vCharge * (double)NUM_LEDS) + 1 ;
+  int i ;
+
+  if (topLed > NUM_LEDS)
+    topLed = NUM_LEDS ;
+
+  if (!topLedOn)
+    --topLed ;
+
+  for (i = 0 ; i < topLed ; ++i)
+    digitalWrite (ledMap [i], 1) ;
+
+  for (i = topLed ; i < NUM_LEDS ; ++i)
+    digitalWrite (ledMap [i], 0) ;
+}
+
+
+/*
+ * ledOnAction:
+ *	Make sure the leading LED is on and check the button
+ *********************************************************************************
+ */
+
+void ledOnAction (void)
+{
+  if (digitalRead (PIFACE) == LOW)
+  {
+    chargeCapacitor () ;
+    ledBargraph (vCap, TRUE) ;
+  }
+}
+
+
+/*
+ * ledOffAction:
+ *	Make sure the leading LED is off and check the button
+ *********************************************************************************
+ */
+
+void ledOffAction (void)
+{
+  dischargeCapacitor () ;
+
+// Are we still pushing the button?
+
+  if (digitalRead (PIFACE) == LOW)
+  {
+    vCap = vCapLast = 0.0 ;
+    ledBargraph (vCap, FALSE) ;
+
+// Wait until we release the button
+
+    while (digitalRead (PIFACE) == LOW)
+      delay (10) ;
+  }
+}
+
+
+/*
+ ***********************************************************************
+ * The main program
+ ***********************************************************************
+ */
+
+int main (void)
+{
+  unsigned int then, ledOnTime, ledOffTime ;
+  unsigned int ourDelay = (int)(1000.0 * timeInc) ;
+  
+  setup     () ;
+  introLeds () ;
+
+// Setup the LED times - TODO reduce the ON time as the game progresses
+
+  ledOnTime  = 1000 ;
+  ledOffTime = 1000 ;
+
+// This is our Gate/Squarewave loop
+
+  for (;;)
+  {
+
+// LED ON:
+
+    (void)ledBargraph (vCap, TRUE) ;
+    then = millis () + ledOnTime ;
+    while (millis () < then)
+    {
+      ledOnAction () ;
+      delay       (ourDelay) ;
+    }
+
+// Have we won yet?
+//	We need vCap to be in the top NUM_LEDS of the vCharge
+
+    if (vCap > ((double)(NUM_LEDS - 1) / (double)NUM_LEDS * vCharge))	// Woo hoo!
+    {
+      winningLeds () ;
+      while (digitalRead (PIFACE) == HIGH)
+	delay (10) ;
+      while (digitalRead (PIFACE) == LOW)
+	delay (10) ;
+      vCap = vCapLast = 0.0 ;
+    }
+
+// LED OFF:
+
+    (void)ledBargraph (vCap, FALSE) ;
+    then = millis () + ledOffTime ;
+    while (millis () < then)
+    {
+      ledOffAction () ;
+      delay        (ourDelay) ;
+    }
+
+  }
+
+  return 0 ;
+}

examples/PiFace/metro.c

@@ -0,0 +1,111 @@
+/*
+ * metronome.c:
+ *	Simple test for the PiFace interface board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <wiringPi.h>
+#include <piFace.h>
+
+#define	PIFACE	200
+
+/*
+ * middleA:
+ *	Play middle A (on the relays - yea!)
+ *********************************************************************************
+ */
+
+static void middleA (void)
+{
+  unsigned int next ;
+
+  for (;;)
+  {
+    next = micros () + 1136 ;
+    digitalWrite (PIFACE + 0, 0)  ;
+    digitalWrite (PIFACE + 1, 0)  ;
+    while (micros () < next)
+      delayMicroseconds (1) ;
+    
+    next = micros () + 1137 ;
+    digitalWrite (PIFACE + 0, 1)  ;
+    digitalWrite (PIFACE + 1, 1)  ;
+    while (micros () < next)
+      delayMicroseconds (1) ;
+    
+  }
+}
+
+
+int main (int argc, char *argv [])
+{
+  int bpm, msPerBeat, state = 0 ;
+  unsigned int end ;
+
+  printf ("Raspberry Pi PiFace Metronome\n") ;
+  printf ("=============================\n") ;
+
+  piHiPri (50) ;
+
+  wiringPiSetupSys () ;	// Needed for timing functions
+  piFaceSetup      (PIFACE) ;
+
+  if (argc != 2)
+  {
+    printf ("Usage: %s <beates per minute>\n", argv [0]) ;
+    exit (1) ;
+  }
+
+  if (strcmp (argv [1], "a") == 0)
+    middleA () ;
+
+  bpm = atoi (argv [1]) ;
+
+  if ((bpm < 40) || (bpm > 208))
+  {
+    printf ("%s range is 40 through 208 beats per minute\n", argv [0]) ;
+    exit (1) ;
+  }
+
+  msPerBeat = 60000 / bpm  ;
+
+// Main loop:
+//	Put some random LED pairs up for a few seconds, then blank ...
+
+  for (;;)
+  {
+    end = millis ()  + msPerBeat ;
+
+    digitalWrite (PIFACE + 0, state)  ;
+    digitalWrite (PIFACE + 1, state)  ;
+
+    while (millis () < end)
+      delayMicroseconds (500) ;
+
+    state ^= 1 ;
+  }
+
+  return 0 ;
+}

examples/PiFace/motor.c

@@ -0,0 +1,120 @@
+/*
+ * motor.c:
+ *	Use the PiFace board to demonstrate an H bridge
+ *	circuit via the 2 relays.
+ *	Then add on an external transsitor to help with PWM.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <wiringPi.h>
+#include <piFace.h>
+#include <softPwm.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+int outputs [2] = { 0,0 } ;
+
+#define	PIFACE_BASE	200
+#define PWM_OUT_PIN	204
+#define	PWM_UP		202
+#define	PWM_DOWN	203
+
+void scanButton (int button)
+{
+  if (digitalRead (PIFACE_BASE + button) == LOW)
+  {
+    outputs [button] ^= 1 ;
+    digitalWrite (PIFACE_BASE + button, outputs [button]) ;
+    printf ("Button %d pushed - output now: %s\n",
+		button, (outputs [button] == 0) ? "Off" : "On") ;
+  }
+
+  while (digitalRead (PIFACE_BASE + button) == LOW)
+    delay (1) ;
+}
+
+
+int main (void)
+{
+  int pin, button ;
+  int pwmValue = 0 ;
+
+  printf ("Raspberry Pi PiFace - Motor control\n") ;
+  printf ("==================================\n") ;
+  printf ("\n") ;
+  printf (
+"This program is designed to be used with a motor connected to the relays\n"
+"in an H-Bridge type configuration with optional speeed control via PWM.\n"
+"\n"
+"Use the leftmost buttons to turn each relay on and off, and the rigthmost\n"
+"buttons to increase ot decrease the PWM output on the control pin (pin\n"
+"4)\n\n") ;
+
+  wiringPiSetup () ;
+  piFaceSetup (PIFACE_BASE) ;
+  softPwmCreate (PWM_OUT_PIN, 100, 100) ;
+
+// Enable internal pull-ups & start with all off
+
+  for (pin = 0 ; pin < 8 ; ++pin)
+  {
+    pullUpDnControl (PIFACE_BASE + pin, PUD_UP) ;
+    digitalWrite    (PIFACE_BASE + pin, 0) ;
+  }
+
+  for (;;)
+  {
+    for (button = 0 ; button < 2 ; ++button)
+      scanButton (button) ;
+
+    if (digitalRead (PWM_UP) == LOW)
+    {
+      pwmValue += 10 ;
+      if (pwmValue > 100)
+	pwmValue = 100 ;
+
+      softPwmWrite (PWM_OUT_PIN, pwmValue) ;
+      printf ("PWM -> %3d\n", pwmValue) ;
+
+      while (digitalRead (PWM_UP) == LOW)
+	delay (5) ;
+    }
+
+    if (digitalRead (PWM_DOWN) == LOW)
+    {
+      pwmValue -= 10 ;
+      if (pwmValue < 0)
+	pwmValue = 0 ;
+
+      softPwmWrite (PWM_OUT_PIN, pwmValue) ;
+      printf ("PWM -> %3d\n", pwmValue) ;
+
+      while (digitalRead (PWM_DOWN) == LOW)
+	delay (5) ;
+    }
+
+    delay (5) ;
+  }
+
+  return 0 ;
+}

examples/PiFace/reaction.c

@@ -0,0 +1,194 @@
+/*
+ * reaction.c:
+ *	Simple test for the PiFace interface board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include <wiringPi.h>
+#include <piFace.h>
+
+
+int outputs [4] = { 0,0,0,0 } ;
+
+#define	PIFACE	200
+
+/*
+ * light:
+ *	Light up the given LED - actually lights up a pair
+ *********************************************************************************
+ */
+
+void light (int led, int value)
+{
+  led *= 2 ;
+  digitalWrite (PIFACE + led + 0, value) ;
+  digitalWrite (PIFACE + led + 1, value) ;
+}
+
+/*
+ * lightAll:
+ *	All On or Off
+ *********************************************************************************
+ */
+
+void lightAll (int onoff)
+{
+  light (0, onoff) ;
+  light (1, onoff) ;
+  light (2, onoff) ;
+  light (3, onoff) ;
+}
+
+
+/*
+ * waitForNoButtons:
+ *	Wait for all buttons to be released
+ *********************************************************************************
+ */
+
+void waitForNoButtons (void)
+{
+  int i, button ;
+
+  for (;;)
+  {
+    button = 0 ;
+    for (i = 0 ; i < 4 ; ++i)
+      button += digitalRead (PIFACE + i) ;
+
+    if (button == 4)
+      break ;
+  }
+}
+
+
+void scanButton (int button)
+{
+  if (digitalRead (PIFACE + button) == LOW)
+  {
+    outputs [button] ^= 1 ;
+    digitalWrite (PIFACE + button, outputs [button]) ;
+  }
+
+  while (digitalRead (PIFACE + button) == LOW)
+    delay (1) ;
+}
+
+
+int main (void)
+{
+  int i, j ;
+  int led, button ;
+  unsigned int start, stop ;
+
+  printf ("Raspberry Pi PiFace Reaction Timer\n") ;
+  printf ("==================================\n") ;
+
+  if (piFaceSetup (PIFACE) == -1)
+    exit (1) ;
+
+// Enable internal pull-ups
+
+  for (i = 0 ; i < 8 ; ++i)
+    pullUpDnControl (PIFACE + i, PUD_UP) ;
+
+
+// Main game loop:
+//	Put some random LED pairs up for a few seconds, then blank ...
+
+  for (;;)
+  {
+    printf ("Press any button to start ... \n") ; fflush (stdout) ;
+
+    for (;;)
+    {
+      led = rand () % 4 ;
+      light (led, 1) ;
+      delay (10) ;
+      light (led, 0) ;
+
+      button = 0 ;
+      for (j = 0 ; j < 4 ; ++j)
+	button += digitalRead (PIFACE + j) ;
+
+      if (button != 4)
+	break ;
+    }
+
+    waitForNoButtons () ;
+
+    printf ("Wait for it ... ") ; fflush (stdout) ;
+
+    led = rand () % 4 ;
+    delay (rand () % 500 + 1000) ;
+    light (led, 1) ;
+
+    start = millis () ;
+    for (button = -1 ; button == -1 ; )
+    {
+      for (j = 0 ; j < 4 ; ++j)
+	if (digitalRead (PIFACE + j) == 0)	// Pushed
+	{
+	  button = j ;
+	  break ;
+	}
+    }
+    stop = millis () ;
+    button = 3 - button ; // Correct for the buttons/LEDs reversed
+
+    light (led, 0) ;
+
+    waitForNoButtons () ;
+
+    light (led, 1) ;
+
+    if (button == led)
+    {
+      printf ("You got it in %3d mS\n", stop - start) ;
+    }
+    else
+    {
+      printf ("Missed: You pushed %d - LED was %d\n", button, led) ;
+      for (;;)
+      {
+	light (button, 1) ;
+	delay (100) ;
+	light (button, 0) ;
+	delay (100) ;
+	i = 0 ;
+	for (j = 0 ; j < 4 ; ++j)
+	  i += digitalRead (PIFACE + j) ;
+	if (i != 4)
+	  break ;
+      }
+
+      waitForNoButtons () ;
+    }
+    light (led, 0) ;
+    delay (4000) ;
+  }
+
+  return 0 ;
+}

examples/PiGlow/Makefile

@@ -0,0 +1,82 @@
+#
+# Makefile:
+#	wiringPi - Wiring Compatable library for the Raspberry Pi
+#	https://projects.drogon.net/wiring-pi
+#
+#	Copyright (c) 2012-2015 Gordon Henderson
+#################################################################################
+# This file is part of wiringPi:
+#	Wiring Compatable library for the Raspberry Pi
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#################################################################################
+
+ifneq ($V,1)
+Q ?= @
+endif
+
+#DEBUG	= -g -O0
+DEBUG	= -O3
+CC	= gcc
+INCLUDE	= -I/usr/local/include
+CFLAGS	= $(DEBUG) -Wall $(INCLUDE) -Winline -pipe
+
+LDFLAGS	= -L/usr/local/lib
+LDLIBS    = -lwiringPi -lwiringPiDev -lpthread -lm
+
+# Should not alter anything below this line
+###############################################################################
+
+SRC	=	piGlow0.c piGlow1.c piglow.c
+
+OBJ	=	$(SRC:.c=.o)
+
+BINS	=	$(SRC:.c=)
+
+all:	$(BINS)
+
+piGlow0:	piGlow0.o
+	$Q echo [link]
+	$Q $(CC) -o $@ piGlow0.o $(LDFLAGS) $(LDLIBS)
+
+piGlow1:	piGlow1.o
+	$Q echo [link]
+	$Q $(CC) -o $@ piGlow1.o $(LDFLAGS) $(LDLIBS)
+
+piglow:	piglow.o
+	$Q echo [link]
+	$Q $(CC) -o $@ piglow.o $(LDFLAGS) $(LDLIBS)
+
+.c.o:
+	$Q echo [CC] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
+
+clean:
+	$Q echo "[Clean]"
+	$Q rm -f $(OBJ) *~ core tags $(BINS)
+
+tags:	$(SRC)
+	$Q echo [ctags]
+	$Q ctags $(SRC)
+
+install:	piglow
+	$Q echo Installing piglow into /usr/local/bin
+	$Q cp -a piglow /usr/local/bin/piglow
+	$Q chmod 755 /usr/local/bin/piglow
+	$Q echo Done. Remember to load the I2C drivers!
+
+depend:
+	makedepend -Y $(SRC)
+
+# DO NOT DELETE

examples/PiGlow/piGlow0.c

@@ -0,0 +1,51 @@
+/*
+ * piglow.c:
+ *	Very simple demonstration of the PiGlow board.
+ *	This uses the SN3218 directly - soon there will be a new PiGlow
+ *	devLib device which will handle the PiGlow board on a more easy
+ *	to use manner...
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <wiringPi.h>
+#include <sn3218.h>
+
+#define	LED_BASE	533
+
+int main (void)
+{
+  int i, j ;
+
+  wiringPiSetupSys () ;
+
+  sn3218Setup (LED_BASE) ;
+
+  for (;;)
+  {
+    for (i = 0 ; i < 256 ; ++i)
+      for (j = 0 ; j < 18 ; ++j)
+	analogWrite (LED_BASE + j, i) ;
+
+    for (i = 255 ; i >= 0 ; --i)
+      for (j = 0 ; j < 18 ; ++j)
+	analogWrite (LED_BASE + j, i) ;
+  }
+}

examples/PiGlow/piGlow1.c

@@ -0,0 +1,258 @@
+/*
+ * piGlow1.c:
+ *	Very simple demonstration of the PiGlow board.
+ *	This uses the piGlow devLib.
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <poll.h>
+
+#include <wiringPi.h>
+#include <piGlow.h>
+
+#define	PIGLOW_BASE	533
+
+#ifndef	TRUE
+#  define TRUE  (1==1)
+#  define FALSE (!TRUE)
+#endif
+
+
+/*
+ * keypressed: clearKeypressed:
+ *	Simple but effective ways to tell if the enter key has been pressed
+ *********************************************************************************
+ */
+
+static int keypressed (void)
+{
+  struct pollfd polls ;
+
+  polls.fd     = fileno (stdin) ;
+  polls.events = POLLIN ;
+
+  return poll (&polls, 1, 0) != 0 ;
+}
+
+static void clearKeypressed (void)
+{
+  while (keypressed ())
+    (void)getchar () ;
+}
+
+
+/*
+ * pulseLed:
+ *	Pulses the LED at position leg, ring from off to a max. value,
+ *	then off again
+ *********************************************************************************
+ */
+
+static void pulseLed (int leg, int ring)
+{
+  int i ;
+
+  for (i = 0 ; i < 140 ; ++i)
+  {
+    piGlow1 (leg, ring, i) ;
+    delay (1) ;
+  }
+  delay (10) ;
+  for (i = 140 ; i >= 0 ; --i)
+  {
+    piGlow1 (leg, ring, i) ;
+    delay (1) ;
+  }
+}
+
+/*
+ * pulseLeg:
+ *	Same as above, but a whole leg at a time
+ *********************************************************************************
+ */
+
+static void pulseLeg (int leg)
+{
+  int i ;
+
+  for (i = 0 ; i < 140 ; ++i)
+  {
+    piGlowLeg (leg, i) ; delay (1) ;
+  }
+  delay (10) ;
+  for (i = 140 ; i >= 0 ; --i)
+  {
+    piGlowLeg (leg, i) ; delay (1) ;
+  }
+}
+
+
+/*
+ * pulse Ring:
+ *	Same as above, but a whole ring at a time
+ *********************************************************************************
+ */
+
+static void pulseRing (int ring)
+{
+  int i ;
+
+  for (i = 0 ; i < 140 ; ++i)
+  {
+    piGlowRing (ring, i) ; delay (1) ;
+  }
+  delay (10) ;
+  for (i = 140 ; i >= 0 ; --i)
+  {
+    piGlowRing (ring, i) ; delay (1) ;
+  }
+}
+
+#define	LEG_STEPS	3
+
+static int legSequence [] =
+{
+   4, 12, 99,
+  99,  4, 12, 
+  12, 99,  4,
+} ;
+  
+
+#define	RING_STEPS	16
+
+static int ringSequence [] =
+{
+   0,  0,  0,  0,  0, 64,
+   0,  0,  0,  0, 64, 64,
+   0,  0,  0, 64, 64,  0,
+   0,  0, 64, 64,  0,  0,
+   0, 64, 64,  0,  0,  0,
+  64, 64,  0,  0,  0,  0,
+  64,  0,  0,  0,  0,  0,
+   0,  0,  0,  0,  0,  0,
+  64,  0,  0,  0,  0,  0,
+  64, 64,  0,  0,  0,  0,
+   0, 64, 64,  0,  0,  0,
+   0,  0, 64, 64,  0,  0,
+   0,  0,  0, 64, 64,  0,
+   0,  0,  0,  0, 64, 64,
+   0,  0,  0,  0,  0, 64,
+   0,  0,  0,  0,  0,  0,
+} ;
+
+/*
+ * main:
+ *	Our little demo prgoram
+ *********************************************************************************
+ */
+
+int main (void)
+{
+  int i ;
+  int step, ring, leg ;
+
+// Always initialise wiringPi:
+//	Use the Sys method if you don't need to run as root
+
+  wiringPiSetupSys () ;
+
+// Initialise the piGlow devLib with our chosen pin base
+
+  piGlowSetup (1) ;
+
+// LEDs, one at a time
+
+  printf ("LEDs, one at a time\n") ;
+  for (; !keypressed () ;)
+    for (leg = 0 ; leg < 3 ; ++leg)
+    {
+      for (ring = 0 ; ring < 6 ; ++ring)
+      {
+	pulseLed (leg, ring) ;
+	if (keypressed ())
+	  break ;
+      }
+      if (keypressed ())
+	break ;
+    }
+  clearKeypressed () ;
+
+// Rings, one at a time
+
+  printf ("Rings, one at a time\n") ;
+  for (; !keypressed () ;)
+    for (ring = 0 ; ring < 6 ; ++ring)
+    {
+      pulseRing (ring) ;
+      if (keypressed ())
+	break ;
+    }
+  clearKeypressed () ;
+
+// Legs, one at a time
+
+  printf ("Legs, one at a time\n") ;
+  for (; !keypressed () ;)
+    for (leg = 0 ; leg < 3 ; ++leg)
+    {
+      pulseLeg (leg) ;
+      if (keypressed ())
+	break ;
+    }
+  clearKeypressed () ;
+
+  delay (1000) ;
+
+// Sequence - alternating rings, legs and random
+
+  printf ("Sequence now\n") ;
+  for (; !keypressed () ;)
+  {
+    for (i = 0 ; i < 20 ; ++i)
+      for (step = 0 ; step < LEG_STEPS ; ++step)
+      {
+	for (leg = 0 ; leg < 3 ; ++leg)
+	  piGlowLeg (leg, legSequence [step * 3 + leg]) ;
+	delay (80) ;
+      }
+
+    for (i = 0 ; i < 10 ; ++i)
+      for (step = 0 ; step < RING_STEPS ; ++step)
+      {
+	for (ring = 0 ; ring < 6 ; ++ring)
+	  piGlowRing (ring, ringSequence [step * 6 + ring]) ;
+	delay (80) ;
+      }
+
+    for (i = 0 ; i < 1000 ; ++i)
+    {
+      leg  = random () % 3 ;
+      ring = random () % 6 ;
+      piGlow1 (leg, ring, random () % 256) ;
+      delay (5) ; 
+      piGlow1 (leg, ring, 0) ;
+    }
+  }
+
+  return 0 ;
+}

examples/PiGlow/piglow.c

@@ -0,0 +1,176 @@
+/*
+ * piglow.c:
+ *	Very simple demonstration of the PiGlow board.
+ *	This uses the piGlow devLib.
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifndef	TRUE
+#  define TRUE  (1==1)
+#  define FALSE (!TRUE)
+#endif
+
+#include <wiringPi.h>
+#include <piGlow.h>
+
+static void failUsage (void)
+{
+  fprintf (stderr, "Usage examples:\n") ;
+  fprintf (stderr, "  piglow off         # All off\n") ;
+  fprintf (stderr, "  piglow red 50      # Light the 3 red LEDs to 50%%\n") ;
+  fprintf (stderr, "     colours are: red, yellow, orange, green, blue and white\n") ;
+  fprintf (stderr, "  piglow all 75      # Light all to 75%%\n") ;
+  fprintf (stderr, "  piglow leg 0 25    # Light leg 0 to 25%%\n") ;
+  fprintf (stderr, "  piglow ring 3 100  # Light ring 3 to 100%%\n") ;
+  fprintf (stderr, "  piglow led 2 5 100 # Light the single LED on Leg 2, ring 5 to 100%%\n") ;
+
+  exit (EXIT_FAILURE) ;
+}
+
+static int getPercent (char *typed)
+{
+  int percent ;
+
+  percent = atoi (typed) ;
+  if ((percent < 0) || (percent > 100))
+  {
+    fprintf (stderr, "piglow: percent value out of range\n") ;
+    exit (EXIT_FAILURE) ;
+  }
+  return (percent * 255) / 100 ;
+}
+
+
+/*
+ * main:
+ *	Our little demo prgoram
+ *********************************************************************************
+ */
+
+int main (int argc, char *argv [])
+{
+  int percent ;
+  int ring, leg ;
+
+// Always initialise wiringPi:
+//	Use the Sys method if you don't need to run as root
+
+  wiringPiSetupSys () ;
+
+// Initialise the piGlow devLib
+
+  piGlowSetup (FALSE) ;
+
+  if (argc == 1)
+    failUsage () ;
+
+  if ((argc == 2) && (strcasecmp (argv [1], "off") == 0))
+  {
+    for (leg = 0 ; leg < 3 ; ++leg)
+      piGlowLeg (leg, 0) ;
+    return 0 ;
+  }
+
+  if (argc == 3)
+  {
+    percent = getPercent (argv [2]) ;
+
+    /**/ if (strcasecmp (argv [1], "red") == 0)
+      piGlowRing (PIGLOW_RED, percent) ;
+    else if (strcasecmp (argv [1], "yellow") == 0)
+      piGlowRing (PIGLOW_YELLOW, percent) ;
+    else if (strcasecmp (argv [1], "orange") == 0)
+      piGlowRing (PIGLOW_ORANGE, percent) ;
+    else if (strcasecmp (argv [1], "green") == 0)
+      piGlowRing (PIGLOW_GREEN, percent) ;
+    else if (strcasecmp (argv [1], "blue") == 0)
+      piGlowRing (PIGLOW_BLUE, percent) ;
+    else if (strcasecmp (argv [1], "white") == 0)
+      piGlowRing (PIGLOW_WHITE, percent) ;
+    else if (strcasecmp (argv [1], "all") == 0)
+      for (ring = 0 ; ring < 6 ; ++ring)
+	piGlowRing (ring, percent) ;
+    else
+    {
+      fprintf (stderr, "piglow: invalid colour\n") ;
+      exit (EXIT_FAILURE) ;
+    }
+    return 0 ;
+  }
+
+  if (argc == 4)
+  {
+    /**/ if (strcasecmp (argv [1], "leg") == 0)
+    {
+      leg = atoi (argv [2]) ;
+      if ((leg < 0) || (leg > 2))
+      {
+	fprintf (stderr, "piglow: leg value out of range\n") ;
+	exit (EXIT_FAILURE) ;
+      }
+      percent = getPercent (argv [3]) ;
+      piGlowLeg (leg, percent) ;
+    }
+    else if (strcasecmp (argv [1], "ring") == 0)
+    {
+      ring = atoi (argv [2]) ;
+      if ((ring < 0) || (ring > 5))
+      {
+	fprintf (stderr, "piglow: ring value out of range\n") ;
+	exit (EXIT_FAILURE) ;
+      }
+      percent = getPercent (argv [3]) ;
+      piGlowRing (ring, percent) ;
+    }
+    return 0 ;
+  }
+
+  if (argc == 5)
+  {
+    if (strcasecmp (argv [1], "led") != 0)
+      failUsage () ;
+
+    leg = atoi (argv [2]) ;
+    if ((leg < 0) || (leg > 2))
+    {
+      fprintf (stderr, "piglow: leg value out of range\n") ;
+      exit (EXIT_FAILURE) ;
+    }
+    ring = atoi (argv [3]) ;
+    if ((ring < 0) || (ring > 5))
+    {
+      fprintf (stderr, "piglow: ring value out of range\n") ;
+      exit (EXIT_FAILURE) ;
+    }
+    percent = getPercent (argv [4]) ;
+    piGlow1 (leg, ring, percent) ;
+    return 0 ;
+  }
+
+  failUsage () ;
+  return 0 ; 
+}
+
+

examples/blink.c

@@ -34,16 +34,14 @@ int main (void)
 {
   printf ("Raspberry Pi blink\n") ;
 
-  if (wiringPiSetup () == -1)
-    return 1 ;
-
+  wiringPiSetup () ;
   pinMode (LED, OUTPUT) ;
 
   for (;;)
   {
-    digitalWrite (LED, 1) ;	// On
+    digitalWrite (LED, HIGH) ;	// On
     delay (500) ;		// mS
-    digitalWrite (LED, 0) ;	// Off
+    digitalWrite (LED, LOW) ;	// Off
     delay (500) ;
   }
   return 0 ;

examples/blink.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/sh -e
 #
 # blink.sh:
 #	Standard "blink" program in wiringPi. Blinks an LED connected
@@ -25,7 +25,7 @@
 
 # LED Pin - wiringPi pin 0 is BCM_GPIO 17.
 
-LED=0
+PIN=0
 
 gpio mode $PIN out
 

examples/blink12.c

@@ -0,0 +1,111 @@
+/*
+ * blink12.c:
+ *	Simple sequence over the first 12 GPIO pins - LEDs
+ *	Aimed at the Gertboard, but it's fairly generic.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+
+// Simple sequencer data
+//	Triplets of LED, On/Off and delay
+
+int data [] =
+{
+            0, 1, 1,
+            1, 1, 1,
+  0, 0, 0,  2, 1, 1,
+  1, 0, 0,  3, 1, 1,
+  2, 0, 0,  4, 1, 1,
+  3, 0, 0,  5, 1, 1,
+  4, 0, 0,  6, 1, 1,
+  5, 0, 0,  7, 1, 1,
+  6, 0, 0, 11, 1, 1,
+  7, 0, 0, 10, 1, 1,
+ 11, 0, 0, 13, 1, 1,
+ 10, 0, 0, 12, 1, 1,
+ 13, 0, 1,
+ 12, 0, 1,
+
+  0, 0, 1,	// Extra delay
+
+// Back again
+
+           12, 1, 1,
+           13, 1, 1,
+ 12, 0, 0, 10, 1, 1,
+ 13, 0, 0, 11, 1, 1,
+ 10, 0, 0,  7, 1, 1,
+ 11, 0, 0,  6, 1, 1,
+  7, 0, 0,  5, 1, 1,
+  6, 0, 0,  4, 1, 1,
+  5, 0, 0,  3, 1, 1,
+  4, 0, 0,  2, 1, 1,
+  3, 0, 0,  1, 1, 1,
+  2, 0, 0,  0, 1, 1,
+  1, 0, 1,
+  0, 0, 1,
+
+  0, 0, 1,	// Extra delay
+
+  0, 9, 0,	// End marker
+
+} ;
+
+
+int main (void)
+{
+  int pin ;
+  int dataPtr ;
+  int l, s, d ;
+
+  printf ("Raspberry Pi - 12-LED Sequence\n") ;
+  printf ("==============================\n") ;
+  printf ("\n") ;
+  printf ("Connect LEDs up to the first 8 GPIO pins, then pins 11, 10, 13, 12 in\n") ;
+  printf ("    that order, then sit back and watch the show!\n") ;
+
+  wiringPiSetup () ;
+
+  for (pin = 0 ; pin < 14 ; ++pin)
+    pinMode (pin, OUTPUT) ;
+
+  dataPtr = 0 ;
+
+  for (;;)
+  {
+    l = data [dataPtr++] ;	// LED
+    s = data [dataPtr++] ;	// State
+    d = data [dataPtr++] ;	// Duration (10ths)
+
+    if (s == 9)			// 9 -> End Marker
+    {
+      dataPtr = 0 ;
+      continue ;
+    }
+
+    digitalWrite (l, s) ;
+    delay        (d * 100) ;
+  }
+
+  return 0 ;
+}

examples/blink12drcs.c

@@ -0,0 +1,125 @@
+/*
+ * blink12drcs.c:
+ *	Simple sequence over the first 12 GPIO pins - LEDs
+ *	Aimed at the Gertboard, but it's fairly generic.
+ *	This version uses DRC totalk to the ATmega on the Gertboard
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+#include <drcSerial.h>
+
+#define	GERT_BASE	100
+
+static int pinMap [] =
+{
+  0, 1, 2, 3,		// Pi Native
+  GERT_BASE + 2, GERT_BASE + 3, GERT_BASE + 4, GERT_BASE + 5,
+  GERT_BASE + 6, GERT_BASE + 7, GERT_BASE + 8, GERT_BASE + 9,
+} ;
+
+// Simple sequencer data
+//	Triplets of LED, On/Off and delay
+
+
+int data [] =
+{
+               0, 1, 1,
+               1, 1, 1,
+   0, 0, 0,    2, 1, 1,
+   1, 0, 0,    3, 1, 1,
+   2, 0, 0,    4, 1, 1,
+   3, 0, 0,    5, 1, 1,
+   4, 0, 0,    6, 1, 1,
+   5, 0, 0,    7, 1, 1,
+   6, 0, 0,    8, 1, 1,
+   7, 0, 0,    9, 1, 1,
+   8, 0, 0,   10, 1, 1,
+   9, 0, 0,   11, 1, 1,
+  10, 0, 1,
+  11, 0, 1,
+
+  0, 0, 1,	// Extra delay
+
+// Back again
+
+              11, 1, 1,
+              10, 1, 1,
+  11, 0, 0,    9, 1, 1,
+  10, 0, 0,    8, 1, 1,
+   9, 0, 0,    7, 1, 1,
+   8, 0, 0,    6, 1, 1,
+   7, 0, 0,    5, 1, 1,
+   6, 0, 0,    4, 1, 1,
+   5, 0, 0,    3, 1, 1,
+   4, 0, 0,    2, 1, 1,
+   3, 0, 0,    1, 1, 1,
+   2, 0, 0,    0, 1, 1,
+   1, 0, 1,
+   0, 0, 1,
+
+   0, 0, 1,	// Extra delay
+
+   0, 9, 0,	// End marker
+
+} ;
+
+
+int main (void)
+{
+  int pin ;
+  int dataPtr ;
+  int l, s, d ;
+
+  printf ("Raspberry Pi - 12-LED Sequence\n") ;
+  printf ("==============================\n") ;
+  printf ("\n") ;
+  printf ("Connect LEDs up to the first 4 Pi pins and 8 pins on the ATmega\n") ;
+  printf ("    from PD2 through PB1 in that order,\n") ;
+  printf ("  then sit back and watch the show!\n") ;
+
+  wiringPiSetup  () ;
+  drcSetupSerial (GERT_BASE, 20, "/dev/ttyAMA0", 115200) ;
+
+  for (pin = 0 ; pin < 12 ; ++pin)
+    pinMode (pinMap [pin], OUTPUT) ;
+
+  dataPtr = 0 ;
+
+  for (;;)
+  {
+    l = data [dataPtr++] ;	// LED
+    s = data [dataPtr++] ;	// State
+    d = data [dataPtr++] ;	// Duration (10ths)
+
+    if (s == 9)			// 9 -> End Marker
+    {
+      dataPtr = 0 ;
+      continue ;
+    }
+
+    digitalWrite (pinMap [l], s) ;
+    delay        (d * analogRead (GERT_BASE) / 4) ;
+  }
+
+  return 0 ;
+}

examples/blink6drcs.c

@@ -0,0 +1,115 @@
+/*
+ * blink6drcs.c:
+ *	Simple sequence over 6 pins on a remote DRC board.
+ *	Aimed at the Gertduino, but it's fairly generic.
+ *	This version uses DRC to talk to the ATmega on the Gertduino
+ *
+ * Copyright (c) 2012-2014 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+#include <drcSerial.h>
+
+#define	GERT_BASE	100
+
+static int pinMap [] =
+{
+  GERT_BASE + 6, GERT_BASE + 5, GERT_BASE + 3, GERT_BASE + 10, GERT_BASE + 9, GERT_BASE + 13,
+} ;
+
+// Simple sequencer data
+//	Triplets of LED, On/Off and delay
+
+
+int data [] =
+{
+               0, 1, 1,
+               1, 1, 1,
+   0, 0, 0,    2, 1, 1,
+   1, 0, 0,    3, 1, 1,
+   2, 0, 0,    4, 1, 1,
+   3, 0, 0,    5, 1, 1,
+   4, 0, 1,
+   5, 0, 1,
+
+   0, 0, 1,	// Extra delay
+
+// Back again
+
+               5, 1, 1,
+               4, 1, 1,
+   5, 0, 0,    3, 1, 1,
+   4, 0, 0,    2, 1, 1,
+   3, 0, 0,    1, 1, 1,
+   2, 0, 0,    0, 1, 1,
+   1, 0, 1,
+   0, 0, 1,
+
+   0, 0, 1,	// Extra delay
+
+   0, 9, 0,	// End marker
+
+} ;
+
+
+int main (void)
+{
+  int pin ;
+  int dataPtr ;
+  int l, s, d ;
+
+  printf ("Raspberry Pi - 6-LED Sequence\n") ;
+  printf ("=============================\n") ;
+  printf ("\n") ;
+  printf ("  Use the 2 buttons to temporarily speed up the sequence\n") ;
+
+  wiringPiSetupSys  () ;	// Not using the Pi's GPIO here
+  drcSetupSerial (GERT_BASE, 20, "/dev/ttyAMA0", 115200) ;
+
+  for (pin = 0 ; pin < 6 ; ++pin)
+    pinMode (pinMap [pin], OUTPUT) ;
+
+  pinMode (GERT_BASE + 16, INPUT) ;	// Buttons
+  pinMode (GERT_BASE + 17, INPUT) ;
+
+  pullUpDnControl (GERT_BASE + 16, PUD_UP) ;
+  pullUpDnControl (GERT_BASE + 17, PUD_UP) ;
+
+  dataPtr = 0 ;
+
+  for (;;)
+  {
+    l = data [dataPtr++] ;	// LED
+    s = data [dataPtr++] ;	// State
+    d = data [dataPtr++] ;	// Duration (10ths)
+
+    if (s == 9)			// 9 -> End Marker
+    {
+      dataPtr = 0 ;
+      continue ;
+    }
+
+    digitalWrite (pinMap [l], s) ;
+    delay        (d * digitalRead (GERT_BASE + 16) * 15 + digitalRead (GERT_BASE + 17) * 20) ;
+  }
+
+  return 0 ;
+}

examples/blink8.c

@@ -0,0 +1,57 @@
+/*
+ * blink8.c:
+ *	Simple sequence over the first 8 GPIO pins - LEDs
+ *	Aimed at the Gertboard, but it's fairly generic.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+
+int main (void)
+{
+  int i, led ;
+
+  printf ("Raspberry Pi - 8-LED Sequencer\n") ;
+  printf ("==============================\n") ;
+  printf ("\n") ;
+  printf ("Connect LEDs to the first 8 GPIO pins and watch ...\n") ;
+
+  wiringPiSetup () ;
+
+  for (i = 0 ; i < 8 ; ++i)
+    pinMode (i, OUTPUT) ;
+
+  for (;;)
+  {
+    for (led = 0 ; led < 8 ; ++led)
+    {
+      digitalWrite (led, 1) ;
+      delay (100) ;
+    }
+
+    for (led = 0 ; led < 8 ; ++led)
+    {
+      digitalWrite (led, 0) ;
+      delay (100) ;
+    }
+  }
+}

examples/clock.c

@@ -0,0 +1,201 @@
+/*
+ * clock.c:
+ *	Demo of the 128x64 graphics based LCD driver.
+ *	This is designed to drive the parallel interface LCD drivers
+ *	based on the popular 12864H controller chip.
+ *
+ *	This test program assumes the following:
+ *		(Which is currently hard-wired into the driver)
+ *
+ *	GPIO 0-7 is connected to display data pins 0-7.
+ *	GPIO 10 is CS1
+ *	GPIO 11 is CS2
+ *	GPIO 12 is STROBE
+ *	GPIO 10 is RS
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+#include <math.h>
+
+#include <wiringPi.h>
+#include <lcd128x64.h>
+
+#ifndef	TRUE
+#  define	TRUE	(1==1)
+#  define	FALSE	(1==2)
+#endif
+
+double clockRadius ;
+double thickness, barLen ;
+int maxX, maxY ;
+
+double rads (double degs)
+{
+  return degs * M_PI / 180.0 ;
+}
+
+void drawClockHands (void)
+{
+  time_t t ;
+  struct tm *now ;
+  double angle, p, x0, y0, x1, y1 ;
+  int h24, h, m, s ;
+  char text [20] ;
+
+  time (&t) ;
+  now = localtime (&t) ;
+
+  h24 = now->tm_hour ;
+  m   = now->tm_min ;
+  s   = now->tm_sec ;
+
+  h = h24 ;
+  if (h > 12)
+    h -= 12 ;
+
+// Hour hand
+
+  angle = h * 30 + m * 0.5 ;
+  x0 = sin (rads (angle)) * (clockRadius * 0.75) ;
+  y0 = cos (rads (angle)) * (clockRadius * 0.75) ;
+  for (p = -3.0 ; p <= 3.0 ; p += 0.2)
+  {
+    x1 = sin (rads (angle + p)) * (clockRadius * 0.7) ;
+    y1 = cos (rads (angle + p)) * (clockRadius * 0.7) ;
+    lcd128x64line (0, 0, x1, y1, 1) ;
+    lcd128x64lineTo (x0, y0, 1) ;
+  }
+
+// Minute hand
+
+  angle = m * 6 ;
+  x0 = sin (rads (angle)) * (clockRadius * 0.9) ;
+  y0 = cos (rads (angle)) * (clockRadius * 0.9) ;
+  for (p = -1.0 ; p <= 1.0 ; p += 0.2)
+  {
+    x1 = sin (rads (angle + p)) * (clockRadius * 0.85) ;
+    y1 = cos (rads (angle + p)) * (clockRadius * 0.85) ;
+    lcd128x64line (0, 0, x1, y1, 1) ;
+    lcd128x64lineTo (x0, y0, 1) ;
+  }
+
+// Second hand
+
+  angle = s * 6 ;
+  x0 = sin (rads (angle)) * (clockRadius * 0.2) ;
+  y0 = cos (rads (angle)) * (clockRadius * 0.2) ;
+  x1 = sin (rads (angle)) * (clockRadius * 0.95) ;
+  y1 = cos (rads (angle)) * (clockRadius * 0.95) ;
+  lcd128x64line (0 - x0, 0 - y0, x1, y1, 1) ;
+  lcd128x64circle (0, 0, clockRadius * 0.1,  0, 1) ;
+  lcd128x64circle (0, 0, clockRadius * 0.05, 1, 1) ;
+
+// Text:
+
+  sprintf (text, "%02d:%02d:%02d", h24, m, s) ;
+  lcd128x64puts (32, 24, text, 0, 1) ;
+
+  sprintf (text, "%2d/%2d/%2d", now->tm_mday, now->tm_mon + 1, now->tm_year - 100) ;
+  lcd128x64puts (32, -23, text, 0, 1) ;
+}
+
+void drawClockFace (void)
+{
+  int m ;
+  double d, px1, py1, px2, py2 ;
+
+  lcd128x64clear (0) ;
+  lcd128x64circle (0,0, clockRadius, 1, TRUE) ;
+  lcd128x64circle (0,0, clockRadius - thickness, 0, TRUE) ;
+
+// The four big indicators for 12,15,30 and 45
+
+  lcd128x64rectangle (- 3,  clockRadius - barLen, 3,  clockRadius,     1, TRUE) ;	// 12
+  lcd128x64rectangle (clockRadius - barLen, 3,  clockRadius, -3, 1, TRUE) ;	// 3
+  lcd128x64rectangle (- 3, -clockRadius + barLen, 3, -clockRadius, 1, TRUE) ;	// 6
+  lcd128x64rectangle (-clockRadius + barLen, 3, -clockRadius, -3, 1, TRUE) ;	// 9
+
+
+// Smaller 5 and 1 minute ticks
+
+  for (m = 0 ; m < 60 ; ++m)
+  {
+    px1 = sin (rads (m * 6)) * clockRadius ;
+    py1 = cos (rads (m * 6)) * clockRadius ;
+    if ((m % 5) == 0)
+      d = barLen ;
+    else 
+      d = barLen / 2.0 ;
+
+    px2 = sin (rads (m * 6)) * (clockRadius - d) ;
+    py2 = cos (rads (m * 6)) * (clockRadius - d) ;
+    lcd128x64line (px1, py1, px2, py2, 1) ;
+  }
+}
+
+void setup (void)
+{
+  lcd128x64getScreenSize (&maxX, &maxY) ;
+  clockRadius = maxY / 2 - 1 ;
+  thickness = maxX / 48 ;
+  barLen = thickness * 4 ;
+  lcd128x64setOrigin (32, 32) ;
+}
+
+
+
+
+/*
+ ***********************************************************************
+ * The main program
+ ***********************************************************************
+ */
+
+int main (int argc, char *argv [])
+{
+  time_t now ;
+
+  wiringPiSetup () ;
+
+  lcd128x64setup () ;
+
+  setup () ;
+  for (;;)
+  {
+    drawClockFace  () ;
+    drawClockHands () ;
+    lcd128x64update () ;
+
+    now = time (NULL) ;
+    while (time (NULL) == now)
+      delay (10) ;
+  }
+  
+
+  return 0 ;
+}

examples/ds1302.c

@@ -0,0 +1,238 @@
+/*
+ * ds1302.c:
+ *	Real Time clock
+ *
+ * Copyright (c) 2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <time.h>
+
+#include <wiringPi.h>
+#include <ds1302.h>
+
+// Register defines
+
+#define	RTC_SECS	 0
+#define	RTC_MINS	 1
+#define	RTC_HOURS	 2
+#define	RTC_DATE	 3
+#define	RTC_MONTH	 4
+#define	RTC_DAY		 5
+#define	RTC_YEAR	 6
+#define	RTC_WP		 7
+#define	RTC_TC		 8
+#define	RTC_BM		31
+
+
+static unsigned int masks [] = { 0x7F, 0x7F, 0x3F, 0x3F, 0x1F, 0x07, 0xFF } ;
+
+
+/*
+ * bcdToD: dToBCD:
+ *	BCD decode/encode
+ *********************************************************************************
+ */
+
+static int bcdToD (unsigned int byte, unsigned int mask)
+{
+  unsigned int b1, b2 ;
+  byte &= mask ;
+  b1 = byte & 0x0F ;
+  b2 = ((byte >> 4) & 0x0F) * 10 ;
+  return b1 + b2 ;
+}
+
+static unsigned int dToBcd (unsigned int byte)
+{
+  return ((byte / 10) << 4) + (byte % 10) ;
+}
+
+
+/*
+ * ramTest:
+ *	Simple test of the 31 bytes of RAM inside the DS1302 chip
+ *********************************************************************************
+ */
+
+static int ramTestValues [] =
+  { 0x00, 0xFF, 0xAA, 0x55, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0xF0, 0x0F, -1 } ;
+
+static int ramTest (void)
+{
+  int addr ;
+  int got ;
+  int i = 0 ;
+  int errors = 0 ;
+  int testVal ;
+
+  printf ("DS1302 RAM TEST\n") ;
+
+  testVal = ramTestValues [i] ;
+
+  while (testVal != -1)
+  {
+    for (addr = 0 ; addr < 31 ; ++addr)
+      ds1302ramWrite (addr, testVal) ;
+
+    for (addr = 0 ; addr < 31 ; ++addr)
+      if ((got = ds1302ramRead (addr)) != testVal)
+      {
+	printf ("DS1302 RAM Failure: Address: %2d, Expected: 0x%02X, Got: 0x%02X\n",
+		addr, testVal, got) ;
+	++errors ;
+      }
+    testVal = ramTestValues [++i] ;
+  }
+
+  for (addr = 0 ; addr < 31 ; ++addr)
+    ds1302ramWrite (addr, addr) ;
+
+  for (addr = 0 ; addr < 31 ; ++addr)
+    if ((got = ds1302ramRead (addr)) != addr)
+    {
+      printf ("DS1302 RAM Failure: Address: %2d, Expected: 0x%02X, Got: 0x%02X\n",
+	      addr, addr, got) ;
+      ++errors ;
+    }
+
+  if (errors == 0)
+    printf ("-- DS1302 RAM TEST: OK\n") ;
+  else
+    printf ("-- DS1302 RAM TEST FAILURE. %d errors.\n", errors) ;
+
+  return 0 ;
+}
+
+/*
+ * setLinuxClock:
+ *	Set the Linux clock from the hardware
+ *********************************************************************************
+ */
+
+static int setLinuxClock (void)
+{
+  char dateTime [20] ;
+  char command [64] ;
+  int  clock [8] ;
+
+
+  printf ("Setting the Linux Clock from the DS1302... ") ; fflush (stdout) ;
+
+  ds1302clockRead (clock) ;
+
+// [MMDDhhmm[[CC]YY][.ss]]
+
+  sprintf (dateTime, "%02d%02d%02d%02d%02d%02d.%02d",
+	bcdToD (clock [RTC_MONTH], masks [RTC_MONTH]),
+	bcdToD (clock [RTC_DATE],  masks [RTC_DATE]),
+	bcdToD (clock [RTC_HOURS], masks [RTC_HOURS]),
+	bcdToD (clock [RTC_MINS],  masks [RTC_MINS]),
+	20,
+	bcdToD (clock [RTC_YEAR],  masks [RTC_YEAR]),
+	bcdToD (clock [RTC_SECS],  masks [RTC_SECS])) ;
+
+  sprintf (command, "/bin/date %s", dateTime) ;
+  system (command) ;
+
+  return 0 ;
+}
+
+
+/*
+ * setDSclock:
+ *	Set the DS1302 block from Linux time
+ *********************************************************************************
+ */
+
+static int setDSclock (void)
+{
+  struct tm t ;
+  time_t now ;
+  int clock [8] ;
+
+  printf ("Setting the clock in the DS1302 from Linux time... ") ;
+
+  now = time (NULL) ;
+  gmtime_r (&now, &t) ;
+
+  clock [ 0] = dToBcd (t.tm_sec) ;	// seconds
+  clock [ 1] = dToBcd (t.tm_min) ;	// mins
+  clock [ 2] = dToBcd (t.tm_hour) ;	// hours
+  clock [ 3] = dToBcd (t.tm_mday) ;	// date
+  clock [ 4] = dToBcd (t.tm_mon + 1) ;	// months 0-11 --> 1-12
+  clock [ 5] = dToBcd (t.tm_wday + 1) ;	// weekdays (sun 0)
+  clock [ 6] = dToBcd (t.tm_year - 100) ;       // years
+  clock [ 7] = 0 ;			// W-Protect off
+
+  ds1302clockWrite (clock) ;
+
+  printf ("OK\n") ;
+
+  return 0 ;
+}
+
+
+
+
+int main (int argc, char *argv [])
+{
+  int i ;
+  int clock [8] ;
+
+  wiringPiSetup () ;
+  ds1302setup   (0, 1, 2) ;
+
+  if (argc == 2)
+  {
+    /**/ if (strcmp (argv [1], "-slc") == 0)
+      return setLinuxClock () ;
+    else if (strcmp (argv [1], "-sdsc") == 0)
+      return setDSclock () ;
+    else if (strcmp (argv [1], "-rtest") == 0)
+      return ramTest () ;
+    else
+    {
+      printf ("Usage: ds1302 [-slc | -sdsc | -rtest]\n") ;
+      return EXIT_FAILURE ;
+    }
+  }
+
+  for (i = 0 ;; ++i)
+  {
+    printf ("%5d:  ", i) ;
+
+    ds1302clockRead (clock) ;
+    printf (" %2d:%02d:%02d",
+	bcdToD (clock [2], masks [2]), bcdToD (clock [1], masks [1]), bcdToD (clock [0], masks [0])) ;
+
+    printf (" %2d/%02d/%04d",
+	bcdToD (clock [3], masks [3]), bcdToD (clock [4], masks [4]), bcdToD (clock [6], masks [6]) + 2000) ;
+      
+    printf ("\n") ;
+
+    delay (200) ;
+  }
+ 
+  return 0 ;
+}

examples/isr.c

@@ -38,16 +38,11 @@
 #include <wiringPi.h>
 
 
-// What GPIO input are we using?
-//	This is a wiringPi pin number
-
-#define	BUTTON_PIN	0
-
 // globalCounter:
 //	Global variable to count interrupts
 //	Should be declared volatile to make sure the compiler doesn't cache it.
 
-static volatile int globalCounter = 0 ;
+static volatile int globalCounter [8] ;
 
 
 /*
@@ -55,10 +50,14 @@ static volatile int globalCounter = 0 ;
  *********************************************************************************
  */
 
-void myInterrupt (void)
-{
-  ++globalCounter ;
-}
+void myInterrupt0 (void) { ++globalCounter [0] ; }
+void myInterrupt1 (void) { ++globalCounter [1] ; }
+void myInterrupt2 (void) { ++globalCounter [2] ; }
+void myInterrupt3 (void) { ++globalCounter [3] ; }
+void myInterrupt4 (void) { ++globalCounter [4] ; }
+void myInterrupt5 (void) { ++globalCounter [5] ; }
+void myInterrupt6 (void) { ++globalCounter [6] ; }
+void myInterrupt7 (void) { ++globalCounter [7] ; }
 
 
 /*
@@ -69,30 +68,42 @@ void myInterrupt (void)
 
 int main (void)
 {
-  int myCounter = 0 ;
+  int gotOne, pin ;
+  int myCounter [8] ;
 
-  if (wiringPiSetup () < 0)
-  {
-    fprintf (stderr, "Unable to setup wiringPi: %s\n", strerror (errno)) ;
-    return 1 ;
-  }
+  for (pin = 0 ; pin < 8 ; ++pin) 
+    globalCounter [pin] = myCounter [pin] = 0 ;
 
-  if (wiringPiISR (BUTTON_PIN, INT_EDGE_FALLING, &myInterrupt) < 0)
-  {
-    fprintf (stderr, "Unable to setup ISR: %s\n", strerror (errno)) ;
-    return 1 ;
-  }
+  wiringPiSetup () ;
 
+  wiringPiISR (0, INT_EDGE_FALLING, &myInterrupt0) ;
+  wiringPiISR (1, INT_EDGE_FALLING, &myInterrupt1) ;
+  wiringPiISR (2, INT_EDGE_FALLING, &myInterrupt2) ;
+  wiringPiISR (3, INT_EDGE_FALLING, &myInterrupt3) ;
+  wiringPiISR (4, INT_EDGE_FALLING, &myInterrupt4) ;
+  wiringPiISR (5, INT_EDGE_FALLING, &myInterrupt5) ;
+  wiringPiISR (6, INT_EDGE_FALLING, &myInterrupt6) ;
+  wiringPiISR (7, INT_EDGE_FALLING, &myInterrupt7) ;
 
   for (;;)
   {
+    gotOne = 0 ;
     printf ("Waiting ... ") ; fflush (stdout) ;
 
-    while (myCounter == globalCounter)
-      delay (100) ;
-
-    printf (" Done. counter: %5d\n", globalCounter) ;
-    myCounter = globalCounter ;
+    for (;;)
+    {
+      for (pin = 0 ; pin < 8 ; ++pin)
+      {
+	if (globalCounter [pin] != myCounter [pin])
+	{
+	  printf (" Int on pin %d: Counter: %5d\n", pin, globalCounter [pin]) ;
+	  myCounter [pin] = globalCounter [pin] ;
+	  ++gotOne ;
+	}
+      }
+      if (gotOne != 0)
+	break ;
+    }
   }
 
   return 0 ;

examples/lcd-adafruit.c

@@ -0,0 +1,347 @@
+/*
+ * lcd-adafruit.c:
+ *	Text-based LCD driver test code
+ *	This is designed to drive the Adafruit RGB LCD Plate
+ *	with the additional 5 buttons for the Raspberry Pi
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+
+#include <wiringPi.h>
+#include <mcp23017.h>
+#include <lcd.h>
+
+#ifndef	TRUE
+#  define	TRUE	(1==1)
+#  define	FALSE	(1==2)
+#endif
+
+
+// Defines for the Adafruit Pi LCD interface board
+
+#define	AF_BASE		100
+#define	AF_RED		(AF_BASE + 6)
+#define	AF_GREEN	(AF_BASE + 7)
+#define	AF_BLUE		(AF_BASE + 8)
+
+#define	AF_E		(AF_BASE + 13)
+#define	AF_RW		(AF_BASE + 14)
+#define	AF_RS		(AF_BASE + 15)
+
+#define	AF_DB4		(AF_BASE + 12)
+#define	AF_DB5		(AF_BASE + 11)
+#define	AF_DB6		(AF_BASE + 10)
+#define	AF_DB7		(AF_BASE +  9)
+
+#define	AF_SELECT	(AF_BASE +  0)
+#define	AF_RIGHT	(AF_BASE +  1)
+#define	AF_DOWN		(AF_BASE +  2)
+#define	AF_UP		(AF_BASE +  3)
+#define	AF_LEFT		(AF_BASE +  4)
+
+
+// User-Defined character test
+
+static unsigned char newChar [8] = 
+{
+  0b00100,
+  0b00100,
+  0b00000,
+  0b00100,
+  0b01110,
+  0b11011,
+  0b11011,
+  0b10001,
+} ;
+
+// Global lcd handle:
+
+static int lcdHandle ;
+
+/*
+ * usage:
+ *********************************************************************************
+ */
+
+int usage (const char *progName)
+{
+  fprintf (stderr, "Usage: %s colour\n", progName) ;
+  return EXIT_FAILURE ;
+}
+
+
+/*
+ * scrollMessage:
+ *********************************************************************************
+ */
+
+static const char *message =
+  "                    "
+  "Wiring Pi by Gordon Henderson. HTTP://WIRINGPI.COM/"
+  "                    " ;
+
+void scrollMessage (int line, int width)
+{
+  char buf [32] ;
+  static int position = 0 ;
+  static int timer = 0 ;
+
+  if (millis () < timer)
+    return ;
+
+  timer = millis () + 200 ;
+
+  strncpy (buf, &message [position], width) ;
+  buf [width] = 0 ;
+  lcdPosition (lcdHandle, 0, line) ;
+  lcdPuts (lcdHandle, buf) ;
+
+  if (++position == (strlen (message) - width))
+    position = 0 ;
+}
+
+
+/*
+ * setBacklightColour:
+ *	The colour outputs are inverted.
+ *********************************************************************************
+ */
+
+static void setBacklightColour (int colour)
+{
+  colour &= 7 ;
+
+  digitalWrite (AF_RED,   !(colour & 1)) ;
+  digitalWrite (AF_GREEN, !(colour & 2)) ;
+  digitalWrite (AF_BLUE,  !(colour & 4)) ;
+}
+
+
+/*
+ * adafruitLCDSetup:
+ *	Setup the Adafruit board by making sure the additional pins are
+ *	set to the correct modes, etc.
+ *********************************************************************************
+ */
+
+static void adafruitLCDSetup (int colour)
+{
+  int i ;
+
+//	Backlight LEDs
+
+  pinMode (AF_RED,   OUTPUT) ;
+  pinMode (AF_GREEN, OUTPUT) ;
+  pinMode (AF_BLUE,  OUTPUT) ;
+  setBacklightColour (colour) ;
+
+//	Input buttons
+
+  for (i = 0 ; i <= 4 ; ++i)
+  {
+    pinMode (AF_BASE + i, INPUT) ;
+    pullUpDnControl (AF_BASE + i, PUD_UP) ;	// Enable pull-ups, switches close to 0v
+  }
+
+// Control signals
+
+  pinMode (AF_RW, OUTPUT) ; digitalWrite (AF_RW, LOW) ;	// Not used with wiringPi - always in write mode
+
+// The other control pins are initialised with lcdInit ()
+
+  lcdHandle = lcdInit (2, 16, 4, AF_RS, AF_E, AF_DB4,AF_DB5,AF_DB6,AF_DB7, 0,0,0,0) ;
+
+  if (lcdHandle < 0)
+  {
+    fprintf (stderr, "lcdInit failed\n") ;
+    exit (EXIT_FAILURE) ;
+  }
+}
+
+
+/*
+ * waitForEnter:
+ *	On the Adafruit display, wait for the select button
+ *********************************************************************************
+ */
+
+static void waitForEnter (void)
+{
+  printf ("Press SELECT to continue: ") ; fflush (stdout) ;
+
+  while (digitalRead (AF_SELECT) == HIGH)	// Wait for push
+    delay (1) ;
+
+  while (digitalRead (AF_SELECT) == LOW)	// Wait for release
+    delay (1) ;
+
+  printf ("OK\n") ;
+}
+
+
+/*
+ * speedTest:
+ *	Test the update speed of the display
+ *********************************************************************************
+ */
+
+static void speedTest (void)
+{
+  unsigned int start, end, taken ;
+  int times ;
+
+  lcdClear (lcdHandle) ;
+  start = millis () ;
+  for (times = 0 ; times < 10 ; ++times)
+  {
+    lcdPuts (lcdHandle, "0123456789ABCDEF") ;
+    lcdPuts (lcdHandle, "0123456789ABCDEF") ;
+  }
+  end   = millis () ;
+  taken = (end - start) / 10;
+
+  lcdClear (lcdHandle) ;
+  lcdPosition (lcdHandle, 0, 0) ; lcdPrintf (lcdHandle, "Speed: %dmS", taken) ;
+  lcdPosition (lcdHandle, 0, 1) ; lcdPrintf (lcdHandle, "For full update") ;
+
+  waitForEnter () ;
+
+  lcdClear (lcdHandle) ;
+  lcdPosition (lcdHandle, 0, 0) ; lcdPrintf (lcdHandle, "Time: %dmS", taken / 32) ;
+  lcdPosition (lcdHandle, 0, 1) ; lcdPrintf (lcdHandle, "Per character") ;
+
+  waitForEnter () ;
+
+  lcdClear (lcdHandle) ;
+  lcdPosition (lcdHandle, 0, 0) ; lcdPrintf (lcdHandle, "%d cps...", 32000 / taken) ;
+
+  waitForEnter () ;
+}
+
+
+/*
+ * The works
+ *********************************************************************************
+ */
+
+int main (int argc, char *argv[])
+{
+  int colour ;
+  int cols = 16 ;
+  int waitForRelease = FALSE ;
+
+  struct tm *t ;
+  time_t tim ;
+
+  char buf [32] ;
+
+  if (argc != 2)
+    return usage (argv [0]) ;
+
+  printf ("Raspberry Pi Adafruit LCD test\n") ;
+  printf ("==============================\n") ;
+
+  colour = atoi (argv [1]) ;
+
+  wiringPiSetupSys () ;
+  mcp23017Setup (AF_BASE, 0x20) ;
+
+  adafruitLCDSetup (colour) ;
+
+  lcdPosition (lcdHandle, 0, 0) ; lcdPuts (lcdHandle, "Gordon Henderson") ;
+  lcdPosition (lcdHandle, 0, 1) ; lcdPuts (lcdHandle, "  wiringpi.com  ") ;
+
+  waitForEnter () ;
+
+  lcdPosition (lcdHandle, 0, 1) ; lcdPuts (lcdHandle, "Adafruit RGB LCD") ;
+
+  waitForEnter () ;
+
+  lcdCharDef  (lcdHandle, 2, newChar) ;
+
+  lcdClear    (lcdHandle) ;
+  lcdPosition (lcdHandle, 0, 0) ;
+  lcdPuts     (lcdHandle, "User Char: ") ;
+  lcdPutchar  (lcdHandle, 2) ;
+
+  lcdCursor      (lcdHandle, TRUE) ;
+  lcdCursorBlink (lcdHandle, TRUE) ;
+
+  waitForEnter () ;
+
+  lcdCursor      (lcdHandle, FALSE) ;
+  lcdCursorBlink (lcdHandle, FALSE) ;
+
+  speedTest () ;
+
+  lcdClear (lcdHandle) ;
+
+  for (;;)
+  {
+    scrollMessage (0, cols) ;
+    
+    tim = time (NULL) ;
+    t = localtime (&tim) ;
+
+    sprintf (buf, "%02d:%02d:%02d", t->tm_hour, t->tm_min, t->tm_sec) ;
+
+    lcdPosition (lcdHandle, (cols - 8) / 2, 1) ;
+    lcdPuts     (lcdHandle, buf) ;
+
+// Check buttons to cycle colour
+
+// If Up or Down are still pushed, then skip
+
+    if (waitForRelease)
+    {
+      if ((digitalRead (AF_UP) == LOW) || (digitalRead (AF_DOWN) == LOW))
+	continue ;
+      else
+	waitForRelease = FALSE ;
+    }
+
+    if (digitalRead (AF_UP) == LOW)	// Pushed
+    {
+      colour = colour + 1 ;
+      if (colour == 8)
+	colour = 0 ;
+      setBacklightColour (colour) ;
+      waitForRelease = TRUE ;
+    }
+
+    if (digitalRead (AF_DOWN) == LOW)	// Pushed
+    {
+      colour = colour - 1 ;
+      if (colour == -1)
+	colour = 7 ;
+      setBacklightColour (colour) ;
+      waitForRelease = TRUE ;
+    }
+
+  }
+
+  return 0 ;
+}

examples/lcd.c

@@ -4,7 +4,19 @@
  *	This is designed to drive the parallel interface LCD drivers
  *	based in the Hitachi HD44780U controller and compatables.
  *
- * Copyright (c) 2012 Gordon Henderson.
+ *	This test program assumes the following:
+ *
+ *	8-bit displays:
+ *		GPIO 0-7 is connected to display data pins 0-7.
+ *		GPIO 11 is the RS pin.
+ *		GPIO 10 is the Strobe/E pin.
+ *
+ *	For 4-bit interface:
+ *		GPIO 4-7 is connected to display data pins 4-7.
+ *		GPIO 11 is the RS pin.
+ *		GPIO 10 is the Strobe/E pin.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson.
  ***********************************************************************
  * This file is part of wiringPi:
  *	https://projects.drogon.net/raspberry-pi/wiringpi/
@@ -35,95 +47,240 @@
 #include <wiringPi.h>
 #include <lcd.h>
 
-int main (void)
+#ifndef	TRUE
+#  define	TRUE	(1==1)
+#  define	FALSE	(1==2)
+#endif
+
+static unsigned char newChar [8] = 
+{
+  0b11111,
+  0b10001,
+  0b10001,
+  0b10101,
+  0b11111,
+  0b10001,
+  0b10001,
+  0b11111,
+} ;
+
+
+// Global lcd handle:
+
+static int lcdHandle ;
+
+/*
+ * usage:
+ *********************************************************************************
+ */
+
+int usage (const char *progName)
+{
+  fprintf (stderr, "Usage: %s bits cols rows\n", progName) ;
+  return EXIT_FAILURE ;
+}
+
+
+/*
+ * scrollMessage:
+ *********************************************************************************
+ */
+
+static const char *message =
+  "                    "
+  "Wiring Pi by Gordon Henderson. HTTP://WIRINGPI.COM/"
+  "                    " ;
+
+void scrollMessage (int line, int width)
 {
-  int i, j ;
-  int fd1, fd2 ; 
+  char buf [32] ;
+  static int position = 0 ;
+  static int timer = 0 ;
 
-  char message1 [256] ;
-  char message2 [256] ;
-  char buf1 [30] ;
-  char buf2 [30] ;
+  if (millis () < timer)
+    return ;
+
+  timer = millis () + 200 ;
+
+  strncpy (buf, &message [position], width) ;
+  buf [width] = 0 ;
+  lcdPosition (lcdHandle, 0, line) ;
+  lcdPuts     (lcdHandle, buf) ;
+
+  if (++position == (strlen (message) - width))
+    position = 0 ;
+}
+
+
+/*
+ * pingPong:
+ *	Bounce a character - only on 4-line displays
+ *********************************************************************************
+ */
+
+static void pingPong (int lcd, int cols)
+{
+  static int position = 0 ;
+  static int dir      = 0 ;
+
+  if (dir == 0)		// Setup
+  {
+    dir = 1 ;
+    lcdPosition (lcdHandle, 0, 3) ;
+    lcdPutchar  (lcdHandle, '*') ;
+    return ;
+  }
+
+  lcdPosition (lcdHandle, position, 3) ;
+  lcdPutchar (lcdHandle, ' ') ;
+  position += dir ;
+
+  if (position == cols)
+  {
+    dir = -1 ;
+    --position ;
+  }
+  
+  if (position < 0)
+  {
+    dir = 1 ;
+    ++position ;
+  }
+
+  lcdPosition (lcdHandle, position, 3) ;
+  lcdPutchar  (lcdHandle, '#') ;
+}
+
+
+/*
+ * waitForEnter:
+ *********************************************************************************
+ */
+
+static void waitForEnter (void)
+{
+  printf ("Press ENTER to continue: ") ;
+  (void)fgetc (stdin) ;
+}
+
+
+/*
+ * The works
+ *********************************************************************************
+ */
+
+int main (int argc, char *argv[])
+{
+  int i ;
+  int lcd ;
+  int bits, rows, cols ;
 
   struct tm *t ;
   time_t tim ;
 
-  printf ("Raspberry Pi LCD test program\n") ;
+  char buf [32] ;
 
-  if (wiringPiSetup () == -1)
-    exit (1) ;
+  if (argc != 4)
+    return usage (argv [0]) ;
 
-  fd1 = lcdInit (4, 20, 4, 8,  9, 4,5,6,7,0,0,0,0) ;
-  fd2 = lcdInit (2, 16, 4, 8, 10, 4,5,6,7,0,0,0,0) ;
+  printf ("Raspberry Pi LCD test\n") ;
+  printf ("=====================\n") ;
 
-//fd1 = lcdInit (4, 20, 8, 8,  9, 0,1,2,3,4,5,6,7) ;
-//fd2 = lcdInit (2, 16, 8, 8, 10, 0,1,2,3,4,5,6,7) ;
+  bits = atoi (argv [1]) ;
+  cols = atoi (argv [2]) ;
+  rows = atoi (argv [3]) ;
 
-  if (fd1 == -1)
+  if (!((rows == 1) || (rows == 2) || (rows == 4)))
   {
-    printf ("lcdInit 1 failed\n") ;
-    return 1 ;
+    fprintf (stderr, "%s: rows must be 1, 2 or 4\n", argv [0]) ;
+    return EXIT_FAILURE ;
   }
 
-  if (fd2 == -1)
+  if (!((cols == 16) || (cols == 20)))
   {
-    printf ("lcdInit 2 failed\n") ;
-    return 1 ;
+    fprintf (stderr, "%s: cols must be 16 or 20\n", argv [0]) ;
+    return EXIT_FAILURE ;
   }
 
-  sleep (1) ;
+  wiringPiSetup () ;
 
-  lcdPosition (fd1, 0, 0) ; lcdPuts (fd1, " Gordon Henderson") ;
-  lcdPosition (fd1, 0, 1) ; lcdPuts (fd1, "  --------------") ;
-/*
-  lcdPosition (fd1, 0, 2) ; lcdPuts (fd1, "   00:00:00") ;
-  lcdPosition (fd1, 0, 3) ; lcdPuts (fd1, "   DD:MM:YY") ;
-*/
+  if (bits == 4)
+    lcdHandle = lcdInit (rows, cols, 4, 11,10, 4,5,6,7,0,0,0,0) ;
+  else
+    lcdHandle = lcdInit (rows, cols, 8, 11,10, 0,1,2,3,4,5,6,7) ;
 
-  lcdPosition (fd2, 0, 0) ; lcdPuts (fd2, "Gordon Henderson") ;
-  lcdPosition (fd2, 0, 1) ; lcdPuts (fd2, "----------------") ;
+  if (lcdHandle < 0)
+  {
+    fprintf (stderr, "%s: lcdInit failed\n", argv [0]) ;
+    return -1 ;
+  }
 
-  sleep (2) ;
+  lcdPosition (lcdHandle, 0, 0) ; lcdPuts (lcdHandle, "Gordon Henderson") ;
+  lcdPosition (lcdHandle, 0, 1) ; lcdPuts (lcdHandle, "  wiringpi.com  ") ;
 
-  sprintf (message1, "%s", "                  http://projects.drogon.net/                    ") ;
-  sprintf (message2, "%s", "                This is a long message to go into the smaller display just for a demonstration of what we can do.                ") ;
+  waitForEnter () ;
 
-  for (;;)
+  if (rows > 1)
   {
-    i = 0 ;
-    j = 0 ;
-    for (;;)
+    lcdPosition (lcdHandle, 0, 1) ; lcdPuts (lcdHandle, "  wiringpi.com  ") ;
+
+    if (rows == 4)
     {
-      strncpy (buf1, &message1 [i], 20) ;
-      buf1 [20] = 0 ;
-      lcdPosition (fd1, 0, 1) ;
-      lcdPuts (fd1, buf1) ;
-      ++i ;
-      if (i == strlen (message1) - 20)
-	i = 0 ;
-
-      strncpy (buf2, &message2 [j], 16) ;
-      buf2 [16] = 0 ;
-      lcdPosition (fd2, 0, 1) ;
-      lcdPuts (fd2, buf2) ;
-      ++j ;
-      if (j == strlen (message2) - 16)
-	j = 0 ;
-
-      tim = time (NULL) ;
-      t = localtime (&tim) ;
-
-      sprintf (buf1, "%02d:%02d:%02d", t->tm_hour, t->tm_min, t->tm_sec) ;
-      lcdPosition (fd1, 5, 2) ;
-      lcdPuts (fd1, buf1) ;
-
-      sprintf (buf1, "%02d/%02d/%02d", t->tm_mday, t->tm_mon + 1, t->tm_year+1900) ;
-      lcdPosition (fd1, 4, 3) ;
-      lcdPuts (fd1, buf1) ;
-
-      delay (250) ;
+      lcdPosition (lcdHandle, 0, 2) ;
+      for (i = 0 ; i < ((cols - 1) / 2) ; ++i)
+        lcdPuts (lcdHandle, "=-") ;
+      lcdPuts (lcdHandle, "=3") ;
+
+      lcdPosition (lcdHandle, 0, 3) ;
+      for (i = 0 ; i < ((cols - 1) / 2) ; ++i)
+        lcdPuts (lcdHandle, "-=") ;
+      lcdPuts (lcdHandle, "-4") ;
     }
   }
 
+  waitForEnter () ;
+
+  lcdCharDef  (lcdHandle, 2, newChar) ;
+
+  lcdClear    (lcdHandle) ;
+  lcdPosition (lcdHandle, 0, 0) ;
+  lcdPuts     (lcdHandle, "User Char: ") ;
+  lcdPutchar  (lcdHandle, 2) ;
+
+  lcdCursor      (lcdHandle, TRUE) ;
+  lcdCursorBlink (lcdHandle, TRUE) ;
+
+  waitForEnter () ;
+
+  lcdCursor      (lcdHandle, FALSE) ;
+  lcdCursorBlink (lcdHandle, FALSE) ;
+  lcdClear       (lcdHandle) ;
+
+  for (;;)
+  {
+    scrollMessage (0, cols) ;
+    
+    if (rows == 1)
+      continue ;
+
+    tim = time (NULL) ;
+    t = localtime (&tim) ;
+
+    sprintf (buf, "%02d:%02d:%02d", t->tm_hour, t->tm_min, t->tm_sec) ;
+
+    lcdPosition (lcdHandle, (cols - 8) / 2, 1) ;
+    lcdPuts     (lcdHandle, buf) ;
+
+    if (rows == 2)
+      continue ;
+
+    sprintf (buf, "%02d/%02d/%04d", t->tm_mday, t->tm_mon + 1, t->tm_year+1900) ;
+
+    lcdPosition (lcdHandle, (cols - 10) / 2, 2) ;
+    lcdPuts     (lcdHandle, buf) ;
+
+    pingPong (lcd, cols) ;
+  }
+
   return 0 ;
 }

examples/lowPower.c

@@ -0,0 +1,68 @@
+/*
+ * lowPower.c:
+ *	Check the Pi's LOW-Power signal.
+ *
+ *	This is a demonstration program that could be turned into some sort
+ *	of logger via e.g. syslog - however it's also probably something
+ *	that might be better handled by a future kernel - who knows.
+ *
+ * Copyright (c) 2014 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <time.h>
+#include <wiringPi.h>
+
+
+#define	LOW_POWER	35
+
+/*
+ * lowPower:
+ *	This is an ISR that waits for the low-power signal going low and
+ *	prints the result.
+ *********************************************************************************
+ */
+
+void lowPower (void)
+{
+  time_t t ;
+
+  time (&t) ;
+  printf ("%s: LOW POWER DETECTED\n", ctime (&t)) ;
+}
+
+
+/*
+ *********************************************************************************
+ * main
+ *********************************************************************************
+ */
+
+int main (void)
+{
+  wiringPiSetupGpio () ;	// GPIO mode as it's an internal pin
+
+  wiringPiISR (LOW_POWER, INT_EDGE_FALLING, &lowPower) ;
+
+  for (;;)
+    delay (1000) ;
+
+  return 0 ;
+}

examples/max31855.c

@@ -0,0 +1,60 @@
+/*
+ * max31855.c:
+ *	SPI Thermocouple interface chip
+ *
+ * Copyright (c) 2015 Gordon Henderson.
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <time.h>
+
+#include <wiringPi.h>
+#include <max31855.h>
+
+int main (int argc, char *argv [])
+{
+  int i = 0 ;
+
+  wiringPiSetup () ;
+  max31855Setup (200, 0) ;
+  max31855Setup (400, 1) ;
+
+  for (;;)
+  {
+    if (i == 0)
+    {
+      printf ("+------+------+------+------++------+------+------+------+\n") ;
+      printf ("| Raw  | Err  |  C   |   F  || Raw  | Err  |  C   |  F   |\n") ;
+      printf ("+------+------+------+------++------+------+------+------+\n") ;
+    }
+
+    printf ("| %4d | %4d | %4d | %4d |",   analogRead (200), analogRead (201), analogRead (202), analogRead (203)) ;
+    printf ("| %4d | %4d | %4d | %4d |\n", analogRead (400), analogRead (401), analogRead (402), analogRead (403)) ;
+    delay (500) ;
+
+    if (++i == 10)
+      i = 0 ;
+
+  }
+
+}

examples/okLed.c

@@ -39,27 +39,26 @@
 #include <wiringPi.h>
 #include <softPwm.h>
 
+// The OK/Act LED is connected to BCM_GPIO pin 16
+
 #define OK_LED  16
 
 int main ()
 {
   int fd, i ;
 
+  wiringPiSetupGpio () ;
+
+// Change the trigger on the OK/Act LED to "none"
+
   if ((fd = open ("/sys/class/leds/led0/trigger", O_RDWR)) < 0)
   {
     fprintf (stderr, "Unable to change LED trigger: %s\n", strerror (errno)) ;
     return 1 ;
   }
-
   write (fd, "none\n", 5) ;
   close (fd) ;
 
-  if (wiringPiSetupGpio () < 0)
-  {
-    fprintf (stderr, "Unable to setup GPIO: %s\n", strerror (errno)) ;
-    return 1 ;
-  }
-
   softPwmCreate (OK_LED, 0, 100) ;
 
   for (;;)

examples/pwm.c

@@ -1,7 +1,6 @@
 /*
  * pwm.c:
- *	Test of the software PWM driver. Needs 12 LEDs connected
- *	to the Pi.
+ *	This tests the hardware PWM channel.
  *
  * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
  ***********************************************************************
@@ -23,71 +22,37 @@
  ***********************************************************************
  */
 
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-
 #include <wiringPi.h>
-#include <softPwm.h>
-
-#define RANGE		100
-#define	NUM_LEDS	 12
-
-int ledMap [NUM_LEDS] = { 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13 } ;
 
-int values [NUM_LEDS] = { 0, 17, 32, 50, 67, 85, 100, 85, 67, 50, 32, 17 } ;
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
 
-int main ()
+int main (void)
 {
-  int i, j ;
-  char buf [80] ;
+  int bright ;
 
-  if (wiringPiSetup () == -1)
-  {
-    fprintf (stdout, "oops: %s\n", strerror (errno)) ;
-    return 1 ;
-  }
-
-  for (i = 0 ; i < NUM_LEDS ; ++i)
-  {
-    softPwmCreate (ledMap [i], 0, RANGE) ;
-    printf ("%3d, %3d, %3d\n", i, ledMap [i], values [i]) ;
-  }
+  printf ("Raspberry Pi wiringPi PWM test program\n") ;
 
-  fgets (buf, 80, stdin) ;
+  if (wiringPiSetup () == -1)
+    exit (1) ;
 
-// Bring all up one by one:
+  pinMode (1, PWM_OUTPUT) ;
 
-  for (i = 0 ; i < NUM_LEDS ; ++i)
-    for (j = 0 ; j <= 100 ; ++j)
+  for (;;)
+  {
+    for (bright = 0 ; bright < 1024 ; ++bright)
     {
-      softPwmWrite (ledMap [i], j) ;
-      delay (10) ;
+      pwmWrite (1, bright) ;
+      delay (1) ;
     }
 
-  fgets (buf, 80, stdin) ;
-
-// Down fast
-
-  for (i = 100 ; i > 0 ; --i)
-  {
-    for (j = 0 ; j < NUM_LEDS ; ++j)
-      softPwmWrite (ledMap [j], i) ;
-    delay (10) ;
+    for (bright = 1023 ; bright >= 0 ; --bright)
+    {
+      pwmWrite (1, bright) ;
+      delay (1) ;
+    }
   }
 
-  fgets (buf, 80, stdin) ;
-
-  for (;;)
-  {
-    for (i = 0 ; i < NUM_LEDS ; ++i)
-      softPwmWrite (ledMap [i], values [i]) ;
-
-    delay (50) ;
-
-    i = values [0] ;
-    for (j = 0 ; j < NUM_LEDS - 1 ; ++j)
-      values [j] = values [j + 1] ;
-    values [NUM_LEDS - 1] = i ;
-  }
+  return 0 ;
 }

examples/q2w/Makefile

@@ -0,0 +1,84 @@
+#
+# Makefile:
+#	wiringPi - Wiring Compatable library for the Raspberry Pi
+#	https://projects.drogon.net/wiring-pi
+#
+#	Copyright (c) 2012-2013 Gordon Henderson
+#################################################################################
+# This file is part of wiringPi:
+#	Wiring Compatable library for the Raspberry Pi
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#################################################################################
+
+ifneq ($V,1)
+Q ?= @
+endif
+
+#DEBUG	= -g -O0
+DEBUG	= -O3
+CC	= gcc
+INCLUDE	= -I/usr/local/include
+CFLAGS	= $(DEBUG) -Wall $(INCLUDE) -Winline -pipe
+
+LDFLAGS	= -L/usr/local/lib
+LDLIBS    = -lwiringPi -lwiringPiDev -lpthread -lm
+
+###############################################################################
+
+SRC	=	blink.c button.c blink-io.c volts.c bright.c
+
+OBJ	=	$(SRC:.c=.o)
+
+BINS	=	$(SRC:.c=)
+
+all:	$(BINS)
+
+blink:	blink.o
+	$Q echo [link]
+	$Q $(CC) -o $@ blink.o $(LDFLAGS) $(LDLIBS)
+
+blink-io:	blink-io.o
+	$Q echo [link]
+	$Q $(CC) -o $@ blink-io.o $(LDFLAGS) $(LDLIBS)
+
+button:	button.o
+	$Q echo [link]
+	$Q $(CC) -o $@ button.o $(LDFLAGS) $(LDLIBS)
+
+volts:	volts.o
+	$Q echo [link]
+	$Q $(CC) -o $@ volts.o $(LDFLAGS) $(LDLIBS)
+
+bright:	bright.o
+	$Q echo [link]
+	$Q $(CC) -o $@ bright.o $(LDFLAGS) $(LDLIBS)
+
+
+.c.o:
+	$Q echo [CC] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
+
+clean:
+	$Q echo "[Clean]"
+	$Q rm -f $(OBJ) *~ core tags $(BINS)
+
+tags:	$(SRC)
+	$Q echo [ctags]
+	$Q ctags $(SRC)
+
+depend:
+	makedepend -Y $(SRC)
+
+# DO NOT DELETE

examples/q2w/binary.c

@@ -0,0 +1,79 @@
+/*
+ * binary.c:
+ *      Using the Quick 2 wire 16-bit GPIO expansion board to output
+ *	a binary counter.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+#include <mcp23017.h>
+
+#define	Q2W_BASE	100
+
+int main (void)
+{
+  int i, bit ;
+
+// Enable the on-goard GPIO
+
+  wiringPiSetup () ;
+
+// Add in the mcp23017 on the q2w board
+
+  mcp23017Setup (Q2W_BASE, 0x20) ;
+
+  printf ("Raspberry Pi - quite2Wire MCP23017 Test\n") ;
+
+// On-board button Input:
+
+  pinMode (0, INPUT) ;
+
+// First 10 pins on q2w board as outputs:
+
+  for (i = 0 ; i < 10 ; ++i)
+    pinMode (Q2W_BASE + i, OUTPUT) ;
+
+// Last pin as an input with the internal pull-up enabled
+
+  pinMode         (Q2W_BASE + 15, INPUT) ;
+  pullUpDnControl (Q2W_BASE + 15, PUD_UP) ;
+
+// Loop, outputting a binary number,
+//	Go faster with the button, or stop if the
+//	on-board button is pushed
+
+  for (;;)
+  {
+    for (i = 0 ; i < 1024 ; ++i)
+    {
+      for (bit = 0 ; bit < 10 ; ++bit)
+        digitalWrite (Q2W_BASE + bit, i & (1 << bit)) ;
+
+      while (digitalRead (0) == HIGH)		// While pushed
+	delay (1) ;
+
+      if (digitalRead (Q2W_BASE + 15) == HIGH)	// Not Pushed
+	delay (100) ;
+    }
+  }
+  return 0 ;
+}

examples/q2w/blink-io.c

@@ -0,0 +1,61 @@
+/*
+ * blink-io.c:
+ *	Simple "blink" test for the Quick2Wire 16-pin IO board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+#include <mcp23017.h>
+
+#define	LED		1
+#define	Q2W_BASE	100
+
+int main (void)
+{
+
+// Enable the on-goard GPIO
+
+  wiringPiSetup () ;
+
+// Add in the mcp23017 on the q2w board
+
+  mcp23017Setup (Q2W_BASE, 0x20) ;
+
+  printf ("Raspberry Pi - Quick2Wire MCP23017 Blink Test\n") ;
+
+// Blink the on-board LED as well as one on the mcp23017
+
+  pinMode (LED, OUTPUT) ;
+  pinMode (Q2W_BASE + 0, OUTPUT) ;
+
+  for (;;)
+  {
+    digitalWrite (LED,          HIGH) ;
+    digitalWrite (Q2W_BASE + 0, HIGH) ;
+    delay (500) ;
+    digitalWrite (LED,          LOW) ;
+    digitalWrite (Q2W_BASE + 0, LOW) ;
+    delay (500) ;
+  }
+
+  return 0 ;
+}

examples/q2w/blink.c

@@ -0,0 +1,50 @@
+/*
+ * blink.c:
+ *	Simple "blink" test for the Quick2Wire interface board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+
+#define	LED	1
+
+int main (void)
+{
+
+// Enable the on-goard GPIO
+
+  wiringPiSetup () ;
+
+  printf ("Raspberry Pi - Quick2Wire Mainboard LED Blink Test\n") ;
+
+  pinMode (LED, OUTPUT) ;
+
+  for (;;)
+  {
+    digitalWrite (LED, HIGH) ;
+    delay (500) ;
+    digitalWrite (LED, LOW) ;
+    delay (500) ;
+  }
+
+  return 0 ;
+}

examples/q2w/blink.sh

@@ -0,0 +1,37 @@
+#!/bin/sh -e
+#
+# blink.sh:
+#	Standard "blink" program in wiringPi. Blinks an LED connected
+#	to the LED on the Quick2Wire board
+#
+# Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+#######################################################################
+# This file is part of wiringPi:
+#	https://projects.drogon.net/raspberry-pi/wiringpi/
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#######################################################################
+
+# LED Pin - wiringPi pin 1 is BCM_GPIO 18.
+
+LED=1
+
+gpio mode $LED out
+
+while true; do
+  gpio write $LED 1
+  sleep 0.5
+  gpio write $LED 0
+  sleep 0.5
+done

examples/q2w/bright.c

@@ -0,0 +1,59 @@
+/*
+ * bright.c:
+ *	Vary the Q2W LED brightness with the analog card
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+#include <pcf8591.h>
+
+#define	LED		  1
+#define Q2W_ABASE       120
+
+int main (void)
+{
+  int value ;
+
+// Enable the on-goard GPIO
+
+  wiringPiSetup () ;
+
+// Add in the pcf8591 on the q2w board
+
+  pcf8591Setup (Q2W_ABASE, 0x48) ;
+
+  printf ("Raspberry Pi - Quick2Wire Analog Test\n") ;
+
+// Setup the LED
+
+  pinMode  (LED, PWM_OUTPUT) ;
+  pwmWrite (LED, 0) ;
+
+  for (;;)
+  {
+    value = analogRead  (Q2W_ABASE + 0) ;
+    pwmWrite (LED, value * 4) ;
+    delay (10) ;
+  }
+
+  return 0 ;
+}

examples/q2w/button.c

@@ -0,0 +1,63 @@
+/*
+ * button.c:
+ *	Simple button test for the Quick2Wire interface board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+
+#define	BUTTON	0
+#define	LED1	1
+#define	LED2	7
+
+int main (void)
+{
+
+// Enable the on-goard GPIO
+
+  wiringPiSetup () ;
+
+  printf ("Raspberry Pi - Quick2Wire Mainboard Button & LED Test\n") ;
+
+  pinMode (BUTTON, INPUT) ;
+  pinMode (LED1, OUTPUT) ;
+  pinMode (LED2, OUTPUT) ;
+
+  digitalWrite (LED1, HIGH) ;		// On-board LED on
+  digitalWrite (LED2, LOW) ;		// 2nd LED off
+
+  for (;;)
+  {
+    if (digitalRead (BUTTON) == HIGH)	// Swap LED states
+    {
+      digitalWrite (LED1, LOW) ;
+      digitalWrite (LED2, HIGH) ;
+      while (digitalRead (BUTTON) == HIGH)
+	delay (1) ;
+      digitalWrite (LED1, HIGH) ;
+      digitalWrite (LED2, LOW) ;
+    }
+    delay (1) ;
+  }
+
+  return 0 ;
+}

examples/q2w/volts.c

@@ -0,0 +1,62 @@
+/*
+ * volts.c:
+ *	Read in all 4 analogs on the Q2W analog board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <wiringPi.h>
+#include <pcf8591.h>
+
+#define	LED		1
+#define Q2W_ABASE       120
+
+int main (void)
+{
+  int value, pin ;
+
+// Enable the on-goard GPIO
+
+  wiringPiSetup () ;
+
+  pinMode (LED, OUTPUT) ;	// On-board LED
+
+// Add in the pcf8591 on the q2w board
+
+  pcf8591Setup (Q2W_ABASE, 0x48) ;
+
+  printf ("Raspberry Pi - Quick2Wire Voltmeter\n") ;
+
+  for (;;)
+  {
+    for (pin = 0 ; pin < 4 ; ++pin)
+    {
+      value = analogRead  (Q2W_ABASE + pin) ;
+      printf ("  %5.2f", (double)value * 3.3 / 255.0) ;
+    }
+    printf ("\r") ; fflush (stdout) ;
+
+    delay (100) ;
+    digitalWrite (LED, !digitalRead (LED)) ;	// Flicker the LED
+  }
+
+  return 0 ;
+}

examples/rht03.c

@@ -0,0 +1,69 @@
+/*
+ * rht03.c:
+ *	Driver for the MaxDetect series sensors
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+
+#include <wiringPi.h>
+#include <maxdetect.h>
+
+#define	RHT03_PIN	0
+
+/*
+ ***********************************************************************
+ * The main program
+ ***********************************************************************
+ */
+
+int main (void)
+{
+  int temp, rh ;
+  int newTemp, newRh ;
+
+  temp = rh = newTemp = newRh = 0 ;
+
+  wiringPiSetup () ;
+  piHiPri       (55) ;
+
+  for (;;)
+  {
+    delay (100) ;
+
+    if (!readRHT03 (RHT03_PIN, &newTemp, &newRh))
+      continue ;
+
+    if ((temp != newTemp) || (rh != newRh))
+    {
+      temp = newTemp ;
+      rh   = newRh ;
+      if ((temp & 0x8000) != 0)	// Negative
+      {
+	temp &= 0x7FFF ;
+	temp = -temp ;
+      }
+      printf ("Temp: %5.1f, RH: %5.1f%%\n", temp / 10.0, rh / 10.0) ;
+    }
+  }
+
+  return 0 ;
+}

examples/softPwm.c

@@ -0,0 +1,89 @@
+/*
+ * softPwm.c:
+ *	Test of the software PWM driver. Needs 8 LEDs connected
+ *	to the Pi - e.g. Ladder board.
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include <wiringPi.h>
+#include <softPwm.h>
+
+#define RANGE		100
+#define	NUM_LEDS	  8
+
+int ledMap [NUM_LEDS] = { 0, 1, 2, 3, 4, 5, 6, 7 } ;
+
+int values [NUM_LEDS] = { 0, 25, 50, 75, 100, 75, 50, 25 } ;
+
+int main ()
+{
+  int i, j ;
+  char buf [80] ;
+
+  wiringPiSetup ()  ;
+
+  for (i = 0 ; i < NUM_LEDS ; ++i)
+  {
+    softPwmCreate (ledMap [i], 0, RANGE) ;
+    printf ("%3d, %3d, %3d\n", i, ledMap [i], values [i]) ;
+  }
+
+  fgets (buf, 80, stdin) ;
+
+// Bring all up one by one:
+
+  for (i = 0 ; i < NUM_LEDS ; ++i)
+    for (j = 0 ; j <= 100 ; ++j)
+    {
+      softPwmWrite (ledMap [i], j) ;
+      delay (10) ;
+    }
+
+  fgets (buf, 80, stdin) ;
+
+// All Down
+
+  for (i = 100 ; i > 0 ; --i)
+  {
+    for (j = 0 ; j < NUM_LEDS ; ++j)
+      softPwmWrite (ledMap [j], i) ;
+    delay (10) ;
+  }
+
+  fgets (buf, 80, stdin) ;
+
+  for (;;)
+  {
+    for (i = 0 ; i < NUM_LEDS ; ++i)
+      softPwmWrite (ledMap [i], values [i]) ;
+
+    delay (50) ;
+
+    i = values [0] ;
+    for (j = 0 ; j < NUM_LEDS - 1 ; ++j)
+      values [j] = values [j + 1] ;
+    values [NUM_LEDS - 1] = i ;
+  }
+}

examples/softTone.c

@@ -0,0 +1,54 @@
+/*
+ * softTone.c:
+ *	Test of the softTone module in wiringPi
+ *	Plays a scale out on pin 3 - connect pizeo disc to pin 3 & 0v
+ *
+ * Copyright (c) 2012-2013 Gordon Henderson. <projects@drogon.net>
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include <wiringPi.h>
+#include <softTone.h>
+
+#define	PIN	3
+
+int scale [8] = { 262, 294, 330, 349, 392, 440, 494, 525 } ;
+
+int main ()
+{
+  int i ;
+
+  wiringPiSetup () ;
+
+  softToneCreate (PIN) ;
+
+  for (;;)
+  {
+    for (i = 0 ; i < 8 ; ++i)
+    {
+      printf ("%3d\n", i) ;
+      softToneWrite (PIN, scale [i]) ;
+      delay (500) ;
+    }
+  }
+}

examples/speed.c

@@ -31,93 +31,65 @@
 
 #define	FAST_COUNT	10000000
 #define	SLOW_COUNT	 1000000
+#define	PASSES		       5
 
-
-int main (void)
+void speedTest (int pin, int maxCount)
 {
-  int i ;
-  uint32_t start, end, count, sum, perSec ;
-
-  printf ("Raspberry Pi wiringPi speed test program\n") ;
-
-// Start the standard way
-
-  if (wiringPiSetup () == -1)
-    exit (1) ;
-
-  printf ("Native wiringPi method: (%8d iterations)\n", FAST_COUNT) ;
-
-  pinMode (0, OUTPUT) ;
+  int count, sum, perSec, i ;
+  unsigned int start, end ;
 
   sum = 0 ;
-  for (i = 0 ; i < 3 ; ++i)
-  {
-    printf ("  Pass: %d: ", i) ;
-    fflush (stdout) ;
 
+  for (i = 0 ; i < PASSES ; ++i)
+  {
     start = millis () ;
-    for (count = 0 ; count < FAST_COUNT ; ++count)
-      digitalWrite (0, 1) ;
+    for (count = 0 ; count < maxCount ; ++count)
+      digitalWrite (pin, 1) ;
     end = millis () ;
-    printf (" %8dmS\n", end - start) ;
+    printf (" %6d", end - start) ;
+    fflush (stdout) ;
     sum += (end - start) ;
   }
-  digitalWrite (0, 0) ;
-  printf ("   Average: %8dmS", sum / 3) ;
-  perSec = (int)(double)FAST_COUNT / (double)((double)sum / 3.0) * 1000.0 ;
-  printf (": %6d/sec\n", perSec) ;
 
+  digitalWrite (pin, 0) ;
+  printf (". Av: %6dmS", sum / PASSES) ;
+  perSec = (int)(double)maxCount / (double)((double)sum / (double)PASSES) * 1000.0 ;
+  printf (": %7d/sec\n", perSec) ;
+}
 
-  printf ("Native GPIO method: (%8d iterations)\n", FAST_COUNT) ;
-
-  if (wiringPiSetupGpio () == -1)
-    exit (1) ;
 
-  pinMode (17, OUTPUT) ;
+int main (void)
+{
+  printf ("Raspberry Pi wiringPi GPIO speed test program\n") ;
+  printf ("=============================================\n") ;
 
-  sum = 0 ;
-  for (i = 0 ; i < 3 ; ++i)
-  {
-    printf ("  Pass: %d: ", i) ;
-    fflush (stdout) ;
+// Start the standard way
 
-    start = millis () ;
-    for (count = 0 ; count < 10000000 ; ++count)
-      digitalWrite (17, 1) ;
-    end = millis () ;
-    printf (" %8dmS\n", end - start) ;
-    sum += (end - start) ;
-  }
-  digitalWrite (17, 0) ;
-  printf ("   Average: %8dmS", sum / 3) ;
-  perSec = (int)(double)FAST_COUNT / (double)((double)sum / 3.0) * 1000.0 ;
-  printf (": %6d/sec\n", perSec) ;
+  printf ("\nNative wiringPi method: (%8d iterations)\n", FAST_COUNT) ;
+  wiringPiSetup () ;
+  pinMode (0, OUTPUT) ;
+  speedTest (0, FAST_COUNT) ;
 
+// GPIO
 
-// Switch to SYS mode:
+  printf ("\nNative GPIO method: (%8d iterations)\n", FAST_COUNT) ;
+  wiringPiSetupGpio () ;
+  pinMode (17, OUTPUT) ;
+  speedTest (17, FAST_COUNT) ;
 
-  if (wiringPiSetupSys () == -1)
-    exit (1) ;
+// Phys
 
-  printf ("/sys/class/gpio method: (%8d iterations)\n", SLOW_COUNT) ;
+  printf ("\nPhysical pin GPIO method: (%8d iterations)\n", FAST_COUNT) ;
+  wiringPiSetupPhys () ;
+  pinMode (11, OUTPUT) ;
+  speedTest (11, FAST_COUNT) ;
 
-  sum = 0 ;
-  for (i = 0 ; i < 3 ; ++i)
-  {
-    printf ("  Pass: %d: ", i) ;
-    fflush (stdout) ;
+// Switch to SYS mode:
 
-    start = millis () ;
-    for (count = 0 ; count < SLOW_COUNT ; ++count)
-      digitalWrite (17, 1) ;
-    end = millis () ;
-    printf (" %8dmS\n", end - start) ;
-    sum += (end - start) ;
-  }
-  digitalWrite (17, 0) ;
-  printf ("   Average: %8dmS", sum / 3) ;
-  perSec = (int)(double)SLOW_COUNT / (double)((double)sum / 3.0) * 1000.0 ;
-  printf (": %6d/sec\n", perSec) ;
+  system ("/usr/local/bin/gpio export 17 out") ;
+  printf ("\n/sys/class/gpio method: (%8d iterations)\n", SLOW_COUNT) ;
+  wiringPiSetupSys () ;
+  speedTest (17, SLOW_COUNT) ;
 
   return 0 ;
 }

examples/spiSpeed.c

@@ -0,0 +1,118 @@
+/*
+ * spiSpeed.c:
+ *	Code to measure the SPI speed/latency.
+ *	Copyright (c) 2014 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+//#include <fcntl.h>
+//#include <sys/ioctl.h>
+//#include <linux/spi/spidev.h>
+
+#include <wiringPi.h>
+#include <wiringPiSPI.h>
+
+#define	TRUE	(1==1)
+#define	FALSE	(!TRUE)
+
+#define	SPI_CHAN		0
+#define	NUM_TIMES		100
+#define	MAX_SIZE		(1024*1024)
+
+static int myFd ;
+
+
+void spiSetup (int speed)
+{
+  if ((myFd = wiringPiSPISetup (SPI_CHAN, speed)) < 0)
+  {
+    fprintf (stderr, "Can't open the SPI bus: %s\n", strerror (errno)) ;
+    exit (EXIT_FAILURE) ;
+  }
+}
+
+
+int main (void)
+{
+  int speed, times, size ;
+  unsigned int start, end ;
+  int spiFail ;
+  unsigned char *myData ;
+  double timePerTransaction, perfectTimePerTransaction, dataSpeed ;
+
+  if ((myData = malloc (MAX_SIZE)) == NULL)
+  {
+    fprintf (stderr, "Unable to allocate buffer: %s\n", strerror (errno)) ;
+    exit (EXIT_FAILURE) ;
+  }
+
+  wiringPiSetup () ;
+
+  for (speed = 1 ; speed <= 32 ; speed *= 2)
+  {
+    printf ("+-------+--------+----------+----------+-----------+------------+\n") ;
+    printf ("|   MHz |   Size | mS/Trans |      TpS |    Mb/Sec | Latency mS |\n") ;
+    printf ("+-------+--------+----------+----------+-----------+------------+\n") ;
+
+    spiFail = FALSE ;
+    spiSetup (speed * 1000000) ;
+    for (size = 1 ; size <= MAX_SIZE ; size *= 2)
+    {
+      printf ("| %5d | %6d ", speed, size) ;
+
+      start = millis () ;
+      for (times = 0 ; times < NUM_TIMES ; ++times)
+	if (wiringPiSPIDataRW (SPI_CHAN, myData, size) == -1)
+	{
+	  printf ("SPI failure: %s\n", strerror (errno)) ;
+	  spiFail = TRUE ;
+	  break ;
+	}
+      end = millis () ;
+
+      if (spiFail)
+	break ;
+
+      timePerTransaction        = ((double)(end - start) / (double)NUM_TIMES) / 1000.0 ;
+      dataSpeed                 =  (double)(size * 8)    / (1024.0 * 1024.0) / timePerTransaction  ;
+      perfectTimePerTransaction = ((double)(size * 8))   / ((double)(speed * 1000000)) ;
+
+      printf ("| %8.3f ", timePerTransaction * 1000.0) ;
+      printf ("| %8.1f ", 1.0 / timePerTransaction) ;
+      printf ("| %9.5f ", dataSpeed) ;
+      printf ("|   %8.5f ", (timePerTransaction - perfectTimePerTransaction) * 1000.0) ;
+      printf ("|\n") ;
+
+    }
+
+    close (myFd) ;
+    printf ("+-------+--------+----------+----------+-----------+------------+\n") ;
+    printf ("\n") ;
+  }
+
+  return 0 ;
+}

gpio/Makefile

@@ -1,9 +1,10 @@
 #
 # Makefile:
-#	wiringPi - Wiring Compatable library for the Raspberry Pi
+#	The gpio command:
+#	  A swiss-army knige of GPIO shenanigans.
 #	https://projects.drogon.net/wiring-pi
 #
-#	Copyright (c) 2012 Gordon Henderson
+#	Copyright (c) 2012-2015 Gordon Henderson
 #################################################################################
 # This file is part of wiringPi:
 #	Wiring Compatable library for the Raspberry Pi
@@ -22,59 +23,79 @@
 #    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
 #################################################################################
 
+DESTDIR?=/usr
+PREFIX?=/local
+
+ifneq ($V,1)
+Q ?= @
+endif
 
 #DEBUG	= -g -O0
 DEBUG	= -O2
 CC	= gcc
-INCLUDE	= -I/usr/local/include
+INCLUDE	= -I$(DESTDIR)$(PREFIX)/include
 CFLAGS	= $(DEBUG) -Wall $(INCLUDE) -Winline -pipe
 
-LDFLAGS	= -L/usr/local/lib
-LIBS    = -lwiringPi -lpthread -lm
+LDFLAGS	= -L$(DESTDIR)$(PREFIX)/lib
+LIBS    = -lwiringPi -lwiringPiDev -lpthread
 
 # May not need to  alter anything below this line
 ###############################################################################
 
-SRC	=	gpio.c
+SRC	=	gpio.c readall.c pins.c
 
 OBJ	=	$(SRC:.c=.o)
 
 all:		gpio
 
-gpio:	gpio.o
-	@echo [Link]
-	@$(CC) -o $@ gpio.o $(LDFLAGS) $(LIBS)
-	
+version.h:	../VERSION
+	$Q echo Need to run newVersion above.
+
+gpio:	$(OBJ)
+	$Q echo [Link]
+	$Q $(CC) -o $@ $(OBJ) $(LDFLAGS) $(LIBS)
+
 .c.o:
-	@echo [Compile] $<
-	@$(CC) -c $(CFLAGS) $< -o $@
+	$Q echo [Compile] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
 
-.PHONEY:	clean
+.PHONY:	clean
 clean:
-	rm -f $(OBJ) gpio *~ core tags *.bak
+	$Q echo "[Clean]"
+	$Q rm -f $(OBJ) gpio *~ core tags *.bak
 
-.PHONEY:	tags
+.PHONY:	tags
 tags:	$(SRC)
-	@echo [ctags]
-	@ctags $(SRC)
-
-.PHONEY:	install
-install:
-	@echo "[Install]"
-	@cp gpio /usr/local/bin
-	@chown root.root /usr/local/bin/gpio
-	@chmod 4755 /usr/local/bin/gpio
-	@mkdir -p /usr/local/man/man1
-	@cp gpio.1 /usr/local/man/man1
-
-.PHONEY:	uninstall
+	$Q echo [ctags]
+	$Q ctags $(SRC)
+
+.PHONY:	install
+install: gpio
+	$Q echo "[Install]"
+	$Q cp gpio		$(DESTDIR)$(PREFIX)/bin
+ifneq ($(WIRINGPI_SUID),0)
+	$Q chown root.root	$(DESTDIR)$(PREFIX)/bin/gpio
+	$Q chmod 4755		$(DESTDIR)$(PREFIX)/bin/gpio
+endif
+	$Q mkdir -p		$(DESTDIR)$(PREFIX)/man/man1
+	$Q cp gpio.1		$(DESTDIR)$(PREFIX)/man/man1
+
+.PHONY:	install-deb
+install-deb:	gpio
+	$Q echo "[Install: deb]"
+	$Q install -m 0755 -d							~/wiringPi/debian-template/wiringPi/usr/bin
+	$Q install -m 0755 gpio							~/wiringPi/debian-template/wiringPi/usr/bin
+
+.PHONY:	uninstall
 uninstall:
-	@echo "[UnInstall]"
-	@rm -f /usr/local/bin/gpio
-	@rm -f /usr/local/man/man1/gpio.1
+	$Q echo "[UnInstall]"
+	$Q rm -f $(DESTDIR)$(PREFIX)/bin/gpio
+	$Q rm -f $(DESTDIR)$(PREFIX)/man/man1/gpio.1
 
-.PHONEY:	depend
+.PHONY:	depend
 depend:
 	makedepend -Y $(SRC)
 
 # DO NOT DELETE
+
+gpio.o: version.h

gpio/gpio.1

@@ -1,19 +1,23 @@
-.TH "GPIO" "21st October 2012" "Command-Line access to Raspberry Pi and PiFace GPIO"
+.TH GPIO 1 "September 2015" wiringPi "Command-Line access to Raspberry Pi's GPIO"
 
 .SH NAME
-gpio \- Command-line access to Raspberry Pi and PiFace GPIO
+gpio \- Command-line access to Raspberry Pi's GPIO
 
 .SH SYNOPSIS
 .B gpio
 .B \-v
 .PP
 .B gpio
-.B [ \-g ]
-.B read/write/wb/pwm/clock/mode ...
+.B [ \-g | \-1 ]
+.B mode/read/write/aread/awrite/wb/pwm/clock ...
+.PP
+.B gpio
+.B [ \-x extension:params ]
+.B mode/read/write/aread/awrite/pwm/pwmTone ...
 .PP
 .B gpio
 .B [ \-p ]
-.B read/write/wb
+.B read/write/toggle/wb
 .B ...
 .PP
 .B gpio
@@ -27,10 +31,18 @@ gpio \- Command-line access to Raspberry Pi and PiFace GPIO
 .B ...
 .PP
 .B gpio
+.B wfi
+.B ...
+.PP
+.B gpio
 .B drive
 group value
 .PP
 .B gpio
+.B usbp
+high | low
+.PP
+.B gpio
 .B pwm-bal/pwm-ms
 .PP
 .B gpio
@@ -73,12 +85,28 @@ Output the current version including the board revision of the Raspberry Pi.
 .TP
 .B \-g
 Use the BCM_GPIO pins numbers rather than wiringPi pin numbers.
-\fINOTE:\fR The BCM_GPIO pin numbers are always used with the 
+\fINote:\fR The BCM_GPIO pin numbers are always used with the 
 export and edge commands.
 
 .TP
+.B \-1
+Use the physical pin numbers rather than wiringPi pin numbers.
+\fINote:\fR that this applies to the P1 connector only. It is not possible to
+use pins on the Revision 2 P5 connector this way, and as with \-g the
+BCM_GPIO pin numbers are always used with the export and edge commands.
+
+.TP
+.B \-x extension
+This causes the named extension to be initialised. Extensions
+comprise of a name (e.g. mcp23017) followed by a colon, then the
+pin-base, then more optional parameters depending on the extension type.
+See the web page on http://wiringpi.com/the-gpio-utility/
+
+.TP
 .B \-p
-Use the PiFace interface board and its corresponding pin numbers.
+Use the PiFace interface board and its corresponding pin numbers. The PiFace
+will always appear at pin number 200 in the gpio command. You can assign any
+pin numbers you like in your own programs though.
 
 .TP
 .B read <pin>
@@ -91,6 +119,28 @@ Write the given value (0 or 1) to the pin. You need to set the pin
 to output mode first.
 
 .TP
+.B aread <pin>
+Read the analog value of the given pin. This needs to be uses in
+conjunction with a -x flag to add in an extension that handles analog
+inputs.  respective logic levels.
+
+e.g. gpio -x mcp3002:200:0 aread 200
+
+will read the first analog input on an mcp3002 SPI ADC chip.
+
+.TP
+.B awrite <pin> <value>
+Write the analog value to the given pin. This needs to be used in
+conjunction with a -x flag to add in an extension that handles analog
+inputs.  respective logic levels.
+
+e.g. gpio -x mcp4802:200:0 awrite 200 128
+
+will write the value 128 to the first DAC port on an mcp4802 chip on
+the Pi's SPI bus 0.
+
+
+.TP
 .B wb <value>
 Write the given byte to the 8 main GPIO pins. You can prefix it with 0x
 to specify a hexadecimal number. You need to set pins to output mode
@@ -102,6 +152,10 @@ Output a table of all GPIO pins values. The values represent the actual values r
 if the pin is in input mode, or the last value written if the pin is in output
 mode.
 
+The readall command is usable with an extension module (via the -x parameter),
+but it's unable to determine pin modes or states, so will perform both a
+digital and analog read on each pin in-turn.
+
 .TP
 .B pwm <pin> <value>
 Write a PWM value (0-1023) to the given pin. The pin needs to be put
@@ -118,6 +172,8 @@ Set a pin into \fIinput\fR, \fIoutput\fR or \fIpwm\fR mode. Can also
 use the literals \fIup\fR, \fIdown\fR or \fItri\fR to set the internal
 pull-up, pull-down or tristate (off) controls.
 
+The ALT modes can also be set using \fIalt0\fR, \fIalt1\fR,  ... \fIalt5\fR.
+
 .TP
 .B unexportall
 Un-Export all the GPIO pins in the /sys/class/gpio directory.
@@ -129,9 +185,11 @@ Print a list (if any) of all the exported GPIO pins and their current values.
 .TP
 .B export
 Export a GPIO pin in the \fI/sys/class/gpio\fR directory. Use like the
-mode command above however only \fIin\fR and \fIout\fR are supported at
-this time. Note that the pin number is the \fBBCM_GPIO\fR number and
-not the wiringPi number.
+mode command above however only \fIin\fR, \fIout\fR, \fIhigh\fR and
+\fRlow\fR are supported at this time. Note that the pin number is the
+\fBBCM_GPIO\fR number and not the wiringPi number. The \fIhigh\fR and
+\fIlow\fR commands pre-set the output value at the same time as the
+export to output mode.
 
 Once a GPIO pin has been exported, the \fBgpio\fR program changes the
 ownership of the \fI/sys/class/gpio/gpioX/value\fR and if present in
@@ -158,6 +216,12 @@ requiring root/sudo.
 Un-Export a GPIO pin in the /sys/class/gpio directory.
 
 .TP
+.B wfi <pin> <mode>
+This set the given pin to the supplied interrupt mode: rising, falling
+or both then waits for the interrupt to happen. It's a non-busy wait,
+so does not consume and CPU while it's waiting.
+
+.TP
 .B drive
 group value
 
@@ -166,6 +230,13 @@ value. Group is 0, 1 or 2 and value is 0-7. Do not use unless you are
 absolutely sure you know what you're doing.
 
 .TP
+.B usbp
+high | low
+
+Change the USB current limiter to high (1.2 amps) or low (the default, 600mA)
+This is only applicable to the model B+
+
+.TP
 .B pwm-bal/pwm-ms 
 Change the PWM mode to balanced (the default) or mark:space ratio (traditional)
 
@@ -177,15 +248,27 @@ Change the PWM range register. The default is 1024.
 .B load i2c [baudrate]
 This loads the i2c or drivers into the kernel and changes the permissions
 on the associated /dev/ entries so that the current user has access to
-them. Optionally it will set the I2C baudrate to that supplied (or as
-close as the Pi can manage) The default speed is 100Kb/sec.
+them. Optionally it will set the I2C baudrate to that supplied in Kb/sec
+(or as close as the Pi can manage) The default speed is 100Kb/sec.
+
+Note: On recent kernels with the device tree enabled you should use the
+raspi-config program to load/unload the I2C device at boot time.
+(or disable the device tree to continue to use this method)
 
 .TP
-.B load spi [buffer size in KB]
+.B load spi
 This loads the spi drivers into the kernel and changes the permissions
 on the associated /dev/ entries so that the current user has access to
-them. Optionally it will set the SPI buffer size to that supplied. The
-default is 4KB.
+them. It used to have the ability to change the buffer size from the
+default of 4096 bytes to an arbitrary value, however for some time the
+Pi Foundation have compiled the SPI device driver into the kernel and
+this has fixed the buffer size. The way to change it now is to edit
+the /boot/cmdline.txt file and add on spdev.bufsiz=8192 to set it to
+e.g. 8192 bytes then reboot.
+
+Note: On recent kernels with the device tree enabled you should use the
+raspi-config program to load/unload the SPI device at boot time.
+(or disable the device tree to continue to use this method)
 
 .TP
 .B gbr
@@ -203,41 +286,12 @@ SPI digital to analogue converter.
 The board jumpers need to be in-place to do this operation.
 
 
-.SH "WiringPi vs. BCM_GPIO Pin numbering"
+.SH "WiringPi vs. BCM_GPIO Pin numbering vs. Physical pin numbering"
 
 .PP
-.TS
-r r r l.
-WiringPi	GPIO-r1	GPIO-r2	Function
-_
-0	17	17
-1	18	18	(PWM)
-2	21	27
-3	22	22
-4	23	23
-5	24	24
-6	25	25
-7	4	4
-8	0	2	I2C: SDA0
-9	1	3	I2C: SCL0
-10	8	8	SPI: CE0
-11	7	7	SPI: CE1
-12	10	10	SPI: MOSI
-13	9	9	SPI: MISO
-14	11	11	SPI: SCLK
-15	14	14	TxD
-16	15	16	RxD
-17	-	28
-18	-	29
-19	-	30
-20	-	31
-.TE
-
-Note that "r1" and "r2" above refers to the board revision. Normally
-wiringPi detects the correct board revision with use for it's own
-numbering scheme, but if you are using a Revision 2 board with some
-of the pins which change numbers between revisions you will need
-to alter your software.
+The quickest way to get a list of the pin differences is to run the command
+.TP
+gpio readall
 
 .SH FILES
 
@@ -267,12 +321,24 @@ When using the \fIexport\fR, \fIedge\fR or \fIunexport\fR commands, the
 pin numbers are \fBalways\fR native BCM_GPIO numbers and never wiringPi
 pin numbers.
 
+As of kernels 4.1.7, a user-level GPIO access mechanism is available,
+however wiringPi will not use this by default - because at this time
+there appears to be issues when trying to program the PWM or clock output
+hardware. If you can live without PWM or GPIO clocks and you want to use
+the GPIO from a non-root program, then you need to make sure that the 
+module \fIbcm2835_gpiomem\fR is loaded at boot time. This should happen
+automatically when you enable the device tree in raspi-config. You may
+also need some additional information in /etc/udev/rules.d/ to change the
+mode and ownership of the /dev/gpiomem file. Finally, you need to set
+the environment variable \fIWIRINGPI_GPIOMEM\fR. This will go-away
+in future releases once the /dev/gpiomem interface is fully operational.
+
 .SH "SEE ALSO"
 
 .LP
 WiringPi's home page
 .IP
-https://projects.drogon.net/raspberry-pi/wiringpi/
+http://wiringpi.com/
 
 .SH AUTHOR
 
@@ -284,7 +350,7 @@ Please report bugs to <projects@drogon.net>
 
 .SH COPYRIGHT
 
-Copyright (c) 2012 Gordon Henderson
+Copyright (c) 2012-2015 Gordon Henderson
 This is free software; see the source for copying conditions. There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 

gpio/gpio.c

@@ -2,7 +2,7 @@
  * gpio.c:
  *	Swiss-Army-Knife, Set-UID command-line interface to the Raspberry
  *	Pi's GPIO.
- *	Copyright (c) 2012 Gordon Henderson
+ *	Copyright (c) 2012-2015 Gordon Henderson
  ***********************************************************************
  * This file is part of wiringPi:
  *	https://projects.drogon.net/raspberry-pi/wiringpi/
@@ -26,42 +26,81 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
+#include <ctype.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
-#include <sys/types.h>
 #include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 
 #include <wiringPi.h>
+#include <wpiExtensions.h>
+
 #include <gertboard.h>
+#include <piFace.h>
+
+#include "version.h"
 
 extern int wiringPiDebug ;
 
+// External functions I can't be bothered creating a separate .h file for:
+
+extern void doReadall    (void) ;
+extern void doPins       (void) ;
+
 #ifndef TRUE
 #  define	TRUE	(1==1)
 #  define	FALSE	(1==2)
 #endif
 
-#define	VERSION	"1.12"
+#define	PI_USB_POWER_CONTROL	38
+#define	I2CDETECT		"/usr/sbin/i2cdetect"
 
-static int wpMode ;
+int wpMode ;
 
 char *usage = "Usage: gpio -v\n"
               "       gpio -h\n"
-              "       gpio [-g] <read/write/wb/pwm/clock/mode> ...\n"
+              "       gpio [-g|-1] [-x extension:params] ...\n"
               "       gpio [-p] <read/write/wb> ...\n"
-	      "       gpio readall\n"
-	      "       gpio unexportall/exports ...\n"
+              "       gpio <read/write/aread/awritewb/pwm/clock/mode> ...\n"
+	      "       gpio readall/reset\n"
+	      "       gpio unexportall/exports\n"
 	      "       gpio export/edge/unexport ...\n"
+	      "       gpio wfi <pin> <mode>\n"
 	      "       gpio drive <group> <value>\n"
 	      "       gpio pwm-bal/pwm-ms \n"
 	      "       gpio pwmr <range> \n"
 	      "       gpio pwmc <divider> \n"
 	      "       gpio load spi/i2c\n"
+	      "       gpio unload spi/i2c\n"
+	      "       gpio i2cd/i2cdetect\n"
+	      "       gpio usbp high/low\n"
 	      "       gpio gbr <channel>\n"
 	      "       gpio gbw <channel> <value>" ;	// No trailing newline needed here.
 
 
+#ifdef	NOT_FOR_NOW
+/*
+ * decodePin:
+ *	Decode a pin "number" which can actually be a pin name to represent
+ *	one of the Pi's on-board pins.
+ *********************************************************************************
+ */
+
+static int decodePin (const char *str)
+{
+
+// The first case - see if it's a number:
+
+  if (isdigit (str [0]))
+    return atoi (str) ;
+
+  return 0 ;
+}
+#endif
+
+
 /*
  * changeOwner:
  *	Change the ownership of the file to the real userId of the calling
@@ -77,12 +116,9 @@ static void changeOwner (char *cmd, char *file)
   if (chown (file, uid, gid) != 0)
   {
     if (errno == ENOENT)	// Warn that it's not there
-      fprintf (stderr, "%s: Warning: File not present: %s\n", cmd, file) ;
+      fprintf (stderr, "%s: Warning (not an error, do not report): File not present: %s\n", cmd, file) ;
     else
-    {
-      fprintf (stderr, "%s: Unable to change ownership of %s: %s\n", cmd, file, strerror (errno)) ;
-      exit (1) ;
-    }
+      fprintf (stderr, "%s: Warning (not an error): Unable to change ownership of %s: %s\n", cmd, file, strerror (errno)) ;
   }
 }
 
@@ -127,9 +163,25 @@ static int moduleLoaded (char *modName)
  *********************************************************************************
  */
 
+static void checkDevTree (char *argv [])
+{
+  struct stat statBuf ;
+
+  if (stat ("/proc/device-tree", &statBuf) == 0)	// We're on a devtree system ...
+  {
+    fprintf (stderr,
+"%s: Unable to load/unload modules as this Pi has the device tree enabled.\n"
+"  You need to run the raspi-config program (as root) and select the\n"
+"  modules (SPI or I2C) that you wish to load/unload there and reboot.\n"
+"  There is more information here:\n"
+"      https://www.raspberrypi.org/forums/viewtopic.php?f=28&t=97314\n", argv [0]) ;
+    exit (1) ;
+  }
+}
+
 static void _doLoadUsage (char *argv [])
 {
-  fprintf (stderr, "Usage: %s load <spi/i2c> [SPI bufferSize in KB | I2C baudrate in Kb/sec]\n", argv [0]) ;
+  fprintf (stderr, "Usage: %s load <spi/i2c> [I2C baudrate in Kb/sec]\n", argv [0]) ;
   exit (1) ;
 }
 
@@ -140,6 +192,8 @@ static void doLoad (int argc, char *argv [])
   char *file1, *file2 ;
   char args1 [32], args2 [32] ;
 
+  checkDevTree (argv) ;
+
   if (argc < 3)
     _doLoadUsage (argv) ;
 
@@ -152,7 +206,10 @@ static void doLoad (int argc, char *argv [])
     file1  = "/dev/spidev0.0" ;
     file2  = "/dev/spidev0.1" ;
     if (argc == 4)
-      sprintf (args1, " bufsiz=%d", atoi (argv [3]) * 1024) ;
+    {
+      fprintf (stderr, "%s: Unable to set the buffer size now. Load aborted. Please see the man page.\n", argv [0]) ;
+      exit (1) ;
+    }
     else if (argc > 4)
       _doLoadUsage (argv) ;
   }
@@ -172,13 +229,13 @@ static void doLoad (int argc, char *argv [])
 
   if (!moduleLoaded (module1))
   {
-    sprintf (cmd, "modprobe %s%s", module1, args1) ;
+    sprintf (cmd, "/sbin/modprobe %s%s", module1, args1) ;
     system (cmd) ;
   }
 
   if (!moduleLoaded (module2))
   {
-    sprintf (cmd, "modprobe %s%s", module2, args2) ;
+    sprintf (cmd, "/sbin/modprobe %s%s", module2, args2) ;
     system (cmd) ;
   }
 
@@ -196,46 +253,82 @@ static void doLoad (int argc, char *argv [])
 
 
 /*
- * doReadall:
- *	Read all the GPIO pins
+ * doUnLoad:
+ *	Un-Load either the spi or i2c modules and change device ownerships, etc.
  *********************************************************************************
  */
 
-static char *pinNames [] =
+static void _doUnLoadUsage (char *argv [])
 {
-  "GPIO 0", "GPIO 1", "GPIO 2", "GPIO 3", "GPIO 4", "GPIO 5", "GPIO 6", "GPIO 7",
-  "SDA   ", "SCL   ",
-  "CE0   ", "CE1   ", "MOSI  ", "MISO  ", "SCLK  ",
-  "TxD   ", "RxD   ",
-  "GPIO 8", "GPIO 9", "GPIO10", "GPIO11",
-} ;
+  fprintf (stderr, "Usage: %s unload <spi/i2c>\n", argv [0]) ;
+  exit (1) ;
+}
 
-static char *alts [] =
+static void doUnLoad (int argc, char *argv [])
 {
-  "IN  ", "OUT ", "ALT5", "ALT4", "ALT0", "ALT1", "ALT2", "ALT3"
-} ;
+  char *module1, *module2 ;
+  char cmd [80] ;
 
-static void doReadall (void)
-{
-  int pin ;
+  checkDevTree (argv) ;
 
-  printf ("+----------+------+--------+------+-------+\n") ;
-  printf ("| wiringPi | GPIO | Name   | Mode | Value |\n") ;
-  printf ("+----------+------+--------+------+-------+\n") ;
+  if (argc != 3)
+    _doUnLoadUsage (argv) ;
 
-  for (pin = 0 ; pin < 64 ; ++pin)
+  /**/ if (strcasecmp (argv [2], "spi") == 0)
   {
-    if (wpiPinToGpio (pin) == -1)
-      continue ;
+    module1 = "spidev" ;
+    module2 = "spi_bcm2708" ;
+  }
+  else if (strcasecmp (argv [2], "i2c") == 0)
+  {
+    module1 = "i2c_dev" ;
+    module2 = "i2c_bcm2708" ;
+  }
+  else
+    _doUnLoadUsage (argv) ;
+
+  if (moduleLoaded (module1))
+  {
+    sprintf (cmd, "/sbin/rmmod %s", module1) ;
+    system (cmd) ;
+  }
+
+  if (moduleLoaded (module2))
+  {
+    sprintf (cmd, "/sbin/rmmod %s", module2) ;
+    system (cmd) ;
+  }
+}
+
+
+/*
+ * doI2Cdetect:
+ *	Run the i2cdetect command with the right runes for this Pi revision
+ *********************************************************************************
+ */
+
+static void doI2Cdetect (int argc, char *argv [])
+{
+  int port = piBoardRev () == 1 ? 0 : 1 ;
+  char command [128] ;
+  struct stat statBuf ;
+
+  if (stat (I2CDETECT, &statBuf) < 0)
+  {
+    fprintf (stderr, "%s: Unable to find i2cdetect command: %s\n", argv [0], strerror (errno)) ;
+    return ;
+  }
 
-    printf ("| %6d   | %3d  | %s | %s | %s  |\n",
-	pin, wpiPinToGpio (pin),
-	pinNames [pin], 
-	alts [getAlt (pin)], 
-	digitalRead (pin) == HIGH ? "High" : "Low ") ;
+  if (!moduleLoaded ("i2c_dev"))
+  {
+    fprintf (stderr, "%s: The I2C kernel module(s) are not loaded.\n", argv [0]) ;
+    return ;
   }
 
-  printf ("+----------+------+--------+------+-------+\n") ;
+  sprintf (command, "%s -y %d", I2CDETECT, port) ;
+  if (system (command) < 0)
+    fprintf (stderr, "%s: Unable to run i2cdetect: %s\n", argv [0], strerror (errno)) ;
+
 }
 
 
@@ -252,9 +345,7 @@ static void doExports (int argc, char *argv [])
   char fName [128] ;
   char buf [16] ;
 
-// Rather crude, but who knows what others are up to...
-
-  for (first = 0, i = 0 ; i < 64 ; ++i)
+  for (first = 0, i = 0 ; i < 64 ; ++i)	// Crude, but effective
   {
 
 // Try to read the direction
@@ -363,19 +454,23 @@ void doExport (int argc, char *argv [])
     exit (1) ;
   }
 
-  /**/ if ((strcasecmp (mode, "in")  == 0) || (strcasecmp (mode, "input")  == 0))
+  /**/ if ((strcasecmp (mode, "in")   == 0) || (strcasecmp (mode, "input")  == 0))
     fprintf (fd, "in\n") ;
-  else if ((strcasecmp (mode, "out") == 0) || (strcasecmp (mode, "output") == 0))
+  else if ((strcasecmp (mode, "out")  == 0) || (strcasecmp (mode, "output") == 0))
     fprintf (fd, "out\n") ;
+  else if ((strcasecmp (mode, "high") == 0) || (strcasecmp (mode, "up")     == 0))
+    fprintf (fd, "high\n") ;
+  else if ((strcasecmp (mode, "low")  == 0) || (strcasecmp (mode, "down")   == 0))
+    fprintf (fd, "low\n") ;
   else
   {
-    fprintf (stderr, "%s: Invalid mode: %s. Should be in or out\n", argv [1], mode) ;
+    fprintf (stderr, "%s: Invalid mode: %s. Should be in, out, high or low\n", argv [1], mode) ;
     exit (1) ;
   }
 
   fclose (fd) ;
 
-// Change ownership so the current user can actually use it!
+// Change ownership so the current user can actually use it
 
   sprintf (fName, "/sys/class/gpio/gpio%d/value", pin) ;
   changeOwner (argv [0], fName) ;
@@ -387,6 +482,52 @@ void doExport (int argc, char *argv [])
 
 
 /*
+ * doWfi:
+ *	gpio wfi pin mode
+ *	Wait for Interrupt on a given pin.
+ *	Slight cheat here - it's easier to actually use ISR now (which calls
+ *	gpio to set the pin modes!) then we simply sleep, and expect the thread
+ *	to exit the program. Crude but effective.
+ *********************************************************************************
+ */
+
+static void wfi (void)
+  { exit (0) ; }
+
+void doWfi (int argc, char *argv [])
+{
+  int pin, mode ;
+
+  if (argc != 4)
+  {
+    fprintf (stderr, "Usage: %s wfi pin mode\n", argv [0]) ;
+    exit (1) ;
+  }
+
+  pin  = atoi (argv [2]) ;
+
+  /**/ if (strcasecmp (argv [3], "rising")  == 0) mode = INT_EDGE_RISING ;
+  else if (strcasecmp (argv [3], "falling") == 0) mode = INT_EDGE_FALLING ;
+  else if (strcasecmp (argv [3], "both")    == 0) mode = INT_EDGE_BOTH ;
+  else
+  {
+    fprintf (stderr, "%s: wfi: Invalid mode: %s. Should be rising, falling or both\n", argv [1], argv [3]) ;
+    exit (1) ;
+  }
+
+  if (wiringPiISR (pin, mode, &wfi) < 0)
+  {
+    fprintf (stderr, "%s: wfi: Unable to setup ISR: %s\n", argv [1], strerror (errno)) ;
+    exit (1) ;
+  }
+
+  for (;;)
+    delay (9999) ;
+}
+
+
+
+/*
  * doEdge:
  *	gpio edge pin mode
  *	Easy access to changing the edge trigger on a GPIO pin
@@ -499,7 +640,7 @@ void doUnexport (int argc, char *argv [])
  *********************************************************************************
  */
 
-void doUnexportall (int argc, char *argv [])
+void doUnexportall (char *progName)
 {
   FILE *fd ;
   int pin ;
@@ -508,7 +649,7 @@ void doUnexportall (int argc, char *argv [])
   {
     if ((fd = fopen ("/sys/class/gpio/unexport", "w")) == NULL)
     {
-      fprintf (stderr, "%s: Unable to open GPIO export interface\n", argv [0]) ;
+      fprintf (stderr, "%s: Unable to open GPIO export interface\n", progName) ;
       exit (1) ;
     }
     fprintf (fd, "%d\n", pin) ;
@@ -518,6 +659,20 @@ void doUnexportall (int argc, char *argv [])
 
 
 /*
+ * doReset:
+ *	Reset the GPIO pins - as much as we can do
+ *********************************************************************************
+ */
+
+static void doReset (char *progName)
+{
+  printf ("GPIO Reset is dangerous and has been removed from the gpio command.\n") ;
+  printf (" - Please write a shell-script to reset the GPIO pins into the state\n") ;
+  printf ("   that you need them in for your applications.\n") ;
+}
+
+
+/*
  * doMode:
  *	gpio mode pin mode ...
  *********************************************************************************
@@ -536,18 +691,25 @@ void doMode (int argc, char *argv [])
 
   pin = atoi (argv [2]) ;
 
-  if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
-    return ;
-
   mode = argv [3] ;
 
-  /**/ if (strcasecmp (mode, "in")     == 0) pinMode         (pin, INPUT) ;
-  else if (strcasecmp (mode, "out")    == 0) pinMode         (pin, OUTPUT) ;
-  else if (strcasecmp (mode, "pwm")    == 0) pinMode         (pin, PWM_OUTPUT) ;
-  else if (strcasecmp (mode, "clock")  == 0) pinMode         (pin, GPIO_CLOCK) ;
-  else if (strcasecmp (mode, "up")     == 0) pullUpDnControl (pin, PUD_UP) ;
-  else if (strcasecmp (mode, "down")   == 0) pullUpDnControl (pin, PUD_DOWN) ;
-  else if (strcasecmp (mode, "tri")    == 0) pullUpDnControl (pin, PUD_OFF) ;
+  /**/ if (strcasecmp (mode, "in")      == 0) pinMode         (pin, INPUT) ;
+  else if (strcasecmp (mode, "input")   == 0) pinMode         (pin, INPUT) ;
+  else if (strcasecmp (mode, "out")     == 0) pinMode         (pin, OUTPUT) ;
+  else if (strcasecmp (mode, "output")  == 0) pinMode         (pin, OUTPUT) ;
+  else if (strcasecmp (mode, "pwm")     == 0) pinMode         (pin, PWM_OUTPUT) ;
+  else if (strcasecmp (mode, "pwmTone") == 0) pinMode         (pin, PWM_TONE_OUTPUT) ;
+  else if (strcasecmp (mode, "clock")   == 0) pinMode         (pin, GPIO_CLOCK) ;
+  else if (strcasecmp (mode, "up")      == 0) pullUpDnControl (pin, PUD_UP) ;
+  else if (strcasecmp (mode, "down")    == 0) pullUpDnControl (pin, PUD_DOWN) ;
+  else if (strcasecmp (mode, "tri")     == 0) pullUpDnControl (pin, PUD_OFF) ;
+  else if (strcasecmp (mode, "off")     == 0) pullUpDnControl (pin, PUD_OFF) ;
+  else if (strcasecmp (mode, "alt0")    == 0) pinModeAlt (pin, 0b100) ;
+  else if (strcasecmp (mode, "alt1")    == 0) pinModeAlt (pin, 0b101) ;
+  else if (strcasecmp (mode, "alt2")    == 0) pinModeAlt (pin, 0b110) ;
+  else if (strcasecmp (mode, "alt3")    == 0) pinModeAlt (pin, 0b111) ;
+  else if (strcasecmp (mode, "alt4")    == 0) pinModeAlt (pin, 0b011) ;
+  else if (strcasecmp (mode, "alt5")    == 0) pinModeAlt (pin, 0b010) ;
   else
   {
     fprintf (stderr, "%s: Invalid mode: %s. Should be in/out/pwm/clock/up/down/tri\n", argv [1], mode) ;
@@ -592,6 +754,58 @@ static void doPadDrive (int argc, char *argv [])
 
 
 /*
+ * doUsbP:
+ *	Control USB Power - High (1.2A) or Low (600mA)
+ *	gpio usbp high/low
+ *********************************************************************************
+ */
+
+static void doUsbP (int argc, char *argv [])
+{
+  int model, rev, mem, maker, overVolted ;
+
+  if (argc != 3)
+  {
+    fprintf (stderr, "Usage: %s usbp high|low\n", argv [0]) ;
+    exit (1) ;
+  }
+
+// Make sure we're on a B+
+
+  piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
+
+  if (model != PI_MODEL_BP)
+  {
+    fprintf (stderr, "USB power contol is applicable to B+ boards only.\n") ;
+    exit (1) ;
+  }
+    
+// Need to force BCM_GPIO mode:
+
+  wiringPiSetupGpio () ;
+
+  if ((strcasecmp (argv [2], "high") == 0) || (strcasecmp (argv [2], "hi") == 0))
+  {
+    digitalWrite (PI_USB_POWER_CONTROL, 1) ;
+    pinMode (PI_USB_POWER_CONTROL, OUTPUT) ;
+    printf ("Switched to HIGH current USB (1.2A)\n") ;
+    return ;
+  }
+
+  if ((strcasecmp (argv [2], "low") == 0) || (strcasecmp (argv [2], "lo") == 0))
+  {
+    digitalWrite (PI_USB_POWER_CONTROL, 0) ;
+    pinMode (PI_USB_POWER_CONTROL, OUTPUT) ;
+    printf ("Switched to LOW current USB (600mA)\n") ;
+    return ;
+  }
+
+  fprintf (stderr, "Usage: %s usbp high|low\n", argv [0]) ;
+  exit (1) ;
+}
+
+
+/*
  * doGbw:
  *	gpio gbw channel value
  *	Gertboard Write - To the Analog output
@@ -604,7 +818,7 @@ static void doGbw (int argc, char *argv [])
 
   if (argc != 4)
   {
-    fprintf (stderr, "Usage: %s gbr <channel> <value>\n", argv [0]) ;
+    fprintf (stderr, "Usage: %s gbw <channel> <value>\n", argv [0]) ;
     exit (1) ;
   }
 
@@ -613,23 +827,23 @@ static void doGbw (int argc, char *argv [])
 
   if ((channel < 0) || (channel > 1))
   {
-    fprintf (stderr, "%s: channel must be 0 or 1\n", argv [0]) ;
+    fprintf (stderr, "%s: gbw: Channel number must be 0 or 1\n", argv [0]) ;
     exit (1) ;
   }
 
-  if ((value < 0) || (value > 1023))
+  if ((value < 0) || (value > 255))
   {
-    fprintf (stderr, "%s: value must be from 0 to 255\n", argv [0]) ;
+    fprintf (stderr, "%s: gbw: Value must be from 0 to 255\n", argv [0]) ;
     exit (1) ;
   }
 
-  if (gertboardSPISetup () == -1)
+  if (gertboardAnalogSetup (64) < 0)
   {
     fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ;
     exit (1) ;
   }
 
-  gertboardAnalogWrite (channel, value) ;
+  analogWrite (64 + channel, value) ;
 }
 
 
@@ -654,21 +868,20 @@ static void doGbr (int argc, char *argv [])
 
   if ((channel < 0) || (channel > 1))
   {
-    fprintf (stderr, "%s: channel must be 0 or 1\n", argv [0]) ;
+    fprintf (stderr, "%s: gbr: Channel number must be 0 or 1\n", argv [0]) ;
     exit (1) ;
   }
 
-  if (gertboardSPISetup () == -1)
+  if (gertboardAnalogSetup (64) < 0)
   {
     fprintf (stderr, "Unable to initialise the Gertboard SPI interface: %s\n", strerror (errno)) ;
     exit (1) ;
   }
 
-  printf ("%d\n",gertboardAnalogRead (channel)) ;
+  printf ("%d\n", analogRead (64 + channel)) ;
 }
 
 
-
 /*
  * doWrite:
  *	gpio write pin value
@@ -687,9 +900,6 @@ static void doWrite (int argc, char *argv [])
 
   pin = atoi (argv [2]) ;
 
-  if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
-    return ;
-
   /**/ if ((strcasecmp (argv [3], "up") == 0) || (strcasecmp (argv [3], "on") == 0))
     val = 1 ;
   else if ((strcasecmp (argv [3], "down") == 0) || (strcasecmp (argv [3], "off") == 0))
@@ -703,6 +913,31 @@ static void doWrite (int argc, char *argv [])
     digitalWrite (pin, HIGH) ;
 }
 
+
+/*
+ * doAwriterite:
+ *	gpio awrite pin value
+ *********************************************************************************
+ */
+
+static void doAwrite (int argc, char *argv [])
+{
+  int pin, val ;
+
+  if (argc != 4)
+  {
+    fprintf (stderr, "Usage: %s awrite pin value\n", argv [0]) ;
+    exit (1) ;
+  }
+
+  pin = atoi (argv [2]) ;
+
+  val = atoi (argv [3]) ;
+
+  analogWrite (pin, val) ;
+}
+
+
 /*
  * doWriteByte:
  *	gpio write value
@@ -742,16 +977,72 @@ void doRead (int argc, char *argv [])
   }
 
   pin = atoi (argv [2]) ;
+  val = digitalRead (pin) ;
+
+  printf ("%s\n", val == 0 ? "0" : "1") ;
+}
+
 
-  if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
+/*
+ * doAread:
+ *	Read an analog pin and return the value
+ *********************************************************************************
+ */
+
+void doAread (int argc, char *argv []) 
+{
+  if (argc != 3)
   {
-    printf ("0\n") ;
-    return ;
+    fprintf (stderr, "Usage: %s aread pin\n", argv [0]) ;
+    exit (1) ;
   }
 
-  val = digitalRead (pin) ;
+  printf ("%d\n", analogRead (atoi (argv [2]))) ;
+}
 
-  printf ("%s\n", val == 0 ? "0" : "1") ;
+
+/*
+ * doToggle:
+ *	Toggle an IO pin
+ *********************************************************************************
+ */
+
+void doToggle (int argc, char *argv [])
+{
+  int pin ;
+
+  if (argc != 3)
+  {
+    fprintf (stderr, "Usage: %s toggle pin\n", argv [0]) ;
+    exit (1) ;
+  }
+
+  pin = atoi (argv [2]) ;
+
+  digitalWrite (pin, !digitalRead (pin)) ;
+}
+
+
+/*
+ * doPwmTone:
+ *	Output a tone in a PWM pin
+ *********************************************************************************
+ */
+
+void doPwmTone (int argc, char *argv [])
+{
+  int pin, freq ;
+
+  if (argc != 4)
+  {
+    fprintf (stderr, "Usage: %s pwmTone <pin> <freq>\n", argv [0]) ;
+    exit (1) ;
+  }
+
+  pin = atoi (argv [2]) ;
+  freq = atoi (argv [3]) ;
+
+  pwmToneWrite (pin, freq) ;
 }
 
 
@@ -773,9 +1064,6 @@ void doClock (int argc, char *argv [])
 
   pin = atoi (argv [2]) ;
 
-  if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
-    return ;
-
   freq = atoi (argv [3]) ;
 
   gpioClockSet (pin, freq) ;
@@ -800,9 +1088,6 @@ void doPwm (int argc, char *argv [])
 
   pin = atoi (argv [2]) ;
 
-  if ((wpMode == WPI_MODE_PINS) && ((pin < 0) || (pin >= NUM_PINS)))
-    return ;
-
   val = atoi (argv [3]) ;
 
   pwmWrite (pin, val) ;
@@ -864,6 +1149,56 @@ static void doPwmClock (int argc, char *argv [])
 
 
 /*
+ * doVersion:
+ *	Handle the ever more complicated version command
+ *********************************************************************************
+ */
+
+static void doVersion (char *argv [])
+{
+  int model, rev, mem, maker, warranty ;
+  struct stat statBuf ;
+
+  printf ("gpio version: %s\n", VERSION) ;
+  printf ("Copyright (c) 2012-2015 Gordon Henderson\n") ;
+  printf ("This is free software with ABSOLUTELY NO WARRANTY.\n") ;
+  printf ("For details type: %s -warranty\n", argv [0]) ;
+  printf ("\n") ;
+  piBoardId (&model, &rev, &mem, &maker, &warranty) ;
+
+/*************
+  if (model == PI_MODEL_UNKNOWN)
+  {
+    printf ("Your Raspberry Pi has an unknown model type. Please report this to\n") ;
+    printf ("    projects@drogon.net\n") ;
+    printf ("with a copy of your /proc/cpuinfo if possible\n") ;
+  }
+  else
+***************/
+
+  {
+    printf ("Raspberry Pi Details:\n") ;
+    printf ("  Type: %s, Revision: %s, Memory: %dMB, Maker: %s %s\n", 
+	piModelNames [model], piRevisionNames [rev], piMemorySize [mem], piMakerNames [maker], warranty ? "[Out of Warranty]" : "") ;
+
+// Check for device tree
+
+    if (stat ("/proc/device-tree", &statBuf) == 0)	// We're on a devtree system ...
+      printf ("  Device tree is enabled.\n") ;
+
+    if (stat ("/dev/gpiomem", &statBuf) == 0)		// User level GPIO is GO
+    {
+      printf ("  This Raspberry Pi supports user-level GPIO access.\n") ;
+      printf ("    -> See the man-page for more details\n") ;
+    }
+    else
+      printf ("  * Root or sudo required for GPIO access.\n") ;
+    
+  }
+}
+
+
+/*
  * main:
  *	Start here
  *********************************************************************************
@@ -885,27 +1220,35 @@ int main (int argc, char *argv [])
     return 1 ;
   }
 
+// Help
+
   if (strcasecmp (argv [1], "-h") == 0)
   {
     printf ("%s: %s\n", argv [0], usage) ;
     return 0 ;
   }
 
-  if (strcasecmp (argv [1], "-v") == 0)
+// Version & Warranty
+//	Wish I could remember why I have both -R and -V ...
+
+  if ((strcmp (argv [1], "-R") == 0) || (strcmp (argv [1], "-V") == 0))
   {
-    printf ("gpio version: %s\n", VERSION) ;
-    printf ("Copyright (c) 2012 Gordon Henderson\n") ;
-    printf ("This is free software with ABSOLUTELY NO WARRANTY.\n") ;
-    printf ("For details type: %s -warranty\n", argv [0]) ;
-    printf ("\n") ;
-    printf ("This Raspberry Pi is a revision %d board.\n", piBoardRev ()) ;
+    printf ("%d\n", piBoardRev ()) ;
+    return 0 ;
+  }
+
+// Version and information
+
+  if (strcmp (argv [1], "-v") == 0)
+  {
+    doVersion (argv) ;
     return 0 ;
   }
 
   if (strcasecmp (argv [1], "-warranty") == 0)
   {
     printf ("gpio version: %s\n", VERSION) ;
-    printf ("Copyright (c) 2012 Gordon Henderson\n") ;
+    printf ("Copyright (c) 2012-2015 Gordon Henderson\n") ;
     printf ("\n") ;
     printf ("    This program is free software; you can redistribute it and/or modify\n") ;
     printf ("    it under the terms of the GNU Leser General Public License as published\n") ;
@@ -934,12 +1277,13 @@ int main (int argc, char *argv [])
   /**/ if (strcasecmp (argv [1], "exports"    ) == 0)	{ doExports     (argc, argv) ;	return 0 ; }
   else if (strcasecmp (argv [1], "export"     ) == 0)	{ doExport      (argc, argv) ;	return 0 ; }
   else if (strcasecmp (argv [1], "edge"       ) == 0)	{ doEdge        (argc, argv) ;	return 0 ; }
-  else if (strcasecmp (argv [1], "unexportall") == 0)	{ doUnexportall (argc, argv) ;	return 0 ; }
   else if (strcasecmp (argv [1], "unexport"   ) == 0)	{ doUnexport    (argc, argv) ;	return 0 ; }
+  else if (strcasecmp (argv [1], "unexportall") == 0)	{ doUnexportall (argv [0]) ;	return 0 ; }
 
 // Check for load command:
 
-  if (strcasecmp (argv [1], "load" ) == 0)	{ doLoad     (argc, argv) ; return 0 ; }
+  if (strcasecmp (argv [1], "load"   ) == 0)	{ doLoad   (argc, argv) ; return 0 ; }
+  if (strcasecmp (argv [1], "unload" ) == 0)	{ doUnLoad (argc, argv) ; return 0 ; }
 
 // Gertboard commands
 
@@ -948,13 +1292,9 @@ int main (int argc, char *argv [])
 
 // Check for -g argument
 
-  if (strcasecmp (argv [1], "-g") == 0)
+  /**/ if (strcasecmp (argv [1], "-g") == 0)
   {
-    if (wiringPiSetupGpio () == -1)
-    {
-      fprintf (stderr, "%s: Unable to initialise GPIO mode.\n", argv [0]) ;
-      exit (1) ;
-    }
+    wiringPiSetupGpio () ;
 
     for (i = 2 ; i < argc ; ++i)
       argv [i - 1] = argv [i] ;
@@ -962,15 +1302,23 @@ int main (int argc, char *argv [])
     wpMode = WPI_MODE_GPIO ;
   }
 
+// Check for -1 argument
+
+  else if (strcasecmp (argv [1], "-1") == 0)
+  {
+    wiringPiSetupPhys () ;
+
+    for (i = 2 ; i < argc ; ++i)
+      argv [i - 1] = argv [i] ;
+    --argc ;
+    wpMode = WPI_MODE_PHYS ;
+  }
+
 // Check for -p argument for PiFace
 
   else if (strcasecmp (argv [1], "-p") == 0)
   {
-    if (wiringPiSetupPiFaceForGpioProg () == -1)
-    {
-      fprintf (stderr, "%s: Unable to initialise PiFace.\n", argv [0]) ;
-      exit (1) ;
-    }
+    piFaceSetup (200) ;
 
     for (i = 2 ; i < argc ; ++i)
       argv [i - 1] = argv [i] ;
@@ -982,38 +1330,69 @@ int main (int argc, char *argv [])
 
   else
   {
-    if (wiringPiSetup () == -1)
-    {
-      fprintf (stderr, "%s: Unable to initialise wiringPi mode\n", argv [0]) ;
-      exit (1) ;
-    }
+    wiringPiSetup () ;
     wpMode = WPI_MODE_PINS ;
   }
 
-// Check for PWM or Pad Drive operations
+// Check for -x argument to load in a new extension
 
-  if (wpMode != WPI_MODE_PIFACE)
+  if (strcasecmp (argv [1], "-x") == 0)
   {
-    if (strcasecmp (argv [1], "pwm-bal") == 0)	{ doPwmMode  (PWM_MODE_BAL) ;	return 0 ; }
-    if (strcasecmp (argv [1], "pwm-ms")  == 0)	{ doPwmMode  (PWM_MODE_MS) ;	return 0 ; }
-    if (strcasecmp (argv [1], "pwmr")    == 0)	{ doPwmRange (argc, argv) ;	return 0 ; }
-    if (strcasecmp (argv [1], "pwmc")    == 0)	{ doPwmClock (argc, argv) ;	return 0 ; }
-    if (strcasecmp (argv [1], "drive")   == 0)	{ doPadDrive (argc, argv) ;	return 0 ; }
+    if (argc < 3)
+    {
+      fprintf (stderr, "%s: -x missing extension specification.\n", argv [0]) ;
+      exit (EXIT_FAILURE) ;
+    }
+
+    if (!loadWPiExtension (argv [0], argv [2], TRUE))	// Prints its own error messages
+      exit (EXIT_FAILURE) ;
+
+    for (i = 3 ; i < argc ; ++i)
+      argv [i - 2] = argv [i] ;
+    argc -= 2 ;
   }
 
-// Check for wiring commands
+  if (argc <= 1)
+  {
+    fprintf (stderr, "%s: no command given\n", argv [0]) ;
+    exit (EXIT_FAILURE) ;
+  }
 
-  /**/ if (strcasecmp (argv [1], "readall" ) == 0) doReadall   () ;
-  else if (strcasecmp (argv [1], "read" )    == 0) doRead      (argc, argv) ;
-  else if (strcasecmp (argv [1], "write")    == 0) doWrite     (argc, argv) ;
-  else if (strcasecmp (argv [1], "wb")       == 0) doWriteByte (argc, argv) ;
-  else if (strcasecmp (argv [1], "pwm"  )    == 0) doPwm       (argc, argv) ;
-  else if (strcasecmp (argv [1], "clock")    == 0) doClock     (argc, argv) ;
-  else if (strcasecmp (argv [1], "mode" )    == 0) doMode      (argc, argv) ;
+// Core wiringPi functions
+
+  /**/ if (strcasecmp (argv [1], "mode"   ) == 0) doMode      (argc, argv) ;
+  else if (strcasecmp (argv [1], "read"   ) == 0) doRead      (argc, argv) ;
+  else if (strcasecmp (argv [1], "write"  ) == 0) doWrite     (argc, argv) ;
+  else if (strcasecmp (argv [1], "pwm"    ) == 0) doPwm       (argc, argv) ;
+  else if (strcasecmp (argv [1], "awrite" ) == 0) doAwrite    (argc, argv) ;
+  else if (strcasecmp (argv [1], "aread"  ) == 0) doAread     (argc, argv) ;
+
+// GPIO Nicies
+
+  else if (strcasecmp (argv [1], "toggle" ) == 0) doToggle    (argc, argv) ;
+
+// Pi Specifics
+
+  else if (strcasecmp (argv [1], "pwm-bal"  ) == 0) doPwmMode    (PWM_MODE_BAL) ;
+  else if (strcasecmp (argv [1], "pwm-ms"   ) == 0) doPwmMode    (PWM_MODE_MS) ;
+  else if (strcasecmp (argv [1], "pwmr"     ) == 0) doPwmRange   (argc, argv) ;
+  else if (strcasecmp (argv [1], "pwmc"     ) == 0) doPwmClock   (argc, argv) ;
+  else if (strcasecmp (argv [1], "pwmTone"  ) == 0) doPwmTone    (argc, argv) ;
+  else if (strcasecmp (argv [1], "drive"    ) == 0) doPadDrive   (argc, argv) ;
+  else if (strcasecmp (argv [1], "usbp"     ) == 0) doUsbP       (argc, argv) ;
+  else if (strcasecmp (argv [1], "readall"  ) == 0) doReadall    () ;
+  else if (strcasecmp (argv [1], "nreadall" ) == 0) doReadall    () ;
+  else if (strcasecmp (argv [1], "pins"     ) == 0) doPins       () ;
+  else if (strcasecmp (argv [1], "i2cdetect") == 0) doI2Cdetect  (argc, argv) ;
+  else if (strcasecmp (argv [1], "i2cd"     ) == 0) doI2Cdetect  (argc, argv) ;
+  else if (strcasecmp (argv [1], "reset"    ) == 0) doReset      (argv [0]) ;
+  else if (strcasecmp (argv [1], "wb"       ) == 0) doWriteByte  (argc, argv) ;
+  else if (strcasecmp (argv [1], "clock"    ) == 0) doClock      (argc, argv) ;
+  else if (strcasecmp (argv [1], "wfi"      ) == 0) doWfi        (argc, argv) ;
   else
   {
     fprintf (stderr, "%s: Unknown command: %s.\n", argv [0], argv [1]) ;
-    exit (1) ;
+    exit (EXIT_FAILURE) ;
   }
   return 0 ;
 }

gpio/pins.c

@@ -0,0 +1,33 @@
+/*
+ * pins.c:
+ *	Just display a handy Pi pinnout diagram.
+ *	Copyright (c) 2012-2015 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#include <stdio.h>
+
+void doPins (void)
+{
+  printf ("The pins command has been deprecated - sorry. Please use the\n") ;
+  printf ("  gpio readall\n") ;
+  printf ("command to get a list of the pinnouts for your Pi.\n") ;
+}
+

gpio/pintest

@@ -0,0 +1,187 @@
+#!/bin/bash
+#
+# pintest
+#	Test the Pi's GPIO port
+# Copyright (c) 2013-2015 Gordon Henderson
+#################################################################################
+# This file is part of wiringPi:
+#	Wiring Compatable library for the Raspberry Pi
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#################################################################################
+
+
+# logErr pin, expected got
+################################################################################
+
+logErr ()
+{
+  if [ $errs = 0 ]; then
+    echo ""
+  fi
+  echo " --> Pin $1 failure. Expected $2, got $3"
+  let errs+=1
+}
+
+
+# printErrorCount
+################################################################################
+
+printErrCount()
+{
+  if [ $errs = 0 ]; then
+    echo "No faults detected."
+  elif [ $errs = 1 ]; then
+    echo "One fault detected."
+  else
+    echo "$errs faults detected"
+  fi
+}
+
+
+# testPins start end
+################################################################################
+
+testPins()
+{
+  start=$1
+    end=$2
+   errs=0
+
+  printf "%30s %2d:%2d: "  "$3" $1 $2
+
+# Set range to inputs
+
+  for i in `seq $start $end`; do
+    gpio mode $i in
+  done
+
+# Enable internal pull-ups and expect to read high
+
+  for i in `seq $start $end`; do
+    gpio mode $i up
+    if [ `gpio read $i` = 0 ]; then
+      logErr $i 1 0
+    fi
+  done
+
+# Enable internal pull-downs and expect to read low
+
+  for i in `seq $start $end`; do
+    gpio mode $i down
+    if [ `gpio read $i` = 1 ]; then
+      echo "Pin $i failure - expected 0, got 1"
+      let errs+=1
+    fi
+  done
+
+# Remove the internal pull up/downs
+
+  for i in `seq $start $end`; do
+    gpio mode $i tri
+  done
+
+  if [ $errs = 0 ]; then
+    echo " OK"
+  else
+    printErrCount
+  fi
+
+  let totErrs+=errs
+}
+
+
+intro()
+{
+  cat <<EOF
+PinTest
+=======
+
+This is a simple utility to test the GPIO pins on your Raspberry Pi.
+
+NOTE: All GPIO peripherals must be removed to perform this test. This
+  includes serial, I2C and SPI connections. You may get incorrect results
+  if something is connected and it interferes with the test.
+
+This test can only test the input side of things. It uses the internal
+pull-up and pull-down resistors to simulate inputs. It does not test
+the output drivers.
+
+You will need to reboot your Pi after this test if you wish to use the 
+serial port as it will be left in GPIO mode rather than serial mode.
+
+This test only tests the original pins present on the Rev A and B. It
+does not test the extra pins on the Revision A2, B2 nor the A+ or B+
+
+Please make sure everything is removed and press the ENTER key to continue,
+EOF
+
+  echo -n "or Control-C to abort... "
+  read a
+}
+
+
+# Start here
+################################################################################
+
+intro
+gpio unexportall
+
+   errs=0
+totErrs=0
+
+echo ""
+
+# Main pins
+
+testPins 0 7 "The main 8 GPIO pins"
+
+# SPI
+
+testPins 10 14 "The 5 SPI pins"
+
+# Serial
+
+testPins 15 16 "The serial pins"
+
+# I2C - Needs somewhat different testing
+#	due to the on-board pull-up's
+
+echo -n "                  The I2C pins  8: 9: "
+errs=0
+gpio mode 8 in
+gpio mode 9 in
+
+if [ `gpio read 8` = 0 ]; then
+  echo "Pin 8 failure - expected 1, got 0"
+  let errs+=1
+fi
+
+if [ `gpio read 9` = 0 ]; then
+  echo "Pin 9 failure - expected 1, got 0"
+  let errs+=1
+fi
+
+if [ $errs = 0 ]; then
+  echo " OK"
+else
+  printErrCount
+fi
+
+echo ""
+if [ $totErrs != 0 ]; then
+  echo ""
+  echo "Faults detected! Output of 'readall':"
+  gpio readall
+fi

gpio/readall.c

@@ -0,0 +1,336 @@
+/*
+ * readall.c:
+ *	The readall functions - getting a bit big, so split them out.
+ *	Copyright (c) 2012-2015 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <ctype.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <wiringPi.h>
+
+extern int wpMode ;
+
+#ifndef TRUE
+#  define       TRUE    (1==1)
+#  define       FALSE   (1==2)
+#endif
+
+/*
+ * doReadallExternal:
+ *	A relatively crude way to read the pins on an external device.
+ *	We don't know the input/output mode of pins, but we can tell
+ *	if it's an analog pin or a digital one...
+ *********************************************************************************
+ */
+
+static void doReadallExternal (void)
+{
+  int pin ;
+
+  printf ("+------+---------+--------+\n") ;
+  printf ("|  Pin | Digital | Analog |\n") ;
+  printf ("+------+---------+--------+\n") ;
+
+  for (pin = wiringPiNodes->pinBase ; pin <= wiringPiNodes->pinMax ; ++pin)
+    printf ("| %4d |  %4d   |  %4d  |\n", pin, digitalRead (pin), analogRead (pin)) ;
+
+  printf ("+------+---------+--------+\n") ;
+}
+
+
+/*
+ * doReadall:
+ *	Read all the GPIO pins
+ *	We also want to use this to read the state of pins on an externally
+ *	connected device, so we need to do some fiddling with the internal
+ *	wiringPi node structures - since the gpio command can only use
+ *	one external device at a time, we'll use that to our advantage...
+ *********************************************************************************
+ */
+
+static char *alts [] =
+{
+  "IN", "OUT", "ALT5", "ALT4", "ALT0", "ALT1", "ALT2", "ALT3"
+} ;
+
+static int physToWpi [64] = 
+{
+  -1,           // 0
+  -1, -1,       // 1, 2
+   8, -1,
+   9, -1,
+   7, 15,
+  -1, 16,
+   0,  1,
+   2, -1,
+   3,  4,
+  -1,  5,
+  12, -1,
+  13,  6,
+  14, 10,
+  -1, 11,       // 25, 26
+  30, 31,	// Actually I2C, but not used
+  21, -1,
+  22, 26,
+  23, -1,
+  24, 27,
+  25, 28,
+  -1, 29,
+  -1, -1,
+  -1, -1,
+  -1, -1,
+  -1, -1,
+  -1, -1,
+  17, 18,
+  19, 20,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1
+} ;
+
+static char *physNames [64] = 
+{
+  NULL,
+
+  "   3.3v", "5v     ",
+  "  SDA.1", "5V     ",
+  "  SCL.1", "0v     ",
+  "GPIO. 7", "TxD    ",
+  "     0v", "RxD    ",
+  "GPIO. 0", "GPIO. 1",
+  "GPIO. 2", "0v     ",
+  "GPIO. 3", "GPIO. 4",
+  "   3.3v", "GPIO. 5",
+  "   MOSI", "0v     ",
+  "   MISO", "GPIO. 6",
+  "   SCLK", "CE0    ",
+  "     0v", "CE1    ",
+  "  SDA.0", "SCL.0  ",
+  "GPIO.21", "0v     ",
+  "GPIO.22", "GPIO.26",
+  "GPIO.23", "0v     ",
+  "GPIO.24", "GPIO.27",
+  "GPIO.25", "GPIO.28",
+  "     0v", "GPIO.29",
+       NULL, NULL,
+       NULL, NULL,
+       NULL, NULL,
+       NULL, NULL,
+       NULL, NULL,
+  "GPIO.17", "GPIO.18",
+  "GPIO.19", "GPIO.20",
+   NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
+} ;
+
+
+/*
+ * readallPhys:
+ *	Given a physical pin output the data on it and the next pin:
+ *| BCM | wPi |   Name  | Mode | Val| Physical |Val | Mode | Name    | wPi | BCM |
+ *********************************************************************************
+ */
+
+static void readallPhys (int physPin)
+{
+  int pin ;
+
+  if (physPinToGpio (physPin) == -1)
+    printf (" |     |    ") ;
+  else
+    printf (" | %3d | %3d", physPinToGpio (physPin), physToWpi [physPin]) ;
+
+  printf (" | %s", physNames [physPin]) ;
+
+  if (physToWpi [physPin] == -1)
+    printf (" |      |  ") ;
+  else
+  {
+    /**/ if (wpMode == WPI_MODE_GPIO)
+      pin = physPinToGpio (physPin) ;
+    else if (wpMode == WPI_MODE_PHYS)
+      pin = physPin ;
+    else
+      pin = physToWpi [physPin] ;
+
+    printf (" | %4s", alts [getAlt (pin)]) ;
+    printf (" | %d", digitalRead (pin)) ;
+  }
+
+// Pin numbers:
+
+  printf (" | %2d", physPin) ;
+  ++physPin ;
+  printf (" || %-2d", physPin) ;
+
+// Same, reversed
+
+  if (physToWpi [physPin] == -1)
+    printf (" |   |     ") ;
+  else
+  {
+    /**/ if (wpMode == WPI_MODE_GPIO)
+      pin = physPinToGpio (physPin) ;
+    else if (wpMode == WPI_MODE_PHYS)
+      pin = physPin ;
+    else
+      pin = physToWpi [physPin] ;
+
+    printf (" | %d", digitalRead (pin)) ;
+    printf (" | %-4s", alts [getAlt (pin)]) ;
+  }
+
+  printf (" | %-5s", physNames [physPin]) ;
+
+  if (physToWpi     [physPin] == -1)
+    printf (" |     |    ") ;
+  else
+    printf (" | %-3d | %-3d", physToWpi [physPin], physPinToGpio (physPin)) ;
+
+  printf (" |\n") ;
+}
+
+
+void cmReadall (void)
+{
+  int pin ;
+
+  printf ("+-----+------+-------+      +-----+------+-------+\n") ;
+  printf ("| Pin | Mode | Value |      | Pin | Mode | Value |\n") ;
+  printf ("+-----+------+-------+      +-----+------+-------+\n") ;
+
+  for (pin = 0 ; pin < 28 ; ++pin)
+  {
+    printf ("| %3d ", pin) ;
+    printf ("| %-4s ", alts [getAlt (pin)]) ;
+    printf ("| %s  ", digitalRead (pin) == HIGH ? "High" : "Low ") ;
+    printf ("|      ") ;
+    printf ("| %3d ", pin + 28) ;
+    printf ("| %-4s ", alts [getAlt (pin + 28)]) ;
+    printf ("| %s  ", digitalRead (pin + 28) == HIGH ? "High" : "Low ") ;
+    printf ("|\n") ;
+  }
+
+  printf ("+-----+------+-------+      +-----+------+-------+\n") ;
+}
+
+
+/*
+ * abReadall:
+ *	Read all the pins on the model A or B.
+ *********************************************************************************
+ */
+
+void abReadall (int model, int rev)
+{
+  int pin ;
+  char *type ;
+
+  if (model == PI_MODEL_A)
+    type = " A" ;
+  else
+    if (rev == PI_VERSION_2)
+      type = "B2" ;
+    else
+      type = "B1" ;
+
+  printf (" +-----+-----+---------+------+---+-Model %s-+---+------+---------+-----+-----+\n", type) ;
+  printf (" | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |\n") ;
+  printf (" +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+\n") ;
+  for (pin = 1 ; pin <= 26 ; pin += 2)
+    readallPhys (pin) ;
+
+  if (rev == PI_VERSION_2) // B version 2
+  {
+    printf (" +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+\n") ;
+    for (pin = 51 ; pin <= 54 ; pin += 2)
+      readallPhys (pin) ;
+  }
+
+  printf (" +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+\n") ;
+  printf (" | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |\n") ;
+  printf (" +-----+-----+---------+------+---+-Model %s-+---+------+---------+-----+-----+\n", type) ;
+}
+
+
+/*
+ * piPlusReadall:
+ *	Read all the pins on the model A+ or the B+
+ *********************************************************************************
+ */
+
+static void plus2header (int model)
+{
+  /**/ if (model == PI_MODEL_AP)
+    printf (" +-----+-----+---------+------+---+--A Plus--+---+------+---------+-----+-----+\n") ;
+  else if (model == PI_MODEL_BP)
+    printf (" +-----+-----+---------+------+---+--B Plus--+---+------+---------+-----+-----+\n") ;
+  else if (model == PI_MODEL_ZERO)
+    printf (" +-----+-----+---------+------+---+-Pi Zero--+---+------+---------+-----+-----+\n") ;
+  else
+    printf (" +-----+-----+---------+------+---+---Pi 2---+---+------+---------+-----+-----+\n") ;
+}
+
+
+void piPlusReadall (int model)
+{
+  int pin ;
+
+  plus2header (model) ;
+
+  printf (" | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |\n") ;
+  printf (" +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+\n") ;
+  for (pin = 1 ; pin <= 40 ; pin += 2)
+    readallPhys (pin) ;
+  printf (" +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+\n") ;
+  printf (" | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |\n") ;
+
+  plus2header (model) ;
+}
+
+
+void doReadall (void)
+{
+  int model, rev, mem, maker, overVolted ;
+
+  if (wiringPiNodes != NULL)	// External readall
+  {
+    doReadallExternal () ;
+    return ;
+  }
+
+  piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
+
+  /**/ if ((model == PI_MODEL_A) || (model == PI_MODEL_B))
+    abReadall (model, rev) ;
+  else if ((model == PI_MODEL_BP) || (model == PI_MODEL_AP) || (model == PI_MODEL_2) || (model == PI_MODEL_ZERO))
+    piPlusReadall (model) ;
+  else if (model == PI_MODEL_CM)
+    cmReadall () ;
+  else
+    printf ("Oops - unable to determine board type... model: %d\n", model) ;
+}

gpio/version.h

@@ -0,0 +1 @@
+#define VERSION "2.31"

newVersion

@@ -0,0 +1,43 @@
+#!/bin/sh -e
+#
+# newVersion:
+#	Utility to create the version.h include file for the gpio command.
+#	and the Debian package
+#
+#	Copyright (c) 2012-2015 Gordon Henderson
+#################################################################################
+# This file is part of wiringPi:
+#	Wiring Compatable library for the Raspberry Pi
+#
+#    wiringPi is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    wiringPi is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public License
+#    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+#################################################################################
+
+echo Updating to version: `cat VERSION`
+
+rm -f gpio/version.h
+echo "#define VERSION \"`cat VERSION`\"" > gpio/version.h
+
+rm -f debian-template/wiringPi/DEBIAN/control
+cat > debian-template/wiringPi/DEBIAN/control <<EOF
+Package: wiringpi
+Version: `cat VERSION`
+Section: libraries
+Priority: optional
+Architecture: armhf
+Depends: libc6
+Maintainer: Gordon Henderson <projects@drogon.net>
+Description: The wiringPi libraries, headers and gpio command
+  Libraries to allow GPIO access on a Raspberry Pi from C and C++
+  programs as well as from the command-line
+EOF

pins/Makefile

@@ -0,0 +1,22 @@
+
+SRC	=	pins.tex
+
+ifneq ($V,1)
+Q ?= @
+endif
+
+
+all:		${SRC}
+	$Q echo	Generating DVI
+	$Q latex  pins.tex
+
+pins.dvi:	pins.tex
+	$Q latex  pins.tex
+
+pdf:	pins.dvi
+	$Q dvipdf pins.dvi
+
+
+.PHONY:	clean
+clean:
+	$Q rm -f *.dvi *.aux *.log *.ps *.toc *.bak *~

pins/pins.tex

@@ -0,0 +1,116 @@
+\documentclass[12pt,a4paper]{article}
+\parskip 1ex
+\parindent 0em
+\thispagestyle{empty}
+\pagestyle{plain}
+\pagenumbering{arabic}
+\setlength{\topmargin}{0pt}
+\setlength{\headheight}{0pt}
+\setlength{\headsep}{0pt}
+\setlength{\topskip}{0pt}
+\setlength{\textheight}{240mm}
+\setlength{\footskip}{5ex}
+\setlength{\oddsidemargin}{0pt}
+\setlength{\evensidemargin}{0pt}
+\setlength{\textwidth}{160mm}
+\usepackage[dvips]{graphics,color}
+\usepackage{helvet}
+\renewcommand{\familydefault}{\sfdefault}
+\begin{document}
+\begin{sffamily}
+\definecolor{rtb-black}{rgb}  {0.0, 0.0, 0.0}
+\definecolor{rtb-navy}{rgb}   {0.0, 0.0, 0.5}
+\definecolor{rtb-green}{rgb}  {0.0, 0.5, 0.0}
+\definecolor{rtb-teal}{rgb}   {0.0, 0.5, 0.5}
+\definecolor{rtb-maroon}{rgb} {0.5, 0.0, 0.0}
+\definecolor{rtb-purple}{rgb} {0.5, 0.0, 0.5}
+\definecolor{rtb-olive}{rgb}  {0.5, 0.5, 0.0}
+\definecolor{rtb-silver}{rgb} {0.7, 0.7, 0.7}
+\definecolor{rtb-grey}{rgb}   {0.5, 0.5, 0.5}
+\definecolor{rtb-blue}{rgb}   {0.0, 0.0, 1.0}
+\definecolor{rtb-lime}{rgb}   {0.0, 1.0, 0.0}
+\definecolor{rtb-aqua}{rgb}   {0.0, 1.0, 1.0}
+\definecolor{rtb-red}{rgb}    {1.0, 0.0, 0.0}
+\definecolor{rtb-fuchsia}{rgb}{1.0, 0.0, 1.0}
+\definecolor{rtb-yellow}{rgb} {1.0, 1.0, 0.0}
+\definecolor{rtb-white}{rgb}  {1.0, 1.0, 1.0}
+
+\begin{center}
+\bfseries{WiringPi: GPIO Pin Numbering Tables}\\
+\tt{http://wiringpi.com/}
+\end{center}
+
+\begin{center}
+\begin{tabular}{|c|c|c||p{8mm}|p{8mm}||c|c|c|c|}
+\hline
+\multicolumn{8}{|c|}{\bfseries{P1: The Main GPIO connector}}\\
+\hline
+\hline
+WiringPi Pin	& BCM GPIO	& Name	& \multicolumn{2}{|c||}{Header}	& Name	& BCM GPIO	& WiringPi Pin\\
+\hline
+\hline
+	& 			& \textcolor{rtb-red}{3.3v}	& \raggedleft{1} &  2 & \textcolor{rtb-maroon}{5v}	& 	& \\
+\hline
+8	& Rv1:0 - Rv2:2		& \textcolor{rtb-aqua}{SDA}	& \raggedleft{3} &  4 & \textcolor{rtb-maroon}{5v}	& 	& \\
+\hline
+9	& Rv1:1 - Rv2:3		& \textcolor{rtb-aqua}{SCL}	& \raggedleft{5} &  6 & \textcolor{rtb-black}{0v}	& 	& \\
+\hline
+7	& 4			& \textcolor{rtb-green}{GPIO7}	& \raggedleft{7} &  8 & \textcolor{rtb-yellow}{TxD}	& 14    & 15\\
+\hline
+	& 			& \textcolor{rtb-black}{0v}	& \raggedleft{9} & 10 & \textcolor{rtb-yellow}{RxD}	& 15	& 16\\
+\hline
+0	& 17			& \textcolor{rtb-green}{GPIO0}	& \raggedleft{11} & 12 & \textcolor{rtb-green}{GPIO1}	& 18	& 1\\
+\hline
+2	& Rv1:21 - Rv2:27	& \textcolor{rtb-green}{GPIO2}	& \raggedleft{13} & 14 & \textcolor{rtb-black}{0v}	& 	& \\
+\hline
+3	& 22			& \textcolor{rtb-green}{GPIO3}	& \raggedleft{15} & 16 & \textcolor{rtb-green}{GPIO4}	& 23	& 4\\
+\hline
+	& 			& \textcolor{rtb-red}{3.3v}	& \raggedleft{17} & 18 & \textcolor{rtb-green}{GPIO5}	& 24	& 5\\
+\hline
+12	& 10			& \textcolor{rtb-teal}{MOSI}	& \raggedleft{19} & 20 & \textcolor{rtb-black}{0v}	& 	& \\
+\hline
+13	& 9			& \textcolor{rtb-teal}{MISO}	& \raggedleft{21} & 22 & \textcolor{rtb-green}{GPIO6}	& 25	& 6\\
+\hline
+14	& 11			& \textcolor{rtb-teal}{SCLK}	& \raggedleft{23} & 24 & \textcolor{rtb-teal}{CE0}	& 8	& 10\\
+\hline
+	& 			& \textcolor{rtb-black}{0v}	& \raggedleft{25} & 26 & \textcolor{rtb-teal}{CE1}	& 7	& 11\\
+\hline
+\hline
+WiringPi Pin	& BCM GPIO	& Name	& \multicolumn{2}{|c||}{Header}	& Name	& BCM GPIO	& WiringPi Pin\\
+\hline
+\end{tabular}
+\end{center}
+
+Note the differences between Revision 1 and Revision 2 Raspberry
+Pi's. The Revision 2 is readily identifiable by the presence of the 2
+mounting holes.
+
+The revision 2 Raspberry Pi has an additional GPIO connector, P5, which is next to the main P1 GPIO
+connector:
+
+\begin{center}
+\begin{tabular}{|c|c|c||p{8mm}|p{8mm}||c|c|c|c|}
+\hline
+\multicolumn{8}{|c|}{\bfseries{P5: Secondary GPIO connector (Rev. 2 Pi only)}}\\
+\hline
+\hline
+WiringPi Pin	& BCM GPIO	& Name	& \multicolumn{2}{|c||}{Header}	& Name	& BCM GPIO	& WiringPi Pin\\
+\hline
+\hline
+	& 		& \textcolor{rtb-maroon}{5v}	& \raggedleft{1} &  2 & \textcolor{rtb-red}{3.3v}	& 	&	\\
+\hline
+17	& 28		& \textcolor{rtb-green}{GPIO8}	& \raggedleft{3} &  4 & \textcolor{rtb-green}{GPIO9}	& 29	& 18	\\
+\hline
+19	& 30		& \textcolor{rtb-green}{GPIO10}	& \raggedleft{5} &  6 & \textcolor{rtb-green}{GPIO11}	& 31	& 20	\\
+\hline
+	& 		& \textcolor{rtb-black}{0v}	& \raggedleft{7} &  8 & \textcolor{rtb-black}{0v}	& 	&	\\
+\hline
+\hline
+WiringPi Pin	& BCM GPIO	& Name	& \multicolumn{2}{|c||}{Header}	& Name	& BCM GPIO	& WiringPi Pin\\
+\hline
+\end{tabular}
+\end{center}
+
+
+\end{sffamily}
+\end{document}

wiringPi/Makefile

@@ -1,8 +1,8 @@
-# ;
+#
 # Makefile:
 #	wiringPi - Wiring Compatable library for the Raspberry Pi
 #
-#	Copyright (c) 2012 Gordon Henderson
+#	Copyright (c) 2012-2015 Gordon Henderson
 #################################################################################
 # This file is part of wiringPi:
 #	https://projects.drogon.net/raspberry-pi/wiringpi/
@@ -21,12 +21,15 @@
 #    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
 #################################################################################
 
-DYN_VERS_MAJ=1
-DYN_VERS_MIN=0
+VERSION=$(shell cat ../VERSION)
+DESTDIR?=/usr
+PREFIX?=/local
+
+LDCONFIG?=ldconfig
 
-VERSION=$(DYN_VERS_MAJ).$(DYN_VERS_MIN)
-DESTDIR=/usr
-PREFIX=/local
+ifneq ($V,1)
+Q ?= @
+endif
 
 STATIC=libwiringPi.a
 DYNAMIC=libwiringPi.so.$(VERSION)
@@ -35,118 +38,145 @@ DYNAMIC=libwiringPi.so.$(VERSION)
 DEBUG	= -O2
 CC	= gcc
 INCLUDE	= -I.
-CFLAGS	= $(DEBUG) -Wall $(INCLUDE) -Winline -pipe -fPIC
+DEFS	= -D_GNU_SOURCE
+CFLAGS	= $(DEBUG) $(DEFS) -Wformat=2 -Wall -Winline $(INCLUDE) -pipe -fPIC
 
 LIBS    =
 
-# Should not alter anything below this line
 ###############################################################################
 
-SRC	=	wiringPi.c wiringPiFace.c wiringSerial.c wiringShift.c	\
-		gertboard.c						\
-		piNes.c							\
-		lcd.c piHiPri.c piThread.c				\
-		wiringPiSPI.c 						\
-		softPwm.c softServo.c softTone.c
+SRC	=	wiringPi.c						\
+		wiringSerial.c wiringShift.c				\
+		piHiPri.c piThread.c					\
+		wiringPiSPI.c wiringPiI2C.c				\
+		softPwm.c softTone.c					\
+		mcp23008.c mcp23016.c mcp23017.c			\
+		mcp23s08.c mcp23s17.c					\
+		sr595.c							\
+		pcf8574.c pcf8591.c					\
+		mcp3002.c mcp3004.c mcp4802.c mcp3422.c			\
+		max31855.c max5322.c					\
+		sn3218.c						\
+		drcSerial.c						\
+		wpiExtensions.c
+
+HEADERS =	wiringPi.h						\
+		wiringSerial.h wiringShift.h				\
+		wiringPiSPI.h wiringPiI2C.h				\
+		softPwm.h softTone.h					\
+		mcp23008.h mcp23016.h mcp23017.h			\
+		mcp23s08.h mcp23s17.h					\
+		sr595.h							\
+		pcf8574.h pcf8591.h					\
+		mcp3002.h mcp3004.h mcp4802.h mcp3422.h			\
+		max31855.h max5322.h					\
+		sn3218.h						\
+		drcSerial.h						\
+		wpiExtensions.h 
 
-SRC_I2C	=	wiringPiI2C.c
 
 OBJ	=	$(SRC:.c=.o)
 
-OBJ_I2C	=	$(SRC_I2C:.c=.o)
-
 all:		$(DYNAMIC)
 
 static:		$(STATIC)
 
 $(STATIC):	$(OBJ)
-	@echo "[Link (Static)]"
-	@ar rcs $(STATIC) $(OBJ)
-	@ranlib $(STATIC)
+	$Q echo "[Link (Static)]"
+	$Q ar rcs $(STATIC) $(OBJ)
+	$Q ranlib $(STATIC)
 #	@size   $(STATIC)
 
 $(DYNAMIC):	$(OBJ)
-	@echo "[Link (Dynamic)]"
-	@$(CC) -shared -Wl,-soname,libwiringPi.so.1 -o libwiringPi.so.1.0 -lpthread $(OBJ)
-
-i2c:	$(OBJ) $(OBJ_I2C)
-	@echo "[Link (Dynamic + I2C)]"
-	@$(CC) -shared -Wl,-soname,libwiringPi.so.1 -o libwiringPi.so.1.0 -lpthread $(OBJ) $(OBJ_I2C)
+	$Q echo "[Link (Dynamic)]"
+	$Q $(CC) -shared -Wl,-soname,libwiringPi.so$(WIRINGPI_SONAME_SUFFIX) -o libwiringPi.so.$(VERSION) -lpthread $(OBJ)
 
 .c.o:
-	@echo [Compile] $<
-	@$(CC) -c $(CFLAGS) $< -o $@
+	$Q echo [Compile] $<
+	$Q $(CC) -c $(CFLAGS) $< -o $@
+
 
-.PHONEY:	clean
+.PHONY:	clean
 clean:
-	rm -f $(OBJ) $(OBJ_I2C) *~ core tags Makefile.bak libwiringPi.*
+	$Q echo "[Clean]"
+	$Q rm -f $(OBJ) $(OBJ_I2C) *~ core tags Makefile.bak libwiringPi.*
 
-.PHONEY:	tags
+.PHONY:	tags
 tags:	$(SRC)
-	@echo [ctags]
-	@ctags $(SRC)
+	$Q echo [ctags]
+	$Q ctags $(SRC)
+
 
-.PHONEY:	install
+.PHONY:	install
 install:	$(DYNAMIC)
-	@echo "[Install]"
-	@install -m 0755 -d			$(DESTDIR)$(PREFIX)/lib
-	@install -m 0755 -d			$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 wiringPi.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 wiringSerial.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 wiringShift.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 gertboard.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 piNes.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 softPwm.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 softServo.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 softTone.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 lcd.h			$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 wiringPiSPI.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0644 wiringPiI2C.h		$(DESTDIR)$(PREFIX)/include
-	@install -m 0755 libwiringPi.so.$(VERSION)		  $(DESTDIR)$(PREFIX)/lib
-	@ln -sf $(DESTDIR)$(PREFIX)/lib/libwiringPi.so.$(VERSION) $(DESTDIR)/lib/libwiringPi.so
-	@ln -sf $(DESTDIR)$(PREFIX)/lib/libwiringPi.so.$(VERSION) $(DESTDIR)/lib/libwiringPi.so.1
-	@ldconfig
-
-.PHONEY:	install-static
+	$Q echo "[Install Headers]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/include
+	$Q install -m 0644 $(HEADERS)					$(DESTDIR)$(PREFIX)/include
+	$Q echo "[Install Dynamic Lib]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/lib
+	$Q install -m 0755 libwiringPi.so.$(VERSION)			$(DESTDIR)$(PREFIX)/lib/libwiringPi.so.$(VERSION)
+	$Q ln -sf $(DESTDIR)$(PREFIX)/lib/libwiringPi.so.$(VERSION)	$(DESTDIR)/lib/libwiringPi.so
+	$Q $(LDCONFIG)
+
+.PHONY:	install-static
 install-static:	$(STATIC)
-	@echo "[Install Static]"
-	@install -m 0755 libwiringPi.a		$(DESTDIR)$(PREFIX)/lib
-
-.PHONEY:	uninstall
+	$Q echo "[Install Headers]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/include
+	$Q install -m 0644 $(HEADERS)					$(DESTDIR)$(PREFIX)/include
+	$Q echo "[Install Static Lib]"
+	$Q install -m 0755 -d						$(DESTDIR)$(PREFIX)/lib
+	$Q install -m 0755 libwiringPi.a					$(DESTDIR)$(PREFIX)/lib
+
+.PHONY:	install-deb
+install-deb:	$(DYNAMIC)
+	$Q echo "[Install Headers: deb]"
+	$Q install -m 0755 -d							~/wiringPi/debian-template/wiringPi/usr/include
+	$Q install -m 0644 $(HEADERS)						~/wiringPi/debian-template/wiringPi/usr/include
+	$Q echo "[Install Dynamic Lib: deb]"
+	install -m 0755 -d							~/wiringPi/debian-template/wiringPi/usr/lib
+	install -m 0755 libwiringPi.so.$(VERSION)				~/wiringPi/debian-template/wiringPi/usr/lib/libwiringPi.so.$(VERSION)
+	ln -sf ~/wiringPi/debian-template/wiringPi/usr/lib/libwiringPi.so.$(VERSION)	~/wiringPi/debian-template/wiringPi/usr/lib/libwiringPi.so
+
+.PHONY:	uninstall
 uninstall:
-	@echo "[UnInstall]"
-	@rm -f $(DESTDIR)$(PREFIX)/include/wiringPi.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/wiringSerial.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/wiringShift.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/gertboard.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/piNes.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/softPwm.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/softServo.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/softTone.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/lcd.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/wiringPiSPI.h
-	@rm -f $(DESTDIR)$(PREFIX)/include/wiringPiI2C.h
-	@rm -f $(DESTDIR)$(PREFIX)/lib/libwiringPi.*
-	@ldconfig
-
-
-.PHONEY:	depend
+	$Q echo "[UnInstall]"
+	$Q cd $(DESTDIR)$(PREFIX)/include/ && rm -f $(HEADERS)
+	$Q cd $(DESTDIR)$(PREFIX)/lib/     && rm -f libwiringPi.*
+	$Q $(LDCONFIG)
+
+
+.PHONY:	depend
 depend:
 	makedepend -Y $(SRC) $(SRC_I2C)
 
 # DO NOT DELETE
 
-wiringPi.o: wiringPi.h
-wiringPiFace.o: wiringPi.h
+wiringPi.o: softPwm.h softTone.h wiringPi.h
 wiringSerial.o: wiringSerial.h
 wiringShift.o: wiringPi.h wiringShift.h
-gertboard.o: wiringPiSPI.h gertboard.h
-piNes.o: wiringPi.h piNes.h
-lcd.o: wiringPi.h lcd.h
 piHiPri.o: wiringPi.h
 piThread.o: wiringPi.h
-wiringPiSPI.o: wiringPiSPI.h
+wiringPiSPI.o: wiringPi.h wiringPiSPI.h
+wiringPiI2C.o: wiringPi.h wiringPiI2C.h
 softPwm.o: wiringPi.h softPwm.h
-softServo.o: wiringPi.h softServo.h
 softTone.o: wiringPi.h softTone.h
-wiringPiI2C.o: wiringPi.h wiringPiI2C.h
+mcp23008.o: wiringPi.h wiringPiI2C.h mcp23x0817.h mcp23008.h
+mcp23016.o: wiringPi.h wiringPiI2C.h mcp23016.h mcp23016reg.h
+mcp23017.o: wiringPi.h wiringPiI2C.h mcp23x0817.h mcp23017.h
+mcp23s08.o: wiringPi.h wiringPiSPI.h mcp23x0817.h mcp23s08.h
+mcp23s17.o: wiringPi.h wiringPiSPI.h mcp23x0817.h mcp23s17.h
+sr595.o: wiringPi.h sr595.h
+pcf8574.o: wiringPi.h wiringPiI2C.h pcf8574.h
+pcf8591.o: wiringPi.h wiringPiI2C.h pcf8591.h
+mcp3002.o: wiringPi.h wiringPiSPI.h mcp3002.h
+mcp3004.o: wiringPi.h wiringPiSPI.h mcp3004.h
+mcp4802.o: wiringPi.h wiringPiSPI.h mcp4802.h
+mcp3422.o: wiringPi.h wiringPiI2C.h mcp3422.h
+max31855.o: wiringPi.h wiringPiSPI.h max31855.h
+max5322.o: wiringPi.h wiringPiSPI.h max5322.h
+sn3218.o: wiringPi.h wiringPiI2C.h sn3218.h
+drcSerial.o: wiringPi.h wiringSerial.h drcSerial.h
+wpiExtensions.o: wiringPi.h mcp23008.h mcp23016.h mcp23017.h mcp23s08.h
+wpiExtensions.o: mcp23s17.h sr595.h pcf8574.h pcf8591.h mcp3002.h mcp3004.h
+wpiExtensions.o: mcp4802.h mcp3422.h max31855.h max5322.h sn3218.h
+wpiExtensions.o: drcSerial.h wpiExtensions.h

wiringPi/drcSerial.c

@@ -0,0 +1,201 @@
+/*
+ * drcSerial.c:
+ *	Extend wiringPi with the DRC Serial protocol (e.g. to Arduino)
+ *	Copyright (c) 2013 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <errno.h>
+
+#include "wiringPi.h"
+#include "wiringSerial.h"
+
+#include "drcSerial.h"
+
+#ifndef	TRUE
+#  define	TRUE	(1==1)
+#  define	FALSE	(1==2)
+#endif
+
+
+/*
+ * myPinMode:
+ *	Change the pin mode on the remote DRC device
+ *********************************************************************************
+ */
+
+static void myPinMode (struct wiringPiNodeStruct *node, int pin, int mode)
+{
+  /**/ if (mode == OUTPUT)
+    serialPutchar (node->fd, 'o') ;       // Input
+  else if (mode == PWM_OUTPUT)
+    serialPutchar (node->fd, 'p') ;       // PWM
+  else
+    serialPutchar (node->fd, 'i') ;       // Default to input
+
+  serialPutchar (node->fd, pin - node->pinBase) ;
+}
+
+
+/*
+ * myPullUpDnControl:
+ *	ATmegas only have pull-up's on of off. No pull-downs.
+ *********************************************************************************
+ */
+
+static void myPullUpDnControl (struct wiringPiNodeStruct *node, int pin, int mode)
+{
+
+// Force pin into input mode
+
+  serialPutchar (node->fd, 'i' ) ;
+  serialPutchar (node->fd, pin - node->pinBase) ;
+
+  /**/ if (mode == PUD_UP)
+  {
+    serialPutchar (node->fd, '1') ;
+    serialPutchar (node->fd, pin - node->pinBase) ;
+  }
+  else if (mode == PUD_OFF)
+  {
+    serialPutchar (node->fd, '0') ;
+    serialPutchar (node->fd, pin - node->pinBase) ;
+  }
+}
+
+
+/*
+ * myDigitalWrite:
+ *********************************************************************************
+ */
+
+static void myDigitalWrite (struct wiringPiNodeStruct *node, int pin, int value)
+{
+  serialPutchar (node->fd, value == 0 ? '0' : '1') ;
+  serialPutchar (node->fd, pin - node->pinBase) ;
+}
+
+
+/*
+ * myPwmWrite:
+ *********************************************************************************
+ */
+
+static void myPwmWrite (struct wiringPiNodeStruct *node, int pin, int value)
+{
+  serialPutchar (node->fd, 'v') ;
+  serialPutchar (node->fd, pin - node->pinBase) ;
+  serialPutchar (node->fd, value & 0xFF) ;
+}
+
+
+/*
+ * myAnalogRead:
+ *********************************************************************************
+ */
+
+static int myAnalogRead (struct wiringPiNodeStruct *node, int pin)
+{
+  int vHi, vLo ;
+
+  serialPutchar (node->fd, 'a') ;
+  serialPutchar (node->fd, pin - node->pinBase) ;
+  vHi = serialGetchar (node->fd) ;
+  vLo = serialGetchar (node->fd) ;
+
+  return (vHi << 8) | vLo ;
+}
+
+
+/*
+ * myDigitalRead:
+ *********************************************************************************
+ */
+
+static int myDigitalRead (struct wiringPiNodeStruct *node, int pin)
+{
+  serialPutchar (node->fd, 'r') ; // Send read command
+  serialPutchar (node->fd, pin - node->pinBase) ;
+  return (serialGetchar (node->fd) == '0') ? 0 : 1 ;
+}
+
+
+/*
+ * drcSetup:
+ *	Create a new instance of an DRC GPIO interface.
+ *	Could be a variable nunber of pins here - we might not know in advance
+ *	if it's an ATmega with 14 pins, or something with less or more!
+ *********************************************************************************
+ */
+
+int drcSetupSerial (const int pinBase, const int numPins, const char *device, const int baud)
+{
+  int fd ;
+  int ok, tries ;
+  time_t then ;
+  struct wiringPiNodeStruct *node ;
+
+  if ((fd = serialOpen (device, baud)) < 0)
+    return wiringPiFailure (WPI_ALMOST, "Unable to open DRC device (%s): %s", device, strerror (errno)) ;
+
+  delay (10) ;	// May need longer if it's an Uno that reboots on the open...
+
+// Flush any pending input
+
+  while (serialDataAvail (fd))
+    (void)serialGetchar (fd) ;
+
+  ok = FALSE ;
+  for (tries = 1 ; (tries < 5) && (!ok) ; ++tries)
+  {
+    serialPutchar (fd, '@') ;		// Ping
+    then = time (NULL) + 2 ;
+    while (time (NULL) < then)
+      if (serialDataAvail (fd))
+      {
+        if (serialGetchar (fd) == '@')
+        {
+          ok = TRUE ;
+          break ;
+        }
+      }
+  }
+
+  if (!ok)
+  {
+    serialClose (fd) ;
+    return wiringPiFailure (WPI_FATAL, "Unable to communicate with DRC serial device") ;
+  }
+
+  node = wiringPiNewNode (pinBase, numPins) ;
+
+  node->fd              = fd ;
+  node->pinMode         = myPinMode ;
+  node->pullUpDnControl = myPullUpDnControl ;
+  node->analogRead      = myAnalogRead ;
+  node->digitalRead     = myDigitalRead ;
+  node->digitalWrite    = myDigitalWrite ;
+  node->pwmWrite        = myPwmWrite ;
+
+  return 0 ;
+}