1：新建固件库工程文件
1.1找到一个固件库模板

8 z3 v5 ~- d+ y9 ~. P4 V

1.2：打开KEIL5新建工程
5 K* W. B$ B: G0 j

' @2 {( D$ O8 s2 D* Y





, [1 o9 B2 F6 h! K$ O0 l
9 B! A, O  R8 J9 T6 F- d

最终效果：



1.3：添加相关文件
8 q9 j, d2 i2 s. Z! U+ N+ F6 g然后我们针对不同文件夹 我们添加不同的文件进来。
1 [3 u+ I, F! U: b- _双击STARTUP 添加我们固件库的启动文件
+ f% R' r* w. O& j# h% a
" j6 I# ]7 v9 E. ^5 }STARTUP:添加Libraries——>CMSIS——>startup中的启动文件



8 G1 C" }$ E9 N. e3 OUSER：添加固件库的User文件夹中的.c文件
9 j7 k9 P9 z, [' m1 e
CMSIS 添加Libraries——>CMSIS文件夹中的.c文件
' A. v5 _4 j" n; F  H) I, L; DDOC:添加固件库中Doc文件夹的readme.txt
6 m4 O! \( s4 [# I( C3 D) M5 n4 B: U# Z2 HFWLIB:添加Libraries——>STM32F10x_StdPeriph_Driver文件夹中的.c文件

" D% A- q0 t5 P2 H4 h添加完效果
( A$ j; e" R: z3 V$ ~# y
2 S; [+ w  o% [' M9 ?) [: g5 A8 J- A

1.4：手动添加其他文件路径进来
打开stm32f0x.h文件
4 n* l& n1 w  q2 _( `8 c& w
3 p# o7 d- K3 e
- x$ P# f7 g: O9 W+ x
6 x9 r* K- p. i" W2 Z) i! I按 Ctrl + F 查找 stm32f10x_conf
6 I% ]6 C/ a+ F0 `' c) X2 H8 |$ B会调到一下的代码 我们得宏定义加载一下
: i, y9 T1 y) @% g' b4 ^
5 L( i2 r% r9 t# O


- y5 {" T8 w2 x( G6 g
; @; I: L) v0 r+ S; x0 S8 I添加其他文件夹.h路径

1 E) c/ P0 k: ^2 u/ b$ K

这样就是新建固件库工程文件完成了。。。。。
下面就开始点灯 点灯 点灯
6 D7 K. O0 l  K& d9 @: l下面就开始点灯 点灯 点灯
9 ~) O2 x1 Y, W4 a( U* l下面就开始点灯 点灯 点灯

; r, U; C- M3 d: @2 x9 Z5 p2：STM32固件库点灯
* a( U( Q! R! S% ]首先你得有个固件库手册来参考 我这里直接上代码。
0 @! D# S! q+ a: k$ N6 Y" S


. N. r2 D( i7 M  v$ B* n我这个用的STM32C8T6板子 PC13是LED灯 根据原理图 给个低电平则点亮

LED配置代码
: x0 O+ K! N! u1 [5 z( w4 Hled.c

1. #include "stm32f10x.h"
   * ^; {5 E9 k: [9 a
2. #include "led.h"
     C$ a6 L" _* j& a: [: w
3. 
   
4. void LED_Init(void)
   
5. {        
   
6.         //1.打开控制GPIOC的时钟(APB2)
     C2 i5 r8 Q% a, k# b+ z
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
   
8.         
   
9.         //2.配置结构体        
   
10.         GPIO_InitTypeDef led_init;
    
11.         led_init.GPIO_Pin   = GPIO_Pin_13;      //GPIOC13引脚
    
12.         led_init.GPIO_Mode  = GPIO_Mode_Out_PP; //推挽输出        
    
13.         led_init.GPIO_Speed = GPIO_Speed_10MHz; //10MHz
    7 y2 p& Q5 q+ C. ]
14.         
    
15.         //3.对成员进行初始化
    
16.         GPIO_Init(GPIOC, &led_init);
    6 J+ K) [& j5 Q. {7 i0 Z. N
17. }

复制代码

led.h
2 u6 v( D! u1 e! g- V3 R) g9 m

1. #ifndef _LED_H_
   % |9 a4 M: d" Q4 f0 T& d
2. #define _LED_H_
   9 ?* l/ @- z- Z1 y+ ^
3. 
   
4. #include "stm32f10x.h"
   ! |5 v& X# M$ D
5. 
   ! Y$ j# \' [0 O+ O, g8 \) L! {0 E
6. void LED_Init(void); //LED初始化函数声明
   , O# E! D  {2 Y
7. 
   , O! [) \) O( r0 a3 b4 n4 a/ E
8. #endif

复制代码

2.1: 方式1点灯
main.c
6 M' x; k, j, K/ `6 K

1. #include "stm32f10x.h"
   - ?9 o7 N  I1 l) k4 V0 x
2. #include "led.h"
   * x4 V/ g6 c, ]3 m
3. 
   # b- f# x% f! y: b/ s  R
4. int  main()
   
5. {
   
6.         LED_Init(); //LED初始化
   
7.         
   ! }, D/ `2 T5 ?% s
8.         while(1)
   + I1 g( a' Q  M0 c. U" l6 V4 z. y
9.         {
   
10.                 //方式1
    
11.                 //GPIO_SetBits(GPIOC,GPIO_Pin_13);                //P13引脚输出高电平
    ! L* X2 E, u: L. y" s
12.                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //P13引脚输出低电平        
    1 i/ K+ o% k6 E4 F
13.         }   
    9 O( {. ^6 f* b  A
14. }

复制代码

5 `" ~) g$ R' Y$ f2 k1 T" w2.2 :方式2点灯
6 u' c: @; N+ e' {# k' m5 C* Tmain.c

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. 
   
4. int  main()
   
5. {
   
6.         LED_Init(); //LED初始化
   
7.         
   
8.         while(1)
   
9.         {
   1 r; H7 w* n+ \! G0 L
10.                 //方式2
    
11.                 //GPIO_WriteBit(GPIOC,GPIO_Pin_13, Bit_SET);   //P13引脚输出高电平
    6 v0 t& ]4 B' J; F. u8 i
12.                 GPIO_WriteBit(GPIOC,GPIO_Pin_13, Bit_RESET); //P13引脚输出低电平
    
13.         }   
    
14. }

复制代码

: o* u& h1 G4 T& d2.3 :方式3点灯
  u6 W5 v1 r; s7 @, pmain.c

1. #include "stm32f10x.h"
   / G" K7 n3 G% L
2. #include "led.h"
   2 s! Z. @; N3 e8 V2 e4 ~
3. 
   1 C% G! d( L5 L7 O& m
4. int  main()
   
5. {
   ) s8 a# x7 r: O0 d- G' _* V
6.         LED_Init(); //LED初始化
   1 H- |+ \; Z0 \' R* Z6 x
7.         
   " S% C+ i, h9 X) I7 K
8.         while(1)
   " U2 a2 M' w) F2 b6 R1 {( @
9.         {
   
10.                 //方式3
    6 M5 k" B1 h; p+ f6 e7 C
11.                 //GPIO_Write(GPIOC, 0X2000);                  //P13引脚输出高电平
    3 C- {* U, F5 F1 L9 n4 z& U
12.                 GPIO_Write(GPIOC, 0X0000);                 //整组端口输出低电平
    ' C* d9 x4 s/ w# R2 |. e: }0 i1 w- v
13.         }   
    
14. }

复制代码

+ m& n% C2 I5 w( A4 t& H点灯效果


$ h6 `5 j: c' S! w
" P% N  h. A2 I3：STM32闪烁灯
加一个延时函数 我们就可以做一个 LED闪烁效果了
这里的延时我们没有用到定时器 ，只是简单的通过循环来延时。

% P% L8 ]4 r" T; F  _delay.c
* u. o( C2 V! S  I4 q

1. #include "stm32f10x.h"
   
2. #include "delay.h"
   % o1 g! k9 w7 W- l! x6 s( |; m
3. 
   1 e; O# Y/ D' c1 Z* @
4. void delay_ms(uint16_t time)
     j7 E7 @9 ?& K. }7 v
5. {
   
6.         uint16_t i = 0;
   0 b: a! O+ z! G* U( m
7.         while(time--)
   ' K" y" x( c7 z% ~6 c4 K" U
8.         {
   9 [3 S1 F! b5 K5 s  X
9.                 i = 10000;
   1 u" i+ I6 S' z3 ^( M& f
10.                 while(i--);
    
11.         }
    2 Q, O  p# \! P  f3 }0 m" \" v
12. }

复制代码

main.c

1. #include "stm32f10x.h"
   , n) j6 M  y7 y
2. #include "led.h"
   
3. #include "delay.h"
   
4. 
   
5. int  main()
   , E1 r: e* u; O: L  ^, B
6. {
   ) s9 A$ S1 M1 w6 z
7.         LED_Init(); //LED初始化
   
8.         
   
9.         while(1)
   
10.         {
    
11.                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    ! ^7 l2 u- _2 D4 l. t1 Z/ W
12.                 delay_ms(1000); //亮灯大约1秒
    
13.                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    
14.                 delay_ms(1000); //熄灭灯大约1秒
    + b5 h- t& {% h8 ]4 o8 P( \
15.         }   
    
16. }

复制代码

闪烁灯效果
$ p8 p9 X+ `/ p# p
& P7 D( G9 E, g1 }7 L- V$ ?
: M# X' R( R0 z1 h  c1 a3 U+ I+ V
4：STM32呼吸灯
呼吸灯就像我们人呼吸那样，我们可以让灯慢慢的亮 慢慢的暗，这个就是通过占空比来调节。（可以理解为LED高电平时间和LED低电平时间）
/ ]" O, E8 R  J, f( X- E) L0 I比如 LED 亮延时100us 然后 暗 100us 这时候他们占空比是百分之50.
那如果我们 LED 亮10us 然后暗 还是100us 这个时候 你会发现 LED灯变暗了很多。 这个其实是我们的视觉暂停 原因导致的。
2 x; o4 L. n4 z1 W1 I! r所以我们可以通过调节 LED点亮的时间 和 LED 熄灭的时间的比例来调节，让LED 慢慢的亮 然后 慢慢的 暗。
9 d, I8 T* k( K" z! ]
慢慢的亮 意思就是 LED的低电平时间慢慢的增加。
) K1 l7 q+ M6 O+ [* p3 I$ F比如从1us 慢慢 到500us 然后LED高电平时间则是 从500us 慢慢到1us。
! Z& o: ?3 n7 \1 j, \如果是想着LED灯 亮慢慢 暗 则相反。
9 k& a5 p; ?" ^6 v% s
main.c
% p( \! Y) d0 Q; P5 B. I4 g

1. #include "stm32f10x.h"
   
2. #include "led.h"
   ) ~! I* [! k4 A0 }7 M  S4 H
3. #include "delay.h"
   
4. 
   
5. int  main()
   6 Y3 D' }( l- {# G0 p
6. {
     }; y- T9 |; C$ A
7.         LED_Init(); //LED初始化
   
8.         unsigned char i = 0;
   
9.         unsigned int t = 1;
   6 X5 d' v' [- X3 ~6 e
10.         unsigned char flag = 1;
    
11.         while(1)
    3 U3 m7 ^5 K( s: @9 g. q/ y* l
12.         {
    % p' s) F5 h( e
13.                 if(flag == 1) //LED由暗到亮
    
14.                 {
    
15.                         for(i=0;i<10;i++)
    
16.                         {
    ' |  S3 P) {/ e/ A2 o2 v: b
17.                                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    
18.                                 delay_us(t);
    5 ?# g& |( B: n( N1 y2 @& g
19.                                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    
20.                                 delay_us(501-t);
    / S# {6 Y% g. B6 Y  }' f& X8 p
21.                         }
    ) R# k: c7 b- t) M( Y
22.                         t++;        
    * q( d0 U3 ]2 a& f0 _
23.                         if(t == 500)
    
24.                         {
    
25.                                 flag = 0;
    
26.                         }
    
27.                 }
    1 I0 S7 Z% F2 A+ \  g, C$ J
28.                 if(flag == 0) //LED由亮到暗
    4 r* j% ~; Q$ X- O, Y
29.                 {
    
30.                         for(i=0;i<10;i++)
    6 |8 E9 C" U  z# f( t4 K. r: d
31.                         {        
    
32.                                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    
33.                                 delay_us(t);
    0 E( w9 E5 {& E
34.                                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    # G8 W9 a. C9 N
35.                                 delay_us(501-t);
    
36.                         }
    7 v5 g6 ^6 r; `( \2 a
37.                         t--;
    ; S) S  O( [) G+ I0 U" k  C
38.                         if(t == 1)
    8 t$ V! c8 U1 A
39.                         {
    ( `$ I, _. n' K1 U
40.                                 flag = 1;
    8 K& X- U4 h, E+ S+ `8 b5 }
41.                         }
    % @* |+ }8 _9 Y& o/ }
42.                 }
    ) Q; b1 a: ~$ ~8 N9 j# K
43.         }
    
44. }

复制代码

! t1 P) y6 ^5 E+ J$ ?, k


6 s$ r# w$ P0 y5 u) U( O5 Q5：STM32按键点灯
% M) F( d+ j0 X$ b9 X我们玩了呼吸灯 也可以玩玩按键点灯，按键其实也是挺简单的，我用的按键是只有两个引脚的，我们任意的一脚接单片机的GND ，另一个接单片机的GPIO 当按下按键 这个GPIO则会是低电平。 那我们就检测这个GPIO是否是低电平 如果是 我们则点亮LED灯。
" {; o8 f' H/ i6 _  e/ \9 t
key.c
1 _' A4 o- p& C3 R4 \* [

1. #include "stm32f10x.h"
   
2. #include "key.h"
   - R; B) H6 d6 a% L
3. 
   
4. /*按键初始化函数*/
   
5. void KEY_Init(void)
   
6. {
   
7.         //1.打开控制GPIOA的时钟(APB2)
   
8.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   
9.         
   
10.         //2.配置结构体        
    4 k# R$ l" \) F
11.         GPIO_InitTypeDef key_init;
    1 N0 d6 t5 n( `/ a6 J
12.         key_init.GPIO_Pin   = GPIO_Pin_5;              //GPIOC13引脚
    
13.         key_init.GPIO_Mode  = GPIO_Mode_IPU;         //上拉输入        
    
14.         //led_init.GPIO_Speed = GPIO_Speed_10MHz; //10MHz
    " t$ |9 F. Z; T* o' n" i5 c
15.         
    
16.         //3.对成员进行初始化
    ; U3 ^8 u5 J! }: k
17.         GPIO_Init(GPIOA, &key_init);
    , Q, O1 _% M. v  L4 R( z
18. }

复制代码

main.c
- ~8 ^, |8 P  y2 u, a

1. #include "stm32f10x.h"
     W. l; g- B3 T( K
2. #include "led.h"
   
3. #include "key.h"
   - b+ c2 P- D. N- H8 z+ W
4. #include "delay.h"
   5 ?, O  {8 T- f6 r# i) Z: H6 B
5. 
   
6. int  main()
   ! `9 F3 F" X% p( Z1 }" n: s
7. {
   $ J( s7 N5 W+ Z" i3 x
8.         LED_Init(); //LED初始化
   
9.         KEY_Init(); //按键初始化
   , {4 g* e6 l2 x: v
10.         GPIO_SetBits(GPIOC,GPIO_Pin_13);        //LED设置高电平
      I- K$ C9 J: C, J0 Z8 K8 @
11.         GPIO_SetBits(GPIOA,GPIO_Pin_5);                //按键设置高电平
    
12.         
    
13.         while(1)
    
14.         {
    
15.                 //如果按键被按下
    
16.                 if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_5) == 0)         
    ; V/ c' R8 R9 j
17.                 {
    6 j+ f) \( x  k+ }, Z
18.                                 delay_ms(20); //消抖再次判断是否按下
    7 u2 ~3 r+ X( B$ g3 s7 _; G
19.                                 if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_5) == 0)
    / {  D0 \7 ~" }9 n8 @, O/ l) A
20.                                 {
    
21.                                         GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    : F2 N8 @; F$ D( i( j
22.                                         delay_ms(1000); //延时大约1秒                                
    
23.                                 }
    
24.                 }
    
25.                 else
    0 d! P# Y$ Z& n5 s
26.                 {
    
27.                                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    0 |: |9 Z& ?$ U) u: d9 T7 O6 E
28.                 }
    ( Q! e6 U5 ~0 r) [
29.         }
    ' C4 ~; c. e: w1 l" e
30. }

复制代码

6 u0 ^0 x& R1 T3 I# b) `# V; R6 o  [按键点灯效果


1 R! Q1 r3 l& g7 w- C
6：STM32震动感应灯
  j" Z" h, N2 N; i$ l需要材料：
6.1：震动传感器
. `4 Z$ p* p1 e
5 r. c& Y* E6 e* Z
0 U! P- d" e% m" k  A+ |
2.继电器
( O! P! z5 Q0 [2 v8 s5 M, h（我用的这个是高电平导通）
( n$ J. ^  d0 C/ a# @, @


9 w+ i' x! U( C/ |: F) o9 X# \灯
/ _" S' N9 Z7 i- _) n: @) c" }9 v' S这种是震动传感器，我们可以也通过震动来点灯，我用的这个模块是当发生震动时，会变成低电平。那其实就是相当于我们的按键，我们去检测一下这个模块到底是不是低电平如果是低电平，那么我们让LED灯点亮1秒啥的都有可以。
直接上代码：
3 o7 g& {$ j- |7 _配置震动传感器模块代码
, O5 ~3 W8 e; t; u, e" o3 {
9 ~! t/ R$ A2 Y5 O# o2 `代码
5 ]* {: h- S3 d5 c) w

1. shake.c
   ; o$ X8 v! c- ~! g# x# e3 Y; @
2. #include "stm32f10x.h"
   
3. #include "shake.h"
   
4. 
   
5. /*震动传感器初始化函数*/
   
6. void SHAKE_Init(void)
   
7. {
   ; m4 g. I8 _9 r7 c3 P  E; t
8.         //打开GPIOC时钟
   , b, ^/ ?2 S7 C0 w. n
9.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   7 I; D1 i9 _- @' X- p7 c0 v' j
10.         
    
11.         //配置结构体
    
12.         GPIO_InitTypeDef shake_init;
    
13.         shake_init.GPIO_Mode  = GPIO_Mode_IPU;         //上拉输入
    * a# ^- U/ W6 s: r7 h4 O
14.         shake_init.GPIO_Pin   = GPIO_Pin_3;                //A3引脚
    3 U! X: p" w6 H& l
15.         //shake_init.GPIO_Speed = GPIO_Speed_50MHz;
    & S- h" K6 W" c- T
16.         
    
17.         //成员初始化
    ; Z& f" y' R; M' Y' X
18.         GPIO_Init(GPIOA, &shake_init);               
    6 _9 B6 t+ u! ]  ?; K2 A
19. }

复制代码

继电器模块配置代码：
8 F( W! K  J& P' p
relay.c

1. #include "relay.h"
   # p* I$ ?0 _  X2 B
2. 
   
3. /*继电器模块初始化函数*/
   : a7 L3 c0 r) g: {! T4 F
4. void RELAY_Init(void)
   3 [. K! Y0 d7 G
5. {
   
6.         //打开时钟
   2 {4 |3 e$ P. q: I# k" v
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   4 L& Y- J. k) @9 G4 o0 b. N+ s
8. 
   / r/ ~' W. n$ m5 w6 _% `  ^
9.         //配置结构体
   4 B- L" \( v+ L2 m8 A
10.         GPIO_InitTypeDef relay_init;
    
11.         relay_init.GPIO_Mode  = GPIO_Mode_Out_PP;         //推挽输出
    5 z/ `* q0 t, Q; n! A
12.         relay_init.GPIO_Pin   = GPIO_Pin_4;                        //3引脚
    ) L: [3 u  `6 @9 k; r9 j; L- U7 A. r
13.         relay_init.GPIO_Speed = GPIO_Speed_50MHz;
    3 d- d$ h" [7 w, I+ D* m. R
14.         
    
15.         //成员初始化
    
16.         GPIO_Init(GPIOA, &relay_init);
    7 p3 E. ^" T  f  A0 k* ]
17. }

复制代码

main.c
% z" x4 a+ G0 o3 j5 i7 l: d4 j

1. #include "stm32f10x.h"
   
2. #include "led.h"
   . N9 C/ \" W" j/ h# ~" ~
3. #include "relay.h"
   
4. #include "delay.h"
   + M" U. k# L7 g( [8 r
5. #include "shake.h"
     [/ t  O; M- X
6. 
   7 R" F$ |7 z& ^" y/ D; l. ]
7. /*主程序入口*/
   ; d/ o- x+ [( \) U' ?
8. int  main()
   9 f; {  r- S! L. w2 e) n. X
9. {
   
10.         LED_Init();  //LED模块初始化
    ! E! _* o6 K8 ]& ?8 n
11.         RELAY_Init();//继电器模块初始化
    
12.         SHAKE_Init();//震动传感器初始化
    1 c9 R% I( U1 U
13.         
    % o2 F- q0 V, e' |0 o
14.         GPIO_SetBits(GPIOC, GPIO_Pin_13);         //LED高电平
    3 t/ ]3 B# n3 `8 {- F6 O# D
15.            GPIO_SetBits(GPIOA, GPIO_Pin_3);         //震动传感器高电平
    4 C3 `7 n5 p2 |2 S( m% M* Y1 y- p
16.         GPIO_ResetBits(GPIOA, GPIO_Pin_4);         //继电器低电平(关闭)
    7 S- @* T' b6 l7 F; W) z
17.         while(1)
    6 r: ]' d- `! g& ~2 T3 Z$ D" i
18.         {
    
19.                 if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_3) == 0)
    
20.                 {
    ( S* O  |& H2 Y
21.                         GPIO_ResetBits(GPIOC, GPIO_Pin_13); //LED点亮
    * G! t9 l+ J# D; X7 J* T
22.                         GPIO_SetBits(GPIOA, GPIO_Pin_4);         //继电器导通 (高电平)
    1 X* y# C% z* M0 K7 j& j1 ~
23.                         delay_ms(1000);
    
24.                 }
    4 g, z: p+ z/ f
25.                 else
    
26.                 {
    
27.                         GPIO_SetBits(GPIOC, GPIO_Pin_13);         //LED不亮
    + Z6 f0 P# f: y% p* l
28.                         GPIO_ResetBits(GPIOA, GPIO_Pin_4);         //继电器不导通 (低电平)
    ; f( Q3 G% U9 _
29.                 }
    5 t0 |6 f# R) ~+ V' B# S
30.                         
    
31.         }
    / [. e: A  `7 @" X- N+ H5 i* P# N9 g  W
32. }

复制代码

) K) ^3 Z- b9 I- h8 H8 I6 S& [; R如何接线

! u0 @+ D' d, w( G# z
) j7 B) o# f3 h: ]5 C
2 |3 ?# |8 |6 N6 X5 `
; K1 }6 `3 \6 U
项目效果
5 G0 D# w2 k  Q5 m
0 X, b1 t  I+ E/ i
/ E2 q$ U" p9 Z# v
' H9 |" X* x: E5 k  z7 k————————————————
* U& |7 W  T" f" b+ d转载：皮卡丘吉尔