WiringNP: NanoPi NEO/NEO2/Air GPIO Programming with C

查看中文

1 Introduction to WiringPi

The wiringPi library was initially developed by Gordon Henderson in C. It contains libraries to access GPIO, I2C, SPI, UART, PWM and etc.
The wiringPi library contains various libraries, header files and a commandline utility:gpio. The gpio utility can be used to read and write GPIO pins.

2 Introduction to WiringNP

The wiringPi library was initially developed for BCM2835, and later migrated to Allwinner H3 and renamed as WiringNP. Now the WiringNP works with FriendlyElec's NanoPi M1, NanoPi NEO and NanoPi NEO2. The first version was made by wertyzp. FriendlyElec developed a version for Allwinner H5 based NanoPi NEO2.

Here is WiringNP's project page: https://github.com/friendlyarm/WiringNP

3 Install WiringNP

Log into your nano board via SSH, open a terminal and install the WiringNP library by running the following commands:

git clone https://github.com/friendlyarm/WiringNP
cd WiringNP/
chmod 755 build
./build

3.1 Verify WiringNP

The WiringNP library contains a set of gpio commands. Users can use them to access the GPIO pins on a nano board. You can verify your WiringNP by running the following command:

gpio readall

If your installation is successful the following messages will show up:

root@FriendlyARM:~# gpio readall
 +-----+-----+----------+------+---+-NanoPI M1+---+------+----------+-----+-----+
 | BCM | wPi |   Name   | Mode | V | Physical | V | Mode | Name     | wPi | BCM |
 +-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+
 |     |     |     3.3v |      |   |  1 || 2  |   |      | 5v       |     |     |
 |  12 |   8 |    SDA.0 | ALT5 | 0 |  3 || 4  |   |      | 5V       |     |     |
 |  11 |   9 |    SCL.0 | ALT5 | 0 |  5 || 6  |   |      | 0v       |     |     |
 | 203 |   7 |   GPIO.7 |  OUT | 0 |  7 || 8  | 0 | ALT5 | TxD3     | 15  | 198 |
 |     |     |       0v |      |   |  9 || 10 | 0 | ALT5 | RxD3     | 16  | 199 |
 |   0 |   0 |     RxD2 | ALT5 | 0 | 11 || 12 | 0 | OFF  | GPIO.1   | 1   | 6   |
 |   2 |   2 |     TxD2 |  OFF | 0 | 13 || 14 |   |      | 0v       |     |     |
 |   3 |   3 |     CTS2 |  OFF | 0 | 15 || 16 | 0 | OFF  | GPIO.4   | 4   | 200 |
 |     |     |     3.3v |      |   | 17 || 18 | 0 | OFF  | GPIO.5   | 5   | 201 |
 |  64 |  12 |     MOSI | ALT4 | 0 | 19 || 20 |   |      | 0v       |     |     |
 |  65 |  13 |     MISO | ALT4 | 0 | 21 || 22 | 0 | ALT5 | RTS2     | 6   | 1   |
 |  66 |  14 |     SCLK | ALT4 | 0 | 23 || 24 | 0 | ALT4 | CE0      | 10  | 67  |
 |     |     |       0v |      |   | 25 || 26 | 0 | OFF  | GPIO.11  | 11  | 17  |
 |  19 |  30 |    SDA.1 | ALT4 | 0 | 27 || 28 | 0 | ALT4 | SCL.1    | 31  | 18  |
 |  20 |  21 |  GPIO.21 |  OFF | 0 | 29 || 30 |   |      | 0v       |     |     |
 |  21 |  22 |  GPIO.22 |  OFF | 0 | 31 || 32 | 0 | OFF  | RTS1     | 26  | 7   |
 |   8 |  23 |  GPIO.23 |  OFF | 0 | 33 || 34 |   |      | 0v       |     |     |
 |  16 |  24 |  GPIO.24 | ALT4 | 0 | 35 || 36 | 0 | OFF  | CTS1     | 27  | 13  |
 |   9 |  25 |  GPIO.25 |  OFF | 0 | 37 || 38 | 0 | OFF  | TxD1     | 28  | 15  |
 |     |     |       0v |      |   | 39 || 40 | 0 | ALT4 | RxD1     | 29  | 14  |
 +-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+
 | BCM | wPi |   Name   | Mode | V | Physical | V | Mode | Name     | wPi | BCM |
 +-----+-----+----------+------+---+-NanoPI M1+---+------+----------+-----+-----+
 
 +-----+----NanoPI M1 Debug UART---+----+
 | BCM | wPi |   Name   | Mode | V | Ph |
 +-----+-----+----------+------+---+----+
 |     |     |       0v |      |   | 41 |
 |     |     |       5v |      |   | 42 |
 |   4 |  32 |   GPIO.4 | ALT5 | 0 | 43 |
 |   5 |  33 |   GPIO.5 | ALT5 | 0 | 44 |
 +-----+-----+----------+------+---+----+

4 Map NanoPi M1's GPIO Pins to WiringNP's Indexes

In the previous section we got a list by running "gpio readall". In the list the "Physical" column stands for the M1's GPIO pins' indexes from 1 to 40
The "wPi" column stands for the indexes when users use WiringNP to access GPIO pins. Here is the numbering scheme for all NanoPi M1's GPIO pins to wPi's indexes:

5 Code Sample with WiringNP

Here is a setup to connect a Matrix - LED module to a NanoPi M1:

Here is the connection:

Matrix-LED	NanoPi M1
S	Pin7
V	Pin4
G	Pin6

We will show how to use WiringNP to control a LED module.
By running "gpio readall" we can find that physical pin "Pin7" corresponds to the wPi index "7". We will use "7" to access this LED.

5.1 C Source Code

Make a C source file:

vi test.c

Type the following lines:

#include <wiringPi.h>
int main(void)
{
  wiringPiSetup() ;
  pinMode (7, OUTPUT) ;
  for(;;)
  {
    digitalWrite(7, HIGH) ;
    delay (500) ;
    digitalWrite(7,  LOW) ;
    delay (500) ;
  }
}

Compile and run "test.c":

gcc -Wall -o test test.c -lwiringPi -lpthread
./test

You can see the LED is blinking.

5.2 Shell Script

Make a shell script:

vi test.sh

Type the following lines:

LED=7
gpio mode $LED out
while true; do
  gpio write $LED 1
  sleep 0.5
  gpio write $LED 0
  sleep 0.5
done

Run the script:

source test.sh

You can see the LED is blinking.

6 Popular WiringNP APIs

Note:most of the descriptions for the following functions are from http://wiringpi.com/. To get more details refer to http://wiringpi.com/.

6.1 Initialization

6.1.1 wiringPiSetup (void)

This initializes wiringPi and assumes that the calling program is going to use the wiringPi pin numbering scheme. The numbering scheme can be checked by running "gpio readall".
You must be root to call this function.

6.1.2 int wiringPiSetupGpio(void)

This function is the same as the above one, however it allows the calling program to use the SoC's GPIO pin numbers directly without re-mapping.
You must be root to call this function.

6.1.3 int wiringPiSetupPhys (void)

This function is the same as "wiringPiSetup", however it allows the calling program to use the physical pin numbers on the P1 connector only.
You must be root to call this function.

6.1.4 int wiringPiSetupSys (void)

This function initializes wiringPi but uses the /sys/class/gpio interface rather than accessing the hardware directly.
This can be called as a non-root user provided the GPIO pins have been exported before-hand using the gpio program.
In this mode you can only use the pins which have been exported via the /sys/class/gpio interface before you run your program.
You can do this in a separate shell script, or by using the system() function from inside your program to call the gpio program.

6.2 Core Functions

6.2.1 void pinMode (int pin, int mode)

This function sets the mode of a pin to either INPUT, OUTPUT, PWM_OUTPUT or GPIO_CLOCK.
This function has no effect when in Sys mode.
If you need to change the pin mode you can do it with the gpio program in a script before you start your program.

6.2.2 void pullUpDnControl (int pin, int pud)

This function sets the pull-up or pull-down resistor mode on the given pin, which should be set as an input.
Unlike the Arduino the NanoPi M1 has both pull-up an down internal resistors.
The parameter pud should be; PUD_OFF, (no pull up/down), PUD_DOWN (pull to ground) or PUD_UP (pull to 3.3v).
The internal pull up/down resistors have a value of approximately 100KΩ on the NanoPi M1.
This function has no effect on the M1's GPIO pins when in Sys mode.
If you need to activate a pull-up/pull-down you can do it with the gpio program in a script before you start your program.

6.2.3 void digitalWrite (int pin, int value)

This function is used to write the value HIGH or LOW (1 or 0) to the given pin which should have been previously set as an output.
WiringPi treats any non-zero number as HIGH, however 0 is the only representation of LOW.

6.2.4 void pwmWrite (int pin, int value)

This function is used to write a value to the PWM register for a given pin. The range is 0-1024. Other PWM devices may have other PWM ranges.
This function is not able to control the M1's on-board PWM when in Sys mode.

6.2.5 digitalRead(int pin);

This function returns the value read at a given pin. It will be HIGH or LOW (1 or 0) depending on the logic level at the pin.

6.2.6 analogRead (int pin) ;

This function returns the value read on a supplied analog input pin. You will need to register additional analog modules to enable this function for devices such as the Gertboard, quick2Wire analog board, etc.

6.2.7 analogWrite (int pin, int value) ;

This function writes a given value to a supplied analog pin. You will need to register additional analog modules to enable this function for devices such as the Gertboard.

7 Update Log

7.1 December-31-2016

• Released English Version