标题: 看不懂这个单片机程序的中断和计数初值 [打印本页]
作者: heicad    时间: 2016-3-11 22:20
标题: 看不懂这个单片机程序的中断和计数初值
本帖最后由 heicad 于 2016-3-11 22:22 编辑

下面是一个51单片机的程序：中断和计数初值这看不懂
  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. uint num=0;                           //外部中断次数
  5. uchar num1=0;
  6. uint Speed_dat=0;
  7. uint Total_Dis=0;
  8. uchar Beep_speed=40;
  9. sbit KEY1=P3^5;
  10. sbit KEY2=P3^6;
  11. sbit KEY3=P3^7;

  13. void delayms(uint xms)
  14. {
  15.         uint i,j;
  16.         for(i=xms;i>0;i--)
  17.                 for(j=110;j>0;j--);
  18. }
  19. #include"LCD1602.H"
  20. #include"AT24C02.H"
  21. void keyscan()
  22. {
  23.         if(!KEY1)
  24.         {
  25.                 delayms(5);
  26.                 if(!KEY1)
  27.                 {
  28.                         if(Beep_speed<255)
  29.                         Beep_speed++;
  30.                         while(!KEY1);
  31.                 }
  32.         }        

  34.         else if(!KEY2)
  35.         {
  36.                 delayms(5);
  37.                 if(!KEY2)
  38.                 {
  39.                         if(Beep_speed>0)
  40.                         Beep_speed--;
  41.                         while(!KEY2);
  42.                 }
  43.         }        

  45.         else if(!KEY3)
  46.         {
  47.                 delayms(5);
  48.                 if(!KEY3)
  49.                 {
  50.                         Write_AT24C02_Byte(0,0);
  51.                         Write_AT24C02_Byte(1,0);
  52.                         Total_Dis=0;
  53.                         dis_Mileage();
  54.                         while(!KEY3);
  55.                 }
  56.         }        
  57. }

  59. void main()
  60. {
  61.         uchar dat=0;
  62.         float M_dat=0.0;
  63.         init_1602();
  64.         Init_AT24C02();
  65.         dat=Read_AT24C02_Random(0);
  66.         Total_Dis=dat*256+Read_AT24C02_Random(1);
  67.         dis_Mileage();
  68.         TMOD=0X01;
  69.         TH0=(65536-1000)/256;
  70.         TL0=(65536-1000)%256;
  71.         ET0=1;
  72.         TR0=1;
  73.         IT0=1;         //边沿触发中断
  74.         EX0=1;
  75.         EA=1;
  76.         while(1)
  77.         {
  78.                 if(num1>99)
  79.                 {
  80.                         num1=0;
  81.                         M_dat+=(float)(Cur_Speed/3.60);                        //每0.1s走的米数
  82.                 }
  83.                 if(M_dat>1000.0)          //路程每增加100m储存一次
  84.                 {
  85.                         M_dat-=1000.0;
  86.                         Total_Dis+=1;
  87.                         Write_AT24C02_Byte(0,Total_Dis/256);
  88.                         Write_AT24C02_Byte(1,Total_Dis%256);
  89.                         dis_Mileage();        
  90.                 }
  91.                 display();
  92.                 keyscan();        
  93.         }
  94. }

  96. void T0_time() interrupt 1                 //定时器0
  97. {
  98.         TH0=(65536-1000)/256;
  99.         TL0=(65536-1000)%256;
  100.         if(num<500)
  101.         num++;
  102.         else
  103.         Speed_dat=0;
  104.         if(num1<100)
  105.         num1++;               
  106. }

  108. void ex_0() interrupt 0           //外部中断0
  109. {
  110.         Speed_dat=(500/num);
  111.     num=0;
  112. }
  113. #define uchar unsigned char
  114. #define uint unsigned int           
  115. sbit EN=P2^7;
  116. sbit RS=P2^5;
  117. sbit RW=P2^6;
  118. sbit BEEP=P2^0;
  119. sbit LED1=P1^2;
  120. sbit LED2=P1^3;
  121. uchar LCD1602_Table[]="0123456789";
  122. //LCD1602显示标尺     //0123456789abcdef
  123. uchar code DIS_TAB1[]={" Speed:---Km/h  "};         
  124. uchar code DIS_TAB2[]={"M:     Km---Km/h"};           
  125. uint sum_dat=0;
  126. uchar Cur_Speed=0;
  127. extern uint Speed_dat;
  128. extern uint Total_Dis;
  129. extern void delayms(uint xms);
  130. void WRITE_LCD1602_DAT(uchar date)
  131. {
  132.         EN=0;
  133.         RS=1;
  134.         P0=date;
  135.         EN=0;
  136.         delayms(5);
  137.         EN=1;
  138. }
  139. void WRITE_LCD1602_COM(uchar date)
  140. {
  141.         EN=0;
  142.         RS=0;
  143.         P0=date;
  144.         EN=0;
  145.         delayms(5);
  146.         EN=1;
  147. }
  148. void init_1602()
  149. {
  150.          unsigned char i;
  151.         RW=0;
  152.         WRITE_LCD1602_COM(0x38);
  153.         WRITE_LCD1602_COM(0x0c);
  154.         WRITE_LCD1602_COM(0x06);
  155.         WRITE_LCD1602_COM(0x01);
  156.         WRITE_LCD1602_COM(0x80);
  157.         for(i=0;i<16;i++)
  158.         WRITE_LCD1602_DAT(DIS_TAB1[i]);
  159.         WRITE_LCD1602_COM(0x80+0x40);
  160.         for(i=0;i<16;i++)
  161.         WRITE_LCD1602_DAT(DIS_TAB2[i]);
  162. }

  164. void display()
  165. {        
  166.         static uint dat=0;
  167.         static uchar i=0;
  168.         if(i<6)
  169.         {
  170.                 i++;
  171.                 sum_dat+=Speed_dat;        
  172.         }
  173.         else
  174.         {
  175.                 i=0;
  176.                 dat=sum_dat/10;
  177.                 sum_dat=0;
  178.         }
  179.         Cur_Speed=dat;
  180.         WRITE_LCD1602_COM(0x80+7);
  181.         if(dat/100>0)        
  182.         WRITE_LCD1602_DAT(LCD1602_Table[dat%1000/100]);
  183.         else
  184.         WRITE_LCD1602_DAT(' ');
  185.         if(dat/10>0)        
  186.         WRITE_LCD1602_DAT(LCD1602_Table[dat%100/10]);
  187.         else
  188.         WRITE_LCD1602_DAT(' ');
  189.         WRITE_LCD1602_DAT(LCD1602_Table[dat%10]);

  191.         WRITE_LCD1602_COM(0x80+9+0x40);
  192.         if(Beep_speed/100>0)        
  193.         WRITE_LCD1602_DAT(LCD1602_Table[Beep_speed%1000/100]);
  194.         else
  195.         WRITE_LCD1602_DAT(' ');
  196.         if(Beep_speed/10>0)        
  197.         WRITE_LCD1602_DAT(LCD1602_Table[Beep_speed%100/10]);
  198.         else
  199.         WRITE_LCD1602_DAT(' ');
  200.         WRITE_LCD1602_DAT(LCD1602_Table[Beep_speed%10]);

  202.         if(dat>Beep_speed)
  203.         {
  204.                 if(i<3)
  205.                 BEEP=0;
  206.                 else
  207.                 BEEP=1;
  208.                 LED1=0;
  209.                 LED2=1;
  210.         }
  211.         else
  212.         {
  213.                 BEEP=1;        
  214.                 LED1=1;
  215.                 LED2=0;
  216.         }
  217.         
  218. }

  220. void dis_Mileage()
  221. {
  222.         WRITE_LCD1602_COM(0x80+0x40+2);
  223.         if(Total_Dis/1000>0)
  224.         WRITE_LCD1602_DAT(LCD1602_Table[Total_Dis%10000/1000]);
  225.         else
  226.         WRITE_LCD1602_DAT(' ');
  227.         if(Total_Dis/100>0)
  228.         WRITE_LCD1602_DAT(LCD1602_Table[Total_Dis%1000/100]);
  229.         else
  230.         WRITE_LCD1602_DAT(' ');
  231.         WRITE_LCD1602_DAT(LCD1602_Table[Total_Dis%100/10]);
  232.         WRITE_LCD1602_DAT('.');
  233.         WRITE_LCD1602_DAT(LCD1602_Table[Total_Dis%10]);
  234. }


  237. #include<intrins.h>
  238. #define        AT24C02_OP_READ        0xa1                // AT24C02器件地址以及读取操作
  239. #define        AT24C02_OP_WRITE 0xa0                // AT24C02器件地址以及写入操作
  240. //#define        AT24C02_MAX_ADDR 0xff                // AT24C02最大地址
  241. //unsigned char code dis_code[]={0x7e,0xbd,0xdb,0x7e,0xdb,0xbd,0x7e,0xff};// 写入到AT24C02的数据串
  242. sbit AT24C02_SDA=P1^1;
  243. sbit AT24C02_SCL=P1^0;
  244. //sbit AT24C02_WP=P3^3;           //写保护  “=0”读写  “=1” 只读
  245. /*****************延时子程序***********************/
  246. void Delay_1ms(unsigned int xms)
  247. {
  248.            unsigned int i,j;
  249.            for(i=xms;i>0;i--)
  250.                    for(j=122;j>0;j--);
  251. }
  252. /*****************24C02初始化子程序***********************/
  253. void Init_AT24C02()
  254. {
  255.          AT24C02_SDA=1;   //总线空闲时，因各设备都是集电极或漏极开路，上拉电阻使SDA和SCL线都保持高电平。
  256. //        AT24C02_WP=1;
  257.          AT24C02_SCL=1;
  258.          _nop_();
  259.          _nop_();
  260.          _nop_();
  261.          _nop_();
  262. }
  263. /*****************24C02起始信号子程序***********************/
  264. void AT24C02_Start()

  266. {
  267.         AT24C02_SDA=1;
  268.         _nop_();
  269.         _nop_();
  270.         AT24C02_SCL=1;
  271.         _nop_();
  272.         _nop_();
  273.         AT24C02_SDA=0;
  274.         _nop_();
  275.         _nop_();
  276.         _nop_();
  277.         _nop_();
  278.         AT24C02_SCL=0;
  279. }
  280. /*****************24C02停止信号子程序***********************/
  281. void AT24C02_Stop()
  282. {
  283.         AT24C02_SDA=0;
  284.         _nop_();
  285.         _nop_();
  286.         AT24C02_SCL=1;
  287.         _nop_();
  288.         _nop_();
  289.         _nop_();
  290.         _nop_();
  291.         AT24C02_SDA=1;
  292.         _nop_();
  293.         _nop_();
  294. }
  295. /*****************24C02应答子程序***********************/
  296. void AT24C02_ACK()
  297. {
  298.         AT24C02_SDA=1;                        // 读取应答
  299.         _nop_();
  300.         _nop_();
  301.         AT24C02_SCL=1;
  302.         _nop_();
  303.         _nop_();
  304.         _nop_();
  305.         _nop_();
  306.         while(AT24C02_SDA);                //等待应答信号
  307.         AT24C02_SCL=0;
  308.         _nop_();
  309.         _nop_();
  310. }
  311. /*****************读出24C02数据子程序***********************/
  312. unsigned char Read_AT24C02_DATA()
  313. {
  314.         unsigned char i,read_data;
  315.         for(i=0;i<8;i++)
  316.         {
  317.                 AT24C02_SCL=1;
  318.                 _nop_();_nop_();_nop_();_nop_();               
  319.                 read_data<<=1;                                                           //从高位到底位
  320.                 read_data|=(unsigned char)AT24C02_SDA;
  321.                 AT24C02_SCL=0;
  322.                 _nop_();_nop_();_nop_();_nop_();
  323.         }
  324.         return(read_data);
  325. }
  326. /*****************写入24C02数据子程序***********************/
  327. void Write_AT24C02_DATA(unsigned char write_data)
  328. {
  329.         unsigned char i;
  330.         for(i=0;i<8;i++)                // 循环移入8个位
  331.         {
  332.                 AT24C02_SDA=(bit)(write_data&0x80);
  333.                 _nop_();
  334.                 AT24C02_SCL=1;
  335.                 _nop_();
  336.                 _nop_();
  337.                 AT24C02_SCL=0;
  338.                 write_data<<=1;
  339.         }
  340. }

  342. /*****************字节写入24C02数据子程序***********************/
  343. void Write_AT24C02_Byte(unsigned char addr, unsigned char write_data) // 在指定地址addr处写入数据write_data
  344. {
  345.         AT24C02_Start();                                                //发起始命令
  346.         Write_AT24C02_DATA(AT24C02_OP_WRITE);        //从机地址写命令
  347.         AT24C02_ACK();
  348.         Write_AT24C02_DATA(addr);                                 //发送AT24C02的字节地址
  349.         AT24C02_ACK();
  350.         Write_AT24C02_DATA(write_data);                          //发送数据到被寻址的存储单元
  351.         AT24C02_ACK();
  352.         AT24C02_Stop();                                                        //停止信号
  353.         Delay_1ms(10);                                                        //延时等待AT24C02内部数据的擦写
  354. }

  356. unsigned char Read_AT24C02_Current()
  357. // 在当前地址读取
  358. {
  359.         unsigned char read_data;
  360.         AT24C02_Start();
  361.         Write_AT24C02_DATA(AT24C02_OP_READ);
  362.         AT24C02_ACK();
  363.         read_data = Read_AT24C02_DATA();
  364.         AT24C02_Stop();
  365.         return read_data;
  366. }

  368. unsigned char Read_AT24C02_Random(unsigned char addr)
  369. // 在指定地址读取
  370. {
  371.         AT24C02_Start();
  372.         Write_AT24C02_DATA(AT24C02_OP_WRITE);
  373.         AT24C02_ACK();
  374.         Write_AT24C02_DATA(addr);
  375.         AT24C02_ACK();
  376.         return(Read_AT24C02_Current());
  377. }
复制代码


作者: heicad    时间: 2016-3-11 22:20
如果这个看不懂，你需要再继续从基础学起。

简单地说如果不给定时器设定初值，他就从0开始计数，如果给他一个初值，就从初值基础上计数，定时器计数满后，会产生中断。定时/计数器计数到0FFFFH（16进制）也就是65536计满，（65536-1000）意思是从64536开始计数，再加1000个机器周期，计数器满，产生中断。至于（65536-1000）/256，就是将256的倍数装进定时器的高位寄存器，（65536-1000）%256，就是将256的余数装进定时器的低位寄存器，因为51单片机是8位的，所以低位只能计数到255，再加1便产生进位。进到高8位中。如果你手工计算好以后，将倍数和余数分别赋值给TH、TL也是一样。
作者: heicad    时间: 2016-3-11 22:21
简单地说如果不给定时器设定初值，他就从0开始计数，如果给他一个初值，就从初值基础上计数，定时器计数满后，会产生中断。定时/计数器计数到0FFFFH（16进制）也就是65536计满，（65536-1000）意思是从64536开始计数，再加1000个机器周期，计数器满，产生中断。至于（65536-1000）/256，就是将256的倍数装进定时器的高位寄存器，（65536-1000）%256，就是将256的余数装进定时器的低位寄存器，因为51单片机是8位的，所以低位只能计数到255，再加1便产生进位。进到高8位中。如果你手工计算好以后，将倍数和余数分别赋值给TH、TL也是一样。
作者: heicad    时间: 2016-3-11 22:21
heicad 发表于 2016-3-11 22:20
如果这个看不懂，你需要再继续从基础学起。

简单地说如果不给定时器设定初值，他就从0开始计数，如果给 ...

那这个是测速，然后显示出速度与里程，但我看不出它的半径什么的设在哪里，能帮解释一下吗，中断那个我问了同学，了解了不少。
作者: 735993584@qq.co    时间: 2017-4-3 21:27
同学，你好啊，你看懂了没，求解释。跟你一样的问题



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