C语言模块化编程(我见过最好的)
C语言中的模块化编程技巧

C语言中的模块化编程技巧在C语言中,模块化编程是一种重要的技巧,能够帮助程序员更好地组织和管理代码,提高代码的可维护性和可扩展性。
下面将介绍一些C语言中的模块化编程技巧,帮助你写出更加优秀的代码。
首先,模块化编程的核心思想是将代码划分为不同的模块或文件,每个模块负责完成特定的功能,从而降低代码的复杂度。
在C语言中,通常使用头文件(.h文件)和源文件(.c文件)来实现模块化编程。
一个常见的模块化编程技巧是使用头文件来声明函数原型和全局变量,在源文件中实现函数功能。
这样可以将函数的接口和实现分离,提高代码的可读性和可维护性。
另外,通过头文件的方式还可以方便地重用代码,减少代码冗余。
另外,C语言中还可以使用静态函数和静态变量来实现模块化编程。
将函数和变量声明为静态的,可以限制其作用域在当前文件内,避免与其他模块的同名函数或变量发生冲突。
这样可以提高代码的可靠性和安全性。
此外,C语言中还可以使用头文件保护宏(#ifndef)来避免头文件重复包含。
头文件保护宏可以确保每个头文件只被包含一次,避免因重复包含导致的编译错误。
这种技巧在大型项目中特别有用,可以有效地管理头文件的依赖关系。
另外,C语言中还可以使用动态链接库(DLL)来实现模块化编程。
将相关的功能封装在一个动态链接库中,可以方便地在不同的程序中重用代码。
动态链接库的使用可以将项目分解为多个独立的模块,减少不同模块之间的耦合度,提高代码的灵活性和扩展性。
总之,模块化编程是C语言中非常重要的技巧,能够帮助程序员更好地管理和组织代码,提高代码的可维护性和可扩展性。
通过合理地划分模块、使用头文件和源文件、采用静态函数和变量、使用头文件保护宏以及动态链接库等技巧,可以写出更加清晰、灵活和可靠的代码。
希望以上介绍的技巧能够帮助你更好地应用模块化编程,在C语言项目中取得更好的效果。
单片机C语言学习之模块化编程完结篇

单片机C语言学习之模块化编程完结篇单片机C语言学习之模块化编程单片机模块化编程是针对编写容量较大的程序的一种编程方法,这种编程会更好的管理自己所建的工程文件。
下面是模块化编程的一般步骤:1.新建工程文件夹(如:C:\模块化编程),具体步骤略。
另外在此文件夹下新建四个文件,分别命名为output、src、inc和listing。
2.新建工程(直接命名为模块化编程并保存在工程文件夹下),具体步骤略。
3.设置TargetOptions对话框在Target窗口下做出如下图1、图2修改与设置。
图1图2之后还将做出如下步骤(图3、图4):图3图44.设置Components对话框将图6的两个红色箭头处改为图7那样(也可根据个人的情况来命名),如果想新建或删除已有的文件,可以点击1,2位置来进行新建或删除。
图5之后弹出图6所示的界面。
图65.新建源文件(.c文件和.h文件)先建main.c文件,直接将其保存在工程文件夹(C:\模块化编程)下;在建其他.c文件(如delay.c、led.c),将它们保存在src文件夹下;最后建.h文件(如delay.h、led.h、common.h),将它们保存在inc文件夹下。
6.添加源文件(.c文件)到工程具体方法如下图:图8图9添加成功后可以看到左栏如下图所示:图10图10那么接下来应该怎样在里面编写源程序就是非常关键的问题了。
.c 文件一般是用来放函数和定义的变量的,如主函数放在main.c中,延时函数放在delay.c中,.h文件是对各个模块的声明,也就是对相应的函数进行封装,在封装的过程中不能包含任何实质性的函数代码。
如用模块化编程来编写一个简单的单向流水灯程序,需要新建main.c、delay.c和led.c三个源文件以及common.h、delay.h和led.h三个.h文件。
具体代码如下://main.c文件#include#include"led.h"//包含该头文件,是因为主函数调用了流水灯函数void main(){led_flash();//调用流水灯函数}//delay.c文件#include"delay.h"void delay(uintz){uint x,y;for(x=z;x>0;x--)for(y=110;y>0;y--);}//led.c文件#include"led.h"uchar temp;//定义一个字符型的变量void led_flash(){temp=0xfe;P1=temp;while(1){temp=_crol_(temp,1);//循环左移delay(1000);//延时约1000msP1=temp;}}//common.h文件#ifndef_COMMON_H_#define_COMMON_H_typedef unsigned int uint;//宏定义typedef unsigned char uchar;//宏定义#endif//delay.h文件#ifndef_DELAY_H_#define_DELAY_H_#include"common.h"//由于delay.c文件中用到了宏定义uint,所以在这里要包含common.hextern void delay(uint z);#endif//led.h文件#ifndef _LED_H_#define _LED_H_#include"delay.h"//包含delay.h是由于led.c文件调用了delay()函数#include//在这里包含51头文件是因为led.c中用到了P1口#include//包含循环移位的头文件extern void led_flash();//在头文件中声明函数需冠以extern关键字#endif通俗的讲,一个模块化程序里面包含硬件驱动模块和软件功能模块。
C语言模块化编程掌握如何将程序分成多个模块进行编写和组织

C语言模块化编程掌握如何将程序分成多个模块进行编写和组织C语言是一种广泛应用于系统软件和应用软件开发的高级编程语言。
它的编程风格和技巧对于初学者来说可能有些困难,但掌握了模块化编程的技巧,可以使代码更加清晰、易读和易于维护。
本文将介绍C语言模块化编程的概念,以及将程序分成多个模块进行编写和组织的方法。
一、模块化编程的概念在C语言中,模块化编程是将一个大型程序分成若干个小模块进行开发和组合的技术。
每个模块负责处理特定的任务或功能,通过定义函数和变量来实现。
模块化编程可以提高代码的可复用性、可维护性和可扩展性,同时也有助于降低开发过程的复杂性。
二、将程序分成多个模块进行编写在进行模块化编程时,需要将程序按照不同的功能分成多个模块,每个模块独立完成特定的任务。
以下是一些分模块的方法和技巧:1. 定义接口:在每个模块中,定义清晰明确的接口,包括函数签名、参数和返回值类型等。
接口定义应该尽量简洁,并且提供足够的功能。
2. 模块间的通信:模块间的通信可以通过函数调用、全局变量或者传递指针等方式进行。
需要注意的是,模块间的耦合度应尽量降低,避免产生过多的依赖。
3. 模块独立性:每个模块应该尽可能独立、可独立编译和测试。
这样可以减少对其他模块的依赖,并提高开发效率。
4. 封装性:模块应该封装内部实现细节,只暴露给其他模块必要的接口。
这样可以隔离模块之间的影响,并隐藏实现细节。
5. 命名规范:为了提高代码的可读性和可维护性,可以采用一定的命名规范,如使用有意义的函数和变量名,避免重复命名等。
三、模块的组织和管理在进行模块化编程时,模块的组织和管理是非常重要的。
以下是一些建议和技巧:1. 模块划分:根据程序的功能和逻辑,将程序分成多个模块,并确定各个模块之间的依赖关系。
2. 模块命名:为每个模块选择一个有意义的名字,可以根据功能、任务或者特定的业务需求来命名。
3. 模块文档:为每个模块编写相关的文档,包括接口说明、函数用途、参数说明和返回值说明等。
第十五章 C语言模块化编程,C语言多文件编译

第十五章C语言模块化编程,C语言多文件编译所谓模块化编程,就是多文件(.c文件)编程,一个 .c 文件和一个 .h 文件可以被称为一个模块。
如果你学习C语言很久了,还只会在一个 .c 文件里写代码,那么本章将会让你突破,带你了解多文件编程,教你学会如果有效的组织各个文件,如果将各个文件联系起来。
15.1 C语言头文件深入理解C语言程序中,源文件通常分为两种:一种用于保存程序的声明(declaration),称为头文件;另一种用于保存程序的实现(implementation),称为定义(definition)文件。
C程序的头文件以“.h”为后缀,C 程序的定义文件以“.c”为后缀。
可以将 .h 文件的内容写在 .c 文件中,也可以将 .c 文件的内容写在 .h 中,但这是很不好的习惯。
许多初学者用了头文件,却不明其理。
在此略作说明。
在以下场景中会使用头文件:∙通过头文件来调用库功能。
在很多场合,源代码不便(或不准)向用户公布,只要向用户提供头文件和二进制的库即可。
用户只需要按照头文件中的接口声明来调用库功能,而不必关心接口怎么实现的。
∙多文件编译。
将稍大的项目分成几个文件实现,通过头文件将其他文件的函数声明引入到当前文件。
∙头文件能加强类型安全检查。
如果某个接口被实现或被使用时,其方式与头文件中的声明不一致,编译器就会指出错误,这一简单的规则能大大减轻程序员调试、改错的负担。
编译时只有函数声明没有函数定义是完全正确的。
函数声明告诉编译器该函数已经存在,但是入口地址还未确定,暂时在此做个标记,链接时编译器会找到函数入口地址,并将标记替换掉。
编译产生的 .obj 文件(Linux下为 .o 文件)已经是二进制文件,与 .exe 的组织形式类似,只是有些函数的入口地址还未找到,程序不能执行。
链接的作用就是找到函数入口地址,将所有的源文件组织成一个可以执行的二进制文件。
关于头文件的内容,初学者还必须注意:∙头文件中可以和C程序一样引用其它头文件,可以写预处理块,但不要写具体的语句。
C语言模块化程序设计

C语言模块化程序设计模块化程序设计是一种将程序分解为独立模块的方法,每个模块具有明确定义和特定功能。
使用模块化程序设计可以提高程序的可维护性、可扩展性和可重用性。
本文将介绍C语言中的模块化程序设计的原则、方法和优势。
首先,要进行模块化程序设计,需要遵循以下原则:1.单一职责原则:每个模块应该只负责一个具体的功能或任务。
这样可以使模块的功能更加明确和独立,并且方便后续的维护和测试。
2.高内聚,低耦合:模块内部的各个部分应该紧密地关联在一起,形成一个功能完整的整体,同时与其他模块的耦合度应该尽量降低,以减少模块间的相互影响和依赖性。
接下来,我们将介绍几种常见的模块化程序设计的方法:1.函数模块化:将功能相似的代码封装在一个函数中,便于重复使用和集中管理。
函数模块化可以提高程序的可读性和可维护性。
2.文件模块化:将具有相关功能的函数、常量和数据结构定义放在同一个文件中,并通过头文件进行声明和引用。
文件模块化可以使代码结构清晰,提高代码的复用性。
3.类模块化:将相关的函数和数据结构封装在一个类中,并通过类的接口来访问和操作。
类模块化可以提供更高级别的封装和抽象,方便程序的组织和管理。
4.动态链接库和静态链接库:将功能模块封装为独立的动态链接库或静态链接库,以供其他程序调用和使用。
链接库模块化可以提高代码的复用性和可移植性。
以上是常见的模块化程序设计方法,可以根据具体的需求和场景选择适合的方法。
无论使用哪种方法,模块化程序设计都可以带来以下几个优势:1.可维护性:模块化的程序结构使程序的各个部分相互独立,修改和维护一个模块时,不会对其他模块造成影响,降低了维护的难度。
2.可重用性:模块化的程序结构使得代码片段可以在多个地方反复使用,提高了代码的复用性,减少了重复编写代码的工作量。
3.可扩展性:由于模块之间的低耦合性,当需要添加新的功能时,可以通过增加新的模块来实现,而不需要修改已有的模块,降低了扩展的成本和风险。
C语言的模块化编程与软件设计

C语言的模块化编程与软件设计引言在软件开发领域,模块化编程是一种重要的编程方法,它将复杂的系统拆分为若干独立的模块,每个模块负责完成特定的功能。
模块化编程有助于提高代码的可维护性、可扩展性和重用性,同时也使得团队合作变得更加高效。
C语言作为一种广泛应用于系统级编程和嵌入式开发的编程语言,模块化编程在C语言中也有着重要的地位。
本文将介绍C语言中的模块化编程方法和与之相关的软件设计原则。
什么是模块化编程?模块化编程是指将一个大型软件系统划分为多个相互独立的模块,每个模块完成特定的功能。
模块之间通过接口进行通信,模块内部实现细节对外部是隐藏的。
模块化编程通过将系统分解为多个小的、独立的部分来简化开发过程,并提高代码的可读性和可维护性。
在C语言中,模块化编程可以通过以下几种方式实现:函数C语言中的函数是一种最基本的模块化编程单元。
每个函数负责完成特定的任务,并通过函数参数和返回值与其他函数进行交互。
通过将功能拆分为多个函数,可以提高代码的可读性和可维护性,并且可以方便地对函数进行单元测试。
头文件和源文件在C语言中,通过将函数的声明放在头文件中,将函数的定义放在源文件中,可以将不同的功能模块分开管理。
头文件包含了函数的接口,源文件包含了函数的具体实现。
这种方式使得代码结构清晰,方便团队协作和代码重用。
模块化开发模块化开发是指将相关的函数和数据结构组合成一个独立的模块,提供给其他模块使用。
每个模块都有自己的头文件和源文件,通过函数的调用和数据的传递进行交互。
模块化开发可以将系统功能划分为若干个独立的模块,每个模块负责完成特定的任务,有利于代码的重用和维护。
面向对象编程思想虽然C语言不是一种面向对象的编程语言,但是可以使用面向对象的思想来进行模块化编程。
通过定义结构体来封装数据和函数,可以实现类似于对象的效果。
这种方式可以将相关的数据和函数组织在一起,提高代码的可读性和可维护性。
模块化编程的优点模块化编程具有以下几个优点:可读性和可维护性将一个大型系统划分为多个独立的模块,每个模块负责完成特定的功能,使得代码结构清晰,易于阅读和理解。
C语言中的模块化编程

C语言中的模块化编程C语言是一种广泛应用于系统编程和嵌入式开发领域的编程语言,其强大的功能和灵活性使其成为开发人员的首选之一。
而在C语言编程中,模块化编程则是一个重要的概念,它能够帮助开发者更好地组织代码、提高代码的可维护性和可重用性。
模块化编程是将一个大型程序拆分为多个相互独立的模块,每个模块负责完成特定的功能或任务。
通过模块化编程,开发者可以更容易地理清代码逻辑关系,降低代码耦合度,提高代码的可读性和可维护性。
在C语言中,实现模块化编程的常用方法包括函数、头文件和静态变量等。
函数是C语言中最基本的模块化单元,通过把相关功能代码封装在函数中,可以实现代码的复用和降低模块间的耦合度。
头文件则用于声明函数原型和全局变量,方便其他模块调用和共享。
静态变量则可以限制变量的作用域,使其只在当前模块内有效,避免与其他模块中的同名变量产生冲突。
另外,C语言还提供了预处理指令和宏定义等功能,可以进一步帮助实现模块化编程。
预处理指令可以用来在编译过程中进行条件编译,根据不同的宏定义编译不同的代码块,实现代码的模块化管理。
而宏定义则可以定义一系列的代码片段,通过调用宏来实现对代码的快速批量修改,提高代码的灵活性和可维护性。
总的来说,模块化编程是C语言中一个重要的编程技巧,它能够帮助开发者更好地管理和组织代码,提高代码的可维护性和可重用性。
通过合理地拆分程序,定义函数和头文件,使用静态变量和宏定义等方法,开发者可以更高效地开发和维护C语言程序。
因此,熟练掌握模块化编程技术对于C语言开发者来说至关重要,可以提高开发效率,降低出错风险,让程序更加易于阅读和维护。
愿每位C语言开发者都能善用模块化编程的技巧,写出高质量的代码,实现更多有意义的项目。
C语言编程如何实现模块化设计

C语言编程如何实现模块化设计在软件开发领域,模块化设计是一种重要的编程思想和方法论。
它将一个大型的软件系统分解为若干个独立的模块,每个模块都有自己的功能和责任,通过模块之间的接口进行交互和通信。
这种模块化设计的好处是可以提高代码的可读性、可维护性和可重用性,同时也有利于团队合作和项目管理。
C语言是一种广泛应用于嵌入式系统和系统级编程的高级编程语言,如何在C语言中实现模块化设计呢?下面将从几个方面进行探讨。
首先,模块化设计的核心思想是将一个大的问题分解为若干个小的问题,并将每个小问题封装到一个独立的模块中。
在C语言中,可以通过函数来实现模块化设计。
每个函数都有自己的输入和输出,通过函数之间的调用和参数传递,可以实现模块之间的交互和通信。
在设计函数时,应该遵循单一职责原则,即每个函数只负责一个具体的功能,这样可以提高函数的可读性和可维护性。
其次,C语言中可以使用头文件来定义模块的接口。
头文件包含了模块的声明和定义,其他模块可以通过包含头文件来使用该模块的功能。
在头文件中,可以定义模块的结构体、函数原型和宏定义等。
通过头文件的使用,可以将模块的实现和使用分离开来,提高了代码的可重用性和可维护性。
另外,C语言中还可以使用静态变量和静态函数来实现模块的封装。
静态变量和静态函数只在当前模块内部可见,其他模块无法直接访问。
这样可以避免不同模块之间的命名冲突和变量污染,提高了代码的安全性和可靠性。
同时,静态变量和静态函数也有利于代码的优化和性能的提升。
此外,C语言中还可以使用宏定义和条件编译来实现模块的定制化和可配置性。
通过宏定义,可以定义一些常量和条件,根据不同的条件编译不同的代码块。
这样可以根据不同的需求和环境来选择不同的功能和实现方式,提高了代码的灵活性和适应性。
最后,C语言中还可以使用库文件和动态链接库来实现模块的封装和复用。
库文件是一组函数和数据的集合,可以被其他程序调用和使用。
通过库文件,可以将一些常用的功能和算法封装起来,供其他模块和项目使用。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{ LED_OFF() ;
} }
void LedStateChange(void)
{
if(g_bSystemTime1Ms)
//系统1MS 时标到
{
g_bSystemTime1Ms = 0 ;
g_u16LedTimeCount++ ;
//LED 计数器加一
if(g_u16LedTimeCount >= 500) //计数达到500,即500MS 到了,改变 LED 的状态。
#include "Timer.h"
static uint16 g_u16LedTimeCount = 0 ; //LED 计数器
static uint8 g_u8LedState = 0 ;
//LED 状态标志, 0表示亮,1表示熄灭
#define LED P0
//定义 LED 接口
#define LED_ON()
下面我们来定义这个头文件,一般来说,头文件的名字应该与源文件的名字保持一致,这样我们便可以清晰的知 道哪个头文件是哪个源文件的描述。
于是便得到了 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 ;
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;
C 语言头文件 *.h 谈及到模块化编程,必然会涉及到多文件编译,也就是工程编译。在这样的一个系统中,往往会有多个
C 文件,而且每个 C 文件的作用不尽相同。在我们的 C 文件中,由于需要对外提供接口,因此必须有一些函数或 者是变量提供给外部其它文件进行调用。 假设我们有一个 LCD.C 文件,其提供最基本的 LCD 的驱动函数
typedef unsigned char uchar;
typedef unsigned char UINT8;
typedef unsigned char uint8;
typedef unsigned char BOOL;
#endif 至此,似乎我们对于源文件和头文件的分工以及模块化编程有那么一点概念了。那么让我们趁热打铁,将上一章
那么你到底是定义了两个 unsigned int 型的指针变量,还是一个指针变量,一个整形变量呢?而你的初衷 又是什么呢,想定义两个 unsigned int 型的指针变量吗?如果是这样,那么估计过不久就会到处抓狂找错误了。
庆幸的是 C 语言已经为我们考虑到了这一点。typedef 正是为此而生。为了给变量起一个别名我们可以用如 下的语句
{
g_u16LedTimeCount = 0 ;
g_u8LedState = ! g_u8LedState ;
单片机 C 语言模块化编程
下面让我们揭开模块化神秘面纱,一窥其真面目。 C 语言源文件 *.c
提到 C 语言源文件,大家都不会陌生。因为我们平常写的程序代码几乎都在这个 XX.C 文件里面。编译 器也是以此文件来进行编译并生成相应的目标文件。作为模块化编程的组成基础,我们所要实现的所有功能的源 代码均在这个文件里。理想的模块化应该可以看成是一个黑盒子。即我们只关心模块提供的功能,而不管模块内 部的实现细节。好比我们买了一部手机,我们只需要会用手机提供的功能即可,不需要知晓它是如何把短信发出 去的,如何响应我们按键的输入,这些过程对我们用户而言,就是是一个黑盒子。 在大规模程序开发中,一个程序由很多个模块组成,很可能,这些模块的编写任务被分配到不同的人。而你在编 写这个模块的时候很可能就需要利用到别人写好的模块的借口,这个时候我们关心的是,它的模块实现了什么样 的接口,我该如何去调用,至于模块内部是如何组织的,对于我而言,无需过多关注。而追求接口的单一性,把 不需要的细节尽可能对外部屏蔽起来,正是我们所需要注意的地方。
extern void Timer0Init(void) ;
extern bit g_bSystemTime1Ms ;
#endif
完成了定时器模块后,我们开始编写 LED 驱动模块。
Led.c 内容如下:
#include <reg52.h>
#include "MacroAndConst.h"
#include "Led.h"
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;
的我们编写的 LED 闪烁函数进行模块划分并重新组织进行编译。 在上一章中我们主要完成的功能是 P0口所驱动的 LED 以1Hz 的频率闪烁。其中用到了定时器,以及 LED 驱动模 块。因而我们可以简单的将整个工程分成三个模块,定时器模块,LED 模块,以及主函数 对应的文件关系如下
main.c
Timer.c --?Timer.h
typedef unsigned long dword;
typedef long
int32;
typedef long
INT32;
typedef signed char int8;
typedef signed char INT8;
typedef unsigned ar
byte;
typedef unsigned char BYTE;
}
由于在 Led.c 文件中需要调用我们的 g_bSystemTime1Ms 变量。同时主函数需要调用 Timer0Init()初始化函数,
所以应该对这个变量和函数在头文件里作外部声明。以方便其它函数调用。
Timer.h 内容如下。
#ifndef _TIMER_H_
#define _TIMER_H_
文件目录下面了。
下面我们开始编写各个模块文件。
首先编写 Timer.c 这个文件主要内容就是定时器初始化,以及定时器中断服务函数。其内容如下。
#include <reg52.h>
bit g_bSystemTime1Ms = 0 ;
// 1MS 系统时标
void Timer0Init(void)
{
TMOD &= 0xf0 ;
TMOD |= 0x01 ;
//定时器0工作方式1
TH0 = 0xfc ;
//定时器初始值
TL0 = 0x66 ;
TR0 = 1 ;
ET0 = 1 ;
}
void Time0Isr(void) interrupt 1
{
TH0 = 0xfc ;
//定时器重新赋初值
TL0 = 0x66 ;
g_bSystemTime1Ms = 1 ; //1MS 时标标志位置位
LcdPutChar(char cNewValue) ; //在当前位置输出一个字符 而在我们的另外一个文件中需要调用此函数,那么我们该如何做呢?
头文件的作用正是在此。可以称其为一份接口描述文件。其文件内部不应该包含任何实质性的函数代码。我 们可以把这个头文件理解成为一份说明书,说明的内容就是我们的模块对外提供的接口函数或者是接口变量。同 时该文件也包含了一些很重要的宏定义以及一些结构体的信息,离开了这些信息,很可能就无法正常使用接口函 数或者是接口变量。但是总的原则是:不该让外界知道的信息就不应该出现在头文件里,而外界调用模块内接口 函数或者是接口变量所必须的信息就一定要出现在头文件里,否则,外界就无法正确的调用我们提供的接口功能。 因而为了让外部函数或者文件调用我们提供的接口功能,就必须包含我们提供的这个接口描述文件----即头文件。 同时,我们自身模块也需要包含这份模块头文件(因为其包含了模块源文件中所需要的宏定义或者是结构体),好 比我们平常所用的文件都是一式三份一样,模块本身也需要包含这个头文件。