Linux系统 测试spi自发自收数据

FizZ

关于SPI驱动，测试SPI自发自收数据，需要在设备下生成SPI节点
1.查看SPI0节点（以板子生成的SPI节点以为准）

1. $ ls /dev/spidev0.0
   
2. /dev/spidev0.0
   

复制代码

2.把spi测试程序移到板子上进行gcc编译
以下为spi测试程序:
可以根据SPI节点的不同修改代码中的节点名称（41行）

1. /************************************************************
   
2. 1.SPI_IOC_RD_MODE                     //读 模式
   
3. 2.SPI_IOC_RD_LSB_FIRST                //读 LSB
   
4. 3.SPI_IOC_RD_BITS_PER_WORD            //读 每字多少位
   
5. 4.SPI_IOC_RD_MAX_SPEED_HZ             //读 最大速率
   
6. 5.SPI_IOC_WR_MODE                     //写 模式
   
7. 6.SPI_IOC_WR_LSB_FIRST                //写 LSB
   
8. 7.SPI_IOC_WR_BITS_PER_WORD            //写 每字多少位
   
9. 8.SPI_IOC_WR_MAX_SPEED_HZ             //写 最大速率
   
10. 9.SPI_IOC_MESSAGE(n)                  //传输n个数据包
    
11. *************************************************************/
    
12. 
    
13. 
    
14. 
    
15. 
    
16. 
    
17. 
    
18. 
    
19. 
    
20. #include <stdint.h>
    
21. #include <unistd.h>
    
22. #include <stdio.h>
    
23. #include <stdlib.h>
    
24. #include <getopt.h>
    
25. #include <fcntl.h>
    
26. #include <sys/ioctl.h>
    
27. #include <linux/types.h>
    
28. #include <linux/spi/spidev.h>
    
29. 
    
30. 
    
31. #include <unistd.h>
    
32. 
    
33. #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
    
34. 
    
35. static void pabort(const char *s)
    
36. {
    
37.     perror(s);
    
38.     abort();
    
39. }
    
40. 
    
41. static const char *device = "/dev/spidev0.0";
    
42. static uint8_t mode;
    
43. static uint8_t bits = 8;
    
44. static uint32_t speed = 1000; //500000;
    
45. static uint16_t delay;
    
46. 
    
47. static void transfer(int fd)
    
48. {
    
49.     int ret;
    
50.      
    
51.     //要发送的数据数组
    
52. 
    
53. 
    
54.     uint8_t tx[] = {
    
55.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    
56.         0x40, 0x00, 0x00, 0x00, 0x00, 0x95,
    
57.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    
58.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    
59.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    
60.         0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD,
    
61.         0xF0, 0x0D,
    
62.     };
    
63. 
    
64. 
    
65. 
    
66.      
    
67. 
    
68. //    uint8_t tx[] = {
    
69. //        0x55,0xaa,0xf5};
    
70.      
    
71.     uint8_t rx[ARRAY_SIZE(tx)] = {0, };    //接收的数据数据
    
72.     //声明并初始化spi_ioc_transfer结构体
    
73.     struct spi_ioc_transfer tr = {
    
74.         .tx_buf = (unsigned long)tx,
    
75.         .rx_buf = (unsigned long)rx,
    
76.         .len = ARRAY_SIZE(tx),
    
77.         .delay_usecs = delay,
    
78.         .speed_hz = speed,
    
79.         .bits_per_word = bits,
    
80.     };
    
81. 
    
82.     //SPI_IOC_MESSAGE(1)的1表示spi_ioc_transfer的数量
    
83.     ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);        //ioctl默认操作,传输数据
    
84.       
    
85.     if (ret == 1)
    
86.         pabort("can't send spi message");
    
87. 
    
88.     for (ret = 0; ret < ARRAY_SIZE(tx); ret++) {    //打印接收缓冲区
    
89.         if (!(ret % 6))                                //6个数据为一簇打印
    
90.             puts("");
    
91.         printf("%.2X ", rx[ret]);
    
92.     }
    
93.     puts("");
    
94. }
    
95. 
    
96. static void print_usage(const char *prog)            //参数错误则打印帮助信息
    
97. {
    
98.     printf("Usage: %s [-DsbdlHOLC3]\n", prog);
    
99.     puts("  -D --device   device to use (default /dev/spidev1.1)\n"
    
100.          "  -s --speed    max speed (Hz)\n"
     
101.          "  -d --delay    delay (usec)\n"
     
102.          "  -b --bpw      bits per word \n"
     
103.          "  -l --loop     loopback\n"
     
104.          "  -H --cpha     clock phase\n"
     
105.          "  -O --cpol     clock polarity\n"
     
106.          "  -L --lsb      least significant bit first\n"
     
107.          "  -C --cs-high  chip select active high\n"
     
108.          "  -3 --3wire    SI/SO signals shared\n");
     
109.     exit(1);
     
110. }
     
111. 
     
112. static void parse_opts(int argc, char *argv[])
     
113. {
     
114.     while (1) {
     
115.         static const struct option lopts[] = {
     
116.             { "device",  1, 0, 'D' },
     
117.             { "speed",   1, 0, 's' },
     
118.             { "delay",   1, 0, 'd' },
     
119.             { "bpw",     1, 0, 'b' },
     
120.             { "loop",    0, 0, 'l' },
     
121.             { "cpha",    0, 0, 'H' },
     
122.             { "cpol",    0, 0, 'O' },
     
123.             { "lsb",     0, 0, 'L' },
     
124.             { "cs-high", 0, 0, 'C' },
     
125.             { "3wire",   0, 0, '3' },
     
126.             { "no-cs",   0, 0, 'N' },
     
127.             { "ready",   0, 0, 'R' },
     
128.             { NULL, 0, 0, 0 },
     
129.         };
     
130.         int c;
     
131. 
     
132.         c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);
     
133. 
     
134.         if (c == -1)
     
135.             break;
     
136. 
     
137.         switch (c) {
     
138.         case 'D':
     
139.             device = optarg;
     
140.             break;
     
141.         case 's':
     
142.             speed = atoi(optarg);
     
143.             break;
     
144.         case 'd':
     
145.             delay = atoi(optarg);
     
146.             break;
     
147.         case 'b':
     
148.             bits = atoi(optarg);
     
149.             break;
     
150.         case 'l':
     
151.             mode |= SPI_LOOP;
     
152.             break;
     
153.         case 'H':
     
154.             mode |= SPI_CPHA;
     
155.             break;
     
156.         case 'O':
     
157.             mode |= SPI_CPOL;
     
158.             break;
     
159.         case 'L':
     
160.             mode |= SPI_LSB_FIRST;
     
161.             break;
     
162.         case 'C':
     
163.             mode |= SPI_CS_HIGH;
     
164.             break;
     
165.         case '3':
     
166.             mode |= SPI_3WIRE;
     
167.             break;
     
168.         case 'N':
     
169.             mode |= SPI_NO_CS;
     
170.             break;
     
171.         case 'R':
     
172.             mode |= SPI_READY;
     
173.             break;
     
174.         default:
     
175.             print_usage(argv[0]);
     
176.             break;
     
177.         }
     
178.     }
     
179. }
     
180. 
     
181. int main(int argc, char *argv[])
     
182. {
     
183.     int ret = 0;
     
184.     int fd;
     
185. 
     
186.      int count=0;
     
187.      char buf[]={0x11,0x22,0x33,0x44,0x55};
     
188. 
     
189.     parse_opts(argc, argv);
     
190. 
     
191.     fd = open(device, O_RDWR);
     
192.     if (fd < 0)
     
193.         pabort("can't open device");
     
194. 
     
195.     /*
     
196.      * spi mode
     
197.      */
     
198.     ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
     
199.     if (ret == -1)
     
200.         pabort("can't set spi mode");
     
201. 
     
202.     ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
     
203.     if (ret == -1)
     
204.         pabort("can't get spi mode");
     
205. 
     
206.     /*
     
207.      * bits per word
     
208.      */
     
209.     ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
     
210.     if (ret == -1)
     
211.         pabort("can't set bits per word");
     
212. 
     
213.     ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
     
214.     if (ret == -1)
     
215.         pabort("can't get bits per word");
     
216. 
     
217.     /*
     
218.      * max speed hz
     
219.      */
     
220.     ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
     
221.     if (ret == -1)
     
222.         pabort("can't set max speed hz");
     
223. 
     
224.     ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
     
225.     if (ret == -1)
     
226.         pabort("can't get max speed hz");
     
227. 
     
228.     printf("spi mode: %d\n", mode);
     
229.     printf("bits per word: %d\n", bits);
     
230.     printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
     
231. 
     
232.     while(1)
     
233.     {
     
234.         transfer(fd);            //传输测试   
     
235.         sleep(1);
     
236.          
     
237.          
     
238. 
     
239.     //count=write(fd,buf,sizeof(buf)/sizeof(buf[0]));
     
240.     //read(fd,buf,count);   
     
241.     //printf("read byte is: 0x%02X\n",buf[0]);
     
242.      //sleep(1);         
     
243.          
     
244.          
     
245.     }
     
246.      
     
247. 
     
248.     close(fd);
     
249. 
     
250.     return ret;
     
251. }

复制代码

3.运行程序，会有以下打印：

1. root@debian:~# ./spidev_test  
   
2. spi mode: 0
   
3. bits per word: 8
   
4. max speed: 1000 Hz (1 KHz)
   
5. 
   
6. 00 00 00 00 00 00
   
7. 00 00 00 00 00 00
   
8. 00 00 00 00 00 00
   
9. 00 00 00 00 00 00
   
10. 00 00 00 00 00 00
    
11. 00 00 00 00 00 00
    
12. 00 00
    
13. 
    
14. 00 00 00 00 00 00
    
15. 00 00 00 00 00 00
    
16. 00 00 00 00 00 00
    
17. 00 00 00 00 00 00
    
18. 00 00 00 00 00 00
    
19. 00 00 00 00 00 00
    
20. 00 00

复制代码

此时短接SPI0_MOSI引脚和SPI0_MISO引脚，会有以下打印:

1. FF FF FF FF FF FF
   
2. 40 00 00 00 00 95
   
3. FF FF FF FF FF FF
   
4. FF FF FF FF FF FF
   
5. FF FF FF FF FF FF
   
6. DE AD BE EF BA AD
   
7. F0 0D

复制代码

断开时又会重新变回0.

参考：https://bbs.csdn.net/topics/391055813?page=1