标题: C51单片机的智能小车程序设计 含遥控端与小车端 注释很详细 [打印本页]
作者: paredes    时间: 2020-11-24 14:14
标题: C51单片机的智能小车程序设计 含遥控端与小车端 注释很详细
电赛用的程序设计，包含了转弯、无线控制、循迹和人体温度检测

单片机源程序如下:
  1. #include "reg52.h"
  2. #include "nRF24L01.h"
  3. #include "control.h"
  4. #include "MLX90614.h"
  5. #include "Ultrasonic.h"
  6. #include "Ultrasonic2.h"


  9. #define uint unsigned int
  10. #define uchar unsigned char

  12. sbit KEY8=P1^6;                                         //发送按键
  13. sbit beep=P0^2;                                        //喇叭
  14. sbit LED=P1^7;                        //发送数据时显示灯
  15. extern Tem;

  17. void delay_ms(uint z)                        //延时函数
  18. {
  19.         uint y;
  20.         while(z--)
  21.                 for(y=110;y>0;y--);
  22. }

  24. void main()
  25. {
  26.          uchar Rx_Buf[32];          //接收到的数据暂存器，最多32字节数据
  27.    uchar Tx_Buf[]={1};        //发送的信息1  
  28.          init_NRF24L01();
  29.          LED=1;                                //初始灯6熄灭   

  31.         while(NRF24L01_Check())                                        //检查不到24l01则报警
  32.         {
  33.                 beep=1;
  34.                 delay_ms(200);
  35.                 beep=0;
  36.                 delay_ms(200);
  37.         }
  38.         while(1)
  39.         {        
  40.                 RX_Mode();                                                        //接收模式  
  41.                 while(!nRF24L01_RxPacket(Rx_Buf))         //等待接收数据,返回1则接收到数据,在等待接收数据期间,可以随时变成发送模式  
  42.             {
  43.                         if(KEY8==0)                                                 //按了按键8,则变成发送模式,发送对应数据,发送完后变成接收模式
  44.                         {        
  45.                                 delay_ms(5);//消抖动
  46.                                 if(KEY8==0)
  47.                                 {
  48.                                          while(!KEY8);
  49.                                         TX_Mode();         //发送模式
  50.                                     nRF24L01_TxPacket(Tx_Buf);                //发送命令数据
  51.                                         LED=0;
  52.                                     delay_ms(300);
  53.                                         LED=1;
  54.                                     delay_ms(300);                                        //发送后LED6闪一下
  55.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  56.                                  }        
  57.                          }
  58.                  }
  59. if(Rx_Buf[0]==1)                                                           //若接收到对应的数据则实现对应功能
  60. {
  61. Rx_Buf[0]=0;                                //清空数据
  62.    LED=1;
  63.          delay_ms(300);
  64.          LED=0;
  65. delay_ms(300);                                //接收到数据 后闪烁         
  66. }
  67.                 switch(Rx_Buf[0])                                //对数据进行分析来控制灯亮
  68.                 {
  69.                         case 0:
  70.                                 break;
  71.                         case 1:
  72.                                 Rx_Buf[0]=0;                                //清空数据
  73.                                 m1 = 0;
  74.                                 m2 = 0;
  75.                                 m3 = 0;
  76.                                 m4 = 0;
  77.                                 break;
  78.                         case 2:
  79.                                 Rx_Buf[0]=0;                                //清空数据
  80.                                 M_up();                                                        //前进
  81.                                 break;
  82.                         case 3:
  83.                                 Rx_Buf[0]=0;                //清空数据
  84.                                 M_back();                                //后退
  85.                                 break;
  86.                         case 4:
  87.                                 Rx_Buf[0]=0;                                //清空数据
  88.                                 M_left();                                                //向左行驶
  89.                                 break;
  90.                         case 5:
  91.                                 Rx_Buf[0]=0;     //清空数据
  92.                                 M_right();                        //向右行驶
  93.                                 break;
  94.                         case 6:
  95.                                 Rx_Buf[0]=0;          //清空数据
  96.                                 M_stop();                                //停止
  97.                                 break;
  98.                         case 7:
  99.                                 Rx_Buf[0]=0;          //停止
  100.                                 delay(20);              //延时程序        1
  101.                                 LCD_show(16,2);
  102.                                 LcdBusy();
  103.                                 LCD_init ();
  104.                                 display(Tem);           // 显示子程序
  105.                                 SMB_ack();        
  106.                                 break;
  107.                         case 8:
  108.                                 Rx_Buf[0]=0;          //停止
  109.                                 Ultrasonic();  //小车端超声波检测
  110.                                 Ultrasonic2(); //人体端超声波检测
  111.                                 break;
  112.                 }                 
  113.         }
  114. }

复制代码


  1. #include "reg52.h"
  2. #include "nRF24L01.h"

  4. #define uint unsigned int
  5. #define uchar unsigned char

  7. sbit KEY1 = P2^0;
  8. sbit KEY2 = P2^1;
  9. sbit KEY3 = P2^2;
  10. sbit KEY4 = P2^3;
  11. sbit KEY5 = P2^4;
  12. sbit KEY6 = P2^5;
  13. sbit KEY7 = P2^6;
  14. sbit KEY8 = P2^7;

  16. sbit beep = P1^6;                                        //喇叭
  17. sbit LED = P1^7 ;                                         //发送数据时显示灯+接收到数据后的功能实现灯


  20. void delay_ms(uint z)                        //延时函数
  21. {
  22.         uint y;
  23.         while(z--)
  24.                 for(y=110;y>0;y--);
  25. }

  27. void main()
  28. {
  29.    uchar Tx_Buf1[]={1,2,3,4,5,6,7,8};        //发送的信息1
  30.    uchar Rx_Buf[32];          //接收到的数据暂存器，最多32字节数据
  31.    init_NRF24L01();
  32.    LED=0;                                //初始灯6熄灭  
  33.         beep = 0;
  34.         while(NRF24L01_Check())                                //检查不到24l01则报警
  35. {
  36.     beep=0;
  37.                 delay_ms(200);
  38.                 beep=1;
  39.                 delay_ms(200);
  40. }

  42.         while(1)
  43.         {        
  44.                 RX_Mode();                                                        //接收模式  
  45.                 while(!nRF24L01_RxPacket(Rx_Buf))         //等待接收数据,返回1则接收到数据,在等待接收数据期间,可以随时变成发送模式  
  46.             {

  48.                         if(KEY1==0)                                                 //按了按键1,则变成发送模式,发送对应数据,发送完后变成接收模式
  49.                         {        
  50.                                 delay_ms(5);//消抖动
  51.                                 if(KEY1==0)
  52.                                 {
  53.                                          while(!KEY1);
  54.                                         TX_Mode();                                                 //发送模式
  55.                                         Tx_Buf1[0]=1;                                        //将1发送过去
  56.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  57.                                         LED=0;
  58.                                     delay_ms(50);
  59.                                         LED=1;
  60.                                     delay_ms(50);                                        //发送后LED1闪一下
  61.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  62.                                  }        
  63.                          }


  66.                          else if(KEY2==0)                                         
  67.                          {        
  68.                                 delay_ms(5);//消抖动
  69.                                 if(KEY2==0)
  70.                                 {
  71.                                         TX_Mode();                                                 //发送模式
  72.                                         Tx_Buf1[0]=2;                                        //将2发送过去
  73.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  74.                                         LED=0;
  75.                             delay_ms(50);
  76.                                         LED=1;
  77.                                         delay_ms(50);
  78.                                         if(KEY2==1)
  79.                                         {
  80.                                                 TX_Mode();                                                 //发送模式
  81.                                         Tx_Buf1[0]=6;                                        //将2发送过去
  82.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  83.                                         }
  84.                                         break;                                        //退出最近的循环,从而变回接收模式,这句关键
  85.                                  }        
  86.                           }


  89.                           else if(KEY3==0)                                                
  90.                           {        
  91.                                 delay_ms(5);//消抖动
  92.                                 if(KEY3==0)
  93.                                 {
  94.                                         TX_Mode();                                                 //发送模式
  95.                                         Tx_Buf1[0]=3;                                        //将3发送过去
  96.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  97.                                         LED=0;
  98.                                     delay_ms(50);
  99.                                         LED=1;
  100.                                     delay_ms(50);
  101.                                         if(KEY3==1)
  102.                                         {
  103.                                                 TX_Mode();                                                 //发送模式
  104.                                         Tx_Buf1[0]=6;                                        //将6发送过去
  105.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  106.                                         }
  107.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  108.                                  }        
  109.                           }


  112.                           else if(KEY4==0)                                                 //按了按键8,则变成发送模式,发送对应数据,发送完后变成接收模式
  113.                           {        
  114.                                 delay_ms(5);//消抖动
  115.                                 if(KEY4==0)
  116.                                 {
  117.                                         TX_Mode();                                                 //发送模式
  118.                                         Tx_Buf1[0]=4;                                        //将4发送过去
  119.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  120.                                         LED=0;
  121.                                     delay_ms(50);
  122.                                         LED=1;
  123.                                     delay_ms(50);
  124.                                         if(KEY4==1)
  125.                                         {
  126.                                                 TX_Mode();                                                 //发送模式
  127.                                         Tx_Buf1[0]=6;                                        //将6发送过去
  128.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  129.                                         }
  130.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  131.                                  }        
  132.                           }


  135.                                 else if(KEY5==0)                                                
  136.                           {        
  137.                                 delay_ms(5);//消抖动
  138.                                 if(KEY5==0)
  139.                                 {
  140.                                         TX_Mode();                                                 //发送模式
  141.                                         Tx_Buf1[0]=5;                                        //将5发送过去
  142.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  143.                                         LED=0;
  144.                                     delay_ms(50);
  145.                                         LED=1;
  146.                                     delay_ms(50);
  147.                                         if(KEY5==1)
  148.                                         {
  149.                                                 TX_Mode();                                                 //发送模式
  150.                                         Tx_Buf1[0]=6;                                        //将6发送过去
  151.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  152.                                         }
  153.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  154.                                  }        
  155.                           }


  158.                                 else if(KEY6==0)                                                 //按了按键8,则变成发送模式,发送对应数据,发送完后变成接收模式
  159.                           {        
  160.                                 delay_ms(5);//消抖动
  161.                                 if(KEY6==0)
  162.                                 {
  163.                                          while(!KEY6);
  164.                                         TX_Mode();                                                 //发送模式
  165.                                         Tx_Buf1[0]=6;                                        //将6发送过去
  166.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  167.                                         LED=0;
  168.                                     delay_ms(50);
  169.                                         LED=1;
  170.                                     delay_ms(50);                                       
  171.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  172.                                  }        
  173.                           }


  176.                                 else if(KEY7==0)                                                 //按了按键8,则变成发送模式,发送对应数据,发送完后变成接收模式
  177.                           {        
  178.                                 delay_ms(5);//消抖动
  179.                                 if(KEY7==0)
  180.                                 {
  181.                                          while(!KEY7);
  182.                                         TX_Mode();                                                 //发送模式
  183.                                         Tx_Buf1[0]=7;                                        //将7发送过去
  184.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  185.                                         LED=0;
  186.                                     delay_ms(50);
  187.                                         LED=1;
  188.                                     delay_ms(50);                                       
  189.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  190.                                  }        
  191.                           }


  194.                                 else if(KEY8==0)                                                 //按了按键8,则变成发送模式,发送对应数据,发送完后变成接收模式
  195.                           {        
  196.                                 delay_ms(5);//消抖动
  197.                                 if(KEY8==0)
  198.                                 {
  199.                                          while(!KEY8);
  200.                                         TX_Mode();                                                 //发送模式
  201.                                         Tx_Buf1[0]=8;                                        //将7发送过去
  202.                                     nRF24L01_TxPacket(Tx_Buf1);                //发送命令数据
  203.                                         LED=0;
  204.                                     delay_ms(50);
  205.                                         LED=1;
  206.                                     delay_ms(50);                                       
  207.                                         break;                                                        //退出最近的循环,从而变回接收模式,这句关键
  208.                                  }        
  209.                           }

  211.                  }
  212.                  if(Rx_Buf[0]==1)                                                           //若接收到对应的数据则实现对应功能
  213.                  {
  214.                      Rx_Buf[0]=0;                                //清空数据
  215.                      LED=0;
  216.                           delay_ms(300);
  217.                           LED=1;
  218.                           delay_ms(300);                        //接收到数据 后闪烁         
  219.                  }
  220.         }
  221. }
复制代码

所有程序51hei提供下载:
智能小车.zip (137.92 KB, 下载次数: 75)

作者: 51hei团团    时间: 2020-11-24 16:48
程序很好,可惜没有原理图啊
作者: cwb2038    时间: 2022-7-14 10:53
谢谢分享·，能提供原理图就更好了！
作者: cwb2038    时间: 2022-9-4 16:07
谢谢分享，可惜没有原理图！



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1