PWM的测试选择了 FreeRTOS_Mutex 例程，主要是因为 PWM 的输出需要更加严格的同步和控制。低功耗模式不适合该应用。PWM的输出设置需要理清程序的同步逻辑。程序首先定义了两个线程Thread1和Thread2，一个Mutex锁信号MutexHandle，通过这个信号进行 UART 资源的保护运行。

6 \, w" ~6 b1 ~, p, m1 [

1. 
   + G: e( }, R9 ]6 g1 _) k0 n+ G0 g
2. osThreadId_t Thread1Handle;
   
3. const osThreadAttr_t Thread1_attributes = {
   ( \: h5 H& e. `* ]
4.   .name = "Thread1",
   
5.   .priority = (osPriority_t) osPriorityNormal,
   2 `! @: x1 N8 h3 Z7 s( i+ R/ g) t
6.   .stack_size = 256 * 4
   
7. };
   
8. /* Definitions for Thread2 */
   
9. osThreadId_t Thread2Handle;
   1 z3 k1 Y1 o' T6 ^( l
10. const osThreadAttr_t Thread2_attributes = {
    5 Y2 c% O' b& F4 y2 |& G
11.   .name = "Thread2",
    5 o4 {1 @. \* M
12.   .priority = (osPriority_t) osPriorityNormal,
    
13.   .stack_size = 256 * 4
    
14. };
    4 ], K1 z4 A6 U" k
15. /* Definitions for Mutex */
    " q, e- d! M" o7 f' ^
16. osMutexId_t MutexHandle;
    
17. const osMutexAttr_t Mutex_attributes = {
    ( T# M$ f+ M* X: T
18.   .name = "Mutex"
    . l# j  I/ f, {6 Z  G) L1 k
19. };

复制代码

首先两个线程在运行前半段使用信号锁进行共用资源 uart 的运行，后面进行运行。
5 {+ |! A! H5 x* U  s8 ?, s
4 v% g/ ?7 `  c

1. 
   ! C8 O, f# ^. B$ v: n2 \8 r
2. /* USER CODE BEGIN Header_Thread1_Entry */
   
3. /**
   + Y1 r. Y" l5 [% }  D. P3 N
4. * @brief Function implementing the Thread1 thread.
   $ j# X, D7 o+ \/ m
5. * @param argument: Not used
   & v" |9 s2 _7 D* @# X
6. * @retval None
   
7. */
   : {3 [1 ~0 }( q9 m0 q; H, b/ l& R
8. /* USER CODE END Header_Thread1_Entry */
   7 e8 J( R$ \+ N. P  a8 R
9. void Thread1_Entry(void *argument)
   : g( N4 v' P* ]% V3 e5 K
10. {
    
11.   /* USER CODE BEGIN Thread1 */
    
12.   uint16_t i;
    ( h+ H, u7 S0 t4 A6 d2 F
13.   /* Infinite loop */
    
14.   for(i = 0; i < 10; ++i)
    ! Z( n4 a# a" E
15.   {
    6 B1 r9 @; i0 X& a/ m, S8 V5 w9 ~
16.   #if EXAMPLE_USES_MUTEX
    
17.   osMutexAcquire(MutexHandle, osWaitForever);
    7 o! x1 {9 q4 N) L' }2 w8 e  p
18.   printf ("Thread1: Mutex Acquired!\n");
    9 s* a) \/ z4 ~- @
19.   #endif
    
20.   
    - X- T8 Q5 b) e1 K$ n
21.   printf("Thread1 : This is message number %u\n", i+1);
    / a" B1 n. U0 s( H7 K
22.   
    5 t0 @& P# O" g. g/ t* y* P
23. #if EXAMPLE_USES_MUTEX
    
24.   printf ("Thread1: Mutex Released!\n");
    
25.   osMutexRelease(MutexHandle);
    / ~% W7 ]0 R2 @% p' w
26.   #endif
    % `' H) |& P- k3 |0 I! |. c
27.     HAL_GPIO_TogglePin(LED1_GREEN_GPIO_Port, LED1_GREEN_Pin);
    ) Z9 e" G* k. q
28.     osDelay(200);
    
29.   }
    
30.   
    ( ~4 {- [3 _; O- @
31.   while(1)
      ?' p4 Y; e  M1 }# G
32.   {
    
33.     HAL_GPIO_TogglePin(LED1_GREEN_GPIO_Port, LED1_GREEN_Pin);
    
34.     osDelay(1000);
    $ i2 h0 _/ ^7 D
35.   }
    
36.   /* USER CODE END Thread1 */
    2 d8 {/ t  Y' }+ P
37. }
    
38. 
    1 @- `/ m( b% C
39. /* USER CODE BEGIN Header_Thread2_Entry */
    
40. /**
    
41. * @brief Function implementing the Thread2 thread.
    
42. * @param argument: Not used
    
43. * @retval None
    5 ?( h5 ^4 h0 j; }/ Q2 ^
44. */
    ! J: \- B# f" k
45. /* USER CODE END Header_Thread2_Entry */
    
46. void Thread2_Entry(void *argument)
    1 s; ]4 S3 X) C
47. {
    2 n9 ?: A1 ]% Y+ P% \* v& v
48.   /* USER CODE BEGIN Thread2 */
    ) R1 I8 k0 ?: B3 r9 q
49.   uint16_t i;
    , }- c& U" c8 ]0 b, l" b
50.   
    6 a4 h- s! w% p0 w' V
51.   /* Infinite loop */
    
52.   for(i = 0; i < 10; ++i)
    6 T' R& Q+ h, o6 N' ?% t! @9 G; }
53.   {
    ' n# Y, t, c7 M4 ^9 C/ N0 v* r$ H9 f
54.   #if EXAMPLE_USES_MUTEX
    + z6 F& P. m6 @4 u
55.     osMutexAcquire(MutexHandle, osWaitForever);
    5 O6 M. \. }' g* x0 u: r2 l3 Z/ m
56.     printf ("Thread2: Mutex Acquired!\n");
    ! m; x$ d' z/ E' ?3 H6 {
57.     #endif
    
58.    
    
59.     printf("Thread2 : This is message number %u\n", i+1);
    2 k/ p5 O$ p# A6 R  e
60. #if EXAMPLE_USES_MUTEX
    
61.     printf ("Thread2: Mutex Released!\n");
    & a* M5 h& J9 b# A  _6 Q
62.     osMutexRelease(MutexHandle);
    
63.     #endif
    2 X, w) ^% K+ {$ F1 k
64.     HAL_GPIO_TogglePin(LED2_YELLOW_GPIO_Port, LED2_YELLOW_Pin);
    * \) F3 W( v$ I" k
65.     osDelay(200);
    
66.   }
    
67.   
    
68.   while(1)
    
69.   {
    * v; B, Q1 q  h7 u+ Y& q" F
70.     HAL_GPIO_TogglePin(LED2_YELLOW_GPIO_Port, LED2_YELLOW_Pin);
    
71.     osDelay(1000);
    5 O# A4 i/ d: v% D, h# m* j& |
72.   }
    
73.     /* USER CODE END Thread2 */
    
74. }
    + Q/ ?9 Q4 D9 r& \2 W$ I; U
75. 
    : l4 a! e1 n" k. x5 C
76. /* Private application code --------------------------------------------------*//* USER CODE BEGIN Application */
    
77. /* USER CODE END Application */

复制代码

# R& o* D. n) Q; W' h1 n3 s进程先获取信号锁，在进行打印输出，输出完成后再解锁，这样可以保证三段打印都是同一个线程的输出。可以看出每次的输出都是一个线程的信息。下面进行PWM的改造测试PWM的设置如图，使用LED1作为PWM的输出，所以设置PB0作为TIM3的CH3通道，PWM输出，脉宽比为50%，所以计数为2048，PLUSE VALUE=1024。设置好以后将程序进行改造，另起一个项目通过CUBE生成初始化代码，然后改造项目。

1. 
   5 X8 U8 W( I5 a! `4 D% D  L
2. /* USER CODE BEGIN Header_Thread1_Entry */
   
3. /**
   
4. * @brief Function implementing the Thread1 thread.
   
5. * @param argument: Not used
   
6. * @retval None
   
7. */
   7 G# G, w# P) Z! v% `  @  q2 m) t
8. /* USER CODE END Header_Thread1_Entry */
   
9. void Thread1_Entry(void *argument)
   ; t% k9 v# _. D4 O" ~
10. {
    
11.   
    
12.   osMutexAcquire(MutexHandle, osWaitForever);
    . S! x& p( E" v4 c/ a6 C  j
13.   printf ("Thread1: Mutex Acquired!\n");
    
14.   printf("Thread1 : PWM starter\n ");
    . s" P5 q2 V% W& c' C
15.   printf ("Thread1: Mutex Released!\n");
    
16.   osMutexRelease(MutexHandle);
    8 L7 @9 o9 F& Z+ ~4 X
17.    HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
    
18.   while(1)
    % y+ A7 U3 p. b& {; L2 X$ |+ l
19.   {
    ' e* Y/ F2 ]8 f9 u
20.     osDelay(1);
    
21.   }
    ( ?6 J0 R  x7 ?7 E" Q' p7 B
22.   /* USER CODE END Thread1 */
    7 W! @4 z4 k# i0 }+ F" r
23. }

复制代码

项目启动后。可以看到LED1开始开始工作。

来源：EEWORLD论坛网友 bigbat 版权归原作者所有
# F% j4 n9 N( f  y8 |
+ L  f0 g: Y4 s) p9 ~7 u' p6 \
$ Y$ }6 z! P  Y" |# J4 |0 l: q' ~