https://wiki.radxa.com/mw/api.php?action=feedcontributions&feedformat=atom&user=Pavle
Radxa Wiki - User contributions [en]
2026-06-13T16:49:55Z
User contributions
MediaWiki 1.23.3
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-07-09T09:37:49Z
<p>Pavle: /* GPIO */</p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/wiringX}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/radxa/wiringX github]:<br />
'''git clone https://github.com/radxa/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/radxa/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/radxa/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' while(1) {'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.<br />
<br />
== UART ==<br />
<br />
We also add UART in wiringX to support serial port communication. Two UART port on J8: UART0 and UART3. A simple example to use UART0 communicate with arduino uno:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int fd=-1, c=0;'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1){'''<br />
''' if(wiringXserialDataAvail (fd)>0){'''<br />
''' c=wiringXserialGetchar(fd);'''<br />
''' printf("Data received is: %d.\n", c);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' unsigned char d=0x00;'''<br />
''' wiringXSetup();'''<br />
''' pinMode(0, OUTPUT);'''<br />
''' if ((fd = wiringXserialOpen ("/dev/ttyS0", 9600)) < 0) {'''<br />
''' fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;'''<br />
''' return -1;'''<br />
''' }'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
''' wiringXserialPutchar(fd, d);'''<br />
''' while(1){'''<br />
''' digitalWrite(0, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(0, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
Codes on arduino:<br />
<br />
'''boolean stringComplete = false; // whether the string is complete'''<br />
'''char inChar = 0x00;'''<br />
'''void setup() {'''<br />
''' // initialize serial:'''<br />
''' Serial.begin(9600);'''<br />
''' pinMode(13,OUTPUT);'''<br />
''' digitalWrite(13,LOW);'''<br />
'''}'''<br />
'''void loop() {'''<br />
''' if (stringComplete) {'''<br />
''' Serial.write(inChar);'''<br />
''' inChar=inChar+1;'''<br />
''' digitalWrite(13,LOW);'''<br />
''' delay(1000);'''<br />
''' digitalWrite(13,HIGH);'''<br />
''' delay(1000);'''<br />
''' }'''<br />
'''}'''<br />
'''void serialEvent() {'''<br />
''' while (Serial.available()) {'''<br />
''' inChar = (char)Serial.read();'''<br />
''' if (inChar == 0x00) {'''<br />
''' stringComplete = true;'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
<br />
Result:<br />
<br />
[[File:Uart.png]]<br />
<br />
And you can see LED on arduino and red led on Rock blink.<br />
<br />
== PWM ==<br />
<br />
PWM is also added to wiringX (kenerl 3.0.36 not supported). Interfaces are provided to use two channels pwm on the header. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' pinMode(6, PWM_OUTPUT);'''<br />
''' wiringXsetPwmPeriod(6, 2000000000);'''<br />
''' wiringXsetPwmDuty(6, 200000000);'''<br />
''' wiringXpwmEnable(6, 1);'''<br />
''' sleep(100);'''<br />
''' wiringXpwmRemove(6);'''<br />
'''}'''<br />
This will output pwm of period 2s, duty_cycle 10% on pin 12, lasts for 100s.<br />
<br />
== AIN ==<br />
Three ain pins on J8. WiringX supports: int wiringXanalogRead(int channel). You can use it to read the adc value on channel 0, 1, 2.</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-25T04:51:11Z
<p>Pavle: /* PWM */</p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/wiringX}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/radxa/wiringX github]:<br />
'''git clone https://github.com/radxa/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/radxa/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/radxa/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.<br />
<br />
== UART ==<br />
<br />
We also add UART in wiringX to support serial port communication. Two UART port on J8: UART0 and UART3. A simple example to use UART0 communicate with arduino uno:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int fd=-1, c=0;'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1){'''<br />
''' if(wiringXserialDataAvail (fd)>0){'''<br />
''' c=wiringXserialGetchar(fd);'''<br />
''' printf("Data received is: %d.\n", c);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' unsigned char d=0x00;'''<br />
''' wiringXSetup();'''<br />
''' pinMode(0, OUTPUT);'''<br />
''' if ((fd = wiringXserialOpen ("/dev/ttyS0", 9600)) < 0) {'''<br />
''' fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;'''<br />
''' return -1;'''<br />
''' }'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
''' wiringXserialPutchar(fd, d);'''<br />
''' while(1){'''<br />
''' digitalWrite(0, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(0, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
Codes on arduino:<br />
<br />
'''boolean stringComplete = false; // whether the string is complete'''<br />
'''char inChar = 0x00;'''<br />
'''void setup() {'''<br />
''' // initialize serial:'''<br />
''' Serial.begin(9600);'''<br />
''' pinMode(13,OUTPUT);'''<br />
''' digitalWrite(13,LOW);'''<br />
'''}'''<br />
'''void loop() {'''<br />
''' if (stringComplete) {'''<br />
''' Serial.write(inChar);'''<br />
''' inChar=inChar+1;'''<br />
''' digitalWrite(13,LOW);'''<br />
''' delay(1000);'''<br />
''' digitalWrite(13,HIGH);'''<br />
''' delay(1000);'''<br />
''' }'''<br />
'''}'''<br />
'''void serialEvent() {'''<br />
''' while (Serial.available()) {'''<br />
''' inChar = (char)Serial.read();'''<br />
''' if (inChar == 0x00) {'''<br />
''' stringComplete = true;'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
<br />
Result:<br />
<br />
[[File:Uart.png]]<br />
<br />
And you can see LED on arduino and red led on Rock blink.<br />
<br />
== PWM ==<br />
<br />
PWM is also added to wiringX (kenerl 3.0.36 not supported). Interfaces are provided to use two channels pwm on the header. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' pinMode(6, PWM_OUTPUT);'''<br />
''' wiringXsetPwmPeriod(6, 2000000000);'''<br />
''' wiringXsetPwmDuty(6, 200000000);'''<br />
''' wiringXpwmEnable(6, 1);'''<br />
''' sleep(100);'''<br />
''' wiringXpwmRemove(6);'''<br />
'''}'''<br />
This will output pwm of period 2s, duty_cycle 10% on pin 12, lasts for 100s.<br />
<br />
== AIN ==<br />
Three ain pins on J8. WiringX supports: int wiringXanalogRead(int channel). You can use it to read the adc value on channel 0, 1, 2.</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-23T03:41:40Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/wiringX}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/radxa/wiringX github]:<br />
'''git clone https://github.com/radxa/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/radxa/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/radxa/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.<br />
<br />
== UART ==<br />
<br />
We also add UART in wiringX to support serial port communication. Two UART port on J8: UART0 and UART3. A simple example to use UART0 communicate with arduino uno:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int fd=-1, c=0;'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1){'''<br />
''' if(wiringXserialDataAvail (fd)>0){'''<br />
''' c=wiringXserialGetchar(fd);'''<br />
''' printf("Data received is: %d.\n", c);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' unsigned char d=0x00;'''<br />
''' wiringXSetup();'''<br />
''' pinMode(0, OUTPUT);'''<br />
''' if ((fd = wiringXserialOpen ("/dev/ttyS0", 9600)) < 0) {'''<br />
''' fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;'''<br />
''' return -1;'''<br />
''' }'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
''' wiringXserialPutchar(fd, d);'''<br />
''' while(1){'''<br />
''' digitalWrite(0, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(0, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
Codes on arduino:<br />
<br />
'''boolean stringComplete = false; // whether the string is complete'''<br />
'''char inChar = 0x00;'''<br />
'''void setup() {'''<br />
''' // initialize serial:'''<br />
''' Serial.begin(9600);'''<br />
''' pinMode(13,OUTPUT);'''<br />
''' digitalWrite(13,LOW);'''<br />
'''}'''<br />
'''void loop() {'''<br />
''' if (stringComplete) {'''<br />
''' Serial.write(inChar);'''<br />
''' inChar=inChar+1;'''<br />
''' digitalWrite(13,LOW);'''<br />
''' delay(1000);'''<br />
''' digitalWrite(13,HIGH);'''<br />
''' delay(1000);'''<br />
''' }'''<br />
'''}'''<br />
'''void serialEvent() {'''<br />
''' while (Serial.available()) {'''<br />
''' inChar = (char)Serial.read();'''<br />
''' if (inChar == 0x00) {'''<br />
''' stringComplete = true;'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
<br />
Result:<br />
<br />
[[File:Uart.png]]<br />
<br />
And you can see LED on arduino and red led on Rock blink.<br />
<br />
== PWM ==<br />
<br />
PWM is also added to wiringX. Interfaces are provided to use two channels pwm on the header. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' pinMode(6, PWM_OUTPUT);'''<br />
''' wiringXsetPwmPeriod(6, 2000000000);'''<br />
''' wiringXsetPwmDuty(6, 200000000);'''<br />
''' wiringXpwmEnable(6, 1);'''<br />
''' sleep(100);'''<br />
''' wiringXpwmRemove(6);'''<br />
'''}'''<br />
This will output pwm of period 2s, duty_cycle 10% on pin 12, lasts for 100s.<br />
<br />
== AIN ==<br />
Three ain pins on J8. WiringX supports: int wiringXanalogRead(int channel). You can use it to read the adc value on channel 0, 1, 2.</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-16T09:45:02Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/wiringX}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/radxa/wiringX github]:<br />
'''git clone https://github.com/radxa/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/radxa/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/radxa/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.<br />
<br />
== UART ==<br />
<br />
We also add UART in wiringX to support serial port communication. Two UART port on J8: UART0 and UART3. A simple example to use UART0 communicate with arduino uno:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int fd=-1, c=0;'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1){'''<br />
''' if(wiringXserialDataAvail (fd)>0){'''<br />
''' c=wiringXserialGetchar(fd);'''<br />
''' printf("Data received is: %d.\n", c);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' unsigned char d=0x00;'''<br />
''' wiringXSetup();'''<br />
''' pinMode(0, OUTPUT);'''<br />
''' if ((fd = wiringXserialOpen ("/dev/ttyS0", 9600)) < 0) {'''<br />
''' fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;'''<br />
''' return -1;'''<br />
''' }'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
''' wiringXserialPutchar(fd, d);'''<br />
''' while(1){'''<br />
''' digitalWrite(0, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(0, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
Codes on arduino:<br />
<br />
'''boolean stringComplete = false; // whether the string is complete'''<br />
'''char inChar = 0x00;'''<br />
'''void setup() {'''<br />
''' // initialize serial:'''<br />
''' Serial.begin(9600);'''<br />
''' pinMode(13,OUTPUT);'''<br />
''' digitalWrite(13,LOW);'''<br />
'''}'''<br />
'''void loop() {'''<br />
''' if (stringComplete) {'''<br />
''' Serial.write(inChar);'''<br />
''' inChar=inChar+1;'''<br />
''' digitalWrite(13,LOW);'''<br />
''' delay(1000);'''<br />
''' digitalWrite(13,HIGH);'''<br />
''' delay(1000);'''<br />
''' }'''<br />
'''}'''<br />
'''void serialEvent() {'''<br />
''' while (Serial.available()) {'''<br />
''' inChar = (char)Serial.read();'''<br />
''' if (inChar == 0x00) {'''<br />
''' stringComplete = true;'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
<br />
Result:<br />
<br />
[[File:Uart.png]]<br />
<br />
And you can see LED on arduino and red led on Rock blink.<br />
<br />
== PWM ==<br />
<br />
PWM is also added to wiringX. Interfaces are provided to use two channels pwm on the header. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' pinMode(6, PWM_OUTPUT);'''<br />
''' wiringXsetPwmPeriod(6, 2000000000);'''<br />
''' wiringXsetPwmDuty(6, 200000000);'''<br />
''' wiringXpwmEnable(6, 1);'''<br />
''' sleep(100);'''<br />
''' wiringXpwmRemove(6);'''<br />
'''}'''<br />
This will output pwm of period 2s, duty_cycle 10% on pin 12, lasts for 100s.</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-16T09:43:17Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/wiringX}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/radxa/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.<br />
<br />
== UART ==<br />
<br />
We also add UART in wiringX to support serial port communication. Two UART port on J8: UART0 and UART3. A simple example to use UART0 communicate with arduino uno:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int fd=-1, c=0;'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1){'''<br />
''' if(wiringXserialDataAvail (fd)>0){'''<br />
''' c=wiringXserialGetchar(fd);'''<br />
''' printf("Data received is: %d.\n", c);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' unsigned char d=0x00;'''<br />
''' wiringXSetup();'''<br />
''' pinMode(0, OUTPUT);'''<br />
''' if ((fd = wiringXserialOpen ("/dev/ttyS0", 9600)) < 0) {'''<br />
''' fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;'''<br />
''' return -1;'''<br />
''' }'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
''' wiringXserialPutchar(fd, d);'''<br />
''' while(1){'''<br />
''' digitalWrite(0, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(0, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
Codes on arduino:<br />
<br />
'''boolean stringComplete = false; // whether the string is complete'''<br />
'''char inChar = 0x00;'''<br />
'''void setup() {'''<br />
''' // initialize serial:'''<br />
''' Serial.begin(9600);'''<br />
''' pinMode(13,OUTPUT);'''<br />
''' digitalWrite(13,LOW);'''<br />
'''}'''<br />
'''void loop() {'''<br />
''' if (stringComplete) {'''<br />
''' Serial.write(inChar);'''<br />
''' inChar=inChar+1;'''<br />
''' digitalWrite(13,LOW);'''<br />
''' delay(1000);'''<br />
''' digitalWrite(13,HIGH);'''<br />
''' delay(1000);'''<br />
''' }'''<br />
'''}'''<br />
'''void serialEvent() {'''<br />
''' while (Serial.available()) {'''<br />
''' inChar = (char)Serial.read();'''<br />
''' if (inChar == 0x00) {'''<br />
''' stringComplete = true;'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
<br />
Result:<br />
<br />
[[File:Uart.png]]<br />
<br />
And you can see LED on arduino and red led on Rock blink.<br />
<br />
== PWM ==<br />
<br />
PWM is also added to wiringX. Interfaces are provided to use two channels pwm on the header. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' pinMode(6, PWM_OUTPUT);'''<br />
''' wiringXsetPwmPeriod(6, 2000000000);'''<br />
''' wiringXsetPwmDuty(6, 200000000);'''<br />
''' wiringXpwmEnable(6, 1);'''<br />
''' sleep(100);'''<br />
''' wiringXpwmRemove(6);'''<br />
'''}'''<br />
This will output pwm of period 2s, duty_cycle 10% on pin 12, lasts for 100s.</div>
Pavle
https://wiki.radxa.com/Rock
Rock
2015-06-16T09:37:22Z
<p>Pavle: </p>
<hr />
<div>{{Rock_header}}<br />
<br />
{{Languages|rock}}<br />
<br />
<div class="col-md-8 mwbs-color-darker"><br />
<div class="thumbnail ">http://wiki.radxa.com/mw/images/3/36/Rock.jpg</div><br />
<div class="caption"><br />
<h3>Radxa Rock(Pro/Lite)</h3><br />
<p class="text-justify">Radxa Rock is a RK3188 based SBC(Single Board Computer) by [[Special:SpecialContact| Radxa]]. It has a quad core ARM processor, can run android or some Linux distributions. It also features 80 pin 2.54mm headers, which makes it easy to connect other sensors or use the GPIO.</p><br />
</div><br />
</div><br />
__TOC__<br />
<div class="col-md-9"><br />
<div class="panel panel-hearts-white"> <br />
<div class="panel-heading"> <h3 class="panel-title"><i class="fa fa-hand-o-up"></i> Getting started</h3> </div><br />
<br />
<div class="panel-body"><br />
The Radxa Rock is shipped with Android 4.2.2 (Jelly Bean) and Ubuntu/Linaro 13.09 dual boot on the NAND flash (on-board storage) and it works out of the box(Rock Pro is shipped with Android 4.4.2(Kitkat) on NAND flash). Let's read '''[[rock/Getting Started|Radxa Rock Getting Started Guide]]''' and hook everything up and start playing with the board.<br />
<br />
Once you get started, you can [[Rock/flash_the_image|flash]] latest [[Rock/prebuilt_images|Android image and several Linux images]], or you can try to [[Rock/SD_images|boot Android/Linux from SD card]]. You can also [[Rock/Android_Build|build your own Android]], [[Rock/Booting_Linux|build your own kernel]], [[Rock/ubuntu|build your own Ubuntu root file system]], or whatever you want.<br />
<br />
'''FAQs'''<br />
<br />
Before you ask any questions about the Radxa Rock check if your question has already been asked and answered [[rock/FAQ|Radxa Rock FAQ]].<br />
<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-3 "><br />
<div class="panel panel-midnight-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-download"></i> Download</h3><br />
</div><br />
<div class="panel-body"><br />
Visit the '''[[rock/download| download]]''' page to get the download link and description of the source code, tools, images etc<br />
</div><br />
</div><br />
</div><br />
<div class="clearfix"></div><br />
<div class="col-md-4 "><br />
<div class="panel panel-cocktail-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-users"></i> Community</h3><br />
</div><br />
<div class="panel-body"><br />
'''Users'''<br />
<br />
* [http://talk.radxa.com/ Radxa Talk]<br />
* [https://plus.google.com/communities/114007636590240429960 Radxa Google Plus community]<br />
* [https://www.facebook.com/groups/218416868348521/ Facebook Group Page]<br />
<br />
'''Developers'''<br />
<br />
* [https://groups.google.com/forum/#!forum/radxa radxa google groups], send emails to radxa@googlegroups.com to subscribe <br />
* <tt>#radxa</tt> [http://en.wikipedia.org/wiki/Internet_Relay_Chat IRC] channel on [http://freenode.net/ Freenode]. Click to [http://webchat.freenode.net/?channels=radxa join #radxa on Freenode (WebChat mode)], or consult [http://irclog.whitequark.org/radxa/ IRC logs]. <br />
</div><br />
</div><br />
<div class="panel panel-gunmetal-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-linux"></i> Linux</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/Booting Linux | Build your own kernel and boot into Linux]]<br />
* [[rock/Linux Mainline | Build Linux Mainline]]<br />
* [[rock/ubuntu| Make Ubuntu rootfs]]<br />
* [[Rock/debian | Make Debian rootfs]]<br />
* [[rock/make_sd_image| Make SD booting images]]<br />
* [[rock/audio | Audio on Rock]]<br />
* [[rock/display | Display on Rock]]<br />
* [[rock/LED| Using LEDs on Rock]]<br />
* [[rock/vnc | Setting up VNC server on Rock]]<br />
* [[rock/sd lubuntu | Boot Lubuntu from SD card]] '''OBSOLETE''' <br />
</div><br />
</div><br />
</div><br />
<div class="col-md-4"><br />
<div class="panel panel-mango-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-cog"></i> Common HowTos</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/flash the image | Flash the image to NAND]]<br />
* [[rock/SD images | Flash the image to SD card]]<br />
* [[rock/SD upgrading | Upgrade NAND from SD card]]<br />
* [[rock/backup| Backing up]]<br />
* [[rock/fsck| Recovery ext4 file system]]<br />
* [[rock/Serial debug tools Setting | Serial console debugging]]<br />
* [[rock/unbrick | Unbrick Rock]]<br />
* [[rock/resize linux rootfs |Resize linux rootfs ]]<br />
* [[rock/ir| Using IR on Rock]]<br />
* [[rock/usb| Using USB on Rock]]<br />
* [[rock/uart| Using UART on Rock]]<br />
* [[rock/Wireless | Using Wireless on Rock]]<br />
* [[rock/Camera | Using Camera on Rock]]<br />
* [[rock/Tp,Lvds,Camera | Using Lvds,Tp,Camera on Rock]]<br />
* [[rock/Rock Lite | Run Rock Lite]]<br />
* [[rock/Hdmi Resolution| Add new hdmi resolution]]<br />
* [[rock/wiringX| wringX: GPIO/I2C/SPI/ISR/UART/PWM]]<br />
</div><br />
</div><br />
<div class="panel panel-berry-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-check-circle"></i> Others</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/dual boot| Dual boot Android/Linux]]<br />
* [[rock/FreeBSD| Boot FreeBSD]] <br />
</div><br />
</div><br />
<div class="panel panel-party-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-gamepad"></i> Addons</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/cases | Cases]]<br />
* [[rock/cables | Cables]]<br />
* [[rock/shields | Extension boards]]<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-4 "><br />
<div class="panel panel-cello-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-hdd-o"></i> Hardware</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/specifications| Specifications]]<br />
* [[rock/hardware revision | Hardware Revision]]<br />
* [[rock/extension header | Extension Header]]<br />
* [[rock/hardware docs | hardware documents]]<br />
</div><br />
</div><br />
<div class="panel panel-meadow-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-android"></i> Android</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/windows adb| ADB under Windows]]<br />
* [[rock/linux adb| ADB under Linux]]<br />
* [[rock/Android Build|Build Android image for RR]]<br />
* [[rock/SD booting | Making bootable SD card]]<br />
* [[rock/AP android |Make radxa as a WIFI_AP]]<br />
* [[rock/Android backup | Backup your apps]]<br />
* [[rock/Android dev tips | Some tips for android development]]<br />
</div><br />
</div><br />
<div class="panel panel-cyanide-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-bold"></i> Bootloader</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/bootloader | Boot Loader]]<br />
* [[rock/U-Boot | U-Boot]]<br />
</div><br />
</div><br />
</div><br />
<div class="clearfix"></div><br />
<div class="col-md-6 pull-left"><br />
<div class="panel panel-neutral-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title">Projects</h3><br />
</div><br />
<div class="panel-body"><br />
* [http://radxa.com/Rock/pilight Run Pilight on Radxa Rock for remote control]<br />
* [http://www.mydbapool.com/install-postgresql-9-4-raspberry-pi-radxa-similarmicrocomputers-running-lubuntu/ How to install PostgreSQL 9.4 on Radxa Rock]<br />
* [http://hwswbits.blogspot.com/2013/10/diy-nas-with-rk3188-device-radxa-rock.html DIY low power NAS (home file server) with Radxa Rock]<br />
* [http://www.megaleecher.net/Network_Sharing_Radxa_Rock Network sharing on Radxa Rock]<br />
* [http://hwswbits.blogspot.com/2013/10/radxa-rock-communicating-with-i2c.html Hardware hacking: Communicating the Radxa with external I2C devices]<br />
* [http://hwswbits.blogspot.com/2013/10/bitbanging-radxa-rock-gpios.html Hardware hacking: Control Radxa Rock's expansion header GPIOs]<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-6 pull-right"><br />
<div class="panel panel-concrete-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title">References</h3><br />
</div><br />
<div class="panel-body"><br />
'''Photos'''<br />
<br />
* [http://dl.radxa.com/rock/media/pic/hd/ Some high definition photos of the Radxa Rock engineering samples]<br />
<br />
'''External'''<br />
<br />
* [http://www.cnx-software.com/2013/09/07/radxa-rock-development-boards-with-rockchip-rk3188-are-available-for-developers-now/ cnx-soft - radxa rock development boards with rockchips rk3188 are available for developers now]<br />
* [http://linuxgizmos.com/open-sbc-runs-android-and-linux-on-quad-core-rockchip/ linuxgizmos - open sbc runs android and linux on quad core rockchip]<br />
* [http://minipute.com/2013/09/12/new-radxa-rock-single-board-computer-runs-rockchip-rk3188-90/3246 minipute - new radxa rock single board computer runs rockchip rk3188]<br />
* [http://omglaptop.com/desktops/radxa-rock-specs-price/ omglaptop - Radxa Rock Specs]<br />
* [http://liliputing.com/2013/10/picuntu-4-5-installer-loads-ubuntu-onto-rockchip-rk3188-devices.html PicUntu 4.5 with a GUI installer for RK3188 based devices]<br />
</div><br />
</div><br />
</div><br />
<br />
<br />
<br />
<br />
[[Category:Rock]]</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-16T09:36:25Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/wiringX}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/wiringX/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.<br />
<br />
== UART ==<br />
<br />
We also add UART in wiringX to support serial port communication. Two UART port on J8: UART0 and UART3. A simple example to use UART0 communicate with arduino uno:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int fd=-1, c=0;'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1){'''<br />
''' if(wiringXserialDataAvail (fd)>0){'''<br />
''' c=wiringXserialGetchar(fd);'''<br />
''' printf("Data received is: %d.\n", c);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' unsigned char d=0x00;'''<br />
''' wiringXSetup();'''<br />
''' pinMode(0, OUTPUT);'''<br />
''' if ((fd = wiringXserialOpen ("/dev/ttyS0", 9600)) < 0) {'''<br />
''' fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;'''<br />
''' return -1;'''<br />
''' }'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
''' wiringXserialPutchar(fd, d);'''<br />
''' while(1){'''<br />
''' digitalWrite(0, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(0, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
Codes on arduino:<br />
<br />
'''boolean stringComplete = false; // whether the string is complete'''<br />
'''char inChar = 0x00;'''<br />
'''void setup() {'''<br />
''' // initialize serial:'''<br />
''' Serial.begin(9600);'''<br />
''' pinMode(13,OUTPUT);'''<br />
''' digitalWrite(13,LOW);'''<br />
'''}'''<br />
'''void loop() {'''<br />
''' if (stringComplete) {'''<br />
''' Serial.write(inChar);'''<br />
''' inChar=inChar+1;'''<br />
''' digitalWrite(13,LOW);'''<br />
''' delay(1000);'''<br />
''' digitalWrite(13,HIGH);'''<br />
''' delay(1000);'''<br />
''' }'''<br />
'''}'''<br />
'''void serialEvent() {'''<br />
''' while (Serial.available()) {'''<br />
''' inChar = (char)Serial.read();'''<br />
''' if (inChar == 0x00) {'''<br />
''' stringComplete = true;'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
<br />
Result:<br />
<br />
[[File:Uart.png]]<br />
<br />
And you can see LED on arduino and red led on Rock blink.<br />
<br />
== PWM ==<br />
<br />
PWM is also added to wiringX. Interfaces are provided to use two channels pwm on the header. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' pinMode(6, PWM_OUTPUT);'''<br />
''' wiringXsetPwmPeriod(6, 2000000000);'''<br />
''' wiringXsetPwmDuty(6, 200000000);'''<br />
''' wiringXpwmEnable(6, 1);'''<br />
''' sleep(100);'''<br />
''' wiringXpwmRemove(6);'''<br />
'''}'''<br />
This will output pwm of period 2s, duty_cycle 10% on pin 12, lasts for 100s.</div>
Pavle
https://wiki.radxa.com/Rock
Rock
2015-06-11T10:19:14Z
<p>Pavle: </p>
<hr />
<div>{{Rock_header}}<br />
<br />
{{Languages|rock}}<br />
<br />
<div class="col-md-8 mwbs-color-darker"><br />
<div class="thumbnail ">http://wiki.radxa.com/mw/images/3/36/Rock.jpg</div><br />
<div class="caption"><br />
<h3>Radxa Rock(Pro/Lite)</h3><br />
<p class="text-justify">Radxa Rock is a RK3188 based SBC(Single Board Computer) by [[Special:SpecialContact| Radxa]]. It has a quad core ARM processor, can run android or some Linux distributions. It also features 80 pin 2.54mm headers, which makes it easy to connect other sensors or use the GPIO.</p><br />
</div><br />
</div><br />
__TOC__<br />
<div class="col-md-9"><br />
<div class="panel panel-hearts-white"> <br />
<div class="panel-heading"> <h3 class="panel-title"><i class="fa fa-hand-o-up"></i> Getting started</h3> </div><br />
<br />
<div class="panel-body"><br />
The Radxa Rock is shipped with Android 4.2.2 (Jelly Bean) and Ubuntu/Linaro 13.09 dual boot on the NAND flash (on-board storage) and it works out of the box(Rock Pro is shipped with Android 4.4.2(Kitkat) on NAND flash). Let's read '''[[rock/Getting Started|Radxa Rock Getting Started Guide]]''' and hook everything up and start playing with the board.<br />
<br />
Once you get started, you can [[Rock/flash_the_image|flash]] latest [[Rock/prebuilt_images|Android image and several Linux images]], or you can try to [[Rock/SD_images|boot Android/Linux from SD card]]. You can also [[Rock/Android_Build|build your own Android]], [[Rock/Booting_Linux|build your own kernel]], [[Rock/ubuntu|build your own Ubuntu root file system]], or whatever you want.<br />
<br />
'''FAQs'''<br />
<br />
Before you ask any questions about the Radxa Rock check if your question has already been asked and answered [[rock/FAQ|Radxa Rock FAQ]].<br />
<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-3 "><br />
<div class="panel panel-midnight-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-download"></i> Download</h3><br />
</div><br />
<div class="panel-body"><br />
Visit the '''[[rock/download| download]]''' page to get the download link and description of the source code, tools, images etc<br />
</div><br />
</div><br />
</div><br />
<div class="clearfix"></div><br />
<div class="col-md-4 "><br />
<div class="panel panel-cocktail-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-users"></i> Community</h3><br />
</div><br />
<div class="panel-body"><br />
'''Users'''<br />
<br />
* [http://talk.radxa.com/ Radxa Talk]<br />
* [https://plus.google.com/communities/114007636590240429960 Radxa Google Plus community]<br />
* [https://www.facebook.com/groups/218416868348521/ Facebook Group Page]<br />
<br />
'''Developers'''<br />
<br />
* [https://groups.google.com/forum/#!forum/radxa radxa google groups], send emails to radxa@googlegroups.com to subscribe <br />
* <tt>#radxa</tt> [http://en.wikipedia.org/wiki/Internet_Relay_Chat IRC] channel on [http://freenode.net/ Freenode]. Click to [http://webchat.freenode.net/?channels=radxa join #radxa on Freenode (WebChat mode)], or consult [http://irclog.whitequark.org/radxa/ IRC logs]. <br />
</div><br />
</div><br />
<div class="panel panel-gunmetal-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-linux"></i> Linux</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/Booting Linux | Build your own kernel and boot into Linux]]<br />
* [[rock/Linux Mainline | Build Linux Mainline]]<br />
* [[rock/ubuntu| Make Ubuntu rootfs]]<br />
* [[Rock/debian | Make Debian rootfs]]<br />
* [[rock/make_sd_image| Make SD booting images]]<br />
* [[rock/audio | Audio on Rock]]<br />
* [[rock/display | Display on Rock]]<br />
* [[rock/LED| Using LEDs on Rock]]<br />
* [[rock/vnc | Setting up VNC server on Rock]]<br />
* [[rock/sd lubuntu | Boot Lubuntu from SD card]] '''OBSOLETE''' <br />
</div><br />
</div><br />
</div><br />
<div class="col-md-4"><br />
<div class="panel panel-mango-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-cog"></i> Common HowTos</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/flash the image | Flash the image to NAND]]<br />
* [[rock/SD images | Flash the image to SD card]]<br />
* [[rock/SD upgrading | Upgrade NAND from SD card]]<br />
* [[rock/backup| Backing up]]<br />
* [[rock/fsck| Recovery ext4 file system]]<br />
* [[rock/Serial debug tools Setting | Serial console debugging]]<br />
* [[rock/unbrick | Unbrick Rock]]<br />
* [[rock/resize linux rootfs |Resize linux rootfs ]]<br />
* [[rock/ir| Using IR on Rock]]<br />
* [[rock/usb| Using USB on Rock]]<br />
* [[rock/uart| Using UART on Rock]]<br />
* [[rock/Wireless | Using Wireless on Rock]]<br />
* [[rock/Camera | Using Camera on Rock]]<br />
* [[rock/Tp,Lvds,Camera | Using Lvds,Tp,Camera on Rock]]<br />
* [[rock/Rock Lite | Run Rock Lite]]<br />
* [[rock/Hdmi Resolution| Add new hdmi resolution]]<br />
* [[rock/wiringX| wringX: GPIO/I2C/SPI/ISR/UART]]<br />
</div><br />
</div><br />
<div class="panel panel-berry-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-check-circle"></i> Others</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/dual boot| Dual boot Android/Linux]]<br />
* [[rock/FreeBSD| Boot FreeBSD]] <br />
</div><br />
</div><br />
<div class="panel panel-party-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-gamepad"></i> Addons</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/cases | Cases]]<br />
* [[rock/cables | Cables]]<br />
* [[rock/shields | Extension boards]]<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-4 "><br />
<div class="panel panel-cello-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-hdd-o"></i> Hardware</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/specifications| Specifications]]<br />
* [[rock/hardware revision | Hardware Revision]]<br />
* [[rock/extension header | Extension Header]]<br />
* [[rock/hardware docs | hardware documents]]<br />
</div><br />
</div><br />
<div class="panel panel-meadow-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-android"></i> Android</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/windows adb| ADB under Windows]]<br />
* [[rock/linux adb| ADB under Linux]]<br />
* [[rock/Android Build|Build Android image for RR]]<br />
* [[rock/SD booting | Making bootable SD card]]<br />
* [[rock/AP android |Make radxa as a WIFI_AP]]<br />
* [[rock/Android backup | Backup your apps]]<br />
* [[rock/Android dev tips | Some tips for android development]]<br />
</div><br />
</div><br />
<div class="panel panel-cyanide-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-bold"></i> Bootloader</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/bootloader | Boot Loader]]<br />
* [[rock/U-Boot | U-Boot]]<br />
</div><br />
</div><br />
</div><br />
<div class="clearfix"></div><br />
<div class="col-md-6 pull-left"><br />
<div class="panel panel-neutral-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title">Projects</h3><br />
</div><br />
<div class="panel-body"><br />
* [http://radxa.com/Rock/pilight Run Pilight on Radxa Rock for remote control]<br />
* [http://www.mydbapool.com/install-postgresql-9-4-raspberry-pi-radxa-similarmicrocomputers-running-lubuntu/ How to install PostgreSQL 9.4 on Radxa Rock]<br />
* [http://hwswbits.blogspot.com/2013/10/diy-nas-with-rk3188-device-radxa-rock.html DIY low power NAS (home file server) with Radxa Rock]<br />
* [http://www.megaleecher.net/Network_Sharing_Radxa_Rock Network sharing on Radxa Rock]<br />
* [http://hwswbits.blogspot.com/2013/10/radxa-rock-communicating-with-i2c.html Hardware hacking: Communicating the Radxa with external I2C devices]<br />
* [http://hwswbits.blogspot.com/2013/10/bitbanging-radxa-rock-gpios.html Hardware hacking: Control Radxa Rock's expansion header GPIOs]<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-6 pull-right"><br />
<div class="panel panel-concrete-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title">References</h3><br />
</div><br />
<div class="panel-body"><br />
'''Photos'''<br />
<br />
* [http://dl.radxa.com/rock/media/pic/hd/ Some high definition photos of the Radxa Rock engineering samples]<br />
<br />
'''External'''<br />
<br />
* [http://www.cnx-software.com/2013/09/07/radxa-rock-development-boards-with-rockchip-rk3188-are-available-for-developers-now/ cnx-soft - radxa rock development boards with rockchips rk3188 are available for developers now]<br />
* [http://linuxgizmos.com/open-sbc-runs-android-and-linux-on-quad-core-rockchip/ linuxgizmos - open sbc runs android and linux on quad core rockchip]<br />
* [http://minipute.com/2013/09/12/new-radxa-rock-single-board-computer-runs-rockchip-rk3188-90/3246 minipute - new radxa rock single board computer runs rockchip rk3188]<br />
* [http://omglaptop.com/desktops/radxa-rock-specs-price/ omglaptop - Radxa Rock Specs]<br />
* [http://liliputing.com/2013/10/picuntu-4-5-installer-loads-ubuntu-onto-rockchip-rk3188-devices.html PicUntu 4.5 with a GUI installer for RK3188 based devices]<br />
</div><br />
</div><br />
</div><br />
<br />
<br />
<br />
<br />
[[Category:Rock]]</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-10T10:51:17Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/flash_the_image}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/wiringX/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.<br />
<br />
== UART ==<br />
<br />
We also add UART in wiringX to support serial port communication. Two UART port on J8: UART0 and UART3. A simple example to use UART0 communicate with arduino uno:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int fd=-1, c=0;'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1){'''<br />
''' if(wiringXserialDataAvail (fd)>0){'''<br />
''' c=wiringXserialGetchar(fd);'''<br />
''' printf("Data received is: %d.\n", c);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' unsigned char d=0x00;'''<br />
''' wiringXSetup();'''<br />
''' pinMode(0, OUTPUT);'''<br />
''' if ((fd = wiringXserialOpen ("/dev/ttyS0", 9600)) < 0) {'''<br />
''' fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;'''<br />
''' return -1;'''<br />
''' }'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
''' wiringXserialPutchar(fd, d);'''<br />
''' while(1){'''<br />
''' digitalWrite(0, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(0, LOW);'''<br />
''' sleep(1);'''<br />
''' }'''<br />
'''}'''<br />
<br />
Codes on arduino:<br />
<br />
'''boolean stringComplete = false; // whether the string is complete'''<br />
'''char inChar = 0x00;'''<br />
'''void setup() {'''<br />
''' // initialize serial:'''<br />
''' Serial.begin(9600);'''<br />
''' pinMode(13,OUTPUT);'''<br />
''' digitalWrite(13,LOW);'''<br />
'''}'''<br />
'''void loop() {'''<br />
''' if (stringComplete) {'''<br />
''' Serial.write(inChar);'''<br />
''' inChar=inChar+1;'''<br />
''' digitalWrite(13,LOW);'''<br />
''' delay(1000);'''<br />
''' digitalWrite(13,HIGH);'''<br />
''' delay(1000);'''<br />
''' }'''<br />
'''}'''<br />
'''void serialEvent() {'''<br />
''' while (Serial.available()) {'''<br />
''' inChar = (char)Serial.read();'''<br />
''' if (inChar == 0x00) {'''<br />
''' stringComplete = true;'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
<br />
Result:<br />
<br />
[[File:Uart.png]]<br />
<br />
And you can see LED on arduino and red led on Rock blink.</div>
Pavle
https://wiki.radxa.com/File:Uart.png
File:Uart.png
2015-06-10T10:49:03Z
<p>Pavle: </p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-10T01:43:16Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/flash_the_image}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/wiringX/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(35, OUTPUT);'''<br />
''' digitalWrite(35, HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(35, LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-09T13:11:34Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/flash_the_image}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/wiringX/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
<br />
[[File:pin-wiringX.png]]<br />
<br />
== GPIO ==<br />
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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(pinToGPIO[35], OUTPUT);'''<br />
''' digitalWrite(pinToGPIO[35], HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(pinToGPIO[35], LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
<br />
[[File:Arduino.png]]<br />
<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-09T13:07:10Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/flash_the_image}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/wiringX/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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:<br />
[[File:pin-wiringX.png]]<br />
== GPIO ==<br />
WiringX provide 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.<br />
''' #include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include "wiringX.h"'''<br />
'''int main(void) {'''<br />
''' wiringXSetup();'''<br />
''' pinMode(pinToGPIO[35], OUTPUT);'''<br />
''' digitalWrite(pinToGPIO[35], HIGH);'''<br />
''' sleep(1);'''<br />
''' digitalWrite(pinToGPIO[35], LOW);'''<br />
''' sleep(1);'''<br />
'''}'''<br />
<br />
<br />
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.<br />
<br />
== I2C ==<br />
To test I2C, SPI and ISR, an arduino uno is used. It has I2C and SPI, and can act as interrupt source.<br />
[[File:Arduino.png]]<br />
I2C0 is connected to pin 31, 32 on J8. Code on radxa:<br />
'''#include <stdio.h>''' <br />
'''#include <stdlib.h>''' <br />
'''#include <unistd.h>''' <br />
'''#include <stdint.h>''' <br />
'''#include "wiringX.h"''' <br />
'''#define I2C_ADDR 0x04''' <br />
'''int fd_i2c; ''' <br />
'''int main(void) { ''' <br />
''' wiringXSetup();'''<br />
''' if((fd_i2c = wiringXI2CSetup(I2C_ADDR)) < 0) { ''' <br />
''' fprintf(stderr, "I2C Setup failed: %i\n", fd_i2c); ''' <br />
''' return -1; ''' <br />
''' } else { '''<br />
''' fprintf(stderr, "I2C Setup OK: %i\n", fd_i2c); ''' <br />
''' } '''<br />
''' int data=0; ''' <br />
''' while(1) { ''' <br />
''' data=wiringXI2CRead(fd_i2c); ''' <br />
''' sleep(2); <br />
''' printf("Data received is:%d\n",data); ''' <br />
''' } '''<br />
'''} '''<br />
<br />
Code on arduino:<br />
''' #include <Wire.h>'''<br />
''' byte i=0;'''<br />
''' void setup()'''<br />
''' {'''<br />
''' Wire.begin(4);'''<br />
''' Wire.onRequest(requestEvent);'''<br />
''' }'''<br />
''' void loop()'''<br />
''' {'''<br />
''' delay(100);'''<br />
''' }'''<br />
''' void requestEvent()'''<br />
''' {'''<br />
''' Wire.write(i);'''<br />
''' i++;'''<br />
''' }'''<br />
The result:<br />
<br />
[[File:I2C.png]]<br />
<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. A simple example on radxa: <br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <stdint.h>'''<br />
'''#include "wiringX.h"'''<br />
'''/* SPI Config */'''<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''int fd_spi;'''<br />
'''int main(void) {'''<br />
''' unsigned char spi_data=0x00;'''<br />
''' wiringXSetup();'''<br />
''' // set up SPI'''<br />
''' if((fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED)) < 0) {'''<br />
''' fprintf(stderr, "SPI Setup failed: %i\n", fd_spi);'''<br />
''' } else {'''<br />
''' fprintf(stderr, "SPI Setup OK: %i\n", fd_spi);'''<br />
''' }'''<br />
''' while(1) { '''<br />
''' wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
''' printf("%c\n",spi_data);'''<br />
''' sleep(2);'''<br />
''' }'''<br />
'''}'''<br />
Arduino code:<br />
'''#include <SPI.h>'''<br />
'''char buf=0;'''<br />
'''volatile boolean process_it;'''<br />
'''void setup (void)'''<br />
'''{'''<br />
''' pinMode(MISO, OUTPUT);'''<br />
''' SPCR |= _BV(SPE);'''<br />
''' process_it = false;'''<br />
''' SPI.attachInterrupt();'''<br />
'''}'''<br />
'''ISR (SPI_STC_vect)'''<br />
'''{'''<br />
''' byte c = SPDR;'''<br />
''' SPDR=0x31;'''<br />
''' buf = c;'''<br />
''' process_it = true;'''<br />
'''}'''<br />
'''void loop (void)'''<br />
'''{'''<br />
''' if (process_it)'''<br />
''' {'''<br />
''' buf= 0; '''<br />
''' process_it = false;'''<br />
''' } '''<br />
'''}'''<br />
<br />
<br />
<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. A simple example:<br />
<br />
'''#include <stdio.h>'''<br />
'''#include <stdlib.h>'''<br />
'''#include <unistd.h>'''<br />
'''#include <pthread.h>'''<br />
'''#include "wiringX.h"'''<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0) {'''<br />
''' printf("interrupt\n");'''<br />
''' } else {'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
''' }'''<br />
'''}'''<br />
'''int main(void) {'''<br />
''' pthread_t pth;'''<br />
''' wiringXSetup();'''<br />
''' wiringXISR(1, INT_EDGE_RISING);'''<br />
''' pthread_create(&pth, NULL, interrupt, NULL);'''<br />
'''}'''<br />
<br />
It will cause interrupt when rising edge inputs to pin 1. The result:<br />
<br />
[[File:Interrupt.png]]<br />
<br />
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.</div>
Pavle
https://wiki.radxa.com/File:Interrupt.png
File:Interrupt.png
2015-06-09T13:04:55Z
<p>Pavle: </p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:I2C.png
File:I2C.png
2015-06-09T12:47:49Z
<p>Pavle: </p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:Arduino.png
File:Arduino.png
2015-06-09T12:36:00Z
<p>Pavle: </p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:Pin-wiringX.png
File:Pin-wiringX.png
2015-06-09T12:13:29Z
<p>Pavle: </p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-09T04:19:27Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/flash_the_image}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/wiringX/wiringX github]. <br />
<br />
When compile your source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header 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).<br />
== GPIO ==<br />
WiringX provide digitalread and digitalwrite, after you set it as input/output using pinMode:<br />
'''wiringXSetup();'''<br />
'''pinMode(0, OUTPUT);'''<br />
'''digitalWrite(0, HIGH);'''<br />
<br />
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.<br />
<br />
== I2C ==<br />
I2C0 is connected to pin 31, 32 on J8, it can be simply used like:<br />
'''#define I2C_ADDR 0x04 '''<br />
'''fd_i2c = wiringXI2CSetup(I2C_ADDR)'''<br />
'''data=wiringXI2CRead(fd_i2c);'''<br />
'''wiringXI2CWrite(fd_i2c, data);'''<br />
== SPI ==<br />
SPI0 and SPI1 are connected to J12/15, J8 respectively. It can be used like:<br />
'''#define SPI_CHAN 0'''<br />
'''#define SPI_SPEED 250000'''<br />
'''wiringXSetup();'''<br />
'''fd_spi = wiringXSPISetup(SPI_CHAN, SPI_SPEED);'''<br />
'''wiringXSPIDataRW(SPI_CHAN, &spi_data, 1);'''<br />
== ISR ==<br />
For RK3188, Port A can be configured as interrupt. It can be used like:<br />
'''pthread_t pth;'''<br />
'''wiringXSetup();'''<br />
'''wiringXISR(1, INT_EDGE_RISING);'''<br />
'''pthread_create(&pth, NULL, interrupt, NULL);'''<br />
This will creat a thread "interrupt" to handle:<br />
'''void *interrupt(void *param) {'''<br />
''' while(1) {'''<br />
''' if(waitForInterrupt(1, 1000) > 0)'''<br />
''' printf("interrupt\n");'''<br />
''' else'''<br />
''' printf("timeout\n");'''<br />
''' }'''<br />
'''}'''<br />
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.</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-09T03:33:44Z
<p>Pavle: </p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/flash_the_image}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. Till now, it supports five platforms: Raspberry Pi, Hummingboard, BananaPi, Radxa Rock and <br />
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.<br />
<br />
Firstly, you can get wiringX from [https://github.com/wiringX/wiringX github]:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on [https://github.com/wiringX/wiringX github]. <br />
<br />
When you compile you source code, add the static lib like:<br />
'''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
'''./test'''<br />
WiringX is running on your board!<br />
<br />
== Pin Number Defined in WiringX==<br />
You can find pin numbers for Radxa Rock(pro/lite) [http://radxa.com/Rock/extension_header here]. However, only those pins that 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 on pin number 33-35.<br />
== GPIO ==<br />
WiringX provide digitalread and digitalwrite to a pin, after you set it as input/output using pinMode:<br />
'''wiringXSetup();'''<br />
'''pinMode(0, OUTPUT);'''<br />
'''digitalWrite(0, HIGH);'''<br />
<br />
<br />
<br />
<br />
== I2C ==<br />
<br />
== SPI ==<br />
<br />
== ISR ==</div>
Pavle
https://wiki.radxa.com/Rock/wiringX
Rock/wiringX
2015-06-09T02:59:00Z
<p>Pavle: Created page with "{{rock_header}} {{Languages|rock/flash_the_image}} __TOC__ WiringX is a modular approach to several GPIO interfaces. For Rock/pro/lite, wiringX provides interface for GPIO, I..."</p>
<hr />
<div>{{rock_header}}<br />
{{Languages|rock/flash_the_image}}<br />
__TOC__<br />
<br />
WiringX is a modular approach to several GPIO interfaces. For Rock/pro/lite, wiringX provides interface for GPIO, I2C, SPI and ISR. You can get the source code and find the way to use it on [https://github.com/wiringX/wiringX github]. <br />
Firstly, get wiringX from github:<br />
'''git clone https://github.com/wiringX/wiringX.git'''<br />
'''cd wiringX'''<br />
or<br />
'''wget https://github.com/wiringX/wiringX/archive/master.zip'''<br />
'''unzip master.zip'''<br />
'''cd wiringX-master'''<br />
Then, install wiringX follow the way on github.<br />
When you compile you source, add the dynamic lib like:<br />
''''gcc -o test test.c /usr/local/lib/libwiringX.a'''<br />
<br />
== GPIO ==<br />
<br />
== I2C ==<br />
<br />
== SPI ==<br />
<br />
== ISR ==</div>
Pavle
https://wiki.radxa.com/Rock
Rock
2015-06-09T02:33:05Z
<p>Pavle: </p>
<hr />
<div>{{Rock_header}}<br />
<br />
{{Languages|rock}}<br />
<br />
<div class="col-md-8 mwbs-color-darker"><br />
<div class="thumbnail ">http://wiki.radxa.com/mw/images/3/36/Rock.jpg</div><br />
<div class="caption"><br />
<h3>Radxa Rock(Pro/Lite)</h3><br />
<p class="text-justify">Radxa Rock is a RK3188 based SBC(Single Board Computer) by [[Special:SpecialContact| Radxa]]. It has a quad core ARM processor, can run android or some Linux distributions. It also features 80 pin 2.54mm headers, which makes it easy to connect other sensors or use the GPIO.</p><br />
</div><br />
</div><br />
__TOC__<br />
<div class="col-md-9"><br />
<div class="panel panel-hearts-white"> <br />
<div class="panel-heading"> <h3 class="panel-title"><i class="fa fa-hand-o-up"></i> Getting started</h3> </div><br />
<br />
<div class="panel-body"><br />
The Radxa Rock is shipped with Android 4.2.2 (Jelly Bean) and Ubuntu/Linaro 13.09 dual boot on the NAND flash (on-board storage) and it works out of the box(Rock Pro is shipped with Android 4.4.2(Kitkat) on NAND flash). Let's read '''[[rock/Getting Started|Radxa Rock Getting Started Guide]]''' and hook everything up and start playing with the board.<br />
<br />
Once you get started, you can [[Rock/flash_the_image|flash]] latest [[Rock/prebuilt_images|Android image and several Linux images]], or you can try to [[Rock/SD_images|boot Android/Linux from SD card]]. You can also [[Rock/Android_Build|build your own Android]], [[Rock/Booting_Linux|build your own kernel]], [[Rock/ubuntu|build your own Ubuntu root file system]], or whatever you want.<br />
<br />
'''FAQs'''<br />
<br />
Before you ask any questions about the Radxa Rock check if your question has already been asked and answered [[rock/FAQ|Radxa Rock FAQ]].<br />
<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-3 "><br />
<div class="panel panel-midnight-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-download"></i> Download</h3><br />
</div><br />
<div class="panel-body"><br />
Visit the '''[[rock/download| download]]''' page to get the download link and description of the source code, tools, images etc<br />
</div><br />
</div><br />
</div><br />
<div class="clearfix"></div><br />
<div class="col-md-4 "><br />
<div class="panel panel-cocktail-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-users"></i> Community</h3><br />
</div><br />
<div class="panel-body"><br />
'''Users'''<br />
<br />
* [http://talk.radxa.com/ Radxa Talk]<br />
* [https://plus.google.com/communities/114007636590240429960 Radxa Google Plus community]<br />
* [https://www.facebook.com/groups/218416868348521/ Facebook Group Page]<br />
<br />
'''Developers'''<br />
<br />
* [https://groups.google.com/forum/#!forum/radxa radxa google groups], send emails to radxa@googlegroups.com to subscribe <br />
* <tt>#radxa</tt> [http://en.wikipedia.org/wiki/Internet_Relay_Chat IRC] channel on [http://freenode.net/ Freenode]. Click to [http://webchat.freenode.net/?channels=radxa join #radxa on Freenode (WebChat mode)], or consult [http://irclog.whitequark.org/radxa/ IRC logs]. <br />
</div><br />
</div><br />
<div class="panel panel-gunmetal-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-linux"></i> Linux</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/Booting Linux | Build your own kernel and boot into Linux]]<br />
* [[rock/Linux Mainline | Build Linux Mainline]]<br />
* [[rock/ubuntu| Make Ubuntu image]]<br />
* [[rock/audio | Audio on Rock]]<br />
* [[rock/display | Display on Rock]]<br />
* [[rock/LED| Using LEDs on Rock]]<br />
* [[rock/vnc | Setting up VNC server on Rock]]<br />
* [[rock/sd lubuntu | Boot Lubuntu from SD card]] '''OBSOLETE''' <br />
</div><br />
</div><br />
</div><br />
<div class="col-md-4"><br />
<div class="panel panel-mango-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-cog"></i> Common HowTos</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/flash the image | Flash the image to NAND]]<br />
* [[rock/SD images | Flash the image to SD card]]<br />
* [[rock/SD upgrading | Upgrade NAND from SD card]]<br />
* [[rock/make_sd_image| Make SD booting images]]<br />
* [[rock/backup| Backing up]]<br />
* [[rock/fsck| Recovery ext4 file system]]<br />
* [[rock/Serial debug tools Setting | Serial console debugging]]<br />
* [[rock/unbrick | Unbrick Rock]]<br />
* [[rock/resize linux rootfs |Resize linux rootfs ]]<br />
* [[rock/ir| Using IR on Rock]]<br />
* [[rock/usb| Using USB on Rock]]<br />
* [[rock/uart| Using UART on Rock]]<br />
* [[rock/Wireless | Using Wireless on Rock]]<br />
* [[rock/Camera | Using Camera on Rock]]<br />
* [[rock/Tp,Lvds,Camera | Using Lvds,Tp,Camera on Rock]]<br />
* [[rock/Rock Lite | Run Rock Lite]]<br />
* [[rock/Hdmi Resolution| Add new hdmi resolution]]<br />
* [[rock/wiringX| wringX: GPIO/I2C/SPI/ISR]]<br />
</div><br />
</div><br />
<div class="panel panel-berry-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-check-circle"></i> Others</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/dual boot| Dual boot Android/Linux]]<br />
* [[rock/FreeBSD| Boot FreeBSD]] <br />
</div><br />
</div><br />
<div class="panel panel-party-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-gamepad"></i> Addons</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/cases | Cases]]<br />
* [[rock/cables | Cables]]<br />
* [[rock/shields | Extension boards]]<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-4 "><br />
<div class="panel panel-cello-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-hdd-o"></i> Hardware</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/specifications| Specifications]]<br />
* [[rock/hardware revision | Hardware Revision]]<br />
* [[rock/extension header | Extension Header]]<br />
* [[rock/hardware docs | hardware documents]]<br />
</div><br />
</div><br />
<div class="panel panel-meadow-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-android"></i> Android</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/windows adb| ADB under Windows]]<br />
* [[rock/linux adb| ADB under Linux]]<br />
* [[rock/Android Build|Build Android image for RR]]<br />
* [[rock/SD booting | Making bootable SD card]]<br />
* [[rock/AP android |Make radxa as a WIFI_AP]]<br />
* [[rock/Android backup | Backup your apps]]<br />
* [[rock/Android dev tips | Some tips for android development]]<br />
</div><br />
</div><br />
<div class="panel panel-cyanide-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title"><i class="fa fa-bold"></i> Bootloader</h3><br />
</div><br />
<div class="panel-body"><br />
* [[rock/bootloader | Boot Loader]]<br />
* [[rock/U-Boot | U-Boot]]<br />
</div><br />
</div><br />
</div><br />
<div class="clearfix"></div><br />
<div class="col-md-6 pull-left"><br />
<div class="panel panel-neutral-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title">Projects</h3><br />
</div><br />
<div class="panel-body"><br />
* [http://radxa.com/Rock/pilight Run Pilight on Radxa Rock for remote control]<br />
* [http://www.mydbapool.com/install-postgresql-9-4-raspberry-pi-radxa-similarmicrocomputers-running-lubuntu/ How to install PostgreSQL 9.4 on Radxa Rock]<br />
* [http://hwswbits.blogspot.com/2013/10/diy-nas-with-rk3188-device-radxa-rock.html DIY low power NAS (home file server) with Radxa Rock]<br />
* [http://www.megaleecher.net/Network_Sharing_Radxa_Rock Network sharing on Radxa Rock]<br />
* [http://hwswbits.blogspot.com/2013/10/radxa-rock-communicating-with-i2c.html Hardware hacking: Communicating the Radxa with external I2C devices]<br />
* [http://hwswbits.blogspot.com/2013/10/bitbanging-radxa-rock-gpios.html Hardware hacking: Control Radxa Rock's expansion header GPIOs]<br />
</div><br />
</div><br />
</div><br />
<div class="col-md-6 pull-right"><br />
<div class="panel panel-concrete-white"><br />
<div class="panel-heading"><br />
<h3 class="panel-title">References</h3><br />
</div><br />
<div class="panel-body"><br />
'''Photos'''<br />
<br />
* [http://dl.radxa.com/rock/media/pic/hd/ Some high definition photos of the Radxa Rock engineering samples]<br />
<br />
'''External'''<br />
<br />
* [http://www.cnx-software.com/2013/09/07/radxa-rock-development-boards-with-rockchip-rk3188-are-available-for-developers-now/ cnx-soft - radxa rock development boards with rockchips rk3188 are available for developers now]<br />
* [http://linuxgizmos.com/open-sbc-runs-android-and-linux-on-quad-core-rockchip/ linuxgizmos - open sbc runs android and linux on quad core rockchip]<br />
* [http://minipute.com/2013/09/12/new-radxa-rock-single-board-computer-runs-rockchip-rk3188-90/3246 minipute - new radxa rock single board computer runs rockchip rk3188]<br />
* [http://omglaptop.com/desktops/radxa-rock-specs-price/ omglaptop - Radxa Rock Specs]<br />
* [http://liliputing.com/2013/10/picuntu-4-5-installer-loads-ubuntu-onto-rockchip-rk3188-devices.html PicUntu 4.5 with a GUI installer for RK3188 based devices]<br />
</div><br />
</div><br />
</div><br />
<br />
<br />
<br />
<br />
[[Category:Rock]]</div>
Pavle
https://wiki.radxa.com/File:Rock2-square_header.png
File:Rock2-square header.png
2015-06-03T08:23:10Z
<p>Pavle: Pavle uploaded a new version of &quot;File:Rock2-square header.png&quot;</p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:Rock2-square_header.png
File:Rock2-square header.png
2015-06-03T08:20:50Z
<p>Pavle: Pavle uploaded a new version of &quot;File:Rock2-square header.png&quot;</p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:Rock2-square_header.png
File:Rock2-square header.png
2015-06-03T08:15:31Z
<p>Pavle: Pavle uploaded a new version of &quot;File:Rock2-square header.png&quot;</p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:Rock2-square_header.png
File:Rock2-square header.png
2015-06-03T08:14:09Z
<p>Pavle: Pavle uploaded a new version of &quot;File:Rock2-square header.png&quot;</p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/Rock2/square_bb/extension_header
Rock2/square bb/extension header
2015-06-03T07:52:19Z
<p>Pavle: </p>
<hr />
<div>Rock2 Sqaure has two extension header on board, one is 50pin 2mm extension header for display. It support LVDS and single channel display with i2c for touch screen. The other is 40 pin 2.54mm extension header for GPIO/SPI/UART /I2C etc.<br />
[[File:Rock2-square header.png]] <br />
==J7 (near wifi antenna, 50 pin 2mm)==<br />
J7 is mainly used for MIPI and LVDS. There are several pins can be used as GPIO, but not recommended.<br />
{| class="wikitable" style="width:50%; white-space:nowrap"<br />
! colspan=8 | J7 <small>(50 Pins)</small><br />
|-<br />
! 1<br />
| style="width:50%;" | I2C4_SDA_TP || colspan=2 | GPIO7_C1_d<br />
! 2<br />
| style="width:50%;" | TOUCH_INT || colspan=2 | GPIO7_A6_u<br />
|-<br />
! 3<br />
| I2C4_SCL_TP || colspan=2 | GPIO7_C2_d<br />
! 4<br />
| colspan=3 | VCC_TP<br />
|-<br />
! 5<br />
| TOUCH_RST || colspan=2 | GPIO7_A5_d<br />
! 6<br />
| colspan=3 | VCC_TP<br />
|-<br />
! 7<br />
| colspan=3 | VCC_LCD<br />
! 8<br />
|I2C1_SCL_Sensor || colspan=2 | GPIO8_A5<br />
|-<br />
! 9<br />
| colspan=3 | VCC_LCD<br />
! 10<br />
| I2C1_SDA_Sensor || colspan=2 | GPIO8_A4<br />
|-<br />
! 11<br />
| colspan=3 | LVDS_D5N<br />
! 12<br />
| colspan=3 | LVDS_D5P<br />
|-<br />
! 13<br />
| colspan=3 | LVDS_D6N<br />
! 14<br />
| colspan=3 | LVDS_D6P<br />
|-<br />
! 15<br />
| colspan=3 | GND<br />
! 16<br />
| colspan=3 | GND<br />
|- <br />
! 17<br />
| colspan=3 | LVDS_D7N<br />
! 18<br />
| colspan=3 | LVDS_D7P<br />
|-<br />
! 19<br />
| colspan=3 | LVDS_D8N<br />
! 20<br />
| colspan=3 | LVDS_D8P<br />
|-<br />
! 21<br />
| colspan=3 | LVDS_CLK1N<br />
! 22<br />
| colspan=3 | LVDS_CLK1P<br />
|-<br />
! 23<br />
| colspan=3 |MIPI_TX/RX_D3N<br />
! 24<br />
|colspan=3 |MIPI_TX/RX_D3P<br />
|-<br />
! 25<br />
|colspan=3 | MIPI_TX/RX_D2N<br />
! 26<br />
| colspan=3 |MIPI_TX/RX_D2P<br />
|-<br />
! 27<br />
| colspan=3 |MIPI_TX/RX_D1N<br />
! 28<br />
| colspan=3 |MIPI_TX/RX_D1P<br />
|-<br />
! 29<br />
| colspan=3 |MIPI_TX/RX_D0N<br />
! 30<br />
| colspan=3 |MIPI_TX/RX_D0P<br />
|-<br />
! 31<br />
| colspan=3 | LVDS_D0N<br />
! 32<br />
| colspan=3 | LVDS_D0P<br />
|-<br />
! 33<br />
| colspan=3 | LVDS_D1N<br />
! 34<br />
| colspan=3 | LVDS_D1P<br />
|-<br />
! 35<br />
| colspan=3 | LCD_BL_LVDS<br />
! 36<br />
| colspan=3 | BL_EN_LVDS<br />
|-<br />
! 37<br />
| colspan=3 | VCC_LEDK<br />
! 38<br />
| colspan=3 | VCC_LEDA<br />
|-<br />
! 39<br />
| colspan=3 | VCC_LEDK<br />
! 40<br />
| colspan=3 | VCC_LEDA<br />
|-<br />
! 41<br />
| colspan=3 | LVDS_D2N<br />
! 42<br />
| colspan=3 | LVDS_D2P<br />
|-<br />
! 43<br />
| colspan=3 | LVDS_D3N<br />
! 44<br />
| colspan=3 | LVDS_D3P<br />
|-<br />
! 45<br />
| colspan=3 | LVDS_CLK0N<br />
! 46<br />
| colspan=3 | LVDS_CLK0P<br />
|-<br />
! 47<br />
| colspan=3 |MIPI_TX/RX_CLKN<br />
! 48<br />
| colspan=3 |MIPI_TX/RX_CLKP<br />
|-<br />
! 49<br />
| colspan=3 | GND<br />
! 50<br />
| colspan=3 | GND<br />
|}<br />
<br />
==J13 (near DC jack, 40 pin 2.54mm)==<br />
J13: most pins can be used as GPIO, also multiplexed as SPI, UART, I2C, etc.<br />
<br />
{| class="wikitable" style="width:50%; white-space:nowrap"<br />
! colspan=8 | J25 <br />
|-<br />
! 1<br />
| colspan=3 style="width:50%;" | GND<br />
! 2<br />
| colspan=3 style="width:50%;" | VCC_SYS<br />
|-<br />
! 3<br />
| colspan=3 | GPIO3_B5_u<br />
! 4<br />
| colspan=3 | GPIO2_A7<br />
|-<br />
! 5<br />
| colspan=3 | GPIO3_B4_d<br />
! 6<br />
| colspan=3 | GPIO2_A6<br />
|-<br />
! 7<br />
| colspan=3 | GPIO3_B3_d<br />
! 8<br />
| colspan=3 | GND<br />
|-<br />
! 9<br />
| colspan=3 | GPIO3_B2_u<br />
! 10<br />
| colspan=3 | GPIO7_B6<br />
|-<br />
! 11<br />
| colspan=3 | VCC_18<br />
! 12<br />
| colspan=3 | GPIO4_A7<br />
|-<br />
! 13<br />
| colspan=3 | VCC_3V<br />
! 14<br />
| colspan=3 | VCC18_DVP<br />
|-<br />
! 15<br />
| ADCIN2 || colspan=2 | GPIO6_A7_d<br />
! 16<br />
| colspan=3 | BAT_DET<br />
|- <br />
! 17<br />
| colspan=3 | HUB_DM1<br />
! 18<br />
| colspan=3 | GPIO8_A0<br />
|-<br />
! 19<br />
| colspan=3 | HUB_DP1<br />
! 20<br />
| SPI2_TXD|| colspan=2 | GPIO8_B1<br />
|-<br />
! 21<br />
| I2C1_SDA_Sensor || colspan=2 | GPIO8_A4<br />
! 22<br />
| SPI2_RXD || colspan=2 | GPIO8_B0<br />
|-<br />
! 23<br />
| I2C1_SCL_Sensor || colspan=2 | GPIO8_A5<br />
! 24<br />
| SPI2_CLK || colspan=2 | GPIO8_A6<br />
|-<br />
! 25<br />
| colspan=3 | VCC_IO<br />
! 26<br />
| SPI2_CSn1 || colspan=2 | GPIO8_A3<br />
|-<br />
! 27<br />
| colspan=3 | HSIC_STROBE<br />
! 28<br />
| SPI2_CSn0 || colspan=2 | GPIO8_A7<br />
|-<br />
! 29<br />
| colspan=3 | HSIC_DATA<br />
! 30<br />
| colspan=3 | GND<br />
|-<br />
! 31<br />
| colspan=3 | GND<br />
! 32<br />
| SPI0_TXD || colspan=2 | GPIO5_B6_d<br />
|-<br />
! 33<br />
| UART1_RX || colspan=2 | GPIO5_B0_u<br />
! 34<br />
| SPI0_RXD || colspan=2 | GPIO5_B7_u<br />
|-<br />
! 35<br />
| UART1_RTS || colspan=2 | GPIO5_B3_u<br />
! 36<br />
| SPI0_CSn1 || colspan=2 | GPIO5_C0_u<br />
|-<br />
! 37<br />
| UART1_CTS || colspan=2 | GPIO5_B2_u<br />
! 38<br />
| SPI0_CSn0 || colspan=2 | GPIO5_B5_u<br />
|-<br />
! 39<br />
| UART1_TX || colspan=2 | GPIO5_B1_d<br />
! 40<br />
| SPI0_CLK || colspan=2 | GPIO5_B4_u<br />
|}</div>
Pavle
https://wiki.radxa.com/Rock2/square_bb/extension_header
Rock2/square bb/extension header
2015-06-03T07:51:28Z
<p>Pavle: </p>
<hr />
<div>Rock2 Sqaure has two extension header on board, one is 50pin 2mm extension header for display. It support LVDS and single channel display with i2c for touch screen. The other is 40 pin 2.54mm extension header for GPIO/SPI/UART etc.<br />
[[File:Rock2-square header.png]] <br />
==J7 (near wifi antenna, 50 pin 2mm)==<br />
J7 is mainly used for MIPI and LVDS. There are several pins can be used as GPIO, but not recommended.<br />
{| class="wikitable" style="width:50%; white-space:nowrap"<br />
! colspan=8 | J7 <small>(50 Pins)</small><br />
|-<br />
! 1<br />
| style="width:50%;" | I2C4_SDA_TP || colspan=2 | GPIO7_C1_d<br />
! 2<br />
| style="width:50%;" | TOUCH_INT || colspan=2 | GPIO7_A6_u<br />
|-<br />
! 3<br />
| I2C4_SCL_TP || colspan=2 | GPIO7_C2_d<br />
! 4<br />
| colspan=3 | VCC_TP<br />
|-<br />
! 5<br />
| TOUCH_RST || colspan=2 | GPIO7_A5_d<br />
! 6<br />
| colspan=3 | VCC_TP<br />
|-<br />
! 7<br />
| colspan=3 | VCC_LCD<br />
! 8<br />
|I2C1_SCL_Sensor || colspan=2 | GPIO8_A5<br />
|-<br />
! 9<br />
| colspan=3 | VCC_LCD<br />
! 10<br />
| I2C1_SDA_Sensor || colspan=2 | GPIO8_A4<br />
|-<br />
! 11<br />
| colspan=3 | LVDS_D5N<br />
! 12<br />
| colspan=3 | LVDS_D5P<br />
|-<br />
! 13<br />
| colspan=3 | LVDS_D6N<br />
! 14<br />
| colspan=3 | LVDS_D6P<br />
|-<br />
! 15<br />
| colspan=3 | GND<br />
! 16<br />
| colspan=3 | GND<br />
|- <br />
! 17<br />
| colspan=3 | LVDS_D7N<br />
! 18<br />
| colspan=3 | LVDS_D7P<br />
|-<br />
! 19<br />
| colspan=3 | LVDS_D8N<br />
! 20<br />
| colspan=3 | LVDS_D8P<br />
|-<br />
! 21<br />
| colspan=3 | LVDS_CLK1N<br />
! 22<br />
| colspan=3 | LVDS_CLK1P<br />
|-<br />
! 23<br />
| colspan=3 |MIPI_TX/RX_D3N<br />
! 24<br />
|colspan=3 |MIPI_TX/RX_D3P<br />
|-<br />
! 25<br />
|colspan=3 | MIPI_TX/RX_D2N<br />
! 26<br />
| colspan=3 |MIPI_TX/RX_D2P<br />
|-<br />
! 27<br />
| colspan=3 |MIPI_TX/RX_D1N<br />
! 28<br />
| colspan=3 |MIPI_TX/RX_D1P<br />
|-<br />
! 29<br />
| colspan=3 |MIPI_TX/RX_D0N<br />
! 30<br />
| colspan=3 |MIPI_TX/RX_D0P<br />
|-<br />
! 31<br />
| colspan=3 | LVDS_D0N<br />
! 32<br />
| colspan=3 | LVDS_D0P<br />
|-<br />
! 33<br />
| colspan=3 | LVDS_D1N<br />
! 34<br />
| colspan=3 | LVDS_D1P<br />
|-<br />
! 35<br />
| colspan=3 | LCD_BL_LVDS<br />
! 36<br />
| colspan=3 | BL_EN_LVDS<br />
|-<br />
! 37<br />
| colspan=3 | VCC_LEDK<br />
! 38<br />
| colspan=3 | VCC_LEDA<br />
|-<br />
! 39<br />
| colspan=3 | VCC_LEDK<br />
! 40<br />
| colspan=3 | VCC_LEDA<br />
|-<br />
! 41<br />
| colspan=3 | LVDS_D2N<br />
! 42<br />
| colspan=3 | LVDS_D2P<br />
|-<br />
! 43<br />
| colspan=3 | LVDS_D3N<br />
! 44<br />
| colspan=3 | LVDS_D3P<br />
|-<br />
! 45<br />
| colspan=3 | LVDS_CLK0N<br />
! 46<br />
| colspan=3 | LVDS_CLK0P<br />
|-<br />
! 47<br />
| colspan=3 |MIPI_TX/RX_CLKN<br />
! 48<br />
| colspan=3 |MIPI_TX/RX_CLKP<br />
|-<br />
! 49<br />
| colspan=3 | GND<br />
! 50<br />
| colspan=3 | GND<br />
|}<br />
<br />
==J13 (near DC jack, 40 pin 2.54mm)==<br />
J13: most pins can be used as GPIO, also multiplexed as SPI, UART, I2C, etc.<br />
<br />
{| class="wikitable" style="width:50%; white-space:nowrap"<br />
! colspan=8 | J25 <br />
|-<br />
! 1<br />
| colspan=3 style="width:50%;" | GND<br />
! 2<br />
| colspan=3 style="width:50%;" | VCC_SYS<br />
|-<br />
! 3<br />
| colspan=3 | GPIO3_B5_u<br />
! 4<br />
| colspan=3 | GPIO2_A7<br />
|-<br />
! 5<br />
| colspan=3 | GPIO3_B4_d<br />
! 6<br />
| colspan=3 | GPIO2_A6<br />
|-<br />
! 7<br />
| colspan=3 | GPIO3_B3_d<br />
! 8<br />
| colspan=3 | GND<br />
|-<br />
! 9<br />
| colspan=3 | GPIO3_B2_u<br />
! 10<br />
| colspan=3 | GPIO7_B6<br />
|-<br />
! 11<br />
| colspan=3 | VCC_18<br />
! 12<br />
| colspan=3 | GPIO4_A7<br />
|-<br />
! 13<br />
| colspan=3 | VCC_3V<br />
! 14<br />
| colspan=3 | VCC18_DVP<br />
|-<br />
! 15<br />
| ADCIN2 || colspan=2 | GPIO6_A7_d<br />
! 16<br />
| colspan=3 | BAT_DET<br />
|- <br />
! 17<br />
| colspan=3 | HUB_DM1<br />
! 18<br />
| colspan=3 | GPIO8_A0<br />
|-<br />
! 19<br />
| colspan=3 | HUB_DP1<br />
! 20<br />
| SPI2_TXD|| colspan=2 | GPIO8_B1<br />
|-<br />
! 21<br />
| I2C1_SDA_Sensor || colspan=2 | GPIO8_A4<br />
! 22<br />
| SPI2_RXD || colspan=2 | GPIO8_B0<br />
|-<br />
! 23<br />
| I2C1_SCL_Sensor || colspan=2 | GPIO8_A5<br />
! 24<br />
| SPI2_CLK || colspan=2 | GPIO8_A6<br />
|-<br />
! 25<br />
| colspan=3 | VCC_IO<br />
! 26<br />
| SPI2_CSn1 || colspan=2 | GPIO8_A3<br />
|-<br />
! 27<br />
| colspan=3 | HSIC_STROBE<br />
! 28<br />
| SPI2_CSn0 || colspan=2 | GPIO8_A7<br />
|-<br />
! 29<br />
| colspan=3 | HSIC_DATA<br />
! 30<br />
| colspan=3 | GND<br />
|-<br />
! 31<br />
| colspan=3 | GND<br />
! 32<br />
| SPI0_TXD || colspan=2 | GPIO5_B6_d<br />
|-<br />
! 33<br />
| UART1_RX || colspan=2 | GPIO5_B0_u<br />
! 34<br />
| SPI0_RXD || colspan=2 | GPIO5_B7_u<br />
|-<br />
! 35<br />
| UART1_RTS || colspan=2 | GPIO5_B3_u<br />
! 36<br />
| SPI0_CSn1 || colspan=2 | GPIO5_C0_u<br />
|-<br />
! 37<br />
| UART1_CTS || colspan=2 | GPIO5_B2_u<br />
! 38<br />
| SPI0_CSn0 || colspan=2 | GPIO5_B5_u<br />
|-<br />
! 39<br />
| UART1_TX || colspan=2 | GPIO5_B1_d<br />
! 40<br />
| SPI0_CLK || colspan=2 | GPIO5_B4_u<br />
|}</div>
Pavle
https://wiki.radxa.com/File:Rock2-square_header.png
File:Rock2-square header.png
2015-06-03T07:45:20Z
<p>Pavle: </p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:J13_header.png
File:J13 header.png
2015-06-03T07:24:24Z
<p>Pavle: </p>
<hr />
<div></div>
Pavle
https://wiki.radxa.com/File:J7_header.png
File:J7 header.png
2015-06-03T07:18:35Z
<p>Pavle: J7_header.png</p>
<hr />
<div>J7_header.png</div>
Pavle