51单片机-AT24C02-实行2-秒表实行（可参考上一节）

种地  论坛元老 | 2024-9-17 08:17:37 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1093|帖子 1093|积分 3279

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
利用定时器去对按键和数码管进行扫描(Whappy)
main.c
  1. #include <REGX52.H>
  2. #include "LCD1602.h"
  3. #include "AT24C02.h"
  4. #include "Delay.h"
  5. #include "Timer0.h"
  6. #include "Nixie.h"
  7. #include "Key.h"
  10. unsigned char KeyNum;
  11. unsigned char Min,Sec,MiniSec;
  12. unsigned char RunFlag;
  14. void main()
  15. {
  16.         Timer0_Init(); //初始化定时器
  17.        
  18.         while(1)
  19.         {
  20.                 KeyNum = Key();
  21.                
  22.                 if(KeyNum == 1)
  23.                 {
  24.                         RunFlag = !RunFlag;
  25.                 }
  26.                 Nixie_SetBuf(1,Min/10);
  27.                 Nixie_SetBuf(2,Min%10);
  28.                 Nixie_SetBuf(3,11);
  29.                 Nixie_SetBuf(4,Sec/10);
  30.                 Nixie_SetBuf(5,Sec%10);
  31.                 Nixie_SetBuf(6,11);
  32.                 Nixie_SetBuf(7,MiniSec/10);
  33.                 Nixie_SetBuf(8,MiniSec%10);
  34.                
  35.                                
  36.         }
  37.         Delay(1000);
  38. }
  40. void Sec_Loop(void)
  41. {
  42.         if(RunFlag)
  43.         {
  44.                 MiniSec++;
  45.                 if(MiniSec >= 100)
  46.                 {
  47.                         MiniSec = 0;
  48.                         Sec++;
  49.                         if(Sec >= 60)
  50.                         {
  51.                                 Sec = 0;
  52.                                 Min++;
  53.                                 if(Min >= 60)
  54.                                 {
  55.                                         Min = 0;
  56.                                 }
  57.                         }
  58.                 }
  60.                 }
  61.        
  62. }
  65. void Timer0_Rountine(void)  interrupt 1
  66. {
  67.         static unsigned int T0Count1,T0Count2,T0Count3;  //Timer0_Rountine(void) 函数结束之后T0Count保留其原来的值
  68.        
  69.         TL0 = 0x66;                //设置定时初值
  70.         TH0 = 0xFC;                //设置定时初值
  71.        
  72.         T0Count1++;
  73.         if(T0Count1 >= 20)
  74.         {
  75.                 T0Count1 = 0;
  76.                 Key_Loop();
  77.         }
  78.        
  79.         T0Count2++;
  80.         if(T0Count2 >= 2)
  81.         {
  82.                 T0Count2 = 0;
  83.                 Nixie_Loop();
  84.         }       
  85.        
  86.         T0Count3++;
  87.         if(T0Count3 >= 10)
  88.         {
  89.                 T0Count3 = 0;
  90.                 Sec_Loop();
  91.         }       
  92. }
复制代码
  1. #include <REGX52.H>
  2. #include "Timer0.h"
  3. #include "Key.h"
  4. #include "Nixie.h"
  5. #include "Delay.h"
  6. #include "AT24C02.h"
  8. unsigned char KeyNum;
  9. unsigned char Min,Sec,MiniSec;
  10. unsigned char RunFlag;
  12. void main()
  13. {
  14.         Timer0_Init();
  15.         while(1)
  16.         {
  17.                 KeyNum=Key();
  18.                 if(KeyNum==1)                        //K1按键按下
  19.                 {
  20.                         RunFlag=!RunFlag;        //启动标志位翻转
  21.                 }
  22.                 if(KeyNum==2)                        //K2按键按下
  23.                 {
  24.                         Min=0;                                //分秒清0
  25.                         Sec=0;
  26.                         MiniSec=0;
  27.                 }
  28.                 if(KeyNum==3)                        //K3按键按下
  29.                 {
  30.                         AT24C02_WriteByte(0,Min);        //将分秒写入AT24C02
  31.                         Delay(5);
  32.                         AT24C02_WriteByte(1,Sec);
  33.                         Delay(5);
  34.                         AT24C02_WriteByte(2,MiniSec);
  35.                         Delay(5);
  36.                 }
  37.                 if(KeyNum==4)                        //K4按键按下
  38.                 {
  39.                         Min=AT24C02_ReadByte(0);        //读出AT24C02数据
  40.                         Sec=AT24C02_ReadByte(1);
  41.                         MiniSec=AT24C02_ReadByte(2);
  42.                 }
  43.                 Nixie_SetBuf(1,Min/10);        //设置显示缓存，显示数据
  44.                 Nixie_SetBuf(2,Min%10);
  45.                 Nixie_SetBuf(3,11);
  46.                 Nixie_SetBuf(4,Sec/10);
  47.                 Nixie_SetBuf(5,Sec%10);
  48.                 Nixie_SetBuf(6,11);
  49.                 Nixie_SetBuf(7,MiniSec/10);
  50.                 Nixie_SetBuf(8,MiniSec%10);
  51.         }
  52. }
  54. /**
  55.   * @brief  秒表驱动函数，在中断中调用
  56.   * @param  无
  57.   * @retval 无
  58.   */
  59. void Sec_Loop(void)
  60. {
  61.         if(RunFlag)
  62.         {
  63.                 MiniSec++;
  64.                 if(MiniSec>=100)
  65.                 {
  66.                         MiniSec=0;
  67.                         Sec++;
  68.                         if(Sec>=60)
  69.                         {
  70.                                 Sec=0;
  71.                                 Min++;
  72.                                 if(Min>=60)
  73.                                 {
  74.                                         Min=0;
  75.                                 }
  76.                         }
  77.                 }
  78.         }
  79. }
  81. void Timer0_Routine() interrupt 1
  82. {
  83.         static unsigned int T0Count1,T0Count2,T0Count3;
  84.         TL0 = 0x18;                //设置定时初值
  85.         TH0 = 0xFC;                //设置定时初值
  86.         T0Count1++;
  87.         if(T0Count1>=20)
  88.         {
  89.                 T0Count1=0;
  90.                 Key_Loop();        //20ms调用一次按键驱动函数
  91.         }
  92.         T0Count2++;
  93.         if(T0Count2>=2)
  94.         {
  95.                 T0Count2=0;
  96.                 Nixie_Loop();//2ms调用一次数码管驱动函数
  97.         }
  98.         T0Count3++;
  99.         if(T0Count3>=10)
  100.         {
  101.                 T0Count3=0;
  102.                 Sec_Loop();        //10ms调用一次数秒表驱动函数
  103.         }
  104. }
复制代码
AT24C02.c
  1. #include <REGX52.H>
  2. #include "IIC.h"
  4. #define AT24C02_ADDRESS 0XA0 //1010 0000 前四位AT24C02地址不变,最后一位决定是写还是读 1:读,即接收 0:写,即发送
  7. //仿照帧格式去写(可参考上一节IIC时序介绍)
  8. //字节写：在WORD ADDRESS处写入数据DATA
  9. void AT24C02_WriteByte(unsigned char WordAddress,Data)
  10. {
  12.         IIC_Start();  //起始信号
  13.         IIC_SendByte(AT24C02_ADDRESS); //发送从机地址和写操作
  14.         IIC_ReceiveAck();  //接收应答位
  15.         IIC_SendByte(WordAddress); //字地址:指定在WORD ADDRESS处写入数据DATA
  16.         IIC_ReceiveAck();  //接收应答位
  17.         IIC_SendByte(Data); //写入数据到WordAddress中
  18.         IIC_ReceiveAck(); //接收应答位
  19.         IIC_Stop();//结束信号
  20.        
  21. }
  25. //Ack : 0:表示应答 1:表示非应答
  26. //随机读：读出在WORD ADDRESS处的数据DATA
  27. unsigned char AT24C02_ReadByte(unsigned char WordAddress)
  28. {
  29.         unsigned char Data;
  30.        
  31.         //写操作,就是先找到要通信的从机
  32.         IIC_Start();  //起始信号
  33.         IIC_SendByte(AT24C02_ADDRESS); //发送从机地址和写操作
  34.         IIC_ReceiveAck();  //接收应答位
  35.         IIC_SendByte(WordAddress); //字地址:指定在WORD ADDRESS处写入数据DATA
  36.         IIC_ReceiveAck();  //接收应答位
  37.        
  38.         //找到对应的从机之后,开始接收从机发过来的数据
  39.         IIC_Start();  //起始信号
  40.         IIC_SendByte(AT24C02_ADDRESS | 0X01); //发送从机地址和读操作
  41.         IIC_ReceiveAck();  //接收应答位
  42.         Data = IIC_ReceiveByte();  //接收一个字节的数据
  43.         IIC_SendAck(1);
  44.         IIC_Stop();//结束信号
  45.        
  46.        
  47.         return Data;
  48. }
复制代码

Nixie.c
  1. #include <REGX52.H>
  2. #include "Delay.h"
  4. unsigned char Nixie_Buf[9] = {0,10,10,10,10,10,10,10,10}; //显示缓存区
  6. unsigned char NixieTable[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x00,0X40};
  8. void Nixie_SetBuf(unsigned char Location,Number)
  9. {
  10.         Nixie_Buf[Location] = Number;
  11. }
  13. void Nixie_Scan(unsigned char Location,Number)
  14. {
  15.         P0 = 0X00;
  16.         switch(Location) //位选
  17.         {
  18.                 case 1: P2_4 = 1;P2_3 = 1; P2_2 = 1; break;
  19.                 case 2: P2_4 = 1;P2_3 = 1; P2_2 = 0; break;
  20.                 case 3: P2_4 = 1;P2_3 = 0; P2_2 = 1; break;
  21.                 case 4: P2_4 = 1;P2_3 = 0; P2_2 = 0; break;
  22.                 case 5: P2_4 = 0;P2_3 = 1; P2_2 = 1; break;
  23.                 case 6: P2_4 = 0;P2_3 = 1; P2_2 = 0; break;
  24.                 case 7: P2_4 = 0;P2_3 = 0; P2_2 = 1; break;
  25.                 case 8: P2_4 = 0;P2_3 = 0; P2_2 = 0; break;
  26.         }
  27.        
  28.         P0 = NixieTable[Number]; //段选
  29.        
  30.                
  31. }
  33. void Nixie_Loop(void)
  34. {
  35.         static unsigned char i = 1;
  36.         Nixie_Scan(i,Nixie_Buf[i]);
  37.         i++;
  38.         if(i >= 9) {i=1;}
  39. }
复制代码
  1. #include <REGX52.H>
  2. #include "Delay.h"
  4. //数码管显示缓存区
  5. unsigned char Nixie_Buf[9]={0,10,10,10,10,10,10,10,10};
  7. //数码管段码表
  8. unsigned char NixieTable[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x00,0x40};
  10. /**
  11.   * @brief  设置显示缓存区
  12.   * @param  Location 要设置的位置，范围：1~8
  13.   * @param  Number 要设置的数字，范围：段码表索引范围
  14.   * @retval 无
  15.   */
  16. void Nixie_SetBuf(unsigned char Location,Number)
  17. {
  18.         Nixie_Buf[Location]=Number;
  19. }
  21. /**
  22.   * @brief  数码管扫描显示
  23.   * @param  Location 要显示的位置，范围：1~8
  24.   * @param  Number 要显示的数字，范围：段码表索引范围
  25.   * @retval 无
  26.   */
  27. void Nixie_Scan(unsigned char Location,Number)
  28. {
  29.         P0=0x00;                                //段码清0，消影
  30.         switch(Location)                //位码输出
  31.         {
  32.                 case 1:P2_4=1;P2_3=1;P2_2=1;break;
  33.                 case 2:P2_4=1;P2_3=1;P2_2=0;break;
  34.                 case 3:P2_4=1;P2_3=0;P2_2=1;break;
  35.                 case 4:P2_4=1;P2_3=0;P2_2=0;break;
  36.                 case 5:P2_4=0;P2_3=1;P2_2=1;break;
  37.                 case 6:P2_4=0;P2_3=1;P2_2=0;break;
  38.                 case 7:P2_4=0;P2_3=0;P2_2=1;break;
  39.                 case 8:P2_4=0;P2_3=0;P2_2=0;break;
  40.         }
  41.         P0=NixieTable[Number];        //段码输出
  42. }
  44. /**
  45.   * @brief  数码管驱动函数，在中断中调用
  46.   * @param  无
  47.   * @retval 无
  48.   */
  49. void Nixie_Loop(void)
  50. {
  51.         static unsigned char i=1;
  52.         Nixie_Scan(i,Nixie_Buf[i]);
  53.         i++;
  54.         if(i>=9){i=1;}
  55. }
复制代码

Timer.c
  1. #include <REGX52.H>
  4. //由软件配置的定时器STC-ISP
  6. /**
  7. * @brief 定时器初始化（51单片机软件内置配置的定时器）
  8.   * @param 无
  9.   * @retval 无
  10.   */
  12. void Timer0_Init()                //1毫秒@11.0592MHz
  13. {
  14.        
  15.         TMOD &= 0xF0;                //设置定时器模式
  16.         TMOD |= 0x01;                //设置定时器模式
  17.         TL0 = 0x66;                //设置定时初值
  18.         TH0 = 0xFC;                //设置定时初值
  19.         TF0 = 0;                //清除TF0标志
  20.         TR0 = 1;                //定时器0开始计时
  21.        
  22.         //打开定时器中断
  23.         ET0  = 1;
  24.         EA = 1;
  25.         PT0 = 0;
  26. }
  30. //void Timer0_Init()
  31. //{
  32. //        /*
  33. //        采用与或式赋值法，可以把不可寻址的位进行寻址，改变其中几位而不影响其他位
  34. //        TMOD = TMOD & 0XF0; //低四位清零，高四位置一
  35. //        TMOD = TMOD | 0X01；//把TMOD的最低位置1，高四位保持不变
  36. //        如上，改变低四位而不改变高四位
  37. //       
  38. //        */
  39. //        //TMOD = 0x01;  //工作模式寄存器
  40. //        TMOD = TMOD & 0XF0; //低四位清零，高四位置一
  41. //        TMOD = TMOD | 0X01；//把TMOD的最低位置1，高四位保持不变
  42. //        //控制寄存器
  43. //        TF0  = 0;
  44. //        TR0 = 1;
  45. //       
  46. //        /*定时器赋初值  定时1ms，12Mhz的晶振，1us产生一个计数脉冲，
  47. //        而16位的计数器是0~65535个可能，也就是65536us，65536个脉冲
  48. //        如何差生一微秒（1ms=1000us）那么从64535开始记到65535产生一个中断
  49. //        通过配置TL0和TH0控制处置也就是把64535变成16进制TL0是低八位两个十六进制，TH0是高八位的两十六进制*/
  50. //       
  51. //        TL0  = 64535%56;
  52. //        TH0  = 64535/256;
  53. //       
  54. //        ET0  = 1;
  55. //        EA = 1;
  56. //        PT0 = 0;
  57. //       
  58. //}
  61. /*定时器中断函数模板
  62. void Timer0_Rountine(void)  interrupt 1
  63. {
  64.         static unsigned int T0Count ;  //Timer0_Rountine(void) 函数结束之后T0Count保留其原来的值
  65.        
  66.         TL0 = 0x66;                //设置定时初值
  67.         TH0 = 0xFC;                //设置定时初值
  68.        
  69.         T0Count++;
  70.         if(T0Count >= 1000)
  71.         {
  72.                 T0Count = 0;
  73.                 P2_0 = ~P2_0;
  74.         }       
  75. }
  76. */
复制代码


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

种地

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表