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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机霍尔自行车码表测速里程表原理图与程序
返回列表 发新帖
查看: 3768|回复: 4
收起左侧

51单片机霍尔自行车码表测速里程表原理图与程序

  [复制链接]
ID:832960 发表于 2020-10-22 00:17 | 显示全部楼层 |阅读模式
1.jpg
  1. #include <reg52.h>                 //调用单片机头文件
  2. #define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
  3. #define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535

  5. sbit clk = P1^3;          //ds1302时钟线定义
  6. sbit io =  P1^4;          //数据线
  7. sbit rst = P1^5;          //复位线
  8.                                                 //秒  分   时   日   月  年   星期         
  9. uchar code write_add[]={0x80,0x82,0x84,0x86,0x88,0x8c,0x8a};   //写地址
  10. uchar code read_add[] ={0x81,0x83,0x85,0x87,0x89,0x8d,0x8b};   //读地址
  11. uchar code init_ds[]  ={0x55,0x17,0x15,0x01,0x01,0x13,0x13};   
  12. uchar miao,fen,shi,ri,yue,week,nian;
  13. uchar i;

  15. uchar t1_num,t2_num;        //计时间中断的次数
  16. unsigned long speed1,juli,time2;
  17. float f_hz        ,speed_km,speed_m;

  19. uchar TH11,TL11;
  20. uchar flag_en;   //开始计算速度使能
  21. uchar flag_stop_en;   //要确定车子是否停下了
  22. unsigned char plu;
  23. uint juli_s;             //每秒走的距离
  24. uint juli_z;         //总路程
  25. float zhijing = 0.55;  //直径 0.55M
  26. bit flag_1s = 1;             //1s
  27. uchar menu_1;        //菜单设置变量
  28. uchar menu_2;        //菜单设置变量

  30. long zong_lc;        //总量程

  32. uchar flag_200ms;
  33. uint shudu;   //定义速度的变量
  34. uint bj_shudu = 40;         //报警速度


  37. //这三个引脚参考资料
  38. sbit rs=P2^4;         //寄存器选择信号 H:数据寄存器          L:指令寄存器
  39. sbit rw=P2^5;         //寄存器选择信号 H:数据寄存器          L:指令寄存器
  40. sbit e =P2^6;         //片选信号   下降沿触发

  42. uchar code table_num[]="0123456789abcdefg";
  43. uchar i;

  45. sbit beep = P3^7;   //蜂鸣器IO口定义



  49. /******************1ms 延时函数*******************/
  50. void delay_1ms(uint q)
  51. {
  52.         uint i,j;
  53.         for(i=0;i<q;i++)
  54.                 for(j=0;j<120;j++);
  55. }


  58. /********************************************************************
  59. * 名称 : delay_uint()
  60. * 功能 : 小延时。
  61. * 输入 : 无
  62. * 输出 : 无
  63. ***********************************************************************/
  64. void delay_uint(uint q)
  65. {
  66.         while(q--);
  67. }

  69. /********************************************************************
  70. * 名称 : write_com(uchar com)
  71. * 功能 : 1602命令函数
  72. * 输入 : 输入的命令值
  73. * 输出 : 无
  74. ***********************************************************************/
  75. void write_com(uchar com)
  76. {
  77.         i =0;
  78.         rs=0;
  79.         rw=0;
  80.         P0=com;
  81.         delay_uint(3);
  82.         e=1;
  83.         delay_uint(25);
  84.         e=0;
  85. }

  87. /********************************************************************
  88. * 名称 : write_data(uchar dat)
  89. * 功能 : 1602写数据函数
  90. * 输入 : 需要写入1602的数据
  91. * 输出 : 无
  92. ***********************************************************************/
  93. void write_data(uchar dat)
  94. {
  95.         i =0;
  96.         rs=1;
  97.         rw=0;
  98.         P0=dat;
  99.         delay_uint(3);
  100.         e=1;
  101.         delay_uint(25);
  102.         e=0;        
  103. }

  105. /********************************************************************
  106. * 名称 : write_sfm2(uchar hang,uchar add,uchar date)
  107. * 功能 : 显示2位十进制数，如果要让第一行，第五个字符开始显示"23" ，调用该函数如下
  108.                   write_sfm1(1,5,23)
  109. * 输入 : 行，列，需要输入1602的数据
  110. * 输出 : 无
  111. ***********************************************************************/
  112. void write_sfm2(uchar hang,uchar add,uint date)
  113. {
  114.         if(hang==1)   
  115.                 write_com(0x80+add);
  116.         else
  117.                 write_com(0x80+0x40+add);
  118.         write_data(0x30+date/10%10);
  119.         write_data(0x30+date%10);        
  120. }

  122. /********************************************************************
  123. * 名称 : write_sfm4(uchar hang,uchar add,uchar date)
  124. * 功能 : 显示2位十进制数，如果要让第一行，第五个字符开始显示"23" ，调用该函数如下
  125.                   write_sfm1(1,5,23)
  126. * 输入 : 行，列，需要输入1602的数据
  127. * 输出 : 无
  128. ***********************************************************************/
  129. void write_sfm4(uchar hang,uchar add,uint date)
  130. {
  131.         if(hang==1)   
  132.                 write_com(0x80+add);
  133.         else
  134.                 write_com(0x80+0x40+add);
  135.         write_data(0x30+date/10000%10);
  136.         write_data(0x30+date/1000%10);
  137.         write_data('.');        
  138.         write_data(0x30+date/100%10);        
  139.         write_data(0x30+date/10%10);
  140.         write_data(0x30+date%10);        
  141.         write_data('k');        
  142.         write_data('m');        
  143. }

  145. void write_sfm7(uchar hang,uchar add,uint date)
  146. {
  147.         if(hang==1)   
  148.                 write_com(0x80+add);
  149.         else
  150.                 write_com(0x80+0x40+add);
  151.         write_data(0x30+date/100000%10);
  152.         write_data(0x30+date/100000%10);
  153.         write_data(0x30+date/10000%10);
  154.         write_data(0x30+date/1000%10);
  155.         write_data('.');        
  156.         write_data(0x30+date/100%10);        
  157.         write_data(0x30+date/10%10);
  158.         write_data('k');        
  159.         write_data('m');        
  160. }

  162. /***********************lcd1602上显示两位十进制数************************/
  163. void write_sfm1(uchar hang,uchar add,uchar date)
  164. {
  165.         if(hang==1)   
  166.                 write_com(0x80+add);
  167.         else
  168.                 write_com(0x80+0x40+add);
  169.         write_data(0x30+date % 10);        
  170. }


  173. /********************************************************************
  174. * 名称 : write_string(uchar hang,uchar add,uchar *p)
  175. * 功能 : 改变液晶中某位的值，如果要让第一行，第五个字符开始显示"ab cd ef" ，调用该函数如下
  176.                   write_string(1,5,"ab cd ef;")
  177. * 输入 : 行，列，需要输入1602的数据
  178. * 输出 : 无
  179. ***********************************************************************/
  180. void write_string(uchar hang,uchar add,uchar *p)
  181. {
  182.         if(hang==1)   
  183.                 write_com(0x80+add);
  184.         else
  185.                 write_com(0x80+0x40+add);
  186.                 while(1)
  187.                 {
  188.                         if(*p == '\0')  break;
  189.                         write_data(*p);
  190.                         p++;
  191.                 }        
  192. }


  195. /***********************lcd1602上显示两位十进制数************************/
  196. void write_sfm2_ds1302(uchar hang,uchar add,uchar date)
  197. {
  198.         if(hang==1)   
  199.                 write_com(0x80+add);
  200.         else
  201.                 write_com(0x80+0x40+add);
  202.         write_data(table_num[date / 16]);
  203.         write_data(table_num[date % 16]);        
  204. }

  206. /*****************控制光标函数********************/
  207. void write_guanbiao(uchar hang,uchar add,uchar date)
  208. {               
  209.         if(hang==1)   
  210.                 write_com(0x80+add);
  211.         else
  212.                 write_com(0x80+0x40+add);
  213.         if(date == 1)
  214.                 write_com(0x0f);     //显示光标并且闪烁        
  215.         else
  216.                 write_com(0x0c);   //关闭光标
  217. }         



  221. /********************************************************************
  222. * 名称 : init_1602()
  223. * 功能 : 初始化1602液晶
  224. * 输入 : 无
  225. * 输出 : 无
  226. ***********************************************************************/
  227. void init_1602()      //1602初始化
  228. {
  229.         write_com(0x38);
  230.         write_com(0x0c);
  231.         write_com(0x06);
  232.         delay_uint(1000);
  233.         write_string(1,0,"sd:00km/h  00:00");               
  234.         write_string(2,0,"lc:00.00km      ");
  235. }


  238. //         E309R

  240. /*************写一个数据到对应的地址里***************/
  241. void write_ds1302(uchar add,uchar dat)
  242. {               
  243.         rst = 1;                         //把复位线拿高
  244.         for(i=0;i<8;i++)
  245.         {                                     //低位在前
  246.                 clk = 0;                 //时钟线拿低开始写数据
  247.                 io = add & 0x01;            
  248.                 add >>= 1;                 //把地址右移一位
  249.                 clk = 1;                 //时钟线拿高
  250.         }        
  251.         for(i=0;i<8;i++)
  252.         {
  253.                 clk = 0;                 //时钟线拿低开始写数据
  254.                 io = dat & 0x01;
  255.                 dat >>= 1;                 //把数据右移一位
  256.                 clk = 1;                 //时钟线拿高
  257.         }
  258.         rst = 0;                         //复位线合低
  259.         clk = 0;
  260.         io = 0;
  261. }

  263. /*************从对应的地址读一个数据出来***************/
  264. uchar read_ds1302(uchar add)
  265. {
  266.         uchar value,i;
  267.         rst = 1;                         //把复位线拿高
  268.         for(i=0;i<8;i++)
  269.         {                                     //低位在前
  270.                 clk = 0;                 //时钟线拿低开始写数据
  271.                 io = add & 0x01;            
  272.                 add >>= 1;                 //把地址右移一位
  273.                 clk = 1;                 //时钟线拿高
  274.         }               
  275.         for(i=0;i<8;i++)
  276.         {
  277.                 clk = 0;                 //时钟线拿低开始读数据
  278.                 value >>= 1;
  279.                 if(io == 1)
  280.                         value |= 0x80;
  281.                 clk = 1;                 //时钟线拿高
  282.         }
  283.         rst = 0;                         //复位线合低
  284.         clk = 0;
  285.         io = 0;
  286.         return value;                 //返回读出来的数据
  287. }



  291. /*************把要的时间 年月日 都读出来***************/
  292. void read_time()
  293. {
  294.         miao = read_ds1302(read_add[0]);        //读秒
  295.         fen  = read_ds1302(read_add[1]);        //读分
  296.         shi  = read_ds1302(read_add[2]);        //读时
  297.         ri   = read_ds1302(read_add[3]);        //读日
  298.         yue  = read_ds1302(read_add[4]);        //读月
  299.         nian = read_ds1302(read_add[5]);        //读年
  300.         week = read_ds1302(read_add[6]);        //读星期
  301. }

  303. /*************把要写的时间 年月日 都写入ds1302里***************/
  304. void write_time()
  305. {
  306.         write_ds1302(0x8e,0x00);                        //打开写保护
  307.         write_ds1302(write_add[0],miao);        //写秒
  308.         write_ds1302(write_add[1],fen);                //写分
  309.         write_ds1302(write_add[2],shi);                //写时
  310.         write_ds1302(write_add[3],ri);                //写日
  311.         write_ds1302(write_add[4],yue);                //写月
  312.         write_ds1302(write_add[5],nian);        //写星期
  313.         write_ds1302(write_add[6],week);        //写年
  314.         write_ds1302(0x8e,0x80);                        //关闭写保护
  315. }

  317. /*************把数据保存到ds1302 RAM中**0-31*************/
  318. void write_ds1302ram(uchar add,uchar dat)
  319. {
  320.         add <<= 1;     //地址是从第二位开始的
  321.         add &= 0xfe;   //把最低位清零  是写的命令
  322.         add |= 0xc0;   //地址最高两位为 1  
  323.         write_ds1302(0x8e,0x00);
  324.         write_ds1302(add,dat);        
  325.         write_ds1302(0x8e,0x80);
  326. }

  328. /*************把数据从ds1302 RAM读出来**0-31*************/
  329. uchar read_ds1302ram(uchar add)
  330. {
  331.         add <<= 1;     //地址是从第二位开始的
  332.         add |= 0x01;   //把最高位置1  是读命令
  333.         add |= 0xc0;   //地址最高两位为 1  
  334.         return(read_ds1302(add));        
  335. }




  340. /*************初始化ds1302时间***************/
  341. void init_ds1302()
  342. {
  343.         uchar i;
  344.         rst = 0;        //第一次读写数据时要把IO品拿低
  345.         clk = 0;
  346.         io = 0;
  347.         i = read_ds1302ram(30);   
  348.         if(i != 3)
  349.         {        
  350.                 i = 3;
  351.                 write_ds1302ram(30,i);
  352.                 write_ds1302(0x8e,0x00);                    //打开写保护
  353.                 for(i=0;i<7;i++)
  354.                         write_ds1302(write_add[i],init_ds[i]);        //把最高位值0 允许ds1302工作
  355.                 write_ds1302(0x8e,0x80);        //关写保护
  356.         }
  357.         write_sfm2(1,0,i);
  358. }

  360. void init_ds1302_io()
  361. {
  362.         rst = 0;        //第一次读写数据时要把IO品拿低
  363.         clk = 0;
  364.         io = 0;        
  365. }

  367. /*************定时器0初始化程序***************/
  368. void init_1602_ds1302()
  369. {
  370. //        write_sfm2_ds1302(2,3,nian);        
  371. //        write_sfm2_ds1302(2,6,yue);        
  372. //        write_sfm2_ds1302(2,9,ri);        
  373.         write_sfm2_ds1302(1,11,shi);        
  374.         write_sfm2_ds1302(1,14,fen);        
  375. //        write_sfm2_ds1302(1,14,miao);
  376. //        write_sfm1(1,14,week);               
  377. }

  379. /***********外部中断0初始化程序****************/
  380. void init_int0()
  381. {
  382.         EX0=1;                          //允许外部中断0中断
  383.         EA=1;                           //开总中断
  384.         IT0 = 1;                   //外部中断0负跳变中断
  385. }


  388. /*************定时器0初始化程序***************/
  389. void time_init()          //定时器0初始化程序
  390. {
  391.         EA   = 1;                   //开总中断
  392.         TMOD = 0X11;          //定时器0、工作方式1
  393.         ET0  = 1;                  //开定时器0中断
  394.         TR0  = 1;                  //允许定时器0定时
  395.         ET1  = 1;                  //开定时器1中断
  396.         TR1  = 1;                  //允许定时器1定时
  397. }


  400. /***********计算速度函数**************/
  401. void menu_dis()          //计算速度函数
  402. {
  403.         static uchar value;
  404.         static uchar times;
  405.         if(menu_1 == 0)
  406.         {        
  407.                 if(flag_1s == 1)   
  408.                 {        
  409.                         flag_1s = 0;
  410.                         times++;
  411.                         if(times>=2)
  412.                         {
  413.                                 times = 0;
  414.                                 shudu = (shudu+3.6*plu*(zhijing * 3.14))/2; //(带个小数点) km/h        
  415.                                 if(shudu>99) shudu=99;        //防止错误
  416.                                 juli_z += (plu*zhijing*3.14);           //总路程m
  417.                                 plu = 0;
  418.                         }
  419.                                          
  420.                         if(flag_en == 0)
  421.                         {
  422.                                 value ++;
  423.                                 if(value >= 3)        //2秒
  424.                                 {        
  425.                                         speed_km = 0;  //速度为0
  426.                                         shudu = (uint)speed_km;        
  427.                                         value = 0;                                
  428.                                 }
  429.                         }
  430.                         write_sfm2(1,3,shudu);               
  431.                         write_sfm4(2,3,juli_z);        
  432.                 }
  433.                 if((flag_en == 1))
  434.                 {        
  435.                         value = 0;               
  436.                         flag_en = 0;         
  437.                          //1s = 1 / 1000000us;          // 1m/s=0.001km除以1/3600h=3.6km/h                        
  438.                         f_hz = (t2_num * 65536.0 + TH11 * 256 + TL11) / 1000000 ;  //算出来就是秒
  439.                         t2_num = 0;        //把变量清零
  440.                         t1_num =0;
  441.                         TH11 = 0;
  442.                         TL11 = 0;                                          
  443. //                        speed_m =  (zhijing * 3.14) / f_hz ;        //算出来的是m/s
  444. //                        juli_z = (juli_z + (uint)speed_m) ;        //总路程m        
  445. //                        speed_km = speed_m * 3.6 *10 ;        //(带个小数点) km/h        
  446. //                    shudu = (uint)(speed_km+shudu)/2;
  447. //                        zong_lc += speed_m;
  448.                 }                                
  449.         }
  450. }

  452. /********************独立按键程序*****************/
  453. uchar key_can;         //按键值

  455. void key()         //独立按键程序
  456. {
  457.         static uchar key_new;
  458.         key_can = 20;                   //按键值还原
  459.         P3 |= 0x78;                     //对应的按键IO口输出为1
  460.         if((P3 & 0x78) != 0x78)                //按键按下
  461.         {
  462.                 delay_1ms(1);                     //按键消抖动
  463.                 if(((P3 & 0x78) != 0x78) && (key_new == 1))
  464.                 {                                                //确认是按键按下
  465.                         key_new = 0;
  466.                         switch(P3 & 0x78)
  467.                         {
  468.                                 case 0x70:  key_can = 4;  break;         //得到按键值
  469.                                 case 0x68:  key_can = 3;  break;         //得到按键值
  470.                                 case 0x58:  key_can = 2;  break;         //得到按键值
  471.                                 case 0x38:  key_can = 1;  break;         //得到按键值
  472.                         }
  473. //                        write_sfm2(1,0,key_can);                                 //显示按键值
  474.                 }                        
  475.         }
  476.         else
  477.                 key_new = 1;        
  478. }


  481. /**********************设置函数************************/
  482. void key_with()
  483. {
  484.         if(key_can == 1)        //设置键
  485.         {
  486.                 menu_1++;
  487.                 if(menu_1 == 1)          //设置时间
  488.                 {
  489.                         menu_2 = 1;
  490.                         write_string(1,0,"    :  :    W:  ");                        
  491.                         write_string(2,0," 20  -  -       ");        
  492.                 }
  493.                 if(menu_1 == 2)          //设置报警速度
  494.                 {
  495.                         menu_2 = 1;
  496.                         write_string(1,0,"set-sd:00km/h   ");                        
  497.                         write_string(2,0,"zlc:             ");        
  498.                 }
  499.                 menu_2 = 1;

  501.                 if(menu_1 > 2)    //回到正常显示
  502.                 {
  503.                         menu_1 = 0;
  504.                         write_guanbiao(1,2,0);          //关闭光标
  505.                         init_1602();      //1602初始化     //初始化液晶显示               
  506.                 }
  507.         }
  508.         if(key_can == 2)        //选择键
  509.         {
  510.                 if(menu_1 == 1)                  //设置时间
  511.                 {
  512.                         menu_2 ++;
  513.                         if(menu_2 > 7)
  514.                                 menu_2 = 1;
  515.                 }
  516.                 if(menu_1 == 2)                 //设置
  517.                 {
  518.                         menu_2 ++;
  519.                         if(menu_2 > 2)
  520.                                 menu_2 = 1;                                
  521.                 }

  523.         }
  524.         if(menu_1 == 1)
  525.         {
  526.                 if(menu_2 == 1)                  //设置时
  527.                 {
  528.                         if(key_can == 3)        //加
  529.                         {
  530.                                 shi+=0x01;
  531.                                 if((shi & 0x0f) >= 0x0a)
  532.                                         shi = (shi & 0xf0) + 0x10;
  533.                                 if(shi >= 0x24)
  534.                                         shi = 0;
  535.                         }               
  536.                         if(key_can == 4)        //减
  537.                         {
  538.                                 if(shi == 0x00)
  539.                                         shi = 0x24;
  540.                                 if((shi & 0x0f) == 0x00)
  541.                                         shi = (shi | 0x0a) - 0x10;
  542.                                 shi -- ;
  543.                         }                                          
  544.                 }
  545.                 if(menu_2 == 2)                  //设置分
  546.                 {
  547.                         if(key_can == 3)        //加
  548.                         {
  549.                                 fen+=0x01;
  550.                                 if((fen & 0x0f) >= 0x0a)
  551.                                         fen = (fen & 0xf0) + 0x10;
  552.                                 if(fen >= 0x60)
  553.                                         fen = 0;
  554.                         }               
  555.                         if(key_can == 4)        //减         
  556.                         {
  557.                                 if(fen == 0x00)
  558.                                         fen = 0x5a;
  559.                                 if((fen & 0x0f) == 0x00)
  560.                                         fen = (fen | 0x0a) - 0x10;
  561.                                 fen -- ;
  562.                         }        
  563.                 }
  564.                 if(menu_2 == 3)                  //设置秒
  565.                 {
  566.                         if(key_can == 3)        //加
  567.                         {
  568.                                 miao+=0x01;
  569.                                 if((miao & 0x0f) >= 0x0a)
  570.                                         miao = (miao & 0xf0) + 0x10;
  571.                                 if(miao >= 0x60)
  572.                                         miao = 0;
  573.                         }        
  574.                         if(key_can == 4)        //减         
  575.                         {
  576.                                 if(miao == 0x00)
  577.                                         miao = 0x5a;
  578.                                 if((miao & 0x0f) == 0x00)
  579.                                         miao = (miao | 0x0a) - 0x10;
  580.                                 miao -- ;                        
  581.                         }
  582.                 }
  583.                 if(menu_2 == 4)                  //设置星期
  584.                 {
  585.                         if(key_can == 3)        //加
  586.                         {
  587.                             week+=0x01;
  588.                                 if((week & 0x0f) >= 0x0a)
  589.                                         week = (week & 0xf0) + 0x10;
  590.                                 if(week >= 0x08)
  591.                                         week = 1;
  592.                         }               
  593.                         if(key_can == 4)        //减         
  594.                         {
  595.                                 if(week == 0x01)
  596.                                         week = 0x08;
  597.                                 if((week & 0x0f) == 0x00)
  598.                                         week = (week | 0x0a) - 0x10;
  599.                                 week -- ;
  600.                         }        
  601.                 }
  602.                 if(menu_2 == 5)                  //设置年
  603.                 {
  604.                         if(key_can == 3)        //加
  605.                         {
  606.                             nian+=0x01;
  607.                                 if((nian & 0x0f) >= 0x0a)
  608.                                         nian = (nian & 0xf0) + 0x10;
  609.                                 if(nian >= 0x9a)
  610.                                         nian = 1;
  611.                         }               
  612.                         if(key_can == 4)        //减         
  613.                         {
  614.                                 if(nian == 0x01)
  615.                                         nian = 0x9a;
  616.                                 if((nian & 0x0f) == 0x00)
  617.                                         nian = (nian | 0x0a) - 0x10;
  618.                                 nian -- ;               
  619.                         }        
  620.                 }
  621.                 if(menu_2 == 6)                  //设置月
  622.                 {
  623.                         if(key_can == 3)        //加
  624.                         {
  625.                             yue+=0x01;
  626.                                 if((yue & 0x0f) >= 0x0a)
  627.                                         yue = (yue & 0xf0) + 0x10;
  628.                                 if(yue >= 0x13)
  629.                                         yue = 1;
  630.                         }               
  631.                         if(key_can == 4)        //减         
  632.                         {
  633.                                 if(yue == 0x01)
  634.                                         yue = 0x13;
  635.                                 if((yue & 0x0f) == 0x00)
  636.                                         yue = (yue | 0x0a) - 0x10;
  637.                                 yue -- ;                                       
  638.                         }        
  639.                 }
  640.                 if(menu_2 == 7)                  //设置日
  641.                 {
  642.                         if(key_can == 3)        //加
  643.                         {
  644.                     ri+=0x01;
  645.                         if((ri & 0x0f) >= 0x0a)
  646.                                 ri = (ri & 0xf0) + 0x10;
  647.                         if(ri >= 0x32)
  648.                                 ri = 0;                        
  649.                         }               
  650.                         if(key_can == 4)        //减         
  651.                         {
  652.                                 if(ri == 0x01)
  653.                                         ri = 0x32;
  654.                                 if((ri & 0x0f) == 0x00)
  655.                                         ri = (ri | 0x0a) - 0x10;
  656.                                 ri -- ;                        
  657.                         }        
  658.                 }
  659.                 write_sfm2_ds1302(1,2,shi);           //显示时
  660.                 write_sfm2_ds1302(1,5,fen);           //显示分
  661.                 write_sfm2_ds1302(1,8,miao);           //显示秒
  662.                 write_sfm1(1,14,week);           //显示星期                                       
  663.                 write_sfm2_ds1302(2,3,nian);           //显示年
  664.                 write_sfm2_ds1302(2,6,yue);           //显示月
  665.                 write_sfm2_ds1302(2,9,ri);           //显示日
  666.                 switch(menu_2)           // 光标显示
  667.                 {
  668.                         case 1:  write_guanbiao(1,2,1);  break;
  669.                         case 2:  write_guanbiao(1,5,1);  break;
  670.                         case 3:  write_guanbiao(1,8,1);  break;
  671.                         case 4:  write_guanbiao(1,14,1); break;
  672.                         case 5:  write_guanbiao(2,3,1);  break;
  673.                         case 6:  write_guanbiao(2,6,1);  break;
  674.                         case 7:  write_guanbiao(2,9,1);  break;
  675.                 }
  676.                 write_time();           //把时间写进去
  677.         }        

  679.         if(menu_1 == 2)
  680.         {               
  681.                 if(menu_2 == 1)                  //设置速度
  682.                 {
  683.                         if(key_can == 3)        //加
  684.                         {
  685.                                 bj_shudu++;
  686.                                 if(bj_shudu >= 99)        //速度设置++
  687.                                         bj_shudu = 99;
  688.                         }        
  689.                         if(key_can == 4)        //减         
  690.                         {
  691.                                 if(bj_shudu != 0)        //速度设置--
  692.                                         bj_shudu -- ;                        
  693.                         }
  694.                 }        
  695.                 if(menu_2 == 2)                  //把总量程清零
  696.                 {
  697.                         if(key_can == 3)        
  698.                         {
  699.                                 juli_z= 0;                  //清零
  700.                         }        
  701.                         if(key_can == 4)                  
  702.                         {
  703.                                 juli_z= 0;                        
  704.                         }
  705.                 }        
  706.                 write_sfm2(1,7,bj_shudu);   //显示报警速度
  707.                 write_sfm7(2,4,juli_z);   //显示
  708.                
  709.                 switch(menu_2)           // 光标显示
  710.                 {
  711.                         case 1:  write_guanbiao(1,6,1);  break;
  712.                         case 2:  write_guanbiao(2,3,1);  break;
  713.                 }
  714.         }
  715. }

  717. /****************报警函数***************/
  718. void clock_h_l()
  719. {
  720.         static uchar value;           
  721.         if((shudu >= bj_shudu))
  722.         {
  723.                 value ++;  //消除实际距离在设定距离左右变化时的干扰
  724.                 {
  725.                         beep = ~beep;           //蜂鸣器报警                        
  726.                 }        
  727.         }
  728.         else
  729.         {
  730.                 beep = 1;        
  731.         }                        
  732. }

  734. /******************主程序**********************/           
  735. void main()
  736. {
  737.         beep = 0;                  //上电蜂鸣器响一下
  738.         delay_1ms(200) ;
  739.         beep = 1;
  740.         P0 = P1 = P2 = P3 = 0xff;  //IO口初始为电平
  741.         init_ds1302_io();           //初始化ds1302io接口
  742.         init_ds1302();
  743.         init_1602();      //1602初始化
  744.         init_int0();
  745.         time_init();          //定时器0初始化程序

  747.         while(1)
  748.         {         //  shudu = 11;
  749.                 key();                         //按键程序
  750.                 if(key_can < 10)
  751.                 {
  752.                         key_with();        //  按键处理

  754.                 }
  755.                 if(flag_200ms == 1)          //定时200ms标志
  756.                 {
  757.                         flag_200ms = 0;
  758.                         read_time();                  //读时间
  759.                         if(menu_1 == 0)
  760.                                 init_1602_ds1302();   //显示时钟
  761.                         clock_h_l();        //报警函数
  762.                 }
  763.                 menu_dis();          //计算速度函数
  764.         }
  765. }


  768. /*********************外部中断0中断服务程序************************/
  769. void int0() interrupt 0
  770. {
  771.         static uchar value;
  772.         plu++;
  773.         switch(value)
  774.         {
  775.                 case 0:
  776.                         t1_num = 0;                 //第一次就把变量清零
  777.                         TH1 = 0;
  778.                         TL1 = 0;
  779.                         value = 1;
  780.                         break;
  781.                 case 1:
  782.                                 t2_num = t1_num;  //保存
  783.                                 TH11 = TH1;
  784.                                 TL11 = TL1;
  785.                                 if(flag_en==0)
  786.                                 {
  787.                                         value=0;
  788.                                 }
  789.                                 flag_en = 1;
  790.                                 break;
  791.         }               
  792. }

  794. /*************定时器0中断服务程序***************/
  795. void time0_int() interrupt 1
  796. {        
  797.         static uchar value;
  798.         TH0 = 0x3c;
  799.         TL0 = 0xb0;     // 50ms
  800.         value++;
  801.         if(value % 4 == 0)
  802.                 flag_200ms = 1;

  804.         if(value >= 20)  //1秒   才是一秒钟的速度
  805.         {
  806.                 value = 0;
  807.                 flag_1s = 1;
  808.         }
  809. }

  811. /*************定时器1中断服务程序***************/
  812. void time1_int() interrupt 3
  813. {
  814.         t1_num++;
  815. }
复制代码


评分

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

查看全部评分

回复

使用道具 举报

ID:140183 发表于 2020-10-22 05:25 | 显示全部楼层
太好啦！感谢分享。每天骑行，有空也需要做一个。
回复

使用道具 举报

ID:844820 发表于 2020-11-20 13:49 | 显示全部楼层
为什么是这个样子呢
JEW4ID9$RLUAEGVOYCIFRW0.png
回复

使用道具 举报

ID:850748 发表于 2020-12-3 16:36 | 显示全部楼层
873113058 发表于 2020-11-20 13:49
为什么是这个样子呢

你这个是从哪弄得呀
回复

使用道具 举报

ID:88256 发表于 2020-12-3 20:59 | 显示全部楼层
我正考虑做一个类似的，请问楼主这种霍尔元件检测那种LED广告屏固定磁柱可靠距离有多远？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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