如何用NRF24l01同时发送多组有正负的数字？

kyzo

如题
我想用NRF24l01模块发送  MPU6050陀螺仪接收到的数据
ax, ay, az, gx, gy, gz;

看教程说只能以byte字节形式发送， 可是字节是无符号的

然后我将数据转成十六进制再发送， 还是不成功。

本人c语言比较菜， 如有菜鸟错误请原谅！！
程序是根据别人的程序改的， 备注部分没有改过来。
望有能人帮我解决解决~

下面是发送端代码

1. /*
   
2. nRF24L01 Arduino发送端
   
3. 
   
4. 引脚接法：
   
5. nRF24L01   Arduino UNO
   
6. VCC        <->        3.3V
   
7. GND        <->        GND
   
8. CE        <->        D9
   
9. CSN        <->        D10
   
10. MOSI<->        D11
    
11. MISO<->        D12
    
12. SCK        <->        D13
    
13. IRQ        <->        不接
    
14. */
    
15. 
    
16. #include "Wire.h"
    
17. #include "I2Cdev.h"
    
18. #include "MPU6050.h"
    
19. MPU6050 accelgyro;
    
20. 
    
21. int16_t ax, ay, az;
    
22. int16_t gx, gy, gz;
    
23. char adata[] = {0,0,0,0,0,0};
    
24. 
    
25. #include <SPI.h>
    
26. #include <Mirf.h>
    
27. #include <nRF24L01.h>
    
28. #include <MirfHardwareSpiDriver.h>
    
29. void setup()
    
30. {
    
31.     Wire.begin();
    
32.     Serial.begin(9600);
    
33.     accelgyro.initialize();
    
34. 
    
35.     Mirf.cePin = 9;                //设置CE引脚为D9
    
36.     Mirf.csnPin = 10;        //设置CE引脚为D10
    
37.     Mirf.spi = &MirfHardwareSpi;
    
38.     Mirf.init();  //初始化nRF24L01               
    
39. 
    
40.         //设置接收标识符"Sen01"
    
41.     Mirf.setRADDR((byte *)"Sen01");
    
42.     //设置一次收发的字节数，这里发一个整数，写sizeof(unsigned int)，实际等于2字节
    
43.     Mirf.payload = sizeof(char);
    
44.     //发送通道，可以填0~128，收发必须一致。
    
45.     Mirf.channel = 5;
    
46.     Mirf.config();
    
47. 
    
48.         //注意一个Arduino写Sender.ino，另一个写Receiver.ino。
    
49.         //这里标识写入了Sender.ino
    
50.     Serial.println("I'm Sender...");
    
51. }
    
52. //int adata = 0;
    
53. void loop()
    
54. {
    
55.         //读取A0值到adata
    
56.     //adata = analogRead(A0);
    
57.     accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
    
58.     /*ax= ax/16384;
    
59.     ay= ay/16384;
    
60.     az= az/16384;
    
61.     gx= gx/131;
    
62.     gy= gy/131;
    
63.     gz= gz/131; */
    
64. 
    
65.     /*adata[0] = ax/16384;
    
66.     adata[1] = ay/16384;
    
67.     adata[2] = az/16384;
    
68.     adata[3] = gx/131;
    
69.     adata[4] = gy/131;
    
70.     adata[5] = gz/131;  */
    
71. 
    
72.     adata[0] = (ax/16384,HEX);
    
73.     adata[1] = (ay/16384,HEX);
    
74.     adata[2] = (az/16384,HEX);
    
75.     adata[3] = (gx/131,HEX);
    
76.     adata[4] = (gy/131,HEX);
    
77.     adata[5] = (gz/131,HEX);
    
78. 
    
79.     //由于nRF24L01只能以byte单字节数组形式发送Mirf.payload个数据，
    
80.     //所以必须将所有需要传输的数据拆成byte。
    
81.     //下面定义byte数组，存放待发数据，因为Mirf.payload = sizeof(unsigned int);
    
82.     //实际下面等于byte data[2];
    
83.     byte data0[Mirf.payload];
    
84.     byte data1[Mirf.payload];
    
85.     byte data2[Mirf.payload];
    
86.     byte data3[Mirf.payload];
    
87.     byte data4[Mirf.payload];
    
88.     byte data5[Mirf.payload];
    
89. 
    
90.     //adata是unsigned int双字节数据，必须拆开。
    
91.     //将adata高低八位拆分：
    
92.     data0[0] = adata[0] & 0xFF;                //低八位给data[0]，
    
93.     data0[1] = adata[0] >> 8;                //高八位给data[1]。
    
94.     data1[0] = adata[1] & 0xFF;
    
95.     data1[1] = adata[1] >> 8;
    
96.     data2[0] = adata[2] & 0xFF;
    
97.     data2[1] = adata[2] >> 8;
    
98.     data3[0] = adata[3] & 0xFF;
    
99.     data3[1] = adata[3] >> 8;
    
100.     data4[0] = adata[4] & 0xFF;
     
101.     data4[1] = adata[4] >> 8;
     
102.     data5[0] = adata[5] & 0xFF;
     
103.     data5[1] = adata[5] >> 8;
     
104.    
     
105.     //data
     
106. 
     
107.     //设置向"serv1"发送数据
     
108.     Mirf.setTADDR((byte *)"Rec01");
     
109.     Mirf.send(data0);
     
110.     Mirf.send(data1);
     
111.     Mirf.send(data2);
     
112.     Mirf.send(data3);
     
113.     Mirf.send(data4);
     
114.     Mirf.send(data5);
     
115.    
     
116. 
     
117.     /*Serial.print(adata[0]); Serial.print("\t");
     
118.     Serial.print(adata[1]); Serial.print("\t");
     
119.     Serial.print(adata[2]); Serial.print("\t");
     
120.     Serial.print(adata[3]); Serial.print("\t");
     
121.     Serial.print(adata[4]); Serial.print("\t");
     
122.     Serial.println(adata[5]);  */  
     
123.     //while死循环等待发送完毕，才能进行下一步操作。
     
124.     while(Mirf.isSending()) {}
     
125.     delay(20);
     
126. }
     

复制代码

下面是接收端代码：

1. /*
   
2. nRF24L01 Arduino Receiver接收端
   
3. 
   
4. 引脚接法：
   
5. nRF24L01   Arduino UNO
   
6. VCC <-> 3.3V
   
7. GND <-> GND
   
8. CE  <-> D9
   
9. CSN <-> D10
   
10. MOSI<-> D11
    
11. MISO<-> D12
    
12. SCK <-> D13
    
13. IRQ <-> 不接
    
14. */
    
15. 
    
16. #include <SPI.h>
    
17. #include <Mirf.h>
    
18. #include <nRF24L01.h>
    
19. #include <MirfHardwareSpiDriver.h>
    
20. 
    
21.     //定义一个变量adata存储最终结果,oldadata存储旧结果，防止相同结果刷屏。
    
22.     int adata[]= {0,0,0,0,0,0};
    
23.     int olddata[] = {0,0,0,0,0,0};
    
24.     int adata0 =0, adata1 = 0, adata2 =0, adata3 = 0, adata4= 0, adata5 =0;
    
25. 
    
26. void setup()
    
27. {
    
28.     Serial.begin(9600);
    
29. 
    
30.     //---------初始化部分，不可随时修改---------
    
31.     Mirf.cePin = 9;     //设置CE引脚为D9
    
32.     Mirf.csnPin = 10;   //设置CE引脚为D10
    
33.     Mirf.spi = &MirfHardwareSpi;
    
34.     Mirf.init();  //初始化nRF24L01
    
35. 
    
36.     //---------配置部分，可以随时修改---------
    
37.     //设置接收标识符"Rev01"
    
38.     Mirf.setRADDR((byte *)"Rec01");
    
39.     //设置一次收发的字节数，这里发一个整数，
    
40.     //写sizeof(unsigned int)，实际等于2字节
    
41.     Mirf.payload = sizeof(char);
    
42.     //发送通道，可以填0~128，收发必须一致。
    
43.     Mirf.channel = 5;
    
44.     Mirf.config();
    
45. 
    
46.     //注意一个Arduino写Sender.ino，另一个写Receiver.ino。
    
47.     //这里用来辨别写入了Receiver.ino程序
    
48.     Serial.println("I'm Receiver...");
    
49. }
    
50. 
    
51. void loop()
    
52. {
    
53.     //定义一个暂存数组，大小为Mirf.payload。
    
54.     byte data0[Mirf.payload];
    
55.     byte data1[Mirf.payload];
    
56.     byte data2[Mirf.payload];
    
57.     byte data3[Mirf.payload];
    
58.     byte data4[Mirf.payload];
    
59.     byte data5[Mirf.payload];
    
60.     if(Mirf.dataReady())    //等待接收数据准备好
    
61.     {
    
62.         Mirf.getData(data0);    //接收数据到data数组
    
63.         Mirf.getData(data1);
    
64.         Mirf.getData(data2);
    
65.         Mirf.getData(data3);
    
66.         Mirf.getData(data4);
    
67.         Mirf.getData(data5);
    
68.         
    
69.         //data[1]<左移8位与data[0]并，重组数据。
    
70.         // adata = (unsigned int)((data[1] << 8) | data[0]);
    
71. 
    
72.         //int("adata");
    
73.         adata0 = (unsigned int)((data0[1] << 8) | data0[0]);
    
74.         adata1 = (unsigned int)((data1[1] << 8) | data1[0]);
    
75.         adata2 = (unsigned int)((data2[1] << 8) | data2[0]);
    
76.         adata3 = (unsigned int)((data3[1] << 8) | data3[0]);
    
77.         adata4 = (unsigned int)((data4[1] << 8) | data4[0]);
    
78.         adata5 = (unsigned int)((data5[1] << 8) | data5[0]);
    
79. 
    
80.         /*adata[0] = adata0;
    
81.         adata[1] = adata1;
    
82.         adata[2] = adata2;
    
83.         adata[3] = adata3;
    
84.         adata[4] = adata4;
    
85.         adata[5] = adata5; */
    
86. 
    
87.         adata[0] = (adata0,DEC);
    
88.         adata[1] = (adata1,DEC);
    
89.         adata[2] = (adata2,DEC);
    
90.         adata[3] = (adata3,DEC);
    
91.         adata[4] = (adata4,DEC);
    
92.         adata[5] = (adata5,DEC);
    
93.         
    
94.       
    
95. 
    
96.         //与上一次结果比较，避免相同结果刷屏,降低串口流量
    
97.         if(adata != olddata)
    
98.         {
    
99.             olddata[0] = adata[0]; //本次结果作为历史结果。
    
100.             olddata[1] = adata[1];
     
101.             olddata[2] = adata[2];
     
102.             olddata[3] = adata[3];
     
103.             olddata[4] = adata[4];
     
104.             olddata[5] = adata[5];
     
105.             
     
106.             //Serial.print输出数据
     
107.             //Serial.print("A0=");
     
108.             //Serial.println(adata);
     
109.             //也可以输出双字节数据   
     
110.     Serial.print(adata[0]); Serial.print("\t");
     
111.     Serial.print(adata[1]); Serial.print("\t");
     
112.     Serial.print(adata[2]); Serial.print("\t");
     
113.     Serial.print(adata[3]); Serial.print("\t");
     
114.     Serial.print(adata[4]); Serial.print("\t");
     
115.     Serial.println(adata[5]);
     
116.             //Serial.write(data[1]);
     
117.             //Serial.write(data[0]);
     
118.        }
     
119. 
     
120.     }
     
121. }
     

复制代码

redtxd

新手学习，刚准备学习2401