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

. |, J! X# K9 p7 ]  h8 n* D

1.2：打开KEIL5新建工程
% l& L9 l6 U1 a7 x: `5 H  G0 I" g5 m
% |9 |& }  w5 \
: s" }0 V, n, p: a: M# ^
# x1 c2 ]: Q3 W  k/ S
3 P! I9 t) M' I6 N/ x) l


  g; F2 A5 G  F; A7 {



最终效果：
; C8 ]  ]; F) H+ W
0 h' [$ |7 [5 O6 }

3 N! @2 i! q9 L( V1.3：添加相关文件
然后我们针对不同文件夹 我们添加不同的文件进来。
( z& w, Q" T8 y" l! Z9 ]9 p% i双击STARTUP 添加我们固件库的启动文件

& i. V3 O% \0 }STARTUP:添加Libraries——>CMSIS——>startup中的启动文件



5 z2 ^+ B) f1 @8 i6 C" S( vUSER：添加固件库的User文件夹中的.c文件
( ^: `8 o% o3 g" f; z
& T( q9 G# Q, M, ^7 H( _( jCMSIS 添加Libraries——>CMSIS文件夹中的.c文件
DOC:添加固件库中Doc文件夹的readme.txt
+ D0 Q1 {& E  Q5 U% V9 MFWLIB:添加Libraries——>STM32F10x_StdPeriph_Driver文件夹中的.c文件
0 e- o1 J3 ^& T. F+ R
添加完效果
2 [. V8 A$ w7 y5 Q
& l4 o: |& T4 y
7 L& e; W: B* f. `  s
1.4：手动添加其他文件路径进来
打开stm32f0x.h文件

3 U3 g7 s5 @: h2 L
, N7 i$ C; X9 v- H
4 m' E. g/ ^( F. B8 p7 S. d) O* l按 Ctrl + F 查找 stm32f10x_conf
会调到一下的代码 我们得宏定义加载一下
2 Q! p" E9 U, z6 B

* i6 s( v# T$ K6 b8 T$ k

) s" d  T8 D4 p# M
添加其他文件夹.h路径


% D, L  y4 I7 R7 C$ ^- B. G
这样就是新建固件库工程文件完成了。。。。。
! s& M; A' p9 l4 x下面就开始点灯 点灯 点灯
4 u' Q! F  H; o0 u0 r, u" B1 c下面就开始点灯 点灯 点灯
下面就开始点灯 点灯 点灯

2：STM32固件库点灯
% [/ w$ {* l2 _! r首先你得有个固件库手册来参考 我这里直接上代码。
7 ?9 l+ R4 O2 h2 D+ A& U

0 p9 `% w. a& [
% Z, _* Z1 M; \8 A我这个用的STM32C8T6板子 PC13是LED灯 根据原理图 给个低电平则点亮

0 Q( o/ |0 v( S# ]LED配置代码
6 Q- U! `+ n$ E9 J5 g* ?  h0 iled.c
4 g* _9 r6 R. |8 C( [, _

1. #include "stm32f10x.h"
   3 v3 z0 A' o; r- R+ t$ k
2. #include "led.h"
   " |- X7 H; ^" ^1 W5 ^4 o
3. 
   
4. void LED_Init(void)
   8 X$ g0 v& @" [) m4 M5 j
5. {        
   3 ?+ g; G8 O2 b1 P; Q8 P
6.         //1.打开控制GPIOC的时钟(APB2)
   
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
    . R( ^+ K/ h6 |5 z
14.         
    
15.         //3.对成员进行初始化
    
16.         GPIO_Init(GPIOC, &led_init);
    3 S$ _: h' E9 f
17. }

复制代码

9 g: S- m- y4 N8 k% a: aled.h
( i7 n' m' l7 d7 F1 ]

1. #ifndef _LED_H_
   5 F. c9 ]5 O! U3 P6 Y$ ?7 a
2. #define _LED_H_
   
3. 
   % e# t8 y" d( B" W, x
4. #include "stm32f10x.h"
   
5. 
   
6. void LED_Init(void); //LED初始化函数声明
   / l  b$ V6 W3 ?- D; n. L+ ~3 M  a6 j
7. 
   . j8 x, g# `( K- r6 Q3 b
8. #endif

复制代码

- r/ \, p+ S; N2 B) e1 D3 G# e2.1: 方式1点灯
" Z/ ~* `( S6 \5 {  I- Omain.c
$ m' b4 Y2 ?" A

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. 
     G& _5 R+ l6 @$ o6 B' w
4. int  main()
   
5. {
   4 P4 s: Z1 O$ Q  j9 P
6.         LED_Init(); //LED初始化
   
7.         
   6 ]# ]* l8 ^0 }: v
8.         while(1)
   6 b& P" A( R+ B, A" p
9.         {
   
10.                 //方式1
    
11.                 //GPIO_SetBits(GPIOC,GPIO_Pin_13);                //P13引脚输出高电平
    " r1 m% o+ q! u4 T2 [0 y6 Y; s; Q
12.                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //P13引脚输出低电平        
    . p  o& L0 @) J6 k6 Y0 _7 n5 L
13.         }   
    * Z/ Q7 S0 H) p. x* s
14. }

复制代码

2.2 :方式2点灯
- e6 p1 O3 g' ^- _% u$ ]) Nmain.c

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. 
   
4. int  main()
   
5. {
   
6.         LED_Init(); //LED初始化
   ' \9 L- i; w* z2 Q' Z7 o2 @' N7 |
7.         
   - C" P4 B1 I5 ?2 U7 p6 R4 e
8.         while(1)
   
9.         {
   $ J9 X! q* a& [/ J  o( H' B
10.                 //方式2
    1 z3 g2 `/ ~. O: Z5 K
11.                 //GPIO_WriteBit(GPIOC,GPIO_Pin_13, Bit_SET);   //P13引脚输出高电平
    ' k# I0 l2 Y. M
12.                 GPIO_WriteBit(GPIOC,GPIO_Pin_13, Bit_RESET); //P13引脚输出低电平
    
13.         }   
    ( \7 v( q, M6 K4 C4 q; S9 ]
14. }

复制代码

+ I$ y7 d5 m3 o5 m' F. t+ l5 D2.3 :方式3点灯
main.c
- b, R( G% O. e9 k. ^; U; M1 ~: }* D

1. #include "stm32f10x.h"
   
2. #include "led.h"
   + O: B" ]$ p' ]2 U
3. 
   
4. int  main()
   6 d9 M( Y& R9 n5 }8 Z) Y! ~
5. {
   ( G% t5 ~+ H, W3 `" w, u" Q
6.         LED_Init(); //LED初始化
   1 m9 i6 v9 a4 L
7.         
   + K2 J- ?  l& i/ h" q; g9 j7 M& j
8.         while(1)
   
9.         {
   
10.                 //方式3
    : s7 i( ~8 O; F+ q
11.                 //GPIO_Write(GPIOC, 0X2000);                  //P13引脚输出高电平
    
12.                 GPIO_Write(GPIOC, 0X0000);                 //整组端口输出低电平
    ) C: q! V! D! m7 {
13.         }   
    
14. }

复制代码

5 F! P. Y8 r8 E9 z( n  O; R6 {点灯效果
% h! q+ h( ~9 x( Z* e* Y1 k3 X
/ o2 ]. [: q  h  S/ Q
- }& w3 U# Y& b- w* F& A
3：STM32闪烁灯
加一个延时函数 我们就可以做一个 LED闪烁效果了
: p& t. Q+ m8 e; I+ ^这里的延时我们没有用到定时器 ，只是简单的通过循环来延时。
9 U. ?# \4 }: b$ c2 U
delay.c
7 y- @3 B4 f$ m  u

1. #include "stm32f10x.h"
   
2. #include "delay.h"
   ( {! r0 c1 Y6 Z# e# o! I) W
3. 
   ) s* c; e6 ~9 c! ~# C3 b
4. void delay_ms(uint16_t time)
   ; c  Z7 U7 U4 W) L
5. {
   
6.         uint16_t i = 0;
   ; `9 Q4 s, l$ F5 t' m" v
7.         while(time--)
   
8.         {
   6 C: O4 O2 P1 g' j( ^" \
9.                 i = 10000;
   6 T/ }  H* U* k. E3 E) o
10.                 while(i--);
    
11.         }
    . F! W: \6 C+ u" x/ o
12. }

复制代码

main.c
- Z- E+ t4 d( r+ Z" |2 Q& E+ L! J

1. #include "stm32f10x.h"
   / l5 f% n* ?( [* Q- p$ l8 N$ Q% G" |
2. #include "led.h"
   3 L" H& P2 ^2 j8 |8 t
3. #include "delay.h"
   + _1 g( U$ d' z9 c9 Y  i- N! Y0 l& {  Y
4. 
   
5. int  main()
   
6. {
   
7.         LED_Init(); //LED初始化
   
8.         
   7 G" k0 R; l; D4 I' h* g
9.         while(1)
   : F- G# n: ?- ?- l  l1 X; R* y
10.         {
    
11.                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    
12.                 delay_ms(1000); //亮灯大约1秒
    4 ~" h) m6 i/ I: ?9 d( W
13.                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    0 s* V4 X' g% M# B
14.                 delay_ms(1000); //熄灭灯大约1秒
    5 l* |: C# F3 t* F9 i
15.         }   
    
16. }

复制代码

闪烁灯效果

9 @* L$ l+ _) u0 e7 L  I/ _; e
! T' |/ [; Y5 t( u3 D! |
4：STM32呼吸灯
呼吸灯就像我们人呼吸那样，我们可以让灯慢慢的亮 慢慢的暗，这个就是通过占空比来调节。（可以理解为LED高电平时间和LED低电平时间）
比如 LED 亮延时100us 然后 暗 100us 这时候他们占空比是百分之50.
那如果我们 LED 亮10us 然后暗 还是100us 这个时候 你会发现 LED灯变暗了很多。 这个其实是我们的视觉暂停 原因导致的。
2 V) {, i) y1 [: |所以我们可以通过调节 LED点亮的时间 和 LED 熄灭的时间的比例来调节，让LED 慢慢的亮 然后 慢慢的 暗。

5 [/ W; b; U% Y% y! N. Y慢慢的亮 意思就是 LED的低电平时间慢慢的增加。
6 j0 [4 g  s$ L4 M比如从1us 慢慢 到500us 然后LED高电平时间则是 从500us 慢慢到1us。
# q& l: V' D0 e* L如果是想着LED灯 亮慢慢 暗 则相反。
. o- _. }7 q4 o" h7 l
main.c
4 ?# |: R) U3 }

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. #include "delay.h"
   ! H0 h6 d/ B) e, e+ ?/ d! }
4. 
   ! B, w- b0 d  x6 X3 v
5. int  main()
   
6. {
   9 T3 l* k, V$ ^0 G  u: c
7.         LED_Init(); //LED初始化
   
8.         unsigned char i = 0;
   2 Y9 I1 |1 R- D6 A: `& g, R
9.         unsigned int t = 1;
   # |* ~: t, q5 O5 V! s- N/ P' a
10.         unsigned char flag = 1;
    ( Z2 [) Z+ s  B4 ?1 h
11.         while(1)
    . ?' n& v& m8 V# b1 c
12.         {
    2 v! ^: y7 B8 Q
13.                 if(flag == 1) //LED由暗到亮
    
14.                 {
    8 o7 N  \' S$ Q7 ?
15.                         for(i=0;i<10;i++)
    
16.                         {
    
17.                                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    2 |# Y  W, f# e: e
18.                                 delay_us(t);
    
19.                                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    $ _+ v- i. L1 y: b3 L
20.                                 delay_us(501-t);
    3 d/ d' M! q0 l! ^
21.                         }
    
22.                         t++;        
    8 h1 n- B/ Y' h$ Q7 s
23.                         if(t == 500)
    . D9 ?! l7 }; \/ R
24.                         {
    
25.                                 flag = 0;
    
26.                         }
    : n9 e/ y8 X2 |
27.                 }
    , a0 ]9 M9 ~& ]# b, @
28.                 if(flag == 0) //LED由亮到暗
    
29.                 {
    
30.                         for(i=0;i<10;i++)
    
31.                         {        
    " _0 m& u4 G8 g& o; U
32.                                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    ( g7 k$ l/ T/ w  Y# c" i6 x
33.                                 delay_us(t);
    
34.                                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    
35.                                 delay_us(501-t);
    1 W1 q7 L. w4 h- w+ |1 z: F
36.                         }
    . p3 P$ c  |) l2 a7 e
37.                         t--;
    
38.                         if(t == 1)
    ( \# P2 k8 c8 B1 ~4 ~
39.                         {
    . M# e. |$ \' ?0 K1 S6 P
40.                                 flag = 1;
    
41.                         }
    
42.                 }
    ; F8 ~" @  s; A2 _( i3 n8 z% a& j+ n
43.         }
    * g7 `; {  t# L! s+ [( R  }
44. }

复制代码

& e7 a+ G' [5 {$ X/ n5：STM32按键点灯
7 O, w- D+ d8 u7 J我们玩了呼吸灯 也可以玩玩按键点灯，按键其实也是挺简单的，我用的按键是只有两个引脚的，我们任意的一脚接单片机的GND ，另一个接单片机的GPIO 当按下按键 这个GPIO则会是低电平。 那我们就检测这个GPIO是否是低电平 如果是 我们则点亮LED灯。

, t9 I# c% ?' }6 D  r6 V/ ~key.c

1. #include "stm32f10x.h"
   3 e- w1 r) _' q
2. #include "key.h"
   
3. 
   2 a  {  P" J. [6 p4 X& m2 h
4. /*按键初始化函数*/
   
5. void KEY_Init(void)
   
6. {
   
7.         //1.打开控制GPIOA的时钟(APB2)
   3 m2 O2 X1 D4 X6 W
8.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   
9.         
   , G( j1 P0 r7 h
10.         //2.配置结构体        
    
11.         GPIO_InitTypeDef key_init;
    
12.         key_init.GPIO_Pin   = GPIO_Pin_5;              //GPIOC13引脚
    4 q: H" a2 i- R
13.         key_init.GPIO_Mode  = GPIO_Mode_IPU;         //上拉输入        
    9 G$ A. i) V, e2 Y8 ?
14.         //led_init.GPIO_Speed = GPIO_Speed_10MHz; //10MHz
    
15.         
    ( d2 A( i3 a% d: A" g
16.         //3.对成员进行初始化
    
17.         GPIO_Init(GPIOA, &key_init);
    
18. }

复制代码

main.c

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. #include "key.h"
   
4. #include "delay.h"
   
5. 
   & H. u, [# v: s
6. int  main()
   * n9 j% e" \( v; W( q, O# D+ s
7. {
   7 |7 Q" Q; ~* t; |6 `
8.         LED_Init(); //LED初始化
   - R0 n4 O" O0 O" o  U
9.         KEY_Init(); //按键初始化
   
10.         GPIO_SetBits(GPIOC,GPIO_Pin_13);        //LED设置高电平
    , ]* |" l: c: {0 ^
11.         GPIO_SetBits(GPIOA,GPIO_Pin_5);                //按键设置高电平
    
12.         
    
13.         while(1)
    
14.         {
    0 o2 m) B% Q8 Y
15.                 //如果按键被按下
    
16.                 if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_5) == 0)         
    
17.                 {
    
18.                                 delay_ms(20); //消抖再次判断是否按下
    , A2 m0 C/ I4 Q9 V. f; T) @/ q
19.                                 if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_5) == 0)
    
20.                                 {
    / l; m8 l$ l9 P5 {3 c
21.                                         GPIO_ResetBits(GPIOC, GPIO_Pin_13);         //LED点亮
    6 ^( y) W8 g0 K  |6 z1 y
22.                                         delay_ms(1000); //延时大约1秒                                
    
23.                                 }
    
24.                 }
    3 J, [- S' M1 A, Q( b9 ^
25.                 else
    ) {9 X, s* @' [, e7 @. a
26.                 {
    7 j9 B  d6 d4 s5 Z  s+ s0 R
27.                                 GPIO_SetBits(GPIOC,GPIO_Pin_13);                //LED熄灭
    * x4 G- _' N9 m3 N# e) e
28.                 }
    " I7 T! G( J& W8 r
29.         }
    
30. }

复制代码

$ c+ y$ a1 Y, ?* y: F按键点灯效果
  `0 N& ]" O: z6 ^4 N' V
* ]$ S( W$ ~- E5 f

7 s3 p1 R6 p8 \+ q1 K! I8 i6：STM32震动感应灯
需要材料：
6.1：震动传感器
9 B% z( ?0 n1 D( `5 F


5 K7 P' `" m( L" _2.继电器
（我用的这个是高电平导通）
7 E9 H! d: G& m
5 l2 O% O( j# G3 F9 A( R' O, C4 r

灯
5 B4 G) o9 u$ y" e% L这种是震动传感器，我们可以也通过震动来点灯，我用的这个模块是当发生震动时，会变成低电平。那其实就是相当于我们的按键，我们去检测一下这个模块到底是不是低电平如果是低电平，那么我们让LED灯点亮1秒啥的都有可以。
直接上代码：
" z* A& Y4 T; b6 T" z( _) V配置震动传感器模块代码
! s1 V" o9 [2 e7 a$ T
代码
+ S; q1 {  r; [9 _: T! B7 s2 W

1. shake.c
   
2. #include "stm32f10x.h"
   
3. #include "shake.h"
   
4. 
   
5. /*震动传感器初始化函数*/
   
6. void SHAKE_Init(void)
   ; g$ X% W- O8 h) l
7. {
   
8.         //打开GPIOC时钟
   . S" j0 {1 T) F6 l( d
9.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   3 o5 y" T9 L+ ?7 x8 b# |
10.         
    
11.         //配置结构体
    
12.         GPIO_InitTypeDef shake_init;
    
13.         shake_init.GPIO_Mode  = GPIO_Mode_IPU;         //上拉输入
    7 t* O9 N- Q9 k4 [' z5 R
14.         shake_init.GPIO_Pin   = GPIO_Pin_3;                //A3引脚
    
15.         //shake_init.GPIO_Speed = GPIO_Speed_50MHz;
    
16.         
      t, s# k5 ]+ E: P* }; _
17.         //成员初始化
    , T8 f/ |9 W; D+ K
18.         GPIO_Init(GPIOA, &shake_init);               
    
19. }

复制代码

5 A: C% I: O8 F/ C+ O) W( A6 ~: i* p继电器模块配置代码：
2 P8 \, I0 }* i$ d0 C2 i: i
# H. k& D! _! Y( ^% N& I. Q0 wrelay.c

1. #include "relay.h"
   ' c% p6 D/ B9 U. Q2 B, t
2. 
   
3. /*继电器模块初始化函数*/
   
4. void RELAY_Init(void)
   2 W. J. q" E" h$ a+ _& i/ x; n" Y
5. {
   4 o1 \! `! A0 c7 C& L! q
6.         //打开时钟
   
7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
   
8. 
   / P% y# ^" R8 ^
9.         //配置结构体
   " d& w6 c: n" |/ X
10.         GPIO_InitTypeDef relay_init;
    4 @1 v9 s" m6 o5 x, F
11.         relay_init.GPIO_Mode  = GPIO_Mode_Out_PP;         //推挽输出
    , T9 ]0 @4 z  X3 V
12.         relay_init.GPIO_Pin   = GPIO_Pin_4;                        //3引脚
    
13.         relay_init.GPIO_Speed = GPIO_Speed_50MHz;
    # E- h1 i; P7 U
14.         
    
15.         //成员初始化
    ( V: l( z( P* M' n2 j; D
16.         GPIO_Init(GPIOA, &relay_init);
    $ E4 F2 v2 |: G6 j2 i: P
17. }

复制代码

main.c

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. #include "relay.h"
   # g" q7 D& `: J5 i, z* C4 w' l- u
4. #include "delay.h"
   3 [2 p/ z+ D- d# j9 e- l) v- a
5. #include "shake.h"
   
6. 
   ! S4 }: `  @' Y6 }* P: W# x
7. /*主程序入口*/
   ; u  m9 O! i# d+ _1 Y
8. int  main()
   
9. {
   5 I. {8 g8 ~9 T" I
10.         LED_Init();  //LED模块初始化
    
11.         RELAY_Init();//继电器模块初始化
      |, q) a. M  y/ A4 ^
12.         SHAKE_Init();//震动传感器初始化
    % b( y, p8 `8 R
13.         
    
14.         GPIO_SetBits(GPIOC, GPIO_Pin_13);         //LED高电平
    $ w6 H  z8 k5 V7 y8 G
15.            GPIO_SetBits(GPIOA, GPIO_Pin_3);         //震动传感器高电平
    
16.         GPIO_ResetBits(GPIOA, GPIO_Pin_4);         //继电器低电平(关闭)
    
17.         while(1)
    
18.         {
    # Z) N3 I/ d8 l6 T# Y
19.                 if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_3) == 0)
    / J; ?: R0 ~, a/ g8 O
20.                 {
    
21.                         GPIO_ResetBits(GPIOC, GPIO_Pin_13); //LED点亮
    : v" W" B2 s4 W# s$ w+ ]
22.                         GPIO_SetBits(GPIOA, GPIO_Pin_4);         //继电器导通 (高电平)
    
23.                         delay_ms(1000);
    4 s. C( _) g9 r. A5 S$ `8 q
24.                 }
    9 ?4 h. H  R* Z/ s* K: K- {
25.                 else
    3 k/ f( l  j& O$ e1 W
26.                 {
    
27.                         GPIO_SetBits(GPIOC, GPIO_Pin_13);         //LED不亮
    
28.                         GPIO_ResetBits(GPIOA, GPIO_Pin_4);         //继电器不导通 (低电平)
    
29.                 }
    
30.                         
    & [1 Y  Q/ X8 Y+ D0 X" v
31.         }
    
32. }

复制代码

如何接线

$ @7 |2 y# B1 N. m, F( {% v
) O% o, L- y" A; Q
; O( a7 E7 p7 L& j5 M& s6 X& g- s
# i0 p+ W7 n7 `8 H1 |
项目效果
: A( x' d: [. ?


& v  O7 B# J8 z8 _  c2 s# |# l————————————————
转载：皮卡丘吉尔