单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 3669|回复: 1
收起左侧

简易自行车码表基于霍尔元件 源码论文原理图

[复制链接]
sinyil 发表于 2017-6-22 23:38 | 显示全部楼层 |阅读模式
STC89C52单片机为核心,A44E 霍尔传感器测转数,实现对自行车里程/速度的测量,采用1602LCD显示自行车的里程数及速度。文章详细介绍了自行车的速度里程表的硬件电路。硬件部分利用霍尔元件将自行车每转一圈的脉冲数传入单片机系统,然后单片机系统将信号经过处理送显示。软件部分用C语言进行编程,采用模块化设计思想。该系统硬件电路简单,子程序具有通用性,完全符合设计要求。
0.png 0.png
实现:利用单片机自带的计数器T1对霍尔传感器脉冲信号进行计数。
3. 对数据进行处理,要求用LED显示里程总数和即时速度。
实现:利用软件编程,对数据进行处理得到需要的数值。
最终实现目标:自行车的速度里程表具有里程、速度测试与显示功能,采用单片机作控制,显示电路可显示里程及速度。

0.png 0.png 0.png

单片机源程序如下:
  1. #include <reg52.h>                 //调用单片机头文件
  2. #define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
  3. #define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535
  4. #include "eeprom52.h"

  5. /******************
  6.         ds1302 内部RAM   RAM0  1100 000R/W   1读 0写
  7.                                          RAM1  1100 001R/W  
  8.                                                .......
  9.                                          RAM30 1111 110R/W   
  10. ********************/

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

  20. uchar t1_num,t2_num;        //计时间中断的次数
  21. unsigned long speed1,juli,time2;
  22. float f_hz        ,speed_km,speed_m;
  23. //dlaout time1        ,speed_km,speed_m;
  24. uchar TH11,TL11;
  25. uchar flag_en;   //开始计算速度使能
  26. uchar flag_stop_en;   //要确定车子是否停下了

  27. uint juli_s;             //每秒走的距离
  28. uint juli_z;         //总路程
  29. float zhijing = 0.55;  //直径 0.55M
  30. bit flag_1s = 1;             //1s
  31. uchar menu_1;        //菜单设置变量
  32. uchar menu_2;        //菜单设置变量

  33. long zong_lc;        //总量程

  34. uchar flag_200ms;
  35. uint shudu;   //定义速度的变量
  36. uint bj_shudu = 80;         //报警速度


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

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

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



  44. /******************1ms 延时函数*******************/
  45. void delay_1ms(uint q)
  46. {
  47.         uint i,j;
  48.         for(i=0;i<q;i++)
  49.                 for(j=0;j<120;j++);
  50. }

  51. /******************把数据保存到单片机内部eepom中******************/
  52. void write_eeprom()
  53. {
  54.        
  55.         SectorErase(0x2000);
  56.         byte_write(0x2000, bj_shudu % 256);
  57.         byte_write(0x2001, bj_shudu / 256);
  58.         byte_write(0x2002, zong_lc % 256);
  59.         byte_write(0x2003, zong_lc / 256 % 256);
  60.         byte_write(0x2004, zong_lc / 256 / 256 % 256);

  61.         byte_write(0x2055, a_a);       
  62. }

  63. /******************把数据从单片机内部eepom中读出来*****************/
  64. void read_eeprom()
  65. {
  66.         uint value;
  67.         bj_shudu  = byte_read(0x2001);
  68.         bj_shudu <<= 8;
  69.         bj_shudu  |= byte_read(0x2000);
  70.         zong_lc  = byte_read(0x2004);
  71.         zong_lc <<= 16;
  72.         value  = byte_read(0x2003);
  73.         zong_lc |= (value << 8);
  74.         zong_lc  |= byte_read(0x2002);
  75.         a_a     = byte_read(0x2055);
  76. }

  77. /**************开机初始化保存的数据*****************/
  78. void init_eeprom()         //开机初始化保存的数据*
  79. {
  80.         read_eeprom();                //先读
  81.         if(a_a != 12)                //新的单片机初始单片机内问eeprom
  82.         {
  83.                 bj_shudu = 50;
  84.                 a_a = 12;
  85.                 write_eeprom();           //保存数据
  86.         }       
  87. }

  88. /********************************************************************
  89. * 名称 : delay_uint()
  90. * 功能 : 小延时。
  91. * 输入 : 无
  92. * 输出 : 无
  93. ***********************************************************************/
  94. void delay_uint(uint q)
  95. {
  96.         while(q--);
  97. }

  98. /********************************************************************
  99. * 名称 : write_com(uchar com)
  100. * 功能 : 1602命令函数
  101. * 输入 : 输入的命令值
  102. * 输出 : 无
  103. ***********************************************************************/
  104. void write_com(uchar com)
  105. {
  106.         i =0;
  107.         e=0;
  108.         rs=0;
  109.         rw=0;
  110.         P0=com;
  111.         delay_uint(25);
  112.         e=1;
  113.         delay_uint(50);
  114.         e=0;
  115. }

  116. /********************************************************************
  117. * 名称 : write_data(uchar dat)
  118. * 功能 : 1602写数据函数
  119. * 输入 : 需要写入1602的数据
  120. * 输出 : 无
  121. ***********************************************************************/
  122. void write_data(uchar dat)
  123. {
  124.         i =0;
  125.         e=0;
  126.         rs=1;
  127.         rw=0;
  128.         P0=dat;
  129.         delay_uint(25);
  130.         e=1;
  131.         delay_uint(50);
  132.         e=0;       
  133. }

  134. /********************************************************************
  135. * 名称 : write_sfm2(uchar hang,uchar add,uchar date)
  136. * 功能 : 显示2位十进制数,如果要让第一行,第五个字符开始显示"23" ,调用该函数如下
  137.                   write_sfm1(1,5,23)
  138. * 输入 : 行,列,需要输入1602的数据
  139. * 输出 : 无
  140. ***********************************************************************/
  141. void write_sfm2(uchar hang,uchar add,uint date)
  142. {
  143.         if(hang==1)   
  144.                 write_com(0x80+add);
  145.         else
  146.                 write_com(0x80+0x40+add);
  147.         write_data(0x30+date/10%10);
  148.         write_data(0x30+date%10);       
  149. }

  150. /********************************************************************
  151. * 名称 : write_sfm4(uchar hang,uchar add,uchar date)
  152. * 功能 : 显示2位十进制数,如果要让第一行,第五个字符开始显示"23" ,调用该函数如下
  153.                   write_sfm1(1,5,23)
  154. * 输入 : 行,列,需要输入1602的数据
  155. * 输出 : 无
  156. ***********************************************************************/
  157. void write_sfm4(uchar hang,uchar add,uint date)
  158. {
  159.         if(hang==1)   
  160.                 write_com(0x80+add);
  161.         else
  162.                 write_com(0x80+0x40+add);
  163.         write_data(0x30+date/10000%10);
  164.         write_data(0x30+date/1000%10);
  165.         write_data('.');       
  166.         write_data(0x30+date/100%10);       
  167.         write_data(0x30+date/10%10);
  168.         write_data(0x30+date%10);       
  169.         write_data('k');       
  170.         write_data('m');       
  171. }

  172. void write_sfm7(uchar hang,uchar add,uint date)
  173. {
  174.         if(hang==1)   
  175.                 write_com(0x80+add);
  176.         else
  177.                 write_com(0x80+0x40+add);
  178.         write_data(0x30+date/100000%10);
  179.         write_data(0x30+date/100000%10);
  180.         write_data(0x30+date/10000%10);
  181.         write_data(0x30+date/1000%10);
  182.         write_data('.');       
  183.         write_data(0x30+date/100%10);       
  184.         write_data(0x30+date/10%10);
  185.         write_data('k');       
  186.         write_data('m');       
  187. }

  188. /***********************lcd1602上显示两位十进制数************************/
  189. void write_sfm1(uchar hang,uchar add,uchar date)
  190. {
  191.         if(hang==1)   
  192.                 write_com(0x80+add);
  193.         else
  194.                 write_com(0x80+0x40+add);
  195.         write_data(0x30+date % 10);       
  196. }


  197. /********************************************************************
  198. * 名称 : write_string(uchar hang,uchar add,uchar *p)
  199. * 功能 : 改变液晶中某位的值,如果要让第一行,第五个字符开始显示"ab cd ef" ,调用该函数如下
  200.                   write_string(1,5,"ab cd ef;")
  201. * 输入 : 行,列,需要输入1602的数据
  202. * 输出 : 无
  203. ***********************************************************************/
  204. void write_string(uchar hang,uchar add,uchar *p)
  205. {
  206.         if(hang==1)   
  207.                 write_com(0x80+add);
  208.         else
  209.                 write_com(0x80+0x40+add);
  210.                 while(1)
  211.                 {
  212.                         if(*p == '\0')  break;
  213.                         write_data(*p);
  214.                         p++;
  215.                 }       
  216. }


  217. /***********************lcd1602上显示两位十进制数************************/
  218. void write_sfm2_ds1302(uchar hang,uchar add,uchar date)
  219. {
  220.         if(hang==1)   
  221.                 write_com(0x80+add);
  222.         else
  223.                 write_com(0x80+0x40+add);
  224.         write_data(table_num[date / 16]);
  225.         write_data(table_num[date % 16]);       
  226. }

  227. /*****************控制光标函数********************/
  228. void write_guanbiao(uchar hang,uchar add,uchar date)
  229. {               
  230.         if(hang==1)   
  231.                 write_com(0x80+add);
  232.         else
  233.                 write_com(0x80+0x40+add);
  234.         if(date == 1)
  235.                 write_com(0x0f);     //显示光标并且闪烁       
  236.         else
  237.                 write_com(0x0c);   //关闭光标
  238. }         



  239. /********************************************************************
  240. * 名称 : init_1602()
  241. * 功能 : 初始化1602液晶
  242. * 输入 : 无
  243. * 输出 : 无
  244. ***********************************************************************/
  245. void init_1602()      //1602初始化
  246. {
  247.         write_com(0x38);
  248.         write_com(0x0c);
  249.         write_com(0x06);
  250.         delay_uint(1000);
  251.         write_string(1,0,"sd:00km/h  00:00");               
  252.         write_string(2,0,"lc:00.00km      ");       
  253. }


  254. //         E309R

  255. /*************写一个数据到对应的地址里***************/
  256. void write_ds1302(uchar add,uchar dat)
  257. {               
  258.         rst = 1;                         //把复位线拿高
  259.         for(i=0;i<8;i++)
  260.         {                                     //低位在前
  261.                 clk = 0;                 //时钟线拿低开始写数据
  262.                 io = add & 0x01;           
  263.                 add >>= 1;                 //把地址右移一位
  264.                 clk = 1;                 //时钟线拿高
  265.         }       
  266.         for(i=0;i<8;i++)
  267.         {
  268.                 clk = 0;                 //时钟线拿低开始写数据
  269.                 io = dat & 0x01;
  270.                 dat >>= 1;                 //把数据右移一位
  271.                 clk = 1;                 //时钟线拿高
  272.         }
  273.         rst = 0;                         //复位线合低
  274.         clk = 0;
  275.         io = 0;
  276. }

  277. /*************从对应的地址读一个数据出来***************/
  278. uchar read_ds1302(uchar add)
  279. {
  280.         uchar value,i;
  281.         rst = 1;                         //把复位线拿高
  282.         for(i=0;i<8;i++)
  283.         {                                     //低位在前
  284.                 clk = 0;                 //时钟线拿低开始写数据
  285.                 io = add & 0x01;           
  286.                 add >>= 1;                 //把地址右移一位
  287.                 clk = 1;                 //时钟线拿高
  288.         }               
  289.         for(i=0;i<8;i++)
  290.         {
  291.                 clk = 0;                 //时钟线拿低开始读数据
  292.                 value >>= 1;
  293.                 if(io == 1)
  294.                         value |= 0x80;
  295.                 clk = 1;                 //时钟线拿高
  296.         }
  297.         rst = 0;                         //复位线合低
  298.         clk = 0;
  299.         io = 0;
  300.         return value;                 //返回读出来的数据
  301. }



  302. /*************把要的时间 年月日 都读出来***************/
  303. void read_time()
  304. {
  305.         miao = read_ds1302(read_add[0]);        //读秒
  306.         fen  = read_ds1302(read_add[1]);        //读分
  307.         shi  = read_ds1302(read_add[2]);        //读时
  308.         ri   = read_ds1302(read_add[3]);        //读日
  309.         yue  = read_ds1302(read_add[4]);        //读月
  310.         nian = read_ds1302(read_add[5]);        //读年
  311.         week = read_ds1302(read_add[6]);        //读星期
  312. }

  313. /*************把要写的时间 年月日 都写入ds1302里***************/
  314. void write_time()
  315. {
  316.         write_ds1302(0x8e,0x00);                        //打开写保护
  317.         write_ds1302(write_add[0],miao);        //写秒
  318.         write_ds1302(write_add[1],fen);                //写分
  319.         write_ds1302(write_add[2],shi);                //写时
  320.         write_ds1302(write_add[3],ri);                //写日
  321.         write_ds1302(write_add[4],yue);                //写月
  322.         write_ds1302(write_add[5],nian);        //写星期
  323.         write_ds1302(write_add[6],week);        //写年
  324.         write_ds1302(0x8e,0x80);                        //关闭写保护
  325. }

  326. /*************把数据保存到ds1302 RAM中**0-31*************/
  327. void write_ds1302ram(uchar add,uchar dat)
  328. {
  329.         add <<= 1;     //地址是从第二位开始的
  330.         add &= 0xfe;   //把最低位清零  是写的命令
  331.         add |= 0xc0;   //地址最高两位为 1  
  332.         write_ds1302(0x8e,0x00);
  333.         write_ds1302(add,dat);       
  334.         write_ds1302(0x8e,0x80);
  335. }

  336. /*************把数据从ds1302 RAM读出来**0-31*************/
  337. uchar read_ds1302ram(uchar add)
  338. {
  339.         add <<= 1;     //地址是从第二位开始的
  340.         add |= 0x01;   //把最高位置1  是读命令
  341.         add |= 0xc0;   //地址最高两位为 1  
  342.         return(read_ds1302(add));       
  343. }




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

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

  369. /*************定时器0初始化程序***************/
  370. void init_1602_ds1302()
  371. {
  372.         if((miao <= 0x60) || (shi <= 0x24))
  373.         {
  374.         //        write_sfm2_ds1302(2,3,nian);       
  375.         //        write_sfm2_ds1302(2,6,yue);       
  376.         //        write_sfm2_ds1302(2,9,ri);       
  377.                 write_sfm2_ds1302(1,11,shi);       
  378.                 write_sfm2_ds1302(1,14,fen);       
  379.         //        write_sfm2_ds1302(1,14,miao);
  380.         //        write_sfm1(1,14,week);               
  381.         }
  382. }

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


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

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

  442.                         write_sfm2(1,3,shudu);               
  443.                         write_sfm4(2,3,juli_z);       

  444.                 }
  445.         }
  446. }

  447. /********************独立按键程序*****************/
  448. uchar key_can;         //按键值

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


  473. /**********************设置函数************************/
  474. void key_with()
  475. {
  476.         if(key_can == 1)        //设置键
  477.         {
  478.                 menu_1++;
  479.                 if(menu_1 == 1)          //设置时间
  480.                 {
  481.                         menu_2 = 1;
  482.                         write_string(1,0,"    :  :    W:  ");                       
  483.                         write_string(2,0," 20  -  -       ");       
  484.                 }
  485.                 if(menu_1 == 2)          //设置报警速度
  486.                 {
  487.                         menu_2 = 1;
  488.                         write_string(1,0,"set-sd:00km/h   ");                       
  489.                         write_string(2,0,"zlc:             ");       
  490.                 }
  491.                 menu_2 = 1;

  492.                 if(menu_1 > 2)    //回到正常显示
  493.                 {
  494.                         menu_1 = 0;
  495.                         write_guanbiao(1,2,0);          //关闭光标
  496.                         init_1602();      //1602初始化     //初始化液晶显示               
  497.                 }
  498.         }
  499.         if(key_can == 2)        //选择键
  500.         {
  501.                 if(menu_1 == 1)                  //设置时间
  502.                 {
  503.                         menu_2 ++;
  504.                         if(menu_2 > 7)
  505.                                 menu_2 = 1;
  506.                 }
  507.                 if(menu_1 == 2)                 //设置
  508.                 {
  509.                         menu_2 ++;
  510.                         if(menu_2 > 2)
  511.                                 menu_2 = 1;                               
  512.                 }

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

  668.         if(menu_1 == 2)
  669.         {               
  670.                 if(menu_2 == 1)                  //设置速度
  671.                 {
  672.                         if(key_can == 3)        //加
  673.                         {
  674.                                 bj_shudu++;
  675.                                 if(bj_shudu >= 99)
  676.                                         bj_shudu = 99;
  677.                         }       
  678.                         if(key_can == 4)        //减          
  679.                         {
  680.                                 if(bj_shudu != 0)
  681.                                         bj_shudu -- ;                       
  682.                         }
  683.                 }       
  684.                 if(menu_2 == 2)                  //把总量程清零
  685.                 {
  686.                         if(key_can == 3)       
  687.                         {
  688.                                 zong_lc= 0;
  689.                         }       
  690.                         if(key_can == 4)                  
  691.                         {
  692.                                 zong_lc= 0;                       
  693.                         }
  694.                 }       


  695.                 write_sfm2(1,7,bj_shudu);   //显示报警速度
  696.                 write_sfm7(2,4,zong_lc);   //显示
  697.                
  698.                 switch(menu_2)           // 光标显示
  699.                 {
  700.                         case 1:  write_guanbiao(1,6,1);  break;
  701.                         case 2:  write_guanbiao(2,3,1);  break;
  702.                 }
  703.                 write_eeprom();
  704.         }
  705. }

  706. /****************报警函数***************/
  707. void clock_h_l()
  708. {
  709.         static uchar value;          
  710.         if((shudu >= bj_shudu))
  711.         {
  712.                 value ++;  //消除实际距离在设定距离左右变化时的干扰
  713.                 if(value > 5)
  714.                 {
  715.                         beep = ~beep;           //蜂鸣器报警                       
  716.                 }       
  717.         }
  718.         else
  719. ……………………

  720. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
简易自行车码表_源码论文原理图.zip (727.42 KB, 下载次数: 73)

评分

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

查看全部评分

回复

使用道具 举报

学就学,玩就玩 发表于 2019-12-1 11:29 | 显示全部楼层
你这程序电机不转啊
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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