shinys000114/WiringPi2-Python
1
0
Fork 0
mirror of git://soft.sys114.com/WiringPi2-Python synced 2025-12-19 02:58:41 +09:00
Code Issues Packages Projects Releases Wiki Activity

Updated to latest WiringPi

Browse Source
This commit is contained in:
Phil Howard
2014-07-18 11:48:01 +00:00
parent f388d58fbd
commit 2204176408
37 changed files with 5291 additions and 2573 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Makefile Normal file
View File

@@ -0,0 +1,8 @@
all: bindings
python setup.py build
bindings:
swig2.0 -python wiringpi.i
install:
sudo python setup.py install

3
WiringPi/People
View File

@@ -28,3 +28,6 @@ Xian Stannard
Andre Crone
Suggested the __WIRING_PI.H__ round wiringPi.h
Rik Teerling
Pointing out some silly mistooks in the I2C code...

48
WiringPi/build
View File

@@ -1,7 +1,6 @@
#!/bin/bash
#!/bin/sh
check-make-ok()
{
check_make_ok() {
if [ $? != 0 ]; then
echo ""
echo "Make Failed..."
@@ -28,6 +27,8 @@ if [ x$1 = "xclean" ]; then
echo -n "PiFace: " ; make clean
cd ../q2w
echo -n "Quick2Wire: " ; make clean
cd ../PiGlow
echo -n "PiGlow: " ; make clean
exit
fi
@@ -50,27 +51,39 @@ fi
echo "WiringPi Library"
cd wiringPi
sudo make uninstall
make
check-make-ok
sudo make install
check-make-ok
if [ x$1 = "xstatic" ]; then
make static
check_make_ok
sudo make install-static
else
make
check_make_ok
sudo make install
fi
check_make_ok
echo
echo "WiringPi Devices Library"
cd ../devLib
sudo make uninstall
make
check-make-ok
sudo make install
check-make-ok
if [ x$1 = "xstatic" ]; then
make static
check_make_ok
sudo make install-static
else
make
check_make_ok
sudo make install
fi
check_make_ok
echo
echo "GPIO Utility"
cd ../gpio
make
check-make-ok
check_make_ok
sudo make install
check-make-ok
check_make_ok
# echo
# echo "Examples"
@@ -81,7 +94,10 @@ fi
echo
echo All Done.
echo ""
echo "NOTE: This is wiringPi v2, and if you need to use the lcd, Piface,"
echo " Gertboard, MaxDetext, etc. routines then you must change your"
echo " compile scripts to add -lwiringPiDev"
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 ""

6
WiringPi/devLib/Makefile
View File

@@ -42,7 +42,8 @@ LIBS =
SRC = ds1302.c maxdetect.c piNes.c \
gertboard.c piFace.c \
lcd128x64.c lcd.c
lcd128x64.c lcd.c \
piGlow.c
OBJ = $(SRC:.c=.o)
@@ -86,6 +87,7 @@ install-headers:
@install -m 0644 piFace.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 lcd128x64.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 lcd.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 piGlow.h $(DESTDIR)$(PREFIX)/include
.PHONEY: install
install: $(DYNAMIC) install-headers
@@ -111,6 +113,7 @@ uninstall:
@rm -f $(DESTDIR)$(PREFIX)/include/piFace.h
@rm -f $(DESTDIR)$(PREFIX)/include/lcd128x64.h
@rm -f $(DESTDIR)$(PREFIX)/include/lcd.h
@rm -f $(DESTDIR)$(PREFIX)/include/piGlow.h
@rm -f $(DESTDIR)$(PREFIX)/lib/libwiringPiDev.*
@ldconfig
@@ -128,3 +131,4 @@ gertboard.o: gertboard.h
piFace.o: piFace.h
lcd128x64.o: font.h lcd128x64.h
lcd.o: lcd.h
piGlow.o: piGlow.h

11
WiringPi/examples/Makefile
View File

@@ -36,13 +36,14 @@ LDLIBS = -lwiringPi -lwiringPiDev -lpthread -lm
###############################################################################
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 \
rht03.c
rht03.c piglow.c
OBJ = $(SRC:.c=.o)
@@ -63,6 +64,10 @@ blink8: blink8.o
@echo [link]
@$(CC) -o $@ blink8.o $(LDFLAGS) $(LDLIBS)
blink12drcs: blink12drcs.o
@echo [link]
@$(CC) -o $@ blink12drcs.o $(LDFLAGS) $(LDLIBS)
blink12: blink12.o
@echo [link]
@$(CC) -o $@ blink12.o $(LDFLAGS) $(LDLIBS)
@@ -139,6 +144,10 @@ ds1302: ds1302.o
@echo [link]
@$(CC) -o $@ ds1302.o $(LDFLAGS) $(LDLIBS)
piglow: piglow.o
@echo [link]
@$(CC) -o $@ piglow.o $(LDFLAGS) $(LDLIBS)
.c.o:
@echo [CC] $<

79
WiringPi/examples/PiGlow/Makefile Normal file
View File

@@ -0,0 +1,79 @@
#
# 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/>.
#################################################################################
#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
@echo [link]
@$(CC) -o $@ piGlow0.o $(LDFLAGS) $(LDLIBS)
piGlow1: piGlow1.o
@echo [link]
@$(CC) -o $@ piGlow1.o $(LDFLAGS) $(LDLIBS)
piglow: piglow.o
@echo [link]
@$(CC) -o $@ piglow.o $(LDFLAGS) $(LDLIBS)
.c.o:
@echo [CC] $<
@$(CC) -c $(CFLAGS) $< -o $@
clean:
@echo "[Clean]"
@rm -f $(OBJ) *~ core tags $(BINS)
tags: $(SRC)
@echo [ctags]
@ctags $(SRC)
install: piglow
@echo Installing piglow into /usr/local/bin
@cp -a piglow /usr/local/bin/piglow
@chmod 755 /usr/local/bin/piglow
@echo Done. Remember to load the I2C drivers!
depend:
makedepend -Y $(SRC)
# DO NOT DELETE

51
WiringPi/examples/PiGlow/piGlow0.c Normal file
View File

@@ -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) ;
}
}

258
WiringPi/examples/PiGlow/piGlow1.c Normal file
View File

@@ -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 ;
}

176
WiringPi/examples/PiGlow/piglow.c Normal file
View File

@@ -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 ;
}

2
WiringPi/examples/blink.sh
View File

@@ -25,7 +25,7 @@
# LED Pin - wiringPi pin 0 is BCM_GPIO 17.
LED=0
PIN=0
gpio mode $PIN out

125
WiringPi/examples/blink12drcs.c Normal file
View File

@@ -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 ;
}

115
WiringPi/examples/blink6drcs.c Normal file
View File

@@ -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 ;
}

238
WiringPi/examples/ds1302.c Normal file
View File

@@ -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 ;
}

5
WiringPi/examples/rht03.c
View File

@@ -56,6 +56,11 @@ int main (void)
{
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) ;
}
}

37
WiringPi/gpio/Makefile
View File

@@ -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-2013 Gordon Henderson
#################################################################################
# This file is part of wiringPi:
# Wiring Compatable library for the Raspberry Pi
@@ -22,20 +23,22 @@
# along with wiringPi. If not, see <http://www.gnu.org/licenses/>.
#################################################################################
DESTDIR=/usr
PREFIX=/local
#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
LDFLAGS = -L$(DESTDIR)$(PREFIX)/lib
LIBS = -lwiringPi -lwiringPiDev -lpthread -lm
# May not need to alter anything below this line
###############################################################################
SRC = gpio.c extensions.c
SRC = gpio.c extensions.c readall.c pins.c
OBJ = $(SRC:.c=.o)
@@ -49,32 +52,32 @@ gpio: $(OBJ)
@echo [Compile] $<
@$(CC) -c $(CFLAGS) $< -o $@
.PHONEY: clean
.PHONY: clean
clean:
@echo "[Clean]"
@rm -f $(OBJ) gpio *~ core tags *.bak
.PHONEY: tags
.PHONY: tags
tags: $(SRC)
@echo [ctags]
@ctags $(SRC)
.PHONEY: install
.PHONY: 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
@cp gpio $(DESTDIR)$(PREFIX)/bin
@chown root.root $(DESTDIR)$(PREFIX)/bin/gpio
@chmod 4755 $(DESTDIR)$(PREFIX)/bin/gpio
@mkdir -p $(DESTDIR)$(PREFIX)/man/man1
@cp gpio.1 $(DESTDIR)$(PREFIX)/man/man1
.PHONEY: uninstall
.PHONY: uninstall
uninstall:
@echo "[UnInstall]"
@rm -f /usr/local/bin/gpio
@rm -f /usr/local/man/man1/gpio.1
@rm -f $(DESTDIR)$(PREFIX)/bin/gpio
@rm -f $(DESTDIR)$(PREFIX)/man/man1/gpio.1
.PHONEY: depend
.PHONY: depend
depend:
makedepend -Y $(SRC)

286
WiringPi/gpio/extensions.c
View File

@@ -43,6 +43,14 @@
#include <sr595.h>
#include <pcf8591.h>
#include <pcf8574.h>
#include <max31855.h>
#include <max5322.h>
#include <mcp3002.h>
#include <mcp3004.h>
#include <mcp4802.h>
#include <mcp3422.h>
#include <sn3218.h>
#include <drcSerial.h>
#include "extensions.h"
@@ -92,6 +100,43 @@ static char *extractInt (char *progName, char *p, int *num)
}
/*
* extractStr:
* Check & return a string at the given location (prefixed by a :)
*********************************************************************************
*/
static char *extractStr (char *progName, char *p, char **str)
{
char *q, *r ;
if (*p != ':')
{
fprintf (stderr, "%s: colon expected\n", progName) ;
return NULL ;
}
++p ;
if (!isprint (*p))
{
fprintf (stderr, "%s: character expected\n", progName) ;
return NULL ;
}
q = p ;
while ((*q != 0) && (*q != ':'))
++q ;
*str = r = calloc (q - p + 2, 1) ; // Zeros it
while (p != q)
*r++ = *p++ ;
return p ;
}
/*
* doExtensionMcp23008:
@@ -330,6 +375,239 @@ static int doExtensionPcf8591 (char *progName, int pinBase, char *params)
}
/*
* doExtensionMax31855:
* Analog IO
* max31855:base:spiChan
*********************************************************************************
*/
static int doExtensionMax31855 (char *progName, int pinBase, char *params)
{
int spi ;
if ((params = extractInt (progName, params, &spi)) == NULL)
return FALSE ;
if ((spi < 0) || (spi > 1))
{
fprintf (stderr, "%s: SPI channel (%d) out of range\n", progName, spi) ;
return FALSE ;
}
max31855Setup (pinBase, spi) ;
return TRUE ;
}
/*
* doExtensionMcp3002:
* Analog IO
* mcp3002:base:spiChan
*********************************************************************************
*/
static int doExtensionMcp3002 (char *progName, int pinBase, char *params)
{
int spi ;
if ((params = extractInt (progName, params, &spi)) == NULL)
return FALSE ;
if ((spi < 0) || (spi > 1))
{
fprintf (stderr, "%s: SPI channel (%d) out of range\n", progName, spi) ;
return FALSE ;
}
mcp3002Setup (pinBase, spi) ;
return TRUE ;
}
/*
* doExtensionMcp3004:
* Analog IO
* mcp3004:base:spiChan
*********************************************************************************
*/
static int doExtensionMcp3004 (char *progName, int pinBase, char *params)
{
int spi ;
if ((params = extractInt (progName, params, &spi)) == NULL)
return FALSE ;
if ((spi < 0) || (spi > 1))
{
fprintf (stderr, "%s: SPI channel (%d) out of range\n", progName, spi) ;
return FALSE ;
}
mcp3004Setup (pinBase, spi) ;
return TRUE ;
}
/*
* doExtensionMax5322:
* Analog O
* max5322:base:spiChan
*********************************************************************************
*/
static int doExtensionMax5322 (char *progName, int pinBase, char *params)
{
int spi ;
if ((params = extractInt (progName, params, &spi)) == NULL)
return FALSE ;
if ((spi < 0) || (spi > 1))
{
fprintf (stderr, "%s: SPI channel (%d) out of range\n", progName, spi) ;
return FALSE ;
}
max5322Setup (pinBase, spi) ;
return TRUE ;
}
/*
* doExtensionMcp4802:
* Analog IO
* mcp4802:base:spiChan
*********************************************************************************
*/
static int doExtensionMcp4802 (char *progName, int pinBase, char *params)
{
int spi ;
if ((params = extractInt (progName, params, &spi)) == NULL)
return FALSE ;
if ((spi < 0) || (spi > 1))
{
fprintf (stderr, "%s: SPI channel (%d) out of range\n", progName, spi) ;
return FALSE ;
}
mcp4802Setup (pinBase, spi) ;
return TRUE ;
}
/*
* doExtensionSn3218:
* Analog Output (LED Driver)
* sn3218:base
*********************************************************************************
*/
static int doExtensionSn3218 (char *progName, int pinBase, char *params)
{
sn3218Setup (pinBase) ;
return TRUE ;
}
/*
* doExtensionMcp3422:
* Analog IO
* mcp3422:base:i2cAddr
*********************************************************************************
*/
static int doExtensionMcp3422 (char *progName, int pinBase, char *params)
{
int i2c, sampleRate, gain ;
if ((params = extractInt (progName, params, &i2c)) == NULL)
return FALSE ;
if ((i2c < 0x03) || (i2c > 0x77))
{
fprintf (stderr, "%s: i2c address (0x%X) out of range\n", progName, i2c) ;
return FALSE ;
}
if ((params = extractInt (progName, params, &sampleRate)) == NULL)
return FALSE ;
if ((sampleRate < 0) || (sampleRate > 3))
{
fprintf (stderr, "%s: sample rate (%d) out of range\n", progName, sampleRate) ;
return FALSE ;
}
if ((params = extractInt (progName, params, &gain)) == NULL)
return FALSE ;
if ((gain < 0) || (gain > 3))
{
fprintf (stderr, "%s: gain (%d) out of range\n", progName, gain) ;
return FALSE ;
}
mcp3422Setup (pinBase, i2c, sampleRate, gain) ;
return TRUE ;
}
/*
* doExtensionDrcS:
* Interface to a DRC Serial system
* drcs:base:pins:serialPort:baud
*********************************************************************************
*/
static int doExtensionDrcS (char *progName, int pinBase, char *params)
{
char *port ;
int pins, baud ;
if ((params = extractInt (progName, params, &pins)) == NULL)
return FALSE ;
if ((pins < 1) || (pins > 100))
{
fprintf (stderr, "%s: pins (%d) out of range (2-100)\n", progName, pins) ;
return FALSE ;
}
if ((params = extractStr (progName, params, &port)) == NULL)
return FALSE ;
if (strlen (port) == 0)
{
fprintf (stderr, "%s: serial port device name required\n", progName) ;
return FALSE ;
}
if ((params = extractInt (progName, params, &baud)) == NULL)
return FALSE ;
if ((baud < 1) || (baud > 4000000))
{
fprintf (stderr, "%s: baud rate (%d) out of range\n", progName, baud) ;
return FALSE ;
}
drcSetupSerial (pinBase, pins, port, baud) ;
return TRUE ;
}
/*
* Function list
*********************************************************************************
@@ -345,6 +623,14 @@ struct extensionFunctionStruct extensionFunctions [] =
{ "sr595", &doExtensionSr595 },
{ "pcf8574", &doExtensionPcf8574 },
{ "pcf8591", &doExtensionPcf8591 },
{ "mcp3002", &doExtensionMcp3002 },
{ "mcp3004", &doExtensionMcp3004 },
{ "mcp4802", &doExtensionMcp4802 },
{ "mcp3422", &doExtensionMcp3422 },
{ "max31855", &doExtensionMax31855 },
{ "max5322", &doExtensionMax5322 },
{ "sn3218", &doExtensionSn3218 },
{ "drcs", &doExtensionDrcS },
{ NULL, NULL },
} ;

54
WiringPi/gpio/gpio.1
View File

@@ -13,11 +13,11 @@ gpio \- Command-line access to Raspberry Pi's GPIO
.PP
.B gpio
.B [ \-x extension:params ]
.B mode/read/write/aread/awrite/pwm ...
.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
@@ -39,6 +39,10 @@ gpio \- Command-line access to Raspberry Pi's GPIO
group value
.PP
.B gpio
.B usbp
high | low
.PP
.B gpio
.B pwm-bal/pwm-ms
.PP
.B gpio
@@ -114,6 +118,28 @@ respective logic levels.
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
@@ -126,10 +152,19 @@ 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 reset
Resets the GPIO - As much as it's possible to do. All pins are set to input
mode and all the internal pull-up/down resistors are disconnected (tristate mode).
Resets the GPIO - As much as it's possible to do. All pins are set to
input mode and all the internal pull-up/down resistors are disconnected
(tristate mode).
The reset command is usable with an extension module (via the -x parameter),
but it's limited to turning the pin into input mode (if applicable) and
removing any pull up/down resistor.
.TP
.B pwm <pin> <value>
@@ -200,6 +235,13 @@ Change the pad driver value for the given pad group to the supplied drive
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)
@@ -212,8 +254,8 @@ 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.
.TP
.B load spi [buffer size in KB]

281
WiringPi/gpio/gpio.c
View File

@@ -43,15 +43,21 @@
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 "2.05"
#define I2CDETECT "/usr/sbin/i2cdetect"
#define VERSION "2.20"
#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"
@@ -68,10 +74,32 @@ char *usage = "Usage: gpio -v\n"
" gpio pwmc <divider> \n"
" gpio load 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
@@ -236,62 +264,6 @@ static void doI2Cdetect (int argc, char *argv [])
}
/*
* doReadall:
* Read all the GPIO pins
*********************************************************************************
*/
static char *pinNames [] =
{
"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",
} ;
static char *alts [] =
{
"IN ", "OUT ", "ALT5", "ALT4", "ALT0", "ALT1", "ALT2", "ALT3"
} ;
static int wpiToPhys [64] =
{
11, 12, 13, 15, 16, 18, 22, 7, // 0...7
3, 5, // 8...9
24, 26, 19, 21, 23, // 10..14
8, 10, // 15..16
3, 4, 5, 6, // 17..20
0,0,0,0,0,0,0,0,0,0,0, // 20..31
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 32..47
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 47..63
} ;
static void doReadall (void)
{
int pin ;
printf ("+----------+-Rev%d-+------+--------+------+-------+\n", piBoardRev ()) ;
printf ("| wiringPi | GPIO | Phys | Name | Mode | Value |\n") ;
printf ("+----------+------+------+--------+------+-------+\n") ;
for (pin = 0 ; pin < 64 ; ++pin) // Crude, but effective
{
if (wpiPinToGpio (pin) == -1)
continue ;
printf ("| %6d | %3d | %3d | %s | %s | %s |\n",
pin, wpiPinToGpio (pin), wpiToPhys [pin],
pinNames [pin],
alts [getAlt (pin)],
digitalRead (pin) == HIGH ? "High" : "Low ") ;
}
printf ("+----------+------+------+--------+------+-------+\n") ;
}
/*
* doExports:
* List all GPIO exports
@@ -614,6 +586,24 @@ void doUnexportall (char *progName)
}
/*
* doResetExternal:
* Load readallExternal, we try to do this with an external device.
*********************************************************************************
*/
static void doResetExternal (void)
{
int pin ;
for (pin = wiringPiNodes->pinBase ; pin <= wiringPiNodes->pinMax ; ++pin)
{
pinMode (pin, INPUT) ;
pullUpDnControl (pin, PUD_OFF) ;
}
}
/*
* doReset:
* Reset the GPIO pins - as much as we can do
@@ -624,16 +614,21 @@ static void doReset (char *progName)
{
int pin ;
doUnexportall (progName) ;
for (pin = 0 ; pin < 64 ; ++pin)
if (wiringPiNodes != NULL) // External reset
doResetExternal () ;
else
{
if (wpiPinToGpio (pin) == -1)
continue ;
doUnexportall (progName) ;
digitalWrite (pin, LOW) ;
pinMode (pin, INPUT) ;
pullUpDnControl (pin, PUD_OFF) ;
for (pin = 0 ; pin < 64 ; ++pin)
{
if (wpiPinToGpio (pin) == -1)
continue ;
digitalWrite (pin, LOW) ;
pinMode (pin, INPUT) ;
pullUpDnControl (pin, PUD_OFF) ;
}
}
}
@@ -659,13 +654,26 @@ void doMode (int argc, char *argv [])
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) ;
// Undocumented
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) ;
@@ -709,6 +717,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
@@ -735,7 +795,7 @@ static void doGbw (int argc, char *argv [])
exit (1) ;
}
if ((value < 0) || (value > 1023))
if ((value < 0) || (value > 255))
{
fprintf (stderr, "%s: gbw: Value must be from 0 to 255\n", argv [0]) ;
exit (1) ;
@@ -926,6 +986,30 @@ void doToggle (int argc, char *argv [])
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) ;
}
/*
* doClock:
* Output a clock on a pin
@@ -1037,6 +1121,7 @@ static void doPwmClock (int argc, char *argv [])
int main (int argc, char *argv [])
{
int i ;
int model, rev, mem, maker, overVolted ;
if (getenv ("WIRINGPI_DEBUG") != NULL)
{
@@ -1077,18 +1162,30 @@ int main (int argc, char *argv [])
if (strcmp (argv [1], "-v") == 0)
{
printf ("gpio version: %s\n", VERSION) ;
printf ("Copyright (c) 2012-2013 Gordon Henderson\n") ;
printf ("Copyright (c) 2012-2014 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 ()) ;
piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
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], mem, piMakerNames [maker], overVolted ? "[OV]" : "") ;
}
return 0 ;
}
if (strcasecmp (argv [1], "-warranty") == 0)
{
printf ("gpio version: %s\n", VERSION) ;
printf ("Copyright (c) 2012-2013 Gordon Henderson\n") ;
printf ("Copyright (c) 2012-2014 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") ;
@@ -1212,18 +1309,22 @@ int main (int argc, char *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], "drive" ) == 0) doPadDrive (argc, argv) ;
else if (strcasecmp (argv [1], "readall" ) == 0) doReadall () ;
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 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]) ;

33
WiringPi/gpio/pins.c Normal file
View File

@@ -0,0 +1,33 @@
/*
* pins.c:
* Just display a handy Pi pinnout diagram.
* 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>
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") ;
}

321
WiringPi/gpio/readall.c Normal file
View File

@@ -0,0 +1,321 @@
/*
* readall.c:
* The readall functions - getting a bit big, so split them out.
* 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 <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) ;
}
/*
* bPlusReadall:
* Read all the pins on the model B+
*********************************************************************************
*/
void bPlusReadall (void)
{
int pin ;
printf (" +-----+-----+---------+------+---+--B Plus--+---+------+---------+-----+-----+\n") ;
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") ;
printf (" +-----+-----+---------+------+---+--B Plus--+---+------+---------+-----+-----+\n") ;
}
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)
bPlusReadall () ;
else if (model == PI_MODEL_CM)
cmReadall () ;
else
printf ("Oops - unable to determine board type... model: %d\n", model) ;
}

27
WiringPi/wiringPi/Makefile
View File

@@ -35,7 +35,8 @@ DYNAMIC=libwiringPi.so.$(VERSION)
DEBUG = -O2
CC = gcc
INCLUDE = -I.
CFLAGS = $(DEBUG) -Wformat=2 -Wall $(INCLUDE) -Winline -pipe -fPIC
DEFS = -D_GNU_SOURCE
CFLAGS = $(DEBUG) $(DEFS) -Wformat=2 -Wall -Winline $(INCLUDE) -pipe -fPIC
LIBS =
@@ -51,8 +52,10 @@ SRC = wiringPi.c \
mcp23s08.c mcp23s17.c \
sr595.c \
pcf8574.c pcf8591.c \
mcp3002.c mcp4802.c mcp3422.c \
drc.c
mcp3002.c mcp3004.c mcp4802.c mcp3422.c \
max31855.c max5322.c \
sn3218.c \
drcSerial.c
OBJ = $(SRC:.c=.o)
@@ -96,17 +99,22 @@ install-headers:
@install -m 0644 softTone.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 wiringPiSPI.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 wiringPiI2C.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 drcSerial.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp23008.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp23016.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp23017.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp23s08.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp23s17.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 max31855.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 max5322.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp3002.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp3004.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp4802.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 mcp3422.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 sr595.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 pcf8574.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 pcf8591.h $(DESTDIR)$(PREFIX)/include
@install -m 0644 sn3218.h $(DESTDIR)$(PREFIX)/include
.PHONEY: install
install: $(DYNAMIC) install-headers
@@ -132,17 +140,22 @@ uninstall:
@rm -f $(DESTDIR)$(PREFIX)/include/softTone.h
@rm -f $(DESTDIR)$(PREFIX)/include/wiringPiSPI.h
@rm -f $(DESTDIR)$(PREFIX)/include/wiringPiI2C.h
@rm -f $(DESTDIR)$(PREFIX)/include/drcSerial.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp23008.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp23016.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp23017.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp23s08.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp23s17.h
@rm -f $(DESTDIR)$(PREFIX)/include/max31855.h
@rm -f $(DESTDIR)$(PREFIX)/include/max5322.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp3002.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp3004.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp4802.h
@rm -f $(DESTDIR)$(PREFIX)/include/mcp3422.h
@rm -f $(DESTDIR)$(PREFIX)/include/sr595.h
@rm -f $(DESTDIR)$(PREFIX)/include/pcf8574.h
@rm -f $(DESTDIR)$(PREFIX)/include/pcf8591.h
@rm -f $(DESTDIR)$(PREFIX)/include/sn3218.h
@rm -f $(DESTDIR)$(PREFIX)/lib/libwiringPi.*
@ldconfig
@@ -153,7 +166,7 @@ depend:
# DO NOT DELETE
wiringPi.o: wiringPi.h
wiringPi.o: softPwm.h softTone.h wiringPi.h
wiringSerial.o: wiringSerial.h
wiringShift.o: wiringPi.h wiringShift.h
piHiPri.o: wiringPi.h
@@ -171,6 +184,10 @@ 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
drc.o: wiringPi.h wiringSerial.h drc.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

20
WiringPi/wiringPi/drc.c → WiringPi/wiringPi/drcSerial.c
View File

@@ -1,6 +1,6 @@
/*
* drc.c:
* Extend wiringPi with the DRC control protocll to Arduino
* drcSerial.c:
* Extend wiringPi with the DRC Serial protocol (e.g. to Arduino)
* Copyright (c) 2013 Gordon Henderson
***********************************************************************
* This file is part of wiringPi:
@@ -30,7 +30,7 @@
#include "wiringPi.h"
#include "wiringSerial.h"
#include "drc.h"
#include "drcSerial.h"
#ifndef TRUE
# define TRUE (1==1)
@@ -69,7 +69,7 @@ static void myPullUpDnControl (struct wiringPiNodeStruct *node, int pin, int mod
// Force pin into input mode
serialPutchar (node->fd, 'i' ) ;
serialPutchar (node->fd, pin) ;
serialPutchar (node->fd, pin - node->pinBase) ;
/**/ if (mode == PUD_UP)
{
@@ -148,14 +148,14 @@ static int myDigitalRead (struct wiringPiNodeStruct *node, int pin)
*********************************************************************************
*/
int drcSetup (const int pinBase, const int numPins, const char *device)
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, 115200)) < 0)
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...
@@ -166,9 +166,9 @@ int drcSetup (const int pinBase, const int numPins, const char *device)
(void)serialGetchar (fd) ;
ok = FALSE ;
for (tries = 1 ; tries < 5 ; ++tries)
for (tries = 1 ; (tries < 5) && (!ok) ; ++tries)
{
serialPutchar (fd, '@') ;
serialPutchar (fd, '@') ; // Ping
then = time (NULL) + 2 ;
while (time (NULL) < then)
if (serialDataAvail (fd))
@@ -179,14 +179,12 @@ int drcSetup (const int pinBase, const int numPins, const char *device)
break ;
}
}
if (ok)
break ;
}
if (!ok)
{
serialClose (fd) ;
return wiringPiFailure (WPI_FATAL, "Unable to communidate with DRC device") ;
return wiringPiFailure (WPI_FATAL, "Unable to communicate with DRC serial device") ;
}
node = wiringPiNewNode (pinBase, numPins) ;

7
WiringPi/wiringPi/drc.h → WiringPi/wiringPi/drcSerial.h
View File

@@ -1,6 +1,6 @@
/*
* drc.h:
* Extend wiringPi with the DRC control protocll to Arduino
* drcSerial.h:
* Extend wiringPi with the DRC Serial protocol (e.g. to Arduino)
* Copyright (c) 2013 Gordon Henderson
***********************************************************************
* This file is part of wiringPi:
@@ -26,8 +26,7 @@
extern "C" {
#endif
int drcSetup (const int pinBase, const int numPins, const char *device) ;
extern int drcSetupSerial (const int pinBase, const int numPins, const char *device, const int baud) ;
#ifdef __cplusplus
}

2
WiringPi/wiringPi/mcp3002.c
View File

@@ -55,7 +55,7 @@ static int myAnalogRead (struct wiringPiNodeStruct *node, int pin)
/*
* mcp3002Setup:
* Create a new wiringPi device node for an mcp2003 on the Pi's
* Create a new wiringPi device node for an mcp3002 on the Pi's
* SPI interface.
*********************************************************************************
*/

34
WiringPi/wiringPi/mcp3422.c
View File

@@ -1,6 +1,7 @@
/*
* mcp3422.c:
* Extend wiringPi with the MCP3422 I2C ADC chip
* Also works for the MCP3423 and MCP3224 (4 channel) chips
* Copyright (c) 2013 Gordon Henderson
***********************************************************************
* This file is part of wiringPi:
@@ -24,6 +25,7 @@
#include <stdio.h>
#include <unistd.h>
#include <stdint.h>
#include <fcntl.h>
#include <sys/ioctl.h>
@@ -43,7 +45,8 @@
int myAnalogRead (struct wiringPiNodeStruct *node, int chan)
{
unsigned char config, b0, b1, b2, b3 ;
unsigned char config ;
unsigned char buffer [4] ;
int value = 0 ;
// One-shot mode, trigger plus the other configs.
@@ -56,35 +59,26 @@ int myAnalogRead (struct wiringPiNodeStruct *node, int chan)
{
case MCP3422_SR_3_75: // 18 bits
delay (270) ;
b0 = wiringPiI2CRead (node->fd) ;
b1 = wiringPiI2CRead (node->fd) ;
b2 = wiringPiI2CRead (node->fd) ;
b3 = wiringPiI2CRead (node->fd) ;
value = ((b0 & 3) << 16) | (b1 << 8) | b2 ;
read (node->fd, buffer, 4) ;
value = ((buffer [0] & 3) << 16) | (buffer [1] << 8) | buffer [0] ;
break ;
case MCP3422_SR_15: // 16 bits
delay ( 70) ;
b0 = wiringPiI2CRead (node->fd) ;
b1 = wiringPiI2CRead (node->fd) ;
b2 = wiringPiI2CRead (node->fd) ;
value = (b0 << 8) | b1 ;
read (node->fd, buffer, 3) ;
value = (buffer [0] << 8) | buffer [1] ;
break ;
case MCP3422_SR_60: // 14 bits
delay ( 17) ;
b0 = wiringPiI2CRead (node->fd) ;
b1 = wiringPiI2CRead (node->fd) ;
b2 = wiringPiI2CRead (node->fd) ;
value = ((b0 & 0x3F) << 8) | b1 ;
read (node->fd, buffer, 3) ;
value = ((buffer [0] & 0x3F) << 8) | buffer [1] ;
break ;
case MCP3422_SR_240: // 12 bits
delay ( 5) ;
b0 = wiringPiI2CRead (node->fd) ;
b1 = wiringPiI2CRead (node->fd) ;
b2 = wiringPiI2CRead (node->fd) ;
value = ((b0 & 0x0F) << 8) | b1 ;
read (node->fd, buffer, 3) ;
value = ((buffer [0] & 0x0F) << 8) | buffer [0] ;
break ;
}
@@ -98,7 +92,7 @@ int myAnalogRead (struct wiringPiNodeStruct *node, int chan)
*********************************************************************************
*/
int mcp3422Setup (int pinBase, int i2cAddress, int channels, int sampleRate, int gain)
int mcp3422Setup (int pinBase, int i2cAddress, int sampleRate, int gain)
{
int fd ;
struct wiringPiNodeStruct *node ;
@@ -106,7 +100,7 @@ int mcp3422Setup (int pinBase, int i2cAddress, int channels, int sampleRate, int
if ((fd = wiringPiI2CSetup (i2cAddress)) < 0)
return fd ;
node = wiringPiNewNode (pinBase, channels) ;
node = wiringPiNewNode (pinBase, 4) ;
node->data0 = sampleRate ;
node->data1 = gain ;

2
WiringPi/wiringPi/mcp3422.h
View File

@@ -36,7 +36,7 @@
extern "C" {
#endif
extern int mcp3422Setup (int pinBase, int i2cAddress, int channels, int sampleRate, int gain) ;
extern int mcp3422Setup (int pinBase, int i2cAddress, int sampleRate, int gain) ;
#ifdef __cplusplus
}

55
WiringPi/wiringPi/softPwm.c
View File

@@ -1,7 +1,7 @@
/*
* softPwm.c:
* Provide 2 channels of software driven PWM.
* Copyright (c) 2012 Gordon Henderson
* Copyright (c) 2012-2014 Gordon Henderson
***********************************************************************
* This file is part of wiringPi:
* https://projects.drogon.net/raspberry-pi/wiringpi/
@@ -28,17 +28,22 @@
#include "wiringPi.h"
#include "softPwm.h"
// MAX_PINS:
// This is more than the number of Pi pins because we can actually softPwm
// pins that are on GPIO expanders. It's not that efficient and more than 1 or
// 2 pins on e.g. (SPI) mcp23s17 won't really be that effective, however...
#define MAX_PINS 1024
// The PWM Frequency is derived from the "pulse time" below. Essentially,
// the frequency is a function of the range and this pulse time.
// The total period will be range * pulse time in uS, so a pulse time
// of 100 and a range of 100 gives a period of 100 * 100 = 10,000 uS
// The total period will be range * pulse time in µS, so a pulse time
// of 100 and a range of 100 gives a period of 100 * 100 = 10,000 µS
// which is a frequency of 100Hz.
//
// It's possible to get a higher frequency by lowering the pulse time,
// however CPU uage will skyrocket as wiringPi uses a hard-loop to time
// periods under 100uS - this is because the Linux timer calls are just
// periods under 100µS - this is because the Linux timer calls are just
// accurate at all, and have an overhead.
//
// Another way to increase the frequency is to reduce the range - however
@@ -46,8 +51,9 @@
#define PULSE_TIME 100
static int marks [MAX_PINS] ;
static int range [MAX_PINS] ;
static int marks [MAX_PINS] ;
static int range [MAX_PINS] ;
static pthread_t threads [MAX_PINS] ;
int newPin = -1 ;
@@ -61,11 +67,15 @@ int newPin = -1 ;
static PI_THREAD (softPwmThread)
{
int pin, mark, space ;
struct sched_param param ;
param.sched_priority = sched_get_priority_max (SCHED_RR) ;
pthread_setschedparam (pthread_self (), SCHED_RR, &param) ;
pin = newPin ;
newPin = -1 ;
piHiPri (50) ;
piHiPri (90) ;
for (;;)
{
@@ -106,13 +116,20 @@ void softPwmWrite (int pin, int value)
/*
* softPwmCreate:
* Create a new PWM thread.
* Create a new softPWM thread.
*********************************************************************************
*/
int softPwmCreate (int pin, int initialValue, int pwmRange)
{
int res ;
pthread_t myThread ;
if (range [pin] != 0) // Already running on this pin
return -1 ;
if (range <= 0)
return -1 ;
pinMode (pin, OUTPUT) ;
digitalWrite (pin, LOW) ;
@@ -121,10 +138,30 @@ int softPwmCreate (int pin, int initialValue, int pwmRange)
range [pin] = pwmRange ;
newPin = pin ;
res = piThreadCreate (softPwmThread) ;
res = pthread_create (&myThread, NULL, softPwmThread, NULL) ;
while (newPin != -1)
delay (1) ;
threads [pin] = myThread ;
return res ;
}
/*
* softPwmStop:
* Stop an existing softPWM thread
*********************************************************************************
*/
void softPwmStop (int pin)
{
if (range [pin] != 0)
{
pthread_cancel (threads [pin]) ;
pthread_join (threads [pin], NULL) ;
range [pin] = 0 ;
digitalWrite (pin, LOW) ;
}
}

1
WiringPi/wiringPi/softPwm.h
View File

@@ -28,6 +28,7 @@ extern "C" {
extern int softPwmCreate (int pin, int value, int range) ;
extern void softPwmWrite (int pin, int value) ;
extern void softPwmStop (int pin) ;
#ifdef __cplusplus
}

33
WiringPi/wiringPi/softTone.c
View File

@@ -36,7 +36,8 @@
#define PULSE_TIME 100
static int freqs [MAX_PINS] ;
static int freqs [MAX_PINS] ;
static pthread_t threads [MAX_PINS] ;
static int newPin = -1 ;
@@ -50,6 +51,10 @@ static int newPin = -1 ;
static PI_THREAD (softToneThread)
{
int pin, freq, halfPeriod ;
struct sched_param param ;
param.sched_priority = sched_get_priority_max (SCHED_RR) ;
pthread_setschedparam (pthread_self (), SCHED_RR, &param) ;
pin = newPin ;
newPin = -1 ;
@@ -105,17 +110,41 @@ void softToneWrite (int pin, int freq)
int softToneCreate (int pin)
{
int res ;
pthread_t myThread ;
pinMode (pin, OUTPUT) ;
digitalWrite (pin, LOW) ;
if (threads [pin] != 0)
return -1 ;
freqs [pin] = 0 ;
newPin = pin ;
res = piThreadCreate (softToneThread) ;
res = pthread_create (&myThread, NULL, softToneThread, NULL) ;
while (newPin != -1)
delay (1) ;
threads [pin] = myThread ;
return res ;
}
/*
* softToneStop:
* Stop an existing softTone thread
*********************************************************************************
*/
void softToneStop (int pin)
{
if (threads [pin] != 0)
{
pthread_cancel (threads [pin]) ;
pthread_join (threads [pin], NULL) ;
threads [pin] = 0 ;
digitalWrite (pin, LOW) ;
}
}

1
WiringPi/wiringPi/softTone.h
View File

@@ -31,6 +31,7 @@ extern "C" {
#endif
extern int softToneCreate (int pin) ;
extern void softToneStop (int pin) ;
extern void softToneWrite (int pin, int freq) ;
#ifdef __cplusplus

283
WiringPi/wiringPi/wiringPi.c
View File

@@ -70,6 +70,9 @@
#include <sys/wait.h>
#include <sys/ioctl.h>
#include "softPwm.h"
#include "softTone.h"
#include "wiringPi.h"
#ifndef TRUE
@@ -194,6 +197,39 @@ static volatile uint32_t *timer ;
static volatile uint32_t *timerIrqRaw ;
#endif
// Data for use with the boardId functions.
// The order of entries here to correspond with the PI_MODEL_X
// and PI_VERSION_X defines in wiringPi.h
// Only intended for the gpio command - use at your own risk!
const char *piModelNames [5] =
{
"Unknown",
"Model A",
"Model B",
"Model B+",
"Compute Module",
} ;
const char *piRevisionNames [5] =
{
"Unknown",
"1",
"1.1",
"1.2",
"2",
} ;
const char *piMakerNames [4] =
{
"Unknown",
"Egoman",
"Sony",
"Qusda",
} ;
// Time for easy calculations
static uint64_t epochMilli, epochMicro ;
@@ -231,14 +267,16 @@ static void (*isrFunctions [64])(void) ;
// pinToGpio:
// Take a Wiring pin (0 through X) and re-map it to the BCM_GPIO pin
// Cope for 2 different board revisions here.
// Cope for 3 different board revisions here.
static int *pinToGpio ;
// Revision 1, 1.1:
static int pinToGpioR1 [64] =
{
17, 18, 21, 22, 23, 24, 25, 4, // From the Original Wiki - GPIO 0 through 7: wpi 0 - 7
0, 1, // I2C - SDA0, SCL0 wpi 8 - 9
0, 1, // I2C - SDA1, SCL1 wpi 8 - 9
8, 7, // SPI - CE1, CE0 wpi 10 - 11
10, 9, 11, // SPI - MOSI, MISO, SCLK wpi 12 - 14
14, 15, // UART - Tx, Rx wpi 15 - 16
@@ -250,6 +288,8 @@ static int pinToGpioR1 [64] =
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 63
} ;
// Revision 2:
static int pinToGpioR2 [64] =
{
17, 18, 27, 22, 23, 24, 25, 4, // From the Original Wiki - GPIO 0 through 7: wpi 0 - 7
@@ -257,11 +297,13 @@ static int pinToGpioR2 [64] =
8, 7, // SPI - CE1, CE0 wpi 10 - 11
10, 9, 11, // SPI - MOSI, MISO, SCLK wpi 12 - 14
14, 15, // UART - Tx, Rx wpi 15 - 16
28, 29, 30, 31, // New GPIOs 8 though 11 wpi 17 - 20
28, 29, 30, 31, // Rev 2: New GPIOs 8 though 11 wpi 17 - 20
5, 6, 13, 19, 26, // B+ wpi 21, 22, 23, 24, 25
12, 16, 20, 21, // B+ wpi 26, 27, 28, 29
0, 1, // B+ wpi 30, 31
// Padding:
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 31
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 47
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 63
} ;
@@ -270,6 +312,7 @@ static int pinToGpioR2 [64] =
// physToGpio:
// Take a physical pin (1 through 26) and re-map it to the BCM_GPIO pin
// Cope for 2 different board revisions here.
// Also add in the P5 connector, so the P5 pins are 3,4,5,6, so 53,54,55,56
static int *physToGpio ;
@@ -290,8 +333,6 @@ static int physToGpioR1 [64] =
11, 8,
-1, 7, // 25, 26
// Padding:
-1, -1, -1, -1, -1, // ... 31
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 47
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 63
@@ -314,14 +355,31 @@ static int physToGpioR2 [64] =
11, 8,
-1, 7, // 25, 26
// Padding:
// B+
-1, -1, -1, -1, -1, // ... 31
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 47
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // ... 63
0, 1,
5, -1,
6, 12,
13, -1,
19, 16,
26, 20,
-1, 21,
// the P5 connector on the Rev 2 boards:
-1, -1,
-1, -1,
-1, -1,
-1, -1,
-1, -1,
28, 29,
30, 31,
-1, -1,
-1, -1,
-1, -1,
-1, -1,
} ;
// gpioToGPFSEL:
// Map a BCM_GPIO pin to it's Function Selection
// control port. (GPFSEL 0-5)
@@ -391,7 +449,7 @@ static uint8_t gpioToEDS [] =
} ;
// gpioToREN
// (Word) offset to the Rising edgde ENable register
// (Word) offset to the Rising edge ENable register
static uint8_t gpioToREN [] =
{
@@ -541,26 +599,36 @@ int wiringPiFailure (int fatal, const char *message, ...)
/*
* piBoardRev:
* Return a number representing the hardware revision of the board.
* Revision is currently 1 or 2.
*
* Much confusion here )-:
* Revision 1 really means the early Model B's.
* Revision 2 is everything else - it covers the B, B+ and CM.
*
* Seems there are some boards with 0000 in them (mistake in manufacture)
* and some board with 0005 in them (another mistake in manufacture?)
* So the distinction between boards that I can see is:
* 0000 - Error
* 0001 - Not used
* 0002 - Rev 1
* 0003 - Rev 1
* 0004 - Rev 2 (Early reports?
* 0005 - Rev 2 (but error?)
* 0006 - Rev 2
* 0008 - Rev 2 - Model A
* 000e - Rev 2 + 512MB
* 000f - Rev 2 + 512MB
* 0001 - Not used
* 0002 - Model B, Rev 1, 256MB, Egoman
* 0003 - Model B, Rev 1.1, 256MB, Egoman, Fuses/D14 removed.
* 0004 - Model B, Rev 2, 256MB, Sony
* 0005 - Model B, Rev 2, 256MB, Qisda
* 0006 - Model B, Rev 2, 256MB, Egoman
* 0007 - Model A, Rev 2, 256MB, Egoman
* 0008 - Model A, Rev 2, 256MB, Sony
* 0009 - Model A, Rev 2, 256MB, Qisda
* 000d - Model B, Rev 2, 512MB, Egoman
* 000e - Model B, Rev 2, 512MB, Sony
* 000f - Model B, Rev 2, 512MB, Qisda
* 0010 - Model B+, Rev 1.2, 512MB, Sony
* 0011 - Pi CM, Rev 1.2, 512MB, Sony
*
* A small thorn is the olde style overvolting - that will add in
* 1000000
*
* The Pi compute module has an revision of 0011 - since we only check the
* last digit, then it's 1, therefore it'll default to not 2 or 3 for a
* Rev 1, so will appear as a Rev 2. This is fine for the most part, but
* we'll properly detect the Compute Module later and adjust accordingly.
*
*********************************************************************************
*/
@@ -577,7 +645,7 @@ int piBoardRev (void)
{
FILE *cpuFd ;
char line [120] ;
char *c, lastChar ;
char *c ;
static int boardRev = -1 ;
if (boardRev != -1) // No point checking twice
@@ -595,12 +663,16 @@ int piBoardRev (void)
if (strncmp (line, "Revision", 8) != 0)
piBoardRevOops ("No \"Revision\" line") ;
// Chomp trailing CR/NL
for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
*c = 0 ;
if (wiringPiDebug)
printf ("piboardRev: Revision string: %s\n", line) ;
// Scan to first digit
for (c = line ; *c ; ++c)
if (isdigit (*c))
break ;
@@ -608,6 +680,11 @@ int piBoardRev (void)
if (!isdigit (*c))
piBoardRevOops ("No numeric revision string") ;
// Make sure its long enough
if (strlen (c) < 4)
piBoardRevOops ("Bogus \"Revision\" line (too small)") ;
// If you have overvolted the Pi, then it appears that the revision
// has 100000 added to it!
@@ -615,12 +692,14 @@ int piBoardRev (void)
if (strlen (c) != 4)
printf ("piboardRev: This Pi has/is overvolted!\n") ;
lastChar = line [strlen (line) - 1] ;
// Isolate last 4 characters:
c = c + strlen (c) - 4 ;
if (wiringPiDebug)
printf ("piboardRev: lastChar is: '%c' (%d, 0x%02X)\n", lastChar, lastChar, lastChar) ;
printf ("piboardRev: last4Chars are: \"%s\"\n", c) ;
/**/ if ((lastChar == '2') || (lastChar == '3'))
if ( (strcmp (c, "0002") == 0) || (strcmp (c, "0003") == 0))
boardRev = 1 ;
else
boardRev = 2 ;
@@ -632,6 +711,82 @@ int piBoardRev (void)
}
/*
* piBoardId:
* Do more digging into the board revision string as above, but return
* as much details as we can.
* This is undocumented and really only intended for the GPIO command.
* Use at your own risk!
*********************************************************************************
*/
void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted)
{
FILE *cpuFd ;
char line [120] ;
char *c ;
(void)piBoardRev () ; // Call this first to make sure all's OK. Don't care about the result.
if ((cpuFd = fopen ("/proc/cpuinfo", "r")) == NULL)
piBoardRevOops ("Unable to open /proc/cpuinfo") ;
while (fgets (line, 120, cpuFd) != NULL)
if (strncmp (line, "Revision", 8) == 0)
break ;
fclose (cpuFd) ;
if (strncmp (line, "Revision", 8) != 0)
piBoardRevOops ("No \"Revision\" line") ;
// Chomp trailing CR/NL
for (c = &line [strlen (line) - 1] ; (*c == '\n') || (*c == '\r') ; --c)
*c = 0 ;
if (wiringPiDebug)
printf ("piboardId: Revision string: %s\n", line) ;
// Scan to first digit
for (c = line ; *c ; ++c)
if (isdigit (*c))
break ;
// Make sure its long enough
if (strlen (c) < 4)
piBoardRevOops ("Bogus \"Revision\" line") ;
// If longer than 4, we'll assume it's been overvolted
*overVolted = strlen (c) > 4 ;
// Extract last 4 characters:
c = c + strlen (c) - 4 ;
// Fill out the replys as appropriate
/**/ if (strcmp (c, "0002") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_1 ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
else if (strcmp (c, "0003") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_1_1 ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
else if (strcmp (c, "0004") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_2 ; *mem = 256 ; *maker = PI_MAKER_SONY ; }
else if (strcmp (c, "0005") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_2 ; *mem = 256 ; *maker = PI_MAKER_QISDA ; }
else if (strcmp (c, "0006") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_2 ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
else if (strcmp (c, "0007") == 0) { *model = PI_MODEL_A ; *rev = PI_VERSION_2 ; *mem = 256 ; *maker = PI_MAKER_EGOMAN ; }
else if (strcmp (c, "0008") == 0) { *model = PI_MODEL_A ; *rev = PI_VERSION_2 ; *mem = 256 ; *maker = PI_MAKER_SONY ; ; }
else if (strcmp (c, "0009") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_2 ; *mem = 256 ; *maker = PI_MAKER_QISDA ; }
else if (strcmp (c, "000d") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_2 ; *mem = 512 ; *maker = PI_MAKER_EGOMAN ; }
else if (strcmp (c, "000e") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_2 ; *mem = 512 ; *maker = PI_MAKER_SONY ; }
else if (strcmp (c, "000f") == 0) { *model = PI_MODEL_B ; *rev = PI_VERSION_2 ; *mem = 512 ; *maker = PI_MAKER_EGOMAN ; }
else if (strcmp (c, "0010") == 0) { *model = PI_MODEL_BP ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_SONY ; }
else if (strcmp (c, "0011") == 0) { *model = PI_MODEL_CM ; *rev = PI_VERSION_1_2 ; *mem = 512 ; *maker = PI_MAKER_SONY ; }
else { *model = 0 ; *rev = 0 ; *mem = 0 ; *maker = 0 ; }
}
/*
* wpiPinToGpio:
* Translate a wiringPi Pin number to native GPIO pin number.
@@ -961,6 +1116,7 @@ void pinMode (int pin, int mode)
{
int fSel, shift, alt ;
struct wiringPiNodeStruct *node = wiringPiNodes ;
int origPin = pin ;
if ((pin & PI_GPIO_MASK) == 0) // On-board pin
{
@@ -971,6 +1127,9 @@ void pinMode (int pin, int mode)
else if (wiringPiMode != WPI_MODE_GPIO)
return ;
softPwmStop (origPin) ;
softToneStop (origPin) ;
fSel = gpioToGPFSEL [pin] ;
shift = gpioToShift [pin] ;
@@ -978,9 +1137,18 @@ void pinMode (int pin, int mode)
*(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) ; // Sets bits to zero = input
else if (mode == OUTPUT)
*(gpio + fSel) = (*(gpio + fSel) & ~(7 << shift)) | (1 << shift) ;
else if (mode == SOFT_PWM_OUTPUT)
softPwmCreate (origPin, 0, 100) ;
else if (mode == SOFT_TONE_OUTPUT)
softToneCreate (origPin) ;
else if (mode == PWM_TONE_OUTPUT)
{
pinMode (origPin, PWM_OUTPUT) ; // Call myself to enable PWM mode
pwmSetMode (PWM_MODE_MS) ;
}
else if (mode == PWM_OUTPUT)
{
if ((alt = gpioToPwmALT [pin]) == 0) // Not a PWM pin
if ((alt = gpioToPwmALT [pin]) == 0) // Not a hardware capable PWM pin
return ;
// Set pin to PWM mode
@@ -990,7 +1158,7 @@ void pinMode (int pin, int mode)
pwmSetMode (PWM_MODE_BAL) ; // Pi default mode
pwmSetRange (1024) ; // Default range of 1024
pwmSetClock (32) ; // 19.2 / 32 = 600KHz - Also starts the PWM
pwmSetClock (32) ; // 19.2 / 32 = 600KHz - Also starts the PWM
}
else if (mode == GPIO_CLOCK)
{
@@ -1203,6 +1371,28 @@ void analogWrite (int pin, int value)
}
/*
* pwmToneWrite:
* Pi Specific.
* Output the given frequency on the Pi's PWM pin
*********************************************************************************
*/
void pwmToneWrite (int pin, int freq)
{
int range ;
if (freq == 0)
pwmWrite (pin, 0) ; // Off
else
{
range = 600000 / freq ;
pwmSetRange (range) ;
pwmWrite (pin, freq / 2) ;
}
}
/*
* digitalWriteByte:
@@ -1369,8 +1559,18 @@ int wiringPiISR (int pin, int mode, void (*function)(void))
if (pid == 0) // Child, exec
{
execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
/**/ if (access ("/usr/local/bin/gpio", X_OK) == 0)
{
execl ("/usr/local/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
}
else if (access ("/usr/bin/gpio", X_OK) == 0)
{
execl ("/usr/bin/gpio", "gpio", "edge", pinS, modeS, (char *)NULL) ;
return wiringPiFailure (WPI_FATAL, "wiringPiISR: execl failed: %s\n", strerror (errno)) ;
}
else
return wiringPiFailure (WPI_FATAL, "wiringPiISR: Can't find gpio program\n") ;
}
else // Parent, wait
wait (NULL) ;
@@ -1531,13 +1731,16 @@ unsigned int micros (void)
*
* Default setup: Initialises the system into wiringPi Pin mode and uses the
* memory mapped hardware directly.
*
* Changed now to revert to "gpio" mode if we're running on a Compute Module.
*********************************************************************************
*/
int wiringPiSetup (void)
{
int fd ;
int boardRev ;
int fd ;
int boardRev ;
int model, rev, mem, maker, overVolted ;
if (getenv (ENV_DEBUG) != NULL)
wiringPiDebug = TRUE ;
@@ -1553,12 +1756,12 @@ int wiringPiSetup (void)
boardRev = piBoardRev () ;
if (boardRev == 1)
/**/ if (boardRev == 1) // A, B, Rev 1, 1.1
{
pinToGpio = pinToGpioR1 ;
physToGpio = physToGpioR1 ;
}
else
else // A, B, Rev 2, B+, CM
{
pinToGpio = pinToGpioR2 ;
physToGpio = physToGpioR2 ;
@@ -1611,7 +1814,13 @@ int wiringPiSetup (void)
initialiseEpoch () ;
wiringPiMode = WPI_MODE_PINS ;
// If we're running on a compute module, then wiringPi pin numbers don't really many anything...
piBoardId (&model, &rev, &mem, &maker, &overVolted) ;
if (model == PI_MODEL_CM)
wiringPiMode = WPI_MODE_GPIO ;
else
wiringPiMode = WPI_MODE_PINS ;
return 0 ;
}

40
WiringPi/wiringPi/wiringPi.h
View File

@@ -24,9 +24,6 @@
#ifndef __WIRING_PI_H__
#define __WIRING_PI_H__
#ifndef O_CLOEXEC
#define O_CLOEXEC 0
#endif
// Handy defines
// Deprecated
@@ -45,6 +42,9 @@
#define OUTPUT 1
#define PWM_OUTPUT 2
#define GPIO_CLOCK 3
#define SOFT_PWM_OUTPUT 4
#define SOFT_TONE_OUTPUT 5
#define PWM_TONE_OUTPUT 6
#define LOW 0
#define HIGH 1
@@ -67,6 +67,33 @@
#define INT_EDGE_RISING 2
#define INT_EDGE_BOTH 3
// Pi model types and version numbers
// Intended for the GPIO program Use at your own risk.
#define PI_MODEL_UNKNOWN 0
#define PI_MODEL_A 1
#define PI_MODEL_B 2
#define PI_MODEL_BP 3
#define PI_MODEL_CM 4
#define PI_VERSION_UNKNOWN 0
#define PI_VERSION_1 1
#define PI_VERSION_1_1 2
#define PI_VERSION_1_2 3
#define PI_VERSION_2 4
#define PI_MAKER_UNKNOWN 0
#define PI_MAKER_EGOMAN 1
#define PI_MAKER_SONY 2
#define PI_MAKER_QISDA 3
extern const char *piModelNames [5] ;
extern const char *piRevisionNames [5] ;
extern const char *piMakerNames [4] ;
// Intended for the GPIO program Use at your own risk.
// Threads
#define PI_THREAD(X) void *X (void *dummy)
@@ -118,6 +145,11 @@ extern struct wiringPiNodeStruct *wiringPiNodes ;
extern "C" {
#endif
// Data
//extern const char *piModelNames [] ;
//extern const char *piRevisionNames[] ;
// Internal
extern int wiringPiFailure (int fatal, const char *message, ...) ;
@@ -150,10 +182,12 @@ extern int wiringPiSetupPiFaceForGpioProg (void) ; // Don't use this - for gpio
// On-Board Raspberry Pi hardware specific stuff
extern int piBoardRev (void) ;
extern void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted) ;
extern int wpiPinToGpio (int wpiPin) ;
extern int physPinToGpio (int physPin) ;
extern void setPadDrive (int group, int value) ;
extern int getAlt (int pin) ;
extern void pwmToneWrite (int pin, int freq) ;
extern void digitalWriteByte (int value) ;
extern void pwmSetMode (int mode) ;
extern void pwmSetRange (unsigned int range) ;

102
setup.py
View File

@@ -4,41 +4,42 @@ from setuptools import setup, find_packages, Extension
_wiringpi2 = Extension(
'_wiringpi2',
include_dirs=['WiringPi/wiringPi','WiringPi/devLib'],
sources=[
'WiringPi/wiringPi/wiringPi.c',
'WiringPi/wiringPi/wiringPiSPI.c',
'WiringPi/devLib/ds1302.c',
'WiringPi/devLib/gertboard.c',
'WiringPi/devLib/lcd128x64.c',
'WiringPi/devLib/lcd.c',
'WiringPi/devLib/maxdetect.c',
'WiringPi/devLib/piFace.c',
'WiringPi/devLib/piGlow.c',
'WiringPi/devLib/piNes.c',
'WiringPi/wiringPi/drcSerial.c',
'WiringPi/wiringPi/max31855.c',
'WiringPi/wiringPi/max5322.c',
'WiringPi/wiringPi/drc.c',
'WiringPi/wiringPi/sn3218.c',
'WiringPi/wiringPi/mcp23s17.c',
'WiringPi/wiringPi/pcf8591.c',
'WiringPi/wiringPi/softTone.c',
'WiringPi/wiringPi/wiringSerial.c',
'WiringPi/wiringPi/mcp23008.c',
'WiringPi/wiringPi/mcp23016.c',
'WiringPi/wiringPi/mcp23017.c',
'WiringPi/wiringPi/mcp23s08.c',
'WiringPi/wiringPi/mcp23s17.c',
'WiringPi/wiringPi/mcp3002.c',
'WiringPi/wiringPi/mcp3004.c',
'WiringPi/wiringPi/piHiPri.c',
'WiringPi/wiringPi/sr595.c',
'WiringPi/wiringPi/wiringShift.c',
'WiringPi/wiringPi/mcp23016.c',
'WiringPi/wiringPi/mcp3422.c',
'WiringPi/wiringPi/piThread.c',
'WiringPi/wiringPi/mcp23017.c',
'WiringPi/wiringPi/mcp4802.c',
'WiringPi/wiringPi/softPwm.c',
'WiringPi/wiringPi/wiringPiI2C.c',
'WiringPi/wiringPi/mcp23s08.c',
'WiringPi/wiringPi/pcf8574.c',
'WiringPi/wiringPi/pcf8591.c',
'WiringPi/wiringPi/piHiPri.c',
'WiringPi/wiringPi/piThread.c',
'WiringPi/wiringPi/sn3218.c',
'WiringPi/wiringPi/softPwm.c',
'WiringPi/wiringPi/softServo.c',
'WiringPi/devLib/ds1302.c',
'WiringPi/devLib/lcd128x64.c',
'WiringPi/devLib/maxdetect.c',
'WiringPi/devLib/gertboard.c',
'WiringPi/devLib/lcd.c',
'WiringPi/devLib/piFace.c',
'WiringPi/devLib/piNes.c',
'WiringPi/devLib/piGlow.c',
'WiringPi/wiringPi/softTone.c',
'WiringPi/wiringPi/sr595.c',
'WiringPi/wiringPi/wiringPi.c',
'WiringPi/wiringPi/wiringPiI2C.c',
'WiringPi/wiringPi/wiringPiSPI.c',
'WiringPi/wiringPi/wiringSerial.c',
'WiringPi/wiringPi/wiringShift.c',
'wiringpi_wrap.c'
],
)
@@ -58,40 +59,41 @@ setup(
install_requires=[],
headers=[
'WiringPi/wiringPi/wiringPi.h',
'WiringPi/wiringPi/wiringPi.h',
'WiringPi/wiringPi/wiringPiI2C.h',
'WiringPi/wiringPi/wiringPiSPI.h',
'WiringPi/wiringPi/wiringSerial.h',
'WiringPi/wiringPi/wiringShift.h',
'WiringPi/devLib/ds1302.h',
'WiringPi/devLib/font.h',
'WiringPi/devLib/gertboard.h',
'WiringPi/devLib/lcd128x64.h',
'WiringPi/devLib/lcd.h',
'WiringPi/devLib/maxdetect.h',
'WiringPi/devLib/piFace.h',
'WiringPi/devLib/piGlow.h',
'WiringPi/devLib/piNes.h',
'WiringPi/wiringPi/drcSerial.h',
'WiringPi/wiringPi/max31855.h',
'WiringPi/wiringPi/max5322.h',
'WiringPi/wiringPi/drc.h',
'WiringPi/wiringPi/sn3218.h',
'WiringPi/wiringPi/mcp23s08.h',
'WiringPi/wiringPi/mcp3422.h',
'WiringPi/wiringPi/softServo.h',
'WiringPi/wiringPi/wiringPiSPI.h',
'WiringPi/wiringPi/mcp23008.h',
'WiringPi/wiringPi/mcp23s17.h',
'WiringPi/wiringPi/mcp4802.h',
'WiringPi/wiringPi/softTone.h',
'WiringPi/wiringPi/wiringSerial.h',
'WiringPi/wiringPi/mcp23016.h',
'WiringPi/wiringPi/mcp23x0817.h',
'WiringPi/wiringPi/pcf8574.h',
'WiringPi/wiringPi/sr595.h',
'WiringPi/wiringPi/wiringShift.h',
'WiringPi/wiringPi/mcp23016reg.h',
'WiringPi/wiringPi/mcp23x08.h',
'WiringPi/wiringPi/pcf8591.h',
'WiringPi/wiringPi/mcp23017.h',
'WiringPi/wiringPi/mcp23s08.h',
'WiringPi/wiringPi/mcp23s17.h',
'WiringPi/wiringPi/mcp23x0817.h',
'WiringPi/wiringPi/mcp23x08.h',
'WiringPi/wiringPi/mcp3002.h',
'WiringPi/wiringPi/mcp3004.h',
'WiringPi/wiringPi/mcp3422.h',
'WiringPi/wiringPi/mcp4802.h',
'WiringPi/wiringPi/pcf8574.h',
'WiringPi/wiringPi/pcf8591.h',
'WiringPi/wiringPi/sn3218.h',
'WiringPi/wiringPi/softPwm.h',
'WiringPi/devLib/ds1302.h',
'WiringPi/devLib/gertboard.h',
'WiringPi/devLib/lcd.h',
'WiringPi/devLib/piFace.h',
'WiringPi/devLib/font.h',
'WiringPi/devLib/lcd128x64.h',
'WiringPi/devLib/maxdetect.h',
'WiringPi/devLib/piNes.h'
'WiringPi/devLib/piGlow.h',
'WiringPi/wiringPi/softServo.h',
'WiringPi/wiringPi/softTone.h',
'WiringPi/wiringPi/sr595.h'
]
)

233
wiringpi.i
View File

@@ -2,54 +2,60 @@
%{
#include "WiringPi/wiringPi/wiringPi.h"
#include "WiringPi/wiringPi/wiringPiSPI.h"
#include "WiringPi/wiringPi/wiringPiI2C.h"
#include "WiringPi/wiringPi/wiringPiSPI.h"
#include "WiringPi/wiringPi/wiringSerial.h"
#include "WiringPi/wiringPi/wiringShift.h"
#include "WiringPi/wiringPi/drcSerial.h"
#include "WiringPi/wiringPi/max31855.h"
#include "WiringPi/wiringPi/max5322.h"
#include "WiringPi/wiringPi/mcp23017.h"
#include "WiringPi/wiringPi/mcp4802.h"
#include "WiringPi/wiringPi/mcp3422.h"
#include "WiringPi/wiringPi/mcp23s08.h"
#include "WiringPi/wiringPi/mcp23008.h"
#include "WiringPi/wiringPi/mcp23x08.h"
#include "WiringPi/wiringPi/mcp23016.h"
#include "WiringPi/wiringPi/mcp23016reg.h"
#include "WiringPi/wiringPi/mcp23017.h"
#include "WiringPi/wiringPi/mcp23s08.h"
#include "WiringPi/wiringPi/mcp23s17.h"
#include "WiringPi/wiringPi/mcp23x0817.h"
#include "WiringPi/wiringPi/mcp23x08.h"
#include "WiringPi/wiringPi/mcp3002.h"
#include "WiringPi/wiringPi/mcp3004.h"
#include "WiringPi/wiringPi/mcp23016reg.h"
#include "WiringPi/wiringPi/sn3218.h"
#include "WiringPi/wiringPi/mcp23x0817.h"
#include "WiringPi/wiringPi/mcp23s17.h"
#include "WiringPi/wiringPi/mcp3422.h"
#include "WiringPi/wiringPi/mcp4802.h"
#include "WiringPi/wiringPi/pcf8574.h"
#include "WiringPi/wiringPi/pcf8591.h"
#include "WiringPi/wiringPi/drc.h"
#include "WiringPi/wiringPi/sn3218.h"
#include "WiringPi/wiringPi/softPwm.h"
#include "WiringPi/wiringPi/softServo.h"
#include "WiringPi/wiringPi/softTone.h"
#include "WiringPi/wiringPi/sr595.h"
#include "WiringPi/devLib/ds1302.h"
#include "WiringPi/devLib/font.h"
#include "WiringPi/devLib/gertboard.h"
#include "WiringPi/devLib/lcd128x64.h"
#include "WiringPi/devLib/font.h"
#include "WiringPi/devLib/lcd.h"
#include "WiringPi/devLib/maxdetect.h"
#include "WiringPi/devLib/piFace.h"
#include "WiringPi/devLib/ds1302.h"
#include "WiringPi/devLib/piNes.h"
#include "WiringPi/devLib/piGlow.h"
#include "WiringPi/devLib/piNes.h"
%}
%apply unsigned char { uint8_t };
%typemap(in) (unsigned char *data, int len) {
$1 = (unsigned char *) PyString_AsString($input);
$2 = PyString_Size($input);
};
extern int wiringPiFailure (int fatal, const char *message, ...) ;
extern struct wiringPiNodeStruct *wiringPiFindNode (int pin) ;
extern struct wiringPiNodeStruct *wiringPiNewNode (int pinBase, int numPins) ;
// Core wiringPi functions
extern int wiringPiSetup (void) ;
extern int wiringPiSetupSys (void) ;
extern int wiringPiSetupGpio (void) ;
extern int wiringPiSetupPhys (void) ;
extern int piFaceSetup (const int pinBase) ;
extern void pinModeAlt (int pin, int mode) ;
extern void pinMode (int pin, int mode) ;
extern void pullUpDnControl (int pin, int pud) ;
extern int digitalRead (int pin) ;
@@ -59,11 +65,13 @@ extern int analogRead (int pin) ;
extern void analogWrite (int pin, int value) ;
// On-Board Raspberry Pi hardware specific stuff
extern int piBoardRev (void) ;
extern void piBoardId (int *model, int *rev, int *mem, int *maker, int *overVolted) ;
extern int wpiPinToGpio (int wpiPin) ;
extern int physPinToGpio (int physPin) ;
extern void setPadDrive (int group, int value) ;
extern int getAlt (int pin) ;
extern void pwmToneWrite (int pin, int freq) ;
extern void digitalWriteByte (int value) ;
extern void pwmSetMode (int mode) ;
extern void pwmSetRange (unsigned int range) ;
@@ -71,112 +79,24 @@ extern void pwmSetClock (int divisor) ;
extern void gpioClockSet (int pin, int freq) ;
// Interrupts
extern int (*waitForInterrupt) (int pin, int mS) ;
extern int waitForInterrupt (int pin, int mS) ;
extern int wiringPiISR (int pin, int mode, void (*function)(void)) ;
// Threads
extern int piThreadCreate (void *(*fn)(void *)) ;
extern void piLock (int key) ;
extern void piUnlock (int key) ;
extern int piThreadCreate (void *(*fn)(void *)) ;
extern void piLock (int key) ;
extern void piUnlock (int key) ;
// Schedulling priority
extern int piHiPri (int pri) ;
// Extras from arduino land
extern int piHiPri (const int pri) ;
// Delays and Timing
extern void delay (unsigned int howLong) ;
extern void delayMicroseconds (unsigned int howLong) ;
extern unsigned int millis (void) ;
extern unsigned int micros (void) ;
// WiringSerial
extern int serialOpen (const char *device, const int baud) ;
extern void serialClose (const int fd) ;
extern void serialFlush (const int fd) ;
extern void serialPutchar (const int fd, const unsigned char c) ;
extern void serialPuts (const int fd, const char *s) ;
extern void serialPrintf (const int fd, const char *message, ...) ;
extern int serialDataAvail (const int fd) ;
extern int serialGetchar (const int fd) ;
// Shifting
extern void shiftOut (uint8_t dPin, uint8_t cPin, uint8_t order, uint8_t val);
extern uint8_t shiftIn (uint8_t dPin, uint8_t cPin, uint8_t order);
// Spi
%typemap(in) (unsigned char *data, int len) {
$1 = (unsigned char *) PyString_AsString($input);
$2 = PyString_Size($input);
};
int wiringPiSPIGetFd (int channel) ;
int wiringPiSPIDataRW (int channel, unsigned char *data, int len) ;
int wiringPiSPISetup (int channel, int speed) ;
// i2c
extern int wiringPiI2CSetupInterface (char *device, int devId) ;
extern int wiringPiI2CSetup (int devId) ;
extern int wiringPiI2CRead (int fd) ;
extern int wiringPiI2CReadReg8 (int fd, int reg) ;
extern int wiringPiI2CReadReg16 (int fd, int reg) ;
extern int wiringPiI2CWrite (int fd, int data) ;
extern int wiringPiI2CWriteReg8 (int fd, int reg, int data) ;
extern int wiringPiI2CWriteReg16 (int fd, int reg, int data) ;
// Soft Tone
extern int softToneCreate (int pin) ;
extern void softToneWrite (int pin, int frewq) ;
// Soft Servo
extern void softServoWrite (int pin, int value) ;
extern int softServoSetup (int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7) ;
// Soft PWM
extern int softPwmCreate (int pin, int value, int range) ;
extern void softPwmWrite (int pin, int value) ;
// MCP and stuff
extern int mcp23008Setup (const int pinBase, const int i2cAddress) ;
extern int mcp23016Setup (const int pinBase, const int i2cAddress) ;
extern int mcp23017Setup (const int pinBase, const int i2cAddress) ;
extern int mcp23s08Setup (const int pinBase, const int spiPort, const int devId) ;
extern int mcp23s17Setup (int pinBase, int spiPort, int devId) ;
extern int mcp3002Setup (int pinBase, int spiChannel) ;
extern int mcp3422Setup (int pinBase, int i2cAddress, int channels, int sampleRate, int gain) ;
extern int mcp4802Setup (int pinBase, int spiChannel) ;
extern int pcf8574Setup (const int pinBase, const int i2cAddress) ;
extern int pcf8591Setup (const int pinBase, const int i2cAddress) ;
extern int sr595Setup (int pinBase, int numPins, int dataPin, int clockPin, int latchPin) ;
// LCD
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 (int rows, int cols, int bits, int rs, int strb,
int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7) ;
// ds1302
extern unsigned int ds1302rtcRead (const int reg) ;
extern void ds1302rtcWrite (const int reg, const unsigned int data) ;
@@ -193,7 +113,7 @@ extern int gertboardAnalogRead (const int chan) ;
extern int gertboardSPISetup (void) ;
extern int gertboardAnalogSetup (const int pinBase) ;
// LCD128x64
// LCD 128x64
extern void lcd128x64setOrigin (int x, int y) ;
extern void lcd128x64setOrientation (int orientation) ;
extern void lcd128x64orientCoordinates (int *x, int *y) ;
@@ -210,9 +130,25 @@ extern void lcd128x64update (void) ;
extern void lcd128x64clear (int colour) ;
extern int lcd128x64setup (void) ;
// NES Joystick
extern int setupNesJoystick (int dPin, int cPin, int lPin) ;
extern unsigned int readNesJoystick (int joystick) ;
// LCD
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) ;
// PiFace
extern int piFaceSetup (const int pinBase) ;
// PiGlow
extern void piGlow1 (const int leg, const int ring, const int intensity) ;
@@ -220,4 +156,69 @@ extern void piGlowLeg (const int leg, const int intensity) ;
extern void piGlowRing (const int ring, const int intensity) ;
extern void piGlowSetup (int clear) ;
// NES
extern int setupNesJoystick (int dPin, int cPin, int lPin) ;
extern unsigned int readNesJoystick (int joystick) ;
// Various IC setup functions
extern int sr595Setup (const int pinBase, const int numPins, const int dataPin, const int clockPin, const int latchPin) ;
extern int drcSetupSerial (const int pinBase, const int numPins, const char *device, const int baud) ;
extern int max31855Setup (int pinBase, int spiChannel) ;
extern int max5322Setup (int pinBase, int spiChannel) ;
extern int mcp23008Setup (const int pinBase, const int i2cAddress) ;
extern int mcp23016Setup (const int pinBase, const int i2cAddress) ;
extern int mcp23017Setup (const int pinBase, const int i2cAddress) ;
extern int mcp23s08Setup (const int pinBase, const int spiPort, const int devId) ;
extern int mcp23s17Setup (int pinBase, int spiPort, int devId) ;
extern int mcp3002Setup (int pinBase, int spiChannel) ;
extern int mcp3004Setup (int pinBase, int spiChannel) ;
extern int mcp3422Setup (int pinBase, int i2cAddress, int sampleRate, int gain) ;
extern int mcp4802Setup (int pinBase, int spiChannel) ;
extern int pcf8574Setup (const int pinBase, const int i2cAddress) ;
extern int pcf8591Setup (const int pinBase, const int i2cAddress) ;
extern int sn3218Setup (int pinBase) ;
// Soft PWM
extern int softPwmCreate (int pin, int value, int range) ;
extern void softPwmWrite (int pin, int value) ;
extern void softPwmStop (int pin) ;
// Soft Servo
extern void softServoWrite (int pin, int value) ;
extern int softServoSetup (int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7) ;
// Soft Tone
extern int softToneCreate (int pin) ;
extern void softToneStop (int pin) ;
extern void softToneWrite (int pin, int freq) ;
// SPI
int wiringPiSPIGetFd (int channel) ;
int wiringPiSPIDataRW (int channel, unsigned char *data, int len) ;
int wiringPiSPISetup (int channel, int speed) ;
// I2C
extern int wiringPiI2CRead (int fd) ;
extern int wiringPiI2CReadReg8 (int fd, int reg) ;
extern int wiringPiI2CReadReg16 (int fd, int reg) ;
extern int wiringPiI2CWrite (int fd, int data) ;
extern int wiringPiI2CWriteReg8 (int fd, int reg, int data) ;
extern int wiringPiI2CWriteReg16 (int fd, int reg, int data) ;
extern int wiringPiI2CSetupInterface (const char *device, int devId) ;
extern int wiringPiI2CSetup (const int devId) ;
// WiringSerial
extern int serialOpen (const char *device, const int baud) ;
extern void serialClose (const int fd) ;
extern void serialFlush (const int fd) ;
extern void serialPutchar (const int fd, const unsigned char c) ;
extern void serialPuts (const int fd, const char *s) ;
extern void serialPrintf (const int fd, const char *message, ...) ;
extern int serialDataAvail (const int fd) ;
extern int serialGetchar (const int fd) ;
// Shift Register
extern uint8_t shiftIn (uint8_t dPin, uint8_t cPin, uint8_t order) ;
extern void shiftOut (uint8_t dPin, uint8_t cPin, uint8_t order, uint8_t val) ;
%include "wiringpi2-class.py"

481
wiringpi2.py
View File

@@ -68,6 +68,18 @@ except AttributeError:
def wiringPiFailure(*args):
return _wiringpi2.wiringPiFailure(*args)
wiringPiFailure = _wiringpi2.wiringPiFailure
def wiringPiFindNode(*args):
return _wiringpi2.wiringPiFindNode(*args)
wiringPiFindNode = _wiringpi2.wiringPiFindNode
def wiringPiNewNode(*args):
return _wiringpi2.wiringPiNewNode(*args)
wiringPiNewNode = _wiringpi2.wiringPiNewNode
def wiringPiSetup():
return _wiringpi2.wiringPiSetup()
wiringPiSetup = _wiringpi2.wiringPiSetup
@@ -84,9 +96,9 @@ def wiringPiSetupPhys():
return _wiringpi2.wiringPiSetupPhys()
wiringPiSetupPhys = _wiringpi2.wiringPiSetupPhys
def piFaceSetup(*args):
return _wiringpi2.piFaceSetup(*args)
piFaceSetup = _wiringpi2.piFaceSetup
def pinModeAlt(*args):
return _wiringpi2.pinModeAlt(*args)
pinModeAlt = _wiringpi2.pinModeAlt
def pinMode(*args):
return _wiringpi2.pinMode(*args)
@@ -120,10 +132,18 @@ def piBoardRev():
return _wiringpi2.piBoardRev()
piBoardRev = _wiringpi2.piBoardRev
def piBoardId(*args):
return _wiringpi2.piBoardId(*args)
piBoardId = _wiringpi2.piBoardId
def wpiPinToGpio(*args):
return _wiringpi2.wpiPinToGpio(*args)
wpiPinToGpio = _wiringpi2.wpiPinToGpio
def physPinToGpio(*args):
return _wiringpi2.physPinToGpio(*args)
physPinToGpio = _wiringpi2.physPinToGpio
def setPadDrive(*args):
return _wiringpi2.setPadDrive(*args)
setPadDrive = _wiringpi2.setPadDrive
@@ -132,6 +152,10 @@ def getAlt(*args):
return _wiringpi2.getAlt(*args)
getAlt = _wiringpi2.getAlt
def pwmToneWrite(*args):
return _wiringpi2.pwmToneWrite(*args)
pwmToneWrite = _wiringpi2.pwmToneWrite
def digitalWriteByte(*args):
return _wiringpi2.digitalWriteByte(*args)
digitalWriteByte = _wiringpi2.digitalWriteByte
@@ -152,6 +176,10 @@ def gpioClockSet(*args):
return _wiringpi2.gpioClockSet(*args)
gpioClockSet = _wiringpi2.gpioClockSet
def waitForInterrupt(*args):
return _wiringpi2.waitForInterrupt(*args)
waitForInterrupt = _wiringpi2.waitForInterrupt
def wiringPiISR(*args):
return _wiringpi2.wiringPiISR(*args)
wiringPiISR = _wiringpi2.wiringPiISR
@@ -188,206 +216,6 @@ def micros():
return _wiringpi2.micros()
micros = _wiringpi2.micros
def serialOpen(*args):
return _wiringpi2.serialOpen(*args)
serialOpen = _wiringpi2.serialOpen
def serialClose(*args):
return _wiringpi2.serialClose(*args)
serialClose = _wiringpi2.serialClose
def serialFlush(*args):
return _wiringpi2.serialFlush(*args)
serialFlush = _wiringpi2.serialFlush
def serialPutchar(*args):
return _wiringpi2.serialPutchar(*args)
serialPutchar = _wiringpi2.serialPutchar
def serialPuts(*args):
return _wiringpi2.serialPuts(*args)
serialPuts = _wiringpi2.serialPuts
def serialPrintf(*args):
return _wiringpi2.serialPrintf(*args)
serialPrintf = _wiringpi2.serialPrintf
def serialDataAvail(*args):
return _wiringpi2.serialDataAvail(*args)
serialDataAvail = _wiringpi2.serialDataAvail
def serialGetchar(*args):
return _wiringpi2.serialGetchar(*args)
serialGetchar = _wiringpi2.serialGetchar
def shiftOut(*args):
return _wiringpi2.shiftOut(*args)
shiftOut = _wiringpi2.shiftOut
def shiftIn(*args):
return _wiringpi2.shiftIn(*args)
shiftIn = _wiringpi2.shiftIn
def wiringPiSPIGetFd(*args):
return _wiringpi2.wiringPiSPIGetFd(*args)
wiringPiSPIGetFd = _wiringpi2.wiringPiSPIGetFd
def wiringPiSPIDataRW(*args):
return _wiringpi2.wiringPiSPIDataRW(*args)
wiringPiSPIDataRW = _wiringpi2.wiringPiSPIDataRW
def wiringPiSPISetup(*args):
return _wiringpi2.wiringPiSPISetup(*args)
wiringPiSPISetup = _wiringpi2.wiringPiSPISetup
def wiringPiI2CSetupInterface(*args):
return _wiringpi2.wiringPiI2CSetupInterface(*args)
wiringPiI2CSetupInterface = _wiringpi2.wiringPiI2CSetupInterface
def wiringPiI2CSetup(*args):
return _wiringpi2.wiringPiI2CSetup(*args)
wiringPiI2CSetup = _wiringpi2.wiringPiI2CSetup
def wiringPiI2CRead(*args):
return _wiringpi2.wiringPiI2CRead(*args)
wiringPiI2CRead = _wiringpi2.wiringPiI2CRead
def wiringPiI2CReadReg8(*args):
return _wiringpi2.wiringPiI2CReadReg8(*args)
wiringPiI2CReadReg8 = _wiringpi2.wiringPiI2CReadReg8
def wiringPiI2CReadReg16(*args):
return _wiringpi2.wiringPiI2CReadReg16(*args)
wiringPiI2CReadReg16 = _wiringpi2.wiringPiI2CReadReg16
def wiringPiI2CWrite(*args):
return _wiringpi2.wiringPiI2CWrite(*args)
wiringPiI2CWrite = _wiringpi2.wiringPiI2CWrite
def wiringPiI2CWriteReg8(*args):
return _wiringpi2.wiringPiI2CWriteReg8(*args)
wiringPiI2CWriteReg8 = _wiringpi2.wiringPiI2CWriteReg8
def wiringPiI2CWriteReg16(*args):
return _wiringpi2.wiringPiI2CWriteReg16(*args)
wiringPiI2CWriteReg16 = _wiringpi2.wiringPiI2CWriteReg16
def softToneCreate(*args):
return _wiringpi2.softToneCreate(*args)
softToneCreate = _wiringpi2.softToneCreate
def softToneWrite(*args):
return _wiringpi2.softToneWrite(*args)
softToneWrite = _wiringpi2.softToneWrite
def softServoWrite(*args):
return _wiringpi2.softServoWrite(*args)
softServoWrite = _wiringpi2.softServoWrite
def softServoSetup(*args):
return _wiringpi2.softServoSetup(*args)
softServoSetup = _wiringpi2.softServoSetup
def softPwmCreate(*args):
return _wiringpi2.softPwmCreate(*args)
softPwmCreate = _wiringpi2.softPwmCreate
def softPwmWrite(*args):
return _wiringpi2.softPwmWrite(*args)
softPwmWrite = _wiringpi2.softPwmWrite
def mcp23008Setup(*args):
return _wiringpi2.mcp23008Setup(*args)
mcp23008Setup = _wiringpi2.mcp23008Setup
def mcp23016Setup(*args):
return _wiringpi2.mcp23016Setup(*args)
mcp23016Setup = _wiringpi2.mcp23016Setup
def mcp23017Setup(*args):
return _wiringpi2.mcp23017Setup(*args)
mcp23017Setup = _wiringpi2.mcp23017Setup
def mcp23s08Setup(*args):
return _wiringpi2.mcp23s08Setup(*args)
mcp23s08Setup = _wiringpi2.mcp23s08Setup
def mcp23s17Setup(*args):
return _wiringpi2.mcp23s17Setup(*args)
mcp23s17Setup = _wiringpi2.mcp23s17Setup
def mcp3002Setup(*args):
return _wiringpi2.mcp3002Setup(*args)
mcp3002Setup = _wiringpi2.mcp3002Setup
def mcp3422Setup(*args):
return _wiringpi2.mcp3422Setup(*args)
mcp3422Setup = _wiringpi2.mcp3422Setup
def mcp4802Setup(*args):
return _wiringpi2.mcp4802Setup(*args)
mcp4802Setup = _wiringpi2.mcp4802Setup
def pcf8574Setup(*args):
return _wiringpi2.pcf8574Setup(*args)
pcf8574Setup = _wiringpi2.pcf8574Setup
def pcf8591Setup(*args):
return _wiringpi2.pcf8591Setup(*args)
pcf8591Setup = _wiringpi2.pcf8591Setup
def sr595Setup(*args):
return _wiringpi2.sr595Setup(*args)
sr595Setup = _wiringpi2.sr595Setup
def lcdHome(*args):
return _wiringpi2.lcdHome(*args)
lcdHome = _wiringpi2.lcdHome
def lcdClear(*args):
return _wiringpi2.lcdClear(*args)
lcdClear = _wiringpi2.lcdClear
def lcdDisplay(*args):
return _wiringpi2.lcdDisplay(*args)
lcdDisplay = _wiringpi2.lcdDisplay
def lcdCursor(*args):
return _wiringpi2.lcdCursor(*args)
lcdCursor = _wiringpi2.lcdCursor
def lcdCursorBlink(*args):
return _wiringpi2.lcdCursorBlink(*args)
lcdCursorBlink = _wiringpi2.lcdCursorBlink
def lcdSendCommand(*args):
return _wiringpi2.lcdSendCommand(*args)
lcdSendCommand = _wiringpi2.lcdSendCommand
def lcdPosition(*args):
return _wiringpi2.lcdPosition(*args)
lcdPosition = _wiringpi2.lcdPosition
def lcdCharDef(*args):
return _wiringpi2.lcdCharDef(*args)
lcdCharDef = _wiringpi2.lcdCharDef
def lcdPutchar(*args):
return _wiringpi2.lcdPutchar(*args)
lcdPutchar = _wiringpi2.lcdPutchar
def lcdPuts(*args):
return _wiringpi2.lcdPuts(*args)
lcdPuts = _wiringpi2.lcdPuts
def lcdPrintf(*args):
return _wiringpi2.lcdPrintf(*args)
lcdPrintf = _wiringpi2.lcdPrintf
def lcdInit(*args):
return _wiringpi2.lcdInit(*args)
lcdInit = _wiringpi2.lcdInit
def ds1302rtcRead(*args):
return _wiringpi2.ds1302rtcRead(*args)
ds1302rtcRead = _wiringpi2.ds1302rtcRead
@@ -496,13 +324,57 @@ def lcd128x64setup():
return _wiringpi2.lcd128x64setup()
lcd128x64setup = _wiringpi2.lcd128x64setup
def setupNesJoystick(*args):
return _wiringpi2.setupNesJoystick(*args)
setupNesJoystick = _wiringpi2.setupNesJoystick
def lcdHome(*args):
return _wiringpi2.lcdHome(*args)
lcdHome = _wiringpi2.lcdHome
def readNesJoystick(*args):
return _wiringpi2.readNesJoystick(*args)
readNesJoystick = _wiringpi2.readNesJoystick
def lcdClear(*args):
return _wiringpi2.lcdClear(*args)
lcdClear = _wiringpi2.lcdClear
def lcdDisplay(*args):
return _wiringpi2.lcdDisplay(*args)
lcdDisplay = _wiringpi2.lcdDisplay
def lcdCursor(*args):
return _wiringpi2.lcdCursor(*args)
lcdCursor = _wiringpi2.lcdCursor
def lcdCursorBlink(*args):
return _wiringpi2.lcdCursorBlink(*args)
lcdCursorBlink = _wiringpi2.lcdCursorBlink
def lcdSendCommand(*args):
return _wiringpi2.lcdSendCommand(*args)
lcdSendCommand = _wiringpi2.lcdSendCommand
def lcdPosition(*args):
return _wiringpi2.lcdPosition(*args)
lcdPosition = _wiringpi2.lcdPosition
def lcdCharDef(*args):
return _wiringpi2.lcdCharDef(*args)
lcdCharDef = _wiringpi2.lcdCharDef
def lcdPutchar(*args):
return _wiringpi2.lcdPutchar(*args)
lcdPutchar = _wiringpi2.lcdPutchar
def lcdPuts(*args):
return _wiringpi2.lcdPuts(*args)
lcdPuts = _wiringpi2.lcdPuts
def lcdPrintf(*args):
return _wiringpi2.lcdPrintf(*args)
lcdPrintf = _wiringpi2.lcdPrintf
def lcdInit(*args):
return _wiringpi2.lcdInit(*args)
lcdInit = _wiringpi2.lcdInit
def piFaceSetup(*args):
return _wiringpi2.piFaceSetup(*args)
piFaceSetup = _wiringpi2.piFaceSetup
def piGlow1(*args):
return _wiringpi2.piGlow1(*args)
@@ -519,6 +391,194 @@ piGlowRing = _wiringpi2.piGlowRing
def piGlowSetup(*args):
return _wiringpi2.piGlowSetup(*args)
piGlowSetup = _wiringpi2.piGlowSetup
def setupNesJoystick(*args):
return _wiringpi2.setupNesJoystick(*args)
setupNesJoystick = _wiringpi2.setupNesJoystick
def readNesJoystick(*args):
return _wiringpi2.readNesJoystick(*args)
readNesJoystick = _wiringpi2.readNesJoystick
def sr595Setup(*args):
return _wiringpi2.sr595Setup(*args)
sr595Setup = _wiringpi2.sr595Setup
def drcSetupSerial(*args):
return _wiringpi2.drcSetupSerial(*args)
drcSetupSerial = _wiringpi2.drcSetupSerial
def max31855Setup(*args):
return _wiringpi2.max31855Setup(*args)
max31855Setup = _wiringpi2.max31855Setup
def max5322Setup(*args):
return _wiringpi2.max5322Setup(*args)
max5322Setup = _wiringpi2.max5322Setup
def mcp23008Setup(*args):
return _wiringpi2.mcp23008Setup(*args)
mcp23008Setup = _wiringpi2.mcp23008Setup
def mcp23016Setup(*args):
return _wiringpi2.mcp23016Setup(*args)
mcp23016Setup = _wiringpi2.mcp23016Setup
def mcp23017Setup(*args):
return _wiringpi2.mcp23017Setup(*args)
mcp23017Setup = _wiringpi2.mcp23017Setup
def mcp23s08Setup(*args):
return _wiringpi2.mcp23s08Setup(*args)
mcp23s08Setup = _wiringpi2.mcp23s08Setup
def mcp23s17Setup(*args):
return _wiringpi2.mcp23s17Setup(*args)
mcp23s17Setup = _wiringpi2.mcp23s17Setup
def mcp3002Setup(*args):
return _wiringpi2.mcp3002Setup(*args)
mcp3002Setup = _wiringpi2.mcp3002Setup
def mcp3004Setup(*args):
return _wiringpi2.mcp3004Setup(*args)
mcp3004Setup = _wiringpi2.mcp3004Setup
def mcp3422Setup(*args):
return _wiringpi2.mcp3422Setup(*args)
mcp3422Setup = _wiringpi2.mcp3422Setup
def mcp4802Setup(*args):
return _wiringpi2.mcp4802Setup(*args)
mcp4802Setup = _wiringpi2.mcp4802Setup
def pcf8574Setup(*args):
return _wiringpi2.pcf8574Setup(*args)
pcf8574Setup = _wiringpi2.pcf8574Setup
def pcf8591Setup(*args):
return _wiringpi2.pcf8591Setup(*args)
pcf8591Setup = _wiringpi2.pcf8591Setup
def sn3218Setup(*args):
return _wiringpi2.sn3218Setup(*args)
sn3218Setup = _wiringpi2.sn3218Setup
def softPwmCreate(*args):
return _wiringpi2.softPwmCreate(*args)
softPwmCreate = _wiringpi2.softPwmCreate
def softPwmWrite(*args):
return _wiringpi2.softPwmWrite(*args)
softPwmWrite = _wiringpi2.softPwmWrite
def softPwmStop(*args):
return _wiringpi2.softPwmStop(*args)
softPwmStop = _wiringpi2.softPwmStop
def softServoWrite(*args):
return _wiringpi2.softServoWrite(*args)
softServoWrite = _wiringpi2.softServoWrite
def softServoSetup(*args):
return _wiringpi2.softServoSetup(*args)
softServoSetup = _wiringpi2.softServoSetup
def softToneCreate(*args):
return _wiringpi2.softToneCreate(*args)
softToneCreate = _wiringpi2.softToneCreate
def softToneStop(*args):
return _wiringpi2.softToneStop(*args)
softToneStop = _wiringpi2.softToneStop
def softToneWrite(*args):
return _wiringpi2.softToneWrite(*args)
softToneWrite = _wiringpi2.softToneWrite
def wiringPiSPIGetFd(*args):
return _wiringpi2.wiringPiSPIGetFd(*args)
wiringPiSPIGetFd = _wiringpi2.wiringPiSPIGetFd
def wiringPiSPIDataRW(*args):
return _wiringpi2.wiringPiSPIDataRW(*args)
wiringPiSPIDataRW = _wiringpi2.wiringPiSPIDataRW
def wiringPiSPISetup(*args):
return _wiringpi2.wiringPiSPISetup(*args)
wiringPiSPISetup = _wiringpi2.wiringPiSPISetup
def wiringPiI2CRead(*args):
return _wiringpi2.wiringPiI2CRead(*args)
wiringPiI2CRead = _wiringpi2.wiringPiI2CRead
def wiringPiI2CReadReg8(*args):
return _wiringpi2.wiringPiI2CReadReg8(*args)
wiringPiI2CReadReg8 = _wiringpi2.wiringPiI2CReadReg8
def wiringPiI2CReadReg16(*args):
return _wiringpi2.wiringPiI2CReadReg16(*args)
wiringPiI2CReadReg16 = _wiringpi2.wiringPiI2CReadReg16
def wiringPiI2CWrite(*args):
return _wiringpi2.wiringPiI2CWrite(*args)
wiringPiI2CWrite = _wiringpi2.wiringPiI2CWrite
def wiringPiI2CWriteReg8(*args):
return _wiringpi2.wiringPiI2CWriteReg8(*args)
wiringPiI2CWriteReg8 = _wiringpi2.wiringPiI2CWriteReg8
def wiringPiI2CWriteReg16(*args):
return _wiringpi2.wiringPiI2CWriteReg16(*args)
wiringPiI2CWriteReg16 = _wiringpi2.wiringPiI2CWriteReg16
def wiringPiI2CSetupInterface(*args):
return _wiringpi2.wiringPiI2CSetupInterface(*args)
wiringPiI2CSetupInterface = _wiringpi2.wiringPiI2CSetupInterface
def wiringPiI2CSetup(*args):
return _wiringpi2.wiringPiI2CSetup(*args)
wiringPiI2CSetup = _wiringpi2.wiringPiI2CSetup
def serialOpen(*args):
return _wiringpi2.serialOpen(*args)
serialOpen = _wiringpi2.serialOpen
def serialClose(*args):
return _wiringpi2.serialClose(*args)
serialClose = _wiringpi2.serialClose
def serialFlush(*args):
return _wiringpi2.serialFlush(*args)
serialFlush = _wiringpi2.serialFlush
def serialPutchar(*args):
return _wiringpi2.serialPutchar(*args)
serialPutchar = _wiringpi2.serialPutchar
def serialPuts(*args):
return _wiringpi2.serialPuts(*args)
serialPuts = _wiringpi2.serialPuts
def serialPrintf(*args):
return _wiringpi2.serialPrintf(*args)
serialPrintf = _wiringpi2.serialPrintf
def serialDataAvail(*args):
return _wiringpi2.serialDataAvail(*args)
serialDataAvail = _wiringpi2.serialDataAvail
def serialGetchar(*args):
return _wiringpi2.serialGetchar(*args)
serialGetchar = _wiringpi2.serialGetchar
def shiftIn(*args):
return _wiringpi2.shiftIn(*args)
shiftIn = _wiringpi2.shiftIn
def shiftOut(*args):
return _wiringpi2.shiftOut(*args)
shiftOut = _wiringpi2.shiftOut
class nes(object):
def setupNesJoystick(self,*args):
return setupNesJoystick(*args)
@@ -674,7 +734,7 @@ class GPIO(object):
def softPwmCreate(self,*args):
return softPwmCreate(*args)
def softPwmWrite(self,*args):
return softPwmWrite(*args)
return sofPwmWrite(*args)
def softToneCreate(self,*args):
return softToneCreate(*args)
@@ -708,5 +768,4 @@ class GPIO(object):
# This file is compatible with both classic and new-style classes.
cvar = _wiringpi2.cvar

BIN
wiringpi2.pyc
View File

Binary file not shown.

4406
wiringpi_wrap.c
View File

File diff suppressed because it is too large Load Diff