本文介绍如何在HDF PWM框架中开发stm32mp1的pwm外设。
. r) s3 a4 _9 q2 W
& e( A# e' w: e* g3 X3 B+ A1 ?0 Lstm32mp1的大部分外设可以使用st提供的HAL库来开发。hal库是st官网为所有st芯片提供的sdk包，使开发者可以免去操作寄存器的操作，直接使用库函数完成芯片外设的配置。

: [1 ^& i, t8 t, g/ @$ N综上所述，可以将整个开发步骤分三步走：
0 |1 o3 h- S) D, t. o% f4 g" T
1、导入STM32HAL库
9 {! \7 A0 ?/ X- d' o
2、使能HDF PWM驱动
, S; c4 K* w# q
! W6 v$ j5 e; A3、编写PWM驱动

1、导入stm32mp1 HAL库文件
5 h! v8 O/ S: L# d/ v: O下载HAL库完成后，将HAL库中的以下文件添加到bearpi-micro\device\st\drivers\stm32mp1xx_hal\STM32MP1xx_HAL_Driver的Inc目录中。
stm32mp1xx_hal_tim.h
$ C+ n: \6 m) z, V/ J& Lstm32mp1xx_hal_tim_ex.h
) i, B, O( J7 W  w. x) [7 F: I# S/ n( Astm32mp1xx_hal_dma.h
4 K; _' j9 k6 Kstm32mp1xx_hal_dma_ex.h
: o! U# m2 R- F" S, v) E将 以下文件添加到bearpi-micro\device\st\drivers\stm32mp1xx_hal\STM32MP1xx_HAL_Driver的Src目录中:
stm32mp1xx_hal_tim.c
# F- D, }6 H5 q% ~+ [% Y" fstm32mp1xx_hal_tim_ex.c
1 L; E  G! A4 H6 |: ostm32mp1xx_hal_dma.c
stm32mp1xx_hal_dma_ex.c

7 g6 I2 A$ A) e. p+ l4 V% G- z1 z, l然后将四个源文件加入编译构建体系：编辑bearpi-micro\device\st\drivers\stm32mp1xx_hal\STM32MP1xx_HAL_Driver\BUILD.gn

在sources添加如下两项：
2 |5 e& L9 @$ u* z5 ~0 R

1.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_tim_ex.c",
   / W/ j9 ?. ~% y9 C0 X) G
2.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_tim.c",
   * r3 m8 |' M: `3 V# Y
3.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_dma_ex.c",
   " S  V- K7 j. P! O5 a, _
4.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_dma.c",

复制代码

添加后如下所示，这样编译系统就会编译这两个文件：
$ O1 ?6 a$ P  A8 t

1. import("//drivers/adapter/khdf/liteos/hdf.gni")
   
2. module_name = "hdf_stm32mp1xx_hal"
   
3. hdf_driver(module_name) {
   
4.   sources = [
   
5.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_tim_ex.c",
   0 h/ |* X$ i7 v2 N
6.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_tim.c",
   
7.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_dma_ex.c",
   
8.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_dma.c",
   % V& J4 P! N$ S: q+ v7 h) t
9.     "STM32MP1xx_HAL_Driver/Src/system_stm32mp1xx.c",
   
10.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal.c",
    
11.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_gpio.c",
    
12.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_i2c.c",
    
13.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_exti.c",
    # }' O6 o; f9 i  I! J7 r
14.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_ltdc.c",
    
15.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_rcc.c",
    
16.     "STM32MP1xx_HAL_Driver/Src/stm32mp1xx_hal_rcc_ex.c",
    . j% c! Q+ K/ k! y$ s9 c7 |) S) r
17. 
    + ~8 E  f% f7 _+ Z
18.   ]
    7 F3 x5 R1 v8 `* \/ x
19.   include_dirs = [
    
20.     ".",
    
21.     "//device/st/drivers/stm32mp1xx_hal/STM32MP1xx_HAL_Driver/Inc",
    
22. 
    
23.   ]
    
24. }
    

复制代码

, m- O2 f' P8 x+ [( ~最后，还需要配置一个宏定义，来使能TIM，编辑 STM32MP1xx_HAL_Driver\Inc\stm32mp1xx_hal_conf.h，将 HAL_TIM_MODULE_ENABLED 和HAL_DMA_MODULE_ENABLED使能 ，如下所示：

1. #define HAL_TIM_MODULE_ENABLED   
   4 ~3 V4 `, R# P0 D( t1 G: W- u
2. #define HAL_DMA_MODULE_ENABLED   

复制代码

到此，我们就能使用stm32mp1xx_hal_tim.h 提供的函数来开发PWM驱动。
) D8 ^' H( ?6 y; ]0 |9 g
( [" r  e% j5 W; ?8 R2、使能HDF PWM框架
由于HDF 框架是在内核中的，需要在内核中使能PWM驱动。

2 Z( I: ^. H8 _6 U+ {) c. E- h! X编辑 vendor/bearpi/bearpi_hm_micro/kernel_configs/debug_tee.config，将 LOSCFG_DRIVERS_HDF_PLATFORM_PWM设置为y，如下所示：
) q5 \% ^' |' s; B: p

1. LOSCFG_DRIVERS_HDF_PLATFORM_PWM = y

复制代码

开启该宏之后，就会编译HDF 的PWM框架，就能在驱动中使用PWM框架的pwm_core.h和pwm_if.h。
8 ?) D9 o; F* x$ i
3、编写驱动代码
按照官网文档的指示进行编写：PWM框架开发

- S3 \+ x4 J8 _3 I同样分为三步走。

1、配置文件
9 s* m) k1 _, m5 b; {$ n3 L7 R一共需要修改两个hcs文件，分别是：device_info.hcs和pwm_config.hcs
, B7 d1 `+ M2 V6 P# I* S8 q7 s
首先 编辑st\bearpi_hm_micro\liteos_a\hdf_config\device_info\device_info.hcs增加pwm节点，如下所示：

4 _9 V. F  V- L9 a% i5 C, x+ \该节点应该是在 platform :: host节点下创建。其中policy=1表示只对内核发布驱动服务，moduleName必须为HDF_PLATFORM_PWM，serviceName必须以HDF_PLATFORM_PWM_开头，后面的数字用来区别不同的pwm外设。

这里我设置为2是因为我使用TIM2作为PWM的源。

1.             device_pwm :: device{
   4 X* m9 Q& U8 v
2.                 device0 :: deviceNode{
   + ?6 n, m, b  I& y
3.                     policy = 1;
   3 N) M: K* o4 n$ T0 i
4.                     priority = 12;
   
5.                     permission = 0777;
   6 s" \0 }& V/ U, m7 ?9 F
6.                     moduleName = "HDF_PLATFORM_PWM";
   
7.                     serviceName = "HDF_PLATFORM_PWM_2";
   
8.                     deviceMatchAttr = "st_stm32mp157_pwm_2";
   : b; G4 \$ c, Y) V! A7 p
9.                 }
   
10.             }

复制代码

, _7 _' c( [9 C第二个配置文件就是自己创建的，在\bearpi_hm_micro\liteos_a\hdf_config\录下创建pwm目录，在目录中创建 pwm_config.hcs，并在其中添加以下内容：

其中PWM的计数频率是1MHZ，在代码中写死，可以修改；physics_register表示TIM的寄存器基地址，根据STM32MP1参考手册可知TIM2的寄存器地址是x40000000寄存器地址范围是0x70。
" l' d3 i+ D3 w0 |
下面的配置表示：使用TIM2 Channel 1作为PWM输出，周期是1ms，占空比是50%

1. root {
   6 m1 F* T8 H# b% B
2.     platform {
   1 Z, T/ x7 V( i% I, v# T
3.         pwm_config {
   
4.             //1mhz
   / D: `) \* Z* V  o4 j
5.             template pwm_device {
   
6.                 Period = 1000;        //1000*0.1us=100us=10khz
   
7.                 Pulse = 500;         //500
   
8.                 Polarity = 0;   //high
   
9.                 IdleState = 0;  //reset
   7 p! L4 F# Y. T, i
10.                 channel = 0;    //channel_1 PA5
    * v( Y3 k; w. n
11.                 match_attr = "";
    5 h" N- ?% X; |  v; \9 g
12.                 num = 0;
    : l1 U9 r9 u, F1 t! p
13.                 physics_register = 0X40000000;
    0 t2 V) `* s- @; l( i" N
14.                 register_size = 0X70;
      B2 i, t! H8 R9 w2 `# I/ ?
15.             }
    / B8 w6 d8 s- S. w* O* p
16. 
    5 K0 f& t2 {$ G
17.             device_0X40000000 :: pwm_device {
    
18.                 match_attr = "st_stm32mp157_pwm_2";
    
19.                 num = 2;
    % `7 o% f/ ~& e
20.                 physics_register = 0X40000000;
    
21.             }
    
22.         }
    
23.     }
    
24. }

复制代码

将上诉两个文件编辑完成后，在t\bearpi_hm_micro\liteos_a\hdf_config\hdf.hcs添加一行：

  Y+ [+ N6 b! @3 f7 s

1. #include "pwm/pwm_config.hcs"

复制代码

2、编写驱动
在earpi-micro\device\st\drivers录下新建pwm目录，并创建驱动源文件stm32mp1_pwm.c，以及BUILD.gn
1 F, V& W- w4 i
; {; m  U: {8 ~- [" E首先定义驱动入口对象：
* X: B  L. T6 C! S# n

1. // 定义驱动入口的对象，必须为HdfDriverEntry（在hdf_device_desc.h中定义）类型的全局变量
   0 p( c6 J1 I1 W9 v+ U& m
2. struct HdfDriverEntry g_pwmDriverEntry = {
   / c* j# v9 S# G
3.     .moduleVersion = 1,
   
4.     .moduleName = "HDF_PLATFORM_PWM",        //必须与device_info.hcs中的字段一样，用于与驱动设备资源匹配
   1 V% a3 G& Z- e  B& i  \
5.     .Bind = HdfPwmDriverBind,
   2 l# |* @1 _' W  }+ n' M
6.     .Init = HdfPwmDriverInit,
   
7.     .Release = HdfPwnDriverRelease,
   7 a; |: z' O: Q3 v1 o
8. };
     P" J+ M5 v2 v( f
9. 
   
10. // 调用HDF_INIT将驱动入口注册到HDF框架中
    
11. HDF_INIT(g_pwmDriverEntry);

复制代码

以及自定义一个PWM对象：

1. //私有pwm结构体
   
2. struct StmPwm {
   
3.     TIM_HandleTypeDef htim;                //HAL TIM必须
   / a3 I& T5 i% M6 x5 u
4.     struct PwmDev dev;                        //HDF PWM核心层必须
   4 X9 |5 Y, V/ l* ~) B$ ^
5.     TIM_OC_InitTypeDef sConfig; //HAL PWM必须
   
6.     uint32_t physics_register;  //TIM基地址
   1 D+ ~1 ]4 W: i9 f
7.     uint32_t register_size;                //地址范围
   ' L* H8 c. @  X& z
8.     uint32_t channel;                        //pwm channel
   
9. };

复制代码

( I- i/ m$ U. d+ g( J9 U初始化函数逻辑很简单，就是使用 struct StmPwm 对象中的成员去调用各个库的初始化函数。
+ a3 G" C4 e5 |( [& C0 l5 h
首先引入PWM所需的头文件：

1. //stm hal库
   . Y2 B9 l( I( D0 Y: [
2. #include "stm32mp1xx_hal.h"
   
3. #include "stm32mp1xx_hal_tim.h"
   
4. //hdf pwm
   
5. #include "pwm_core.h"
   & X% y* c6 i3 ^( Y! k) a
6. #include "pwm_if.h"

复制代码

驱动初始化函数：首先读取上文所配置的信息到StmPwm对象中，然后将PwmDev添加到HDF PWM框架中，这样就能使用HDF PWM框架的功能；最后调用STM32MP1 HAL库函数，初始化TIM2的PWM模式，设置对应的GPIO复用功能，开始输出PWM。
5 U: n6 }/ F( s# h3 Y: x' ^0 T

1. // 驱动自身业务初始的接口（设置IO口为输出） HDF框架在加载驱动的时候，会将私有配置信息保存在HdfDeviceObject 中的property里面
   
2. int32_t HdfPwmDriverInit(struct HdfDeviceObject *device)
   
3. {
   
4.     dprintf("%s enter\r\n",__func__);
   * w% c) @) y6 J$ d
5. 
   
6.     RCC_ClkInitTypeDef    clkconfig;
   
7.     uint32_t              pFLatency;
   6 b2 |% x+ Z5 U* ]" e( n
8.     uint32_t              uwTimclock;
   1 n9 C1 O: N4 W9 o( s
9. 
   
10.     sp = (struct StmPwm *)OsalMemCalloc(sizeof(*sp));
    " [. x& H- p- ]" \" q5 r! Z
11. 
    
12.     //读取配置文件
    ! c8 d# I* }* W7 i
13.     readHcs(device);
    5 Q" }: X$ H5 E) r- S/ H
14. 
    
15.     //获取时钟频率
    $ k6 h2 h, p7 }1 J1 t, T
16.     HAL_RCC_GetClockConfig(&clkconfig, &pFLatency);   
    
17.     __HAL_RCC_TIM2_CLK_ENABLE();
    ; W' j* }- C8 l" e7 |0 t( r: e" Q
18.     uwTimclock = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_TIMG1);
    # O1 y( k7 `4 K7 @/ B4 j: _
19.     //dprintf(" uwTimclock = %d\r\n",uwTimclock);
    ( h( H# B0 x7 V8 P
20.         //配置TIM的计数频率为10MHZ
    # \1 N9 A, C$ a. o) G5 c1 Y. P
21.     sp->htim.Init.Prescaler = (uint32_t) ((uwTimclock / 10000000U) - 1U);   
    
22.     sp->htim.Init.CounterMode = TIM_COUNTERMODE_UP;
    + s& Z0 N; ^8 r5 Q- J
23.     sp->htim.Init.ClockDivision = 0U;
    
24.     sp->htim.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
25.     sp->sConfig.OCMode = TIM_OCMODE_PWM1;
    % d; j3 f6 E+ i% M' T
26.     sp->sConfig.OCFastMode = TIM_OCFAST_DISABLE;
    2 q3 }& h. s- r4 R+ R
27. 
    
28.     sp->dev.method = &g_pwmOps;
    * I& t/ F& W+ e$ o6 E/ P% @
29.     sp->dev.cfg.duty = sp->sConfig.Pulse;  
    6 Y& N5 }$ E9 k5 Q1 A+ Q; L6 ?
30.     sp->dev.cfg.period = sp->htim.Init.Period;   
    
31.     sp->dev.cfg.polarity = sp->sConfig.OCPolarity;   
    
32.     sp->dev.cfg.status = PWM_ENABLE_STATUS;
    , q9 }0 l3 y- _+ ?7 E0 {
33.     sp->dev.cfg.number = 10000;
    
34. 
    * i1 y: g- j7 A" y4 ~
35.     sp->dev.busy = false;
    1 d, `# ~9 e; C
36. 
    
37.     //添加到核心层
    7 E7 I0 U4 Y" I
38.     if (PwmDeviceAdd(device, &(sp->dev)) != HDF_SUCCESS) {
    - e4 n" J+ e" s: Y- Z# X
39. 
    : g: ^- o% c" q3 G, M
40.         return HDF_FAILURE;
    # s2 Z! M! o' k
41.     }
    7 D  Z* I- ]* \# S6 E9 b
42.         //对TIM2寄存器基地址进行映射
    , ?. O' I  `+ r1 ]5 L
43.     sp->htim.Instance = (TIM_TypeDef *)OsalIoRemap(sp->physics_register, sp->register_size);
    
44.     if (sp->htim.Instance == NULL) {
    
45.         dprintf("error OsalIoRemap for htim \r\n");
    8 C7 Y3 \6 H- _, o, U" Z* C$ A
46.         return -1;
    1 n& M% E7 K  u# g* `* u
47.     }
    
48.     //初始化PWM寄存器
    
49.     if (HAL_TIM_PWM_Init(&sp->htim) == HAL_OK)
    
50.     {
    
51.         dprintf("pwm init ok config channel \r\n");
    
52. 
    * Q7 L) ~( ?& ]1 C- p2 x- Z/ l
53.         HAL_TIM_PWM_ConfigChannel(&sp->htim, &sp->sConfig, sp->channel);
    
54.                 //初始化gpio
    4 o' _& J& u6 ]; c* M" ]/ F+ C. u
55.         HAL_TIM_MspPostInit(&sp->htim);
      H7 Q. y: ?/ |6 F! ], Y+ e- B# g
56.         //开始输出PWM
    
57.         HAL_TIM_PWM_Start(&sp->htim,sp->channel);
    
58.     }else{
    * p: M) X& k( e
59.         return -1;
    
60.     }
    ! _8 U. o) @. {7 B
61. 
    # I4 o' X0 A/ F- S
62. 
    
63.     return HDF_SUCCESS;
    
64. }

复制代码

读取上诉配置文件到StmPwm对象：
2 u! u. z1 g0 V- H0 T

1. //读取配置文件   pa5 tim2 channel 1
     j! B% l( A) E* C) N) t
2. int readHcs(struct HdfDeviceObject *obj)
   # K, E2 Q/ Y" X5 S( S: ?7 W* G
3. {
   
4.     dprintf("%s enter\r\n",__func__);
   
5. 
   
6. 
   ! s4 l, D/ D, j, n' Z$ X0 r
7.     struct DeviceResourceIface *iface = NULL;
   
8. 
   
9.     iface = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
   
10.     if (iface == NULL || iface->GetUint32 == NULL) {
    
11.         HDF_LOGE("%s: face is invalid", __func__);
    ) Q3 [1 P( h# x/ \) ~3 y3 [
12.         return HDF_FAILURE;
    
13.     }
    
14.     if (iface->GetUint32(obj->property, "Period", &sp->htim.Init.Period, 0) != HDF_SUCCESS) {
    ( g" d& `8 ]9 Q, Q( |7 P1 c
15.         HDF_LOGE("%s: read num fail", __func__);
    
16.         return HDF_FAILURE;
    
17.     }
    
18.     if (iface->GetUint32(obj->property, "Pulse", &sp->sConfig.Pulse, 0) != HDF_SUCCESS) {
    
19.         HDF_LOGE("%s: read num fail", __func__);
    & k5 c4 x4 F0 O# C9 z9 M
20.         return HDF_FAILURE;
    9 i/ j' w  o6 x3 l; v" v2 p
21.     }
    
22.     if (iface->GetUint32(obj->property, "physics_register", &sp->physics_register, 0) != HDF_SUCCESS) {
    
23.         HDF_LOGE("%s: read num fail", __func__);
    , `% ?% Q/ ?0 Y2 \
24.         return HDF_FAILURE;
    
25.     }
    6 k+ {; ^" G( I+ I" V$ G
26.     if (iface->GetUint32(obj->property, "register_size", &sp->register_size, 0) != HDF_SUCCESS) {
    
27.         HDF_LOGE("%s: read num fail", __func__);
    
28.         return HDF_FAILURE;
    / K5 M5 r; a; l0 x& T; x7 G' I2 O
29.     }
    
30.     if (iface->GetUint32(obj->property, "channel", &sp->channel, 0) != HDF_SUCCESS) {
    
31.         HDF_LOGE("%s: read num fail", __func__);
    , M; g2 o5 r0 C
32.         return HDF_FAILURE;
    " \3 y/ B: ?8 r0 b' r0 c6 `
33.     }
    
34.     if (iface->GetUint32(obj->property, "Polarity", &sp->sConfig.OCPolarity , 0) != HDF_SUCCESS) {
    % Y" O7 A: u* W; X
35.         HDF_LOGE("%s: read num fail", __func__);
    
36.         return HDF_FAILURE;
    
37.     }
    
38.     if (iface->GetUint32(obj->property, "IdleState", &sp->sConfig.OCIdleState , 0) != HDF_SUCCESS) {
    
39.         HDF_LOGE("%s: read num fail", __func__);
    
40.         return HDF_FAILURE;
    
41.     }
    5 o, L# z* ^) {# u3 y
42.     if (iface->GetUint32(obj->property, "IdleState", &sp->dev.num , 0) != HDF_SUCCESS) {
    
43.         HDF_LOGE("%s: read num fail", __func__);
    & o8 U) H( o+ p' [& H! B
44.         return HDF_FAILURE;
    ! c: A# w* s" I9 F5 y
45.     }
    
46. 
    
47.     return 0;
    
48. }
    " @! D5 b% J4 Y! O

复制代码

* [- S- g: l1 F/ OGPIOA_5 复用为PWM模式
, n6 s: B4 a: y& N3 b+ V

1. //初始化gpio口
   ( r: l: {' G4 @2 ~
2. void HAL_TIM_MspPostInit(TIM_HandleTypeDef* htim)
   ! f; M; o6 b/ ?# |6 j7 h
3. {
   
4.     __HAL_RCC_GPIOA_CLK_ENABLE();
   
5.     dprintf("%s enter\r\n",__func__);
   
6.     GPIO_InitTypeDef GPIO_InitStruct;
   
7. 
   0 P0 F! p* h; L
8.     //gpioa addr
   ) K2 h( S/ \6 q8 h  j" S
9.     unsigned char *gpioa= (unsigned char *)OsalIoRemap(GPIOA_PHYADDR, GPIOA_SIZE);
   2 D/ ^/ I1 \$ _4 d5 E
10.     /**TIM2 GPIO Configuration   
    2 L6 j% @+ q/ c" j1 H$ j7 h
11.     PA5     ------> TIM2_CH1
    
12.     */
    , V1 j1 u9 v7 }4 X
13.     GPIO_InitStruct.Pin = GPIO_PIN_5;
    
14.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
15.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
16.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    % x8 Y) O5 {+ m* G- U0 X8 f% w9 O. N# ~
17.     GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;
    , {; y  Y& E' B  J* |+ N
18.     HAL_GPIO_Init((GPIO_TypeDef *)gpioa, &GPIO_InitStruct);
    ; ?, U" b, v% z) o0 N
19. 
    
20. }

复制代码

到此初始化任务就基本完成，那么HDF PWM框架如何来使用我们的PWM驱动呢？这就要提到 PwmMethod，通过设置PwmMethod的函数，提供接口给PWM框架，主要是提供StmPwmSetConfig。

1. struct PwmMethod g_pwmOps = {
   
2.     .setConfig = StmPwmSetConfig,
   - o# N3 W; d+ Q) @1 _3 y
3. };

复制代码

HDF_PWM框架是通过pwm_if.h文件给内核提供PWM功能的，我们来看pwm_if.h给内核提供了什么。

+ @6 M5 Q/ c+ O1 h* q- B, x

1. //获取pwm句柄
   + I; n( }7 m, i( m4 _5 o  p
2. DevHandle PwmOpen(uint32_t num);
   
3. void PwmClose(DevHandle handle);
   
4. //设置pwm周期
   
5. int32_t PwmSetPeriod(DevHandle handle, uint32_t period);
   
6. //设置占空比
   
7. int32_t PwmSetDuty(DevHandle handle, uint32_t duty);
   
8. //设置极性
   6 ~# i+ z7 K; ~* e( Q/ ^
9. int32_t PwmSetPolarity(DevHandle handle, uint8_t polarity);
   
10. //使能pwm
    8 E0 V$ t- [! p" f
11. int32_t PwmEnable(DevHandle handle);
    " w( [- L- F9 |- z% z
12. int32_t PwmDisable(DevHandle handle);
    3 n6 A3 r0 y& L' o' O
13. //设置pwm
    
14. int32_t PwmSetConfig(DevHandle handle, struct PwmConfig *config);
    9 j" D5 k5 t+ l% u% @5 |
15. int32_t PwmGetConfig(DevHandle handle, struct PwmConfig *config);

复制代码

7 e( S# }% L9 {! M! H/ `% }, f可以看到PWM框架提供给内核设置PWM参数的接口，这些接口最终会调用我们编写的驱动，那么我们的驱动应该如何实现上述的功能？答案就在:StmPwmSetConfig，所有的接口最终都会调用PwmSetConfig()而间接调用我们编写的StmPwmSetConfig()。

在StmPwmSetConfig()中会对config参数进行检查，然后根据config参数去操作PWM外设，具体而言就是调用HAL库的PWM函数去实现：
! U0 f- t8 o/ c$ u6 V0 J" s
6 P# q$ `, F$ F' L, F

1. //给pwm框架注册的函数
   
2. struct PwmMethod g_pwmOps = {
   
3.     .setConfig = StmPwmSetConfig,
     @$ k' e2 X) j3 R1 }8 l
4. };
   
5. //设置pwm
   + }! V5 ]4 Q, s% p" b+ k8 Z5 G
6. static int32_t StmPwmSetConfig(struct PwmDev *pwm, struct PwmConfig *config)
   6 c; C: X3 U  D7 T4 E5 m
7. {
   
8. 
   5 G# K/ \, O0 Y# y
9.     if (pwm->cfg.polarity != config->polarity ) {
   
10.         HDF_LOGE("%s: not support set pwm polarity", __func__);
    3 l/ ?+ q% u' {& I$ r( L. `
11.         return HDF_ERR_NOT_SUPPORT;
    
12.     }
    
13. 
    7 V5 E) g# ?7 j' A
14.     if (config->status == PWM_DISABLE_STATUS) {
    ) X8 M3 P+ t! Q* y+ M" ?& Y
15. 
    
16.         StmPwmDisable();
    
17.         return HDF_SUCCESS;
    
18.     }
    , \3 e9 e( b8 Q  t( _  [3 q$ f
19. 
    % Q2 b% G% Y* X3 n+ ]* z: F- y
20.     if (config->polarity != PWM_NORMAL_POLARITY && config->polarity != PWM_INVERTED_POLARITY) {
      F( Z" x& `0 t# t
21.         HDF_LOGE("%s: polarity %u is invalid", __func__, config->polarity);
    : H+ z' s) w/ d5 V$ R+ b7 V
22.         return HDF_ERR_INVALID_PARAM;
    
23.     }
    , ?. Z: ~; U0 G1 I: X
24. 
    8 Z5 z* M. n3 D1 n4 c* V0 r; {
25.     if (config->period < 0) {
    ) u9 M" T8 b/ ]  ]. Y2 M% Y
26.         HDF_LOGE("%s: period %u is not support, min period %u", __func__, config->period, 0);
    
27.         return HDF_ERR_INVALID_PARAM;
    
28.     }
    
29.     if (config->duty < 1 || config->duty > config->period) {
    . E$ \6 T- `- b
30.         HDF_LOGE("%s: duty %u is not support, min dutyCycle 1 max dutyCycle %u",
    
31.             __func__, config->duty, config->period);
    / W" D; Z) G9 C
32.         return HDF_ERR_INVALID_PARAM;
    
33.     }
    3 L0 R3 x4 `' q
34.     //暂停pwm，更新配置
    
35.     StmPwmDisable();
    * S8 z" r+ M: Z# @. w
36. 
    0 ]! ~  M& f3 \* O
37.     if (pwm->cfg.polarity != config->polarity) {
    % `5 _$ ?* \% G/ H
38.         StmPwmSetPolarity( config->polarity);
    # z2 B1 ?! x  a4 ]6 j
39.     }
    
40.     StmPwmSetPeriod( config->period);
    2 T4 |. r2 S. x/ L
41.     StmPwmSetDuty( config->duty);
    ' P5 T% D# r$ {3 A, f* r
42.     //继续输出
    
43. 
    
44.     if (config->number == 0) {
    
45.         StmPwmAlwaysOutput();
      S5 z( m" r* g
46.     } else {
    
47.         StmPwmOutputNumberSquareWaves( config->number);
    4 G2 n, j/ E) {+ J; E. T0 X" ]
48.     }
    # g! V7 b% U$ L# p% C2 Z# G+ f2 V
49.     return HDF_SUCCESS;
    
50. }
    

复制代码

HAL库实现配置PWM的方法：

1. static inline void StmPwmDisable()
   , L. e' T1 ^5 J& x8 w! a% j7 j
2. {
   
3.     HAL_TIM_PWM_Stop(&sp->htim, sp->channel);
   - i* S" j0 T! c4 M1 _) w: R+ R
4. }
   ) x! P$ I9 F0 C. M
5. 
   
6. static inline void StmPwmSetPeriod(uint32_t us)
   0 ?% R# F3 L% _
7. {
   * z+ t2 h4 e1 y' N6 ]& M
8.     sp->htim.Init.Period = us;
   8 m  n# H' e! V* Q* N% c( R/ K5 ?
9.     TIM_Base_SetConfig(sp->htim.Instance, &sp->htim.Init);
   
10. }
    
11. static inline void StmPwmSetDuty(uint32_t us)
    1 q5 X* _2 F% s) ^# Q8 f( ]' n
12. {
    * `/ i) f% y) O0 q
13.     sp->sConfig.Pulse = us;
    . x' O: R2 ]& M5 w5 C2 P( m# w
14.     HAL_TIM_PWM_ConfigChannel(&sp->htim, &sp->sConfig, sp->channel);
    / o2 W* P- ^  D; P3 \
15. }
    % F. ~) E+ Q9 Z* \* k* s/ a
16. static inline void StmPwmSetPolarity(uint32_t polarity)
    
17. {
    , i0 I  p% L' G2 h# W
18.     sp->sConfig.OCPolarity = polarity;
    
19.     HAL_TIM_PWM_ConfigChannel(&sp->htim, &sp->sConfig, sp->channel);   
    
20. }
    
21. static inline void StmPwmAlwaysOutput()
    
22. {
    9 V9 T  T9 c1 p9 R
23.     HAL_TIM_PWM_Start(&sp->htim, sp->channel);
    ! k! i  ]( {: V6 D% d4 n
24. }
    
25. 
    
26. static inline void StmPwmOutputNumberSquareWaves(uint32_t num)
    $ G- a; L' U* `3 f, C7 u. S4 G
27. {
    
28. 
    7 X* p; }0 _0 A% A+ }
29.     HAL_TIM_PWM_Start(&sp->htim, sp->channel);
    . C/ d% A! Q% p: L
30. }

复制代码

3、编写构建脚本
最后要将我们编写好的驱动文件加入到编译构建系统中：
9 p7 H+ G" D  D& K. Z& X
( E* ]- j( e4 V编辑BUILD.gn：
5 T! H5 q+ b$ B% T% _0 L

1. import("//drivers/adapter/khdf/liteos/hdf.gni")
   
2. module_switch = defined(LOSCFG_DRIVERS_HDF_PLATFORM_PWM)
   , H( }: x2 X9 b9 R
3. hdf_driver("hdf_pwm") {
   + l+ U& Q2 ^9 w7 L+ G- V
4.     sources = [
   
5.     "stm32mp1_pwm.c",
   
6.     ]
   
7.     include_dirs = [
   
8.      "." ,
   0 o) J. ~8 e9 N7 a# N) M
9.      "//device/st/drivers/stm32mp1xx_hal/STM32MP1xx_HAL_Driver/Inc",
   . k, B( e+ k1 ]
10.   ]
    
11. }

复制代码

+ `$ x3 C% x2 q并修改device/st/drivers/BUILD.gn，在dep添加pwm：

# F* @/ @  o5 D7 _( V  }1 g+ |

1. group("drivers") {
   
2.   deps = [
   1 J$ f" v3 A0 o+ Y. ~7 f" |; \
3.     "pwm",
   
4.     "uart",
   
5.     "iwdg",
   - B' X0 D6 \3 {$ o, b; \8 }! h
6.     "i2c",
   : d1 z6 b% H7 K" ?6 }% S
7.     "gpio",
   - f- ^- T. r/ V' G
8.     "led",
   : l& \- z% L; G- o6 M8 m5 ]. V
9.     "button",
   0 U( Y9 C  P6 a2 h! ^+ n
10.     "sample",
    7 E0 b% m* A- @2 j  s1 I5 `
11.     "mem",
    
12.     "stm32mp1xx_hal",
    
13.     "wifi/driver/hi3881",
    
14.     "wifi/driver:hdf_vendor_wifi",
    5 k" t- x3 F0 E; }0 r  _
15.   ]
    7 [6 N' f! _; }3 x
16. }

复制代码

& c$ l: ]$ q; M. @7 e4、效果
完成PWM驱动的编写后，就可以使用bearpi-micro\drivers\framework\include\platform\pwm_if.h里的函数来控制PWM波。如图是使用逻辑分析测量到的GPIOA_5引脚上的PWM信号：

0 Y8 b+ @9 O/ l/ k计数频率10MHZ，计数值1000，那么PWM的频率就是10MHZ/1000=10KHZ：
, o: A* o! a- v" M. l; |


————————————————
版权声明：killer-p


  x4 _0 m2 ~# P+ r6 S% _, R. f