找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 4261|回复: 4
打印 上一主题 下一主题
收起左侧

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

  [复制链接]
跳转到指定楼层
楼主
  1. #include <reg52.h>                 //调用单片机头文件
  2. #define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
  3. #define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535

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

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

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

  26. long zong_lc;        //总量程

  27. uchar flag_200ms;
  28. uint shudu;   //定义速度的变量
  29. uint bj_shudu = 40;         //报警速度


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

  34. uchar code table_num[]="0123456789abcdefg";
  35. uchar i;

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



  37. /******************1ms 延时函数*******************/
  38. void delay_1ms(uint q)
  39. {
  40.         uint i,j;
  41.         for(i=0;i<q;i++)
  42.                 for(j=0;j<120;j++);
  43. }


  44. /********************************************************************
  45. * 名称 : delay_uint()
  46. * 功能 : 小延时。
  47. * 输入 : 无
  48. * 输出 : 无
  49. ***********************************************************************/
  50. void delay_uint(uint q)
  51. {
  52.         while(q--);
  53. }

  54. /********************************************************************
  55. * 名称 : write_com(uchar com)
  56. * 功能 : 1602命令函数
  57. * 输入 : 输入的命令值
  58. * 输出 : 无
  59. ***********************************************************************/
  60. void write_com(uchar com)
  61. {
  62.         i =0;
  63.         rs=0;
  64.         rw=0;
  65.         P0=com;
  66.         delay_uint(3);
  67.         e=1;
  68.         delay_uint(25);
  69.         e=0;
  70. }

  71. /********************************************************************
  72. * 名称 : write_data(uchar dat)
  73. * 功能 : 1602写数据函数
  74. * 输入 : 需要写入1602的数据
  75. * 输出 : 无
  76. ***********************************************************************/
  77. void write_data(uchar dat)
  78. {
  79.         i =0;
  80.         rs=1;
  81.         rw=0;
  82.         P0=dat;
  83.         delay_uint(3);
  84.         e=1;
  85.         delay_uint(25);
  86.         e=0;        
  87. }

  88. /********************************************************************
  89. * 名称 : write_sfm2(uchar hang,uchar add,uchar date)
  90. * 功能 : 显示2位十进制数,如果要让第一行,第五个字符开始显示"23" ,调用该函数如下
  91.                   write_sfm1(1,5,23)
  92. * 输入 : 行,列,需要输入1602的数据
  93. * 输出 : 无
  94. ***********************************************************************/
  95. void write_sfm2(uchar hang,uchar add,uint date)
  96. {
  97.         if(hang==1)   
  98.                 write_com(0x80+add);
  99.         else
  100.                 write_com(0x80+0x40+add);
  101.         write_data(0x30+date/10%10);
  102.         write_data(0x30+date%10);        
  103. }

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

  126. void write_sfm7(uchar hang,uchar add,uint date)
  127. {
  128.         if(hang==1)   
  129.                 write_com(0x80+add);
  130.         else
  131.                 write_com(0x80+0x40+add);
  132.         write_data(0x30+date/100000%10);
  133.         write_data(0x30+date/100000%10);
  134.         write_data(0x30+date/10000%10);
  135.         write_data(0x30+date/1000%10);
  136.         write_data('.');        
  137.         write_data(0x30+date/100%10);        
  138.         write_data(0x30+date/10%10);
  139.         write_data('k');        
  140.         write_data('m');        
  141. }

  142. /***********************lcd1602上显示两位十进制数************************/
  143. void write_sfm1(uchar hang,uchar add,uchar date)
  144. {
  145.         if(hang==1)   
  146.                 write_com(0x80+add);
  147.         else
  148.                 write_com(0x80+0x40+add);
  149.         write_data(0x30+date % 10);        
  150. }


  151. /********************************************************************
  152. * 名称 : write_string(uchar hang,uchar add,uchar *p)
  153. * 功能 : 改变液晶中某位的值,如果要让第一行,第五个字符开始显示"ab cd ef" ,调用该函数如下
  154.                   write_string(1,5,"ab cd ef;")
  155. * 输入 : 行,列,需要输入1602的数据
  156. * 输出 : 无
  157. ***********************************************************************/
  158. void write_string(uchar hang,uchar add,uchar *p)
  159. {
  160.         if(hang==1)   
  161.                 write_com(0x80+add);
  162.         else
  163.                 write_com(0x80+0x40+add);
  164.                 while(1)
  165.                 {
  166.                         if(*p == '\0')  break;
  167.                         write_data(*p);
  168.                         p++;
  169.                 }        
  170. }


  171. /***********************lcd1602上显示两位十进制数************************/
  172. void write_sfm2_ds1302(uchar hang,uchar add,uchar date)
  173. {
  174.         if(hang==1)   
  175.                 write_com(0x80+add);
  176.         else
  177.                 write_com(0x80+0x40+add);
  178.         write_data(table_num[date / 16]);
  179.         write_data(table_num[date % 16]);        
  180. }

  181. /*****************控制光标函数********************/
  182. void write_guanbiao(uchar hang,uchar add,uchar date)
  183. {               
  184.         if(hang==1)   
  185.                 write_com(0x80+add);
  186.         else
  187.                 write_com(0x80+0x40+add);
  188.         if(date == 1)
  189.                 write_com(0x0f);     //显示光标并且闪烁        
  190.         else
  191.                 write_com(0x0c);   //关闭光标
  192. }         



  193. /********************************************************************
  194. * 名称 : init_1602()
  195. * 功能 : 初始化1602液晶
  196. * 输入 : 无
  197. * 输出 : 无
  198. ***********************************************************************/
  199. void init_1602()      //1602初始化
  200. {
  201.         write_com(0x38);
  202.         write_com(0x0c);
  203.         write_com(0x06);
  204.         delay_uint(1000);
  205.         write_string(1,0,"sd:00km/h  00:00");               
  206.         write_string(2,0,"lc:00.00km      ");
  207. }


  208. //         E309R

  209. /*************写一个数据到对应的地址里***************/
  210. void write_ds1302(uchar add,uchar dat)
  211. {               
  212.         rst = 1;                         //把复位线拿高
  213.         for(i=0;i<8;i++)
  214.         {                                     //低位在前
  215.                 clk = 0;                 //时钟线拿低开始写数据
  216.                 io = add & 0x01;            
  217.                 add >>= 1;                 //把地址右移一位
  218.                 clk = 1;                 //时钟线拿高
  219.         }        
  220.         for(i=0;i<8;i++)
  221.         {
  222.                 clk = 0;                 //时钟线拿低开始写数据
  223.                 io = dat & 0x01;
  224.                 dat >>= 1;                 //把数据右移一位
  225.                 clk = 1;                 //时钟线拿高
  226.         }
  227.         rst = 0;                         //复位线合低
  228.         clk = 0;
  229.         io = 0;
  230. }

  231. /*************从对应的地址读一个数据出来***************/
  232. uchar read_ds1302(uchar add)
  233. {
  234.         uchar value,i;
  235.         rst = 1;                         //把复位线拿高
  236.         for(i=0;i<8;i++)
  237.         {                                     //低位在前
  238.                 clk = 0;                 //时钟线拿低开始写数据
  239.                 io = add & 0x01;            
  240.                 add >>= 1;                 //把地址右移一位
  241.                 clk = 1;                 //时钟线拿高
  242.         }               
  243.         for(i=0;i<8;i++)
  244.         {
  245.                 clk = 0;                 //时钟线拿低开始读数据
  246.                 value >>= 1;
  247.                 if(io == 1)
  248.                         value |= 0x80;
  249.                 clk = 1;                 //时钟线拿高
  250.         }
  251.         rst = 0;                         //复位线合低
  252.         clk = 0;
  253.         io = 0;
  254.         return value;                 //返回读出来的数据
  255. }



  256. /*************把要的时间 年月日 都读出来***************/
  257. void read_time()
  258. {
  259.         miao = read_ds1302(read_add[0]);        //读秒
  260.         fen  = read_ds1302(read_add[1]);        //读分
  261.         shi  = read_ds1302(read_add[2]);        //读时
  262.         ri   = read_ds1302(read_add[3]);        //读日
  263.         yue  = read_ds1302(read_add[4]);        //读月
  264.         nian = read_ds1302(read_add[5]);        //读年
  265.         week = read_ds1302(read_add[6]);        //读星期
  266. }

  267. /*************把要写的时间 年月日 都写入ds1302里***************/
  268. void write_time()
  269. {
  270.         write_ds1302(0x8e,0x00);                        //打开写保护
  271.         write_ds1302(write_add[0],miao);        //写秒
  272.         write_ds1302(write_add[1],fen);                //写分
  273.         write_ds1302(write_add[2],shi);                //写时
  274.         write_ds1302(write_add[3],ri);                //写日
  275.         write_ds1302(write_add[4],yue);                //写月
  276.         write_ds1302(write_add[5],nian);        //写星期
  277.         write_ds1302(write_add[6],week);        //写年
  278.         write_ds1302(0x8e,0x80);                        //关闭写保护
  279. }

  280. /*************把数据保存到ds1302 RAM中**0-31*************/
  281. void write_ds1302ram(uchar add,uchar dat)
  282. {
  283.         add <<= 1;     //地址是从第二位开始的
  284.         add &= 0xfe;   //把最低位清零  是写的命令
  285.         add |= 0xc0;   //地址最高两位为 1  
  286.         write_ds1302(0x8e,0x00);
  287.         write_ds1302(add,dat);        
  288.         write_ds1302(0x8e,0x80);
  289. }

  290. /*************把数据从ds1302 RAM读出来**0-31*************/
  291. uchar read_ds1302ram(uchar add)
  292. {
  293.         add <<= 1;     //地址是从第二位开始的
  294.         add |= 0x01;   //把最高位置1  是读命令
  295.         add |= 0xc0;   //地址最高两位为 1  
  296.         return(read_ds1302(add));        
  297. }




  298. /*************初始化ds1302时间***************/
  299. void init_ds1302()
  300. {
  301.         uchar i;
  302.         rst = 0;        //第一次读写数据时要把IO品拿低
  303.         clk = 0;
  304.         io = 0;
  305.         i = read_ds1302ram(30);   
  306.         if(i != 3)
  307.         {        
  308.                 i = 3;
  309.                 write_ds1302ram(30,i);
  310.                 write_ds1302(0x8e,0x00);                    //打开写保护
  311.                 for(i=0;i<7;i++)
  312.                         write_ds1302(write_add[i],init_ds[i]);        //把最高位值0 允许ds1302工作
  313.                 write_ds1302(0x8e,0x80);        //关写保护
  314.         }
  315.         write_sfm2(1,0,i);
  316. }

  317. void init_ds1302_io()
  318. {
  319.         rst = 0;        //第一次读写数据时要把IO品拿低
  320.         clk = 0;
  321.         io = 0;        
  322. }

  323. /*************定时器0初始化程序***************/
  324. void init_1602_ds1302()
  325. {
  326. //        write_sfm2_ds1302(2,3,nian);        
  327. //        write_sfm2_ds1302(2,6,yue);        
  328. //        write_sfm2_ds1302(2,9,ri);        
  329.         write_sfm2_ds1302(1,11,shi);        
  330.         write_sfm2_ds1302(1,14,fen);        
  331. //        write_sfm2_ds1302(1,14,miao);
  332. //        write_sfm1(1,14,week);               
  333. }

  334. /***********外部中断0初始化程序****************/
  335. void init_int0()
  336. {
  337.         EX0=1;                          //允许外部中断0中断
  338.         EA=1;                           //开总中断
  339.         IT0 = 1;                   //外部中断0负跳变中断
  340. }


  341. /*************定时器0初始化程序***************/
  342. void time_init()          //定时器0初始化程序
  343. {
  344.         EA   = 1;                   //开总中断
  345.         TMOD = 0X11;          //定时器0、工作方式1
  346.         ET0  = 1;                  //开定时器0中断
  347.         TR0  = 1;                  //允许定时器0定时
  348.         ET1  = 1;                  //开定时器1中断
  349.         TR1  = 1;                  //允许定时器1定时
  350. }


  351. /***********计算速度函数**************/
  352. void menu_dis()          //计算速度函数
  353. {
  354.         static uchar value;
  355.         static uchar times;
  356.         if(menu_1 == 0)
  357.         {        
  358.                 if(flag_1s == 1)   
  359.                 {        
  360.                         flag_1s = 0;
  361.                         times++;
  362.                         if(times>=2)
  363.                         {
  364.                                 times = 0;
  365.                                 shudu = (shudu+3.6*plu*(zhijing * 3.14))/2; //(带个小数点) km/h        
  366.                                 if(shudu>99) shudu=99;        //防止错误
  367.                                 juli_z += (plu*zhijing*3.14);           //总路程m
  368.                                 plu = 0;
  369.                         }
  370.                                          
  371.                         if(flag_en == 0)
  372.                         {
  373.                                 value ++;
  374.                                 if(value >= 3)        //2秒
  375.                                 {        
  376.                                         speed_km = 0;  //速度为0
  377.                                         shudu = (uint)speed_km;        
  378.                                         value = 0;                                
  379.                                 }
  380.                         }
  381.                         write_sfm2(1,3,shudu);               
  382.                         write_sfm4(2,3,juli_z);        
  383.                 }
  384.                 if((flag_en == 1))
  385.                 {        
  386.                         value = 0;               
  387.                         flag_en = 0;         
  388.                          //1s = 1 / 1000000us;          // 1m/s=0.001km除以1/3600h=3.6km/h                        
  389.                         f_hz = (t2_num * 65536.0 + TH11 * 256 + TL11) / 1000000 ;  //算出来就是秒
  390.                         t2_num = 0;        //把变量清零
  391.                         t1_num =0;
  392.                         TH11 = 0;
  393.                         TL11 = 0;                                          
  394. //                        speed_m =  (zhijing * 3.14) / f_hz ;        //算出来的是m/s
  395. //                        juli_z = (juli_z + (uint)speed_m) ;        //总路程m        
  396. //                        speed_km = speed_m * 3.6 *10 ;        //(带个小数点) km/h        
  397. //                    shudu = (uint)(speed_km+shudu)/2;
  398. //                        zong_lc += speed_m;
  399.                 }                                
  400.         }
  401. }

  402. /********************独立按键程序*****************/
  403. uchar key_can;         //按键值

  404. void key()         //独立按键程序
  405. {
  406.         static uchar key_new;
  407.         key_can = 20;                   //按键值还原
  408.         P3 |= 0x78;                     //对应的按键IO口输出为1
  409.         if((P3 & 0x78) != 0x78)                //按键按下
  410.         {
  411.                 delay_1ms(1);                     //按键消抖动
  412.                 if(((P3 & 0x78) != 0x78) && (key_new == 1))
  413.                 {                                                //确认是按键按下
  414.                         key_new = 0;
  415.                         switch(P3 & 0x78)
  416.                         {
  417.                                 case 0x70:  key_can = 4;  break;         //得到按键值
  418.                                 case 0x68:  key_can = 3;  break;         //得到按键值
  419.                                 case 0x58:  key_can = 2;  break;         //得到按键值
  420.                                 case 0x38:  key_can = 1;  break;         //得到按键值
  421.                         }
  422. //                        write_sfm2(1,0,key_can);                                 //显示按键值
  423.                 }                        
  424.         }
  425.         else
  426.                 key_new = 1;        
  427. }


  428. /**********************设置函数************************/
  429. void key_with()
  430. {
  431.         if(key_can == 1)        //设置键
  432.         {
  433.                 menu_1++;
  434.                 if(menu_1 == 1)          //设置时间
  435.                 {
  436.                         menu_2 = 1;
  437.                         write_string(1,0,"    :  :    W:  ");                        
  438.                         write_string(2,0," 20  -  -       ");        
  439.                 }
  440.                 if(menu_1 == 2)          //设置报警速度
  441.                 {
  442.                         menu_2 = 1;
  443.                         write_string(1,0,"set-sd:00km/h   ");                        
  444.                         write_string(2,0,"zlc:             ");        
  445.                 }
  446.                 menu_2 = 1;

  447.                 if(menu_1 > 2)    //回到正常显示
  448.                 {
  449.                         menu_1 = 0;
  450.                         write_guanbiao(1,2,0);          //关闭光标
  451.                         init_1602();      //1602初始化     //初始化液晶显示               
  452.                 }
  453.         }
  454.         if(key_can == 2)        //选择键
  455.         {
  456.                 if(menu_1 == 1)                  //设置时间
  457.                 {
  458.                         menu_2 ++;
  459.                         if(menu_2 > 7)
  460.                                 menu_2 = 1;
  461.                 }
  462.                 if(menu_1 == 2)                 //设置
  463.                 {
  464.                         menu_2 ++;
  465.                         if(menu_2 > 2)
  466.                                 menu_2 = 1;                                
  467.                 }

  468.         }
  469.         if(menu_1 == 1)
  470.         {
  471.                 if(menu_2 == 1)                  //设置时
  472.                 {
  473.                         if(key_can == 3)        //加
  474.                         {
  475.                                 shi+=0x01;
  476.                                 if((shi & 0x0f) >= 0x0a)
  477.                                         shi = (shi & 0xf0) + 0x10;
  478.                                 if(shi >= 0x24)
  479.                                         shi = 0;
  480.                         }               
  481.                         if(key_can == 4)        //减
  482.                         {
  483.                                 if(shi == 0x00)
  484.                                         shi = 0x24;
  485.                                 if((shi & 0x0f) == 0x00)
  486.                                         shi = (shi | 0x0a) - 0x10;
  487.                                 shi -- ;
  488.                         }                                          
  489.                 }
  490.                 if(menu_2 == 2)                  //设置分
  491.                 {
  492.                         if(key_can == 3)        //加
  493.                         {
  494.                                 fen+=0x01;
  495.                                 if((fen & 0x0f) >= 0x0a)
  496.                                         fen = (fen & 0xf0) + 0x10;
  497.                                 if(fen >= 0x60)
  498.                                         fen = 0;
  499.                         }               
  500.                         if(key_can == 4)        //减         
  501.                         {
  502.                                 if(fen == 0x00)
  503.                                         fen = 0x5a;
  504.                                 if((fen & 0x0f) == 0x00)
  505.                                         fen = (fen | 0x0a) - 0x10;
  506.                                 fen -- ;
  507.                         }        
  508.                 }
  509.                 if(menu_2 == 3)                  //设置秒
  510.                 {
  511.                         if(key_can == 3)        //加
  512.                         {
  513.                                 miao+=0x01;
  514.                                 if((miao & 0x0f) >= 0x0a)
  515.                                         miao = (miao & 0xf0) + 0x10;
  516.                                 if(miao >= 0x60)
  517.                                         miao = 0;
  518.                         }        
  519.                         if(key_can == 4)        //减         
  520.                         {
  521.                                 if(miao == 0x00)
  522.                                         miao = 0x5a;
  523.                                 if((miao & 0x0f) == 0x00)
  524.                                         miao = (miao | 0x0a) - 0x10;
  525.                                 miao -- ;                        
  526.                         }
  527.                 }
  528.                 if(menu_2 == 4)                  //设置星期
  529.                 {
  530.                         if(key_can == 3)        //加
  531.                         {
  532.                             week+=0x01;
  533.                                 if((week & 0x0f) >= 0x0a)
  534.                                         week = (week & 0xf0) + 0x10;
  535.                                 if(week >= 0x08)
  536.                                         week = 1;
  537.                         }               
  538.                         if(key_can == 4)        //减         
  539.                         {
  540.                                 if(week == 0x01)
  541.                                         week = 0x08;
  542.                                 if((week & 0x0f) == 0x00)
  543.                                         week = (week | 0x0a) - 0x10;
  544.                                 week -- ;
  545.                         }        
  546.                 }
  547.                 if(menu_2 == 5)                  //设置年
  548.                 {
  549.                         if(key_can == 3)        //加
  550.                         {
  551.                             nian+=0x01;
  552.                                 if((nian & 0x0f) >= 0x0a)
  553.                                         nian = (nian & 0xf0) + 0x10;
  554.                                 if(nian >= 0x9a)
  555.                                         nian = 1;
  556.                         }               
  557.                         if(key_can == 4)        //减         
  558.                         {
  559.                                 if(nian == 0x01)
  560.                                         nian = 0x9a;
  561.                                 if((nian & 0x0f) == 0x00)
  562.                                         nian = (nian | 0x0a) - 0x10;
  563.                                 nian -- ;               
  564.                         }        
  565.                 }
  566.                 if(menu_2 == 6)                  //设置月
  567.                 {
  568.                         if(key_can == 3)        //加
  569.                         {
  570.                             yue+=0x01;
  571.                                 if((yue & 0x0f) >= 0x0a)
  572.                                         yue = (yue & 0xf0) + 0x10;
  573.                                 if(yue >= 0x13)
  574.                                         yue = 1;
  575.                         }               
  576.                         if(key_can == 4)        //减         
  577.                         {
  578.                                 if(yue == 0x01)
  579.                                         yue = 0x13;
  580.                                 if((yue & 0x0f) == 0x00)
  581.                                         yue = (yue | 0x0a) - 0x10;
  582.                                 yue -- ;                                       
  583.                         }        
  584.                 }
  585.                 if(menu_2 == 7)                  //设置日
  586.                 {
  587.                         if(key_can == 3)        //加
  588.                         {
  589.                     ri+=0x01;
  590.                         if((ri & 0x0f) >= 0x0a)
  591.                                 ri = (ri & 0xf0) + 0x10;
  592.                         if(ri >= 0x32)
  593.                                 ri = 0;                        
  594.                         }               
  595.                         if(key_can == 4)        //减         
  596.                         {
  597.                                 if(ri == 0x01)
  598.                                         ri = 0x32;
  599.                                 if((ri & 0x0f) == 0x00)
  600.                                         ri = (ri | 0x0a) - 0x10;
  601.                                 ri -- ;                        
  602.                         }        
  603.                 }
  604.                 write_sfm2_ds1302(1,2,shi);           //显示时
  605.                 write_sfm2_ds1302(1,5,fen);           //显示分
  606.                 write_sfm2_ds1302(1,8,miao);           //显示秒
  607.                 write_sfm1(1,14,week);           //显示星期                                       
  608.                 write_sfm2_ds1302(2,3,nian);           //显示年
  609.                 write_sfm2_ds1302(2,6,yue);           //显示月
  610.                 write_sfm2_ds1302(2,9,ri);           //显示日
  611.                 switch(menu_2)           // 光标显示
  612.                 {
  613.                         case 1:  write_guanbiao(1,2,1);  break;
  614.                         case 2:  write_guanbiao(1,5,1);  break;
  615.                         case 3:  write_guanbiao(1,8,1);  break;
  616.                         case 4:  write_guanbiao(1,14,1); break;
  617.                         case 5:  write_guanbiao(2,3,1);  break;
  618.                         case 6:  write_guanbiao(2,6,1);  break;
  619.                         case 7:  write_guanbiao(2,9,1);  break;
  620.                 }
  621.                 write_time();           //把时间写进去
  622.         }        

  623.         if(menu_1 == 2)
  624.         {               
  625.                 if(menu_2 == 1)                  //设置速度
  626.                 {
  627.                         if(key_can == 3)        //加
  628.                         {
  629.                                 bj_shudu++;
  630.                                 if(bj_shudu >= 99)        //速度设置++
  631.                                         bj_shudu = 99;
  632.                         }        
  633.                         if(key_can == 4)        //减         
  634.                         {
  635.                                 if(bj_shudu != 0)        //速度设置--
  636.                                         bj_shudu -- ;                        
  637.                         }
  638.                 }        
  639.                 if(menu_2 == 2)                  //把总量程清零
  640.                 {
  641.                         if(key_can == 3)        
  642.                         {
  643.                                 juli_z= 0;                  //清零
  644.                         }        
  645.                         if(key_can == 4)                  
  646.                         {
  647.                                 juli_z= 0;                        
  648.                         }
  649.                 }        
  650.                 write_sfm2(1,7,bj_shudu);   //显示报警速度
  651.                 write_sfm7(2,4,juli_z);   //显示
  652.                
  653.                 switch(menu_2)           // 光标显示
  654.                 {
  655.                         case 1:  write_guanbiao(1,6,1);  break;
  656.                         case 2:  write_guanbiao(2,3,1);  break;
  657.                 }
  658.         }
  659. }

  660. /****************报警函数***************/
  661. void clock_h_l()
  662. {
  663.         static uchar value;           
  664.         if((shudu >= bj_shudu))
  665.         {
  666.                 value ++;  //消除实际距离在设定距离左右变化时的干扰
  667.                 {
  668.                         beep = ~beep;           //蜂鸣器报警                        
  669.                 }        
  670.         }
  671.         else
  672.         {
  673.                 beep = 1;        
  674.         }                        
  675. }

  676. /******************主程序**********************/           
  677. void main()
  678. {
  679.         beep = 0;                  //上电蜂鸣器响一下
  680.         delay_1ms(200) ;
  681.         beep = 1;
  682.         P0 = P1 = P2 = P3 = 0xff;  //IO口初始为电平
  683.         init_ds1302_io();           //初始化ds1302io接口
  684.         init_ds1302();
  685.         init_1602();      //1602初始化
  686.         init_int0();
  687.         time_init();          //定时器0初始化程序

  688.         while(1)
  689.         {         //  shudu = 11;
  690.                 key();                         //按键程序
  691.                 if(key_can < 10)
  692.                 {
  693.                         key_with();        //  按键处理

  694.                 }
  695.                 if(flag_200ms == 1)          //定时200ms标志
  696.                 {
  697.                         flag_200ms = 0;
  698.                         read_time();                  //读时间
  699.                         if(menu_1 == 0)
  700.                                 init_1602_ds1302();   //显示时钟
  701.                         clock_h_l();        //报警函数
  702.                 }
  703.                 menu_dis();          //计算速度函数
  704.         }
  705. }


  706. /*********************外部中断0中断服务程序************************/
  707. void int0() interrupt 0
  708. {
  709.         static uchar value;
  710.         plu++;
  711.         switch(value)
  712.         {
  713.                 case 0:
  714.                         t1_num = 0;                 //第一次就把变量清零
  715.                         TH1 = 0;
  716.                         TL1 = 0;
  717.                         value = 1;
  718.                         break;
  719.                 case 1:
  720.                                 t2_num = t1_num;  //保存
  721.                                 TH11 = TH1;
  722.                                 TL11 = TL1;
  723.                                 if(flag_en==0)
  724.                                 {
  725.                                         value=0;
  726.                                 }
  727.                                 flag_en = 1;
  728.                                 break;
  729.         }               
  730. }

  731. /*************定时器0中断服务程序***************/
  732. void time0_int() interrupt 1
  733. {        
  734.         static uchar value;
  735.         TH0 = 0x3c;
  736.         TL0 = 0xb0;     // 50ms
  737.         value++;
  738.         if(value % 4 == 0)
  739.                 flag_200ms = 1;

  740.         if(value >= 20)  //1秒   才是一秒钟的速度
  741.         {
  742.                 value = 0;
  743.                 flag_1s = 1;
  744.         }
  745. }

  746. /*************定时器1中断服务程序***************/
  747. void time1_int() interrupt 3
  748. {
  749.         t1_num++;
  750. }
复制代码


评分

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

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏6 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:140183 发表于 2020-10-22 05:25 | 只看该作者
太好啦!感谢分享。每天骑行,有空也需要做一个。
回复

使用道具 举报

板凳
ID:844820 发表于 2020-11-20 13:49 | 只看该作者
为什么是这个样子呢

JEW4ID9$RLUAEGVOYCIFRW0.png (88.23 KB, 下载次数: 45)

JEW4ID9$RLUAEGVOYCIFRW0.png
回复

使用道具 举报

地板
ID:850748 发表于 2020-12-3 16:36 | 只看该作者
873113058 发表于 2020-11-20 13:49
为什么是这个样子呢

你这个是从哪弄得呀
回复

使用道具 举报

5#
ID:88256 发表于 2020-12-3 20:59 | 只看该作者
我正考虑做一个类似的,请问楼主这种霍尔元件检测那种LED广告屏固定磁柱可靠距离有多远?
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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