用定时器生成PWM波

    PWM全称是Pulse Width Modulation，通过控制高频信号的占空比，眼睛当成低通滤波器，可以控制亮暗。再循环更改pwm的阈值，就弄出了呼吸的效果。

    这里采用一个比较简单的方法生成PWM波：设置定时器中断然后根据阈值判断置高和置低。

1. void TIM3_IRQHandler(void)  
   
2. {
   8 a' O  t& ^/ }9 O
3.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  
   $ ~9 U/ R& ^; ]* l0 C% M& _
4.         if(counter==255)            
   % S8 C0 e/ m3 x, @% B7 R4 z9 t" T
5.             counter = 0;
   ( C1 V: D! E4 D1 ~
6.         else
   
7.             counter +=1;
   . t8 e2 i9 P6 b; u2 p6 M
8.         if(mode == 0){
   
9.             if(counter < pwm)              
   ; a' A2 |' i4 E( u0 y6 U" T
10.                 GPIO_SetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);
    0 W+ ^+ I. ]- u/ U
11.             else
    ! R1 |% E5 d9 ]4 n3 k
12.                 GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);   
    
13.         }
    : B5 r' N0 B' `$ d+ c4 o
14.         if(mode == 1)
    
15.         {
    0 B5 h! y5 {" A- I2 e( I
16.             if(counter < pwm)              
    4 X$ K! h, `4 a1 \4 \2 \
17.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);
    ; K. y  P- [2 s2 ?, }
18.             else
    
19.                 GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     
    ; h/ B$ I  H' n- N7 ^, d) [
20.         }  
    * V2 H. m; {: g+ k
21.         if(mode ==2){
    
22.             if(counter < pwm)              
    
23.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    % f4 u% i- {/ i' `# ^: E
24.             else
    
25.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    
26.         }
    
27. }

复制代码

' E' b! a0 P& K, c( k6 c1 v8 T

程序流程

• 开启外设时钟（GPIO和TIM）
  
  ; k6 E9 n$ ^3 m+ o' W

1. void RCC_Configuration(void)               
   0 \4 G  X' k5 }& N: L' b
2. {
   
3.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);                                                      
   
4.      RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE);
   
5. }

复制代码

• 配置GPIO
• 配置时钟, 使能中断（计数阈值，预分频，时钟分频，计数模式）
  
  1 n; @' t; b4 |$ Y0 k1 |) f) n2 X4 b

1. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
   
2. {
   
3. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
   
4. TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
   3 o( o/ C  {0 Q* a$ }" c' D  Z
5. TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
   9 S1 @8 i, U7 d( T; Y
6. TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // 时钟分频倍数
   
7. TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 计数方式为向上计数
   
8. TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);      //  初始化tim3
   
9. TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIM3溢出中断标志
   / J% k: ^7 C5 [3 ]. _7 f
10. TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
    3 f' b9 [" A2 {+ V
11. TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
    * ^5 n; I  w. v2 J- H
12. }

复制代码

! p! b0 l1 T+ O% V. \  Z/ M

• 配置中断优先级
  
  

1. void nvic()                                 //配置中断优先级
   9 e) |6 O" s* _. D* _( A
2. {   
   ; F! o1 S+ q. e) t
3. NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
   
4. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
   + E. U8 k# L/ t5 I  E* B. `
5. NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
   
6. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
   8 f9 {4 P' y9 }- Q
7. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
   % D$ S" b5 E, l' y  ?
8. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
   
9. NVIC_Init(&NVIC_InitStructure);                        //  初始化
   0 V% u+ a5 V& I' I  |# r! S" X+ C
10. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
    3 X) y' U/ _2 C7 j
11. NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
    " }8 \4 p/ E% r
12. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
    4 W2 ?* s; x, K  e) M/ G$ A* P4 K
13. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
    
14. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
15. NVIC_Init(&NVIC_InitStructure);
    
16. }

复制代码

• 写中断服务函数
  . S' l+ _3 ?4 q9 q

: U' d* N$ C8 j, `2 z& D; \) g5 i

代码实现

    为了方便按键检测，除了TIM3配置PWM波之外，TIM4用来检测是否有输入。由于使用开漏输出，这里使用5V电源。

1. #include "stm32f10x.h"
   
2. #include "math.h"
   
3. #include "stdio.h"
   
4. 
   8 E2 _' S/ F; X; K+ G- X4 L
5. u8  counter=0;
   9 |* L) @: _, P9 o
6. int  pwm=100;
   
7. int flag=0;
   
8. int mode =0;
   
9. int velocity =0;
   
10. int turning=1;
    
11. 
    : C* t6 F/ Q" }) q
12. void RCC_Configuration(void);    //时钟初始化，开启外设时钟
    
13. void GPIO_Configuration(void);   //IO口初始化，配置其功能
    1 W% j. W/ K. c5 V" ?- q$ C; q1 j
14. void tim3(void);                 //定时器tim4初始化配置
    + f4 x- y2 k" U2 I# @4 D
15. void tim4(void);                 //定时器tim4初始化配置
    2 c+ W4 Y- l8 u( F% |2 {
16. void nvic(void);                 //中断优先级等配置
    ! |. D5 n1 c; D1 d+ s9 o& Y  j/ R
17. void exti(void);                 //外部中断配置
    ( b, s' }5 ?5 e1 j: K$ y2 m: d
18. void delay_nus(u32);           //72M时钟下，约延时us
    & b1 Z$ n$ ^0 |' l
19. void delay_nms(u32);            //72M时钟下，约延时ms
    
20. void breathing(int velocity){
    7 w, K- K, N# m; P
21.         switch(velocity){
    
22.                 case 0:
    3 l2 D! P4 U' x
23.                     if(flag)
    
24.                             pwm +=1;
    
25.                             if(pwm>240) flag=0;
    ! }- g: J+ _$ e( d  V
26.                     if(flag == 0){
    
27.                             pwm -=1;
    
28.                             if(pwm<10) flag=1;
    
29.                     }
    
30.                     break;
    
31.                 case 1:
    / X# H3 [% Y( j8 d
32.                     if(flag)
    
33.                             pwm +=2;
    
34.                             if(pwm>240) flag=0;
    * K% B  u9 j/ @. o# Q" ]
35.                     if(flag == 0){
    0 T9 B& A4 h8 O% D
36.                             pwm -=2;
    
37.                             if(pwm<10) flag=1;
    
38.                     }
    
39.                     break;
    
40.                 case 2:
    . d8 j# W" C- t; _5 e8 N% O
41.                     if(flag)
    % L! d  d9 T: ~# \, y9 C7 T
42.                             pwm +=3;
    * k0 |9 `5 Z1 T8 K5 X# P: q$ ~
43.                             if(pwm>240) flag=0;
    
44.                     if(flag == 0){
    
45.                             pwm -=3;
    
46.                             if(pwm<10) flag=1;
    
47.                     }
    
48.                     break;
    
49.         }
    
50. }
    
51. 
    
52. 
    
53. void assert_failed(uint8_t* file, uint32_t line)
    * N  O! n0 |  b* j3 k
54. {
    , k1 f7 b6 B- N4 K0 e& s3 V# s% {
55.     printf("Wrong parameters value: file %s on line %d\r\n", file, line);
      D& x+ ?, b" D
56.     while(1);
    
57. }
    & p7 T, w$ ~% y; z1 Q( n- h
58. 
    ) Q8 w" h1 m2 H+ H
59. void TIM4_IRQHandler(void)   //TIM4的溢出更新中断响应函数 ，读取按键输入值，根据输入控制pwm波占空比
    
60. {
    
61.         u8 key_in1=0x01,key_in2=0x01;
    
62.         TIM_ClearITPendingBit(TIM4,TIM_IT_Update);//     清空TIM4溢出中断响应函数标志位
    
63.         key_in1= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_12);  // 读PC12的状态
    - @8 U  E( e: F! Q5 E
64.         key_in2= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_13);// 读PC13的状态
    
65.         if(key_in1 && key_in2) turning =1;
    
66.         breathing(velocity);
    ) t; T7 ?7 [4 f/ Z7 g) {
67.         if(key_in1==0 && turning){
    # L; x3 g6 y% l1 h5 Q
68.                 turning =0;
    
69.         velocity = (velocity + 1) % 3;
    
70.     }//调速度
    
71.     if(key_in2==0 && turning){
    3 N% J: b$ M- R3 {3 F- L: l$ e: L
72.                 turning =0;
    6 N# }2 Q; p. s+ ~+ I
73.         mode = (mode + 1) % 3;
    ( e! @: `  W' C* B9 p
74.     }//调颜色
    % M; M! F- N/ q" o% E4 I
75. }   
    
76. 
    
77. 
    1 x4 ]5 d: C0 b! z1 Z
78. void TIM3_IRQHandler(void)      //    //TIM3的溢出更新中断响应函数，产生pwm波
    3 z: T2 b+ R# \1 [5 v- R7 w6 {
79. {
    , K5 l! N  ?% E% L4 W4 n
80.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //   //  清空TIM3溢出中断响应函数标志位
    : D+ C" z3 d! G7 p! j# f( I8 y
81.         if(counter==255)            //counter 从0到255累加循环计数，每进一次中断，counter加一
    . P4 S- F: d  y& W8 H
82.             counter = 0;
    
83.         else
    + n: O5 q+ M$ `$ u9 |- b
84.             counter +=1;
    
85.         if(mode == 0){
    ) F' p6 i$ u% X6 H8 A* z; I  H
86.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    ( K9 Z3 ?+ t  k! z8 P4 K* o6 f
87.                 GPIO_SetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1); //将PC14 PC15置为高电平
    
88.             else
    3 J1 u/ {8 {1 g) f9 V
89.                         GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);     // 将PC14 PC15置为低电平
    
90.         }
    
91.         if(mode == 1)
    ; {6 E( J9 G  ^$ ?- C9 h
92.         {
    
93.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    
94.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2); //将PC14 PC15置为高电平
    + X9 e. j  S( F
95.             else
    2 g3 a  o6 X' H# Z- e
96.                         GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     // 将PC14 PC15置为低电平
    + o6 F4 O. d. o7 W6 v% @2 u. }: I
97.         }  
    
98.         if(mode ==2){
      N: y/ |6 F- N$ F+ ^
99.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    ; ?5 N8 I) Y6 G& i. }
100.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); //将PC14 PC15置为高电平
     
101.             else
     
102.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); // 将PC14 PC15置为低电平
     
103.         }
     3 c2 R% ]' c' F) P( P
104. }   
     
105. 
     
106. 
     
107. int main(void)
     4 r6 d0 l9 f1 B4 o
108. {
     % ]; [: Q, C# c+ l5 a  @( c
109.     RCC_Configuration();                                                                    
     $ w+ Z  B: E3 l8 ]' g
110.   GPIO_Configuration();                        
     ' \$ ]& i8 R& g- K. U- Q
111.     tim4();
     
112.     tim3();
     
113.   nvic();
     * p! k0 {, t/ M* R4 |1 A
114.     while(1)
     
115.     {
     ; l  i" _1 {* \! p, O
116.     }   
     
117. }   
     
118. 
     * y$ r* ?- {2 M3 p$ B) y5 S
119. void delay_nus(u32 n)       //72M时钟下，约延时us
     6 Q4 ]: T9 H5 j  l( z' U
120. {
     * e& x7 N9 _# }! W, m) O' y
121.   u8 i;
     
122.   while(n--)
     , }. H$ X" u7 a( C; G
123.   {
     , q, G$ Q) y! k/ u
124.     i=7;
     
125.     while(i--);
     2 j7 ~, y: i( R) F3 ~+ l- d: @
126.   }
     9 z  [, ^' u' n2 i1 W. p; _
127. }
     
128. 
     ; R; l: G4 ]4 o! c8 J
129. 
     ) g/ k- _  S- I, J: p; R
130. void delay_nms(u32 n)     //72M时钟下，约延时ms
     
131. {
     
132.     while(n--)
     
133.       delay_nus(1000);
     
134. }
     
135. 
     ( c; w6 p0 S; ~* I
136. 
     7 Y; }5 d2 j) s/ d; X4 [3 s
137. void RCC_Configuration(void)                 //使用任何一个外设时，务必开启其相应的时钟
     
138. {
     
139.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);    //使能APB2控制外设的时钟，包括GPIOC, 功能复用时钟AFIO等，                                                                              
     : J" L  ^) |2 O  {3 H! f0 p
140.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE); //使能APB1控制外设的时钟，定时器tim3、4，其他外设详见手册            
     ( T2 i% ?- m0 F' f! s
141. }
     
142. 
     
143. 
     + ]) l$ `% E# I- w& C  c
144. void GPIO_Configuration(void)            //使用某io口输入输出时，请务必对其初始化配置
     
145. {
     , x+ L5 e0 s- P# I
146.     GPIO_InitTypeDef GPIO_InitStructure;   //定义格式为GPIO_InitTypeDef的结构体的名字为GPIO_InitStructure  
     
147.                                           //typedef struct { u16 GPIO_Pin; GPIOSpeed_TypeDef GPIO_Speed; GPIOMode_TypeDef GPIO_Mode; } GPIO_InitTypeDef;
     
148.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;    //配置IO口的工作模式为上拉输入（该io口内部外接电阻到电源）
     
149.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //配置IO口最高的输出速率为50M
     
150.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13;  //配置被选中的管脚，|表示同时被选中
     & v& @6 m- I! [* v5 J
151.     GPIO_Init(GPIOC, &GPIO_InitStructure);                  //初始化GPIOC的相应IO口为上述配置，用于按键检测
     ! M9 C/ O% b! C6 w$ [
152.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;       //配置IO口工作模式为 推挽输出（有较强的输出能力）
     1 D2 P! l# u0 m) @, w" F
153.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;      //配置IO口最高的输出速率为50M
     
154.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2;  //配置被选的管脚，|表示同时被选中
     
155.     GPIO_Init(GPIOA, &GPIO_InitStructure);        //初始化GPIOA的相应IO口为上述配置
     
156.     GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //失能STM32 JTAG烧写功能，只能用SWD模式烧写，解放出PA15和PB中部分IO口
       F0 n7 ^& I! }  }8 U
157. }
     
158. 
     : J! E( s% h: b7 \5 G, J
159. 
     
160. void tim4()                           //配置TIM4为基本定时器模式,约10ms触发一次，触发频率约100Hz
     ) Y) U1 C6 Q+ ^; J1 K3 V
161. {
     $ `8 P2 H' `: [7 R3 V5 K
162.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     
163.     TIM_TimeBaseStructure. TIM_Period =9999;          // 配置计数阈值为9999，超过时，自动清零，并触发中断
     
164.     TIM_TimeBaseStructure.TIM_Prescaler =71;         //  时钟预分频值，除以多少
     . k$ A5 \, F2 N: Z
165.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 时钟分频倍数
     
166.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 计数方式为向上计数
     , ]5 N5 e+ S* t
167.     TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);      //  初始化tim4
     0 s! ~! ]& S5 _+ B
168.     TIM_ClearITPendingBit(TIM4,TIM_IT_Update); //清除TIM4溢出中断标志
     
169.     TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);   //  使能TIM4的溢出更新中断
     
170.     TIM_Cmd(TIM4,ENABLE);                //        使能TIM4
     , N. K! Y& }# g- o
171. }
     ! V& t; q) S- J7 s
172. 
     ) Z( ^$ y5 R; [! i" O
173. 
     
174. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
     
175. {
     ) ?- `8 j+ g0 O
176.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     ; k' j+ S) A& ^% m6 O+ H  {
177.     TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
     . H8 `0 o' [/ ]% `5 w' t
178.     TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
     * O, q( o; Z$ X* Q; \( {8 P( d1 g
179.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // 时钟分频倍数
     
180.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 计数方式为向上计数
     
181.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);      //  初始化tim3
     
182.     TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIM3溢出中断标志
     ' O, |" O4 l. l. P* }
183.     TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
     + g: H& P+ e) D$ q1 n
184.     TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
     
185. }
     ( C. V1 p* I7 \$ K
186. 
     , _4 t  a# R# n
187. 
     
188. void nvic()                                 //配置中断优先级
     
189. {   
     
190.      NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
     
191.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
     
192.      NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
     3 V* ~# E  J) {* c
193.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
     
194.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
     . Z& {3 n  Z- S) R: H. U
195.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
     " P6 i0 E1 C- ^# @* h- ~! Y
196.      NVIC_Init(&NVIC_InitStructure);                        //  初始化
     
197.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
     ( i/ \# G0 g- {$ s: N4 L  y
198.      NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
     
199.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
     / [  q8 A4 S7 p- E$ z$ A# h1 D0 j# a
200.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
     1 k5 S* ?9 c9 y1 _. g; U, v
201.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     
202.      NVIC_Init(&NVIC_InitStructure);
     ! Y: i/ `6 u5 l+ b+ G+ ^5 }# l6 ~
203. }

复制代码

转载自：单片机与嵌入式
如有侵权请联系删除

, f( \, l& {$ T