• (STM32)从零开始的RT-Thread之旅--PWM驱动ST7735调光

    上一章我们先用SPI读取到了LCD的ID，这一章则是使用PWM调光点亮屏幕，因为测试这块屏幕时，发现直接设置背光引脚为高好像无法点亮，好像必须使用PWM调光，不过反正后面调节亮度还是需要PWM，索性先打通PWM。但这其中官方留的坑还是挺多的，简单的一个PWM因为需要契合内核驱动框架调了半天。

    一如之前配置SPI的时候先配置RT-Thread Settings：

    如果图形界面没有PWM，随便右键一个图标，点击配置项。

    然后还是到board.h中定义相关的宏定义：

    看一下介绍，结合上一章所讲，大致调用流程也很清晰。如果你在CubeMX中配置了相关PWM，就会生成这两个函数：

    此时编译后会发现存在问题：

    打开pwm_config.h中可以看到PWM_CONFIG是从PWM2开始配置的：

    如果使用的PWM1则需要仿照现有的添加一个PWM1的：

     这里 tim_handle.Instance 也就是我们的PWM1对应的定时器是TIM1，名字是"pwm1"，这个名字和我们之前用SPI4注册"spi40"设备时用的总线名字一样，我们到时候会通过一个函数搜索到它，如官方给的例子：

    再次编译发现还回有问题，问题出在drv_pwm_set和drv_pwm_get这两个函数中，这是因为内核没有把H7系列的芯片包含进去：

    可以看到这里的内核驱动代码还不完善，其实这里主要是为了获取 tim_clock 这个变量，也就是定时器时钟，但是对于H7来说，确定用的哪个定时器很重要。详细可以参考：

    H7定时器

    这个应该是硬汉出的教程，别人转载的。这里我讲一下我是用的TIM1是怎么配置的，你可以根据需要配置你自己的定时器。这里讲解一下怎么由时钟树理解时钟走向。

    首先我们进到 HAL_RCC_GetPCLK2Freq 这个函数中，如果你定时器挂载在APB1上，则应该使用的是 HAL_RCC_GetPCLK1Freq 这个函数获取PCLK1的频率。为什么需要用这个函数？我们从时钟树上理一下，这部分时钟树如下：

    TIM1挂载在APB2下，时钟源是 rcc_timy_ker_ck ，我们需要先确定 rcc_pclk2的频率，也就是APB2总线的频率，它又来自于 rcc_hclk ，也就是AHB1/2的时钟，所以我们进入函数HAL_RCC_GetPCLK2Freq 可以看到：

    首先我们通过HAL_RCC_GetHCLKFreq()这个函数获取到HCLK的时钟频率，然后拆分后面的部分，(RCC->D2CFGR & RCC_D2CFGR_D2PPRE2)>> RCC_D2CFGR_D2PPRE2_Pos 是为了获取 RCC_D2CFGR_D2PPRE2 寄存器的值，原理如下：

    获取到 RCC_D2CFGR_D2PPRE2 寄存器的值后，查表：

    比如这个寄存器的值是 110，即6，D1CorePrescTable[6] = 3，HCLK的时钟右移3，相当于除以8，正好和上图中计算110：rcc_pclk2的情况相同。然后根据这个时钟去计算定时器时钟，这又分为两个情况：

    源码中我们可以看到在使用 HAL_RCC_GetPCLK2Freq 获取定时器时钟的情况中只有乘2这一种情况：

    但其实应该是两种情况，我这里在CubeMX中 D2PPRE2 寄存器选择的是除以2，所以这里乘2是没有关系的： 

    如果在CubeMX中D2PPRE2选择1，你会发现定时器那里会自动选为除以1，但是选1的话可以看到会有如下提示：

    APB2最大只能120MHz，选1则系统主频最高只能240MHz了。 

    修改完这里，编译即可正常通过。然后我们就可以开始调用官方给的接口函数控制PWM了：

    1. #include 
    2. #include 
    3. #include "mpwm.h"
    4. #include 
    5. struct rt_device_pwm *pwm_lcd;
    6.  
    7. static uint32_t mpulse = 0;
    8.  
    9. void mpwm_set(uint32_t pulse)
    10. {
    11.     mpulse = pulse;
    12.     rt_pwm_set(pwm_lcd,2,1000,pulse);
    13.  
    14. }
    15.  
    16. uint32_t mpwm_get(void)
    17. {
    18.     return mpulse;
    19. }
    20.  
    21. void mpwm_init(void)
    22. {
    23.  
    24.     pwm_lcd = (struct rt_device_pwm *)rt_device_find("pwm1");
    25.     if(!pwm_lcd)
    26.     {
    27.         rt_kprintf("pwm1 can't find\n");
    28.     }
    29.     rt_pwm_enable(pwm_lcd,2);
    30.     rt_pwm_set(pwm_lcd,2,1000,0);
    31. }

    这里简单写了几个接口函数，实际直接使用，发现并没有输出，主要的坑已经全踩过了！懒得给官方提PR了，留给后人完善吧。

    STM32的PWM所使用定时的初始化在内核驱动 drv_pwm.c 文件中的 stm32_pwm_init的 stm32_hw_pwm_init 函数里：

    注意上图红色方框，你使用哪个定时器就需要添加哪个定时器的时钟使能。其次高级定时器一些额外的设置也需要添加，你如果不知道你用的定时器需不需要添加这些，请参照你使用CubeMX生成的定时器配置，我这里是在main.c中：

    根据上面函数的配置，添加到这个函数里： 

    我这里使用的TIM1需要配置刹车和死区配置。添加完这些，你会发现还是无法使用PWM输出，这是因为是使能函数有问题：

    在同个文件中还有pwm使能函数，这个函数中所使用的 HAL_TIM_PWM_Start 函数只对普通定时器有效，TIM1是高级定时器，所以应该使用的函数是：HAL_TIMEx_PWMN_Start 。我这里不考虑其他情况，只针对我自己的工程做以下修改：

    此时再使用PWM即可正常使用。 

    下一章：

    (STM32)从零开始的RT-Thread之旅--SPI驱动ST7735(2)

    附：

    drv_pwm.c(仅供参考)：

    1. /*
    2.  * Copyright (c) 2006-2018, RT-Thread Development Team
    3.  *
    4.  * SPDX-License-Identifier: Apache-2.0
    5.  *
    6.  * Change Logs:
    7.  * Date           Author       Notes
    8.  * 2018-12-13     zylx         first version
    9.  */
    10.  
    11. #include 
    12. #include
    13. #include
    14.  
    15. #ifdef RT_USING_PWM
    16. #include "drv_config.h"
    17.  
    18. #define DRV_DEBUG
    19. #define LOG_TAG             "drv.pwm"
    20. #include 
    21.  
    22. #define MAX_PERIOD 65535
    23. #define MIN_PERIOD 3
    24. #define MIN_PULSE 2
    25.  
    26. extern void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
    27.  
    28. enum
    29. {
    30. #ifdef BSP_USING_PWM1
    31.     PWM1_INDEX,
    32. #endif
    33. #ifdef BSP_USING_PWM2
    34.     PWM2_INDEX,
    35. #endif
    36. #ifdef BSP_USING_PWM3
    37.     PWM3_INDEX,
    38. #endif
    39. #ifdef BSP_USING_PWM4
    40.     PWM4_INDEX,
    41. #endif
    42. #ifdef BSP_USING_PWM5
    43.     PWM5_INDEX,
    44. #endif
    45. #ifdef BSP_USING_PWM6
    46.     PWM6_INDEX,
    47. #endif
    48. #ifdef BSP_USING_PWM7
    49.     PWM7_INDEX,
    50. #endif
    51. #ifdef BSP_USING_PWM8
    52.     PWM8_INDEX,
    53. #endif
    54. #ifdef BSP_USING_PWM9
    55.     PWM9_INDEX,
    56. #endif
    57. #ifdef BSP_USING_PWM10
    58.     PWM10_INDEX,
    59. #endif
    60. #ifdef BSP_USING_PWM11
    61.     PWM11_INDEX,
    62. #endif
    63. #ifdef BSP_USING_PWM12
    64.     PWM12_INDEX,
    65. #endif
    66. #ifdef BSP_USING_PWM13
    67.     PWM13_INDEX,
    68. #endif
    69. #ifdef BSP_USING_PWM14
    70.     PWM14_INDEX,
    71. #endif
    72. #ifdef BSP_USING_PWM15
    73.     PWM15_INDEX,
    74. #endif
    75. #ifdef BSP_USING_PWM16
    76.     PWM16_INDEX,
    77. #endif
    78. #ifdef BSP_USING_PWM17
    79.     PWM17_INDEX,
    80. #endif
    81. };
    82.  
    83. struct stm32_pwm
    84. {
    85.     struct rt_device_pwm pwm_device;
    86.     TIM_HandleTypeDef    tim_handle;
    87.     rt_uint8_t channel;
    88.     char *name;
    89. };
    90.  
    91. static struct stm32_pwm stm32_pwm_obj[] =
    92. {
    93. #ifdef BSP_USING_PWM1
    94.     PWM1_CONFIG,
    95. #endif
    96.  
    97. #ifdef BSP_USING_PWM2
    98.     PWM2_CONFIG,
    99. #endif
    100.  
    101. #ifdef BSP_USING_PWM3
    102.     PWM3_CONFIG,
    103. #endif
    104.  
    105. #ifdef BSP_USING_PWM4
    106.     PWM4_CONFIG,
    107. #endif
    108.  
    109. #ifdef BSP_USING_PWM5
    110.     PWM5_CONFIG,
    111. #endif
    112.  
    113. #ifdef BSP_USING_PWM6
    114.     PWM6_CONFIG,
    115. #endif
    116.  
    117. #ifdef BSP_USING_PWM7
    118.     PWM7_CONFIG,
    119. #endif
    120.  
    121. #ifdef BSP_USING_PWM8
    122.     PWM8_CONFIG,
    123. #endif
    124.  
    125. #ifdef BSP_USING_PWM9
    126.     PWM9_CONFIG,
    127. #endif
    128.  
    129. #ifdef BSP_USING_PWM10
    130.     PWM10_CONFIG,
    131. #endif
    132.  
    133. #ifdef BSP_USING_PWM11
    134.     PWM11_CONFIG,
    135. #endif
    136.  
    137. #ifdef BSP_USING_PWM12
    138.     PWM12_CONFIG,
    139. #endif
    140.  
    141. #ifdef BSP_USING_PWM13
    142.     PWM13_CONFIG,
    143. #endif
    144.  
    145. #ifdef BSP_USING_PWM14
    146.     PWM14_CONFIG,
    147. #endif
    148.  
    149. #ifdef BSP_USING_PWM15
    150.     PWM15_CONFIG,
    151. #endif
    152.  
    153. #ifdef BSP_USING_PWM16
    154.     PWM16_CONFIG,
    155. #endif
    156.  
    157. #ifdef BSP_USING_PWM17
    158.     PWM17_CONFIG,
    159. #endif
    160. };
    161.  
    162. static rt_err_t drv_pwm_control(struct rt_device_pwm *device, int cmd, void *arg);
    163. static struct rt_pwm_ops drv_ops =
    164. {
    165.     drv_pwm_control
    166. };
    167.  
    168. static rt_err_t drv_pwm_enable(TIM_HandleTypeDef *htim, struct rt_pwm_configuration *configuration, rt_bool_t enable)
    169. {
    170.     /* Converts the channel number to the channel number of Hal library */
    171.     rt_uint32_t channel = 0x04 * (configuration->channel - 1);
    172.  
    173. //    if (!enable)
    174. //    {
    175. //        HAL_TIM_PWM_Stop(htim, channel);
    176. //    }
    177. //    else
    178. //    {
    179. //        HAL_TIM_PWM_Start(htim, channel);
    180. //    }
    181.     if (!enable)
    182.     {
    183.         HAL_TIMEx_PWMN_Stop(htim, channel);
    184.     }
    185.     else
    186.     {
    187.         HAL_TIMEx_PWMN_Start(htim, channel);
    188.     }
    189.     return RT_EOK;
    190. }
    191.  
    192. static rt_err_t drv_pwm_get(TIM_HandleTypeDef *htim, struct rt_pwm_configuration *configuration)
    193. {
    194.     /* Converts the channel number to the channel number of Hal library */
    195.     rt_uint32_t channel = 0x04 * (configuration->channel - 1);
    196.     rt_uint64_t tim_clock;
    197.  
    198. #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)
    199.     if (htim->Instance == TIM9 || htim->Instance == TIM10 || htim->Instance == TIM11)
    200. #elif defined(SOC_SERIES_STM32L4)
    201.     if (htim->Instance == TIM15 || htim->Instance == TIM16 || htim->Instance == TIM17)
    202. #elif defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0)  || defined(SOC_SERIES_STM32H7)
    203.     if (0)
    204. #elif defined(SOC_SERIES_STM32H7)
    205.     if (1)
    206. #endif
    207.     {
    208. #if !defined(SOC_SERIES_STM32F0) && !defined(SOC_SERIES_STM32G0)
    209.         tim_clock = HAL_RCC_GetPCLK2Freq() * 2;
    210. #endif
    211.     }
    212.     else
    213.     {
    214. #if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0)
    215.         tim_clock = HAL_RCC_GetPCLK1Freq();
    216. #else
    217.         tim_clock = HAL_RCC_GetPCLK1Freq() * 2;
    218. #endif
    219.     }
    220.  
    221.     if (__HAL_TIM_GET_CLOCKDIVISION(htim) == TIM_CLOCKDIVISION_DIV2)
    222.     {
    223.         tim_clock = tim_clock / 2;
    224.     }
    225.     else if (__HAL_TIM_GET_CLOCKDIVISION(htim) == TIM_CLOCKDIVISION_DIV4)
    226.     {
    227.         tim_clock = tim_clock / 4;
    228.     }
    229.  
    230.     /* Convert nanosecond to frequency and duty cycle. 1s = 1 * 1000 * 1000 * 1000 ns */
    231.     tim_clock /= 1000000UL;
    232.     configuration->period = (__HAL_TIM_GET_AUTORELOAD(htim) + 1) * (htim->Instance->PSC + 1) * 1000UL / tim_clock;
    233.     configuration->pulse = (__HAL_TIM_GET_COMPARE(htim, channel) + 1) * (htim->Instance->PSC + 1) * 1000UL / tim_clock;
    234.  
    235.     return RT_EOK;
    236. }
    237.  
    238. static rt_err_t drv_pwm_set(TIM_HandleTypeDef *htim, struct rt_pwm_configuration *configuration)
    239. {
    240.     rt_uint32_t period, pulse;
    241.     rt_uint64_t tim_clock, psc;
    242.     /* Converts the channel number to the channel number of Hal library */
    243.     rt_uint32_t channel = 0x04 * (configuration->channel - 1);
    244.  
    245. #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7)
    246.     if (htim->Instance == TIM9 || htim->Instance == TIM10 || htim->Instance == TIM11)
    247. #elif defined(SOC_SERIES_STM32L4)
    248.     if (htim->Instance == TIM15 || htim->Instance == TIM16 || htim->Instance == TIM17)
    249. #elif defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0)
    250.     if (0)
    251. #elif defined(SOC_SERIES_STM32H7)
    252.     if (1)
    253. #endif
    254.     {
    255. #if !defined(SOC_SERIES_STM32F0) && !defined(SOC_SERIES_STM32G0)
    256.         tim_clock = HAL_RCC_GetPCLK2Freq() * 2;
    257. #endif
    258.     }
    259.     else
    260.     {
    261. #if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0)
    262.         tim_clock = HAL_RCC_GetPCLK1Freq();
    263. #else
    264.         tim_clock = HAL_RCC_GetPCLK1Freq() * 2;
    265. #endif
    266.     }
    267.     /* Convert nanosecond to frequency and duty cycle. 1s = 1 * 1000 * 1000 * 1000 ns */
    268.     tim_clock /= 1000000UL;
    269.     period = (unsigned long long)configuration->period * tim_clock / 1000ULL ;
    270.     psc = period / MAX_PERIOD + 1;
    271.     period = period / psc;
    272.  
    273.     __HAL_TIM_SET_PRESCALER(htim, psc - 1);
    274.  
    275.     if (period < MIN_PERIOD)
    276.     {
    277.         period = MIN_PERIOD;
    278.     }
    279.  
    280.     __HAL_TIM_SET_AUTORELOAD(htim, period - 1);
    281.  
    282.     pulse = (unsigned long long)configuration->pulse * tim_clock / psc / 1000ULL;
    283.     if (pulse < MIN_PULSE)
    284.     {
    285.         pulse = MIN_PULSE;
    286.     }
    287.     else if (pulse > period)
    288.     {
    289.         pulse = period;
    290.     }
    291.  
    292.     __HAL_TIM_SET_COMPARE(htim, channel, pulse - 1);
    293.     __HAL_TIM_SET_COUNTER(htim, 0);
    294.  
    295.     /* Update frequency value */
    296.     HAL_TIM_GenerateEvent(htim, TIM_EVENTSOURCE_UPDATE);
    297.  
    298.     return RT_EOK;
    299. }
    300.  
    301. static rt_err_t drv_pwm_control(struct rt_device_pwm *device, int cmd, void *arg)
    302. {
    303.     struct rt_pwm_configuration *configuration = (struct rt_pwm_configuration *)arg;
    304.     TIM_HandleTypeDef *htim = (TIM_HandleTypeDef *)device->parent.user_data;
    305.  
    306.     switch (cmd)
    307.     {
    308.     case PWM_CMD_ENABLE:
    309.         return drv_pwm_enable(htim, configuration, RT_TRUE);
    310.     case PWM_CMD_DISABLE:
    311.         return drv_pwm_enable(htim, configuration, RT_FALSE);
    312.     case PWM_CMD_SET:
    313.         return drv_pwm_set(htim, configuration);
    314.     case PWM_CMD_GET:
    315.         return drv_pwm_get(htim, configuration);
    316.     default:
    317.         return RT_EINVAL;
    318.     }
    319. }
    320.  
    321. static rt_err_t stm32_hw_pwm_init(struct stm32_pwm *device)
    322. {
    323.     rt_err_t result = RT_EOK;
    324.     TIM_HandleTypeDef *tim = RT_NULL;
    325.     TIM_OC_InitTypeDef oc_config = {0};
    326.     TIM_MasterConfigTypeDef master_config = {0};
    327.     TIM_ClockConfigTypeDef clock_config = {0};
    328.     TIM_BreakDeadTimeConfigTypeDef break_dead_time_config = {0};
    329.     RT_ASSERT(device != RT_NULL);
    330.     //Add TIMx CLK enable
    331.     __HAL_RCC_TIM1_CLK_ENABLE();
    332.     tim = (TIM_HandleTypeDef *)&device->tim_handle;
    333.  
    334.     /* configure the timer to pwm mode */
    335.     tim->Init.Prescaler = 0;
    336.     tim->Init.CounterMode = TIM_COUNTERMODE_UP;
    337.     tim->Init.Period = 200;
    338.     tim->Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    339. #if defined(SOC_SERIES_STM32H7)
    340.     tim->Init.RepetitionCounter = 0;
    341. #endif
    342. #if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32H7)
    343.     tim->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    344. #endif
    345.     if (HAL_TIM_PWM_Init(tim) != HAL_OK)
    346.     {
    347.         LOG_E("%s pwm init failed", device->name);
    348.         result = -RT_ERROR;
    349.         goto __exit;
    350.     }
    351.  
    352.     clock_config.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    353.     if (HAL_TIM_ConfigClockSource(tim, &clock_config) != HAL_OK)
    354.     {
    355.         LOG_E("%s clock init failed", device->name);
    356.         result = -RT_ERROR;
    357.         goto __exit;
    358.     }
    359.  
    360.     master_config.MasterOutputTrigger = TIM_TRGO_RESET;
    361. #if defined(SOC_SERIES_STM32H7)
    362.     master_config.MasterOutputTrigger2 = TIM_TRGO_RESET;
    363. #endif
    364.     master_config.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    365.     if (HAL_TIMEx_MasterConfigSynchronization(tim, &master_config) != HAL_OK)
    366.     {
    367.         LOG_E("%s master config failed", device->name);
    368.         result = -RT_ERROR;
    369.         goto __exit;
    370.     }
    371.  
    372.     oc_config.OCMode = TIM_OCMODE_PWM1;
    373.     oc_config.Pulse = 0;
    374.     oc_config.OCPolarity = TIM_OCPOLARITY_HIGH;
    375. #if defined(SOC_SERIES_STM32H7)
    376.     oc_config.OCNPolarity = TIM_OCNPOLARITY_LOW;
    377. #endif
    378.     oc_config.OCFastMode = TIM_OCFAST_DISABLE;
    379.     oc_config.OCNIdleState = TIM_OCNIDLESTATE_RESET;
    380.     oc_config.OCIdleState  = TIM_OCIDLESTATE_RESET;
    381.  
    382.     /* config pwm channel */
    383.     if (device->channel & 0x01)
    384.     {
    385.         if (HAL_TIM_PWM_ConfigChannel(tim, &oc_config, TIM_CHANNEL_1) != HAL_OK)
    386.         {
    387.             LOG_E("%s channel1 config failed", device->name);
    388.             result = -RT_ERROR;
    389.             goto __exit;
    390.         }
    391.     }
    392.  
    393.     if (device->channel & 0x02)
    394.     {
    395.         if (HAL_TIM_PWM_ConfigChannel(tim, &oc_config, TIM_CHANNEL_2) != HAL_OK)
    396.         {
    397.             LOG_E("%s channel2 config failed", device->name);
    398.             result = -RT_ERROR;
    399.             goto __exit;
    400.         }
    401.     }
    402.  
    403.     if (device->channel & 0x04)
    404.     {
    405.         if (HAL_TIM_PWM_ConfigChannel(tim, &oc_config, TIM_CHANNEL_3) != HAL_OK)
    406.         {
    407.             LOG_E("%s channel3 config failed", device->name);
    408.             result = -RT_ERROR;
    409.             goto __exit;
    410.         }
    411.     }
    412.  
    413.     if (device->channel & 0x08)
    414.     {
    415.         if (HAL_TIM_PWM_ConfigChannel(tim, &oc_config, TIM_CHANNEL_4) != HAL_OK)
    416.         {
    417.             LOG_E("%s channel4 config failed", device->name);
    418.             result = -RT_ERROR;
    419.             goto __exit;
    420.         }
    421.     }
    422. #if defined(SOC_SERIES_STM32H7)
    423.     break_dead_time_config.OffStateRunMode = TIM_OSSR_DISABLE;
    424.     break_dead_time_config.OffStateIDLEMode = TIM_OSSI_DISABLE;
    425.     break_dead_time_config.LockLevel = TIM_LOCKLEVEL_OFF;
    426.     break_dead_time_config.DeadTime = 0;
    427.     break_dead_time_config.BreakState = TIM_BREAK_DISABLE;
    428.     break_dead_time_config.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
    429.     break_dead_time_config.BreakFilter = 0;
    430.     break_dead_time_config.Break2State = TIM_BREAK2_DISABLE;
    431.     break_dead_time_config.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
    432.     break_dead_time_config.Break2Filter = 0;
    433.     break_dead_time_config.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
    434.     if (HAL_TIMEx_ConfigBreakDeadTime(tim, &break_dead_time_config) != HAL_OK)
    435.     {
    436.         LOG_E("%s break_dead_time config failed", device->name);
    437.         result = -RT_ERROR;
    438.         goto __exit;
    439.     }
    440. #endif
    441.     /* pwm pin configuration */
    442.     HAL_TIM_MspPostInit(tim);
    443.  
    444.     /* enable update request source */
    445.     __HAL_TIM_URS_ENABLE(tim);
    446.  
    447. __exit:
    448.     return result;
    449. }
    450.  
    451. static void pwm_get_channel(void)
    452. {
    453. #ifdef BSP_USING_PWM1_CH1
    454.     stm32_pwm_obj[PWM1_INDEX].channel |= 1 << 0;
    455. #endif
    456. #ifdef BSP_USING_PWM1_CH2
    457.     stm32_pwm_obj[PWM1_INDEX].channel |= 1 << 1;
    458. #endif
    459. #ifdef BSP_USING_PWM1_CH3
    460.     stm32_pwm_obj[PWM1_INDEX].channel |= 1 << 2;
    461. #endif
    462. #ifdef BSP_USING_PWM1_CH4
    463.     stm32_pwm_obj[PWM1_INDEX].channel |= 1 << 3;
    464. #endif
    465. #ifdef BSP_USING_PWM2_CH1
    466.     stm32_pwm_obj[PWM2_INDEX].channel |= 1 << 0;
    467. #endif
    468. #ifdef BSP_USING_PWM2_CH2
    469.     stm32_pwm_obj[PWM2_INDEX].channel |= 1 << 1;
    470. #endif
    471. #ifdef BSP_USING_PWM2_CH3
    472.     stm32_pwm_obj[PWM2_INDEX].channel |= 1 << 2;
    473. #endif
    474. #ifdef BSP_USING_PWM2_CH4
    475.     stm32_pwm_obj[PWM2_INDEX].channel |= 1 << 3;
    476. #endif
    477. #ifdef BSP_USING_PWM3_CH1
    478.     stm32_pwm_obj[PWM3_INDEX].channel |= 1 << 0;
    479. #endif
    480. #ifdef BSP_USING_PWM3_CH2
    481.     stm32_pwm_obj[PWM3_INDEX].channel |= 1 << 1;
    482. #endif
    483. #ifdef BSP_USING_PWM3_CH3
    484.     stm32_pwm_obj[PWM3_INDEX].channel |= 1 << 2;
    485. #endif
    486. #ifdef BSP_USING_PWM3_CH4
    487.     stm32_pwm_obj[PWM3_INDEX].channel |= 1 << 3;
    488. #endif
    489. #ifdef BSP_USING_PWM4_CH1
    490.     stm32_pwm_obj[PWM4_INDEX].channel |= 1 << 0;
    491. #endif
    492. #ifdef BSP_USING_PWM4_CH2
    493.     stm32_pwm_obj[PWM4_INDEX].channel |= 1 << 1;
    494. #endif
    495. #ifdef BSP_USING_PWM4_CH3
    496.     stm32_pwm_obj[PWM4_INDEX].channel |= 1 << 2;
    497. #endif
    498. #ifdef BSP_USING_PWM4_CH4
    499.     stm32_pwm_obj[PWM4_INDEX].channel |= 1 << 3;
    500. #endif
    501. #ifdef BSP_USING_PWM5_CH1
    502.     stm32_pwm_obj[PWM5_INDEX].channel |= 1 << 0;
    503. #endif
    504. #ifdef BSP_USING_PWM5_CH2
    505.     stm32_pwm_obj[PWM5_INDEX].channel |= 1 << 1;
    506. #endif
    507. #ifdef BSP_USING_PWM5_CH3
    508.     stm32_pwm_obj[PWM5_INDEX].channel |= 1 << 2;
    509. #endif
    510. #ifdef BSP_USING_PWM5_CH4
    511.     stm32_pwm_obj[PWM5_INDEX].channel |= 1 << 3;
    512. #endif
    513. #ifdef BSP_USING_PWM6_CH1
    514.     stm32_pwm_obj[PWM6_INDEX].channel |= 1 << 0;
    515. #endif
    516. #ifdef BSP_USING_PWM6_CH2
    517.     stm32_pwm_obj[PWM6_INDEX].channel |= 1 << 1;
    518. #endif
    519. #ifdef BSP_USING_PWM6_CH3
    520.     stm32_pwm_obj[PWM6_INDEX].channel |= 1 << 2;
    521. #endif
    522. #ifdef BSP_USING_PWM6_CH4
    523.     stm32_pwm_obj[PWM6_INDEX].channel |= 1 << 3;
    524. #endif
    525. #ifdef BSP_USING_PWM7_CH1
    526.     stm32_pwm_obj[PWM7_INDEX].channel |= 1 << 0;
    527. #endif
    528. #ifdef BSP_USING_PWM7_CH2
    529.     stm32_pwm_obj[PWM7_INDEX].channel |= 1 << 1;
    530. #endif
    531. #ifdef BSP_USING_PWM7_CH3
    532.     stm32_pwm_obj[PWM7_INDEX].channel |= 1 << 2;
    533. #endif
    534. #ifdef BSP_USING_PWM7_CH4
    535.     stm32_pwm_obj[PWM7_INDEX].channel |= 1 << 3;
    536. #endif
    537. #ifdef BSP_USING_PWM8_CH1
    538.     stm32_pwm_obj[PWM8_INDEX].channel |= 1 << 0;
    539. #endif
    540. #ifdef BSP_USING_PWM8_CH2
    541.     stm32_pwm_obj[PWM8_INDEX].channel |= 1 << 1;
    542. #endif
    543. #ifdef BSP_USING_PWM8_CH3
    544.     stm32_pwm_obj[PWM8_INDEX].channel |= 1 << 2;
    545. #endif
    546. #ifdef BSP_USING_PWM8_CH4
    547.     stm32_pwm_obj[PWM8_INDEX].channel |= 1 << 3;
    548. #endif
    549. #ifdef BSP_USING_PWM9_CH1
    550.     stm32_pwm_obj[PWM9_INDEX].channel |= 1 << 0;
    551. #endif
    552. #ifdef BSP_USING_PWM9_CH2
    553.     stm32_pwm_obj[PWM9_INDEX].channel |= 1 << 1;
    554. #endif
    555. #ifdef BSP_USING_PWM9_CH3
    556.     stm32_pwm_obj[PWM9_INDEX].channel |= 1 << 2;
    557. #endif
    558. #ifdef BSP_USING_PWM9_CH4
    559.     stm32_pwm_obj[PWM9_INDEX].channel |= 1 << 3;
    560. #endif
    561. #ifdef BSP_USING_PWM12_CH1
    562.     stm32_pwm_obj[PWM12_INDEX].channel |= 1 << 0;
    563. #endif
    564. #ifdef BSP_USING_PWM12_CH2
    565.     stm32_pwm_obj[PWM12_INDEX].channel |= 1 << 1;
    566. #endif
    567. }
    568.  
    569. static int stm32_pwm_init(void)
    570. {
    571.     int i = 0;
    572.     int result = RT_EOK;
    573.  
    574.     pwm_get_channel();
    575.  
    576.     for (i = 0; i < sizeof(stm32_pwm_obj) / sizeof(stm32_pwm_obj[0]); i++)
    577.     {
    578.         /* pwm init */
    579.         if (stm32_hw_pwm_init(&stm32_pwm_obj[i]) != RT_EOK)
    580.         {
    581.             LOG_E("%s init failed", stm32_pwm_obj[i].name);
    582.             result = -RT_ERROR;
    583.             goto __exit;
    584.         }
    585.         else
    586.         {
    587.             LOG_D("%s init success", stm32_pwm_obj[i].name);
    588.  
    589.             /* register pwm device */
    590.             if (rt_device_pwm_register(&stm32_pwm_obj[i].pwm_device, stm32_pwm_obj[i].name, &drv_ops, &stm32_pwm_obj[i].tim_handle) == RT_EOK)
    591.             {
    592.                 LOG_D("%s register success", stm32_pwm_obj[i].name);
    593.             }
    594.             else
    595.             {
    596.                 LOG_E("%s register failed", stm32_pwm_obj[i].name);
    597.                 result = -RT_ERROR;
    598.             }
    599.         }
    600.     }
    601.  
    602. __exit:
    603.     return result;
    604. }
    605. INIT_DEVICE_EXPORT(stm32_pwm_init);
    606. #endif /* RT_USING_PWM */

  • 相关阅读:
    DNS大全（114DNS 、阿里DNS、百度DNS 、360 DNS、Google DNS）
    Linux libreoffice安装 word转pdf 中文乱码（缺少字体解决）
    C# 实现腾讯云多路直播流的云端混合录制
    2022年最新青海机动车签字授权人模拟考试及答案
    【线性代数】【一】1.2 消元法与方程组的矩阵表示
    Azure 机器学习 - Azure机器学习产品和技术介绍全览
    咨询第三方软件测试机构报价时，软件企业应该准备什么?
    CesiumJS PrimitiveAPI 高级着色入门 - 从参数化几何与 Fabric 材质到着色器 - 下篇
    使用 ModSecurity 和 ELK 进行持续安全监控
    for循环命名
  • 原文地址：https://blog.csdn.net/qwe5959798/article/details/127898473