PIC单片机nrf24l01无线模块实验

qwer1415926

网上买了几片G01-D模块兼容NRF24l01 ，陆陆续续弄了好长时间终于可以使用了。
最远距离没测试，10多米没有压力。感兴趣的可以看看。
程序有些乱。

1. /***********nrf 24i01.h***********/
   
2. #ifndef NRF24L01_h//FASONG
   
3. #define NRF24L01_h
   
4. #include <pic.h>
   
5. //__CONFIG(0X3B31);
   
6. #define uint8 unsigned char
   
7. #define uint16 unsigned int
   
8. void delays(uint16 us);
   
9. void SpiInit();
   
10. uint8 SPI_RW(uint8 byte);
    
11. uint8 SPI_Read(uint8 reg);
    
12. uint8 SPI_RW_Reg(uint8 reg,uint8 value);
    
13. uint8 SPI_Read_Buf(uint8 reg, uint8 *pBuf, uint8 uchars);
    
14. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
    
15. void TX_MODE(void);
    
16. void SetRX_Mode(void);
    
17. 
    
18. void Transmit(uint8 *tx_buf);
    
19. void ce24();
    
20. 
    
21. 
    
22. 
    
23. #define CSN  RD1
    
24. #define IRQ  RC1
    
25. #define CE   RD0
    
26. #define MOSI RC3
    
27. #define MISO RC0
    
28. #define SCK  RC2
    
29. #define BACK_LED RD4
    
30. #define KEY  RB0
    
31. /*********************
    
32. #define CSN  RE1
    
33. #define IRQ  RE0
    
34. #define CE   RE2
    
35. #define MOSI RC4
    
36. #define MISO RC5
    
37. #define SCK  RC3
    
38. #define BACK_LED RC1
    
39. #define KEY  RB7
    
40. ************************/
    
41. 
    
42. #define TX_ADR_WIDTH   5
    
43. #define RX_ADR_WIDTH   5
    
44. #define RX_PLOAD_WIDTH 10
    
45. #define TX_PLOAD_WIDTH 10
    
46. uint8 TX_ADDRESS[TX_ADR_WIDTH]={0X34,0X43,0X10,0X10,0X01};
    
47. uint8 RX_ADDRESS[RX_ADR_WIDTH]={0X34,0X43,0X10,0X10,0X01};
    
48. uint8 Tx_Buf[TX_PLOAD_WIDTH]={0};
    
49. /*
    
50. uint8 Tx_Buf[TX_PLOAD_WIDTH]={0xff,0xee,0x11,0x22,0x33,0xaa,0xbb,0x11,0x22,0x33,0xaa,0xbb,
    
51.                                0x11,0x22,0x33,0xaa,0xbb,0x11,0x22,0x33,0xaa,0xbb
    
52.                              ,0x11,0x22,0x33,0xaa,0xbb,0x11,0x22,0x33,0xee,0xff};//32
    
53. */
    
54. uint8 sta=0;//NRF24L01状态
    
55. 
    
56. /***********************寄存器指令***********************/
    
57. #define READ_REG      0X00    //读寄存器指令
    
58. #define WRITE_REG     0X20    //写寄存器指令
    
59. #define RD_RX_PLOAD   0X61    //读取接收数据指令
    
60. #define WR_TX_PLOAD   0XA0    //写待发数据指令
    
61. #define FLUSH_TX      0XE1    //清除发送FIFO指令
    
62. #define FLUSH_RX      0XE2    //清除接收FIFO指令
    
63. #define REUSE_TX_PL   0XE3    //定义重复装载数据指令
    
64. #define NOPP          0XFF    //保留
    
65. /***********************寄存器地址***********************/
    
66. #define config        0X00    //配置收发状态，CRC校验及收发响应方式
    
67. #define EN_AA         0X01    //自动应答功能设置
    
68. #define EN_RXADDR     0X02    //可用信道设置
    
69. #define SETUP_AW      0X03    //收发地址宽度设置
    
70. #define SETUP_RETR    0X04    //自动重发功能设置
    
71. #define RF_CH         0X05    //工作频率设置
    
72. #define RF_SETUP      0X06    //发送速率，功耗功能设置
    
73. #define STATUS        0X07    //状态寄存器
    
74. #define OBSERVE_TX    0X08    //发送监测功能
    
75. #define CD            0X09    //地址检测
    
76. #define RX_ADDR_P0    0X0A    //频道0接收数据地址
    
77. #define RX_ADDR_P1    0X0B    //频道1接收数据地址
    
78. #define RX_ADDR_P2    0X0C    //频道2接收数据地址
    
79. #define RX_ADDR_P3    0X0D    //频道3接收数据地址
    
80. #define RX_ADDR_P4    0X0E    //频道4接收数据地址
    
81. #define RX_ADDR_P5    0X0F    //频道5接收数据地址
    
82. #define TX_ADDR       0X10    //发送地址寄存器
    
83. #define RX_PW_P0      0x11    // 接收频道0接收数据有效数据长度
    
84. #define RX_PW_P1      0x12    // 接收频道1接收数据有效数据长度
    
85. #define RX_PW_P2      0x13    // 接收频道2接收数据有效数据长度
    
86. #define RX_PW_P3      0x14    // 接收频道3接收数据有效数据长度
    
87. #define RX_PW_P4      0x15    // 接收频道4接收数据有效数据长度
    
88. #define RX_PW_P5      0x16    // 接收频道5接收数据有效数据长度
    
89. #define FIFO_STATUS   0X17    //FIFO栈入栈出状态寄存器设置
    
90. #define MAX_RT        0X10    //MAX_RTD在第5位|
    
91. #define TX_DS         0X20    //TX_DS在第6位  | 在读回STATUS时与其相与，就知道该位是否为1
    
92. #define RX_DR         0X40    //RX_DR在第7位  |
    
93. 
    
94. void ce24()
    
95. {
    
96. 
    
97. if(KEY==0)
    
98.           {
    
99.               delays(1000);
    
100.               if(KEY==0)
     
101.               {
     
102.                   //while(KEY==0);
     
103.                   BACK_LED=1;
     
104.                   delays(5000);
     
105.                   BACK_LED=0;
     
106.                   //TX_MODE();
     
107.                  // Transmit(0xff);
     
108.                   delays(5000);
     
109.                   sta=SPI_Read(READ_REG+STATUS);
     
110.                   SPI_RW_Reg(WRITE_REG+STATUS,sta);//STATUS清0
     
111.                   CE=0;
     
112.               }
     
113.           }
     
114. }
     
115. 
     
116. void delays(uint16 us)
     
117. {
     
118.     while(us--);
     
119. }
     
120. 
     
121. /*****************************************************************/
     
122. 
     
123. void SpiInit()
     
124. {
     
125.      TRISC=0X03;//设置RC3/SCK,RC5/SDO为输出0X20//misoshuru
     
126. 
     
127.      TRISD=0X00;//IRQ为输入，CE,CSN为输出0X01
     
128. 
     
129. 
     
130.                 CE=0;
     
131.                   CSN=1;
     
132.      CSN=1;
     
133.      SCK=0;
     
134.      IRQ=1;
     
135. 
     
136.      //delay(50000);
     
137. 
     
138.      TX_MODE();
     
139.      //Transmit(Tx_Buf);
     
140.      delays(50000);
     
141.      sta=SPI_Read(READ_REG+STATUS);
     
142.       SPI_RW_Reg(WRITE_REG+STATUS,sta);//STATUS清0
     
143. CE=0;
     
144. 
     
145. 
     
146. 
     
147. 
     
148. 
     
149. 
     
150. 
     
151. }
     
152. 
     
153. uint8 SPI_RW(uint8 byte)
     
154. {
     
155. uint8  bit_ctr;
     
156. //DI();
     
157.     for(bit_ctr=0;bit_ctr<8;bit_ctr++)    // output 8-bit
     
158.     {
     
159.      if(byte & 0x80)
     
160.       {MOSI = 1;}
     
161.      else
     
162.      { MOSI = 0;}
     
163.      byte = (byte << 1);             // shift next bit into MSB..
     
164.      SCK = 1;                   // Set nRF24L01_SCK high..
     
165.      if(MISO) byte |= 1;
     
166.                 NOP();NOP();NOP();NOP();
     
167.      SCK = 0;              // ..then set nRF24L01_SCK low again
     
168.                 NOP();NOP();NOP();NOP();
     
169.     }
     
170.     //EI();
     
171.     return(byte);                 // return read byte
     
172. }
     
173. /*uint8 SPI_Read()   //通过SPI读一个字节
     
174. {
     
175.       CSN=0;
     
176.       SSPBUF=0X00;//读一个字节前必需先写入一个字节
     
177.       while(!BF);
     
178.       CSN=1;
     
179.       return(SSPBUF);
     
180. }*/
     
181. uint8 SPI_Read(uint8 reg)
     
182. {
     
183.       uint8 reg_val;
     
184.       CSN=0;
     
185.       SPI_RW(reg);
     
186.       reg_val=SPI_RW(0);
     
187.       CSN=1;
     
188.       return(reg_val);
     
189. }
     
190. uint8 SPI_RW_Reg(uint8 reg,uint8 value)//向寄存器写一个字节，同时返回状态字
     
191. {
     
192.       uint8 status;
     
193.       CSN=0;
     
194.       status=SPI_RW(reg);
     
195.       SPI_RW(value);
     
196.       CSN=1;
     
197.       return(status);
     
198. }
     
199. /*****************************************************************************************/
     
200. /*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
     
201. /*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数
     
202. /****************************************************************************************/
     
203. uint8 SPI_Read_Buf(uint8 reg, uint8 *pBuf, uint8 uchars)
     
204. {
     
205.               uint8 status,uchar_ctr;
     
206. 
     
207.               CSN = 0;                                                // Set CSN low, init SPI tranaction
     
208.               status = SPI_RW(reg);                                   // Select register to write to and read status uchar
     
209. 
     
210.               for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
     
211.                             pBuf[uchar_ctr] = SPI_RW(0);    //
     
212. 
     
213.               CSN = 1;                          
     
214. 
     
215.               return(status);                    // return nRF24L01 status uchar
     
216. }
     
217. //*/////////////
     
218. 
     
219. uint8 SPI_Write_Buf(uint8 reg,uint8 *pBuf,uint8 bytes)//向寄存器写入一个字符串
     
220. {
     
221.       uint8 status,byte_ctr;
     
222.       CSN=0;
     
223.       status=SPI_RW(reg);
     
224.       for(byte_ctr=0;byte_ctr< bytes; byte_ctr++)   
     
225.   {
     
226.             SPI_RW(*pBuf++);
     
227.       }
     
228.       CSN=1;
     
229.       return(status);
     
230. }
     
231. 
     
232. 
     
233. 
     
234. 
     
235. /***************************以上为SPI通讯程序**********************************/
     
236. /******************************************************************************/
     
237. //发送模式代码
     
238. void TX_MODE(void)
     
239. //void TX_MODE(unsigned char *tx_data)
     
240. {
     
241.      CE=0;
     
242.         // CSN=1;   // Spi  disable
     
243.      SCK=0;   //
     
244.      SPI_RW_Reg(FLUSH_TX,0X00);
     
245.      SPI_Write_Buf(WRITE_REG+TX_ADDR,TX_ADDRESS,TX_ADR_WIDTH); // 写本地地址
     
246.      SPI_Write_Buf(WRITE_REG+RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);// 写接收端地址
     
247. //        SPI_Write_Buf(WR_TX_PLOAD, tx_data, TX_ADR_WIDTH);      //写有效数据地址 + 有效数据 + 有效数据宽度
     
248.      SPI_RW_Reg(WRITE_REG+EN_AA,0X01); //  频道0自动              ACK应答允许      
     
249.      SPI_RW_Reg(WRITE_REG+EN_RXADDR,0X01); //  允许接收地址只有频道0，
     
250.      SPI_RW_Reg(WRITE_REG+SETUP_RETR,0X15);//禁止重发0X00//0AZIDONG 0x15 5ci
     
251.      SPI_RW_Reg(WRITE_REG+RF_CH,40);   //   设置信道工作为2.4GHZ，收发必须一致
     
252.      SPI_RW_Reg(WRITE_REG+RF_SETUP,0X07);//设置发射速率为1MHZ，发射功率
     
253.      SPI_RW_Reg(WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//设置接收数据长度，本次设置为32字节
     
254.      SPI_RW_Reg(WRITE_REG+config,0X0e);//发送上电,16位CRC校验,CRC使能
     
255.      CE=1;
     
256.                 IRQ=1;
     
257.      delays(5000);
     
258. }
     
259. void Transmit(uint8 *tx_buf)
     
260. {
     
261.      CE=0;
     
262.      SPI_Write_Buf(WRITE_REG+RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);
     
263.      SPI_RW_Reg(FLUSH_TX,0X00);
     
264.      SPI_Write_Buf(WR_TX_PLOAD,tx_buf,TX_PLOAD_WIDTH);
     
265.      SPI_RW_Reg(WRITE_REG+config,0X0E);
     
266.      CE=1;
     
267.      delays(100);
     
268. }
     
269. /***********************************************************************************************************
     
270. /*函数：void nRF24L01_TxPacket(unsigned char * tx_buf)
     
271. /*功能：发送 tx_buf中数据
     
272. /**********************************************************************************************************/
     
273. void nRF24L01_TxPacket(unsigned char * tx_buf)
     
274. {
     
275. 
     
276. TX_MODE();
     
277. CE=0;   //StandBy I模式
     
278. SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
     
279. SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);     // 装载数据
     
280. SPI_RW_Reg(WRITE_REG + config, 0x0e);      // IRQ收发完成中断响应，16位CRC，主发送////////
     
281. CE=1;   //置高CE，激发数据发送
     
282. delays(200);
     
283. }
     
284. /****************************************************************************/
     
285. /****************************************************************************************************/
     
286. /*函数：void SetRX_Mode(void)
     
287. /*功能：数据接收配置
     
288. /****************************************************************************************************/
     
289. void SetRX_Mode(void)
     
290. {
     
291.               CE=0;
     
292.               SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);                               // IRQ收发完成中断响应，16位CRC              ，主接收
     
293.               CE = 1;
     
294.               delays(180);
     
295. }
     
296. /******************************************************************************************************/
     
297. /*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
     
298. /*功能：数据读取后放如rx_buf接收缓冲区中
     
299. /******************************************************************************************************/
     
300. unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
     
301. {
     
302.     unsigned char revale=0;
     
303.               sta=SPI_Read(STATUS);              // 读取状态寄存其来判断数据接收状况
     
304.               if(RX_DR)                                                        // 判断是否接收到数据
     
305.               {
     
306.                   CE = 0;                                           //SPI使能
     
307.                             SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
     
308.                             revale =1;                                          //读取数据完成标志
     
309.               }
     
310.               SPI_RW_Reg(WRITE_REG+STATUS,sta);   //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
     
311.               return revale;
     
312. }
     
313. 
     
314. 
     
315. 
     
316. 
     
317. 
     
318. unsigned char Check_ACK(void)
     
319. {
     
320.         sta=SPI_Read(WRITE_REG+STATUS);//读取寄存状态            // 返回状态寄存器
     
321. return 1;
     
322.         if(MAX_RT || TX_DS)
     
323.             {
     
324.                     SPI_RW_Reg(WRITE_REG + STATUS, 0xff);  // 清除TX_DS或MAX_RT中断标志
     
325.                 CSN = 0;
     
326.                 SPI_RW(FLUSH_TX);
     
327.                 CSN = 1;
     
328.                 IRQ = 1;
     
329. 
     
330.                 return 0;
     
331.             }
     
332.             IRQ = 1;
     
333.     //else
     
334.          
     
335. }
     
336. 
     
337. /****************************************/
     
338. 
     
339. /**************************************************
     
340. 函数：Check_ACK()
     
341. 描述：
     
342.     检查接收设备有无接收到数据包，设定没有收到应答信
     
343.     号是否重发
     
344. /***********************************************
     
345. uchar Check_ACK(bit clear)
     
346. {
     
347.     delay(2000);
     
348.     while(IRQ);
     
349.     sta = SPI_RW(NOP);                    // 返回状态寄存器
     
350.     if(TX_DS)
     
351.     {
     
352.         blink(3);
     
353.     }
     
354.     //blink(5);
     
355.     if(MAX_RT)
     
356.         if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
     
357.             SPI_RW(FLUSH_TX);
     
358.     SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
     
359.     IRQ = 1;
     
360.     if(TX_DS)
     
361.         return(0x00);
     
362.     else
     
363.         return(0xff);
     
364. }
     
365. *************************************************/
     
366. 
     
367. /*************************************/
     
368. #endif
     
369. 
     
370. /************************发送main********************/
     
371. /*************发送模式**********/
     
372. /********2021.2.1**************/
     
373. #include <pic.h>//pic新开发板使用
     
374. __CONFIG(0X3B31);//关闭看门狗,选择高速晶振,上电延时复位,掉电复位使能,代码保护
     
375. 
     
376. #include "NRF24L01.h"
     
377. 
     
378. #define uchar unsigned char
     
379. #define uint  unsigned int
     
380. #define  DQ      RA0
     
381. #define  DQ_in   TRISA0=1
     
382. #define  DQ_LOW()    TRISA0=0;DQ=0
     
383. #define  DQ_HIGH()   TRISA0=1
     
384. 
     
385. uint temper;
     
386. char m=0;
     
387. uchar flag_fu=0;  //温度正负值标志位
     
388. uchar a1,a2,a3,a4;
     
389. uchar bz1,bz2,bz3;
     
390. void delayms(uint x);
     
391. void delayus(uint ,uchar );
     
392. void init();  
     
393. void reset18();
     
394. void write_byte(uchar date);
     
395. uchar read_byte();
     
396. void get_tem();
     
397. 
     
398. void timer1_init();
     
399. uchar counter=0;
     
400. #define LED RD0
     
401. 
     
402. uchar dispaly[8];
     
403. const int table[]={0,1,2,3,4,5,6,7,8,9};
     
404. 
     
405. 
     
406. 
     
407. 
     
408. 
     
409. 
     
410. 
     
411. void timer1_init()
     
412. {
     
413.         GIE=1;
     
414.         PEIE=1;
     
415.         T1CKPS0=1;T1CKPS1=1;                //1:8
     
416.         TMR1CS=0;
     
417.     TMR1IE=1;
     
418.         TMR1ON=1;
     
419.         TMR1H=0xfb;
     
420.         TMR1L=0x1e;
     
421. 
     
422. }
     
423.    void interrupt ISR(void)
     
424.   {
     
425.          
     
426.         if(TMR1IF==1)
     
427.         {
     
428.                
     
429.                 TMR1IF=0;
     
430.                 TMR1H=0xfb;
     
431.                 TMR1L=0x1e;
     
432.         if(++counter>=120)
     
433.            {
     
434.         //        disp(a1,a2,a3,a4);
     
435.                                 LED=~LED;
     
436.                 counter=0;
     
437.         }
     
438.         }
     
439.                   }
     
440. 
     
441. 
     
442. 
     
443. 
     
444. /**********main***********/
     
445. void main()
     
446. {
     
447. int i;
     
448. //unsigned char TX_Buf[8] = {0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f};
     
449. ADON=0;
     
450. timer1_init();
     
451.    init();
     
452. SpiInit();
     
453. //write_byte(0x20);
     
454. delayms(1000);
     
455. 
     
456. delayms(1000);
     
457. 
     
458. 
     
459. 
     
460.    while(1)
     
461.   {
     
462.     uchar num;
     
463.   RD2=1;
     
464.    get_tem();
     
465. delayms(1000);
     
466. RD2=0;
     
467. delayms(1000);
     
468. ce24();
     
469.    }  
     
470. }
     
471. /*************************************/
     
472. void delayms(unsigned int x)
     
473. {
     
474. unsigned int a,b;
     
475. for(a=x;a>0;a--)
     
476.       for(b=110;b>0;b--);
     
477.   }
     
478. 
     
479. 
     
480. 
     
481. 
     
482. void init()
     
483. {
     
484.   TRISB=0x00;
     
485.         TRISD=0x00;
     
486. PORTD=0X00;
     
487.   TRISB0=1;
     
488.   //PORTD=0x0f;
     
489. ADCON1=0X06;
     
490.   delayms(10);
     
491. T0CS=0;
     
492. TRISA=0x00;
     
493. 
     
494.   delayms(10);
     
495. //ADON=0;
     
496. //ANSEL=0X07;
     
497. 
     
498.   PORTA=0x00;
     
499.   delayms(10);
     
500.   PORTD=0xFF;
     
501.         RA5=1;
     
502.   delayms(1000);
     
503.   PORTD=0x00;
     
504. }
     
505. void delayus(uint x,uchar y)
     
506. {
     
507. uint i;uchar j;
     
508.     for(i=x;i>0;i--)
     
509.       for(j=y;j>0;j--) ;
     
510. }
     
511. 
     
512. void reset18()
     
513. {
     
514.       uchar st=1;
     
515.           DQ_HIGH();
     
516.           NOP();NOP();
     
517.      while(st)
     
518.   {
     
519.           DQ_LOW();
     
520.           delayus(15,10);//750us
     
521.           DQ_HIGH();
     
522.           delayus(3,2);//70us
     
523.        st=DQ;
     
524.       if(DQ==1)
     
525.          st=1;
     
526.    else
     
527.           st=0;
     
528.    delayus(11,10);//500us
     
529.    }
     
530. }
     
531. 
     
532. void write_byte(uchar date)
     
533. {
     
534.   uchar i,temp;
     
535.      DQ_HIGH();
     
536.      NOP();NOP();
     
537.   for(i=8;i>0;i--)
     
538.    {
     
539. 
     
540.      temp=date&0x01;
     
541.       DQ_LOW();
     
542.       delayus(0,0);
     
543.       if(temp==1)
     
544.         DQ_HIGH();
     
545.       delayus(2,1);//45us
     
546.       DQ_HIGH();
     
547.      date=date>>1;
     
548.     }
     
549. }
     
550. 
     
551. uchar read_byte()
     
552. {
     
553. uchar i,date;
     
554. static bit j;
     
555. for(i=8;i>0;i-- )
     
556.   {
     
557.           date=date>>1;
     
558.           DQ_HIGH();
     
559.           NOP();NOP();
     
560.           DQ_LOW();
     
561.           NOP();NOP(); NOP();NOP(); NOP();NOP();
     
562.           DQ_HIGH();
     
563.           NOP();NOP(); NOP();NOP(); NOP();
     
564.           j=DQ;
     
565.           if(j==1)
     
566.              date=date|0x80;
     
567.             delayus(1,1);
     
568.    }  
     
569.        return(date);  
     
570. }
     
571. 
     
572. void get_tem()
     
573. {
     
574.         bz1=0;bz2=0;bz3=0;
     
575.         uchar tem1,tem2,num;
     
576.         GIE=0;
     
577.         reset18();
     
578.         write_byte(0xCC);
     
579.         write_byte(0x44);
     
580.    // delayus(2,2);//600us(60,15)
     
581.         GIE=1;
     
582. 
     
583.         GIE=0;
     
584.         reset18();
     
585.         write_byte(0xCC);
     
586.                 GIE=1;
     
587.    delayus(2,1);
     
588.         GIE=0;
     
589.         write_byte(0xBE);
     
590.         tem1=read_byte();
     
591.         tem2=read_byte();
     
592.         GIE=1;      
     
593.          temper = ((tem2<<4)&0xF0)|((tem1>>4)&0x0F);
     
594.   if(temper>127)
     
595.   {
     
596.         //temper = ~temper + 1;
     
597.                         flag_fu=1;
     
598.                         bz1=1;
     
599.         }
     
600.         else
     
601.         {
     
602.                 flag_fu=0;
     
603.                 bz1=0;
     
604.         }
     
605. 
     
606. 
     
607. /*
     
608.    if(temper&0x8000)
     
609.         {
     
610.                 temper=~temper;
     
611.                 temper+=1;
     
612.                 flag_fu=1;
     
613.         }
     
614.         else
     
615.         {
     
616.                 flag_fu=0;
     
617.         }
     
618.    */
     
619.   temper=(tem2*256+tem1)*6.25;
     
620.    if(flag_fu==1)
     
621.         {        temper = ~temper + 1;}
     
622. 
     
623. if(temper>10000)
     
624.         {
     
625.                 temper=temper%10000;
     
626.         a1=temper/1000;
     
627.         a2=temper%1000/100;
     
628.         a3=temper%100/10;
     
629.         a4=temper%10;
     
630.                 m=1;
     
631.                 bz3=1;
     
632.         }
     
633.         else
     
634.         {
     
635.         temper=temper%10000;
     
636.         a1=temper/1000;
     
637.         a2=temper%1000/100;
     
638.         a3=temper%100/10;
     
639.         a4=temper%10;
     
640.                         m=0;
     
641.                 bz3=0;
     
642.         }
     
643. //if(a0>2)a0=0;
     
644. //TX_MODE();
     
645. delayms(30);
     
646. if(bz1==bz3){bz2=1;}
     
647. delayus(3,2);
     
648. dispaly[1]=table[a1];
     
649. dispaly[2]=table[a2];
     
650. dispaly[3]=table[a3];
     
651. dispaly[4]=table[a4];
     
652. dispaly[5]=table[bz1];
     
653. dispaly[6]=table[bz2];
     
654. dispaly[7]=table[bz3];
     
655. 
     
656. delayms(3);
     
657. nRF24L01_TxPacket( dispaly); // Transmit Tx buffer data
     
658. SPI_RW_Reg(WRITE_REG+STATUS,0XFF);
     
659. SPI_RW_Reg(FLUSH_TX,0X00);
     
660. //value18=(int)temper;
     
661. 
     
662. 
     
663. 
     
664. }
     
665. 
     
666. /************************数码管接收*******************************/
     
667. #include <pic.h>//接收模式
     
668. __CONFIG(0x3B31);
     
669. //const rom unsigned int CONFIG=0x0101;
     
670. #define uint8 unsigned char
     
671. #define uint16 unsigned int
     
672. #define uchar unsigned char
     
673. #define uint unsigned int
     
674. #define CSN  RB5
     
675. #define IRQ  RB1
     
676. #define CE   RB4
     
677. #define MOSI RB3
     
678. #define MISO RB0
     
679. #define SCK  RB2
     
680. #define BACK_LED RD7
     
681. #define KEY  RB6
     
682. uint temperx;
     
683. void xianshishuju();
     
684. uchar a1,a2,a3,a4;
     
685. uchar a0;
     
686. #define DOT_SET RD7=0
     
687. #define DOT_CLR RD7=1
     
688. #define RA1_SET RA1=0
     
689. #define RA1_CLR RA1=1
     
690. #define RA2_SET RA2=0
     
691. #define RA2_CLR RA2=1
     
692. #define RA3_SET RA3=0
     
693. #define RA3_CLR RA3=1
     
694. #define RA4_SET RA4=0
     
695. #define RA4_CLR RA4=1
     
696. 
     
697. 
     
698. #define TX_ADR_WIDTH   5
     
699. #define RX_ADR_WIDTH   5
     
700. #define RX_PLOAD_WIDTH 10
     
701. #define TX_PLOAD_WIDTH 10
     
702. uint8 TX_ADDRESS[TX_ADR_WIDTH]={0X34,0X43,0X10,0X10,0X01};
     
703. uint8 RX_ADDRESS[RX_ADR_WIDTH]={0X34,0X43,0X10,0X10,0X01};
     
704. uint8 Tx_Buf[TX_PLOAD_WIDTH];
     
705. uint8 Rx_Buf[RX_PLOAD_WIDTH];
     
706. 
     
707. uint8 sta=0;//NRF24L01状态
     
708. 
     
709. /***********************寄存器指令***********************/
     
710. #define READ_REG      0X00    //读寄存器指令
     
711. #define WRITE_REG     0X20    //写寄存器指令
     
712. #define RD_RX_PLOAD   0X61    //读取接收数据指令
     
713. #define WR_TX_PLOAD   0XA0    //写待发数据指令
     
714. #define FLUSH_TX      0XE1    //清除发送FIFO指令
     
715. #define FLUSH_RX      0XE2    //清除接收FIFO指令
     
716. #define REUSE_TX_PL   0XE3    //定义重复装载数据指令
     
717. //#define NOP           0XFF    //保留
     
718. /***********************寄存器地址***********************/
     
719. #define config        0X00    //配置收发状态，CRC校验及收发响应方式
     
720. #define EN_AA         0X01    //自动应答功能设置
     
721. #define EN_RXADDR     0X02    //可用信道设置
     
722. #define SETUP_AW      0X03    //收发地址宽度设置
     
723. #define SETUP_RETR    0X04    //自动重发功能设置
     
724. #define RF_CH         0X05    //工作频率设置
     
725. #define RF_SETUP      0X06    //发送速率，功耗功能设置
     
726. #define STATUS        0X07    //状态寄存器
     
727. #define OBSERVE_TX    0X08    //发送监测功能
     
728. #define CD            0X09    //地址检测
     
729. #define RX_ADDR_P0    0X0A    //频道0接收数据地址
     
730. #define RX_ADDR_P1    0X0B    //频道1接收数据地址
     
731. #define RX_ADDR_P2    0X0C    //频道2接收数据地址
     
732. #define RX_ADDR_P3    0X0D    //频道3接收数据地址
     
733. #define RX_ADDR_P4    0X0E    //频道4接收数据地址
     
734. #define RX_ADDR_P5    0X0F    //频道5接收数据地址
     
735. #define TX_ADDR       0X10    //发送地址寄存器
     
736. #define RX_PW_P0      0x11    // 接收频道0接收数据有效数据长度
     
737. #define RX_PW_P1      0x12    // 接收频道1接收数据有效数据长度
     
738. #define RX_PW_P2      0x13    // 接收频道2接收数据有效数据长度
     
739. #define RX_PW_P3      0x14    // 接收频道3接收数据有效数据长度
     
740. #define RX_PW_P4      0x15    // 接收频道4接收数据有效数据长度
     
741. #define RX_PW_P5      0x16    // 接收频道5接收数据有效数据长度
     
742. #define FIFO_STATUS   0X17    //FIFO栈入栈出状态寄存器设置
     
743. #define MAX_RT        0X10    //MAX_RTD在第5位|
     
744. #define TX_DS         0X20    //TX_DS在第6位  | 在读回STATUS时与其相与，就知道该位是否为1
     
745. #define RX_DR         0X40    //RX_DR在第7位  |
     
746. 
     
747. uchar const seg_data[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x00};
     
748. //0-9的显示代码
     
749. 
     
750. void delay(uint16 us)//延时函数
     
751. {
     
752.     while(us--);
     
753. }
     
754. 
     
755. 
     
756. void SpiInit()
     
757. {
     
758.      TRISC=0X00;//设置RC3/SCK,RC5/SDO为输出0X20//rc0shuru
     
759.    //  ANSELE=0X00;
     
760.     // TRISD=0X00;//IRQ为输入，CE,CSN为输出0X01
     
761.         TRISB=0X43;
     
762.        delay(20);
     
763.        CE=0;    // chip enable
     
764.                 delay(20);
     
765.                   CSN=1;   // Spi disable
     
766.                  delay(20);
     
767.                   SCK=0;
     
768.                  delay(20);
     
769. }
     
770. 
     
771. uint8 SPI_RW(uint8 byte)
     
772. {
     
773. uint8  bit_ctr;
     
774. //DI();
     
775.     for(bit_ctr=0;bit_ctr<8;bit_ctr++)    // output 8-bit
     
776.     {
     
777.      if(byte & 0x80)
     
778.       MOSI = 1;
     
779.      else
     
780.       MOSI = 0;
     
781.      byte = (byte << 1);             // shift next bit into MSB..
     
782.      SCK = 1;                   // Set nRF24L01_SCK high..
     
783.      if(MISO) byte |= 1;
     
784.                 NOP();NOP();NOP();NOP();
     
785.      SCK = 0;              // ..then set nRF24L01_SCK low again
     
786.                 NOP();NOP();NOP();NOP();
     
787.     }
     
788.     //EI();
     
789.     return(byte);           
     
790. }
     
791. 
     
792. uint8 SPI_Read(uint8 reg)
     
793. {
     
794.       uint8 reg_val;
     
795.       CSN=0;
     
796.       SPI_RW(reg);
     
797.       reg_val=SPI_RW(0);
     
798.       CSN=1;
     
799.       return(reg_val);
     
800. }
     
801. uint8 SPI_RW_Reg(uint8 reg,uint8 value)//向寄存器写一个字节，同时返回状态字
     
802. {
     
803.       uint8 status;
     
804.       CSN=0;
     
805.       status=SPI_RW(reg);
     
806.       SPI_RW(value);
     
807.       CSN=1;
     
808.       return(status);
     
809. }
     
810. uint8 SPI_Write_Buf(uint8 reg,uint8 *pBuf,uint8 bytes)//向寄存器写入一个字符串
     
811. {
     
812.       uint8 status,byte_ctr;
     
813.       CSN=0;
     
814.       status=SPI_RW(reg);
     
815.       for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)   
     
816. {
     
817.        //SPI_RW(pBuf[byte_ctr]);    //
     
818. SPI_RW(*pBuf++);//gaiguo
     
819.       }
     
820.       CSN=1;
     
821.       return(status);
     
822. }
     
823. /***************************以上为SPI通讯程序**********************************/
     
824. /******************************************************************************/
     
825. //接收模式代码
     
826. void RX_MODE(void)
     
827. {
     
828.      CE=0;
     
829.      SPI_RW_Reg(FLUSH_TX,0X00);///////////////////gaiguo/////////////
     
830.      SPI_Write_Buf(WRITE_REG+TX_ADDR,TX_ADDRESS,TX_ADR_WIDTH);// 写本地地址
     
831.      SPI_Write_Buf(WRITE_REG+RX_ADDR_P0,TX_ADDRESS,TX_ADR_WIDTH);// 写接收端地址
     
832.      SPI_RW_Reg(WRITE_REG+EN_AA,0X01);//  频道0自动 ACK应答允许
     
833.      SPI_RW_Reg(WRITE_REG+EN_RXADDR,0X01);//  允许接收地址只有频道0，如果需要多频道，可以参考Page21
     
834.      //SPI_RW_Reg(WRITE_REG+SETUP_RETR,0X1a);/////////////////////gaiguo
     
835.      SPI_RW_Reg(WRITE_REG+RF_CH,40);
     
836.      SPI_RW_Reg(WRITE_REG+RF_SETUP,0X07);
     
837.      SPI_RW_Reg(WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);
     
838.      SPI_RW_Reg(WRITE_REG+config,0X0f);//接受
     
839. 
     
840.      delay(200);
     
841.          CE=1;
     
842.          delay(200);
     
843. }
     
844. uint8 SPI_Read_Buf(uint8 reg,uint8 *pBuf,uint8 bytes)
     
845. {
     
846.      uint8 status,uchar_ctr;
     
847.      CSN=0;
     
848.      status=SPI_RW(reg);
     
849.      for(uchar_ctr=0;uchar_ctr<bytes;uchar_ctr++) //for(byte_ctr=0;byte_ctr< bytes; byte_ctr++)  
     
850.      {
     
851.           pBuf[uchar_ctr]=SPI_RW(0);//*pBUF++=SPIR_RW(0xff);
     
852.      }
     
853.      CSN=1;
     
854.      return(status);
     
855. }
     
856. /*********************************************************/
     
857. uint8 nRF24l01_RxPacket(uint8 *rx_buf)
     
858. {
     
859.      uint8 revale=0;
     
860.         CE = 1;
     
861.          delay(10);
     
862. //        RX_MODE();
     
863.          // delay(10);
     
864.      sta=SPI_Read(STATUS);// 读取状态寄存其来判断数据接收状况
     
865.       if(sta&RX_DR)//判断是否接收到数据 if(sta&RX_DR)
     
866.      {
     
867.                         CE = 0;//SPI使能///tianjia
     
868.                          delay(2);
     
869.            SPI_Read_Buf(RD_RX_PLOAD,rx_buf,RX_PLOAD_WIDTH);
     
870.                           SPI_RW_Reg(WRITE_REG+STATUS,sta);//接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志.
     
871.            revale=1;
     
872.                                 CSN=0;
     
873.                         //        SPI_RW(FLUSH_RX);
     
874.                               
     
875.                          SPI_RW_Reg(FLUSH_RX,0X00);//////////////////////////////////////////gaiiiii
     
876.                         CSN=1;
     
877.      }
     
878. 
     
879.         IRQ=1;//////////////////////////gaiguo+++      
     
880.      return(revale);
     
881. }
     
882. /*************************
     
883. uint8 nRF24l01_RxPacket(uint8 *rx_buf)
     
884. {
     
885.      uint8 revale=0;
     
886. 
     
887. //        RX_MODE();
     
888.          // delay(10);
     
889.      sta=SPI_Read(STATUS);// 读取状态寄存其来判断数据接收状况
     
890.      if(sta&RX_DR)//判断是否接收到数据 if(sta&RX_DR)
     
891.      {
     
892.                         CE = 0;//SPI使能///tianjia
     
893.                          delay(2);
     
894.            SPI_Read_Buf(RD_RX_PLOAD,rx_buf,RX_PLOAD_WIDTH);
     
895.            revale=1;
     
896.                          //SPI_RW_Reg(FLUSH_RX,0X00);//////////////////////////////////////////gaiiiii
     
897.      }
     
898.      SPI_RW_Reg(WRITE_REG+STATUS,sta);//接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志.
     
899.         IRQ=1;//////////////////////////gaiguo+++      
     
900.      return(revale);
     
901. }
     
902. ********************/
     
903. /********************
     
904. void xianshishuju()
     
905. {
     
906.       
     
907. 
     
908.                         //        a1=RxBuf[3];           //符号位
     
909.    a2=((RxBuf[2]<<4)|RxBuf[1]);  //整数位
     
910.    a1=RxBuf[0];       //小数位
     
911.       a3=RxBuf[2];       //十位
     
912.        a4=RxBuf[1];       //个位
     
913.                         
     
914.       
     
915. PORTD=seg_data[0];
     
916.         RA5=1;
     
917.         delay(20);
     
918.         RA5=0;
     
919.         PORTD=seg_data[a1];                                //显示个位
     
920.         RA4_CLR;
     
921.         DOT_CLR;
     
922.         delay(20);
     
923.         RA4_SET;
     
924.         PORTD=seg_data[a2];
     
925.         RA3_CLR;
     
926.       
     
927.         delay(20);
     
928.         RA3_SET;
     
929.         PORTD=seg_data[a3];
     
930.         RA2_CLR;
     
931.         delay(20);
     
932.         RA2_SET;
     
933.         PORTD=seg_data[a4];
     
934.         RA1_CLR;
     
935.         delay(20);
     
936.         RA1_SET;
     
937.                
     
938. 
     
939. 
     
940. 
     
941. 
     
942. }
     
943. /*******************************
     
944. if(nRF24l01_RxPacket(Rx_Buf))
     
945.                                   {
     
946. 
     
947.                                    a1=Rx_Buf[1];       //小数位
     
948.                                          a2=Rx_Buf[2];  //整数位
     
949.                                       a3=Rx_Buf[3];       //十位
     
950.                                        a4=Rx_Buf[4];       //个位
     
951.                               
     
952.                                                         };break;
     
953. 
     
954. 
     
955. 
     
956. 
     
957. 
     
958. 
     
959. 
     
960. 
     
961. 
     
962. **************************/
     
963. void main()
     
964. {
     
965.      uint8 recv=0;
     
966.         uint k=0;
     
967.                 int s;
     
968.     //unsigned char RX_Buf[20] = {0};
     
969. 
     
970.         //OPTION=0X00;    //设置A口为普通I/O口
     
971.         TRISD = 0;  //portd 输出
     
972.         TRISB = 0X00;                                          //设置B口低4位为输入//高四位为输出
     
973.         TRISA = 0;  //porta 输出
     
974.         PORTA = 0x00;//先关闭所有显示
     
975.         //PORTD = 0x0f;
     
976.      //delay(1);
     
977.      TRISE0=0;
     
978.                 RE0=1;
     
979. 
     
980.      delay(1000);
     
981.      SpiInit();
     
982.         delay(1000);
     
983.       RX_MODE();
     
984.           delay(3500);
     
985.            nRF24l01_RxPacket(Rx_Buf);
     
986.   delay(2500);
     
987.      RX_MODE();
     
988.           delay(3500);
     
989. 
     
990. 
     
991. delay(500);
     
992. 
     
993. 
     
994.      while(1)
     
995.      {
     
996. 
     
997. 
     
998. 
     
999.         k++;  
     
1000.       
      
1001.         switch(k)
      
1002.                 {
      
1003.                 case 1000: if(nRF24l01_RxPacket(Rx_Buf)){break;}
      
1004. 
      
1005.                                                         break;
      
1006.                         
      
1007.                
      
1008.                
      
1009.                 case 1003:k=0;break;//SPI_RW_Reg(FLUSH_RX,0X00);
      
1010.                 }
      
1011. 
      
1012.                                 //        a0=Rx_Buf[5];          //biaozhiwei
      
1013.                                         a1=Rx_Buf[1];       //shi数位
      
1014.                                          a2=Rx_Buf[2];  //ge数位
      
1015.                                       a3=Rx_Buf[3];       //0.位
      
1016.                                        a4=Rx_Buf[4];       //0.00
      
1017.                                                 a0=Rx_Buf[5];          //biaozhiwei
      
1018.                                                         s=a0;
      
1019.                                         if(s==0)
      
1020.                                         {
      
1021.                                                 RE0=1;
      
1022.                                                                 PORTD=seg_data[0];
      
1023.                                                 RA5=1;
      
1024.                                                 delay(20);
      
1025.                                                 RA5=0;
      
1026.                                                 PORTD=seg_data[a1];                                //显示个位
      
1027.                                                 RA4_CLR;
      
1028.                                                
      
1029.                                                 delay(20);
      
1030.                                                 RA4_SET;
      
1031.                                                 PORTD=seg_data[a2];
      
1032.                                                 RA3_CLR;
      
1033.                                                 DOT_CLR;
      
1034.                                                 delay(20);
      
1035.                                                 RA3_SET;
      
1036.                                                 PORTD=seg_data[a3];
      
1037.                                                 RA2_CLR;
      
1038.                                                 delay(20);
      
1039.                                                 RA2_SET;
      
1040.                                                 PORTD=seg_data[a4];
      
1041.                                                 RA1_CLR;
      
1042.                                                 delay(20);
      
1043.                                                 RA1_SET;
      
1044.                                                                 //        xianshishuju( temperx);
      
1045.                                 }
      
1046.                         if(s!=0)
      
1047.                                         {
      
1048.                                                 RE0=1;
      
1049.                                                                 PORTD=seg_data[1];
      
1050.                                                 RA5=1;
      
1051.                                                 delay(20);
      
1052.                                                 RA5=0;
      
1053.                                                 PORTD=seg_data[a1];                                //显示个位
      
1054.                                                 RA4_CLR;
      
1055.                                                
      
1056.                                                 delay(20);
      
1057.                                                 RA4_SET;
      
1058.                                                 PORTD=seg_data[a2];
      
1059.                                                 RA3_CLR;
      
1060.                                                 DOT_CLR;
      
1061.                                                 delay(20);
      
1062.                                                 RA3_SET;
      
1063.                                                 PORTD=seg_data[a3];
      
1064.                                                 RA2_CLR;
      
1065.                                                 delay(20);
      
1066.                                                 RA2_SET;
      
1067.                                                 PORTD=seg_data[a4];
      
1068.                                                 RA1_CLR;
      
1069.                                                 delay(20);
      
1070.                                                 RA1_SET;
      
1071.                                                                 //        xianshishuju( temperx);
      
1072.                                 }
      
1073.                        
      
1074. 
      
1075.      }
      
1076. }
      
1077. 
      
1078. 
      
1079. /**************************************12864接收************/
      
1080. #include <pic.h>//接收模式2020.2.4
      
1081. __CONFIG(0x3B31);
      
1082. //const rom unsigned int CONFIG=0x0101;
      
1083. //#include "tab1.h"
      
1084. #include "tab2.h"
      
1085. #include "dianzhen12864.h"
      
1086. #include "ds18b20_74.h"
      
1087. #include "nrf24_74.h"
      
1088. #define uint8 unsigned char
      
1089. #define uint16 unsigned int
      
1090. #define uchar unsigned char
      
1091. #define uint unsigned int
      
1092. void delayms(unsigned int x);
      
1093. void delay(uint16 us);
      
1094. uint temperx;
      
1095. uint temper;
      
1096. uchar d1,d2,d3,d4;
      
1097. 
      
1098.         void get_tem();
      
1099. uchar flag_fu=0;  //温度正负值标志位
      
1100. 
      
1101. #define BG RA5
      
1102. #define key RB0
      
1103. 
      
1104. 
      
1105. uchar f1,f2,f3,f4;
      
1106. 
      
1107. int table[]={0,1,2,3,4,5,6,7,8,9};
      
1108. 
      
1109. //0-9的显示代码
      
1110. char const wen1[]={
      
1111. 
      
1112. /*--  文字:  温  --*/
      
1113. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
      
1114. 0x10,0x60,0x02,0x8C,0x00,0x00,0xFE,0x92,0x92,0x92,0x92,0x92,0xFE,0x00,0x00,0x00,
      
1115. 0x04,0x04,0x7E,0x01,0x40,0x7E,0x42,0x42,0x7E,0x42,0x7E,0x42,0x42,0x7E,0x40,0x00,
      
1116. };
      
1117. char const du1[]={
      
1118. /*--  文字:  度  --*/
      
1119. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
      
1120. 0x00,0x00,0xFC,0x24,0x24,0x24,0xFC,0x25,0x26,0x24,0xFC,0x24,0x24,0x24,0x04,0x00,
      
1121. 0x40,0x30,0x8F,0x80,0x84,0x4C,0x55,0x25,0x25,0x25,0x55,0x4C,0x80,0x80,0x80,0x00,
      
1122. 
      
1123. 
      
1124. };
      
1125. char const du2[]={
      
1126. /*--  文字:  ℃  --*/
      
1127. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
      
1128. 0x06,0x09,0x09,0xE6,0xF8,0x0C,0x04,0x02,0x02,0x02,0x02,0x02,0x04,0x1E,0x00,0x00,
      
1129. 0x00,0x00,0x00,0x07,0x1F,0x30,0x20,0x40,0x40,0x40,0x40,0x40,0x20,0x10,0x00,0x00,
      
1130. };
      
1131. /***********************/
      
1132. 
      
1133. char const shi[]={
      
1134. /*--  文字:  室  --*/
      
1135. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
      
1136. 0x10,0x0C,0x24,0x24,0xA4,0x64,0x25,0x26,0x24,0x24,0xA4,0x24,0x24,0x14,0x0C,0x00,
      
1137. 0x40,0x40,0x48,0x49,0x49,0x49,0x49,0x7F,0x49,0x49,0x49,0x4B,0x48,0x40,0x40,0x00,
      
1138. };
      
1139. char const wai[]={
      
1140. /*--  文字:  外  --*/
      
1141. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
      
1142. 0x00,0xC0,0x30,0x1F,0x10,0x10,0xF0,0x00,0x00,0xFF,0x20,0x40,0x80,0x00,0x00,0x00,
      
1143. 0x81,0x40,0x21,0x12,0x0C,0x03,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,0x03,0x00,0x00,
      
1144. };
      
1145. char const nei[]={
      
1146. /*--  文字:  内  --*/
      
1147. /*--  宋体12;  此字体下对应的点阵为：宽x高=16x16   --*/
      
1148. 0x00,0xF8,0x08,0x08,0x08,0x08,0x88,0x7F,0x88,0x08,0x08,0x08,0x08,0xF8,0x00,0x00,
      
1149. 0x00,0xFF,0x00,0x08,0x04,0x02,0x01,0x00,0x00,0x01,0x02,0x4C,0x80,0x7F,0x00,0x00,
      
1150. };
      
1151. /***************************/
      
1152. /*************************************/
      
1153. void delayms(uint x)
      
1154. {
      
1155. unsigned int a,b;
      
1156. for(a=x;a>0;a--)
      
1157.       for(b=110;b>0;b--);
      
1158.   }
      
1159. 
      
1160. 
      
1161. 
      
1162. 
      
1163.                         void delay(uint16 us)//延时函数
      
1164.                         {
      
1165.                             while(us--);
      
1166.                         }
      
1167. 
      
1168.         void get_tem()
      
1169.                 {
      
1170.                                         uchar i,m;
      
1171.                         uchar tem1,tem2,num;
      
1172.                         GIE=0;
      
1173.                         reset18();
      
1174.                         write_byte(0xCC);
      
1175.                         write_byte(0x44);
      
1176.                    // delayus(2,2);//600us(60,15)
      
1177.                          GIE=1;
      
1178.       
      
1179.                         GIE=0;
      
1180.                         reset18();
      
1181.                         write_byte(0xCC);
      
1182.                
      
1183.                               
      
1184.                                         write_byte(0xBE);
      
1185.                                         tem1=read_byte();
      
1186.                                         tem2=read_byte();
      
1187.                                         GIE=1;      
      
1188.                                          temper = ((tem2<<4)&0xF0)|((tem1>>4)&0x0F);
      
1189.                   if(temper>127)
      
1190.                                                   {
      
1191.                                                         //temper = ~temper + 1;
      
1192.                                                         flag_fu=1;
      
1193.                                                 }
      
1194.                         else
      
1195.                                         {
      
1196.                                                         flag_fu=0;
      
1197.                                         }
      
1198.                   
      
1199.                
      
1200.       
      
1201.                   temper=(tem2*256+tem1)*6.25;
      
1202.                    if(flag_fu==1)
      
1203.                                 {        temper = ~temper + 1;}
      
1204.                         if(temper>10000)
      
1205.         {
      
1206.         d1=temper/10000;
      
1207.         d2=temper%10000/1000;
      
1208.         d3=temper%1000/100;
      
1209.         d4=temper%100/10;
      
1210.                 m=1;
      
1211.         }
      
1212.         else
      
1213.         {
      
1214.         d1=temper/1000;
      
1215.         d2=temper%1000/100;
      
1216.         d3=temper%100/10;
      
1217.         d4=temper%10;
      
1218.                         m=0;
      
1219.         }
      
1220.       
      
1221.                 if        (flag_fu==1)
      
1222. 
      
1223.                 {
      
1224.                                 DisplayString1608(1,60,"-");
      
1225.                                                 delay(10);
      
1226.                                         //DisplayNumber1608(1, 33, 0);
      
1227.                                          DisplayNumber1608(1, 68, d1);
      
1228.                                         //delay(100);
      
1229.                                         delay(10);
      
1230.                                         DisplayNumber1608(1, 76,d2 );
      
1231.                                         //delay(100);
      
1232.                                         delay(10);
      
1233.                                          
      
1234.                                         DisplayString1608(1,84,".");
      
1235.                                         delay(10);
      
1236.                                         DisplayNumber1608(1,88,d3 );
      
1237.                                         //delay(100);
      
1238.                                         delay(10);
      
1239.                                         DisplayNumber1608(1, 96,d4 );
      
1240.                                         //delay(100);
      
1241. 
      
1242.                 }      
      
1243. 
      
1244.                         else{
      
1245. 
      
1246.                                         if(m==1)
      
1247.                                                 {
      
1248.                               
      
1249.                                                  DisplayNumber1608(1, 60, 1);
      
1250.                                                         delay(10);
      
1251.                                                  DisplayNumber1608(1, 68, d1);
      
1252.                                                 //delay(100);
      
1253.                                                 delay(10);
      
1254.                                                 DisplayNumber1608(1, 76,d2 );
      
1255.                                                 //delay(100);
      
1256.                               
      
1257.                                                 delay(10);
      
1258.                                                 
      
1259.                                                 DisplayString1608(1,84,".");
      
1260.                                                         delay(10);
      
1261.                                                 DisplayNumber1608(1,88,d3 );
      
1262.                                                 //delay(100);
      
1263.                                                 delay(10);
      
1264.                                                 DisplayNumber1608(1, 96,d4 );
      
1265.                                                 //delay(100);
      
1266.                                                 }
      
1267.                        
      
1268.                                         else
      
1269.                                         {
      
1270.                                                 DisplayString1608(1,60," ");
      
1271.                                                 delay(10);
      
1272.                                         //DisplayNumber1608(1, 33, 0);
      
1273.                                          DisplayNumber1608(1, 68, d1);
      
1274.                                         //delay(100);
      
1275.                                         delay(10);
      
1276.                                         DisplayNumber1608(1, 76,d2 );
      
1277.                                         //delay(100);
      
1278.                                         delay(10);
      
1279.                                          
      
1280.                                         DisplayString1608(1,84,".");
      
1281.                                         delay(10);
      
1282.                                         DisplayNumber1608(1,88,d3 );
      
1283.                                         //delay(100);
      
1284.                                         delay(10);
      
1285.                                         DisplayNumber1608(1, 96,d4 );
      
1286.                                         //delay(100);
      
1287.                                         }               
      
1288.                 }
      
1289. 
      
1290. }
      
1291. 
      
1292. void main()
      
1293. {
      
1294. 
      
1295.         uint k=0;
      
1296. uchar a1,a2,a3,a4;
      
1297. uchar bz1,bz2,bz3;//bz1:正负标志bz2: 正常标志bz3:超100标志
      
1298. bz1=0;
      
1299. bz2=0;
      
1300. bz3=0;
      
1301. uchar aw1,aw2,aw3;
      
1302.     //unsigned char RX_Buf[20] = {0};
      
1303. 
      
1304.         //OPTION=0X00;    //设置A口为普通I/O口
      
1305.         TRISD = 0;  //portd 输出
      
1306.         TRISB = 0X01;                                          //设置B口低4位为输入//高四位为输出
      
1307.         ADCON1=0X06;
      
1308.           delay(100);
      
1309.                 T0CS=0;
      
1310.                 TRISA=0x00;
      
1311.         PORTD = 0x00;
      
1312.      //delay(1);
      
1313.      TRISE0=0;
      
1314.                 RE0=1;
      
1315.                 BG=1;
      
1316.     InitLCD();
      
1317.         delay(1000);
      
1318.     clear_screen();
      
1319.     reset18();
      
1320.      delay(1000);
      
1321.      SpiInit();
      
1322.         delay(1000);
      
1323.       RX_MODE();
      
1324.           delay(3500);
      
1325.            nRF24l01_RxPacket(Rx_Buf);
      
1326.   delay(2500);
      
1327.      RX_MODE();
      
1328.           delay(3500);
      
1329.         display_graphic_16x16(1,1,shi); /*在第 1 页，第 1 列显示单个汉字""*/
      
1330.         display_graphic_16x16(1,16,nei); /*在第 1 页，第 1 列显示单个汉字""*/
      
1331. 
      
1332.     display_graphic_16x16(1,32,wen1); /*在第 1 页，第 1 列显示单个汉字""*/
      
1333.     display_graphic_16x16(1,(48),du1); /*在第 1 页，第 17 列显示单个汉字""*/
      
1334. display_graphic_16x16(1,(114),du2); /*在第 5 页，第 89 列显示单个数字"9"*/
      
1335.         display_graphic_16x16(3,1,shi); /*在第 1 页，第 1 列显示单个汉字""*/
      
1336.         display_graphic_16x16(3,16,wai); /*在第 1 页，第 1 列显示单个汉字""*/
      
1337. 
      
1338.     display_graphic_16x16(3,32,wen1); /*在第 1 页，第 1 列显示单个汉字""*/
      
1339.     display_graphic_16x16(3,(48),du1); /*在第 1 页，第 17 列显示单个汉字""*/
      
1340. display_graphic_16x16(3,(114),du2); /*在第 5 页，第 89 列显示单个数字"9"*/
      
1341. 
      
1342. delay(500);
      
1343. 
      
1344. 
      
1345.      while(1)
      
1346.      {
      
1347.                
      
1348. 
      
1349.       
      
1350.            get_tem();
      
1351. 
      
1352.         k++;  
      
1353.       
      
1354.         switch(k)
      
1355.                 {
      
1356.                 case 30: if(nRF24l01_RxPacket(Rx_Buf))
      
1357.                                 {               
      
1358.                                                         RD4=1;
      
1359.                                 }
      
1360.                        
      
1361.                                         break;
      
1362.                         
      
1363.                
      
1364.                
      
1365.                 case 38:k=0;//        CSN=0;SPI_RW(FLUSH_RX);        CSN=1;
      
1366.                                                 RD4=0;break;//SPI_RW_Reg(FLUSH_RX,0X00);
      
1367. 
      
1368.                 }
      
1369. 
      
1370.                 delayms(10);
      
1371. 
      
1372.       
      
1373. 
      
1374.                                        
      
1375.                                         a1=Rx_Buf[1];       //小数位
      
1376.                                          a2=Rx_Buf[2];  //整数位
      
1377.                                       a3=Rx_Buf[3];       //十位
      
1378.                                        a4=Rx_Buf[4];       //个      
      
1379.                                                 bz1=Rx_Buf[5];
      
1380.                                                         bz2=Rx_Buf[6];
      
1381.                                                                 bz3=Rx_Buf[7];
      
1382.         delayms(10);
      
1383. 
      
1384.                
      
1385.                               
      
1386.                                                 f1=table[a1];
      
1387.                                                 f2=table[a2];
      
1388.                                                 f3=table[a3];
      
1389.                                                 f4=table[a4];
      
1390.                                                 aw1=table[bz1];
      
1391.                                                 aw2=table[bz2];
      
1392.                                                 aw3=table[bz3];
      
1393.                         if(aw2==0)
      
1394.                         {
      
1395.                                         if(aw3==1)
      
1396.                                                 {
      
1397.                                                            DisplayString1608(3,60,1);
      
1398.                                                                 delay(100);
      
1399.                                                         //DisplayNumber1608(1, 33, 0);
      
1400.                                                          DisplayNumber1608(3, 68, f1);
      
1401.                                                         //delay(100);
      
1402.                                                         delay(100);
      
1403.                                                         DisplayNumber1608(3, 76,f2 );
      
1404.                                                         //delay(100);
      
1405.                                                         delay(100);
      
1406.                                                          //display_graphic_8x16(3,(17),dian);
      
1407.                                                         DisplayString1608(3,84,".");
      
1408.                                                         delay(100);
      
1409.                                                         DisplayNumber1608(3,88,f3 );
      
1410.                                                         //delay(100);
      
1411.                                                         delay(100);
      
1412.                                                         DisplayNumber1608(3, 96,f4);
      
1413.                                                         delay(100);
      
1414.                                                 }
      
1415. 
      
1416.                                                                                 if(aw1==1)
      
1417.                                                         {
      
1418.                                                                    DisplayString1608(3,60,"-");
      
1419.                                                                         delay(100);
      
1420.                                                                 //DisplayNumber1608(1, 33, 0);
      
1421.                                                                  DisplayNumber1608(3, 68, f1);
      
1422.                                                                 //delay(100);
      
1423.                                                                 delay(100);
      
1424.                                                                 DisplayNumber1608(3, 76,f2 );
      
1425.                                                                 //delay(100);
      
1426.                                                                 delay(100);
      
1427.                                                                  //display_graphic_8x16(3,(17),dian);
      
1428.                                                                 DisplayString1608(3,84,".");
      
1429.                                                                 delay(100);
      
1430.                                                                 DisplayNumber1608(3,88,f3 );
      
1431.                                                                 //delay(100);
      
1432.                                                                 delay(100);
      
1433.                                                                 DisplayNumber1608(3, 96,f4);
      
1434.                                                                 delay(100);
      
1435.                                                         }
      
1436.                                        
      
1437.                                                 else{
      
1438.                                                                 DisplayString1608(3,68,"?");
      
1439.                                                                 DisplayString1608(3,76,"?");                                               
      
1440.                                                                 DisplayString1608(3,84,"?");
      
1441.                                                                 DisplayString1608(3,92,"?");
      
1442.                                                 }      
      
1443.                                        
      
1444.                                 }
      
1445.                         delayms(10);
      
1446.                                         if(aw2==1)
      
1447.                                         {                       
      
1448.                        
      
1449.                                                            DisplayString1608(3,60," ");
      
1450.                                                                         delay(100);
      
1451.                                                                 //DisplayNumber1608(1, 33, 0);
      
1452.                                                                  DisplayNumber1608(3, 68, f1);
      
1453.                                                                 //delay(100);
      
1454.                                                                 delay(100);
      
1455.                                                                 DisplayNumber1608(3, 76,f2 );
      
1456.                                                                 //delay(100);
      
1457.                                                                 delay(100);
      
1458.                                                                  //display_graphic_8x16(3,(17),dian); /*在第 5 页，第 89 列显示单个数字"9"*/
      
1459.                                                                 DisplayString1608(3,84,".");
      
1460.                                                                 delay(100);
      
1461.                                                                 DisplayNumber1608(3,88,f3 );
      
1462.                                                                 //delay(100);
      
1463.                                                                 delay(100);
      
1464.                                                                 DisplayNumber1608(3, 96,f4);
      
1465.                                                                 delay(100);
      
1466.                                                
      
1467.                                         }
      
1468.                         if(key==0)
      
1469.                         {
      
1470.                                         delayms(20);
      
1471.                                         if(key==0)
      
1472.                                                 {
      
1473.                                                 BG=~BG;
      
1474.                                                 }
      
1475.                
      
1476.                
      
1477.                                 }
      
1478. }
      
1479. 
      
1480. }
      
1481. 
      
1482. /*********************************************************/
      

复制代码

12864驱动以前发过可以找找。

xiaoyao_mdj

几年前弄了几块这个，调通了就没玩了，不知道弄什么好

fryefryefrye

xiaoyao_mdj 发表于 2021-2-5 13:26
几年前弄了几块这个，调通了就没玩了，不知道弄什么好

做了一个无钥匙进入系统，用了好几年了，家里的门，电动车，单元门，都是靠这个开。随身都不带钥匙了，就带一个这个电子标签。
https://github.com/fryefryefrye/Open-Source-RKS

fryefryefrye

用Arduino驱动比这个方便一点，有现成的库可以调用。

fryefryefrye

这个模块还有一个优点，设置适当的频道，他还可以接受和发射蓝牙的广播信号，可以模拟一个蓝牙设备的广播，也能接受其他蓝牙设备的广播。

甚至可以做一个利用手机作为一个电子标签，做无钥匙开门系统。

https://github.com/fryefryefrye/ ... -Bluetooth-Address/