You’ve been spotted! http://hackaday.com/2012/05/06/using-arduino-shields-with-the-raspberry-pi/ 🙂

Just got some of my Arduino stuff ported to Raspberry Pi!
Thanks for doing some great work.

if you add

#ifdef __cplusplus
extern "C" {
#endif

and

#ifdef __cplusplus
}
#endif

to your wiringPi.h then it plays nicely with c++ code.

Gordon
Thanks for you wiring Pi code, I have used it with JNI to get my Java code interfacing with GPIO pins. I am now trying to extend it to do the i2c interface and was trying to setup the #defines when I noticed the PWM defines were not what I was expecting. Your code has…
#define PWM_CONTROL 0
#define PWM_STATUS 1
#define PWM0_RANGE 4
#define PWM0_DATA 5
#define PWM1_RANGE 8
#define PWM1_DATA 9
whereas the BCM2835 describes , for example , the Range registers as being offset as follows
RNG1 0x14 and
RNG2 0x20. (I note also the spec refers to RNG1 and RNG2 instead of the #defines PWM0 and 1)

Clearly your code works as I can see the LED correctly varying in intensity, but I cannot see how the offset work ?
I was trying to do the same for I2C(BSC) registers and I had the following

#define I2C_0 (BCM2708_PERI_BASE + 0x205000)
#define I2C_1 (BCM2708_PERI_BASE + 0x804000)

#define I2C_CONTROL_OFFSET 0x0
#define I2C_STATUS_OFFSET 0x4
#define I2C_DLEN_OFFSET 0x8
#define I2C_SLAVE_ADDRESS_OFFSET 0xc
#define I2C_DATA_FIFO_OFFSET 0x10
#define I2C_CLOCK_DIVIDER_OFFSET 0x14
#define I2C_DATA_DELAY_OFFSET 0x18

but now I am not sure I have understood correctly.

Many thanks for any help
Steve

Gordon, thanks for providing us the wiringPi library. I thought you might like to know that I made a small Java wrapper for it, to allow anyone using that language to read from, and write to the pins. The project can be downloaded from GitHub: https://github.com/jkransen/framboos

I made a blog about it here: http://jkransen.wordpress.com/2012/07/16/raspberry-pi/

Many thanks!

Jeroen

Thanks for posting the Shift Library on the website but I don’t seem to get a clock pulse on the pin I defined – This is my “simple” code

#include
#include
#include
#include

#include

int main(void){
int LatchPin=2,DataPin=0,ClockPin=1;
printf(“Raspberry Pi Shift Out Test\n”) ;
printf(“%d\n”,LatchPin);
printf(“%d\n”,DataPin);
printf(“%d\n”,ClockPin);
if (wiringPiSetup() == -1)
exit (1) ;

pinMode(LatchPin, OUTPUT);
pinMode(DataPin, OUTPUT);
pinMode(ClockPin, OUTPUT);

shiftOut(DataPin,ClockPin,1,85);

digitalWrite(LatchPin, 1);
delay(100);
digitalWrite(LatchPin, 0);
return 0;
}

I just can’t see what’s wrong

Thanks

Paul

Hi Gordon,
I’ve been playing around with the PWM control using your gpio program. I hooked a scope up to the Wiring Pi pin 1 (GPIO pin 18) and noticed that when the PWM value is changed between 0 and 1023, the duty cycle of the signal is indeed changing from 0% to 100% as would be expected. However, the frequency of the PWM signal itself is also changing. For example, at pwm=511 (50% duty) the frequency (over one period of the PWM signal) is 300kHz. Interestingly, with pwm=255 (25% duty), the frequency of the signal drops to 150kHz. I would normally expect the frequency to remain static and just the duty cycle change.

You are a god of programming!
Thanks for wiringpi!
With this solving robotycs is very simple thing.

Hi Gordon,

Just like to say a big thank you for wiringpi it’s a great help for us less talented programmers. I have a couple of question/suggestions for improvement:

1) Can you add DESTDIR to the makefile to make distribution packaging a little easier?

2) I have been looking as the pwm output on my oscilloscope and to my surprise the output was not as I expected in that as you adjust the pulse width the frequency changes. In fact what is happening here is that for values between 0-512 the high level pulse remains constant and the low level is extended, once above 512 the reverse happens (low level constant and high level changes). Peak frequency is 300kHz with a value of 512 and drops below 18kHz for low and high values. The other point is that you need values of exactly 2^n for stable pulses up to 512 and 1024-2^n for stable pulses above 512.

I have experimented with wiringpi.c to see is I can achieve a more traditional pwm output and I am happy to report that you can. The solution is to switch to MS_MODE rather than PWM_MODE. The downside of this is that the pwm frequency is rather slow at around 600Hz and even with PWMCLK_DIV set to 2 is still still only 9kHz. I then tried different clock sources and have found that using PLLD as the source with PWMCLK_DIV set to 16 gives a much more respectable pwm frequency of 30.5kHz. Whith these settings the frequency is stable and constant regardless of the pwm value chosen.

I hope this is of some help,

Regards,

Chris

Does this allow me to use my Arduino boards and libraries on the RPI? I need to get my NRF24L01 RF Transceiver working on the Pi so it can communicate iwth an Arduino which also has that transceiver connected (thus enabling me to wirelessly control things attached to the Arduino). Problem is that I have practically no experience in directly controlling hardware. I have always imported libraries in my Arduino code and controlled everything through those libraries. The only hardware I have ever directly read from was a potentiometer and the only thing I have ever directly controlled was a simple LED.

great program. you’ve saved me a lot of time 😀
thank you!!!

Hello,

I’m trying to control a servo using the pwm pin. The problem is I want to use wiringPi (or later on the python wrap) but need settings different from default divisor and range. How to change this parameter in wiringPi? I tried this:
#include

#include
#include
#include

int main (void)
{
int pin ;
int bitCount ;
int bits;

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

bitCount = 16 ;
if (bitCount > 32) bitCount = 32;
if (bitCount < 1) bitCount = 1;
bits = 0;
while (bitCount) {
bits < 32) bitCount = 32;
if (bitCount < 1) bitCount = 1;
bits = 0;
while (bitCount) {
bits <<= 1;
bits |= 1;
bitCount–;
}
pwmWrite(1, 400);
delay (1000);
return 0 ;
}

but didn't work.

Thank you.

Hi, i’ve noticed that wiringPi has UART functionality, at the moment i have my UART tx/rx looped. I have minicom open and in terminal i run “sudo echo – “testing testing 1 2 1 2″ > /dev/ttyAMA0” and can see the text testing testing 1 2 1 2 in minicom. My question is can i write a program using wiringPi that would give the same output? Like printf but for /dev/ttyAMA0?

Thanks
-Matt

Hi, thanks for all the work, I hope you have time to help me solve a problem.

I’m using an up to date raspbian install, kernel info “3.2.27+ #250 PREEMPT Thu Oct 18 19:03:02” on a v1 (256Mb) board.

I am trying to receive and decode the signals from a standard RC receiver. This is encoded as variable length pulses within a given time frame. I use edge detection the both directions and record the time differences to do the decode. There are 6 channels, so I use 6 pins to read with.

With wiringPiSetupSys(), I can just about get stable readings from all 6 channels. Sadly if I then try to do anything like play audio in response to an input, then the accuracy drops for my channels to the point where it is not usable.

I need less overhead and jitter, but when I swap to wiringPiSetupGpio() or wiringPiSetup() I don’t seem to be getting any interrupts at all ?

(Have tried both “native” and wiringpi pin numbers.)

Any thoughts ?

Gordon.. Firstly.. great job..

I have installed wiringpi on my raspberrypi and am using a sample from http://www.raspberrypi.org/phpBB3/viewtopic.php?t=16118&p=191051 to control 4 motors that I have linked to using http://shieldlist.org/adafruit/motor.

I have hooked up all the pins and seem to have everything ready but when I run the code executable even though it says its applying pwm absolutely nothing happens!

Is there anything else I need to install to be able to use the Arduino motor shield or is wiringpi enough?

Thank you thank you Gordon! You’ve have saved me a lot time.

Hi. I am unable to get wiringPi working on my rev2 board in turbo mode, I get: gpio: Unable to initialise wiringPi mode. I am using raspbian with latest updates (and rpi-update). With WIRINGPI_DEBUG I get this:

# gpio readall
gpio: wiringPi debug mode enabled
wiringPi: Debug mode enabled
wiringPi: wiringPiSetup called
piboardRev: Revision string: Revision : 000f
piboardRev: lastChar is: ‘f’ (102, 0x66)
piBoardRev: Returning revision: 2
wiringPiSetup: mmap failed (pads): Success
gpio: Unable to initialise wiringPi mode

Any ideas?

is there a way to use wiringPi & I2C with QTCreator

The two last question I figure out reading your Funtions (API).

Thanks for the suggestion. This worked when issuing in command line, both pins set to 0V. Rebooted and both pins defaulted to 3V3.

What is weird is that I had this working for a short time. By working, I mean I could run the above python script and see a response on the oscilliscope. Then, had to run to class, come back, and of course I’m getting no response.

I’ve read above that you want this section to be questions and comments on your wiringpi library and not a forum, so let me know if I should post elsewhere, or what other troubleshooting steps I may be able to take.

Thanks for the suggestion of a boot script to resolve the issue of needing to be root in order to export the pins. It works well, but is probably not as clean as a good script writer could produce.
#!/bin/bash
# Setup script for pin functions using gpio
# This script should go in /etc/init.d/
# Make the script executable: sudo chmod 755 /etc/init.d/exportPiPins.sh
# After testing (sudo /etc/init.d/exportPiPins.sh), register the script
# to run at boot time: sudo update-rc.d exportPiPins.sh defaults
# You should modify the script to export the pins you need so they will
# be available to user programs. The pin numbers are BCM-GPIO pins.
# See web or documentation for mapping to physical pins.

### BEGIN INIT INFO
# Provides: gpio17
# Required-Start: $network $syslog
# Default-Start: 2 3 4 5
# Required-Stop: $network
# Default-Stop: 0 1 6
# Short Description: Export Pins
# Description: Export Pins at boot and unexport pins at shutdown
### END INIT INFO

# Author: Mike Beaver
# Thanks to Gordon@Drogon.net for pointing out that a boot script would resolve
# the problem with needing root privileges to do anything with the gpio pins.
# Once the pins are exported, his WiringPi utilities and library work just fine
# for a normal non-root user. Just the thing for a headless web server to run your
# sprinklers, heating system, or ……

case “$1” in
start)
echo 0 > /sys/class/gpio/export
echo 1 > /sys/class/gpio/export
echo 4 > /sys/class/gpio/export
echo 9 > /sys/class/gpio/export
echo 10 > /sys/class/gpio/export
echo 11 > /sys/class/gpio/export
echo 17 > /sys/class/gpio/export
echo 18 > /sys/class/gpio/export
echo 22 > /sys/class/gpio/export
echo 23 > /sys/class/gpio/export
echo 24 > /sys/class/gpio/export
;;
stop)
echo 0 > /sys/class/gpio/unexport
echo 1 > /sys/class/gpio/unexport
echo 4 > /sys/class/gpio/unexport
echo 9 > /sys/class/gpio/unexport
echo 10 > /sys/class/gpio/unexport
echo 11 > /sys/class/gpio/unexport
echo 17 > /sys/class/gpio/unexport
echo 18 > /sys/class/gpio/unexport
echo 22 > /sys/class/gpio/unexport
echo 23 > /sys/class/gpio/unexport
echo 24 > /sys/class/gpio/unexport
;;
esac
:

Hi Gordon

Thanks for the gertboard code in wiring Pi. I had to adapt it a bit for the ADC and DAC I bought. I thought you may wish to see my changes:

The DAC is RS Stock No. 681-1092 Brand Microchip Mfr Part No. MCP4822-E/P.

For which I had to change gertboardAnalogWrite to:

int gertboardAnalogWrite (int chan, int value)
{
uint8_t spiData [2] ;
uint8_t chanBits, dataBits ;
int iret;
if (chan == 0)
chanBits = 0x30 ; // gain x1 , active, channel A
else
chanBits = 0xB0 ; // gain x1 , active, channel B

chanBits |= ((value >> 8) & 0x0F) ;
dataBits = (value & 0xFf) ;
…

And the ADC is MCP3002 2.7V Dual Channel 10-Bit A/D Converter

For which I had to change gertboardAnalogRead:

int gertboardAnalogRead (int chan)
{
uint8_t spiData [3] ;

int iret;

if (chan == 0)
spiData [0] = 0b01100 ; // single ended channel 0
else
spiData [0] = 0b01110 ; //single ended channel 1

spiData [1] = 0 ;
spiData [2] = 0 ;

if( (iret = wiringPiSPIDataRW (SPI_A2D, spiData, 3))<0){
printf("Error returned by wiringPiSPIDataRW %d",iret);
}
return (spiData[1] <> 5 );
}

Dear Gordon,
I’am working for the first time with Makefiles. In simple programs (they contain only one source file) I’am using your Makefile to build my Projects. But when it comes to more source files, which should be build to a single program, I don’t know what to add to the Makefile…
Could you create an example for a Makefile with at least two C-files and one header?
Thanks a lot!

Bonjour,

Grand merci pour l’aide en ligne !
je viens de faire mon entrée dans le monde de GPIO de RaspBerry PI
A bientôt

Gordon,
A huge thank you for putting this together! I just finished a group semester project and this library was a huge help. We put together the old Simon game using a Raspberry Pi. I threw it up on youtube if you’re interested in checking it out. http://www.youtube.com/watch?v=GmE3ANOYYOY

Hi Gordon I tried to contact you via email but to no avail. I’ve created a C# wrapper class for your WiringPi libraries which include I2C and SPI, the reason being that although there’s already a RaspberryPi.Net solution it uses bit banged SPI which I think is rather poor and inefficient.

I just wanted to let you know in case you want to place a link on your site to the wrapper. It can be found on github: https://github.com/danriches/WiringPi.Net
Other information pertaining to using it is located on my blog, yes it’s sparse as I’ve only just started:
http://danriches.blogspot.co.uk/

Hope this is helpful to anyone out there BUT please be aware that this is only in development stage and SPI is the only thing I’ve tested out so far…

Have Fun and thanks for the great library, you’re a star!!

Dan

Hai,

Anyone played with the BH1750FVI and Raspi V2 ?
Would like to get it running but not finding any good src.. all is for the arduino and not sure if this is a good Wire.h replacement…

Maybe someone can help me out here ?

Chrs Paul.

Hi
WiringPi setup is works correctly and fine i am really thankfull to @Gordon. but there is a problem regarding wiringPiSetup its showing me error when i am running my executable in an infinite loop
its working fine for 5-10 minutes after this an
Error is always occured :

wiringPiSetup: Unable to open /dev/mem: Too many open files

please show me some footmarks of yours on this problem

Hi Gordon. First of all thanks for y help. I am using wiringPiISR for interrupts, but this function run the callback in other thread.
I want to stop my main progam, run the interrupt and then return to the main program is that possible?.

Hi, Gordon, I need your help. Sorry for my bad English, I’m Cuban. I’m great fan of your library.
I need to make a periodic task in the rpi.
I need a frequency of at least 20 Hz and no more than 1 KHz.
I have achieved this by using gettimeofday or clock_gettime in a loop, waiting to get to the right moment. My results are very close to my needs, but i really want to do this in a more efficient way, because i will do other task in the pi (example: image processing).
Is there a way I can use the kernel, a timer, a scheduler, or anything else, to do this?
Is there any other library I could use?
Thanks in advice.

Thanks for that great library.

I have a question related to the “interrupts” with the RPI;
Weirdly, if you put a printf in a call back function, triggered by a physical “pull-up” circuit, the interrupt function ‘wiringPiISR’ calls the callback function multiple times (arround 5-6).

In the other hand, if you put some delay in the callback function, lets say 2000ms, its seems to be called only once…

I guess the RPI is confused with the input state for few milliseconds and therefore triggers the callback function multiple times. What do you think ?