如何用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. }
     

复制代码

275891381

自己定义个规则  每个int16_t 按3个字节发送  第一个定义个正负标志  第二个高8位  第三个 低八位  就可以了      例如符号位用0x0f 代表负   0xf0 代表 正    -12345=0x0f  0x48 0f69

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. int16_t data[6];
    
21. int num=0;
    
22. int16_t ax, ay, az;
    
23. int16_t gx, gy, gz;
    
24. char adata[] = {0,0,0,0,0,0};
    
25. 
    
26. #include <SPI.h>
    
27. #include <Mirf.h>
    
28. #include <nRF24L01.h>
    
29. #include <MirfHardwareSpiDriver.h>
    
30. void setup()
    
31. {
    
32.     Wire.begin();
    
33.     Serial.begin(9600);
    
34.     accelgyro.initialize();
    
35. 
    
36.     Mirf.cePin = 9;                //设置CE引脚为D9
    
37.     Mirf.csnPin = 10;        //设置CE引脚为D10
    
38.     Mirf.spi = &MirfHardwareSpi;
    
39.     Mirf.init();  //初始化nRF24L01               
    
40. 
    
41.         //设置接收标识符"Sen01"
    
42.     Mirf.setRADDR((byte *)"Sen01");
    
43.     //设置一次收发的字节数，这里发一个整数，写sizeof(unsigned int)，实际等于2字节
    
44.     Mirf.payload = 18;
    
45.    
    
46.     //发送通道，可以填0~128，收发必须一致。
    
47.     Mirf.channel = 5;
    
48.     Mirf.config();
    
49. 
    
50.         //注意一个Arduino写Sender.ino，另一个写Receiver.ino。
    
51.         //这里标识写入了Sender.ino
    
52.     Serial.println("I'm Sender...");
    
53. }
    
54. //int adata = 0;
    
55. void loop()
    
56. {
    
57.         //读取A0值到adata
    
58.     //adata = analogRead(A0);
    
59.     accelgyro.getMotion6(&data[0], &data[1], &data[2], &data[3], &data[4], &data[5]);
    
60.     byte adata[Mirf.payload];
    
61.     for(int i=0;i<6;i++)
    
62.     {
    
63.           if(data[i]< 0){adata[3*i+0]=0x0f;adata[3*i+1]=(0-data[i])/255;adata[3*i+2]=(0-data[i])%255;}
    
64.           if(data[i]>=0){adata[3*i+0]=0xf0;adata[3*i+1]=(0+data[i])/255;adata[3*i+2]=(0+data[i])%255;}
    
65.     }
    
66. 
    
67.     //设置向"serv1"发送数据
    
68.     Mirf.setTADDR((byte *)"Rec01");
    
69.     Mirf.send(adata);
    
70. 
    
71.     /*Serial.print(adata[0]); Serial.print("\t");
    
72.     Serial.print(adata[1]); Serial.print("\t");
    
73.     Serial.print(adata[2]); Serial.print("\t");
    
74.     Serial.print(adata[3]); Serial.print("\t");
    
75.     Serial.print(adata[4]); Serial.print("\t");
    
76.     Serial.println(adata[5]);  */  
    
77.     //while死循环等待发送完毕，才能进行下一步操作。
    
78.     while(Mirf.isSending()) {}
    
79.     delay(20);
    
80. }
    

复制代码

kyzo

275891381 发表于 2016-9-8 08:15
自己定义个规则  每个int16_t 按3个字节发送  第一个定义个正负标志  第二个高8位  第三个 低八位  就可以 ...

可以加个qq向您寻求指导吗 我q740237763

kyzo

275891381 发表于 2016-9-8 08:15
自己定义个规则  每个int16_t 按3个字节发送  第一个定义个正负标志  第二个高8位  第三个 低八位  就可以 ...

谢谢你！！我跟着这个思路已经做出来了！

接收端代码：

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

复制代码

275891381

kyzo 发表于 2016-9-8 13:16
谢谢你！！我跟着这个思路已经做出来了！

接收端代码：

弄好就行，恭喜了，这样可能会放慢mpu6050的数据速度，还有别的方法 就是用一个字节的8位定义正负 这样 6*2+1个字节就够了 估计能快一点点；

最好再优化下你的程序，不然会慢的很

kyzo

275891381 发表于 2016-9-8 16:17
弄好就行，恭喜了，这样可能会放慢mpu6050的数据速度，还有别的方法 就是用一个字节的8位定义正负 这样 ...

不太懂 可以详细说一下吗