强大的STM32F4的定时器设定方法-附源码

STM32定时器比较多，使用起来也比较混乱。

windows下做过编程的人一定对SetTimer有印象，不过该定时器也不那么好用，因为id要自己维护，并且保证不跟程序中的其他id冲突。

手头上的项目要用到定时器，又不想每次都跑到寄存器里详细设定参数，所以就写了个类似SetTimer的定时器。

注：请在STM32F407上使用该定时器，其他内核需要修改，如M3内核是没有32位定时器的
使用方法：
u8 SetTimer(u32 unTime, u32 unCount, TIMERFUN pHandler,u32 ucPara)
使用SetTimer去向系统申请一个定时器，如果成功，返回定时器ID，失败返回0.为了使定时器ID更有意义，这里设定返回值为定时器编号
这里根据计时时间自动分配定时器。

比如你需要一个比较长时间的定时，那么SetTimer会给你分配一个32位定时器（M4内核）
参数：
unTime：计时时间（ms，如需ns请自行修改或者使用delay）
unCount ：计时器运行次数，0为无限运行，非零的话，运行unCount次后，该定时器关闭。

pHandler：定时器定时后执行的函数，该处如果不需要执行，可填0（什么都不需要做，干嘛要开启定时器？）,当然这里可以自己定义函数指针类型（比如传2个参数或者变参：呃，变参太变态）
ucPara：函数参数
/*关闭定时器
tmrId:定时器ID
*/
void KillTimer(TIMER tmrId);
例如：
view sourceprint?
1 //每隔0.5s 反转4bit 灯
2 tmrIrb = SetTimer(500, 0, IndRvsBit, 4);
3 printf("IndRvsBit Timer Id: %d\r\n",tmrIrb);
4
5 if(0 != tmrIrb)
6 {
7 ucCnt = SetTimer(10 * 1000, 1, KillBlink, tmrIrb); //10s 后关闭位4反转
8 printf("KillBlink Timer Id: %d\r\n",ucCnt);
9 }
view sourceprint?
1
view sourceprint?
1
view sourceprint?
1
view sourceprint?
1
view sourceprint?
1
view sourceprint?
1
这里要提前定义好参数里的函数指针
view sourceprint?
01 void KillBlink(u8 ucOpt)
02 {
03 // RTC_ShutWakeUp();
04 KillTimer(ucOpt);
05 printf("KillBlink(%d)\r\n", ucOpt);
06 }
07
08 void AdPickTime(u8 ucOpt)
09 {
10 PushCmd(0xF2,0);
11 }
12
13 void IndRvsBit(u8 ucOpt)
14 {
15 SubBoardIndSingle(4, acCurInd[4] ^ (1 << ucOpt));
16 }
header：
view sourceprint?
01 #ifndef __TIMER_H
02 #define __TIMER_H
03 #include "board.h"
04 #include "zkekglobe.h"
0 5 /////////////////////////////////////////////////////////////////// ///////////////
6
0//All rights reserved
7
08 //////////////////////////////////////////////////////////////////////////////////
09
10
11
12 /*使能基本计时器
13 ucTimerIdx:计时器编号 范围：2~5 9~14
14 unCount 自动重装值。

15 uwPsc 计数器分频 2-65535 计时时间 = unCount * uwPsc / 84M(168M if ucTimerIdx in{9, 10, 11})
16 pHandler 计数完成后执行函数
17 ucPara 执行函数的参数
18
19
20 返回值:
21 0:成功
22 1:ucOpt unRunningFreqency unCount 参数错误
23 2:定时器编号参数错误
24 3:定时器已经被占用
25 4:16位定时器传入的计数参数超阈值*/
26 u8 TimerEnable(u8 ucTimerIdx, u32 unCount, u16 uwPsc,TIMERFUN pHandler,u8 ucPara);
27
28 /*
29 获取空闲计时器
30
31 unTime ：要计时的时间
32
33 返回值：timerId or 0:failed
34 */
35 u8 GetAFreeTimer(u32 unTime);
36
37
38
39 /*设置定时器,最大计时2147483647ms(24.8天)，最小1ms ，其中unTime 值
不能超过该值
40 unTime: 计时时间，单位ms
41 unCount: 0：连续计时；其它：计时次数，到达次数后计时器停止工作
42 pHandler 计数完成后执行函数
43 ucPara 执行函数的参数
44 返回值： TimerID or 0:失败
45 */
46 u8 SetTimer(u32 unTime, u32 unCount, TIMERFUN pHandler,u32 ucPara); 47
48
49
50
51
52 /*关闭定时器
53 tmrId:定时器ID
54 */
55 void KillTimer(TIMER tmrId);
56
57 /*停止基本计时器 使能位置0，停止其时钟
58 ucTimerIdx:计时器编号 范围：2~5
59 ucOpt 可选参数 保留不用
60 */
61 void TimerStop(u8 ucTimerIdx,u8 ucOpt);
62 #endif
c:
view sourceprint?
00
1
#include "timer.h"
00 2 ////////////////////////////////////////////////////////////////// ////////////////
00
3
////All rights reserved
00 4 ////////////////////////////////////////////////////////////////// ////////////////
005
006 TIMERFUN Timer2Fun = 0; 007 TIMERFUN Timer3Fun = 0; 008 TIMERFUN Timer4Fun = 0; 009 TIMERFUN Timer5Fun = 0; 010 TIMERFUN Timer9Fun = 0; 011 TIMERFUN Timer10Fun = 0;
012 TIMERFUN Timer11Fun = 0;
013 TIMERFUN Timer12Fun = 0;
014 TIMERFUN Timer13Fun = 0;
015 TIMERFUN Timer14Fun = 0;
016
017 u8 ucTimer2Para = 0;
018 u8 ucTimer3Para = 0;
019 u8 ucTimer4Para = 0;
020 u8 ucTimer5Para = 0;
021 u8 ucTimer9Para = 0;
022 u8 ucTimer10Para = 0;
023 u8 ucTimer11Para = 0;
024 u8 ucTimer12Para = 0;
025 u8 ucTimer13Para = 0;
026 u8 ucTimer14Para = 0;
027
028
029 u8 ucTmr2Efct = 0;
030 u8 ucTmr3Efct = 0;
031 u8 ucTmr4Efct = 0;
032 u8 ucTmr5Efct = 0;
033 u8 ucTmr9Efct = 0;
034 u8 ucTmr10Efct = 0;
035 u8 ucTmr11Efct = 0;
036 u8 ucTmr12Efct = 0;
037 u8 ucTmr13Efct = 0;
038 u8 ucTmr14Efct = 0;
039
040
041 u8 acTimerId[10] = { 0 };
042 u8 acTmrOrder[10] = {9, 10, 11, 3, 4, 12, 13, 14, 2, 5}; //
定时器按定时时间长短查找顺序
043
044 u32 anTimingCnt[10] = { 0 };
045
046
048
049 u8 GetAFreeTimer(u32 unTime)
050 {
051 u8 ucTmrSearchWith = 0;
052
053 u8 ucTimerIndex = 0;
054
055 //find an idle timer
056 if(unTime < 16384)//小于16.383s
057 {
058 ucTmrSearchWith = 1;
059 }
060 else if(unTime > 16383 && unTime < 32768)
061 {
062 ucTmrSearchWith = 3;
063 }
064 else if(unTime > 32767 && unTime < 2147483647)
065 {
066 ucTmrSearchWith = 8;
067 }
068
069
070 for(; ucTmrSearchWith < 10; ucTmrSearchWith++)
071 {
072 if(0 == acTimerId[ucTmrSearchWith])
073 {
074 ucTimerIndex = acTmrOrder[ucTmrSearchWith]; 075 }
076 }
077
078 return ucTimerIndex;
079 }
080
081
082
084
085
086
087
088
089
090 /*设置定时器,最大计时2147483647ms(24.8天)，最小1ms ，其中unTime 值不能超过该值
091 unTime: 计时时间，单位ms
092 unCount: 0：连续计时；其它：计时次数，到达次数后计时器停止工作 093 pHandler 计数完成后执行函数
094 ucPara 执行函数的参数
095 返回值：TimerID or 0:失败
096 */
097 u8 SetTimer(u32 unTime, u32 unCount, TIMERFUN pHandler,u32 ucPara) 098 {
099 u8 ucTimerIndex = 0;
100 u8 ucRslt = 0;
101 u8 ucTmrSearchWith = 0;
102 u32 unTimeUse = 0;
103
104 //find an idle timer
105
106 if(unTime < 16384)//小于16.383s
107 {
108 ucTmrSearchWith = 0;
109 }
110 else if(unTime > 16383 && unTime < 32768)
111 {
112 ucTmrSearchWith = 3;
113 }
114 else if(unTime > 32767 && unTime < 2147483647)
115 {
116 ucTmrSearchWith = 8;
117 }
118 else
119 {
120 return 0;
121 }
122
123
124 for(; ucTmrSearchWith < 10; ucTmrSearchWith++)
125 {
126 if(0 == acTimerId[ucTmrSearchWith])
127 {
128 ucTimerIndex = acTmrOrder[ucTmrSearchWith]; 129 acTimerId[ucTmrSearchWith] = ucTimerIndex; 130 ucRslt = ucTimerIndex;
131
132 anTimingCnt[ucTmrSearchWith] = unCount;
133
134 unTimeUse = unTime;
135 if(ucTmrSearchWith < 3)
136 {
137 unTimeUse *= 2;
138 }
139
140 if( 0 != TimerEnable(ucTimerIndex, unTimeUse * 2, 42000, pHandler, ucPara))
141 {
142 acTimerId[ucTmrSearchWith] = 0;
143 ucRslt = 0;
144 continue;
145 }
146 break;
147 }
148 }
149 return ucRslt;
150 }
151
152
153 /*关闭定时器
154 tmrId:定时器ID
155 */
156 void KillTimer(TIMER tmrId) 157 {
158 TimerStop(tmrId,0);
159 switch(tmrId)
160 {
161 case 2:
162 acTimerId[8] = 0; 163 break;
164 case 3:
165 acTimerId[3] = 0; 166 break;
167 case 4:
168 acTimerId[4] = 0; 169 break;
170 case 5:
171 acTimerId[9] = 0; 172 break;
173 case 9:
174 acTimerId[0] = 0; 175 break;
176 case 10:
177 acTimerId[1] = 0; 178 break;
179 case 11:
180 acTimerId[2] = 0; 181 break;
182 case 12:
183 acTimerId[5] = 0; 184 break;
185 case 13:
186 acTimerId[6] = 0; 187 break;
188 case 14:
189 acTimerId[7] = 0;
190 break;
191 default:
192 break;
193 }
194 }
195
196 //定时器2中断服务程序
197 void TIM2_IRQHandler(void)
198 {
199 if(TIM2->SR&0X0001)//溢出中断
200 {
201 if(ucTmr2Efct)
202 {
203 if(Timer2Fun)
204 {
205 (*Timer2Fun)(ucTimer2Para);
206 }
207
208 if(anTimingCnt[8] > 1) //判断计时次数209 {
210 anTimingCnt[8]--;
211 }
212 else if(1 == anTimingCnt[8]) //计时次数完成213 {
214 KillTimer(2);
215 }
216 }
217 else
218 {
219 ucTmr2Efct = 1;
220 }
221 }
222 TIM2->SR&=~(1<<0);//清除中断标志位
223 }
224 //定时器3中断服务程序
225 void TIM3_IRQHandler(void)
226 {
227 if(TIM3->SR&0X0001)//溢出中断
228 {
229 if(1 == ucTmr3Efct)
230 {
231 if(Timer3Fun)
232 {
233 (*Timer3Fun)(ucTimer3Para);
234 }
235
236 if(anTimingCnt[3] > 1) //判断计时次数237 {
238 anTimingCnt[3] --;
239 }
240 else if(1 == anTimingCnt[3]) //计时次数完成241 {
242 KillTimer(3);
243 }
244 }
245 else
246 {
247 ucTmr3Efct = 1;
248 }
249 }
250 TIM3->SR&=~(1<<0);//清除中断标志位
251 }
252 //定时器4中断服务程序
253 void TIM4_IRQHandler(void)
254 {
255 if(TIM4->SR&0X0001)//溢出中断
256 {
257 if(1 == ucTmr4Efct)
258 {
259 if(Timer4Fun)
260 {
261 (*Timer4Fun)(ucTimer4Para);
262 }
263
264 if(anTimingCnt[4] > 1) //判断计时次数265 {
266 anTimingCnt[4] --;
267 }
268 else if(1 == anTimingCnt[4]) //计时次数完成269 {
270 KillTimer(4);
271 }
272 }
273 else
274 {
275 ucTmr4Efct = 1;
276 }
277 }
278 TIM4->SR&=~(1<<0);//清除中断标志位
279 }
280 //定时器5中断服务程序
281 void TIM5_IRQHandler(void)
282 {
283 if(TIM5->SR&0X0001)//溢出中断
284 {
285 if(1 == ucTmr5Efct)
286 {
287 if(Timer5Fun)
288 {
289 (*Timer5Fun)(ucTimer5Para);
290 }
291
292 if(anTimingCnt[9] > 1) //判断计时次数293 {
294 anTimingCnt[9] --;
295 }
296 else if(1 == anTimingCnt[9]) //计时次数完成
297 {
298 KillTimer(5);
299 }
300 }
301 else
302 {
303 ucTmr5Efct = 1;
304 }
305 }
306 TIM5->SR&=~(1<<0);//清除中断标志位
307 }
308 //定时器9中断服务程序
309 void TIM1_BRK_TIM9_IRQHandler(void)
310 {
311 if(TIM9->SR&0X0001)//溢出中断
312 {
313 if(1 == ucTmr9Efct)
314 {
315 if(Timer9Fun)
316 {
317 (*Timer9Fun)(ucTimer9Para);
318 }
319
320 if(anTimingCnt[0] > 1) //判断计时次数321 {
322 anTimingCnt[0]--;
323 }
324 else if(1 == anTimingCnt[0]) //计时次数完成325 {
326 KillTimer(9);
327 }
328 }
329 else
330 {
331 ucTmr9Efct = 1;
332 }
333 TIM9->SR&=~(1<<0);//清除中断标志位
334 }
335 }
336
337 //定时器10中断服务程序
338 void TIM1_UP_TIM10_IRQHandler(void)
339 {
340 if(TIM10->SR&0X0001)//溢出中断
341 {
342 if(1 == ucTmr10Efct)
343 {
344 if(Timer10Fun)
345 {
346 (*Timer10Fun)(ucTimer10Para);
347
}
348
349 if(anTimingCnt[1] > 1) //判断计时次数350 {
351 anTimingCnt[1] --;
352 }
353 else if(1 == anTimingCnt[1]) //计时次数完成354 {
355 KillTimer(10);
356 }
357 }
358 else
359 {
360 ucTmr10Efct = 1;
361 }
362 TIM10->SR&=~(1<<0);//清除中断标志位
363 }
364 }
365
366
367 //定时器11中断服务程序
368 void TIM1_TRG_COM_TIM11_IRQHandler(void)
369 {
370 if(TIM11->SR&0X0001)//溢出中断
371 {
372 if(1 == ucTmr11Efct)
373 {
374 if(Timer11Fun)
375 {
376 (*Timer11Fun)(ucTimer11Para);
377
}
378
379 if(anTimingCnt[2] > 1) //判断计时次数380 {
381 anTimingCnt[2] --;
382 }
383 else if(1 == anTimingCnt[2]) //计时次数完成384 {
385 KillTimer(11);
386 }
387 }
388 else
389 {
390 ucTmr11Efct = 1;
391 }
392 TIM11->SR&=~(1<<0);//清除中断标志位
393 }
394 }
395
396
397
398 //定时器12中断服务程序
399 void TIM8_BRK_TIM12_IRQHandler(void)
400 {
401 if(TIM12->SR&0X0001)//溢出中断
402 {
403 if(1 == ucTmr12Efct)
404 {
405 if(Timer12Fun)
406 {
407 (*Timer12Fun)(ucTimer12Para);
408 }
409
410 if(anTimingCnt[5] > 1) //判断计时次数411 {
412 anTimingCnt[5] --;
413 }
414 else if(1 == anTimingCnt[5]) //计时次数完成415 {
416 KillTimer(12);
417 }
418 }
419 else
420 {
421 ucTmr12Efct = 1;
422 }
423 TIM12->SR&=~(1<<0);//清除中断标志位
424 }
425 }
426
427
428 //定时器13中断服务程序
429 void TIM8_UP_TIM13_IRQHandler(void)
430 {
431 if(TIM13->SR&0X0001)//溢出中断
432 {
433 if(1 == ucTmr13Efct)
434 {
435 if(Timer13Fun)
436 {
437 (*Timer13Fun)(ucTimer13Para);
438 }
440 if(anTimingCnt[6] > 1) //判断计时次数441 {
442 anTimingCnt[6] --;
443 }
444 else if(1 == anTimingCnt[6]) //计时次数完成445 {
446 KillTimer(13);
447 }
448 }
449 else
450 {
451 ucTmr13Efct = 1;
452 }
453 TIM13->SR&=~(1<<0);//清除中断标志位
454 }
455 }
456
457
458 //定时器14中断服务程序
459 void TIM8_TRG_COM_TIM14_IRQHandler(void)
460 {
461 if(TIM14->SR&0X0001)//溢出中断
462 {
463 if(1 == ucTmr14Efct)
464 {
465 if(Timer14Fun)
466 {
467 (*Timer14Fun)(ucTimer14Para);
468 }
469
470 if(anTimingCnt[7] > 1) //判断计时次数471 {
472 anTimingCnt[7] --;
473 }
474 else if(1 == anTimingCnt[7]) //计时次数完成
476 KillTimer(14);
477 }
478 }
479 else
480 {
481 ucTmr14Efct = 1;
482 }
483 TIM14->SR&=~(1<<0);//清除中断标志位
484 }
485 }
486
487
488 /*使能基本计时器
489 ucTimerIdx:计时器编号 范围：2~5 9~14
490 unCount 自动重装值。

491 uwPsc 计数器分频 2-65535 计时时间 = unCount * uwPsc / 84M(168M if ucTimerIdx in{9, 10, 11})
492 pHandler 计数完成后执行函数
493 ucPara 执行函数的参数
494
495
496 返回值:
497 0:成功
498 1:ucOpt unRunningFreqency unCount 参数错误
499 2:定时器编号参数错误
500 3:定时器已经被占用
501 4:16位定时器传入的计数参数超阈值*/
502 u8 TimerEnable(u8 ucTimerIdx, u32 unCount, u16 uwPsc,TIMERFUN pHandler,u8 ucPara)
503 {
504 //参数检查
505 if(unCount < 2 || uwPsc < 2 || uwPsc > 65535) //参数错误:重装值、分频数设置错误
506 {
507 return 1; 508 }
509 if(ucTimerIdx < 2 || ucTimerIdx > 14 || (ucTimerIdx > 5 && ucTimerIdx < 9) ) //参数错误:不是
2-5 9-14定时器 510 {
511 return 2; 512 } 513 514 515
516 switch(ucTimerIdx) 517 { 518 case 2:
519 if(0x0001 & TIM2 ->CR1) //定时器正在被使用 520 {
521 return 3; 522 }
523 RCC ->APB1ENR |= 1; 524 TIM2 ->ARR = unCount - 1; 525 TIM2 ->PSC = uwPsc - 1; 526 TIM2 ->DIER |= 1; 527 Timer2Fun = pHandler; 528 ucTimer2Para = ucPara; 529 MY_NVIC_Init(2,0,TIM2_IRQn,2); 530 TIM2->SR = 0;//清除中断标志位 531 TIM2 ->CR1 |= 0x01; 532 break; 533 case 3:
534 if(unCount > 0x0000FFFF) 535 {
536 return 4; 537 }
538 if(0x0001 & TIM3 ->CR1) //定时器正在被使用 539 {
540 return 3;
541 }
542 RCC ->APB1ENR |= 1 << 1; //使能定时器时钟543 TIM3 ->ARR = unCount - 1;
544 TIM3 ->PSC = uwPsc - 1;
545 TIM3 ->DIER |= 1;
546 Timer3Fun = pHandler;
547 ucTimer3Para = ucPara;
548 MY_NVIC_Init(0,3,TIM3_IRQn,2);
549 TIM3->SR = 0;//清除中断标志位
550 TIM3 ->CR1 |= 0x01;
551 break;
552 case 4:
553 if(unCount > 0x0000FFFF)
554 {
555 return 4;
556 }
557 if(0x0001 & TIM4 ->CR1) //定时器正在被使用558 {
559 return 3;
560 }
561 RCC ->APB1ENR |= 1 << 2; //使能定时器时钟562 TIM4 ->ARR = unCount - 1;
563 TIM4 ->PSC = uwPsc - 1;
564 TIM4 ->DIER |= 1;
565
566 Timer4Fun = pHandler;
567 ucTimer4Para = ucPara;
568 MY_NVIC_Init(1, 0 , TIM4_IRQn, 2);
569 TIM4->SR = 0;//清除中断标志位
570 TIM4 ->CR1 |= 0x01;
571 break;
572 case 5:
573 if(0x0001 & TIM5 ->CR1) //定时器正在被使用574 {
575 return 3;
576 }
577 RCC ->APB1ENR |= 1 << 3; //使能定时器时钟 578 TIM5 ->ARR = unCount - 1; 579 TIM5 ->PSC = uwPsc - 1; 580 TIM5 ->DIER |= 1; 581
582 Timer5Fun = pHandler; 583 ucTimer5Para = ucPara; 584 MY_NVIC_Init(2,1,TIM5_IRQn,2); 585 TIM5->SR = 0;//清除中断标志位 586 TIM5 ->CR1 |= 0x01; 587 break; 588 case 9:
589 if(0x0001 & TIM9 ->CR1) //定时器正在被使用 590 {
591 return 3; 592 }
593 RCC ->APB2ENR |= 1 << 16; //使能定时器时钟 594 TIM9 ->ARR = unCount - 1; 595 TIM9 ->PSC = uwPsc - 1; 596 TIM9 ->DIER |= 1; 597
598 Timer9Fun = pHandler; 599 ucTimer9Para = ucPara;
600 MY_NVIC_Init(0, 0 ,TIM1_BRK_TIM9_IRQn,2); 601 TIM9->SR = 0;//清除中断标志位 602 TIM9 ->CR1 |= 0x01; 603 break; 604 case 10:
605
if(0x0001 & TIM10 ->CR1) //定时器正在被使用 606 {
607 return 3; 608 }
609 RCC ->APB2ENR |= 1 << 17; //使能定时器时钟 610 TIM10 ->ARR = unCount - 1; 611 TIM10 ->PSC = uwPsc - 1;
612 TIM10 ->DIER |= 1; 613
614 Timer10Fun = pHandler; 615 ucTimer10Para = ucPara;
616 MY_NVIC_Init(0, 1 ,TIM1_UP_TIM10_IRQn,2); 617 TIM10->SR = 0;//清除中断标志位 618 TIM10 ->CR1 |= 0x01; 619 break; 620 case 11:
621
if(0x0001 & TIM11 ->CR1) //定时器正在被使用 622 {
623 return 3; 624 }
625 RCC ->APB2ENR |= 1 << 18; //使能定时器时钟 626 TIM11 ->ARR = unCount - 1; 627 TIM11 ->PSC = uwPsc - 1; 628 TIM11 ->DIER |= 1; 629
630 Timer11Fun = pHandler; 631 ucTimer11Para = ucPara;
632 MY_NVIC_Init(0, 2 ,TIM1_TRG_COM_TIM11_IRQn,2); 633 TIM11->SR = 0;//清除中断标志位 634 TIM11 ->CR1 |= 0x01; 635 break; 636 case 12:
637
if(0x0001 & TIM12 ->CR1) //定时器正在被使用 638 {
639 return 3; 640 }
641 RCC ->APB1ENR |= 1 << 6; //使能定时器时钟 642 TIM12 ->ARR = unCount - 1; 643 TIM12 ->PSC = uwPsc - 1; 644 TIM12 ->DIER |= 1; 645
646 Timer12Fun = pHandler; 647 ucTimer12Para = ucPara;
648 MY_NVIC_Init(1, 1 ,TIM8_BRK_TIM12_IRQn,2); 649 TIM12->SR = 0;//清除中断标志位 650 TIM12 ->CR1 |= 0x01; 651 break; 652 case 13:
653
if(0x0001 & TIM13 ->CR1) //定时器正在被使用 654 {
655 return 3; 656 }
657 RCC ->APB1ENR |= 1 << 7; //使能定时器时钟 658 TIM13 ->ARR = unCount - 1; 659 TIM13 ->PSC = uwPsc - 1; 660 TIM13 ->DIER |= 1; 661
662 Timer13Fun = pHandler; 663 ucTimer13Para = ucPara;
664 MY_NVIC_Init(1, 2 ,TIM8_UP_TIM13_IRQn,2); 665 TIM13->SR = 0;//清除中断标志位 666 TIM13 ->CR1 |= 0x01; 667 break; 668 case 14:
669
if(0x0001 & TIM14 ->CR1) //定时器正在被使用 670 {
671 return 3; 672 }
673 RCC ->APB1ENR |= 1 << 8; //使能定时器时钟 674 TIM14 ->ARR = unCount - 1; 675 TIM14 ->PSC = uwPsc - 1; 676 TIM14 ->DIER |= 1; 677
678 Timer14Fun = pHandler; 679 ucTimer14Para = ucPara;
680 MY_NVIC_Init(1, 3 ,TIM8_TRG_COM_TIM14_IRQn,2);
681 TIM14->SR = 0;//清除中断标志位
682 TIM14 ->CR1 |= 0x01;
683 break;
684 default:
685 break;
686 }
687 return 0; //返回成功
688 }
689
690
691 /*停止基本计时器使能位置0，停止其时钟
692 ucTimerIdx:计时器编号范围：2~5
693 ucOpt 可选参数保留不用
694 */
695 void TimerStop(u8 ucTimerIdx,u8 ucOpt)
696 {
697 switch(ucTimerIdx)
698 {
699 case 2:
700 TIM2 ->CR1 &= ~(1 << 0); //关闭使能701 Timer2Fun = 0;
702 ucTimer2Para = 0;
703 ucTmr2Efct = 0;
704 break;
705 case 3:
706 TIM3 ->CR1 &= ~(1 << 0); //关闭使能707 Timer3Fun = 0;
708 ucTimer3Para = 0;
709 ucTmr3Efct = 0;
710 break;
711 case 4:
712 TIM4 ->CR1 &= ~(1 << 0); //关闭使能713 Timer4Fun = 0;
714 ucTimer4Para = 0;
715 ucTmr4Efct = 0;
717 case 5:
718 TIM5 ->CR1 &= ~(1 << 0); //关闭使能719 Timer5Fun = 0;
720 ucTimer5Para = 0;
721 ucTmr5Efct = 0;
722 break;
723 case 9:
724 TIM9 ->CR1 &= ~(1 << 0); //关闭使能725 Timer9Fun = 0;
726 ucTimer9Para = 0;
727 ucTmr9Efct = 0;
728 break;
729 case 10:
730 TIM10 ->CR1 &= ~(1 << 0); //关闭使能731 Timer10Fun = 0;
732 ucTimer10Para = 0;
733 ucTmr10Efct = 0;
734 break;
735 case 11:
736 TIM11 ->CR1 &= ~(1 << 0); //关闭使能737 Timer11Fun = 0;
738 ucTimer11Para = 0;
739 ucTmr11Efct = 0;
740 break;
741 case 12:
742 TIM12 ->CR1 &= ~(1 << 0); //关闭使能743 Timer12Fun = 0;
744 ucTimer12Para = 0;
745 ucTmr12Efct = 0;
746 break;
747 case 13:
748 TIM13 ->CR1 &= ~(1 << 0); //关闭使能749 Timer13Fun = 0;
750 ucTimer13Para = 0;
751 ucTmr13Efct = 0;
753 case 14:
754 TIM14 ->CR1 &= ~(1 << 0); //关闭使能755 Timer14Fun = 0;
756 ucTimer14Para = 0;
757 ucTmr14Efct = 0;
758 break;
759 default:
760 break;
761 }
762 }
防止小白copy代码而不仔细阅读说明，我把函数类型定义写在这里,大牛请自行添加或修改.
另外，SetTimer那里挖了个坑，摔死一个算一个。

typedef void (*TIMERFUN)(u8);。