嵌入式学习--江协51单片机day6

更新一放学习方式，之前一直都是跟着老师敲代码，但是这样会导致中间明白不了，而且有些老师背面改了，是直接在视频中添的字，导致背面查抄不出错误。以是，将会以明白为主，代码直接从源码粘贴，上课就主要是明白了。
然后总共是过三遍，上课看视频明白一边，每两个模块会写一篇博客，周末回顾会照着源码敲注释
（最近的视频大多都是1小时多一集，大概一天看一个模块，看4个小时左右）
AT24C02和DS18B20
这两个一个是I2C总线一个是单总线
AT24C02

AT24C02是E2PROM，一种存储器,使用I2C总线
重要的原理是I2C总线的时序结构，背面的代码就是模拟实现
（这里主机从机，一般是单片机做主机，模块做从机）
为了差别模块的衔接，在各个模块中会有多余的赋值操作
这里发送和接受都是以字节为单位（在吸收或者是读取数据时，要读取的数据已经位于线上，例如，这里读取时数据已经位于SDA线上）
（&常用于获取某一位，|常用于赋值某一位）
（这里的释放是指置一）

2. #include <REGX52.H>
4. //引脚定义
5. sbit I2C_SCL=P2^1;
6. sbit I2C_SDA=P2^0;
8. /**
9.   * @brief  I2C开始
10.   * @param  无
11.   * @retval 无
12.   */
13. void I2C_Start(void)
14. {
15.         I2C_SDA=1;
16.         I2C_SCL=1;
17.         I2C_SDA=0;
18.         I2C_SCL=0;
19. }
21. /**
22.   * @brief  I2C停止
23.   * @param  无
24.   * @retval 无
25.   */
26. void I2C_Stop(void)
27. {
28.         I2C_SDA=0;
29.         I2C_SCL=1;
30.         I2C_SDA=1;
31. }
33. /**
34.   * @brief  I2C发送一个字节
35.   * @param  Byte 要发送的字节
36.   * @retval 无
37.   */
38. void I2C_SendByte(unsigned char Byte)
39. {
40.         unsigned char i;
41.         for(i=0;i<8;i++)
42.         {
43.                 I2C_SDA=Byte&(0x80>>i);
44.                 I2C_SCL=1;
45.                 I2C_SCL=0;
46.         }
47. }
49. /**
50.   * @brief  I2C接收一个字节
51.   * @param  无
52.   * @retval 接收到的一个字节数据
53.   */
54. unsigned char I2C_ReceiveByte(void)
55. {
56.         unsigned char i,Byte=0x00;
57.         I2C_SDA=1;
58.         for(i=0;i<8;i++)
59.         {
60.                 I2C_SCL=1;
61.                 if(I2C_SDA){Byte|=(0x80>>i);}
62.                 I2C_SCL=0;
63.         }
64.         return Byte;
65. }
67. /**
68.   * @brief  I2C发送应答
69.   * @param  AckBit 应答位，0为应答，1为非应答
70.   * @retval 无
71.   */
72. void I2C_SendAck(unsigned char AckBit)
73. {
74.         I2C_SDA=AckBit;
75.         I2C_SCL=1;
76.         I2C_SCL=0;
77. }
79. /**
80.   * @brief  I2C接收应答位
81.   * @param  无
82.   * @retval 接收到的应答位，0为应答，1为非应答
83.   */
84. unsigned char I2C_ReceiveAck(void)
85. {
86.         unsigned char AckBit;
87.         I2C_SDA=1;
88.         I2C_SCL=1;
89.         AckBit=I2C_SDA;
90.         I2C_SCL=0;
91.         return AckBit;
92. }

复制代码

在了解了基础模块后，我们就可以发送数据帧

2. #include <REGX52.H>
3. #include "I2C.h"
5. #define AT24C02_ADDRESS                0xA0
7. /**
8.   * @brief  AT24C02写入一个字节
9.   * @param  WordAddress 要写入字节的地址
10.   * @param  Data 要写入的数据
11.   * @retval 无
12.   */
13. void AT24C02_WriteByte(unsigned char WordAddress,Data)
14. {
15.         I2C_Start();
16.         I2C_SendByte(AT24C02_ADDRESS);
17.         I2C_ReceiveAck();
18.         I2C_SendByte(WordAddress);
19.         I2C_ReceiveAck();
20.         I2C_SendByte(Data);
21.         I2C_ReceiveAck();
22.         I2C_Stop();
23. }
25. /**
26.   * @brief  AT24C02读取一个字节
27.   * @param  WordAddress 要读出字节的地址
28.   * @retval 读出的数据
29.   */
30. unsigned char AT24C02_ReadByte(unsigned char WordAddress)
31. {
32.         unsigned char Data;
33.         I2C_Start();
34.         I2C_SendByte(AT24C02_ADDRESS);
35.         I2C_ReceiveAck();
36.         I2C_SendByte(WordAddress);
37.         I2C_ReceiveAck();
38.         I2C_Start();
39.         I2C_SendByte(AT24C02_ADDRESS|0x01);
40.         I2C_ReceiveAck();
41.         Data=I2C_ReceiveByte();
42.         I2C_SendAck(1);
43.         I2C_Stop();
44.         return Data;
45. }

复制代码

AT24C02数据存储

在实现了各个模块后，数据存储就变得简单了
注意在写入时，要delay一段时间，在手册中规定了最短时间
int在C51中是16位，我们无论是发送还是接受都是8位，以是要给他分开

2. #include <REGX52.H>
3. #include "LCD1602.h"
4. #include "Key.h"
5. #include "AT24C02.h"
6. #include "Delay.h"
8. unsigned char KeyNum;
9. unsigned int Num;
11. void main()
12. {
13.         LCD_Init();
14.         LCD_ShowNum(1,1,Num,5);
15.         while(1)
16.         {
17.                 KeyNum=Key();
18.                 if(KeyNum==1)        //K1按键，Num自增
19.                 {
20.                         Num++;
21.                         LCD_ShowNum(1,1,Num,5);
22.                 }
23.                 if(KeyNum==2)        //K2按键，Num自减
24.                 {
25.                         Num--;
26.                         LCD_ShowNum(1,1,Num,5);
27.                 }
28.                 if(KeyNum==3)        //K3按键，向AT24C02写入数据
29.                 {
30.                         AT24C02_WriteByte(0,Num%256);
31.                         Delay(5);
32.                         AT24C02_WriteByte(1,Num/256);
33.                         Delay(5);
34.                         LCD_ShowString(2,1,"Write OK");
35.                         Delay(1000);
36.                         LCD_ShowString(2,1,"        ");
37.                 }
38.                 if(KeyNum==4)        //K4按键，从AT24C02读取数据
39.                 {
40.                         Num=AT24C02_ReadByte(0);
41.                         Num|=AT24C02_ReadByte(1)<<8;
42.                         LCD_ShowNum(1,1,Num,5);
43.                         LCD_ShowString(2,1,"Read OK ");
44.                         Delay(1000);
45.                         LCD_ShowString(2,1,"        ");
46.                 }
47.         }
48. }

复制代码

秒表（定时器扫描数码管）

在这里老师更新了按键的实现，之前使用delay加while死循环过滤按键的震动，会出现按下后主函数无法进行（卡在死循环），这里使用定时器扫描按键就制止了这种情况，同时可以选择实现按下释放还是松开释放

2. #include <REGX52.H>
3. #include "Delay.h"
5. unsigned char Key_KeyNumber;
7. /**
8.   * @brief  获取按键键码
9.   * @param  无
10.   * @retval 按下按键的键码，范围：0,1~4,0表示无按键按下
11.   */
12. unsigned char Key(void)
13. {
14.         unsigned char Temp=0;
15.         Temp=Key_KeyNumber;
16.         Key_KeyNumber=0;
17.         return Temp;
18. }
20. /**
21.   * @brief  获取当前按键的状态，无消抖及松手检测
22.   * @param  无
23.   * @retval 按下按键的键码，范围：0,1~4,0表示无按键按下
24.   */
25. unsigned char Key_GetState()
26. {
27.         unsigned char KeyNumber=0;
28.        
29.         if(P3_1==0){KeyNumber=1;}
30.         if(P3_0==0){KeyNumber=2;}
31.         if(P3_2==0){KeyNumber=3;}
32.         if(P3_3==0){KeyNumber=4;}
33.        
34.         return KeyNumber;
35. }
37. /**
38.   * @brief  按键驱动函数，在中断中调用
39.   * @param  无
40.   * @retval 无
41.   */
42. void Key_Loop(void)
43. {
44.         static unsigned char NowState,LastState;
45.         LastState=NowState;                                //按键状态更新
46.         NowState=Key_GetState();                //获取当前按键状态
47.         //如果上个时间点按键按下，这个时间点未按下，则是松手瞬间，以此避免消抖和松手检测
48.         if(LastState==1 && NowState==0)
49.         {
50.                 Key_KeyNumber=1;
51.         }
52.         if(LastState==2 && NowState==0)
53.         {
54.                 Key_KeyNumber=2;
55.         }
56.         if(LastState==3 && NowState==0)
57.         {
58.                 Key_KeyNumber=3;
59.         }
60.         if(LastState==4 && NowState==0)
61.         {
62.                 Key_KeyNumber=4;
63.         }
64. }

复制代码

可能有人对于Key的实现有疑问，为什么不直接返回KeyNumber？由于我们需要给它恢复0的状态，以是需要额外设置变量
数码管也进行了更新
添加数组Buf是为了背面体现用的，表示第i位上的数字

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

复制代码

主函数中中断函数的使用也很巧妙，这个只能是个人体悟了吧

2. #include <REGX52.H>
3. #include "Timer0.h"
4. #include "Key.h"
5. #include "Nixie.h"
6. #include "Delay.h"
7. #include "AT24C02.h"
9. unsigned char KeyNum;
10. unsigned char Min,Sec,MiniSec;
11. unsigned char RunFlag;
13. void main()
14. {
15.         Timer0_Init();
16.         while(1)
17.         {
18.                 KeyNum=Key();
19.                 if(KeyNum==1)                        //K1按键按下
20.                 {
21.                         RunFlag=!RunFlag;        //启动标志位翻转
22.                 }
23.                 if(KeyNum==2)                        //K2按键按下
24.                 {
25.                         Min=0;                                //分秒清0
26.                         Sec=0;
27.                         MiniSec=0;
28.                 }
29.                 if(KeyNum==3)                        //K3按键按下
30.                 {
31.                         AT24C02_WriteByte(0,Min);        //将分秒写入AT24C02
32.                         Delay(5);
33.                         AT24C02_WriteByte(1,Sec);
34.                         Delay(5);
35.                         AT24C02_WriteByte(2,MiniSec);
36.                         Delay(5);
37.                 }
38.                 if(KeyNum==4)                        //K4按键按下
39.                 {
40.                         Min=AT24C02_ReadByte(0);        //读出AT24C02数据
41.                         Sec=AT24C02_ReadByte(1);
42.                         MiniSec=AT24C02_ReadByte(2);
43.                 }
44.                 Nixie_SetBuf(1,Min/10);        //设置显示缓存，显示数据
45.                 Nixie_SetBuf(2,Min%10);
46.                 Nixie_SetBuf(3,11);
47.                 Nixie_SetBuf(4,Sec/10);
48.                 Nixie_SetBuf(5,Sec%10);
49.                 Nixie_SetBuf(6,11);
50.                 Nixie_SetBuf(7,MiniSec/10);
51.                 Nixie_SetBuf(8,MiniSec%10);
52.         }
53. }
55. /**
56.   * @brief  秒表驱动函数，在中断中调用
57.   * @param  无
58.   * @retval 无
59.   */
60. void Sec_Loop(void)
61. {
62.         if(RunFlag)
63.         {
64.                 MiniSec++;
65.                 if(MiniSec>=100)
66.                 {
67.                         MiniSec=0;
68.                         Sec++;
69.                         if(Sec>=60)
70.                         {
71.                                 Sec=0;
72.                                 Min++;
73.                                 if(Min>=60)
74.                                 {
75.                                         Min=0;
76.                                 }
77.                         }
78.                 }
79.         }
80. }
82. void Timer0_Routine() interrupt 1
83. {
84.         static unsigned int T0Count1,T0Count2,T0Count3;
85.         TL0 = 0x18;                //设置定时初值
86.         TH0 = 0xFC;                //设置定时初值
87.         T0Count1++;
88.         if(T0Count1>=20)
89.         {
90.                 T0Count1=0;
91.                 Key_Loop();        //20ms调用一次按键驱动函数
92.         }
93.         T0Count2++;
94.         if(T0Count2>=2)
95.         {
96.                 T0Count2=0;
97.                 Nixie_Loop();//2ms调用一次数码管驱动函数
98.         }
99.         T0Count3++;
100.         if(T0Count3>=10)
101.         {
102.                 T0Count3=0;
103.                 Sec_Loop();        //10ms调用一次数秒表驱动函数
104.         }
105. }

复制代码

就到这里结束了，温度传感器下一篇再写了，太长了....