从GPIO实现控制LED发光二极管开始说起之一

最新推荐文章于 2024-03-15 19:42:24 发布

和风化雨

最新推荐文章于 2024-03-15 19:42:24 发布

阅读量3.6k

点赞数 1

分类专栏：嵌入式系统文章标签：单片机物联网 stm32 1024程序员节

本文链接：https://blog.csdn.net/wxg_wuchujie88/article/details/111247025

版权

嵌入式系统专栏收录该内容

29 篇文章 25 订阅

订阅专栏

一般说来，GPIO是所有MCU必备的，最常见，也是最容易使用的设备。虽然简单，但学好了也不容易，实际上能够将GPIO功能实现好，MCU的基础学习也可以说是完成大半了。下面的系列我们假设认为所有的读者都会C语言。

1.单LED闪烁

从简单控制一个LED闪烁开始，电路如下：

要想让LED闪烁，只要让P0.7管脚周期性地产生交替的高低电平即可实现，程序代码如下：

/*
实例1.0
filename:main.c
描述功能：控制连接到MCU管脚上的发光二极管闪烁
接线：at89C51的P0.7管脚连接到发光二极管的阴极，
     即当P0.7管脚为低电平时发光二极管发光，高电平时发光二极管熄灭
*/
#include"reg51.h"
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   
   //工作循环
   while(1){
     //LED亮
      P0_7=0;//给LED管脚低电平，LED亮 *注意1
      delay(5000);//亮一段时间
     //LED熄灭
      P0_7=1;//给LED管脚高电平，LED熄灭*注意1
      delay(5000);//亮一段时间
   }
}

除了18行、21行外，其余的代码非常简单，18行表示P1.7管脚输出低电平，21行表示P0.7管脚输出高电平，其余的管脚可以类推。

这一段代码上大部分人刚开始学习MCU时写的代码，但是这部分代码将应用与具体的元件太纠缠了（注意1），如果硬件进行了修改，这段代码就要修改2处（18行、21行），最好进行分离，分离的办法是利用宏，或直接是C51中的位变量，如下：

/*
实例1.1
filename:main.c
描述功能：控制连接到MCU管脚上的发光二极管闪烁
接线：at89C51的P1.7管脚连接到发光二极管的阴极，
     即当P0.7管脚为低电平时发光二极管发光，高电平时发光二极管熄灭
*/
#include"reg51.h"
//定义位变量如下
sbit LED=P0^7;
//也可以用宏的形式---->#define LED P0_7
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   //工作循环
   while(1){
     //LED亮
      LED=0;//给LED管脚低电平，LED亮
      delay(5000);//亮一段时间
     //LED熄灭
      LED=1;//给LED管脚高电平，LED熄灭
      delay(5000);//亮一段时间
   }
}

上述代码中定义了一个位变量LED，初步实现了应用与代码的分离，且意义更明确，如果硬件进行了修改，此处代码只要修改第10行即可。

进一步封装：

描述功能：控制连接到MCU管脚上的发光二极管闪烁
接线：at89C51的P1.7管脚连接到发光二极管的阴极，
     即当P0.7管脚为低电平时发光二极管发光，高电平时发光二极管熄灭
*/
#include"reg51.h"
sbit LED=P0^7;
void LED_ON(){
  LED=0;
}
void LED_OFF(){
  LED=1;
}
void Init(){

}

#include"LED.h"
void delay(unsigned int t){
   while(t--);
}

void main(){
   //初始化
   Init();
   //工作循环
   while(1){
     //LED亮
     LED_ON();
      delay(5000);//亮一段时间
     //LED熄灭
     LED_OFF();
     delay(5000);//亮一段时间
   }
}

2.多LED闪烁

如果要控制多个发光二极管闪烁,可以在上述的系统上进行修改：电路设计是复制、粘贴，代码也是复制粘贴，只是要稍微改变数据，外加电路采用了排阻：

/*
实例1.2
*/
#include"reg51.h"
sbit LED0=P0^0;
.... 
sbit LEDn=P0^7;
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   
   //工作循环
   while(1){

     //LED0亮
      LED0=0;//给LED管脚低电平，LED亮
      delay(5000);//亮一段时间
     //LED0熄灭
      LED0=1;//给LED管脚高电平，LED熄灭
      delay(5000);//亮一段时间
     ....
     //LED8亮
      LED7=0;//给LED管脚低电平，LED亮
      delay(5000);//亮一段时间
     //LED7熄灭
      LED7=1;//给LED管脚高电平，LED熄灭
      delay(5000);//亮一段时间
   }
}

但是上述的重复的代码太多，动作相同，考虑用循环（循环结构出现的原因），且查询资料可以知道实际上是可以同时控制几个管脚的电平，即一次性设置端口值的：

/*
实例2
*/
#include"reg51.h"
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   int i=0;//循环变量
   //工作循环
   while(1){
     for(i=0;i<8;i++){ //N代表了LED的个数
       //LED亮
       P0=~(1<<i);//给LED管脚i低电平，LEDi亮，其余灭。这里用到了C语言中的位操作
       delay(5000);//亮一段时间
       //LED0熄灭
       P0=0xFF;//给所有LED管脚高电平，LED熄灭
       delay(5000);//亮一段时间     
     }
   }
}

上述15、18行实现了多个LED的同时控制，其他的也可以类推。与实例1.1类似，借助宏实现了应用与代码的分离：

/*
实例3
*/
#include"reg51.h"
#define LEDs P0  

void delay(unsigned int t){
   while(t--);
}
//定义了一个宏，有利于改变接口，控制与电路分离
  
void main(){
   //初始化
   int i=0;//循环变量
   //工作循环
   while(1){
     for(i=0;i<N;i++){ //N代表了LED的个数
       //LED亮
       LEDs=~(1<<i);//给LED管脚低电平，LED亮，这里用到了C语言中的位操作
       delay(5000);//亮一段时间
       //LED0熄灭
       LEDs=0xFF;//给LED管脚高电平，LED熄灭
       delay(5000);//亮一段时间     
     }
   }
}

我们发现上述的代码第15行中，只是给LEDs不同的值就可以改变管脚的电平了，进而熄灭或点亮LED，我们可以将这些数据（LED的花型）分离出来，放到一个数组中，代码可以进一步优化：

/*
实例4
*/
#include"reg51.h"
//定义了一个宏，有利于改变接口，控制与电路分离
#define LEDs P0   
void delay(unsigned int t){
   while(t--);
}
//流水灯的花型数据
unsigned char code table[]={0x01,0x02,....}; 
void main(){
   //初始化
   int i=0;//循环变量

   //工作循环
   while(1){
     for(i=0;i<100;i++){
       //LED亮
       LEDs=table[i];//给LED管脚低电平，LED亮，这里用到了C语言中的位操作
       delay(5000);//亮一段时间
       //LED0熄灭
       LEDs=0xFF;//LED熄灭，实际上这就是消影
       delay(5000);//熄灭一段时间     
     }
   }
}

上述和电路的关系还是比较密切，如果是高电平时LED点亮，低电平熄灭又怎么办？而且花型的数据也可能很多，这怎么办呢？我们将熄灭LED的代码也放到数组中来，并且由系统计算花型数据的个数：

/*
实例5
*/
#include"reg51.h"

//定义了一个宏，有利于改变接口，控制与电路分离
#define LEDs P0  
void delay(unsigned int t){
   while(t--);
}  
//流水灯的花型数据,首元素就是熄灭
unsigned char code table[]={0x01,0x02,....};
void main(){
   //初始化
   int i=0;//循环变量
   //工作循环
   while(1){
     for(i=1;i<sizeof(table)/sizeof(unsined char);i++){
       //LED亮
       LEDs=table[i];//给LED管脚低电平，LED亮，这里用到了C语言中的位操作
       delay(5000);//亮一段时间
       //LED0熄灭
       LEDs=table[0];//LED熄灭，实际上这就是消影
       delay(5000);//熄灭一段时间     
     }
   }

上面的代码还可以再次优化，它如果换了一种芯片呢，怎么办？而且有很多MCU也不是8位的，可能是16位的，况且现在很多的MCU其GPIO管脚电平的高低采用不同的寄存器（一般涉及管脚功能选择，输入输出方向选择和置位及清零等），这时我们可以采用的策略是将应用与驱动相分离：

/*
实例6
*/
#include"reg51.h"

#define LED_ON 1

#if LED_ON  
#define _ON  ~
#else
#define _ON
#endif

//定义了一个宏，有利于改变接口，控制与电路分离
#define LEDs P0 
#define PATTERN_DATA unsigned char code
#define LEDs_ON(pattern) \
        LEDs=_ON(pattern);

#define LEDs_OFF(pattern)\
        LEDs=_ON(0xFF);
#define  LEDs_Init()  
#else
#define PATTERN_DATA unsigned int
#define LEDs  P0
#if LED_ON
#define LEDs_ON(pattern)\
        LEDs->OUTSET|=pattern;
#define LEDs_OFF(pattern) \
        LEDs->OUTCLEAR|=pattern;
#else
#define LEDs_ON(pattern)\
        LEDs->OUTCLEAR|=pattern;
#define LEDs_OFF(pattern) \
        LEDs->OUTSET|=pattern;
#endif
void LEDs_Init(){
...........
}
#endif

void delay(unsigned int t){
   while(--t);
}
void main(){
  
   int i=0;//循环变量
   //流水灯的花型数据,首元素就是熄灭
   PATTERN_DATA table[]={0x00,0x02,....};
   //初始化
   LEDs_Init();
   //工作循环
   while(1){
     for(i=0;i<sizeof(table)/sizeof(PATTERN_DATA);i++){
       //LED亮
       LEDs_ON(table[i]);//
       delay(5000);//亮一段时间
       //LED0熄灭
       LEDs_OFF(table[i]);;//LED熄灭，实际上这就是消影
       delay(5000);//熄灭一段时间     
     }
   }

还有没有优化的余地？还是有的，在此不再进一步展开了。

实例6代码已经很长了，主要是在主函数前要考虑针对各种电路及不同的MCU，我们可以进一步进行分离，将代码分成两部分，分别放到不同的文件中，并且在一个团队中也很少有人经常替换不同的MCU，所以我们以MCS51为例，将代码分散在多个文件中：

/*
filename:config.h
描述：配置文件
*/
#ifndef CONFIG_H
#define CONFIG_H
#include "led.h"
#endif

另外可能涉及到多种数据类型，我们还可以定义一个type.h文件：

/*
type.h
*/
#ifndef TYPE_H
#define TYPE_H
typedef unsigned char uchar;
typedef uchar u8;
typedef unsigned int uint;
typedef uint u16;
//#define PATTERN_DATA unsigned char code
typedef unsigned char code  PATTERN_DATA
#endif

头文件对实现的驱动函数进行声明，该文件也将包含到总配置文件 (config.h)及驱动源文件中：

/*
filename:led.h
描述：led控制头文件
*/
#ifndef LED_H
#define LED_H
#include "type.h"

void leds_On(PATTERN_DATA);
void leds_Off(PATTERN_DATA);
void leds_Init(PATTERN_DATA);

#endif

/*
filename:leds.C
描述：实现LED的控制
*/
#include"reg51.h"
#include"led.h"

//定义了一个宏，有利于改变接口，控制与电路分离
#define LEDs P0 
#define LED_ON 1

#if LED_ON==1  
#define _ON  
#else
#define _ON ~
#endif

void leds_Init(){};
void leds_On(PATTERN_DATA pattern){
     LEDS=_ON(pattern);
}
void leds_Off(PATTERN_DATA pattern){
     LEDS=_ON(pattern);
}

/*
filename：main.c
描述：主文件，主要实现应用功能
*/
#include"config.h"
void delay(u16 t){
   while(t--);
}
void main(){
  
   int i=0;//循环变量
   //流水灯的花型数据,首元素就是熄灭
   PATTERN_DATA table[]={0x00,0x02,....};
   //初始化
   leds_Init();
   //工作循环
   while(1){
     for(i=0;i<sizeof(table)/sizeof(PATTERN_DATA);i++){
       //LED亮
       leds_On(table[i]);//
       delay(5000);//亮一段时间
       //LED0熄灭
       leds_Off(table[i]);;//LED熄灭，实际上这就是消影
       delay(5000);//熄灭一段时间     
     }
   }

通过上述4个文件就实现了系统软件的3层开发模式，将硬件、驱动、应用就行了隔离。

在入门阶段为了尽快熟悉芯片，我们可以采用实例0的方式，而在开发中最好采用上述分层的方式。

3.GPIO控制数码管

当我们将多个LED按照一定的规律排列时，这些LED就可以表达特定的信息，最典型的是将8个LED组装在一起，将它们的阴极或阳极连接在一起做出共阴或共阳的所谓数码管，可以用数码管来表示特定的数字信息等。

3.1单数码管显示

当有1个数码管时，我们可以将数码管的8个段管脚(a,b,c,d,e,f,g,dp)接到一个8位端口，公共端（位管脚）通过一个限流电阻接地(共阴极数码管)或接电源（共阳极数码管）。这是我们可以在上述的config.h中填加一行：

/*
filename:config.h
描述：配置文件
*/
#ifndef CONFIG_H
#define CONFIG_H
#include "type.h"
#include "led.h"
#include "segment.h"
#endif

其中的segment.h为数码管的驱动头文件：

/*
filename:segment.h
*/
#ifndef SEGMENT_H
#define SEGMENT_H
void  Segemt_Init();
void  segment_StillDisplay(u8 pat);
#endif

数码管的驱动文件如下，其实现与上述控制8个LED类型，只是为了显示出不同的数据要有特定的花型数据（这里称为段码）：

/*
filename:segment.c
描述：共阳极数码管接在P2管脚上
*/
#include"reg51.h"
#include"segment.h"
#define SEGMENT P2
extern void delay(u16);
//段码表
static u8 code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e};
void  segemt_Init(){};
void  segment_StillDisplay(u8 pat){
      SEGMENT=table[pat];//显示
      delay(5000);//延时
      SEGMENT=0xFF;//消影
}

如果希望系统交替显示0~9，我们的代码可以为：

/*
filename：main.c
描述：主文件，主要实现应用功能
*/
#include"config.h"
void delay(u16 t){
   while(t--);
}
void main(){
  u16 i=0;//循环变量
  //初始化
   segment_Init();
   //工作循环
   while(1){
     for(i=0;i<9;i++){
       segment_StillDisplay(i);    
     }
}

3.2多数码管显示

通常系统中的数码管是不止1个的，比如说有8个，如果每一个数码管都占用着一个端口的话，显然系统是没有那么多的端口可以空出来使用的，这时候可以考虑采用动态显示的方式，该种方式利用视觉暂留现象，在一个显示周期内只显示一个数码管，所有的数码管共用一个端口作为段输出口，输出段码，另外动态控制每一个数码管的公共端个端口，输出所谓的数码管位码，指定特定位置的数码管显示数字。

头文件中要加入动态显示功能函数的声明：

/*
filename:segment.h
*/
#ifndef SEGMENT_H
#define SEGMENT_H
#include "type.h"
void  segemt_Init();
void  segment_Display(u8 pat);
void  segment_DynamicDisplay();//新加的
#endif

源文件中实现该函数：

/*
filename:segment.c
描述：共阴数码管段接在P2端口上，位选线接在P3端口
*/
#include "reg51.h"
#include"segment.h"
#define SEGMENT P2
#define POS    P3
extern void delay(u16);
//共阴数码管段码表0~F,消影
static u8 code _table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e,0xFF};
//显示位置
static u8 code _pos[]={~(1<<0),~(1<<1),~(1<<2),~(1<<3),~(1<<4),~(1<<5),~(1<<6),~(1<<7)};
//显示初始化
void  segemt_Init(){};
static u8 disp_pos=0;//显示的位置
u8 display_table[]={1,2,3,4,5,6,7,8};//显示的数值，也可以修改，且其他源文件中可以声明这个值以便修改
void  segment_DyamicDisplay(){
      SEGMENT=_table[display_table[disp_pos]];//显示
      POS=_pos[disp_pos];
      delay(50);//延时
      SEGMENT=_table[16];//消影
      disp_pos++;
      if(disp_pos==8)
             disp_pos=0;
 }

主函数中可以直接调用了，不用修改其他代码

/*
filename：main.c
描述：主文件，主要实现应用功能
*/
#include"config.h"
void delay(u16 t){
   while(t--);
}
void main(){
  u16 i=0;//循环变量
  //初始化
   segment_Init();
   //工作循环
   while(1){
       segment_DynamicDisplay(); 
     }
}

以上分析了通过GPIO控制LED,实现LED的闪烁、流水灯及数码管数字显示灯，从学习和教学的角度应采用实例1.0和实例2，从工程实践的角度应采用多文件方式。

4总结

本部分实例主要实现如下几个功能：

1.单个led闪烁

2.8个led闪烁，即流水灯

3.单个数码管的静态交替显示0~F

4.8个数码管的分别动态显示0~7

为便于学习，以最少代码形式展示代码：

1.单个led闪烁

/*
实例1.0
filename:mai.c
描述功能：控制连接到MCU管脚上的发光二极管闪烁
接线：at89C51的P0.7管脚连接到发光二极管的阴极，
     即当P0.7管脚为低电平时发光二极管发光，高电平时发光二极管熄灭
*/
#include"reg51.h"
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   
   //工作循环
   while(1){
     //LED亮
      P0_7=0;//给LED管脚低电平，LED亮 *注意1
      delay(5000);//亮一段时间
     //LED熄灭
      P0_7=1;//给LED管脚高电平，LED熄灭*注意1
      delay(5000);//亮一段时间
   }
}

2.多个led闪烁-，即流水灯

/*
实例7
*/
#include"reg51.h"
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   int i=0;//循环变量
   //流水灯的花型数据
   unsigned char code table[]={0x01,0x02,....};
   //工作循环
   while(1){
     for(i=0;i<;i++){
       //LED亮
       P0=table[i];//给LED管脚低电平，LED亮，这里用到了C语言中的位操作
       delay(5000);//亮一段时间
       //LED0熄灭
       P0=0xFF;//LED熄灭，实际上这就是消影
       delay(5000);//熄灭一段时间     
     }
   }
}

3.单个数码管的静态交替显示0~F实现

/*
实例8
*/
#include"reg51.h"
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   int i=0;//循环变量
  //显示特定数字的字段码，本质上还是流水灯的花型数据
   unsigned char code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e,0xFF};
   //工作循环
   while(1){
     for(i=1;i<17;i++){
       P1=table[i];//输出字段码,端口变了就改端口
       delay(50000);//亮一段时间,时间太长就把数字改小
       P1=table[16];//LED熄灭，实际上这就是消影。数码管如果是共阳的，就将数字改为0x00
       delay(50000);//熄灭一段时间     
     }
   }
}

4.8个数码管的分别动态显示0~7

/*
实例8
*/
#include"reg51.h"
void delay(unsigned int t){
   while(t--);
}
void main(){
   //初始化
   int i=0;//循环变量
   //显示特定数字的字段码，本质上还是流水灯的花型数据
   unsigned char code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e,0xFF};
   unsigned char disp_table[]={0,1,2,3,4,5,6,7};//显示的数值
   //工作循环
   while(1){
     for(i=0;i<8;i++){
       P2=table[disp_table[i]];//输出字段码
       P3=~(1<<i);//输出位码
       delay(50);//亮一段时间
       P2=table[16];//LED熄灭，实际上这就是消影
       delay(50);//熄灭一段时间     
     }
   }
}

上述的4个代码简单、粗暴，能够很明显地看出逻辑及控制关系，易于学习，缺点是无法重用，只可借鉴其实现方法。

将应用、驱动相分离的方法其缺陷是逻辑及控制关系不明显。初期的代码量比较多，随着工作的进展，添加的工作多于修改的工作，总的代码量比较多，实际的平均工作量比较少，换了接线，换了板子只要改了驱动，实现头文件中定义的函数即可。

两种方法，一个适用于教学和学习，一个适应于工程，各有利弊。

和风化雨

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
从GPIO实现控制LED发光二极管开始说起之一

一般说来，GPIO是所有MCU必备的，最常见，也是最容易使用的设备。虽然简单，但学好了也不容易，实际上能够将GPIO功能实现好，MCU的基础学习也可以说是完成大半了。下面的系列我们假设认为所有的读者都会C语言。从简单控制一个LED闪烁开始：/*实例0*/#include"reg51.h"void delay(unsinged int t){ while(--t);}void main(){ //初始化 //工作循环 while(1){ //L.
复制链接

扫一扫