Using externalhardware over SPI from C/C++

peterv6i

Hi, need help on how to use  /dev/spi0.0 in C/C++

I need to use external hardware (uart2spi) with orangepipc. For now I have connected SPI pins and power to external board.




This external "board" works well with Arduino over a library provided by author of the board.
The source of library is here: https://github.com/RowlandTechno ... aster/MULTIUART.cpp

I need a help on how to "convert" this method to C function using /dev/spi0.0 device (how to write and receive byte/bytes) from spi.
The digitalWrite(_ss_pin, HIGH); is used to set CS signal high or low.. (I have connected CS pin from my board to CS pin on GPIO).

the methods below are for Arduino (need help how to rewrite to C using /dev/spi0.0 device)

1. char CheckRx(char UART)
   
2. {
   
3.         char RETVAL = 0;
   
4. if (UART < 4)
   
5.         {
   
6.                 digitalWrite(_ss_pin, LOW);
   
7. SPI.transfer(0x10 | UART);
   
8. delayMicroseconds(250);
   
9. RETVAL = SPI.transfer(0xFF);
   
10. digitalWrite(_ss_pin, HIGH);
    
11. delayMicroseconds(50);
    
12.         }
    
13. return (RETVAL);
    
14. }

Copy code

or this

1. void ReceiveString(char *RETVAL, char UART, char NUMBYTES)
   
2. {
   
3.         //Local variable definitions
   
4.         char IDX = (0x0);
   
5. 
   
6.         if (UART < 4)
   
7.         {
   
8.                 digitalWrite(_ss_pin, LOW);
   
9. SPI.transfer(0x20 | UART);
   
10. delayMicroseconds(50);
    
11. SPI.transfer(NUMBYTES);
    
12. delayMicroseconds(50);
    
13. while ((IDX < NUMBYTES))
    
14.                 {
    
15.                         RETVAL[IDX] = SPI.transfer(0xFF);
    
16. delayMicroseconds(50);
    
17. IDX = IDX + 1;
    
18.                 }
    
19. 
    
20.                 digitalWrite(_ss_pin, HIGH);
    
21. delayMicroseconds(50);
    
22. RETVAL[IDX] = 0;
    
23.         }
    
24. }

Copy code

some instructions are also here:

"This board provides up to four buffered UART channels from a single SPI connection. If more than four UARTs are required then a second board can be added to provide eight channels and so on.

The command code and UART channel are packed together into a single byte to increase efficiency. The command code resides in the top 4 bits and the channel resides in the bottom 2 bits.

Here are the bits in the byte and their representation.

cccc00uu

where cccc is the command code and uu is the UART channel (0 - 3).

Command Code	Parameters	Returns	Description
0x10	N/A	NumBytes (0-255)	Reads the number of bytes in the channel receive buffer.
0x30	N/A	NumBytes (0-255)	Reads the number of bytes in the channel transmit buffer.
0x20	NumBytes (0-255)	DataByte (0-255) [0-x]	Reads data byte(s) from the channel receive buffer.
0x40	NumBytes (0-255), DataByte (0-255) [0-x]	N/A	Puts data byte(s) into the channel transmit buffer.
0x80	Baud (0-7)	N/A	Sets the channel baud rate

Here are the options for the baud rate parameter.

0=1200, 1=2400, 2=4800, 3=9600, 4=19200, 5=38400, 6=57600, 7=115200

So to read the number of bytes in UART channel 2 receive buffer we send the following command code and then perform a read.

CS Low

SPISend ( 0x12 )

NumBytes = SPIReceive ( 0xFF )

CS High

To read 5 bytes from UART channel 2 receive buffer we send the following command code, the number of bytes and then perform enough reads to pull out all the data we want.

CS Low
SPISend ( 0x22 )

SPISend ( 0x05 )

Byte[0] = SPIReceive ( 0xFF )

Byte[1] = SPIReceive ( 0xFF )

Byte[2] = SPIReceive ( 0xFF )

Byte[3] = SPIReceive ( 0xFF )

Byte[4] = SPIReceive ( 0xFF )

CS High

To write 5 bytes to UART channel 2 transmit buffer we send the following command code, the number of bytes and then perform enough writes to send out all the data we want.

CS Low

SPISend ( 0x42 )

SPISend ( 0x05 )

SPISend ( Byte[0] )

SPISend ( Byte[1] )

SPISend ( Byte[2] )

SPISend ( Byte[3] )

SPISend ( Byte[4] )

CS High

Each UART peripheral has an 1000 byte buffer dedicated for receiving and another 1000 byte buffer dedicated to transmitting allowing a large amount of data to be sent and received simultaneously which should mean that you never loose a byte.

"

For now I have setup Netbeans with remote acess to orangepipc..this simple code work well ;)

1. #include <iostream>
   
2. #include <stdio.h>
   
3. #include <stdint.h>
   
4. #include <fcntl.h>
   
5. #include <stdlib.h>
   
6. #include <unistd.h>
   
7. #include <errno.h>
   
8. #include <sys/ioctl.h>
   
9. #include <string.h>
   
10. #include <gpio_lib.h>
    
11. #include <linux/spi/spidev.h>
    
12. #include <spi_lib.h>
    
13. #include <linux/types.h>
    
14. 
    
15. 
    
16. using namespace std;
    
17. 
    
18. #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
    
19. 
    
20. static const char *device = "/dev/spidev0.0";
    
21. static uint8_t mode = 3;
    
22. static uint8_t bits = 8;
    
23. static uint32_t speed = 1000000;
    
24. static uint16_t delay;
    
25. 
    
26. int main(int argc, char** argv) {
    
27.     int ret = 0;
    
28.     int fd;
    
29. 
    
30.     fd = open(device, O_RDWR);
    
31.     if (fd < 0) {
    
32.         printf("can't open device");
    
33.         return -1;
    
34.     }
    
35.    
    
36.    
    
37.    
    
38.     close(fd);
    
39.     return ret;
    
40. 
    
41. 
    
42. 
    
43. 
    
44.     /*
    
45.     int init = sunxi_gpio_init();
    
46.     cout << "sunxi_gpio_init(): " << init << ".\n";
    
47.     sunxi_gpio_set_cfgpin(SUNXI_GPA(11), SUNXI_GPIO_OUTPUT);
    
48.     sunxi_gpio_set_cfgpin(SUNXI_GPA(0), SUNXI_GPIO_OUTPUT);
    
49. 
    
50.     sunxi_gpio_output(SUNXI_GPA(11), 1);
    
51.     sleep(1);
    
52.     sunxi_gpio_output(SUNXI_GPA(11), 0);
    
53.     sunxi_gpio_output(SUNXI_GPA(0), 0);
    
54.     sleep(1);
    
55.     cout << ".";
    
56.      */
    
57. 
    
58. 
    
59.     return 0;
    
60. 
    
61. 
    
62. }

Copy code

thank you for any help
Peter

Tina

Hi,
Just to make sure:
Why can't you use the UART pins, next to the power socket?
Don't get me wrong, I never used the GPIO for UART communication, have you considered:

• If you haven't had a look at the GPIO pinout, you can find it here
• as far a I can see you connected 6 wires to the TTL controler -> what pins at the GPIO of the OPI did you use and what corrosponding pins at your board.
• As far as I understand the UART1_TX is pin38 and UART1_RX pin40 in MUX2 (?/I have not much knowledge about them but others might). UART2 and 3 see link above
• Wouldn't you need to remap these?
  

I am just trying to help a bit and maybe others will have a solution.

peterv6i

Hi, this external interface board uses

3.3V pin for power supply,
GND pin for ground

and

MISO
MOSI
CLK
CS

pin from GPIO for SPI communication..

I use this board because I have no additional space in the housing where 5 or more sensors are installed. Sensors are for:
salinity, pressure, temperature, oxygen, clorophile.. I know that OrangePi PC has some UARTs on board but I need minimum 5 uarts port. I like to avoid external usb2uart interfaces.

Initially I have used this interface with Arduino board over SPI channel but I like to use OrangePi because it's a computer (not a microcontroller) and on orangpipc I can install mysql and other software to store measured datas. I'm doing some research If I can use orangpi as autonomous measurement system.

pmpp

@peterv6i there are $2 ways to remote your arduino 150feet away from recording station, check your PM

peterv6i

I just need to use SPI bus with C/C++ and I'am looking for help thank you..