View source for WiringPi for RK3399

[[WiringNP: NanoPi NEO/NEO2/Air GPIO Programming with C/zh|查看中文]]

==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.<br />
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.<br />

==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 [https://github.com/wertyzp wertyzp]. FriendlyElec developed a version for Allwinner H5 based NanoPi NEO2.<br />
<br />
Here is WiringNP's project page: https://github.com/friendlyarm/WiringNP<br />

==Install WiringNP on NEO/NEO2==
Log into your nano board via SSH, open a terminal and install the WiringNP library by running the following commands:<br />
<syntaxhighlight lang="bash">
git clone https://github.com/friendlyarm/WiringNP
cd WiringNP/
chmod 755 build
./build
</syntaxhighlight>

==Install WiringNP on NanoPi M1==
Log into your nano board via SSH, open a terminal and install the WiringNP library by running the following commands:<br />
<syntaxhighlight lang="bash">
git clone https://github.com/friendlyarm/WiringNP
cd WiringNP/
git checkout nanopi-m1
chmod 755 build
./build
</syntaxhighlight>

==== 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:
<syntaxhighlight lang="bash">
gpio readall
</syntaxhighlight>
If your installation is successful the following messages will show up. Here is the message list for NEO2:
<syntaxhighlight lang="bash">
root@FriendlyARM:~# gpio readall
  +-----+-----+----------+------+---+-NanoPi NEO/NEO2--+------+----------+-----+-----+
 | BCM | wPi |   Name   | Mode | V | Physical | V | Mode | Name     | wPi | BCM |
 +-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+
 |     |     |     3.3V |      |   |  1 || 2  |   |      | 5V       |     |     |
 |  12 |   8 |  GPIOA12 |  OFF | 0 |  3 || 4  |   |      | 5V       |     |     |
 |  11 |   9 |  GPIOA11 |  OFF | 0 |  5 || 6  |   |      | 0v       |     |     |
 | 203 |   7 |  GPIOG11 |  OUT | 1 |  7 || 8  | 0 | OFF  | GPIOG6   | 15  | 198 |
 |     |     |       0v |      |   |  9 || 10 | 0 | OFF  | GPIOG7   | 16  | 199 |
 |   0 |   0 |   GPIOA0 |  OFF | 0 | 11 || 12 | 0 | OFF  | GPIOA6   | 1   | 6   |
 |   2 |   2 |   GPIOA2 |  OFF | 0 | 13 || 14 |   |      | 0v       |     |     |
 |   3 |   3 |   GPIOA3 |  OFF | 0 | 15 || 16 | 0 | OFF  | GPIOG8   | 4   | 200 |
 |     |     |     3.3v |      |   | 17 || 18 | 0 | OFF  | GPIOG9   | 5   | 201 |
 |  64 |  12 |   GPIOC0 |  OFF | 0 | 19 || 20 |   |      | 0v       |     |     |
 |  65 |  13 |   GPIOC1 |  OFF | 0 | 21 || 22 | 0 | OFF  | GPIOA1   | 6   | 1   |
 |  66 |  14 |   GPIOC2 |  OFF | 0 | 23 || 24 | 0 | OFF  | GPIOC3   | 10  | 67  |
 +-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+
 | BCM | wPi |   Name   | Mode | V | Physical | V | Mode | Name     | wPi | BCM |
 +-----+-----+----------+------+---+-NanoPi NEO/NEO2--+------+----------+-----+-----+

 +-----+----NanoPi NEO/NEO2 Debug UART-+----+
 | BCM | wPi |   Name   | Mode | V | Ph |
 +-----+-----+----------+------+---+----+
 |   4 |  17 |   GPIOA4 | ALT5 | 0 | 37 |
 |   5 |  18 |   GPIOA5 | ALT4 | 0 | 38 |
 +-----+-----+----------+------+---+----+
</syntaxhighlight>

<!---
==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<br />
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:<br />
[[File:WiringNP-GPIO-ALL.jpg|frameless|600px]]
--->

==Code Sample with WiringNP==
Here is a setup to connect a [[Matrix - LED]] module to a NanoPi NEO2:<br>
[[File:WiringNP-LED-Demo.jpg|frameless|300px|WiringNP-LED-Demo]]<br />
Here is the connection:<br/>
{| class="wikitable"
|-
|Matrix-LED || NanoPi M1
|-
|S    || Pin7
|-
|V    || Pin4
|- 
|G    || Pin6
|}

We will show how to use WiringNP to control a LED module.<br />
In the following code samples index 7 stands for Pin7. We will use "7" to access this physical pin.<br />

=== C Source Code ===
Make a C source file:
<syntaxhighlight lang="bash">
vi test.c
</syntaxhighlight>
Type the following lines:
<syntaxhighlight lang="c">
#include <wiringPi.h>
int main(void)
{
  wiringPiSetup() ;
  pinMode (7, OUTPUT) ;
  for(;;)
  {
    digitalWrite(7, HIGH) ;
    delay (500) ;
    digitalWrite(7,  LOW) ;
    delay (500) ;
  }
}
</syntaxhighlight>
Compile and run "test.c":
<syntaxhighlight lang="bash">
gcc -Wall -o test test.c -lwiringPi -lpthread
sudo ./test 
</syntaxhighlight>
You can see the LED is blinking.

===PWM Code Sample===
The PWM pin in NanoPi NEO/NEO2 is multiplexing which can be set to either PWM or SerialPort0. To set this pin to PWM you need to run "sudo npi-config" and enter the "Advanced Options" menu to Enable/Disable PWM. Note: after PWM is enabled SerialPort0 will not be accessed and you need to login your board via SSH.<br />
<br />
Here is a hardware setup to connect a [[Matrix - Buzzer]] to a NanoPi NEO2:<br />
[[File:WiringNP-PWM-Demo.jpg|frameless|300px|WiringNP-PWM-Demo]]<br />

Create a source file in C:<br/>
<syntaxhighlight lang="bash">
vi pwmtest.c
</syntaxhighlight>
Type the following code:
<syntaxhighlight lang="c">
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
int main (void)
{
  int l ;
  printf ("PWM test program\n") ;

  //using wiringPi Pin Number
  int pin = 18;              
  if (wiringPiSetup () == -1)
    exit (1) ;               
              
  /*
  //using Physical Pin Number
  int pin = 38;              
  if (wiringPiSetupPhys() == -1)
    exit (1) ;                  
  */                            
              
  /*
  //using BCM Pin Number
  int pin = 5;          
  if (wiringPiSetupGpio() == -1)
    exit (1);                   
  */                            
                            
  pinMode (pin, PWM_OUTPUT);
  for (;;) {                      
    for (l = 0 ; l < 1024 ; ++l) {
      pwmWrite (pin, l) ;         
      delay (1) ;        
    }                              
    for (l = 1023 ; l >= 0 ; --l) {
      pwmWrite (pin, l) ;          
      delay (1) ;        
    }            
  }         
  return 0 ;
}
</syntaxhighlight>
Compile the pwmtest.c file and run the generated executable:
<syntaxhighlight lang="bash">
gcc -Wall -o pwmtest pwmtest.c -lwiringPi -lpthread
./pwmtest 
</syntaxhighlight>
Connect a PWM beeper to a NEO/NEO2 and the beeper will sound.

=== Shell Script ===
Make a shell script:
<syntaxhighlight lang="bash">
vi test.sh
</syntaxhighlight>
Type the following lines:
<syntaxhighlight lang="bash">
LED=7
gpio mode $LED out
while true; do
  gpio write $LED 1
  sleep 0.5
  gpio write $LED 0
  sleep 0.5
done
</syntaxhighlight>
Run the script:
<syntaxhighlight lang="bash">
sudo source test.sh
</syntaxhighlight>
You can see the LED is blinking.

==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/.

=== Initialization ===
==== 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".<br />
You must be root to call this function.

==== 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.<br />
You must be root to call this function.

==== 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.<br />
You must be root to call this function.

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

=== Core Functions ===
==== void pinMode (int pin, int mode) ====
This function sets the mode of a pin to either INPUT, OUTPUT, PWM_OUTPUT or GPIO_CLOCK.<br/> 
This function has no effect when in Sys mode.<br/>
If you need to change the pin mode you can do it with the gpio program in a script before you start your program.

==== 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.<br />
Unlike the Arduino the NanoPi M1 has both pull-up an down internal resistors.<br />
The parameter pud should be; PUD_OFF, (no pull up/down), PUD_DOWN (pull to ground) or PUD_UP (pull to 3.3v).<br />
The internal pull up/down resistors have a value of approximately 100KΩ on the NanoPi M1.<br />
This function has no effect on the M1's GPIO pins when in Sys mode.<br />
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.

==== 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.<br />
WiringPi treats any non-zero number as HIGH, however 0 is the only representation of LOW.

==== 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.<br />
This function is not able to control the M1's on-board PWM when in Sys mode.<br />

==== 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.<br />

==== 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.<br />

==== 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.<br/>

==Update Log==
===December-31-2016===
* Released English Version

===May-16-2017===
* Updated section 2 by adding support for H5 based NEO2
* Added section 4 by adding support for H5 based NEO2
* Added section 5.2: code sample on how to access a PWM device

===May-17-2017===
* Updated section 4 by adding installation steps for M1

===May-24-2017===
* Updated section 5.2 by adding a PWM code sample for NEO2