Rock/wiringX
Contents
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and MIPS CI20 Creator. For Radxa Rock(pro/lite), wiringX provides interfaces for GPIO, I2C, SPI and ISR. You can easily use these function on Rock through wiringX.
Firstly, get wiringX from github:
git clone https://github.com/wiringX/wiringX.git cd wiringX
or
wget https://github.com/wiringX/wiringX/archive/master.zip unzip master.zip cd wiringX-master
Then, install wiringX follow the way on github.
When compile your source code, add the static lib like:
gcc -o test test.c /usr/local/lib/libwiringX.a ./test
WiringX is running on your board!
Pin Number Defined in WiringX
You can find pin numbers for Radxa Rock(pro/lite) here. However, only pins can be used as GPIO are valid in wiringX. Thus, for J8, totally 21 pins can be used (number defined as 0-20) and for J12/15, 8 pins can be used (number 25-32). Besides, 3 onboard LEDs can be used, (number 33-35). Pin number defined in wiringX is as below:
GPIO
WiringX provides digitalread and digitalwrite, after you set it as input/output using pinMode. The example below shows how to blink the blue LED (pin NO. 35) on board.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "wiringX.h"
int main(void) {
wiringXSetup();
pinMode(35, OUTPUT);
digitalWrite(35, HIGH);
sleep(1);
digitalWrite(35, LOW);
sleep(1);
}
Theoretically, all pins can be used as GPIO. However, some multiplexed pins can't be used (pin number defined in extension header): J8: 11-16, 20, 22, 24, 26-28, 31-32; J12/15: 33-38. These pins can only be used as PWM, UART or SPI, not for GPIO.
I2C
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.
I2C0 is connected to pin 31, 32 on J8. Code on radxa:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include "wiringX.h"
#define I2C_ADDR 0x04
int fd_i2c;
int main(void) {
wiringXSetup();
if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) {
fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c);
return -1;
} else {
fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c);
}
int data=0;
while(1) {
data=wiringXI2CRead(fd_i2c);
sleep(2);
printf("Data received is:%d\n",data);
}
}
Code on arduino:
#include <Wire.h>
byte i=0;
void setup()
{
Wire.begin(4);
Wire.onRequest(requestEvent);
}
void loop()
{
delay(100);
}
void requestEvent()
{
Wire.write(i);
i++;
}
The result:
SPI
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include "wiringX.h"
/* SPI Config */
#define SPI_CHAN 0
#define SPI_SPEED 250000
int fd_spi;
int main(void) {
unsigned char spi_data=0x00;
wiringXSetup();
// set up SPI
if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {
fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);
} else {
fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);
}
while(1) {
wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);
printf("%c\n",spi_data);
sleep(2);
}
}
Arduino code:
#include <SPI.h>
char buf=0;
volatile boolean process_it;
void setup (void)
{
pinMode(MISO, OUTPUT);
SPCR |= _BV(SPE);
process_it = false;
SPI.attachInterrupt();
}
ISR (SPI_STC_vect)
{
byte c = SPDR;
SPDR=0x31;
buf = c;
process_it = true;
}
void loop (void)
{
if (process_it)
{
buf= 0;
process_it = false;
}
}
ISR
For RK3188, Port A can be configured as interrupt. A simple example:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include "wiringX.h"
void *interrupt(void *param) {
while(1) {
if(waitForInterrupt(1, 1000) > 0) {
printf("interrupt\n");
} else {
printf("timeout\n");
}
}
}
int main(void) {
pthread_t pth;
wiringXSetup();
wiringXISR(1, INT_EDGE_RISING);
pthread_create(&pth, NULL, interrupt, NULL);
}
It will cause interrupt when rising edge inputs to pin 1. The result:
It should take note that, for a linux kernel version below 3.12, interrupt only support INT_EDGE_RISING or INT_EDGE_FALLING, not for INT_EDGE_BOTH.