单片机模块化编程串口中断怎么处理

　　本文主要是关于单片机的相关介绍，并着重对单片机模块化编程串口中断的处理进行了详尽的阐述。

　　模块化编程

　　单片机编程时，如果代码量不多，可以将所有的函数和定义等放在一个main.c文件中，但是随着代码量的增加，如果将所有代码都放在同一个.C文件中，会使得程序结构混乱、可读性与可移植性变差，而模块化编程就是解决这个问题的常用而有效的方法。

　　

　　模块化设计的原则

　　“高内聚，低耦合”

　　高内聚：一个C文件里面的函数，只有相互之间的调用，而没有调用其它文件里面的函数，这样可以视为高内聚。尽量减小不同文件里函数的交叉引用。

　　低耦合：一个完整的系统，模块与模块之间，尽可能的使其独立存在。也就是说，让每一个模块，尽可能的独立完成某个特定的子功能。模块与模块之间的接口，尽量的少而简单。

　　模块化编程的方法

　　1.创建一个.c源文件和一个.h头文件

　　原则上文件可以任意命名;但强烈推荐如下原则：.c文件与.h文件同名；文件名要有意义，最好能够体现该文件代码的功能定义。

　　例如：IIC通信源文件与头文件命名为IIC.c与IIC.h。

　　2.防重复包含

　　头文件中需要防重复包含处理，防止头文件在被多个文件引用的时候，让编译器在编译时不会多次编译。

　　在.h文件中加入如下代码

　　#ifndef XXX

　　#define XXX

　　//Your Code

　　#endif

　　其中的XXX原则上可以是任意字符，在同一个工程中各个.h文件的XXX不能相同，因此强烈推荐如下的规则：将.h文件的文件名全部都大写，“。”替换成下划线”_”，首尾各添加2个下划线”__”作为ＸＸＸ。

　　例如IIC.h中的写法：

　　#ifndef __IIC_H__

　　#define __IIC_H__

　　//code

　　#endif

　　3.代码的封装

　　.c文件中通常是：

　　函数的定义\

　　只被本.c文件调用的宏定义

　　.h文件中通常是

　　函数的声明

　　被外部调用的宏定义

　　4.添加到工程中

　　只需要将。文件添加到工程中，.h文件不同添加到工程里，同时在.c文件里把对应的.h文件包含进来。

　　以下是一个IIC.h和IIC.c文件的内容

　　IIC.h的内容

　　复制代码

　　#ifndef __I2C_H__

　　#define __I2C_H__

　　#include 《reg52.h》

　　#define uchar unsigned char

　　sbit SDA=P2^0;

　　sbit SCL=P2^1;

　　void delay（）;

　　void start（）;

　　void stop（）;

　　void ack（）;

　　void nack（）;

　　void write_byte（uchar date）;

　　uchar read_byte（）;

　　void write_at24c02（uchar address ，uchar date）;

　　uchar read_at24c02（uchar address）;

　　#endif

　　复制代码

　　IIC.c的内容

　　#include “i2c.h”

　　void delay（）

　　{

　　;;

　　}

　　/*各个函数的定义*/

　　main.c内容

　　#include 《reg52.h》

　　#include “i2c.h”《br》

　　void main（）

　　{

　　//code

　　}

　　单片机模块化编程

　　在刚开始接触到C语言程序的时候，由于学习内容所限，写的程序都不是很大，一般也就几百行而矣。所以所有的程序都完成在一个源文件里面。记得那时候大一参加学校里的一个电子设计大赛，调试了一个多星期，所有程序加起来大概将近1000行，长长的一个文件，从上浏览下来都要好半天。出了错误简单的语法错误还好定位，其它一些错误，往往找半天才找的到。那个时候开始知道了模块化编程这个东西，也尝试着开始把程序分模块编写。最开始是把相同功能的一些函数（譬如1602液晶的驱动）全部写在一个头文件（.h）文件里面，然后需要调用的地方包含进去，但是很快发现这种方法有其局限性，很容易犯重复包含的错误。

　　而且调用起来也很不方便。很快暑假的电子设计大赛来临了，学校对我们的单片机软件编程进行了一些培训。由于学校历年来参加国赛和省赛，因此积累了一定数量的驱动模块，那些日子，老师每天都会布置一定量的任务，让我们用这些模块组合起来，完成一定功能。而正是那些日子模块化编程的培训，使我对于模块化编程有了更进一步的认识。并且程序规范也开始慢慢注意起来。此后的日子，无论程序的大小，均采用模块化编程的方式去编写。很长一段时间以来，一直有单片机爱好者在QQ上和我一起交流。有时候，他们会发过来一些有问题的程序源文件，让我帮忙修改一下。同样是长长的一个文件，而且命名极不规范，从头看下来，着实是痛苦，说实话，还真不如我重新给他们写一个更快一些，此话到不假，因为手头积累了一定量的模块，在完成一个新的系统时候，只需要根据上层功能需求，在底层模块的支持下，可以很快方便的完成。而不需要从头到尾再一砖一瓦的重新编写。藉此，也可以看出模块化编程的一个好处，就是可重复利用率高。下面让我们揭开模块化神秘面纱，一窥其真面目。

　　C语言源文件 *.c

　　提到C语言源文件，大家都不会陌生。因为我们平常写的程序代码几乎都在这个XX.C文件里面。编译器也是以此文件来进行编译并生成相应的目标文件。作为模块化编程的组成基础，我们所要实现的所有功能的源代码均在这个文件里。理想的模块化应该可以看成是一个黑盒子。即我们只关心模块提供的功能，而不管模块内部的实现细节。好比我们买了一部手机，我们只需要会用手机提供的功能即可，不需要知晓它是如何把短信发出去的，如何响应我们按键的输入，这些过程对我们用户而言，就是是一个黑盒子。

　　在大规模程序开发中，一个程序由很多个模块组成，很可能，这些模块的编写任务被分配到不同的人。而你在编写这个模块的时候很可能就需要利用到别人写好的模块的借口，这个时候我们关心的是，它的模块实现了什么样的接口，我该如何去调用，至于模块内部是如何组织的，对于我而言，无需过多关注。而追求接口的单一性，把不需要的细节尽可能对外部屏蔽起来，正是我们所需要注意的地方。

　　C语言头文件 *.h

　　谈及到模块化编程，必然会涉及到多文件编译，也就是工程编译。在这样的一个系统中，往往会有多个C文件，而且每个C文件的作用不尽相同。在我们的C文件中，由于需要对外提供接口，因此必须有一些函数或者是变量提供给外部其它文件进行调用。

　　假设我们有一个LCD.C文件，其提供最基本的LCD的驱动函数

　　LcdPutChar（char cNewValue） ; //在当前位置输出一个字符

　　而在我们的另外一个文件中需要调用此函数，那么我们该如何做呢？

　　头文件的作用正是在此。可以称其为一份接口描述文件。其文件内部不应该包含任何实质性的函数代码。我们可以把这个头文件理解成为一份说明书，说明的内容就是我们的模块对外提供的接口函数或者是接口变量。同时该文件也包含了一些很重要的宏定义以及一些结构体的信息，离开了这些信息，很可能就无法正常使用接口函数或者是接口变量。但是总的原则是：不该让外界知道的信息就不应该出现在头文件里，而外界调用模块内接口函数或者是接口变量所必须的信息就一定要出现在头文件里，否则，外界就无法正确的调用我们提供的接口功能。因而为了让外部函数或者文件调用我们提供的接口功能，就必须包含我们提供的这个接口描述文件----即头文件。同时，我们自身模块也需要包含这份模块头文件（因为其包含了模块源文件中所需要的宏定义或者是结构体），好比我们平常所用的文件都是一式三份一样，模块本身也需要包含这个头文件。

　　下面我们来定义这个头文件，一般来说，头文件的名字应该与源文件的名字保持一致，这样我们便可以清晰的知道哪个头文件是哪个源文件的描述。

　　于是便得到了LCD.C的头文件LCD.h 其内容如下。

　　#ifndef _LCD_H_

　　#define _LCD_H_

　　extern LcdPutChar（char cNewValue） ;

　　#endif

　　这与我们在源文件中定义函数时有点类似。不同的是，在其前面添加了extern 修饰符表明其是一个外部函数，可以被外部其它模块进行调用。

　　#ifndef _LCD_H_

　　#define _LCD_H_

　　#endif

　　这个几条条件编译和宏定义是为了防止重复包含。假如有两个不同源文件需要调用LcdPutChar（char cNewValue）这个函数，他们分别都通过#include “Lcd.h”把这个头文件包含了进去。在第一个源文件进行编译时候，由于没有定义过 _LCD_H_ 因此 #ifndef _LCD_H_ 条件成立，于是定义_LCD_H_ 并将下面的声明包含进去。在第二个文件编译时候，由于第一个文件包含时候，已经将_LCD_H_定义过了。因此#ifndef _LCD_H_ 不成立，整个头文件内容就没有被包含。假设没有这样的条件编译语句，那么两个文件都包含了extern LcdPutChar（char cNewValue） ; 就会引起重复包含的错误。

　　不得不说的typedef

　　很多朋友似乎了习惯程序中利用如下语句来对数据类型进行定义

　　#define uint unsigned int

　　#define uchar unsigned char

　　然后在定义变量的时候 直接这样使用

　　uint g_nTimeCounter = 0 ;

　　不可否认，这样确实很方便，而且对于移植起来也有一定的方便性。但是考虑下面这种情况你还会 这么认为吗？

　　#define PINT unsigned int * //定义unsigned int 指针类型

　　PINT g_npTimeCounter， g_npTimeState ;

　　那么你到底是定义了两个unsigned int 型的指针变量，还是一个指针变量，一个整形变量呢？而你的初衷又是什么呢，想定义两个unsigned int 型的指针变量吗？如果是这样，那么估计过不久就会到处抓狂找错误了。

　　庆幸的是C语言已经为我们考虑到了这一点。typedef 正是为此而生。为了给变量起一个别名我们可以用如下的语句

　　typedef unsigned int uint16 ; //给指向无符号整形变量起一个别名 uint16

　　typedef unsigned int * puint16 ; //给指向无符号整形变量指针起一个别名 puint16

　　在我们定义变量时候便可以这样定义了：

　　uint16 g_nTimeCounter = 0 ; //定义一个无符号的整形变量

　　puint16 g_npTimeCounter ; //定义一个无符号的整形变量的指针

　　在我们使用51单片机的C语言编程的时候，整形变量的范围是16位，而在基于32的微处理下的整形变量是32位。倘若我们在8位单片机下编写的一些代码想要移植到32位的处理器上，那么很可能我们就需要在源文件中到处修改变量的类型定义。这是一件庞大的工作，为了考虑程序的可移植性，在一开始，我们就应该养成良好的习惯，用变量的别名进行定义。

　　如在8位单片机的平台下，有如下一个变量定义

　　uint16 g_nTimeCounter = 0 ;

　　如果移植32单片机的平台下，想要其的范围依旧为16位。

　　可以直接修改uint16 的定义，即

　　typedef unsigned short int uint16 ;

　　这样就可以了，而不需要到源文件处处寻找并修改。

　　将常用的数据类型全部采用此种方法定义，形成一个头文件，便于我们以后编程直接调用。

　　文件名 MacroAndConst.h

　　其内容如下：

　　#ifndef _MACRO_AND_CONST_H_

　　#define _MACRO_AND_CONST_H_

　　typedef unsigned int uint16;

　　typedef unsigned int UINT;

　　typedef unsigned int uint;

　　typedef unsigned int UINT16;

　　typedef unsigned int WORD;

　　typedef unsigned int word;

　　typedef int int16;

　　typedef int INT16;

　　typedef unsigned long uint32;

　　typedef unsigned long UINT32;

　　typedef unsigned long DWORD;

　　typedef unsigned long dword;

　　typedef long int32;

　　typedef long INT32;

　　typedef signed char int8;

　　typedef signed char INT8;

　　typedef unsigned char byte;

　　typedef unsigned char BYTE;

　　typedef unsigned char uchar;

　　typedef unsigned char UINT8;

　　typedef unsigned char uint8;

　　typedef unsigned char BOOL;

　　#endif

　　至此，似乎我们对于源文件和头文件的分工以及模块化编程有那么一点概念了。那么让我们趁热打铁，将上一章的我们编写的LED闪烁函数进行模块划分并重新组织进行编译。

　　在上一章中我们主要完成的功能是P0口所驱动的LED以1Hz的频率闪烁。其中用到了定时器，以及LED驱动模块。因而我们可以简单的将整个工程分成三个模块，定时器模块，LED模块，以及主函数

　　对应的文件关系如下

　　main.c

　　Timer.c --？Timer.h

　　Led.c --？Led.h

　　单片机模块化编程串口中断怎么处理

　　只要进行如下程序即可。

　　#include《reg51.h》

　　#define u16 unsigned int

　　#define u8 unsigned char

　　code u16 sj_tab［］={800，400，200，100};//每个档位对应的时间

　　u8 setsj=0;//档位

　　u16 jsflag;

　　#define LED P2

　　code u8 led_tab［］={0xfe，0xfd，0xfb，0xf7，0xef，0xdf，0xbf，0x7f，};//LED亮的方式

　　u8 ledflag=0;

　　/****************************************/

　　void init（） //初始化函数

　　{ TMOD=0x01;

　　TH0=（65536-1000）/256;

　　TL0=（65536-1000）%256;

　　EA=1;

　　ET0=1;

　　}

　　/*********按键扫描******/

　　sbit k=P3^2;

　　u8 key（）{

　　static u8 ms;

　　if（k==0）{//检测到0

　　if（ms《10）ms++;

　　if（ms==5）return 0;//连续5次扫描都为0，

　　}

　　else ms=0;

　　return 1;

　　}

　　/***********************************/

　　u8 count=0; //计数

　　void main（）//主函数

　　{

　　init（）;//系统初始化

　　jsflag=sj_tab［setsj］;//初始加载时间

　　TR0=1; //定时器开始计时

　　while（1）{

　　if（key（）==0）{ //按键按下

　　if（++setsj》=4）setsj=0;//档位+1，加到最大后归0

　　}

　　LED=led_tab［ledflag］;

　　}

　　}

　　/****************************/

　　void timer0（） interrupt 1//1ms定时器

　　{

　　TH0=（65536-1000）/256;//重载初值

　　TL0=（65536-1000）%256;

　　if（jsflag》0）jsflag--;//1ms减1

　　if（jsflag==0）{//减到0

　　jsflag=sj_tab［setsj］;//重载时间

　　if（++ledflag》=8）ledflag=0;

　　}

　　}

　　结语

　　关于单片机模块化编程的相关介绍就到这了，如有不足之处欢迎指正。

相关阅读推荐：8051模块化编程分析

相关阅读推荐：如何对一个大的项目进行模块化编程