嵌入式初学者入门的第一个“项目”就是LED点灯，那么，本文带你看看51、STM32、Linux点灯有什么区别？

51点灯

51点灯，是很多单片机初学者的首选，难度也是相对比较低的。
( H/ w8 U- \, n$ d准备工作：

• 51开发板（以STC51单片机为例）
• Keil C51、STC-ISP下载软件
  
  
  

) s- j$ h: N" u2 L51单片机开发，通常是直接操作寄存器，比如P1_0对应LED的IO口。
- e0 a. |6 s7 Y3 U- S7 Y+ @+ b源代码：

1. #include <reg51.h>
   
2. sbit LED = P1^0;
   
3. void main(){    LED = 0;
   * `9 y# R- |$ Q
4.     while(1);}

复制代码

STM32点灯

相对于51点灯，STM32点灯难度系数要大一点，因为STM32外设资源更多，启动文件更复杂，很多新手看到之后直接就放弃了。
其实，也很简单，下面分别通过寄存器和标准外设库点灯，你就知道明白了。
4 N( W( s+ `; n. d  m. d准备工作：

• STM32开发板
• Keil MDK、ST-LINK Utility下载软件
  ; w# ~; a* G0 \& i6 v

1、寄存器版本
4 c. C  r8 z7 u  ~9 q+ n9 C直接操作寄存器，需要深入理解每个寄存器每个bit位的含义（不建议初学者一开始就学寄存器），而且，源码看起来比较多：
3 W- W2 C8 G+ Z  L) d

1. 
   
2. #include "stm32f4xx.h"
   2 P0 M9 r6 X* k# w! _
3. 
   9 \2 I& @/ P! V" a! B8 r) y! k
4. /* 主函数*/
   # F: J, L- w" I. O
5. int main(void)
   
6. {
   
7.     /*开启 GPIOH 时钟，使用外设时都要先开启它的时钟*/
   
8.     RCC_AHB1ENR |= (1<<7);
   
9. 
   
10.     /* LED 端口初始化 */
    8 e- Z* z3 [* z- ~! D
11.     /*GPIOH MODER10 清空*/
    % u$ ]: O& f0 E) a; l% O. r: \
12.     GPIOH_MODER &= ~( 0x03<< (2*10));
    
13. 
    
14.     /*PH10 MODER10 = 01b 输出模式*/
    3 d1 x! Q4 o( O8 x% d0 c' U
15.     GPIOH_MODER |= (1<<2*10);
    ; I/ L" U( f" _) D' }% y
16. 
    1 X% \& ~+ ~, z+ S) d
17.     /*GPIOH OTYPER10 清空*/
    7 S7 y* N1 R+ R: Q, R
18.     GPIOH_OTYPER &= ~(1<<1*10);
    : ~/ R) Q: _: K0 w6 P5 h0 S7 g
19. 
    * U: f" q& S6 p+ w
20.     /*PH10 OTYPER10 = 0b 推挽模式*/
    
21.     GPIOH_OTYPER |= (0<<1*10);
    
22. 
    
23.     /*GPIOH OSPEEDR10 清空*/
    
24.     GPIOH_OSPEEDR &= ~(0x03<<2*10);
    0 d. a# I8 p0 s# Y) J
25. 
    
26.     /*PH10 OSPEEDR10 = 0b 速率 2MHz*/
    
27.     GPIOH_OSPEEDR |= (0<<2*10);
    $ J4 \+ {3 b( P# m( k  ?
28. 
    5 {  s7 V' `0 h& w" C
29.     /*GPIOH PUPDR10 清空*/
    7 H, `, H& j4 c' N- H0 T
30.     GPIOH_PUPDR &= ~(0x03<<2*10);
    1 _1 }8 b, p6 e1 O( a  m
31. 
    
32.     /*PH10 PUPDR10 = 01b 上拉模式*/
    
33.     GPIOH_PUPDR |= (1<<2*10);
    
34. 
    1 y5 t; Q/ z, o: \: u
35.     /*PH10 BSRR 寄存器的 BR10 置 1，使引脚输出低电平*/
    
36.     GPIOH_BSRR |= (1<<16<<10);  //点灯
    
37. 
    . I% ~+ ]' `. N
38.     while (1);
    . U# d+ [& l. k
39. }
    , p/ T  K1 g! |" I% X) m$ O) E: n

复制代码

- L6 a3 x; O0 I( t! Q5 S
# P& S; s0 n+ s) E3 Y! H' i2、标准外设库版本
标准外设库，就是ST官方已经把寄存器进行封装过一次，你直接调用函数借口即可。

1. #include "stm32f10x.h"
   : e; r( y( n3 D3 r7 g2 k$ n
2. 
   " c' }* J& j; V9 }
3. /*  LED时钟端口、引脚定义*/
   
4. #define LED_PORT       GPIOC   
   
5. #define LED_PIN       GPIO_Pin_0
   3 C4 i+ M, y) C" D9 [* U9 `
6. #define LED_PORT_RCC            RCC_APB2Periph_GPIOC
   
7. 
   
8. void LED_Init()
   , v/ e1 |7 p4 E' o) u
9. {
   
10.     GPIO_InitTypeDef GPIO_InitStructure;        //定义结构体变量
    
11. 
    , R! Z' ?. z, J& H7 @. L
12.     RCC_APB2PeriphClockCmd(LED_PORT_RCC, ENABLE);
    5 M' s# P8 l; B
13. 
    5 z- ]+ \& \& C0 z' `' s3 u0 u' \
14.     GPIO_InitStructure.GPIO_Pin = LED_PIN;                //选择你要设置的IO口
    
15.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;      //设置推挽输出模式
    1 W! J! _! F9 a2 u
16.     GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;       //设置传输速率
    4 m: R' o8 ~0 R: w+ t: T
17.     GPIO_Init(LED_PORT,&GPIO_InitStructure);              //初始化GPIO
    . I5 N6 @1 [' L
18. 
    2 Y8 K1 E. r4 u3 K: ?
19.     GPIO_SetBits(LED_PORT, LED_PIN);                       //将LED端口拉高，熄灭LED
    
20. }
    
21. 
    ( \. U$ C: X5 z  n
22. int main()
    
23. {  
    
24.   LED_Init();
    9 g, ]! t0 b' c3 b" N; `1 R
25.   GPIO_ResetBits(LED_PORT,GPIO_Pin_0);//点灯
    
26. 
    
27.     while(1);
    4 c% \& s# v9 B3 O
28. }
    " R2 z$ y0 j4 b. [' n

复制代码

; w# ]5 l- s1 y( L& K

Linux点灯

Linux点灯，相对来说就更复杂了。当然，有一些已经搭建好的环境，就相对简单一点，也比较容易。如果自己一步一步移植系统、写驱动···就很复杂。
+ [, |0 x# J( Y6 z# I) B
0 o" @6 b# x; g- ]" m. P/ g, d1、树莓派
我们这里以【开源库wiringPi】为例：

• 下载U-boot源码，配置、编译；
• 下载Linux内核、配置、编译（一般开发板都会有现成的配置文件）；
• 制作跟文件系统；（以上三个步骤，如果没有一定的Linux基础，可以使用一键烧写）
• 移植开源库WiringPi；
• 查看电路图找到LED对应的引脚，程序需要用到引脚号；
• 编码、交叉编译；
• 下载运行。
  
  

4 E  I, K* K# a8 G准备工作做好之后，点灯的源码就比较简单：

1. #include <wiringPi.h>
   " v1 t3 @! ]5 ]5 |4 B( r5 F
2. 
   ! Z7 L4 N- m0 n1 L
3. int main(void)
   3 o) B4 i4 x8 d
4. {
   
5.     wiringPiSetup() ;
   , e3 u, F* _, m5 |
6.     pinMode (7, OUTPUT);
   
7.     gitalWrite(7, HIGH);
   " L3 c& q) c/ [( H8 C. X
8.     while(1);
   
9. }

复制代码

" C& Q0 n( s. V2 ^4 U/ s: M
2、Linux驱动点灯
在所有的点灯方法中，这个方法难度系数极高，涵盖了嵌入式开发从上层应用到底层驱动。步骤涉及了驱动代码编写、Linux内核模块添加、移植操作系统、Linux应用程序编写。
这里分享一下mini2440经典LED驱动源码：

1. 
   8 t( X3 P/ v* \# }& U7 q& D
2. #include <linux/init.h>
   
3. #include <linux/module.h>
   . j5 M  P- n/ n
4. #include <linux/fs.h>
   
5. #include <linux/miscdevice.h>
   
6. #include <linux/ioctl.h>
   
7. #include <linux/gpio.h>
   
8. #include <mach/regs-gpio.h>
   9 P4 N* s) H3 s0 [  {# x
9. #include "led.h"
   
10. 
    
11. static int led_open(struct inode *inode, struct file *file)
    
12. {  
    
13.     s3c2410_gpio_cfgpin(S3C2410_GPB(5), S3C2410_GPIO_OUTPUT);
    
14.     s3c2410_gpio_setpin(S3C2410_GPB(5), 1);   
    ' r' W9 |; W/ g% @8 c  a/ O8 P
15.     return 0;
    " S& z! J& L5 k
16. }
    1 P; s8 x' I: U" L7 _. k2 ]
17. 
    9 Q; ], z; P; X
18. static int led_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
    
19. {  
    ; P- Y( c& v- Y' N; b& |1 z6 j
20.     switch (cmd) {  
    
21.         case LED_ON:   
    % j9 @9 d. [6 w5 F5 O% q; f/ g1 t9 ?
22.             s3c2410_gpio_setpin(S3C2410_GPB(5), 0);   
    + D4 l: h% f" g5 m! R* @
23.             return 0;  
    6 ?. A' F* Z" @
24.         case LED_OFF:   
    1 |; M8 @9 D6 y
25.             s3c2410_gpio_setpin(S3C2410_GPB(5), 1);   
    
26.             return 0;  
    ( f) w% T) n9 k7 D$ X$ v
27.         default:   
    
28.             return -EINVAL;  
    4 A# |" U4 i- f
29.         }
    
30. }
    
31. 
    
32. static struct file_operations led_fops = {  
    ! Q# L- D. {( z1 P6 ?
33.     .owner = THIS_MODULE,  
    
34.     .open = led_open,  
    6 v; `# {. m. a$ G3 M
35.     .ioctl = led_ioctl,
    
36. };
    
37. 
    
38. static struct miscdevice led_misc = {  
    8 Z- x4 |8 ]0 i" w: P
39.     .minor = MISC_DYNAMIC_MINOR,  
    
40.     .name = "led",  
    
41.     .fops = &led_fops,
    1 V" |/ F+ B8 _; p& `- j
42. };
    $ B# B$ ?- H% I6 [: M; J0 S  R* M
43. 
    
44. static int led_init(void){  
    7 d( w, ~$ E3 p, A. _
45.     return misc_register(&led_misc);
    
46. }
    
47. 
    2 U9 X* I' j  B3 Q; c
48. static void led_exit(void){  
    
49.     misc_deregister(&led_misc);
    " C7 Z5 u; D2 d& z
50. }
    / C9 ^+ Q. ]0 x
51. 
    
52. MODULE_LICENSE("Dual BSD/GPL");
    ! j6 c( X; F. Y- s
53. module_init(led_init);
    
54. module_exit(led_exit);
    8 l6 O6 m. l/ }" R* N+ ~9 S

复制代码

% b4 u( y/ {, D* P3 W驱动写了，然后就是应用层代码：

1. 
   
2. 
   4 j1 I% H+ w; h8 X  T6 Q2 z& r# {
3. #include <sys/types.h>
   
4. #include <sys/stat.h>
   
5. #include <fcntl.h>
   1 F9 p$ F$ x5 B9 E3 b
6. #include <sys/ioctl.h>
   ! N9 H% U$ a4 ^( q
7. #include <unistd.h>
   * Q) J0 Y( n3 Q' ^# _( J
8. #include <stdio.h>
   ) [; _1 N4 u0 T0 S
9. #include "led.h"
   
10. 
    
11. int main(void){        
    
12.     int fd;         
    % U# f% i$ s3 e" S
13.     fd = open("/dev/led", O_RDWR);         
    0 s+ l5 P2 U3 X$ F1 `- P
14.     if (fd < 0) {               
    . n$ Q( w$ [6 Z0 S8 m" }+ C
15.         printf("No such device!\n");               
    
16.         return -1;        
    3 j3 S3 n* O) Y6 E2 ]
17.     }         
    
18.     while (1) {               
    / |5 Y  G$ C+ c+ R  H# B
19.         ioctl(fd, LED_ON);               
    
20.         sleep(1);               
    
21.         ioctl(fd, LED_OFF);               
    ! p6 N. f  a0 I% o
22.         sleep(1);        
    + {- m3 j3 N. w8 h" t+ K1 R3 ^6 g
23.         }         
    
24. 
    * ~' J) g" `2 `. f
25.     close(fd);         
    ) q, v! _1 O4 K  g9 K
26.     return 0;
    
27. }

复制代码

: E2 V9 B, e; U
) Z/ f( E$ A' U; D8 @
7 K) a% P0 A) ?) ]7 v8 _/ s$ m+ v
; J: G1 O- q6 u6 w8 n