设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › USB无线串口转NRF24L01数传通信，DS18B20采集温度，并通 ...
返回列表 发新帖
查看: 2391|回复: 1
收起左侧

USB无线串口转NRF24L01数传通信，DS18B20采集温度，并通过串口助手显示

[复制链接]
ID:808304 发表于 2020-11-17 19:16 | 显示全部楼层 |阅读模式
最近做了一个用USB无线串口模块，串口转NRF24L01 数传通信，通过DS18B20采集外界温度，并通过传口助手显示采集的温度用到的模块用到的器材
USB无线串口模块，串口转NRF24L01 数传通信
温度采集模块，DS18B20
2块NRF24L01
51单片机
软件：串口助手
USB无线串口模块，串口转NRF24L01 数传通信.jpg DS18B20.jpg 测试结果.PNG

具体程序如下
  1. #include<reg51.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint  unsigned int


  7. /**********  NRF24L01寄存器操作命令  ***********/
  8. #define READ_REG        0x00  //读配置寄存器,低5位为寄存器地址
  9. #define WRITE_REG       0x20  //写配置寄存器,低5位为寄存器地址
  10. #define RD_RX_PLOAD     0x61  //读RX有效数据,1~32字节
  11. #define WR_TX_PLOAD     0xA0  //写TX有效数据,1~32字节
  12. #define FLUSH_TX        0xE1  //清除TX FIFO寄存器.发射模式下用
  13. #define FLUSH_RX        0xE2  //清除RX FIFO寄存器.接收模式下用
  14. #define REUSE_TX_PL     0xE3  //重新使用上一包数据,CE为高,数据包被不断发送.
  15. #define NOP             0xFF  //空操作,可以用来读状态寄存器         
  16. /**********  NRF24L01寄存器地址   *************/
  17. #define CONFIG          0x00  //配置寄存器地址                             
  18. #define EN_AA           0x01  //使能自动应答功能
  19. #define EN_RXADDR       0x02  //接收地址允许
  20. #define SETUP_AW        0x03  //设置地址宽度(所有数据通道)
  21. #define SETUP_RETR      0x04  //建立自动重发
  22. #define RF_CH           0x05  //RF通道
  23. #define RF_SETUP        0x06  //RF寄存器
  24. #define STATUS          0x07  //状态寄存器
  25. #define OBSERVE_TX      0x08  // 发送检测寄存器
  26. #define CD              0x09  // 载波检测寄存器
  27. #define RX_ADDR_P0      0x0A  // 数据通道0接收地址
  28. #define RX_ADDR_P1      0x0B  // 数据通道1接收地址
  29. #define RX_ADDR_P2      0x0C  // 数据通道2接收地址
  30. #define RX_ADDR_P3      0x0D  // 数据通道3接收地址
  31. #define RX_ADDR_P4      0x0E  // 数据通道4接收地址
  32. #define RX_ADDR_P5      0x0F  // 数据通道5接收地址
  33. #define TX_ADDR         0x10  // 发送地址寄存器
  34. #define RX_PW_P0        0x11  // 接收数据通道0有效数据宽度(1~32字节)
  35. #define RX_PW_P1        0x12  // 接收数据通道1有效数据宽度(1~32字节)
  36. #define RX_PW_P2        0x13  // 接收数据通道2有效数据宽度(1~32字节)
  37. #define RX_PW_P3        0x14  // 接收数据通道3有效数据宽度(1~32字节)
  38. #define RX_PW_P4        0x15  // 接收数据通道4有效数据宽度(1~32字节)
  39. #define RX_PW_P5        0x16  // 接收数据通道5有效数据宽度(1~32字节)
  40. #define FIFO_STATUS     0x17  // FIFO状态寄存器
  41. /*————————————————————————————————————————————————————————————————————*/

  43. /******   STATUS寄存器bit位定义      *******/
  44. #define MAX_TX          0x10            //达到最大发送次数中断
  45. #define TX_OK           0x20            //TX发送完成中断
  46. #define RX_OK           0x40            //接收到数据中断
  47. /*——————————————————————————————————————————————————*/

  49. /*********     24L01发送接收数据宽度定义          ***********/
  50. #define TX_ADR_WIDTH    5     //5字节地址宽度
  51. #define RX_ADR_WIDTH    5     //5字节地址宽度
  52. #define TX_PLOAD_WIDTH  32    //32字节有效数据宽度
  53. #define RX_PLOAD_WIDTH  32    //32字节有效数据宽度

  55. const uchar TX_ADDRESS[TX_ADR_WIDTH]={0xFF,0xFF,0xFF,0xFF,0xFF}; //发送地址
  56. const uchar RX_ADDRESS[RX_ADR_WIDTH]={0xFF,0xFF,0xFF,0xFF,0xFF}; //发送地址

  58. sbit NRF_CE   = P0^7;
  59. sbit NRF_CSN  = P0^6;
  60. sbit NRF_MISO = P0^3;
  61. sbit NRF_MOSI = P0^4;
  62. sbit NRF_SCK  = P0^5;
  63. sbit NRF_IRQ  = P0^2;
  64. sbit LED=P1^0;
  65. sbit DQ=P3^7; //ds18b20 与单片机连接口
  66. //sbit S1=P3^0;
  67. //sbit S2=P3^1;
  68. //sbit S3=P3^2;
  69. uchar rece_buf[32];
  70. uchar data disdata[6];// 百、十、个、小数位1、小数位2、        小数位3、
  71. uint tvalue; // 温度值
  72. uchar tflag; // 温度正负标志

  74. void delay_us(uchar num)
  75. {
  76.         uchar i;
  77.         for(i=0;i>num;i++)
  78.         _nop_();
  79. }
  80. void delay_150us()
  81. {
  82.         uint i;

  84.         for(i=0;i>150;i++);
  85. }
  86. void delay(uint t)
  87. {
  88.         uchar k;
  89.         while(t--)
  90.         for(k=0;k<200;k++);
  91. }
  92. /***************************************************************/

  94. /*******************************************************************/
  95. uchar SPI_RW(uchar byte)
  96. {
  97.         uchar bit_ctr;
  98.         for(bit_ctr=0;bit_ctr<8;bit_ctr++)  // 输出8位
  99.         {
  100.                 NRF_MOSI=(byte&0x80);                         // MSB TO MOSI
  101.                 byte=(byte<<1);                                        // shift next bit to MSB
  102.                 NRF_SCK=1;
  103.                 byte|=NRF_MISO;                                // capture current MISO bit
  104.                 NRF_SCK=0;
  105.         }
  106.         return byte;
  107. }

  109. /*********************************************/
  110. /* 函数功能：给24L01的寄存器写值（一个字节） */
  111. /* 入口参数：reg   要写的寄存器地址          */
  112. /*           value 给寄存器写的值            */
  113. /* 出口参数：status 状态值                   */
  114. /*********************************************/
  115. uchar NRF24L01_Write_Reg(uchar reg,uchar value)
  116. {
  117.         uchar status;

  119.         NRF_CSN=0;                  //CSN=0;   
  120.           status = SPI_RW(reg);                //发送寄存器地址,并读取状态值
  121.         SPI_RW(value);
  122.         NRF_CSN=1;                  //CSN=1;

  124.         return status;
  125. }
  126. /*************************************************/
  127. /* 函数功能：读24L01的寄存器值 （一个字节）      */
  128. /* 入口参数：reg  要读的寄存器地址               */
  129. /* 出口参数：value 读出寄存器的值                */
  130. /*************************************************/
  131. uchar NRF24L01_Read_Reg(uchar reg)
  132. {
  133.         uchar value;

  135.         NRF_CSN=0;              //CSN=0;   
  136.           SPI_RW(reg);                        //发送寄存器值(位置),并读取状态值
  137.         value = SPI_RW(NOP);
  138.         NRF_CSN=1;                     //CSN=1;

  140.         return value;
  141. }
  142. /*********************************************/
  143. /* 函数功能：读24L01的寄存器值（多个字节）   */
  144. /* 入口参数：reg   寄存器地址                */
  145. /*           *pBuf 读出寄存器值的存放数组    */
  146. /*           len   数组字节长度              */
  147. /* 出口参数：status 状态值                   */
  148. /*********************************************/
  149. uchar NRF24L01_Read_Buf(uchar reg,uchar *pBuf,uchar len)
  150. {
  151.         uchar status,u8_ctr;
  152.         NRF_CSN=0;                           //CSN=0      
  153.           status=SPI_RW(reg);                                //发送寄存器地址,并读取状态值             
  154.         for(u8_ctr=0;u8_ctr<len;u8_ctr++)
  155.         pBuf[u8_ctr]=SPI_RW(0XFF);                //读出数据
  156.         NRF_CSN=1;                                 //CSN=1
  157.           return status;                                //返回读到的状态值
  158. }
  159. /**********************************************/
  160. /* 函数功能：给24L01的寄存器写值（多个字节）  */
  161. /* 入口参数：reg  要写的寄存器地址            */
  162. /*           *pBuf 值的存放数组               */
  163. /*           len   数组字节长度               */
  164. /**********************************************/
  165. uchar NRF24L01_Write_Buf(uchar reg, uchar *pBuf, uchar len)
  166. {
  167.         uchar status,u8_ctr;
  168.         NRF_CSN=0;
  169.           status = SPI_RW(reg);                        //发送寄存器值(位置),并读取状态值
  170.           for(u8_ctr=0; u8_ctr<len; u8_ctr++)
  171.         SPI_RW(*pBuf++);                                 //写入数据
  172.         NRF_CSN=1;
  173.           return status;                          //返回读到的状态值
  174. }                                                                                                    

  176. /*********************************************/
  177. /* 函数功能：24L01接收数据                   */
  178. /* 入口参数：rxbuf 接收数据数组              */
  179. /* 返回值： 0   成功收到数据                 */
  180. /*          1   没有收到数据                 */
  181. /*********************************************/
  182. uchar NRF24L01_RxPacket(uchar *rxbuf)
  183. {
  184.         uchar state;
  185.          
  186.         state=NRF24L01_Read_Reg(STATUS);                          //读取状态寄存器的值             
  187.         NRF24L01_Write_Reg(WRITE_REG+STATUS,state); //清除TX_DS或MAX_RT中断标志
  188.         if(state&RX_OK)                                                                //接收到数据
  189.         {
  190.                 NRF_CE = 0;
  191.                 NRF24L01_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
  192.                 NRF24L01_Write_Reg(FLUSH_RX,0xff);                                        //清除RX FIFO寄存器
  193.                 NRF_CE = 1;
  194.                 delay_150us();
  195.                 return 0;
  196.         }          
  197.         return 1;//没收到任何数据
  198. }
  199. /**********************************************/
  200. /* 函数功能：设置24L01为发送模式              */
  201. /* 入口参数：txbuf  发送数据数组              */
  202. /* 返回值； 0x10    达到最大重发次数，发送失败*/
  203. /*          0x20    成功发送完成              */
  204. /*          0xff    发送失败                  */
  205. /**********************************************/
  206. uchar NRF24L01_TxPacket(uchar *txbuf)
  207. {
  208.         uchar state;
  209.    
  210.         NRF_CE=0;                                                                                                //CE拉低，使能24L01配置
  211.           NRF24L01_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);        //写数据到TX BUF  32个字节
  212.         NRF_CE=1;                                                                                                //CE置高，使能发送          
  213.         while(NRF_IRQ==1);                                                                                //等待发送完成
  214.         state=NRF24L01_Read_Reg(STATUS);                                                  //读取状态寄存器的值          
  215.         NRF24L01_Write_Reg(WRITE_REG+STATUS,state);                         //清除TX_DS或MAX_RT中断标志
  216.         if(state&MAX_TX)                                                                                //达到最大重发次数
  217.         {
  218.                 NRF24L01_Write_Reg(FLUSH_TX,0xff);                                        //清除TX FIFO寄存器
  219.                 return MAX_TX;
  220.         }
  221.         if(state&TX_OK)                                                                                        //发送完成
  222.         {
  223.                 return TX_OK;
  224.         }
  225.         return 0xff;                                                                                        //发送失败
  226. }

  228. /********************************************/
  229. /* 函数功能：检测24L01是否存在              */
  230. /* 返回值；  0  存在                        */
  231. /*           1  不存在                      */
  232. /********************************************/           
  233. uchar NRF24L01_Check(void)
  234. {
  235.         uchar check_in_buf[5]={0x11,0x22,0x33,0x44,0x55};
  236.         uchar check_out_buf[5]={0x00};

  238.         NRF_SCK=0;
  239.         NRF_CSN=1;   
  240.         NRF_CE=0;

  242.         NRF24L01_Write_Buf(WRITE_REG+TX_ADDR, check_in_buf, 5);

  244.         NRF24L01_Read_Buf(READ_REG+TX_ADDR, check_out_buf, 5);

  246.         if((check_out_buf[0] == 0x11)&&\
  247.            (check_out_buf[1] == 0x22)&&\
  248.            (check_out_buf[2] == 0x33)&&\
  249.            (check_out_buf[3] == 0x44)&&\
  250.            (check_out_buf[4] == 0x55))return 0;
  251.         else return 1;
  252. }                       


  255. void NRF24L01_RT_Init(void)
  256. {       
  257.         NRF_CE=0;                  
  258.           NRF24L01_Write_Reg(WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度
  259.         NRF24L01_Write_Reg(FLUSH_RX,0xff);                                                                        //清除RX FIFO寄存器   
  260.           NRF24L01_Write_Buf(WRITE_REG+TX_ADDR,(uchar*)TX_ADDRESS,TX_ADR_WIDTH);//写TX节点地址
  261.           NRF24L01_Write_Buf(WRITE_REG+RX_ADDR_P0,(uchar*)RX_ADDRESS,RX_ADR_WIDTH); //设置TX节点地址,主要为了使能ACK          
  262.           NRF24L01_Write_Reg(WRITE_REG+EN_AA,0x01);     //使能通道0的自动应答   
  263.           NRF24L01_Write_Reg(WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收地址  
  264.           NRF24L01_Write_Reg(WRITE_REG+SETUP_RETR,0x1a);//设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次
  265.           NRF24L01_Write_Reg(WRITE_REG+RF_CH,0);        //设置RF通道为2.400GHz  频率=2.4+0GHz
  266.           NRF24L01_Write_Reg(WRITE_REG+RF_SETUP,0x0F);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
  267.           NRF24L01_Write_Reg(WRITE_REG+CONFIG,0x0f);    //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开启所有中断
  268.         NRF_CE=1;                                                                          //CE置高，使能发送
  269. }

  271. void SEND_BUF(uchar *buf)
  272. {
  273.         NRF_CE=0;
  274.         NRF24L01_Write_Reg(WRITE_REG+CONFIG,0x0e);
  275.         NRF_CE=1;
  276.         delay_us(15);
  277.         NRF24L01_TxPacket(buf);
  278.         NRF_CE=0;
  279.         NRF24L01_Write_Reg(WRITE_REG+CONFIG, 0x0f);
  280.         NRF_CE=1;       
  281. }
  282. /******************************ds18b20 程序 ******************************************************************/
  283. void delay_18b20(uint i) // 延时 1 微秒
  284. {
  285. while(i--);
  286. }
  287. void ds18b20rst() //ds18b20 初始化子函数
  288. // 要求"数据线拉高 - 延时 - 数据线拉低 - 延时大于 480 微妙 -数据线拉高 - 延时等待 "
  289. {
  290. uchar x=0;
  291. DQ = 1; // 信号线 DQ复位
  292. delay_18b20(4); // 延时
  293. DQ = 0; //DQ 拉低
  294. delay_18b20(100); // 精确延时大于 480us
  295. DQ = 1; // 拉高
  296. delay_18b20(40);
  297. }
  298. void ds18b20wr(uchar wdata) /* 写数据子函数 , 无返回值，含参数 */
  299. {
  300. uchar i=0;
  301. for (i=8; i>0; i--)// 要写完一个字节，故需要重复 8 次以下操作
  302. {
  303. DQ = 0; // 数据线拉低
  304. DQ = wdata&0x01;//wdata 是一个形参，将其与 0000 0001 进行按位与
  305. // 按从低到高的顺序发送数据（一次发送一位 )
  306. delay_18b20(10);
  307. DQ = 1; // 最后将数据线拉高
  308. wdata>>=1; // 将 wdata 右移 1 位
  309. }
  310. }
  311. uchar ds18b20rd() // 读数据子函数 , 是有返回值 dat
  312. {
  313. uchar i=0;
  314. uchar dat = 0;
  315. for (i=8;i>0;i--)// 要读完一个字节，故需要重复 8 次以下操作
  316. {
  317. DQ = 0; // 给脉冲信号
  318. dat>>=1;
  319. DQ = 1; // 给脉冲信号
  320. if(DQ)
  321. dat|=0x80;
  322. delay_18b20(10);
  323. }
  324. return(dat); // 返回 dat
  325. }
  326. read_temp() // 读取温度值并转换的子函数，有返回值温度值 tvalue
  327. {
  328. uchar a,b;
  329. ds18b20rst(); // 调用 ds18b20 初始化子函数
  330. ds18b20wr(0xcc);// 调用写数据子函数，向 ds18b20 写命令 0xcc
  331. //ccH 表示跳过 ROM读序列号，适用于单机工作，直接向 18b20 发送温度变换命令
  332. ds18b20wr(0x44);// 调用写数据子函数，向 ds18b20 写命令 0x44
  333. //44H 表示启动 ds18b20 温度转换 , 结果自行存入 9 字节的 RAM中
  334. ds18b20rst(); // 调用 ds18b20 初始化子函数
  335. ds18b20wr(0xcc);// 同上
  336. ds18b20wr(0xbe);// 调用写数据子函数，向 ds18b20 写命令 0xbe
  337. //beH 表示读取 RAM中 9 字节的温度数据
  338. a=ds18b20rd(); // 调用读数据子函数，并将所得数据给 a
  339. b=ds18b20rd(); //
  340. tvalue=b; // 把 b 的值给 tvalue
  341. tvalue<<=8; //tvalue 左移 8 位
  342. tvalue=tvalue|a;//tvalue 与 a 进行按位或
  343. if(tvalue<0x0fff)//
  344. tflag=0; // 前五位为 0 时，读取的温度为正，标志位为 0，此时只要
  345. // 将测得数值乘以 0.0625 即可得到实际温度
  346. else // 前五位为 1 时，读取的温度为负，标志位为 1，此时需要
  347. { // 将测得数值取反后再加 1，再乘以 0.0625 即可得到实际温度
  348. tvalue=~tvalue+1;
  349. tflag=1; // 此时表示负温度
  350. }
  351. tvalue=tvalue*(0.625);// 温度值扩大 10 倍，精确到 1 位小数
  352. return(tvalue); // 返回温度值
  353. }
  354. /**********************************************/


  357. void main()
  358. {uchar flagdat;
  359.         while(NRF24L01_Check()); // 等待检测到NRF24L01，程序才会向下执行
  360.         NRF24L01_RT_Init();               

  362.         while(1)
  363.         {
  364.                 if(NRF_IRQ==0)                 // 如果无线模块接收到数据
  365.                 {               
  366.                         if(NRF24L01_RxPacket(rece_buf)==0)
  367.                         {                          
  368.                                 if(        rece_buf[1]=='1')                           //第1位以后是收到的命令数据，rece_buf[0]是数据位数长度
  369.                                         LED=0;
  370.                                 if(        rece_buf[1]=='2')                         //第1位以后是收到的命令数据，rece_buf[0]是数据位数长度
  371.                                         LED=1;               
  372.                         }
  373.                 }
  374.                 read_temp(); // 调用 ds18b20 读取温度       
  375.        

  377.                   rece_buf[1]='T';
  378.                   rece_buf[2]='=';
  379.       
  380.                  rece_buf[3]='+'; // 百位数;
  381.                         rece_buf[4]=tvalue%1000/100+0x30;// 十位数;
  382.                         rece_buf[5]=tvalue%100/10+0x30; // 个位数;
  383.       rece_buf[6] ='.';
  384.                   rece_buf[7] =tvalue%10+0x30; // 小数位
  385.      rece_buf[8]='C';
  386.                  rece_buf[9]=0x0d;
  387.                  rece_buf[10]=0x0a;//串口助手换行
  388.                         rece_buf[0]=10;                                                  //一共要发送10个字节，rece_buf[0]必须是10！！！！！！
  389.                         SEND_BUF(rece_buf);
  390.                

  392.                 delay(1000);
  393.         }
  394. }
复制代码

全部资料51hei下载地址：
DS18B20采集温度，并通过串口助手显示采集的温度.zip (43.69 KB, 下载次数: 48)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:858367 发表于 2021-1-8 09:17 | 显示全部楼层
楼主辛苦，资料不错
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表