通用定时器PWM控制两个舵机，延时1秒旋转90度(无删版心路历程）)

e芯凌

两个c文件访问同一个全局变量
（1）不用头文件

在file_a.c中定义一个全局变量：int flag ;
在file_b.c中：extern int flag；即可。
（2）利用头文件

在file_a.c中定义一个全局变量：int flag；
在common.h中定义：extern int flag;
然后在file_b.c中包含common.h文件即可。
注：file_a.c中不可包含头文件common.h。


我们使用STM32输出PWM时会使用定时器的PWM输出模式来进行生成，但是这样子生成PWM是有局限的，它只能生成四路频率相同的PWM，当你设定了TIMx_PSC（预分频寄存器）和TIMx_ARR（自动重装载寄存器），这时PWM的频率就被定下来了，为系统的时钟/TIMx_PSC+1/TIMx_ARR+1，你可以通过改变各个通道的CCR寄存器来改变占空比。但是如果我们想生成多路不同频率的PWM的话，使用这个方法只能使用多个定时器了，这样对于定时器资源较少的板子无疑是不可取的


<=、>= 是关系运算符，
&&、|| 是逻辑运算符
关系运算符的优先级大于逻辑运算符，所以会优先计算四个大小判断，假设x = 10;
原来的表达式：
x >= 1 && x <= 10 || x >= 200 && x <= 210
在执行完关系运算以后：
1 && 1 || 0 && 0
在这个表达式中，又因为&&运算符比||运算符的优先级高一级，所以会先进行&&运算，表达式变成：
1 || 0
最后进行 || 运算，得到结果：
1


简单说就是如果是多个else if的话，只要第一个if条件成立，即使满足else if的条件也不会执行else if及else的内容，如果是多个if的话，最后的else会执行的；else与最近的if匹配，包括else if 的if

led.h

1. #ifndef __LED_H
   
2. #define __LED_H
   
3. 
   
4. void LED_Init(void);
   
5. 
   
6. #define LED0 PBout(5)
   
7. #define LED1 PEout(5)
   
8. 
   
9. #endif

复制代码

led.c

1. #include "led.h"
   
2. #include "stm32f10x.h"
   
3. 
   
4. void LED_Init(void)
   
5. {
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.        
   
8.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOE,ENABLE);//使能GPIOA和GPIOB
   
9.                                                                                                                                                                                                                                                                                                          //| 既是逻辑运算符也是位运算符；|| 只是逻辑运算符
   
10.                                                                                                                                                                                                                                                                                                                 //| 不具有短路效果，即左边true，右边还会执行；
    
11.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
    
12.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_5;
    
13.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
14.         GPIO_Init(GPIOB,&GPIO_InitStructure);
    
15.   GPIO_SetBits(GPIOB,GPIO_Pin_5);       
    
16.        
    
17.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
    
18.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_5;
    
19.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
20.         GPIO_Init(GPIOE,&GPIO_InitStructure);       
    
21.   GPIO_SetBits(GPIOE,GPIO_Pin_5);               
    
22. }

复制代码

key.h

1. #ifndef __KEY_H
   
2. #define __key_h
   
3. #include "sys.h"
   
4. 
   
5. #define KEY0  GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_4)
   
6. #define KEY1  GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_3)
   
7. #define WK_UP GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)//读取按键3(WK_UP)
   
8. 
   
9. #define KEY0_PRES         1        //KEY0按下
   
10. #define KEY1_PRES          2        //KEY1按下
    
11. #define WKUP_PRES   3        //KEY_UP按下(即WK_UP/KEY_UP)
    
12. 
    
13. 
    
14. void KEY_Init(void);//IO初始化
    
15. u8 KEY_Scan(u8);          //按键扫描函数               
    
16. 
    
17. 
    
18. #endif

复制代码

key.c

1. #include "key.h"
   
2. #include "delay.h"
   
3. //#include "led.h"
   
4. 
   
5. void KEY_Init(void) //IO初始化
   
6. {
   
7.         GPIO_InitTypeDef GPIO_InitStructure;
   
8. 
   
9.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOE,ENABLE);//使能PORTA,PORTE时钟
   
10. 
    
11.         GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_4|GPIO_Pin_3;//KEY0-KEY1
    
12.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //设置成上拉输入
    
13.         GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE4,3
    
14. 
    
15.         //初始化 WK_UP-->GPIOA.0          下拉输入
    
16.         GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_0;
    
17.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PA0设置成输入，默认下拉          
    
18.         GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.0
    
19. 
    
20. }
    
21. 
    
22. //mode:0,不支持连续按;1,支持连续按
    
23. /*
    
24. u8 KEY_Scan(u8 mode)
    
25. {         
    
26.         static u8 key_up=1;//按键按松开标志
    
27.         if(mode)
    
28.                 key_up=1;  //支持连按                  
    
29.         if(key_up&&(KEY0==0||KEY1==0||WK_UP==1))
    
30.         {
    
31.                 delay_ms(10);//去抖动
    
32.                 key_up=0;
    
33.                 if(KEY0==0)
    
34.                         return KEY0_PRES;
    
35.                 else if(KEY1==0)
    
36.                         return KEY1_PRES;
    
37.                 else if(WK_UP==1)
    
38.                         return WKUP_PRES;
    
39.         }else if(KEY0==1&&KEY1==1&&WK_UP==0)
    
40.         key_up=1;             
    
41.         return 0;// 无按键按下
    
42. }
    
43. */
    
44. 
    
45. u8 KEY_Scan(u8 mode)
    
46. {         
    
47.         static u8 flag=0;//TMD罪魁祸首就是你我真的是傻->->
    
48.         static u8 key_up=1;//按键按松开标志
    
49.        
    
50.         if(mode)
    
51.                 key_up=1;  //支持连按                  
    
52.         if(key_up&&(KEY0==0||KEY1==0))//他不会再进来第二次了
    
53.         {
    
54.                 delay_ms(10);//去抖动
    
55.                 key_up=0;
    
56.                 if((KEY0==0)&&(KEY1==1))
    
57.                 {
    
58.                         flag=1;
    
59.                         return 1;
    
60.                 }
    
61.                 if((KEY1==0)&&(KEY0==1))
    
62.                 {
    
63.                         flag=2;
    
64.                         return 2;
    
65.                 }
    
66.                 if((KEY1==0)&&(KEY0==0))
    
67.                 {
    
68.                         //if(!flag)//现在这个灯的状态比较乱
    
69.                         //LED0=!LED0;
    
70. 
    
71.                         if(flag==1)
    
72.                         {
    
73.                                 //LED0=1;//说明确实没有进来
    
74.                                 return 3;
    
75.                         }
    
76.                         if(flag==2)
    
77.                         {
    
78.                                 return 4;
    
79.                                 //LED0=0;
    
80.                         }
    
81.                 }
    
82.         }
    
83.         if((KEY0==1)&&(KEY1==1))
    
84.         {
    
85.                 key_up=1;
    
86.     flag=0;               
    
87. 
    
88.         }
    
89.         /*
    
90.         if(KEY0==0&&KEY1==1)
    
91.         {
    
92.                 flag=0;
    
93.                 return 3;
    
94.         }
    
95.         if(KEY0==1&&KEY1==0)
    
96.         {
    
97.                 flag=0;
    
98.                 return 4;
    
99.         }
    
100.         */
     
101.         return 0;// 无按键按下
     
102. }
     

复制代码

pwm.h

1. #ifndef __PWM_H
   
2. #define __PWM_H
   
3. 
   
4. #include "sys.h"
   
5. 
   
6. void TIM3_PWM_Init1(u16 arr,u16 psc);
   
7. void TIM3_PWM_Init2(u16 arr,u16 psc);
   
8. 
   
9. 
   
10. #endif
    

复制代码

pwm.c

1. #include "pwm.h"
   
2. 
   
3. 
   
4. void TIM3_PWM_Init1(u16 arr,u16 psc)//PA.7
   
5. {
   
6.        
   
7.         GPIO_InitTypeDef GPIO_InitStructure;
   
8.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitstruct;
   
9.         TIM_OCInitTypeDef TIM_OCInitStructure;
   
10.        
    
11.        
    
12.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
    
13.         //RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    
14.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
15.        
    
16.        
    
17.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
    
18.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_7;
    
19.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
20.         GPIO_Init(GPIOA,&GPIO_InitStructure);
    
21.   //GPIO_SetBits(GPIOA,GPIO_Pin_1);
    
22.        
    
23.         //GPIO_PinRemapConfig(GPIO_PartialRemap_TIM3, ENABLE);
    
24.        
    
25. 
    
26.         TIM_TimeBaseInitstruct.TIM_ClockDivision=TIM_CKD_DIV1;
    
27.         TIM_TimeBaseInitstruct.TIM_CounterMode=TIM_CounterMode_Up;
    
28.         TIM_TimeBaseInitstruct.TIM_Period=arr;
    
29.         TIM_TimeBaseInitstruct.TIM_Prescaler=psc;
    
30.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitstruct);
    
31.        
    
32. 
    
33.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2; //选择 PWM 模式 2
    
34.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //比较输出使能
    
35.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; //输出极性高
    
36.         TIM_OC2Init(TIM3, &TIM_OCInitStructure); //初始化 TIM3 OC1
    
37.        
    
38.         TIM_Cmd(TIM3, ENABLE);
    
39.        
    
40.         TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
    
41. 
    
42.         //TIM_ARRPreloadConfig(TIM3,ENABLE);//为什么正点原子的教程里没有加这个函数，可没有这个除了例程别的引脚都没法动,加了一次之后就不需要要能控制舵机了
    
43. }
    
44. 
    
45. 
    
46. void TIM3_PWM_Init2(u16 arr,u16 psc)//PA.6
    
47. {
    
48.        
    
49.         GPIO_InitTypeDef GPIO_InitStructure;
    
50.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitstruct;
    
51.         TIM_OCInitTypeDef TIM_OCInitStructure;
    
52.        
    
53.        
    
54.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
    
55.         //RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    
56.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
57.        
    
58.        
    
59.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
    
60.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6;
    
61.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
62.         GPIO_Init(GPIOA,&GPIO_InitStructure);
    
63.   //GPIO_SetBits(GPIOA,GPIO_Pin_1);
    
64.        
    
65.         //GPIO_PinRemapConfig(GPIO_PartialRemap_TIM3, ENABLE);
    
66.        
    
67. 
    
68.         TIM_TimeBaseInitstruct.TIM_ClockDivision=TIM_CKD_DIV1;
    
69.         TIM_TimeBaseInitstruct.TIM_CounterMode=TIM_CounterMode_Up;
    
70.         TIM_TimeBaseInitstruct.TIM_Period=arr;
    
71.         TIM_TimeBaseInitstruct.TIM_Prescaler=psc;
    
72.         TIM_TimeBaseInit(TIM3,&TIM_TimeBaseInitstruct);
    
73.        
    
74. 
    
75.         TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2; //选择 PWM 模式 2
    
76.         TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //比较输出使能
    
77.         TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; //输出极性高
    
78.         TIM_OC1Init(TIM3, &TIM_OCInitStructure); //初始化 TIM3 OC1
    
79.        
    
80.         TIM_Cmd(TIM3, ENABLE);
    
81.        
    
82.         TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);
    
83. 
    
84.         //TIM_ARRPreloadConfig(TIM3,ENABLE);//为什么正点原子的教程里没有加这个函数，可没有这个除了例程别的引脚都没法动,加了一次之后就不需要要能控制舵机了
    
85. }
    

复制代码

timer.h

1. #ifndef __TIMER_H
   
2. #define __TIMER_H
   
3. 
   
4. #include "sys.h"
   
5. 
   
6. void TIM2_Init(u16 arr,u16 psc);
   
7. 
   
8. 
   
9. #endif

复制代码

timer.c

1. #include "timer.h"
   
2. #include "led.h"
   
3. 
   
4. 
   
5. 
   
6. 
   
7. void TIM2_Init(u16 arr,u16 psc)
   
8. {
   
9.        
   
10.         TIM_TimeBaseInitTypeDef TIM_TimeBaseInitstruct;
    
11.          NVIC_InitTypeDef NVIC_InitStructure;
    
12.        
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);
    
14.        
    
15.         TIM_TimeBaseInitstruct.TIM_ClockDivision=TIM_CKD_DIV1;
    
16.         TIM_TimeBaseInitstruct.TIM_CounterMode=TIM_CounterMode_Up;
    
17.         TIM_TimeBaseInitstruct.TIM_Period=arr;
    
18.         TIM_TimeBaseInitstruct.TIM_Prescaler=psc;
    
19.         TIM_TimeBaseInit(TIM2,&TIM_TimeBaseInitstruct);
    
20.        
    
21.         TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
    
22.        
    
23.         NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;                        //使能按键TIME2所在的中断通道
    
24.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;        //抢占优先级2，
    
25.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x03;                                        //子优先级3
    
26.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                                //使能TIM3中断通道
    
27.   NVIC_Init(&NVIC_InitStructure);
    
28. 
    
29.         TIM_Cmd(TIM2, ENABLE);        
    
30.        
    
31. }

复制代码

main.c

1. #include "usart.h"
   
2. 
   
3. u16 count=0;
   
4. u16 mark1=0;
   
5. u16 mark2=0;
   
6. u16 flag1=0;
   
7. u16 flag2=0;
   
8. 
   
9. int main()
   
10. {
    
11.        
    
12.         //u16 delay_time=500;
    
13.         /*
    
14.                 u16 i;
    
15.                 u16 angle=57;
    
16.                 u16 angle2=57;
    
17.         */
    
18.         //u16 times=0;
    
19.        
    
20.         delay_init();
    
21.        
    
22.         LED_Init();//多用了1个led初始化按键控制就有用了,原来是我忘记调用KEY_Init()函数,我TMD
    
23.        
    
24.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);       
    
25. 
    
26.         TIM3_PWM_Init1(199,7199);
    
27.         TIM3_PWM_Init2(199,7199);//这个改成59的时候为什么就不行了，同一个定时器只能生成一种PWM，不是一个
    
28.        
    
29.         uart_init(115200);
    
30.         KEY_Init();
    
31.         TIM2_Init(9,7199);//有这个时不会运行，为啥这个有错会影响后面的呢,函数里面参数没全部改过来
    
32.        
    
33.         while(1)
    
34.         {
    
35.                
    
36.                
    
37.                 /*
    
38.                 if(count%500==0||1==KEY_Scan(1)||2==KEY_Scan(1)||3==KEY_Scan(1)||4==KEY_Scan(1))//为什么按下按键就不执行这个语句了,不打印，灯不闪,这个按键返回值有问题，好了，count计数到500的时候可能没有运行到这
    
39.                 {                                                                         //同时按两个按键停了
    
40.                         printf("%d  %d  %d %d/r/n",KEY_Scan(1),mark1,mark2,count);
    
41.                         //LED0=!LED0;
    
42.                 }
    
43.                 */
    
44.                
    
45.                 //我的按键函数写的太复杂了，可以简化成
    
46. /*
    
47.                 if(KEY0==0)
    
48.                 {
    
49.                         if(flag1==0)
    
50.                         {
    
51.                                 mark1=count;
    
52.                                 flag1=1;
    
53.                         }
    
54.                         if(count-mark1>=0)
    
55.                         {
    
56.                                 TIM_SetCompare1(TIM3,185);
    
57.                         }
    
58.           }
    
59.                 else
    
60.                 {
    
61.                         TIM_SetCompare1(TIM3,185);
    
62.                         flag1=0;
    
63.                 }
    
64.                
    
65.                 if(KEY1==0)
    
66.                 {
    
67.                         if(flag2==0)
    
68.                         {
    
69.                                 mark2=count;
    
70.                                 flag2=1;
    
71.                         }
    
72.                         if(count-mark1>=0)
    
73.                         {
    
74.                                 TIM_SetCompare1(TIM3,185);
    
75.                         }
    
76.           }
    
77.                 else
    
78.                 {
    
79.                         TIM_SetCompare1(TIM3,185);
    
80.                         flag2=0;
    
81.                 }
    
82. */               
    
83.                
    
84.                
    
85.                
    
86.                
    
87.                
    
88.        
    
89.                 if((count-mark1>=1000)&&(flag1==1))
    
90.                 {
    
91.                         TIM_SetCompare1(TIM3,185);
    
92.                 }
    
93.                 if((count-mark2>=1000)&&(flag2==1))
    
94.                 {
    
95.                         TIM_SetCompare2(TIM3,185);
    
96.                 }
    
97. 
    
98.                 if(1==KEY_Scan(1))
    
99.                 {
    
100.                         if(flag1==0)
     
101.                         {
     
102.                                 mark1=count;
     
103.                                 flag1=1;
     
104.                         }
     
105.                         if(flag2==1)
     
106.                                 flag2=0;
     
107.                         TIM_SetCompare2(TIM3,195);
     
108.                 }
     
109. 
     
110.                 if(2==KEY_Scan(1))
     
111.                 {
     
112.                         if(flag2==0)
     
113.                         {
     
114.                                 mark2=count;
     
115.                                 flag2=1;
     
116.                         }
     
117.                         if(flag1==1)
     
118.                                 flag1=0;
     
119.                         TIM_SetCompare1(TIM3,195);
     
120.                 }
     
121.                
     
122.                 if(3==KEY_Scan(1))
     
123.                 {
     
124.                         if(flag2==0)
     
125.                         {
     
126.                                 mark2=count;
     
127.                                 flag2=1;
     
128.                         }
     
129.                 }
     
130.                 if(4==KEY_Scan(1))
     
131.                 {
     
132.                         if(flag1==0)
     
133.                         {
     
134.                                 mark1=count;
     
135.                                 flag1=1;
     
136.                         }
     
137.                 }
     
138.                 if(0==KEY_Scan(1))
     
139.                 {
     
140.                         flag1=0;
     
141.                         flag2=0;
     
142.                         TIM_SetCompare1(TIM3,195);
     
143.                         TIM_SetCompare2(TIM3,195);
     
144.                 }
     
145. 
     
146.                 /*
     
147.                 if(count%500==0)
     
148.                 {
     
149.                         printf("%d  %d  %d  %d  %d\n",count,mark1,mark2,flag1,flag2);
     
150.                 }
     
151.                 */
     
152.                
     
153.                 /*
     
154.                 if(times%100==0)
     
155.                 {
     
156.                  printf("%d  %d  %d\n",count,mark1,mark2);
     
157.                 LED0=0;
     
158.                
     
159.                 }
     
160.                 times++;
     
161.                 delay_ms(20);
     
162.                 if(times%200==0)
     
163.                 {
     
164.                 printf("1111");
     
165.                 LED0=1;
     
166.                 }
     
167.                 */
     
168.                
     
169.                
     
170.                 /*即时按键控制
     
171.                 if(1==KEY_Scan(1))
     
172.                 {
     
173.                         TIM_SetCompare2(TIM3,185);
     
174.                         delay_ms(delay_time);
     
175.                         LED0=0;            
     
176.                 }
     
177.                 TIM_SetCompare2(TIM3,195);
     
178.                 if(2==KEY_Scan(1))
     
179.                 {
     
180.                         TIM_SetCompare1(TIM3,185);
     
181.                         delay_ms(delay_time);
     
182.                         LED0=0;            
     
183.                 }
     
184.                 TIM_SetCompare1(TIM3,195);
     
185.                 */
     
186.                
     
187.                
     
188.                
     
189.                 /*
     
190.                 KEY_Scan(0);
     
191.                 if(count-mark1==1000)
     
192.                 {
     
193.                         TIM_SetCompare2(TIM3,185);
     
194.                 }
     
195.                 if(count-mark2==1000)
     
196.                 {
     
197.                         TIM_SetCompare1(TIM3,51);
     
198.                 }
     
199.                 */
     
200.                 /*
     
201.                 for(i=0;i<4;i++)
     
202.                 {
     
203.                         delay_ms(delay_time);
     
204.                         TIM_SetCompare2(TIM3,angle);
     
205.                         angle-=5;
     
206.                         }
     
207.                 for(i=0;i<4;i++)
     
208.                 {
     
209.                         delay_ms(delay_time);
     
210.                         TIM_SetCompare2(TIM3,angle);
     
211.                         angle+=5;
     
212.                 }
     
213.                
     
214.                 for(i=0;i<4;i++)
     
215.                 {
     
216.                         delay_ms(delay_time);
     
217.                         TIM_SetCompare1(TIM3,angle2);
     
218.                         angle2-=5;
     
219.                         }
     
220.                 for(i=0;i<4;i++)
     
221.                 {
     
222.                         delay_ms(delay_time);
     
223.                         TIM_SetCompare1(TIM3,angle2);
     
224.                         angle2+=5;
     
225.                 }
     
226.                 */
     
227.                
     
228.                 /*
     
229.                 if(1==KEY_Scan(1))//mode=0时可以返回0，mode=1时返回1，没按键
     
230.                 {
     
231.                         TIM_SetCompare2(TIM3,185);
     
232.                         delay_ms(delay_time);
     
233.                         LED0=0;            //多用LED指示状态，为什么led不亮
     
234.                 }
     
235.                
     
236.                 if(2==KEY_Scan(1))//mode=0时可以返回0，mode=1时返回1，没按键
     
237.                 {
     
238.                         TIM_SetCompare1(TIM3,185);
     
239.                         delay_ms(delay_time);
     
240.                         LED0=0;            //多用LED指示状态，为什么led不亮
     
241.                 }
     
242.                
     
243.                 TIM_SetCompare2(TIM3,180);
     
244.                 delay_ms(delay_time);
     
245.                 TIM_SetCompare2(TIM3,175);
     
246.                 delay_ms(delay_time);
     
247.                 TIM_SetCompare1(TIM3,180);
     
248.                 delay_ms(delay_time);
     
249.                 TIM_SetCompare1(TIM3,175);
     
250.                 delay_ms(delay_time);
     
251.                 LED0=1;
     
252.                 LED1=0;
     
253.                
     
254.     */
     
255.                 /*
     
256.                 if(2==KEY_Scan(0))
     
257.                 {
     
258.                         TIM_SetCompare1(TIM3,185);
     
259.                         delay_ms(delay_time);
     
260.                 }
     
261.                 */
     
262.         }       
     
263.                
     
264. }

复制代码