标题: STM32双通道方波频率检测与倍频输出的设计源码 蓝桥杯CT117E考试板 [打印本页]

---

作者: h809275982    时间: 2018-5-23 17:18
标题: STM32双通道方波频率检测与倍频输出的设计源码 蓝桥杯CT117E考试板
嵌入式第五届省赛-双通道方波频率检测与倍频输出HGS20180328
“蓝桥杯” 第六届全国软件和信息技术专业人才大赛
嵌入式设计与开发项目模拟试题
功能简述
  “双通道方波频率检测与倍频输出”设计要求测量输入方波信号的频率，并根据设定的
倍频数，输出经过倍频的方波信号。倍频数可以通过按键设定，也可以通过串行口设定；LCD
显示2个通道的频率测量值和倍频数。系统框图如图 1所示：

CT117E考试板电路原理图、LCD 驱动程序、及本题涉及到的芯片资料可参考计算机上的电子文档。电路原理图、程序流程图及相关工程文件请以考生准考证命名，并保存在指定文件夹中（文件夹名为考生准考证号，文件夹位于Windows桌面上） 。


单片机源程序如下:

1. //上电为本地模式  
   
2. //无PWM输入显示0Hz  
   
3. //TIM2_PWMin和串口发有冲突  但题目未用TX，不初始化TX即可(因为PWM为输入模式)，这样无论是否在串口模式都能保证PWM输出
   
4. //TIM3_PWMout使用  GPIO_Mode_Out_PP
   
5. #include "stm32f10x.h"
   
6. #include <stdio.h>
   
7. #include "user.h"
   
8. #include "lcd.h"
   
9. #include "i2c.h"
   
10. 
    
11. u32 TimingDelay = 0;
    
12. u8  USART_Test=0;
    
13. u8 string[20];
    
14. u8 PA6_Mul=0,PA7_Mul=0;
    
15. u8 PA6_Out=0,PA7_Out=0;
    
16. 
    
17. __IO uint16_t ICReadValue1_now = 0,ICReadValue1_last = 0, ICReadValue2_now = 0,ICReadValue2_last = 0;
    
18. __IO uint32_t Freq1_now = 0,Freq1_last = 0,Freq2_now = 0,Freq2_last = 0;
    
19. __IO uint8_t  Freq1_Display=0,Freq2_Display=0;
    
20. 
    
21. uint16_t CCR1_Val = 500;   //  72000 000/(71+2)=1/1000 000
    
22. uint16_t CCR2_Val = 1000;  //  T=CCR*2*(1/1000 000) , f=1/T  ==>CCR=5000000/f
    
23. 
    
24. u8 count=0;
    
25. u8 RX_buf[20];
    
26. u8 Data_right=0;
    
27. u8 RXcomplitFlag=0;
    
28. 
    
29. u8 Local_mode=1;
    
30. u8 Set_channel=1;
    
31. 
    
32. u16 LED=0XFFFF;
    
33. 
    
34. void Delay_Ms(u32 nTime);
    
35. void LED_Config(void);
    
36. void LCD_Config(void);
    
37. void KEY_Config(void);
    
38. void IIC_Config(void);
    
39. void USART_Config(void);
    
40. void TIM2_PWMin_Config(void);
    
41. void TIM3_PWMout_Config(void);
    
42. void ALL_Init(void);
    
43. void KEY_Scan(void);
    
44. u8 IIC_Read(u8 add);
    
45. void IIC_Write(u8 add,u8 dat);
    
46. void NVIC_Configuration(void);
    
47. void USART_SendStr(u8 *str);
    
48. void LED_Run(void);
    
49. 
    
50. int main(void)
    
51. {
    
52.         SysTick_Config(SystemCoreClock/1000);
    
53.         LED_Config();
    
54.   LCD_Config();
    
55.   KEY_Config();
    
56.   IIC_Config();
    
57.   USART_Config();
    
58.   TIM2_PWMin_Config();
    
59.   TIM3_PWMout_Config();
    
60.   ALL_Init();
    
61.         
    
62.         Delay_Ms(5);IIC_Write(0x01,2);
    
63.         Delay_Ms(5);IIC_Write(0x02,2);
    
64.         Delay_Ms(5);PA6_Mul=IIC_Read(0x01);
    
65.         Delay_Ms(5);PA7_Mul=IIC_Read(0x02);
    
66.         sprintf((char*)string," N(1):%d            ",PA6_Mul);
    
67.         LCD_DisplayStringLine(Line2,string);
    
68.         sprintf((char*)string," N(2):%d            ",PA7_Mul);
    
69.         LCD_DisplayStringLine(Line6,string);
    
70.   LED_Run();
    
71.         
    
72.   while (1)
    
73.   {
    
74.                 KEY_Scan();
    
75.                 LED_Run();
    
76.                 if(Freq1_Display==1)
    
77.                 {
    
78.                         Freq1_Display=0;
    
79.                         sprintf((char*)string," Channel(1):%dHz  ",Freq1_now);
    
80.                         LCD_DisplayStringLine(Line1,string);
    
81.                         if((Freq1_now>=50)&&(Freq1_now<=50000))
    
82.                         {
    
83.                                 CCR1_Val = 500000/Freq1_now/PA6_Mul;
    
84.                                 PA6_Out=1;LED&=~LED1;
    
85.                         }
    
86.                         else {PA6_Out=0;LED|=LED1;LCD_DisplayStringLine(Line1,(unsigned char *)" Channel(1):0Hz        ");}
    
87.                 }
    
88.                 else {PA6_Out=0;LED|=LED1;LCD_DisplayStringLine(Line1,(unsigned char *)" Channel(1):0Hz          ");}
    
89.                
    
90.                 if(Freq2_Display==1)
    
91.                 {
    
92.                         Freq2_Display=0;
    
93.                         sprintf((char*)string," Channel(1):%dHz  ",Freq2_now);
    
94.                         LCD_DisplayStringLine(Line5,string);
    
95.                   if((Freq2_now>=50)&&(Freq2_now<=50000))
    
96.                         {
    
97.                                 CCR2_Val = 500000/Freq2_now/PA7_Mul;
    
98.                                 PA7_Out=1;LED&=~LED2;
    
99.                         }
    
100.                         else {PA7_Out=0;LED|=LED2;LCD_DisplayStringLine(Line5,(unsigned char *)" Channel(2):0Hz        ");}
     
101.                 }
     
102.                 else {PA7_Out=0;LED|=LED2;LCD_DisplayStringLine(Line5,(unsigned char *)" Channel(2):0Hz        ");}
     
103.                
     
104.                 if(RXcomplitFlag==1)
     
105.                 {
     
106.                         RXcomplitFlag=0;
     
107.                         if((RX_buf[4]-48)==1)
     
108.                         {
     
109.                                 PA6_Mul=(RX_buf[6]-48)*10+(RX_buf[7]-48);
     
110.                                 sprintf((char*)string," N(1):%d                ",PA6_Mul);
     
111.               LCD_DisplayStringLine(Line2,string);
     
112.                         }
     
113.                         else if((RX_buf[4]-48)==2)
     
114.                         {
     
115.                                 PA7_Mul=(RX_buf[6]-48)*10+(RX_buf[7]-48);
     
116.                                 sprintf((char*)string," N(2):%d                ",PA7_Mul);
     
117.               LCD_DisplayStringLine(Line6,string);
     
118.                         }
     
119.                 }
     
120.   }
     
121. }
     
122. 
     
123. void KEY_Scan(void)
     
124. {
     
125.         if(RB1==0)
     
126.         {
     
127.                 Delay_Ms(5);
     
128.                 if(RB1==0)
     
129.                 {
     
130.                         if(Local_mode==0)
     
131.                         {
     
132.                                 Local_mode=1;
     
133.                                 USART_Cmd(USARTz, DISABLE);
     
134.                                 USART_ITConfig(USARTz, USART_IT_RXNE, DISABLE);
     
135. //                                TIM2_PWMin_Config();
     
136.                                 RCC_APB1PeriphClockCmd(USARTz_CLK, DISABLE);
     
137.         LCD_DisplayStringLine(Line9,(unsigned char *)"                  1 ");
     
138.                                 LED|=LED3;
     
139.                         }
     
140.       else if(Local_mode==1)
     
141.                         {
     
142.                                 Local_mode=0;Set_channel=1;
     
143.                                 USART_Config();
     
144.         LCD_DisplayStringLine(Line9,(unsigned char *)"                    ");
     
145.                                 LED&=~LED3;
     
146.                         }                                
     
147.                 }
     
148.                 while(!RB1);
     
149.         }
     
150.         else if(RB2==0)
     
151.         {
     
152.                 Delay_Ms(5);
     
153.                 if(RB2==0)
     
154.                 {
     
155.                         if(Local_mode==1)
     
156.                         {
     
157.                                 if(Set_channel==1)
     
158.                                 {
     
159.                                         Set_channel=2;
     
160.                                         LCD_DisplayStringLine(Line9,(unsigned char *)"                  2 ");
     
161.                                 }
     
162.                                 else if(Set_channel==2)
     
163.                                 {
     
164.                                         Set_channel=1;
     
165.                                         LCD_DisplayStringLine(Line9,(unsigned char *)"                  1 ");
     
166.                                 }
     
167.                         }        
     
168.                 }
     
169.                 while(!RB2);
     
170.         }
     
171.         else if(RB3==0)
     
172.         {
     
173.                 Delay_Ms(5);
     
174.                 if(RB3==0)
     
175.                 {
     
176.                         if(Local_mode==1)
     
177.                         {
     
178.                                 if(Set_channel==1)
     
179.                                 {
     
180.                                         PA6_Mul--;
     
181.                                         if(PA6_Mul<=1)PA6_Mul=1;
     
182.                                         sprintf((char*)string," N(1):%d                ",PA6_Mul);
     
183.                 LCD_DisplayStringLine(Line2,string);
     
184.                                         Delay_Ms(5);IIC_Write(0x01,PA6_Mul);
     
185.                                 }
     
186.                                 else if(Set_channel==2)
     
187.                                 {
     
188.                                         PA7_Mul--;
     
189.                                         if(PA7_Mul<=1)PA7_Mul=1;
     
190.                                         sprintf((char*)string," N(2):%d                ",PA7_Mul);
     
191.                 LCD_DisplayStringLine(Line6,string);
     
192.                                         Delay_Ms(5);IIC_Write(0x02,PA7_Mul);
     
193.                                 }
     
194.                         }        
     
195.                 }
     
196.                 while(!RB3);
     
197.         }
     
198.         else if(RB4==0)
     
199.         {
     
200.                 Delay_Ms(5);
     
201.                 if(RB4==0)
     
202.                 {
     
203.                         if(Local_mode==1)
     
204.                         {
     
205.                                 if(Set_channel==1)
     
206.                                 {
     
207.                                         PA6_Mul++;
     
208.                                         if(PA6_Mul>=10)PA6_Mul=10;
     
209.                                         sprintf((char*)string," N(1):%d                ",PA6_Mul);
     
210.                 LCD_DisplayStringLine(Line2,string);
     
211.                                         Delay_Ms(5);IIC_Write(0x01,PA6_Mul);
     
212.                                 }
     
213.                                 else if(Set_channel==2)
     
214.                                 {
     
215.                                         PA7_Mul++;
     
216.                                         if(PA7_Mul>=10)PA7_Mul=10;
     
217.                                         sprintf((char*)string," N(2):%d                ",PA7_Mul);
     
218.                 LCD_DisplayStringLine(Line6,string);
     
219.                                         Delay_Ms(5);IIC_Write(0x02,PA7_Mul);
     
220.                                 }
     
221.                         }        
     
222.                 }
     
223.                 while(!RB4);
     
224.         }
     
225. }
     
226. 
     
227. 
     
228. void LCD_Config(void)
     
229. {
     
230.         STM3210B_LCD_Init();
     
231.         LCD_Clear(White);
     
232.         LCD_SetBackColor(White);
     
233.         LCD_SetTextColor(Blue);
     
234.         LCD_DisplayStringLine(Line0,(unsigned char *)"                    ");        
     
235.         LCD_DisplayStringLine(Line1,(unsigned char *)" Channel(1):1000Hz  ");        
     
236.         LCD_DisplayStringLine(Line2,(unsigned char *)" N(1):2             ");
     
237.         LCD_DisplayStringLine(Line3,(unsigned char *)"                    ");
     
238.         LCD_DisplayStringLine(Line4,(unsigned char *)"                    ");
     
239.         LCD_DisplayStringLine(Line5,(unsigned char *)" Channel(2):1000Hz  ");
     
240.         LCD_DisplayStringLine(Line6,(unsigned char *)" N(2):2             ");
     
241.         LCD_DisplayStringLine(Line7,(unsigned char *)"                    ");        
     
242.         LCD_DisplayStringLine(Line8,(unsigned char *)"                    ");
     
243.         LCD_DisplayStringLine(Line9,(unsigned char *)"                  1 ");        
     
244. }        
     
245. 
     
246. void USART_SendStr(u8 *str)
     
247. {
     
248.         u8 i=0;
     
249.         do
     
250.         {
     
251.                 USART_SendData(USART2, *(str+i));
     
252.                 while(USART_GetFlagStatus(USART2,USART_FLAG_TXE)==RESET);
     
253.                 i++;
     
254.         }while(*(str+i)!='\0');
     
255.         while(USART_GetFlagStatus(USART2,USART_FLAG_TC)==RESET);
     
256. }
     
257. 
     
258. void TIM2_PWMin_Config(void)
     
259. {
     
260.         GPIO_InitTypeDef GPIO_InitStructure;
     
261.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     
262.         TIM_ICInitTypeDef  TIM_ICInitStructure;
     
263.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
     
264.         
     
265.         GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_1|GPIO_Pin_2;
     
266.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
     
267.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
268.   GPIO_Init(GPIOA, &GPIO_InitStructure);
     
269.         
     
270.         TIM_TimeBaseStructure.TIM_Period = 0xffff;
     
271.   TIM_TimeBaseStructure.TIM_Prescaler = 71;
     
272.   TIM_TimeBaseStructure.TIM_ClockDivision = 0;
     
273.   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
     
274.   TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
     
275. 
     
276.         TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
     
277.   TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
     
278.   TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
     
279.   TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
     
280.   TIM_ICInitStructure.TIM_ICFilter = 0x0;
     
281.         TIM_ICInit(TIM2, &TIM_ICInitStructure);
     
282.         
     
283.         TIM_ICInitStructure.TIM_Channel = TIM_Channel_3;
     
284.   TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
     
285.   TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
     
286.   TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
     
287.   TIM_ICInitStructure.TIM_ICFilter = 0x0;
     
288.   TIM_ICInit(TIM2, &TIM_ICInitStructure);
     
289.         
     
290.   TIM_Cmd(TIM2, ENABLE);
     
291.   TIM_ITConfig(TIM2, TIM_IT_CC2|TIM_IT_CC3, ENABLE);
     
292. }        
     
293. 
     
294. 
     
295. void TIM2_IRQHandler(void)
     
296. {
     
297.   if(TIM_GetITStatus(TIM2, TIM_IT_CC2) == SET)
     
298.   {
     
299.                 TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
     
300.                 ICReadValue1_now=TIM_GetCapture2(TIM2);
     
301.                 if(ICReadValue1_now!=ICReadValue1_last)
     
302.                 {
     
303.                         Freq1_now=1000000/(ICReadValue1_now-ICReadValue1_last);
     
304.                 }
     
305.                 if(Freq1_now==0)
     
306.                 {
     
307.                         Freq1_now=Freq1_last;
     
308.                 }
     
309.                 ICReadValue1_last=ICReadValue1_now;
     
310.                 Freq1_last=Freq1_now;
     
311.                 Freq1_Display=1;
     
312.         }
     
313.         if(TIM_GetITStatus(TIM2, TIM_IT_CC3) == SET)
     
314.   {
     
315.                 TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
     
316.                 ICReadValue2_now=TIM_GetCapture3(TIM2);
     
317.                 if(ICReadValue2_now!=ICReadValue2_last)
     
318.                 {
     
319.                         Freq2_now=1000000/(ICReadValue2_now-ICReadValue2_last);
     
320.                 }
     
321.                 if(Freq2_now==0)
     
322.                 {
     
323.                         Freq2_now=Freq2_last;
     
324.                 }
     
325.                 ICReadValue2_last=ICReadValue2_now;
     
326.                 Freq2_last=Freq2_now;
     
327.                 Freq2_Display=1;
     
328.         }        
     
329. }
     
330. 
     
331. 
     
332. void TIM3_PWMout_Config(void)
     
333. {
     
334.         GPIO_InitTypeDef GPIO_InitStructure;
     
335.         TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     
336.   TIM_OCInitTypeDef  TIM_OCInitStructure;
     
337.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
     
338.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
     
339.         
     
340.         GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6|GPIO_Pin_7;
     
341.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
342.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
343.   GPIO_Init(GPIOA, &GPIO_InitStructure);
     
344.         
     
345.         TIM_TimeBaseStructure.TIM_Period = 65535;
     
346.   TIM_TimeBaseStructure.TIM_Prescaler = 71;
     
347.   TIM_TimeBaseStructure.TIM_ClockDivision = 0;
     
348.   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
     
349.   TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
     
350.         
     
351.   TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
     
352.   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
     
353.   TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
     
354.   TIM_OC1Init(TIM3, &TIM_OCInitStructure);
     
355.   TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Disable);
     
356. 
     
357.   TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
     
358.   TIM_OC2Init(TIM3, &TIM_OCInitStructure);
     
359.   TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Disable);
     
360. 
     
361.   TIM_ITConfig(TIM3, TIM_IT_CC1|TIM_IT_CC2, ENABLE);
     
362.   TIM_Cmd(TIM3, ENABLE);
     
363. }        
     
364. 
     
365. uint16_t capture = 0;
     
366. 
     
367. void TIM3_IRQHandler(void)
     
368. {
     
369.   if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
     
370.   {
     
371.     TIM_ClearITPendingBit(TIM3, TIM_IT_CC1 );
     
372.     capture = TIM_GetCapture1(TIM3);
     
373.     TIM_SetCompare1(TIM3, capture + CCR1_Val );
     
374.                 if(PA6_Out==1)
     
375.                 {
     
376.                         GPIO_WriteBit(GPIOA, GPIO_Pin_6, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOA,GPIO_Pin_6)));
     
377.                 }
     
378.                 else
     
379.                 {
     
380.                         CCR1_Val=0;GPIO_WriteBit(GPIOA, GPIO_Pin_6, (BitAction)0);
     
381.                 }
     
382.   }
     
383. 
     
384.   if (TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET)
     
385.   {
     
386.     TIM_ClearITPendingBit(TIM3, TIM_IT_CC2);
     
387.     capture = TIM_GetCapture2(TIM3);
     
388.     TIM_SetCompare2(TIM3, capture + CCR2_Val);
     
389.                 if(PA7_Out==1)
     
390.                 {
     
391.                         GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOA,GPIO_Pin_7)));
     
392.                 }
     
393.                 else
     
394.                 {
     
395.                         GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)0);
     
396.                 }
     
397.   }
     
398. }
     
399. 
     
400. void ALL_Init(void)
     
401. {
     
402.         NVIC_Configuration();
     
403.         GPIO_SetBits(GPIOD, GPIO_Pin_2);
     
404.         GPIO_SetBits(GPIOC, LED1|LED2|LED3|LED4|LED5|LED6|LED7|LED8);
     
405.   GPIO_ResetBits(GPIOD, GPIO_Pin_2);
     
406. }
     
407.         
     
408. void NVIC_Configuration(void)
     
409. {
     
410.   NVIC_InitTypeDef NVIC_InitStructure;
     
411.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
     
412.   NVIC_InitStructure.NVIC_IRQChannel = USARTz_IRQn;
     
413.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
     
414.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
415.   NVIC_Init(&NVIC_InitStructure);
     
416.         
     
417.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
     
418.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
     
419.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
420.   NVIC_Init(&NVIC_InitStructure);
     
421.         
     
422.         NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
     
423.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
     
424.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
425.   NVIC_Init(&NVIC_InitStructure);
     
426. }
     
427. 
     
428. void SysTick_Handler(void)
     
429. {
     
430.                 TimingDelay--;
     
431. }
     
432. 
     
433. void USART2_IRQHandler(void)
     
434. {
     
435.         u8 temp;
     
436.   if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
     
437.   {
     
438. 
     
439.     temp = USART_ReceiveData(USART2);
     
440.     if(temp == 'S')
     
441.     {
     
442.       RX_buf[count]=temp;Data_right=1;count++;
     
443.     }
     
444.                 else if(Data_right==1)
     
445.     {
     
446.       RX_buf[count]=temp;
     
447.                         count++;
     
448.                         if(count==8)
     
449.                         {
     
450.                                 count=0;Data_right=0;RXcomplitFlag=1;
     
451.                         }
     
452.     }
     
453.                 USART_ClearITPendingBit(USART2, USART_IT_RXNE);
     
454.   }
     
455. }
     
456. 
     
457. 
     
458. void LED_Run(void)
     
459. {
     
460.         GPIO_Write(GPIOC,LED);
     
461.         GPIO_SetBits(GPIOD, GPIO_Pin_2);
     
462.   GPIO_ResetBits(GPIOD, GPIO_Pin_2);
     
463. }
     
464. 
     
465. 
     
466. 
     
467. 
     
468. 
     
469. 
     
470. 
     
471. 
     
472. 
     
473. 
     
474. 
     
475. 
     
476. 
     
477. 
     
478. void KEY_Config(void)
     
479. {
     
480.         GPIO_InitTypeDef GPIO_InitStructure;
     
481.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB, ENABLE);
     
482.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_8;
     
483.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
     
484.   GPIO_Init(GPIOA, &GPIO_InitStructure);
     
485.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2;
     
486.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
     
487.   GPIO_Init(GPIOB, &GPIO_InitStructure);
     
488. }        
     
489. 
     
490. void IIC_Config(void)
     
491. {
     
492.         i2c_init();
     
493. }        
     
494. u8 IIC_Read(u8 add)
     
495. {
     
496.         u8 data;
     
497.         I2CStart();
     
498.         I2CSendByte(0xa0);
     
499.         I2CSendAck();
     
500.         I2CSendByte(add);
     
501.         I2CSendAck();
     
502.         
     
503.         I2CStart();
     
504.         I2CSendByte(0xa1);
     
505. ……………………
     
506. 
     
507. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
嵌入式第五届省赛-双通道方波频率检测与倍频输出HGS20180328.rar (449.17 KB, 下载次数: 68)

2018-5-24 03:44 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1