用定时器生成PWM波

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

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

1. void TIM3_IRQHandler(void)  
   1 p8 S- T: D3 r6 O3 g2 a
2. {
   
3.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  
   
4.         if(counter==255)            
   
5.             counter = 0;
   
6.         else
   
7.             counter +=1;
   
8.         if(mode == 0){
   + l: p4 v" y2 H  ~
9.             if(counter < pwm)              
   
10.                 GPIO_SetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);
    : `0 }. x4 m2 I% E! T  u4 Q
11.             else
    
12.                 GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);   
    
13.         }
    7 o0 E/ P4 z3 T. N0 n
14.         if(mode == 1)
    7 R' M* t7 [/ D& F' h% u
15.         {
    6 {9 b$ E% `& f1 G3 `! ]
16.             if(counter < pwm)              
      [& O( ^6 m7 l
17.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);
    0 f; U2 R+ |% o  }5 Q
18.             else
    
19.                 GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     
    
20.         }  
    6 u# E! @+ B0 N( `1 E
21.         if(mode ==2){
    
22.             if(counter < pwm)              
    : ~" z, o% j' p! a/ e/ b+ H
23.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    
24.             else
    + E5 I! l8 D+ K7 D4 ~
25.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0);
    
26.         }
    
27. }

复制代码

3 Y9 F  {: q; }# `) J  s

程序流程

• 开启外设时钟（GPIO和TIM）
  
  3 J5 G$ L0 a3 R' m8 w: Y

1. void RCC_Configuration(void)               
   8 I5 {0 V: g3 r
2. {
   - k2 `, Y% L7 ~1 f
3.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);                                                      
   ' w" |5 d& _3 ?' c
4.      RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE);
   $ F+ u5 b3 @: \# Z, i9 Y. \
5. }

复制代码

: q, r5 d  n1 I4 z! n& m

• 配置GPIO
• 配置时钟, 使能中断（计数阈值，预分频，时钟分频，计数模式）
  
  3 j8 _' _5 L9 T7 O; m2 s  j

1. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
   8 J. |3 p# r3 x$ Y, }2 }
2. {
   / S* z% V( }3 l4 b2 k$ j; q
3. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
   
4. TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
   . R4 V  t2 s. e& m" e" Q* u
5. TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
   
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溢出中断标志
   
10. TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
    
11. TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
    
12. }

复制代码

+ O1 l; _, a+ ?; P; d- A! ^# T6 p& d
0 O' y- m! \$ y/ M; f9 u7 c

• 配置中断优先级
  
  . g! g+ u6 d7 O$ b5 [

1. void nvic()                                 //配置中断优先级
   # W2 o2 Y9 g0 j" P
2. {   
   
3. NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
   
4. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
   
5. NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
   8 ~, H) Y! j' W% n5 m7 B0 \
6. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
   3 l. i  d3 A& Y0 A  _
7. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
   
8. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
   
9. NVIC_Init(&NVIC_InitStructure);                        //  初始化
   % J4 i, Z4 o0 d) ~0 @
10. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
    8 N6 Q* |4 O9 t8 U$ q, O, ]
11. NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
    
12. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
    
13. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
    + O) o9 v- ^" T
14. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    : [. f1 i' J* H2 c" m
15. NVIC_Init(&NVIC_InitStructure);
    
16. }

复制代码

4 L! u. \6 O) q( x2 l  W* C2 r" P
  ?5 m+ x2 c1 x

• 写中断服务函数
  ( f3 T! `* D# f1 t; r  A  q3 |

2 v! y; R2 u/ {9 X) Q; f

代码实现

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

1. #include "stm32f10x.h"
   
2. #include "math.h"
   
3. #include "stdio.h"
   
4. 
   
5. u8  counter=0;
   : r% a5 y2 D  C6 S
6. int  pwm=100;
   
7. int flag=0;
   
8. int mode =0;
   4 f8 G0 M# O: u. x. ~* }
9. int velocity =0;
   9 \+ A, H$ A# `4 W
10. int turning=1;
    
11. 
    
12. void RCC_Configuration(void);    //时钟初始化，开启外设时钟
    
13. void GPIO_Configuration(void);   //IO口初始化，配置其功能
    
14. void tim3(void);                 //定时器tim4初始化配置
    % l  y8 |" b& _1 I3 d$ t
15. void tim4(void);                 //定时器tim4初始化配置
    
16. void nvic(void);                 //中断优先级等配置
    
17. void exti(void);                 //外部中断配置
      U$ ~: e' r) |, r2 T
18. void delay_nus(u32);           //72M时钟下，约延时us
    9 N  {3 h9 W6 I- h  d; L
19. void delay_nms(u32);            //72M时钟下，约延时ms
    
20. void breathing(int velocity){
    
21.         switch(velocity){
    
22.                 case 0:
    
23.                     if(flag)
    
24.                             pwm +=1;
    ! }5 B5 ]$ u+ h1 f  f. C
25.                             if(pwm>240) flag=0;
    ( Y( }9 v! b: O$ A' v2 I
26.                     if(flag == 0){
    
27.                             pwm -=1;
    ; Y6 O8 E9 b4 r5 t
28.                             if(pwm<10) flag=1;
    + Q! F8 m( O) h% F% f1 u
29.                     }
    
30.                     break;
    * Y8 @' z4 }; [& q& D6 K" A  p
31.                 case 1:
    . I  V. R' L3 @. K7 K6 y
32.                     if(flag)
    
33.                             pwm +=2;
    
34.                             if(pwm>240) flag=0;
    
35.                     if(flag == 0){
    
36.                             pwm -=2;
    ) o$ A5 {. B* W; _% y& a/ Z9 l( j
37.                             if(pwm<10) flag=1;
    + H, \+ v. f1 L, J0 Z
38.                     }
    , l5 @% `1 k& a9 }  |0 q! h
39.                     break;
    
40.                 case 2:
    . \5 }( z+ J- T9 r# L
41.                     if(flag)
    
42.                             pwm +=3;
    
43.                             if(pwm>240) flag=0;
    
44.                     if(flag == 0){
    
45.                             pwm -=3;
    ) S3 g  S# q/ U2 D# s; O( s
46.                             if(pwm<10) flag=1;
    
47.                     }
    
48.                     break;
    
49.         }
    
50. }
    
51. 
    
52. 
    ' ?/ I8 J$ l4 ~" ^9 d/ b" j1 R% r
53. void assert_failed(uint8_t* file, uint32_t line)
    
54. {
    ; q6 }2 T' \$ t& V" z# e
55.     printf("Wrong parameters value: file %s on line %d\r\n", file, line);
    
56.     while(1);
    
57. }
    
58. 
    
59. void TIM4_IRQHandler(void)   //TIM4的溢出更新中断响应函数 ，读取按键输入值，根据输入控制pwm波占空比
    3 c. }4 Z+ v2 ~" L: Y1 p1 E
60. {
    - V# m: k$ k( v2 c
61.         u8 key_in1=0x01,key_in2=0x01;
    5 g, z- i/ d7 w5 u  x. i8 K
62.         TIM_ClearITPendingBit(TIM4,TIM_IT_Update);//     清空TIM4溢出中断响应函数标志位
    / U& \, ^, W  X0 J" v. _1 A
63.         key_in1= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_12);  // 读PC12的状态
    
64.         key_in2= GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_13);// 读PC13的状态
    
65.         if(key_in1 && key_in2) turning =1;
    
66.         breathing(velocity);
    . E+ |  p, A& T9 G/ V2 [
67.         if(key_in1==0 && turning){
    2 n, k; v, y; D: U. ]
68.                 turning =0;
    
69.         velocity = (velocity + 1) % 3;
    / [/ V' Q& f6 o' a1 Q
70.     }//调速度
    % G0 o: t- {* U1 \
71.     if(key_in2==0 && turning){
    
72.                 turning =0;
    
73.         mode = (mode + 1) % 3;
    
74.     }//调颜色
    
75. }   
    
76. 
    8 ^# L) e/ Q# E6 U, I' y* G' j
77. 
    
78. void TIM3_IRQHandler(void)      //    //TIM3的溢出更新中断响应函数，产生pwm波
    
79. {
    8 z% q3 X7 d1 @7 v5 O6 L
80.         TIM_ClearITPendingBit(TIM3,TIM_IT_Update);  //   //  清空TIM3溢出中断响应函数标志位
    + S# x5 w" d& q9 e  Q  l" }- }
81.         if(counter==255)            //counter 从0到255累加循环计数，每进一次中断，counter加一
    8 V+ n# U! {  b9 [0 D) d: ~
82.             counter = 0;
    $ d4 Y- s6 {6 b$ j! x
83.         else
    
84.             counter +=1;
    2 f, [. S1 f2 d- D1 g  U2 R
85.         if(mode == 0){
    
86.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    2 |5 C" k$ l3 L0 A6 O& t
87.                 GPIO_SetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1); //将PC14 PC15置为高电平
      U- b- f" C! r: Z, g- p3 k2 S
88.             else
    . i; H5 ^9 [( ~
89.                         GPIO_ResetBits(GPIOA,GPIO_Pin_0|GPIO_Pin_1);     // 将PC14 PC15置为低电平
    
90.         }
    * {* v& o% n4 q; C. K3 U
91.         if(mode == 1)
    ! H. q8 B2 W, U' q. d/ i$ N
92.         {
    
93.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    9 w# t* V7 s4 q- G2 u7 s4 f  v
94.                 GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2); //将PC14 PC15置为高电平
    ( s$ D1 l4 n+ ?8 i; ]
95.             else
      ~" Q( |6 R( W
96.                         GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);     // 将PC14 PC15置为低电平
    
97.         }  
    
98.         if(mode ==2){
    
99.             if(counter < pwm)              //当counter值小于pwm值时，将IO口设为高；当counter值大于等于pwm时，将IO口置低
    
100.                 GPIO_SetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); //将PC14 PC15置为高电平
     
101.             else
     9 p" J8 p( q1 p  E: Q  x2 F
102.                 GPIO_ResetBits(GPIOA,GPIO_Pin_2|GPIO_Pin_0); // 将PC14 PC15置为低电平
     ; d3 K9 C% n' F* k. M6 [% D4 i
103.         }
     , q" |7 S- ?6 `, b2 X% c# u
104. }   
     
105. 
     * [7 X9 |( R( T' i2 i3 d3 D
106. 
     
107. int main(void)
     2 p# N7 C) D: g2 w, S
108. {
     2 ~) f! g* w+ L( Y3 R
109.     RCC_Configuration();                                                                    
     
110.   GPIO_Configuration();                        
     
111.     tim4();
     + Z7 h" k$ M# r4 j  E8 q  H* N/ W
112.     tim3();
     
113.   nvic();
     ; z1 B1 }1 p7 ]! T
114.     while(1)
     9 |# R. ~1 p' k$ z  b
115.     {
     
116.     }   
     * a" `" v. n7 W0 t6 @; x6 v
117. }   
     
118. 
     
119. void delay_nus(u32 n)       //72M时钟下，约延时us
     / d1 |0 e  t% L- x: a+ m
120. {
     $ u, R5 [4 w2 h1 K* b: E$ K' ^
121.   u8 i;
     
122.   while(n--)
     
123.   {
     
124.     i=7;
     
125.     while(i--);
     
126.   }
     
127. }
     
128. 
     
129. 
     
130. void delay_nms(u32 n)     //72M时钟下，约延时ms
     7 V8 q9 i, N+ l9 a% m, D
131. {
     9 T; D+ K" S; a- |# T& {
132.     while(n--)
     6 G+ Y9 n! D3 l$ _% N! e4 h
133.       delay_nus(1000);
     9 q8 Z5 E9 e( V& j
134. }
     
135. 
     $ s% n" S- M* {6 R7 w
136. 
     ' T9 z3 k. N# [" j' V0 b8 F8 |
137. void RCC_Configuration(void)                 //使用任何一个外设时，务必开启其相应的时钟
     
138. {
     
139.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);    //使能APB2控制外设的时钟，包括GPIOC, 功能复用时钟AFIO等，                                                                              
     ' m$ ^$ v2 Y, b& u7 f8 P
140.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4|RCC_APB1Periph_TIM3, ENABLE); //使能APB1控制外设的时钟，定时器tim3、4，其他外设详见手册            
     ; ^4 I! R) p' U! D  P7 k1 x
141. }
     ; |7 J9 J; e9 C7 Q* B* O6 x
142. 
     
143. 
     0 d( w0 T7 t& u$ Y" t4 k
144. void GPIO_Configuration(void)            //使用某io口输入输出时，请务必对其初始化配置
     
145. {
     
146.     GPIO_InitTypeDef GPIO_InitStructure;   //定义格式为GPIO_InitTypeDef的结构体的名字为GPIO_InitStructure  
     $ d, [& F0 b- i( ?* j( q5 z1 {
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口内部外接电阻到电源）
     - w" v% b. O; F. M5 V! O
149.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //配置IO口最高的输出速率为50M
     $ _& h; P" N2 ~7 H2 o
150.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13;  //配置被选中的管脚，|表示同时被选中
     
151.     GPIO_Init(GPIOC, &GPIO_InitStructure);                  //初始化GPIOC的相应IO口为上述配置，用于按键检测
     
152.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;       //配置IO口工作模式为 推挽输出（有较强的输出能力）
     7 y2 {- x* X# ?/ ^8 L! m
153.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;      //配置IO口最高的输出速率为50M
       e. S$ C+ N. f) y
154.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2;  //配置被选的管脚，|表示同时被选中
     / H/ l$ O7 q' X, |/ N. B" W
155.     GPIO_Init(GPIOA, &GPIO_InitStructure);        //初始化GPIOA的相应IO口为上述配置
     
156.     GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE); //失能STM32 JTAG烧写功能，只能用SWD模式烧写，解放出PA15和PB中部分IO口
     
157. }
     
158. 
     3 ^5 c" U7 r1 i
159. 
     ' n  [8 x! Z' Y, c
160. void tim4()                           //配置TIM4为基本定时器模式,约10ms触发一次，触发频率约100Hz
     
161. {
       k; l- g0 T  T% R2 A% @
162.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     * Q5 D' q1 m% J
163.     TIM_TimeBaseStructure. TIM_Period =9999;          // 配置计数阈值为9999，超过时，自动清零，并触发中断
       }1 u! G( i: A- ?, w) m
164.     TIM_TimeBaseStructure.TIM_Prescaler =71;         //  时钟预分频值，除以多少
     
165.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 时钟分频倍数
     
166.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 计数方式为向上计数
     $ n/ [; j( P$ P5 `3 l
167.     TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);      //  初始化tim4
     
168.     TIM_ClearITPendingBit(TIM4,TIM_IT_Update); //清除TIM4溢出中断标志
     
169.     TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);   //  使能TIM4的溢出更新中断
     9 ]6 _* @6 C7 L7 n) p$ |2 V, a3 q
170.     TIM_Cmd(TIM4,ENABLE);                //        使能TIM4
     
171. }
     
172. 
     
173. 
     
174. void tim3()                           //配置TIM3为基本定时器模式 ，约10us触发一次，触发频率约100kHz
     
175. {
     ' O) N0 v# ?* \! f; t
176.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   //定义格式为TIM_TimeBaseInitTypeDef的结构体的名字为TIM_TimeBaseStructure  
     
177.     TIM_TimeBaseStructure. TIM_Period =9;         //配置计数阈值为9，超过时，自动清零，并触发中断
     7 f, T# g9 A% [- O- ]/ j1 c6 f# c$ p. [
178.     TIM_TimeBaseStructure.TIM_Prescaler =71;     //    时钟预分频值，除以多少
     3 S& \; `, ^1 o
179.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // 时钟分频倍数
     4 H' r) |4 i7 J, U& `4 f, Z
180.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  // 计数方式为向上计数
     
181.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);      //  初始化tim3
     - F# u7 L; k' E2 f1 J
182.     TIM_ClearITPendingBit(TIM3,TIM_IT_Update); //清除TIM3溢出中断标志
     
183.     TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE); //  使能TIM3的溢出更新中断
     
184.     TIM_Cmd(TIM3,ENABLE);                     //           使能TIM3
     ) W/ z5 W- I& v! c' D5 D
185. }
     
186. 
     
187. 
     
188. void nvic()                                 //配置中断优先级
     
189. {   
       z( l, F( T; J4 ~2 U" Z/ K6 c2 ~
190.      NVIC_InitTypeDef NVIC_InitStructure;  //    //   命名一优先级变量
     0 n* I+ G8 w; o! a
191.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);    //     将优先级分组方式配置为group1,有2个抢占（打断）优先级，8个响应优先级
     1 d4 |5 }  T" E) b1 y. {/ I" ?
192.      NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //该中断为TIM4溢出更新中断
     
193.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//打断优先级为1，在该组中为较低的，0优先级最高
     % ~6 e8 ?  a9 V: R  M) @6 A( R
194.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 响应优先级0，打断优先级一样时，0最高
     % g0 \' c) t& Q% o/ }+ Y
195.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;        //  设置使能
     
196.      NVIC_Init(&NVIC_InitStructure);                        //  初始化
     
197.      NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //要用同一个Group
     , \# l5 C9 A- A! }. m" k
198.      NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //TIM3 溢出更新中断
     
199.      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;//    打断优先级为1，与上一个相同，不希望中断相互打断对方
     / Q+ b4 h& g: N9 P, x' j! U
200.      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;     //  响应优先级1，低于上一个，当两个中断同时来时，上一个先执行
     
201.      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
     9 Q1 @4 T( y5 u; |( G5 @
202.      NVIC_Init(&NVIC_InitStructure);
       W8 M7 u: [6 }/ Q7 Z: J/ H4 q+ K
203. }

复制代码

转载自：单片机与嵌入式
9 z& D# C: U% r& W! B$ E& `$ c如有侵权请联系删除


/ k9 Y+ G& w" J& q' V! U' H
5 }6 h" I6 B0 ]2 H6 o, m! O