[2] STM32F4 - Biblioteka LL - PWM

W tym poście chciałbym przedstawić sposób wygenerowania sygnału PWM na jednym z liczników.

[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

CubeMX:

Poniżej przedstawię przykładowe ustawienie PWM za pomocą Cube Mx. Na samym początku ustawiam odpowiednie kanału pod pinami odpowiedzialnymi za sterowanie ledami.

Następnie ustawiam odpowiednie parametry generowanych sygnałów PWM:

Program PWM:

Wygenerowana funkcja odpowiedzialna za uruchomienie licznika wygląda następująco:

1. static void MX_TIM4_Init(void)
2. {
4.   /* USER CODE BEGIN TIM4_Init 0 */
6.   /* USER CODE END TIM4_Init 0 */
8.   LL_TIM_InitTypeDef TIM_InitStruct = {0};
9.   LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
11.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
13.   /* Peripheral clock enable */
14.   LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM4);
16.   /* USER CODE BEGIN TIM4_Init 1 */
18.   /* USER CODE END TIM4_Init 1 */
19.   TIM_InitStruct.Prescaler = 9;
20.   TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
21.   TIM_InitStruct.Autoreload = 65535;
22.   TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
23.   LL_TIM_Init(TIM4, &TIM_InitStruct);
25.   LL_TIM_DisableARRPreload(TIM4);
26.   LL_TIM_SetClockSource(TIM4, LL_TIM_CLOCKSOURCE_INTERNAL);
28.   LL_TIM_OC_EnablePreload(TIM4, LL_TIM_CHANNEL_CH1);
29.   TIM_OC_InitStruct.OCMode = LL_TIM_OCMODE_PWM1;
30.   TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_DISABLE;
31.   TIM_OC_InitStruct.OCNState = LL_TIM_OCSTATE_DISABLE;
32.   TIM_OC_InitStruct.CompareValue = 0;
33.   TIM_OC_InitStruct.OCPolarity = LL_TIM_OCPOLARITY_HIGH;
34.   LL_TIM_OC_Init(TIM4, LL_TIM_CHANNEL_CH1, &TIM_OC_InitStruct);
35.   LL_TIM_OC_DisableFast(TIM4, LL_TIM_CHANNEL_CH1);
37.   LL_TIM_OC_EnablePreload(TIM4, LL_TIM_CHANNEL_CH2);
38.   TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_DISABLE;
39.   TIM_OC_InitStruct.OCNState = LL_TIM_OCSTATE_DISABLE;
40.   TIM_OC_InitStruct.CompareValue = 0;
41.   LL_TIM_OC_Init(TIM4, LL_TIM_CHANNEL_CH2, &TIM_OC_InitStruct);
42.   LL_TIM_OC_DisableFast(TIM4, LL_TIM_CHANNEL_CH2);
43.   LL_TIM_OC_EnablePreload(TIM4, LL_TIM_CHANNEL_CH3);
45.   TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_DISABLE;
46.   TIM_OC_InitStruct.OCNState = LL_TIM_OCSTATE_DISABLE;
47.   TIM_OC_InitStruct.CompareValue = 0;
48.   LL_TIM_OC_Init(TIM4, LL_TIM_CHANNEL_CH3, &TIM_OC_InitStruct);
49.   LL_TIM_OC_DisableFast(TIM4, LL_TIM_CHANNEL_CH3);
50.   LL_TIM_OC_EnablePreload(TIM4, LL_TIM_CHANNEL_CH4);
52.   TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_DISABLE;
53.   TIM_OC_InitStruct.OCNState = LL_TIM_OCSTATE_DISABLE;
54.   TIM_OC_InitStruct.CompareValue = 0;
55.   LL_TIM_OC_Init(TIM4, LL_TIM_CHANNEL_CH4, &TIM_OC_InitStruct);
56.   LL_TIM_OC_DisableFast(TIM4, LL_TIM_CHANNEL_CH4);
58.   LL_TIM_SetTriggerOutput(TIM4, LL_TIM_TRGO_RESET);
59.   LL_TIM_DisableMasterSlaveMode(TIM4);
60.   /* USER CODE BEGIN TIM4_Init 2 */
62.   /* USER CODE END TIM4_Init 2 */
63.   LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOD);
64.   /**TIM4 GPIO Configuration  
65.   PD12   ------> TIM4_CH1
66.   PD13   ------> TIM4_CH2
67.   PD14   ------> TIM4_CH3
68.   PD15   ------> TIM4_CH4
69.   */
70.   GPIO_InitStruct.Pin = LL_GPIO_PIN_12|LL_GPIO_PIN_13|LL_GPIO_PIN_14|LL_GPIO_PIN_15;
71.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
72.   GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
73.   GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
74.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
75.   GPIO_InitStruct.Alternate = LL_GPIO_AF_2;
76.   LL_GPIO_Init(GPIOD, &GPIO_InitStruct);
77. }

Jak widać wyjścia Timerów zostały przypisane do pinów z podłączonymi diodami na płycie STM32F4 - Discovery.

Następnie należy uruchomić rejestr porównawczy dla odpowiednich kanałów licznika. Następnie uruchamiam poszczególne kanały licznika oraz sam licznik:

1. LL_TIM_OC_EnablePreload(TIM4, LL_TIM_CHANNEL_CH1 | LL_TIM_CHANNEL_CH2 | \
2.        LL_TIM_CHANNEL_CH3 | LL_TIM_CHANNEL_CH4);
3. LL_TIM_CC_EnableChannel(TIM4, LL_TIM_CHANNEL_CH4);
4. LL_TIM_CC_EnableChannel(TIM4, LL_TIM_CHANNEL_CH3);
5. LL_TIM_CC_EnableChannel(TIM4, LL_TIM_CHANNEL_CH2);
6. LL_TIM_CC_EnableChannel(TIM4, LL_TIM_CHANNEL_CH1);
7. LL_TIM_EnableCounter(TIM4);

Ustawienie wartości dla każdego z kanałów wygląda następująco:

1. LL_TIM_OC_SetCompareCH1(TIM4, 500);
2. LL_TIM_OC_SetCompareCH2(TIM4, 40000);
3. LL_TIM_OC_SetCompareCH3(TIM4, 50000);
4. LL_TIM_OC_SetCompareCH4(TIM4, 60000);

Oczywiście wyżej opisane funkcje można też zapisać w sposób operujący bezpośrednio rejestrach ( co jest właściwie tym samym co korzystanie z bibliotek LL, tylko dla biblioteki LL wykorzystywane są makra ułatwiające tą sprawę):

1. /* Enable preload */
2. register __IO uint32_t *pReg = (__IO uint32_t *)((uint32_t)((uint32_t)(&TIM4->CCMR1) + 0x04U));
3. SET_BIT(*pReg, (TIM_CCMR1_OC1PE << SHIFT_TAB_OCxx[6U]));
5. /* Enable channel */
6. ((TIM4->CCER) |= (LL_TIM_CHANNEL_CH1));
7. ((TIM4->CCER) |= (LL_TIM_CHANNEL_CH2));
8. ((TIM4->CCER) |= (LL_TIM_CHANNEL_CH3));
9. ((TIM4->CCER) |= (LL_TIM_CHANNEL_CH4));
11. /* Enable counter */
12. ((TIM4->CR1) |= (TIM_CR1_CEN));
14. /* Set Compare */
15. (TIM4->CCR1) = (30000);
16. (TIM4->CCR2) = (20000);
17. (TIM4->CCR3) = (10000);
18. (TIM4->CCR4) = (5000);