第11届 蓝桥杯 单片机 省赛代码（第一场）

目录
一，标题
二，标题难点及分析
        1，固定的模块：
        2，改变的地方：
        3,我觉得的难点：
三，代码参考：
main.c
IIC.c
IIC.H
四，有不完美的地方，请见谅。 

---

一，标题

二，标题难点及分析

        1，固定的模块：

PCF8591和24C02模块，不懂的同砚可以去看看小蜜蜂的强化标题写一下：
   【备赛宝典】小蜜蜂老师关于蓝桥杯单片机大赛的独家教程及资源大汇总-小蜜蜂笔记
          2，改变的地方：

   与前面几届的标题差别的主要是按键变成了矩阵键盘，矩阵键盘我写的非常简单，比方S12,当行R4=0，别的’行列‘为1，只要C2=0时，S12就按键按下：
       R4 = 0;
    R1 = R2= R3 = 1;
    C1 = C2 = C3 = C4 = 1;
    if (C2 == 0)                                                        // "S12"
    {
        Delay(100);
        if (C2 == 0)
      其他的根本上没有什么改变，不会的可以看看我的代码，或者找老师讨教。
        3,我觉得的难点：

         应该是判断Vpp < param(参数)，计数器加1：

        我的想法是设置两个变量stat_volt开始电压和old_volt大于param的先前电压，只要满意（old_volt > param && param > SMG_volt），便可以加1。
三，代码参考：

main.c

1. #include "STC15.H"
2. #include "IIC.h"
4. #define uchar unsigned char
5. #define uint unsigned int
6.        
7. sbit R1 = P3^0;
8. sbit R2 = P3^1;
9. sbit R3 = P3^2;
10. sbit R4 = P3^3;
12. sbit C1 = P3^4;
13. sbit C2 = P3^5;
14. sbit C3 = P4^2;
15. sbit C4 = P4^4;
18. uchar code SMG_NoDot[18]={0xc0,0xf9,
19.     0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
20.     0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
22. uchar code SMG_Dot[10]={0x40,0x79,
23.     0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};
25.                
26. uint DAC_value = 0;
27. float DAC_volt = 0;
28. uint SMG_volt = 0;
29.                
30. uint param = 0;       
31. uchar stat_led = 0xff;
32. uchar count_v = 0;
33. uchar mode = 3;
34. uchar count = 0;
36. uint stat_volt = 0;
37. uint old_volt = 0;
38. uchar dat_error = 0;
39. uchar F_time = 0;
40. uchar dat_24c02 = 0;
43. void Delay(uint t)
44. {
45.         while(t--);
46. }
48. void Select_HC573(uchar n,uchar dat)
49. {
50.         P2 = (P2 & 0x1f) | 0x00;
51.         P0 = dat;
52.        
53.         switch(n)
54.         {
55.                 case 4:
56.                         P2 = (P2 & 0x1f) | 0x80;
57.                 break;
58.                 case 5:
59.                         P2 = (P2 & 0x1f) | 0xa0;
60.                 break;
61.                 case 6:
62.                         P2 = (P2 & 0x1f) | 0xc0;
63.                 break;
64.                 case 7:
65.                         P2 = (P2 & 0x1f) | 0xe0;
66.                 break;
67.                 case 0:
68.                         P2 = (P2 & 0x1f) | 0x00;
69.                 break;
70.         }
71.         P2 = (P2 & 0x1f) | 0x00;
72. }
74. void Choose_SMG(uchar dat,uchar pos)
75. {
76.         Select_HC573(6,0x01 << pos);
77.         Select_HC573(7,dat);
78.        
79.         Delay(500);
80.        
81.         Select_HC573(6,0x01 << pos);
82.         Select_HC573(7,0xff);
83. }
85. void Display_SMG()
86. {
87.          switch(mode)
88.          {
89.                  case 1:
90.                         Choose_SMG(0xc1,0);                                                                        //1100 0001  "U"
91.                         Delay(100);
92.                  
93.                         Choose_SMG(SMG_Dot[SMG_volt / 100],5);
94.                         Delay(100);
95.                         Choose_SMG(SMG_NoDot[(SMG_volt / 10) % 10],6);
96.                         Delay(100);
97.                         Choose_SMG(SMG_NoDot[SMG_volt % 10],7);
98.                         Delay(100);
99.                  break;
100.                  
101.                  case 2:
102.                         Choose_SMG(0x8C,0);                                                                        //1000 1100  "P"
103.                         Delay(100);
104.                  
105.                         Choose_SMG(SMG_Dot[param / 100],5);
106.                         Delay(100);
107.                         Choose_SMG(SMG_NoDot[(param / 10) % 10],6);
108.                         Delay(100);
109.                         Choose_SMG(SMG_NoDot[param % 10],7);
110.                         Delay(100);
111.                  break;
112.                  
113.                  case 3:
114.                         Choose_SMG(0xc8,0);                                                                        //1100 1000  "n"
115.                         Delay(100);
116.                  
117.                         if(count_v > 9)
118.                         {
119.                                 Choose_SMG(SMG_NoDot[(count_v / 10) % 10],6);
120.                         }
121.                                 Delay(100);
122.                        
123.                                 Choose_SMG(SMG_NoDot[count_v % 10],7);
124.                                 Delay(100);
125.                  break;
126.          }
127. }
129. void Init_Timer()
130. {
131.         TH0 = (65536 - 50000) / 256;
132.         TL0 = (65536 - 50000) % 256;
133.        
134.         TMOD = 0x01;
135.        
136.         ET0 = 1;
137.         TR0 = 1;
138.         EA = 1;
139. }
141. void Service_Timer0() interrupt 1
142. {
143.         TH0 = (65536 - 50000) / 256;
144.         TL0 = (65536 - 50000) % 256;
145.        
146.         if(stat_volt == 0)
147.         {
148.                 stat_volt = 1;
149.                 old_volt = SMG_volt;
150.         }
151.         else
152.         {
153.     if (old_volt > param && param > SMG_volt)
154.     {
155.         count_v++;
156.         if (count_v >= 100)
157.         {
158.             count_v = 0;
159.         }
161.        if(count_v % 2 == 0)
162.                          {
163.                                         stat_led |= 0x02;
164.                                  Select_HC573(4,stat_led);
165.                          }
166.                          else
167.                          {
168.                                         stat_led &= ~0x02;
169.                                  Select_HC573(4,stat_led);
170.                          }
171.                         }
172.                 old_volt = SMG_volt;
173.         }
174.         if(F_time == 1)
175.         {
176.                 count++;
177.                 if(count >= 100)
178.                 {
179.                         if(SMG_volt < param)
180.                         {
181.                                 stat_led &= ~0x01;
182.                                 Select_HC573(4,stat_led);
183.                                 F_time = 0;
184.                         }
185.                        
186.                 }
187.         }
188. }
190. void write_24c02(uchar addree,uchar dat)
191. {
192.         I2CStart();
193.         I2CSendByte(0xa0);
194.         I2CWaitAck();
195.        
196.         I2CSendByte(addree);
197.         I2CWaitAck();
198.        
199.         I2CSendByte(dat);
200.         I2CWaitAck();
201.        
202.         I2CStop();
203. }
205. uchar read_24c02(uchar addree)
206. {
207.         uchar tmp;
208.        
209.         I2CStart();
210.         I2CSendByte(0xa0);
211.         I2CWaitAck();
212.        
213.         I2CSendByte(addree);
214.         I2CWaitAck();
215.        
216.         I2CStart();
217.         I2CSendByte(0xa1);
218.         I2CWaitAck();
219.        
220.         tmp = I2CReceiveByte();
221.         I2CSendAck(1);
222.         I2CStop();
223.        
224.         return tmp;
225. }
227. uchar Read_PCF8591_AIN()
228. {
229.         uchar tmp;
230.         I2CStart();
231.         I2CSendByte(0x90);
232.         I2CWaitAck();
233.        
234.         I2CSendByte(0x03);
235.         I2CWaitAck();
236.        
237.         Display_SMG();
238.        
239.         I2CStart();
240.         I2CSendByte(0x91);
241.         I2CWaitAck();
242.        
243.         tmp = I2CReceiveByte();
244.         I2CSendAck(1);
245.         I2CStop();
246.        
247.         return tmp;
248. }
250. void Vpp_work()
251. {
252.         uchar i;
253.         for(i = 0;i < 3;i++)
254.         {
255.                 DAC_value += Read_PCF8591_AIN();
256.         }
257.         DAC_value = DAC_value / 3;
258.        
259.         DAC_volt = DAC_value * (5.0 / 255);
260.         SMG_volt = DAC_volt * 100;
261.        
262.         if(SMG_volt < param)
263.         {
264.                 if(F_time == 0)
265.                 {
266.                         F_time = 1;
267.                 }
268.         }       
269.         else
270.         {
271.                 F_time = 0;
272.                 count = 0;
273.                 stat_led |= 0x01;
274.                 Select_HC573(4,stat_led);
275.         }
276.         Display_SMG();
277.         Select_HC573(4,stat_led);
278. }
280. void Scan_keys()
281. {
282.         R4 = 0;
283.         R1 = R2= R3 = 1;
284.         C1 = C2 = C3 = C4 = 1;
285.        
286.         if(C2 == 0)                                                                                                                // "S12"
287.         {
288.                 Delay(100);
289.                 if(C2 == 0)
290.                 {
291.                         dat_error = 0;
292.                         if(mode == 3)
293.                         {
294.                                 mode = 1;
295.                         }
296.                         else if(mode == 1)
297.                         {
298.                                 mode = 2;
299.                         }
300.                         else if(mode == 2)
301.                         {
302.                                 mode = 3;
303.                                 dat_24c02 = param / 10;
304.                                 write_24c02(0x00,dat_24c02);
305.                         }
306.                         while(C2 == 0)
307.                         {
308.                                 Vpp_work();
309.                         }
310.                 }
311.         }
312.        
313.         if(C1 == 0)                                                                                                                // "S16"
314.         {
315.                 Delay(100);
316.                 if(C1 == 0)
317.                 {
318.                         if(mode == 2)
319.                         {
320.                                 dat_error = 0;
321.                                 if(param < 500)
322.                                 {
323.                                         param = param + 50;
324.                                 }
325.                                 else
326.                                 {
327.                                         param = 0;
328.                                 }
329.                                
330.                         }       
331.                         else
332.                         {
333.                                 dat_error++;
334.                         }
335.                        
336.                         while(C1 == 0)
337.                         {
338.                                 Vpp_work();
339.                         }
340.                 }
341.         }
343.         R3 = 0;
344.         R1 = R2 = R4 = 1;
345.         C1 = C2 = C3 = C4 = 1;
346.        
347.         if(C1 == 0)                                                                                                                // "S17"
348.         {
349.                 Delay(100);
350.                 if(C1 == 0)
351.                 {
352.                         if(mode == 2)
353.                         {
354.                                 dat_error = 0;
355.                                 if(param <= 500)
356.                                 {
357.                                         param = param - 50;
358.                                 }
359.                                 else
360.                                 {
361.                                         param = 500;
362.                                 }
363.                         }       
364.                         else
365.                         {
366.                                 dat_error++;
367.                         }
368.                        
369.                         while(C1 == 0)
370.                         {
371.                                 Vpp_work();
372.                         }
373.                 }
374.         }
376.         if(C2 == 0)                                                                                                        //"S13"
377.         {
378.                 Delay(100);
379.                 if(C2 == 0)
380.                 {
381.                         if(mode == 3)
382.                         {
383.                                 dat_error = 0;
384.                                 count_v = 0;
385.                         }
386.                         else
387.                         {
388.                                 dat_error++;
389.                         }
390.                        
391.                         while(C2 == 0)
392.                         {
393.                                 Vpp_work();
394.                         }
395.                 }
396.         }
397.                
398. }
400. void key_err()
401. {
402.         if(dat_error >= 3)
403.                         {
404.                                 stat_led &= ~0x04;
405.                                 Select_HC573(4,stat_led);
406.                         }
407.                         else
408.                         {
409.                                 stat_led |= 0x04;
410.                                 Select_HC573(4,stat_led);
411.                         }
412. }
414. void Init_System()
415. {
416.         Select_HC573(0,0x00);
417.         Select_HC573(5,0x00);
418.         Select_HC573(4,0xff);
419.        
420.         Select_HC573(6,0xff);
421.         Select_HC573(7,0xff);
422.        
423.         dat_24c02 = read_24c02(0x00);
424.         if(dat_24c02 > 500 || dat_24c02 % 5 != 0)
425.         {
426.                 dat_24c02 = 0;
427.         }
428.         param = dat_24c02 * 10;
429. }
432. void main()
433. {
434.         Init_System();
435.         Init_Timer();
436.         while(1)
437.         {
438.                 Scan_keys();
439.                 Vpp_work();
440.                 key_err();
441.         }
442. }

复制代码

IIC.c

1. #include "STC15.H"
2. #include "intrins.h"
4. sbit sda = P2^1;
5. sbit scl = P2^0;
7. #define DELAY_TIME        5
9. //
10. static void I2C_Delay(unsigned char n)
11. {
12.     do
13.     {
14.         _nop_();_nop_();_nop_();_nop_();_nop_();
15.         _nop_();_nop_();_nop_();_nop_();_nop_();
16.         _nop_();_nop_();_nop_();_nop_();_nop_();               
17.     }
18.     while(n--);             
19. }
21. //
22. void I2CStart(void)
23. {
24.     sda = 1;
25.     scl = 1;
26.         I2C_Delay(DELAY_TIME);
27.     sda = 0;
28.         I2C_Delay(DELAY_TIME);
29.     scl = 0;   
30. }
32. //
33. void I2CStop(void)
34. {
35.     sda = 0;
36.     scl = 1;
37.         I2C_Delay(DELAY_TIME);
38.     sda = 1;
39.         I2C_Delay(DELAY_TIME);
40. }
42. //
43. void I2CSendByte(unsigned char byt)
44. {
45.     unsigned char i;
46.        
47.     for(i=0; i<8; i++){
48.         scl = 0;
49.                 I2C_Delay(DELAY_TIME);
50.         if(byt & 0x80){
51.             sda = 1;
52.         }
53.         else{
54.             sda = 0;
55.         }
56.                 I2C_Delay(DELAY_TIME);
57.         scl = 1;
58.         byt <<= 1;
59.                 I2C_Delay(DELAY_TIME);
60.     }
61.        
62.     scl = 0;  
63. }
65. //
66. unsigned char I2CReceiveByte(void)
67. {
68.         unsigned char da;
69.         unsigned char i;
70.         for(i=0;i<8;i++){   
71.                 scl = 1;
72.                 I2C_Delay(DELAY_TIME);
73.                 da <<= 1;
74.                 if(sda)
75.                         da |= 0x01;
76.                 scl = 0;
77.                 I2C_Delay(DELAY_TIME);
78.         }
79.         return da;   
80. }
82. //
83. unsigned char I2CWaitAck(void)
84. {
85.         unsigned char ackbit;
86.        
87.     scl = 1;
88.         I2C_Delay(DELAY_TIME);
89.     ackbit = sda;
90.     scl = 0;
91.         I2C_Delay(DELAY_TIME);
92.        
93.         return ackbit;
94. }
96. //
97. void I2CSendAck(unsigned char ackbit)
98. {
99.     scl = 0;
100.     sda = ackbit;
101.         I2C_Delay(DELAY_TIME);
102.     scl = 1;
103.         I2C_Delay(DELAY_TIME);
104.     scl = 0;
105.         sda = 1;
106.         I2C_Delay(DELAY_TIME);
107. }

复制代码

IIC.H

1. #ifndef IIC_H
2. #define IIC_H
4. void I2CStart(void);
5. void I2CStop(void);
6. void I2CSendByte(unsigned char byt);
7. unsigned char I2CReceiveByte(void);
8. unsigned char I2CWaitAck(void);
9. void I2CSendAck(unsigned char ackbit);
12. #endif

复制代码

四，有不完美的地方，请见谅。 


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