code:

1. 
   
2. #include <iostream>
   
3. #include <stdint.h>
   
4. #include <unistd.h>
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <getopt.h>
   
8. #include <fcntl.h>
   
9. #include <sys/ioctl.h>
   
10. #include <sys/times.h>
    
11. #include <linux/types.h>
    
12. #include <linux/spi/spidev.h>
    
13. #include <spi_lib.h>
    
14. 
    
15. using namespace std;
    
16. 
    
17. #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
    
18. 
    
19. static const char *device = "/dev/spidev0.0";
    
20. static uint8_t mode = 0;
    
21. static uint8_t bits = 8;
    
22. static uint32_t speed = 1500000;
    
23. static uint16_t delays;
    
24. 
    
25. static void pabort(const char *s) {
    
26.     perror(s);
    
27.     abort();
    
28. }
    
29. 
    
30. void setBaudRate(int fd, char uart) {
    
31.     if (uart < 4) {
    
32.         int ret = -1;
    
33.         uint8_t tx_buffer_baud = (uint8_t) (0x80 | uart); //9600 baud rate UART 1
    
34.         ret = spi_write(fd, &tx_buffer_baud, 1);
    
35.         printf("ret1: %d\n", ret);
    
36.         tx_buffer_baud = (uint8_t) 0x3;
    
37.         ret = spi_write(fd, &tx_buffer_baud, 1);
    
38.         printf("ret1: %d\n", ret);
    
39.     }
    
40. }
    
41. 
    
42. void TransmitString(int fd, char uart, char *DATA, char NUMBYTES) {
    
43.     char IDX = (0x0);
    
44.     int ret = -1;
    
45.     if (uart < 4) {
    
46.         uint8_t tx_buffer_baud = (uint8_t) (0x40 | uart); //9600 baud rate UART 1
    
47.         ret = spi_write(fd, &tx_buffer_baud, 1);
    
48.         tx_buffer_baud = (uint8_t) (NUMBYTES);
    
49.         ret = spi_write(fd, &tx_buffer_baud, 1);
    
50.         usleep(150);
    
51.         while (IDX < NUMBYTES) {
    
52.             tx_buffer_baud = (uint8_t) DATA[IDX];
    
53.             ret = spi_write(fd, &tx_buffer_baud, 1);
    
54.             IDX = IDX + 1;
    
55.         }
    
56.         
    
57.     }
    
58. }
    
59. 
    
60. int main(int argc, char** argv) {
    
61.     int ret = 0;
    
62.     int fd;
    
63. 
    
64.     fd = open(device, O_RDWR); //read write
    
65.     if (fd < 0) {
    
66.         printf("can't open device");
    
67.         return -1;
    
68.     }
    
69.    
    
70.          /*
    
71.          * spi mode
    
72.          */
    
73.         ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
    
74.         if (ret == -1)
    
75.                 pabort("can't set spi mode");
    
76. 
    
77.         ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
    
78.         if (ret == -1)
    
79.                 pabort("can't get spi mode");
    
80. 
    
81.         /*
    
82.          * bits per word
    
83.          */
    
84.         ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
    
85.         if (ret == -1)
    
86.                 printf("can't set bits per word");
    
87. 
    
88.         ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
    
89.         if (ret == -1)
    
90.                 printf("can't get bits per word");
    
91. 
    
92.         /*
    
93.          * max speed hz
    
94.          */
    
95.         ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
    
96.         if (ret == -1)
    
97.                 printf("can't set max speed hz");
    
98. 
    
99.         ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
    
100.         if (ret == -1)
     
101.                 printf("can't get max speed hz");
     
102. 
     
103. 
     
104.    
     
105.     printf("spi mode: %d\n", mode);
     
106.     printf("bits per word: %d\n", bits);
     
107.     printf("max speed: %d Hz (%d KHz)\n", speed, speed / 1000);
     
108. 
     
109. 
     
110.     //set baud rate
     
111.     // Initialise the UART baud rates
     
112.     // 0=1200, 1=2400, 2=4800, 3=9600, 4=19200, 5=38400, 6=57600, 7=115200
     
113.     setBaudRate(fd, 0); //UART 1
     
114.     setBaudRate(fd, 1); //UART 1
     
115.     setBaudRate(fd, 2); //UART 1
     
116.     setBaudRate(fd, 3); //UART 1
     
117.    
     
118.    
     
119. 
     
120.     TransmitString(fd,0,"PETER TEST",10);
     
121.    
     
122.     close(fd);
     
123.     return ret;
     
124. 
     
125. }