PWM的测试选择了 FreeRTOS_Mutex 例程，主要是因为 PWM 的输出需要更加严格的同步和控制。低功耗模式不适合该应用。PWM的输出设置需要理清程序的同步逻辑。程序首先定义了两个线程Thread1和Thread2，一个Mutex锁信号MutexHandle，通过这个信号进行 UART 资源的保护运行。
1 F6 N& d6 l4 {- j5 K4 m
% o& o  ~5 Q  V& q3 f

1. 
   ) u7 ~$ U% G. i
2. osThreadId_t Thread1Handle;
   + D7 P5 k% }& m% i8 j
3. const osThreadAttr_t Thread1_attributes = {
   
4.   .name = "Thread1",
   ) Q0 h+ L9 V5 w, f8 M; |4 s
5.   .priority = (osPriority_t) osPriorityNormal,
   
6.   .stack_size = 256 * 4
   , }, t; d" ^7 }* q# _+ l3 K
7. };
   , Q$ W8 K+ }2 d% R9 v
8. /* Definitions for Thread2 */
   
9. osThreadId_t Thread2Handle;
   + r0 P2 r+ g; P. W9 ]" ^7 e) r0 X6 y
10. const osThreadAttr_t Thread2_attributes = {
    . _5 Y7 s1 `! I9 U0 ~% v1 I2 ~
11.   .name = "Thread2",
    % s' v- ]& u, s% w
12.   .priority = (osPriority_t) osPriorityNormal,
    4 _% O/ _& Y  A5 c; F9 [* ^3 e
13.   .stack_size = 256 * 4
    ( A( C2 j1 @, G- |
14. };
    
15. /* Definitions for Mutex */
    5 d. ?. z+ U( m
16. osMutexId_t MutexHandle;
    8 n4 W4 [1 a% T4 T  j
17. const osMutexAttr_t Mutex_attributes = {
    
18.   .name = "Mutex"
    
19. };

复制代码

首先两个线程在运行前半段使用信号锁进行共用资源 uart 的运行，后面进行运行。

5 S. I. _6 u+ e. p$ R9 B

1. 
   
2. /* USER CODE BEGIN Header_Thread1_Entry */
   
3. /**
   1 X  N' M$ P/ R6 O8 J0 K
4. * @brief Function implementing the Thread1 thread.
   
5. * @param argument: Not used
   
6. * @retval None
   ; {2 o5 {) P5 g. T) g
7. */
   
8. /* USER CODE END Header_Thread1_Entry */
   # c6 K+ Y+ X: x6 t3 k, H
9. void Thread1_Entry(void *argument)
   0 C/ d+ }& V2 j9 Q4 B! Q
10. {
    ; z: `. {8 z* O8 O
11.   /* USER CODE BEGIN Thread1 */
    : V2 r- T8 ~9 L  W; K/ ~& R7 r
12.   uint16_t i;
    
13.   /* Infinite loop */
    2 P8 Z6 S6 R9 Y3 N! V
14.   for(i = 0; i < 10; ++i)
    
15.   {
    
16.   #if EXAMPLE_USES_MUTEX
    / R6 c! ?1 P" R& c& y! U* D
17.   osMutexAcquire(MutexHandle, osWaitForever);
    
18.   printf ("Thread1: Mutex Acquired!\n");
    
19.   #endif
    & k: V* n' T' I. P8 x  x9 r5 f
20.   
    
21.   printf("Thread1 : This is message number %u\n", i+1);
    ) V: f, t# d4 [  O3 |
22.   
    ) ]) C+ ^+ B; N+ x6 [
23. #if EXAMPLE_USES_MUTEX
    - a' V: _% ~' ^- s
24.   printf ("Thread1: Mutex Released!\n");
    
25.   osMutexRelease(MutexHandle);
    
26.   #endif
    
27.     HAL_GPIO_TogglePin(LED1_GREEN_GPIO_Port, LED1_GREEN_Pin);
    
28.     osDelay(200);
      H; ?+ O7 M! ]% Q4 y. D
29.   }
    
30.   
    - L  E& t+ z1 W# T6 y( U0 `$ R6 W
31.   while(1)
    ' I4 ^$ s# g7 I! q2 A: T1 ?1 \
32.   {
    ! {3 A$ J/ [" c/ {
33.     HAL_GPIO_TogglePin(LED1_GREEN_GPIO_Port, LED1_GREEN_Pin);
    * a5 J$ S* V" h; w+ w
34.     osDelay(1000);
    6 x& r% f7 e& O- o% \
35.   }
    2 g' V. {3 D# a1 I: C
36.   /* USER CODE END Thread1 */
    5 D( u; R* V# L  O- x% v# i
37. }
    . ^( D* D, y+ X6 T; M6 x% t: {* ?
38. 
    
39. /* USER CODE BEGIN Header_Thread2_Entry */
    : A  a# a7 U8 w
40. /**
    - O0 j, ~! ]. L9 Z
41. * @brief Function implementing the Thread2 thread.
    
42. * @param argument: Not used
    
43. * @retval None
    1 f# H2 P) u* y# v- ?) v# \2 n. y- C
44. */
    / m9 o+ h7 y/ D- z- m: C1 s( G3 N
45. /* USER CODE END Header_Thread2_Entry */
    
46. void Thread2_Entry(void *argument)
    5 ?- d6 G& z% C; Y: e) B% a; A5 r
47. {
    
48.   /* USER CODE BEGIN Thread2 */
    
49.   uint16_t i;
    : d3 b) Y& r% i( ?4 S& _8 l
50.   
    ) [' \( \$ K! ]2 x" R
51.   /* Infinite loop */
    5 Z9 S# H3 z, V# j7 n: P9 g# `
52.   for(i = 0; i < 10; ++i)
    
53.   {
      L3 e5 A+ p1 S/ d. t( X( K
54.   #if EXAMPLE_USES_MUTEX
    
55.     osMutexAcquire(MutexHandle, osWaitForever);
    
56.     printf ("Thread2: Mutex Acquired!\n");
    
57.     #endif
    + X0 M& A5 f* _4 A
58.    
    # l" H+ k! Z1 D& g# j9 ~
59.     printf("Thread2 : This is message number %u\n", i+1);
    
60. #if EXAMPLE_USES_MUTEX
    
61.     printf ("Thread2: Mutex Released!\n");
    $ p/ P, |9 `. N$ a
62.     osMutexRelease(MutexHandle);
    $ ?4 ^9 k& n2 ?4 [+ c0 I4 t5 J
63.     #endif
    6 `: ]& z6 `1 p9 L, v  s5 D4 O: m
64.     HAL_GPIO_TogglePin(LED2_YELLOW_GPIO_Port, LED2_YELLOW_Pin);
    % T' r, w* J4 F3 C7 e: Q
65.     osDelay(200);
    - G" y4 X, K0 J+ n& d
66.   }
    
67.   
    
68.   while(1)
    ( s& Q& y+ K' @6 u  \0 F0 _
69.   {
    / w/ ?9 F9 h" T8 [* t* l& h
70.     HAL_GPIO_TogglePin(LED2_YELLOW_GPIO_Port, LED2_YELLOW_Pin);
    
71.     osDelay(1000);
    
72.   }
    # {& N7 j, T9 k! L2 z/ S  G
73.     /* USER CODE END Thread2 */
    1 V6 A1 c2 q+ f
74. }
    
75. 
    
76. /* Private application code --------------------------------------------------*//* USER CODE BEGIN Application */
    
77. /* USER CODE END Application */

复制代码

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

1. 
   
2. /* USER CODE BEGIN Header_Thread1_Entry */
   
3. /**
   & ~" \+ X% r) N
4. * @brief Function implementing the Thread1 thread.
   2 F; F% ]8 X* M% X% x% z6 I+ w
5. * @param argument: Not used
   6 W' F7 A" Z3 {. ^( t" l
6. * @retval None
   
7. */
   - Q1 p& ]0 t0 m% k, Z
8. /* USER CODE END Header_Thread1_Entry */
   7 Y- n. `# o4 ?& a" v
9. void Thread1_Entry(void *argument)
   
10. {
    
11.   
    2 R$ F0 E8 G" }9 T& N0 {1 T
12.   osMutexAcquire(MutexHandle, osWaitForever);
    
13.   printf ("Thread1: Mutex Acquired!\n");
    " C& u" \7 j  P7 v2 c, J- X
14.   printf("Thread1 : PWM starter\n ");
    6 V8 x& J/ _& l1 r8 @& M% t7 D
15.   printf ("Thread1: Mutex Released!\n");
    ! m# V! t. R- k& N3 I
16.   osMutexRelease(MutexHandle);
    + {3 U) G7 J: X, G5 Z6 Z
17.    HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
    
18.   while(1)
    
19.   {
    : r& S4 ^4 l& R# w+ C6 n! _1 Q
20.     osDelay(1);
    
21.   }
    
22.   /* USER CODE END Thread1 */
    
23. }

复制代码

项目启动后。可以看到LED1开始开始工作。
  ~8 q' Z' t6 C( q/ L) e# ~# B6 G
4 y% T4 S; u2 G. b1 T来源：EEWORLD论坛网友 bigbat 版权归原作者所有

2 h$ T3 F1 G: E' V' i