单片机交通信号灯控制系统设计文档 PPT 仿真 源码 PCB

这个设计很全ppt 还有源程序和仿真都有
下载地址：
基于单片机的智能交通灯系统的设计.zip (1.74 MB, 下载次数: 135)

2016-12-5 02:06 上传

点击文件名下载附件

下面是文档的部分内容预览：

ppt内容预览：

2  设计要求和设计方案

2.1 设计要求

2.1.1项目概述

道路交通信号灯是道路交通安全的产品，它可以加强道路交通管理，减少交通事故的发生，提高道路使用效率，改善交通状况的一种重要工具。它适用于各种十字、丁字等交叉路口，由道路交通信号灯控制，指导车辆和行人安全而有序地通行。

2.1.2 设计任务

设计一种交通信号灯的控制系统。要求直观，简单。能够满足十字路口交通等的使用需求。

2.1.3 设计要求

1. 交通路口为十字路口。

2．马路为双向六车道，即要有左转灯，直行灯，右转灯。

3．要考虑人行横道的信号灯。

4．有显示设备可以显示通信时间。

5．要求通行时间可调。

2.2 设计方案

2.2.1 供电方案

    系统要在正常而稳定的状态下工作，必须要有可靠的电源。而本次基于单片机的设计需要显示的芯片较多，电源供应量大，因此本次设计了如下三种方案。

方案一：利用独立的稳压电源供电。优点是可提供稳定而可靠电源，而且可以利用220V电压转化，不受各种因素的限制；缺点是各模块都采用独立电源，会增加本次设计的难度，而且对其他电路还会造成一定的干扰。

方案二：采用USB转接口5V电压供电，这样简单明了，但是单单一个5V电源供电可能会显得电源不足，而无法满足实际的需要。

方案三：采用USB转接口5V双电源电压供电，这样把本次设计分为两大模块，一是交通信号灯控制系统，二是万年历系统，采用双电源供电，一个为交通信号灯控制系统提供电源，另一个为万年历系统提供电源。这样即简单而又可提供稳定的电源。

考虑到实际情况和电路的简洁，本设计采用了第三套方案，此方案在电路的设计上可以把系统分为两大模块，使系统设计简单化，从而又可以提供稳定而可靠电源。而且在单电源断电的情况下不影响另一模块的工作。

2.2.2 输入方案

    该系统要求能手动及智能控制改变交通信号灯的通行时间和万年历时间的调整。

方案一：采用8155扩展I/O 口及键盘、显示等。该方案的优点是：使用灵活可编程，并且有RAM,及计数器。若用该方案，可提供较多I/O 口,但操作起来稍显复杂。

方案二： 直接在I/O口线上接上按键开关。该方案优点是：编程更加简洁，使用更加简单，且成本更低。缺点就是功能有限。

综合考虑本设计的实际需要，在使用输入的时候不需要过于复杂的功能，因此直接在I/O口线上接上按键开关足以满足本次系统设计的需要，故采用方案二。

2.2.3 显示界面方案

本设计涉及到倒计时、状态灯、时间、温度等显示功能。基于功能需求，本设计考虑如下四种方案：

方案一：完全采用数码管显示。这种方案只显示有限的符号和数码字符，无法胜任功能需求。

方案二：完全采用点阵式LED 显示。这种方案实现复杂，且须完成大量的软件工作；但功能强大，可方便的显示各种英文字符，汉字，图形等。

方案三：采用LCD1602液晶显示，这种显示比较乐观，但是工作量大，而且设计复杂，再加上需要到的LCD1602较多，从经济上也不划算。

方案四：采用数码管、LED与LCD1602相结合的方法因为设计既要求倒计时数字输出，又要求有状态灯输出，同时还要显示出年、月、日、时、分、秒、星期和温度。为了方便观看并考虑到实际情况，用数码管显示交通信号灯的倒计时，用LED显示交通灯的状态灯、用LCD1602显示年、月、日、时、分、秒、星期和温度。这种设计方案既满足系统功能要求，又减少了系统实现的复杂度。

2.2.4交通灯方案

2.2.4.1交通灯规则方案

本设计的交通灯以十字路口为模型，在实现基本的功能前提下增加了时间及温度的液晶显示。从而还增加了路口高峰期的智能化人工管理机制。

    实际生活中交通信号灯的规则千变万化，在不同的路口上看到的交通信号灯的规则不一样，但是总体还是相差不大，也有一些根据实际的需要而设置不同的交通规则，本次系统交通规则的设置是根据现实生活中的交通规则和多加考虑各种现实因素结合起来而制定了以下交通规则。

下图所示为一种红绿灯规则的状态图：

                 

      

共四种状态，分别设定为S1、S2、S3、S4，交通灯以这四种状态为一个周期，循环执行如下图所示：

依据上述车辆行驶的状态图，可以列出正常模式下各个路口交通信号灯的逻辑表如下表所示(其中逻辑值“1”表示直行通行，逻辑值“0”表示禁止通行，逻辑值“L”表示左转通行)：

表2.1 正常模式下工作表

S1的状态	E	S	W	N
逻辑值	0	1	0	1
显示时间	正常模式下为40S

S2的状态	E	S	W	N
逻辑值	0	L	0	L
显示时间	正常模式下为20S

S3的状态	E	S	W	N
逻辑值	1	0	1	0
显示时间	正常模式下为40S

S4的状态	E	S	W	N
逻辑值	L	0	L	0
显示时间	正常模式下为20S

程序就是在上述四种状态下循环转化的，而每种状态下又包括绿灯通行和黄灯闪烁警告状态。系统在正常模式下循环一个周期所需要的时间为120S,数码管显示的工作模式为半周期60.

2.2.4.2各种模式下通行时间

   本系统结合实际的需要，而在上述四种状态的每种状态下再细分为绿灯通行、黄灯闪烁两种状态，总共八种工作状态。系统在正常工作模式下又可分为三种工作模式，分别为：正常模式、繁忙模式和特殊模式。各种模式下的时间分配如下表2.2：

表2.2 各模式下时间分配表

	S1	S2	S3	S4	S5	S6	S7	S8	周期
正常模式	35S	5S	15S	5S	35S	5S	15S	5S	120S
繁忙模式	25S	5S	10S	5S	25S	5S	10S	5S	90S
特殊模式	50S	5S	15S	5S	50S	5S	15S	5S	150S

2.2.5 万年历设计方案

电路设计框图

本系统的电路系统框图如图2.6所示。AT89C51单片机对DS1302和DS18B20写入控制字并读取相应的数据，继而控制LCD1602作出对应的显示，同时也向交通信号灯外部发出定时中断，从而改变交通信号灯的工作模式。

3  芯片的介绍及应用

3.1 AT89C51单片机介绍及应用

单片微型计算机简称单片机，同时又称为微控制器、嵌入式微控制器等，它属于第四代电子计算机。它把各种芯片电路集成在一块芯片上，因此它具有体积小、抗干扰能力强、功耗低、可靠性高以及低廉的价格。它广泛应用于工业过程控制、测控系统及各种智能仪器仪表等。因此国际上逐渐采用微控制器(MCU)代替单片微型计算机(SCM)这一名称。微控制器可以更准确的反应出单片机的本质，但单片机这一名称以为大多数人所接受，所以单片微型计算机即是单片机，同时又称为微控制器。

3.1.1单片机的引脚及功能

AT89C51单片机的 引脚图如图3.1 所示

图3.1 AT89C51单片机引脚图

VCC：电源电压

GND：地

P0口：P0口是一个漏极开路型8位双向I／0口，即数据／地址总线的复用口。当它作为输出端口使用时，每位能驱动8个TTL逻辑门电路。

P1口：Pl 口是一个带内部上拉电阻的8位双向I／O口，Pl口的输出缓冲级能驱动4个TTL逻辑门电路。当我们对端口写入“1”时，通过内部上拉电阻来把端口拉到高电平，此时P1口可做为输入端口。当P1口做为输入口时，由于内部存在上拉电阻，当被外部引脚拉低时会输出数据。P1口除了以上功能外，最重要的是它的第二功能如表3.1所示。

表3.1 P1口引脚的第二功能

端口引脚	第二功能：
P1.5	MOSI（用于ISP编程）
P1.6	MOSI（用于ISP编程）
P1.7	MOSI（用于ISP编程）

P2口：P2口也是一个带有内部上拉电阻的8 位双向I／O 口。P2 的输出缓冲级也能驱动4 个TTL逻辑门电路。当我们对端口写入“1”时，通过内部上拉电阻来把端口拉到高电平，此时P2口可做为输入端口。当P2口做为输入口时，由于内部存在上拉电阻，当被外部引脚拉低时会输出数据。当访问外部程序存储器或16位地址外部数据的存储器时，P2口输出高8位数据地址。当访问8 位外部数据存储器地址时，P2口的内容在整个访问过程将不会改变。

P3 口：P3 口也是一个带有内部上拉电阻的8 位双向I／0 口。P3 口输出缓冲级也能驱动4 个TTL逻辑门电路。当我们对端口写入“1”时，通过内部上拉电阻来把端口拉到高电平，此时P3口可做为输入端口。当P3口做为输入口时，由于内部存在上拉电阻，当被外部引脚拉低时会输出数据。P3口除了以上用途外，最重要的是它的第二功能如表3.2所示。

表3.2 P3口引脚的第二功能

端口引脚	第二功能：
P3.0	RXD（串行输入）
P3.1	TXD（串行输出）
P3.2	/INT0（外中断0）
P3.3	/ INT1（外中断1）
P3.4	T0（定时／计数器0外部输入）
P3.5	T1（定时／计数器1外部输入）
P3.6	/ WR（外部数据存储器写选通）
P3.7	/ RD(外部数据存储器读选通）

P3口还可用于接收一些Flash闪速存储器的编程及程序的校验控制等。

RST：复位输入引脚。振荡器在工作时，RST引脚将会出现两个或两个以上的机器周期高电平来使单片机进行复位。WDT 溢出将使该引脚输出高电平，设置SFR AUXR的DISRT0 位（地址8EH）可打开或关闭该功能。DISRT0位缺省为RESET输出高电平打开状态。

ALE／：在访问外部数据存储器或程序存储器时，ALE（地址锁存）主要是利用输出脉冲来锁存地址低8位字节。ALE还可以用于对外输出时钟信号或定时功能，因为ALE时刻以时钟振荡器的1/6频率输出固定的脉冲信号。

值得注意的是：当我们在访问外部数据存储器时将会跳过一个ALE脉冲。在F1ash存储器编程期间，该引脚还可用于输入编程脉冲。还可以通过特殊的功能寄存器中的8EH单元的D0位置来禁止ALE工作。执行该操作后，需要通过MOVX和MOVC指令ALE才能被激活，从而恢复工作状态。在执行单片机外部程序时，ALE应设置为无效。

程序的储存是在（）允许输出外部程序存储器时进行，当单片机需要进行读写数据时，此时该引脚在每个周期下就会两次有效，从而发出两次脉冲，当访问外部的数据存储器时，则是发出一次脉冲信号。

／VPP：外部访问允许。当EA端设置为低电平时，CPU可单独访问外部程序存储器（即：0000H－FFFFH地址）。

XTAL1：振荡器的反相放大器和内部时钟发生器的输入端。

3.1.2单片机最小系统的设置

本次基于单片机交通信号灯控制系统的设计的单片机最小系统设置的如下图所示:

图3.2 AT89C51单片机最小系统图

3.2 LCD1602芯片介绍及应用

3.2.1 液晶显示器的介绍           

液晶显示器有多种分类方法，通常按显示的方式分可分为字符式、段式、点阵式等。液晶显示器即可显示黑白又可显示多彩色灰度，因此可分为黑白显示器和彩色显示器。如果按驱动方式分，它又可以分为单纯矩阵驱动（Simple Matrix）、静态驱动（Static）和主动矩阵驱动（Active Matrix）三种。液晶显示器它具有厚度薄、体积小，适用于大规模集成电路的驱动等特点，目前已广泛应用在数字摄像机、便携式电脑、MP3、MP4、PDA移动通信工具等领域。

3.2.2 液晶显示器各种图形的显示原理                                                            

液晶显示器是利用液晶的物理特性，通过高低电压来控制显示的区域，高电平则亮，低电平则灭，这样就可以显示出图形。液晶显示器图形的显示是通过N*M个液晶显示单元构成，通过控制各个显示单元的亮暗而达到显示图形的目的。例如一个液晶显示器有64行显示屏，而每行有128列，每字节又由8列组成，因此每行可显示16个字节，即整个显示器可显示1024个字节。最后通过控制液晶显示相应位置的亮暗从而显示出每字节上的内容。

3.2.3 LCD1602的基本参数及引脚功能

LCD1602采用标准的14脚（无背光）或16脚（带背光）接口，本次设计采用16脚（带背光）来显示年、月、日、时、分、秒、星期和温度。各引脚接口说明如表3.3所示:

第1脚：VSS为地电源。

第2脚：VDD接5V正电源。

第3脚：VL是显示器对比度调整端，当接地信号时液晶对比度最高，当接正电源时对比度最弱，对比度的高低将会影响液晶显示器的显示，对比度过高时会产生“鬼影”。因此我们通常接一个10K的电位器来调节。

第4脚：RS是寄存器的选择，高电平表示数据寄存器、低电平表示指令寄存器。

第5脚：R/W是信号线的读写，当高电平时表示正在进行读操作，当低电平时表示正在进行写操作，如果RS和R/W同时为低电平时可进行显示地址或写入指令，如果RS为低电平且R/W为高电平时可进行读取信号，如果RS为高电平R/W为低电平时可进行写入数据。

第6脚：E端是使能信号端，当E端由高电平变化为低电平时，液晶模块命令开始执行。

第7～14脚：D0～D7是8位双向数据线。

第15脚：背光源正极。

第16脚：背光源负极。

表3.3引脚接口说明表

编号	符号	引脚说明	编号	符号	引脚说明
1	VSS	电源地	9	D2	数据
2	VDD	电源正极	10	D3	数据
3	VL	液晶显示偏压	11	D4	数据
4	RS	数据/命令选择	12	D5	数据
5	R/W	读/写选择	13	D6	数据
6	E	使能信号	14	D7	数据
7	D0	数据	15	BLA	背光源正极
8	D1	数据	16	BLK	背光源负极

3.2.4 LCD1602的指令说明及时序

LCD1602内部液晶显示模块控制器指令共11条，如表3.4所示：

LCD1602的读写操作、光标操作以及屏幕显示等都是通过各种指令程序而实现的，具体说明如下：（注：1为高电平，0为低电平）

指令1：清显示，指令码由01H复位到00H位置。

指令2：光标复位，执行时光标将返回到00H位置。

指令3：光标以及显示模式的设置。光标的移动方向为：高电平表示右移，低电平则表示左移。S:屏幕文字是否进行右移或者进行左移。高电平表示有效，低电平表示无效。

指令4：显示控制开关。B：光标闪烁的控制，高电平表示闪烁，低电平则表示不闪烁。

C：光标开关的控制，高电平表示有光标，低电平则表示无光标 。D：整体显示的开关控制，高电平表示打开显示，低电平则表示关闭显示。

指令5：光标或者显示移位 S/C的控制。高电平表示文字移动的显示，低电平表示光标的移动。

指令6：功能命令的设置。DL为高电平表示4位总线，低电平则表示8位总线。F: 低电平表示显示5x7的点阵字符，高电平表示显示5x10的点阵字符。 N：低电平表示单行显示，高电平表示双行显示

指令7：字符发生器RAM地址设置。

指令8：DDRAM地址的设置。

指令9：光标地址和读忙信号。 BF：表示忙标志位，高电平时表示忙，此时模块不能进行命令或者数据的接受，低电平则表示不忙。

指令10：写数据。

指令11：读数据

表3.4 控制命令表

序号	指令	RS	R/W	D7	D6	D5	D4	D3	D2	D1	D0
1	清显示	0	0	0	0	0	0	0	0	0	1
2	光标返回	0	0	0	0	0	0	0	0	1	*
3	置输入模式	0	0	0	0	0	0	0	1	I/D	S
4	显示开/关控制	0	0	0	0	0	0	1	D	C	B
5	光标或字符移位	0	0	0	0	0	1	S/C	R/L	*	*
6	置功能	0	0	0	0	1	DL	N	F	*	*
7	置字符发生存贮器地址	0	0	0	1	字符发生存贮器地址
8	置数据存贮器地址	0	0	1	显示数据存贮器地址
9	读忙标志或地址	0	1	BF	计数器地址
10	写数据到CGRAM或DDRAM）	1	0	写入的数据内容
11	从CGRAM或DDRAM读数	1	1	读出的数据内容

LCD1602液晶显示器有多种，其中市场上最常见的是HD44780。HD44780内置了DDRA（80字节），CGRAM（64字节，用来存放用户自定义字符，每个字符需要用到8个字节，所以以一共可以存放8个用户自定义字符），CGROM（内存了160个字符，包括了标准的ASCII码表上的字符等）。与HD44780相兼容的芯片时序表如表3.5所示：

表3.5 基本操作时序表

读状态	输入	RS=L，R/W=H，E=H	输出	D0—D7=状态字
写指令	输入	RS=L，R/W=L，D0—D7=指令码，E=高脉冲	输出	无
读数据	输入	RS=H，R/W=H，E=H	输出	D0—D7=数据
写数据	输入	RS=H，R/W=L，D0—D7=数据，E=高脉冲	输出	无

读写操作时序如图3.3和3.4所示。

图3.3 读操作时序

图3.4写操作时序   

      LCD1602液晶显示是一个慢显示器件，所以每次在执行指令时一定要先进行确认模块的忙标志位是否为低电平，否而指令将会失效。要进行字符的显示，首先要进行输入显示字符的地址，实际就是输入显示的内容。LCD1602内部显示地址如图3.5所示。                                                      

对液晶模块的初始化中要先设置其显示模式，在液晶模块显示字符时光标将会自动右移。液晶模块在繁忙状态下将不能输入指令。

3.2.5 LCD1602液晶显示模块原理图

LCD1602显示模块电路，首先VSS接地信号，VDD接5V高电平，VEE接10K的变阻器，变阻器两端分别接5V电压和大地。接着RS、RW和E是数据信号线分别接单片机的P2.5、P2.6和P2.7引脚。最后D0到D7接单片机的P0.0到P0.7引脚，要接排阻。而实际的LCD1602还有两个背光调节引脚，分别是BLA和BLK接5V电压和大地。

图3.6 LCD1602显示电路

3.3 DS1302芯片介绍及应用

DS1302是美国 DALLAS 公司推出的一种高性能、低功耗的时钟芯片，它采用 SPI 三线接口与 CPU 进行同步通信，并可采用突发方式一次传送一个或多个字节的时钟信号和 RAM数据。它可提供年、月、日、星期、时、分、秒的计时显示，各月天数它可进行自动的调整，同时还具有闰年的补偿功能。工作电压范围为2.5～5.5V。DS1302芯片采用双电源供电，即有主电源和备用电源。同时还可设置备用电源的充电方式，提供了对备用电源进行电流充电的能力。DS1302也可用于数据的记录， 特别是对于某些特殊意义的数据点的记录上，它能实现数据和数据出现的时间同时记录，因此在各种测量系统中得到广泛的应用。

3.3.1 DS1302引脚功能

DS1302芯片的外部引脚分配如图3.7所示。

图3.7 DS1302的外部引脚分配

Vcc1：表示主电源；Vcc2：表示备份电源。如果 Vcc2>Vcc1+0.2V， 则 Vcc2向 DS1302供电，如果 Vcc2< Vcc1，由则Vcc1向 DS1302供电。

SCLK：串行时钟，输入，控制数据的输入与输出。

I/O：三线接口时的双向数据线。

CE：输入信号。DS1302在进行读写数据时，此位必须为高。该引脚有两个功能：首先是CE 开始控制字进行访问移位寄存器的逻辑控制；其次是CE 提供结束单字节或者多字节数据的传输方法。

3.3.2 DS1302读写说明

DS1302是 SPI 总线方式来驱动。它不仅需要向寄存器写入控制字， 同时还需要读取相应寄存器的数据。

1：DS1302的读写寄存器

DS1302的时间寄存器总共有12个，其中读寄存器（81H-8DH）和写寄存器（81H-8DH）是以BCD码格式进行数据的存取。

表3.6 DS1302的读写寄存器

写寄存器	读寄存器	Bit7	Bit6	Bit5	Bit4	Bit3	Bit2	Bit1	Bit0
80H	81H	CH	10秒			秒
82H	83H		10分			分
84H	85H	12/24	0	10	时	时
				AM/PM
86H	87H	0	0	10日		日
88H	89H	0	0	0	10月	月
8A	8BH	0	0	0	0	0	星期
8C	8DH	10年				年
8E	8FH	WP	0	0	0	0	0	0	0

DS1302小时寄存器（84H、85H）的位7应用于DS1302是运行的模式。即12小时制还是24小时制。当位7为1时，表示12小时模式，此时相应的寄存器位5为高时表示AM,为低时表示PM。当位7为0时， 表示24小时模式。

DS1302秒寄存器（80H、81H）的位7应用于时钟暂停标志（CH）位。当该位为1时，时钟振荡器停止，DS1302处于低功耗状态；当该位为0时，时钟开始运行。

DS1302 控制寄存器（8EH、8FH）的位7是写入保护位，其它7位均为0。当WP位为0时可以开始进行对时钟和RAW进行写入，当WP位为1时，禁止对寄存器的写入操作。

2：DS1302中静态RAM地址

   DS1302在静态工作模式下的RAW地址如表3.7所示。

表3.7 静态 RAM 的地址表

读地址	写地址		数据范围
C1H	C0H		00-FFH
C3H	C2H		00-FFH
C5H	C4H		00-FFH
. . .	. . .		. . .
FDH	FCH		00-FFH

3：DS1302的工作模式寄存器

DS1302的工作模式寄存器又分为时钟突发模式寄存器、RAW突发模式寄存器等。突发模式是指一次传送多个字节的时钟信号和 RAM 数据。 突发模式寄存器如表3.8所示。

表3.8突发模式寄存器

工作模式寄存器		读寄存器	写寄存器
时钟突发模式寄器	CLOCK BURST	BFH	BEH
RAW突发模式寄存器	RAW BURST	FFH	FEH

4：DS1302控制字符表

DS1302的控制字最高位（位7）必须是1，才能进行数据的写入，否则不能写入数据；次高位（位6）表示RAW数据或者时钟日历的存取，当为1时表示RAW数据存取，为0则表示时钟日历的存取；接着是数据操作地址（位5-位1）；最后是位0表示数据的读写操作，当为1时表示读操作，为0表示写操作。如表3.9所示。

表3.9              控制字（即地址及命令字节）

5：DS1302的读写时序

DS1302数据的读写规则是在控制字的基础上从低位到高位的输出，每当控制字指令输入后下一个SCLK脉冲上升沿到来时，数据就会被写入到DS1302中，数据从最低位开始写入，下一个SCLK脉冲的下降沿到来时，就会读出DS1302里面的数据，读出的规则也是从低位到高位。

图3.8 数据读写时序

3.3.3 DS1302时钟采集模块原理图

图3.9 DS1302原理图

此图为DS1302时钟芯片模块采集原理图，X1和X2接的是时钟晶振,,大小为32.768MHz，VCC1和VCC2分别接3V和5V电压，I/O、SCLK和ST分别接单片机的P1.6、P1.7和P1.5引脚。

3.4 DS18B20芯片介绍及应用

   DS18B20数字温度计是DALLAS公司生产的One－Wire，即单总线器件，它具有体积小而且线路简单的优点。它只有三个引脚，分别是接高电源、地信号和一条数据信号线，设计简单而又方便。因此它广泛应用于温度的测温系统。

    DS18B20除了体积小、线路设计简单优点外，它在实际应用中不需要其它外部任何器件即可实现温度的测温功能，测量温度范围为－55—+125 °C 之间,如超出检测的温度,DS18B20将会发出报警信号。数字温度计的读取可以从9位到12位选择。可用数据线供电，供电范围+3.0-5.5V电压。

3.4.1 DS18B20引脚功能

DS18B20器件的封装引脚排列及引脚功能的描述如图3.10和表3.10。

图3.10（底视图）

表3.10 DS18B20引脚功能

序号	名称	引脚功能描
1	GND	地信号
2	DQ	数据输入/输出引脚。开漏单总线接口引脚。当被用在寄生电源下，也可以向器件提供电源。
3	VDD	可选择的VDD引脚。当工作于寄生电源时，此引脚必须接地。

3.4.2 DS18B20的应用及原理图

DS18B20采用的是one－Wire总线协议方式连接，实际就是在一根数据线进行数据的双向传输，，然而对于51单片机在硬件上并不支持单总线协议方式的连接，因此我们采用软件的方法来模拟单总线的协议方式来完成对DS18B20温度芯片的访问。

DS18B20的读写是在一根I/O线上进行，因此，对数据的读写有着严格的要求。DS18B20的通信协议也有着严格的要求来确保数据传输的正确性和完整性。

DS18B20有严格的通信协议来保证各位数据传输的正确性和完整性。该通信协议又细分了几种信号的时序，即：初始化时序、读时序、写时序。然而在这几种时序的工作下都是以主机作为主设备，单总线器件作为从设备。数据的传输是在主机先启动读入时序，读出数据后进入写时序命令，从而启动读写时序功能，完成数据的传输。数据和命令的传输都是低位在先。下面为DS18B20在本次设计的温度采集模块原理图3.11所示。

图3.11 DS18B20温度采集原理图

温度采集模块图主要是由DS18B20芯片进行，通过AT89C51单片机进行数据的传输和接受，从而再送到LCD1602，从LCD1602显示出来。DS18B20只有三个引脚，分别是VCC为正电源接5V电压，GND地信号接大地，最后是DQ数据输入/输出引脚连接AT89C51单片机的P1.0引脚。

4  程序的设计流程

4.1 交通灯程序设计的流程

4.1.1倒计时显示的理论分析

利用定时器中断，设置              TH0= (65536-50000)/256，TH1＝(65536-50000)%256，即每0.05秒中断一次。每到第20次中断即过了20*0.05秒＝1秒时，使时间的计数值减1，便实现了倒计时的功能。

4.1.2状态灯显示的理论分析

黄灯闪烁同样可以利用定时器中断。每到第10次中断即过了10*0.05秒＝0.5秒时，使黄灯标志位反置，即可让黄灯1秒闪烁一次。

4.1.3 交通灯主程序设计流程

交通灯系统在正常模式下工作的

• 首先，正常进入系统开始运行，交通灯在默认正常模式下工作，数码管显示时间为60。
• 交通信号灯开始正常工作，右转弯为常亮灯（绿色）。南北直行方向绿灯亮，其它方向亮红灯，数码管开始倒计时，南北方向从40倒计，东西方向从60倒计。
• 35S后，南北直行方向灭绿灯，闪烁黄灯，闪烁时间为5S。
• 40S后，南北直行方向亮红灯，左转方向亮绿灯，亮时15S，同时数码管从20倒计，其它不变。
• 55S后，南北左转方向灭绿灯，闪烁黄灯，闪烁时间为5S。
• 60S后，南北左转方向黄灯灭，亮红灯，数码管从60倒计，东西直行方向亮绿灯，数码管从40倒计，其它不变。
• 95S后，东西直行方向灭绿灯，闪烁黄灯，闪烁时间为5S。
• 100S后，东西直行方向灭黄灯，亮红灯，左转方向亮绿灯，亮时为15S，同时数码管从20倒计，其它不变。
• 115S后，东西左转方向灭绿灯，闪烁黄灯，闪烁时间为5S。
• 120S后，东西左转方向灭黄灯，亮红灯，数码管从60倒计。南北直行亮绿灯，数码管从40倒计。
  

图4.1   程序设计流程图

4.2万年历的设计流程

万年历的设置一方面可以更好的显示时间和温度，其次可以对交通信号灯系统的控制，定时向交通信号灯控制系统发出外部中断，从而该变当前工作模式,以致在实际中更具有实用性。

图4.2 万年历主程序流程图

       此次万年历的设计功能主要是两个，一个是通过LCD1602显示时间和温度，另一个则是为交通信号灯提供外部定时中断，从而改变当前的工作模式。而万年历的设计流程和普通设计的一样，开始先是对各种芯片的初始化，接着是从DS1302、DS18B20读取时间和温度信息，从而传送到AT89C51单片机进行时间、温度的分离转化，再传送到LCD1602显示出来，其次是时间的调整和校正，通过调整按键可以对秒、分、时、星期、日、月和年进行加减1的修改。最近是定时发出外部中断，利用IF语句进行判断，适合条件则输出低电平到交通信号灯，否则为高电平。从而达到了实验的目的。

4.3万年历时间的调整流程

本次万年历系统的设计只是采用DS1302进行时间的扫描和读取，而没用进行掉电保存电路的设计，因此在每次硬件的开启，系统都是进入初始化设置，以致要进行时间的调整和校正。

图4.3 时间调整控制图

时间的调整程序设计。首先，系统在正常工作下，由DS1302时钟芯片进行时间的读取，传递到AT89C51单片机进行对时间进行分离和转化，最后由LCD1602显示出来。在进行时间的调整和校正时，先进入调整模式，即按下第一个按键，执行调整程序，先是进入秒程序调整，按加减按键相应的进行加1或减1，再按调整切换键进入分程序调整，按加减减进行相应的加1减1，再接着是时、星期、日、月、年的调整。按加减键进行相应的加减1，在进行调整途中，如果按退出时间调整按键都将会退出时间调整程序。如图4.3时间调整控制图所示。

4.4交通信号系统工作模式的工作流程

图4.4 工作模式切换图

开始进入系统时，默认模式为正常模式60S，到了早上7:00时上班高峰期，万年历发出中断，从而使系统进入繁忙模式45S，从而可以减少路口上交通的拥堵。时间到了早上9:00，车辆逐渐减少，万年历又发出定时中断使系统进入正常模式，到了11：00，万年历再次发出定时中断，重新使系统进入繁忙模式，减少车辆的拥堵。到了下午14:00，万年历发出定时中断，使系统进入正常模式，在正常模式下运行到下午17:00下班时间，为了减少交通的拥堵，万年历发出定时中断，使系统进入繁忙模式，到了晚上19:00，道口上车辆减少，万年历最后发出定时中断，使系统在正常模式下正常运行。系统在正常模式、繁忙模式和特殊模式下运行时，还可以进行外部手动进行中断来进行通行时间的调整。如：在正常模式下按下繁忙模式，系统将会进入繁忙模式，当下次中断再次到来时，系统会根据中断的要求而进入相应的模式，不会受上次中断或下次中断的影响。

5  软硬件的仿真调试

5.1 PROTEUS仿真图

整个交通灯控制系统在PROTEUS仿真图中的仿真如下所示，双向通行，倒计时是2位时间提醒。每个路口分别有左转、直行和右转，分别有红灯、绿灯和黄灯提示。每个路口还相应配有行人的红绿灯指示 。图右上角数码管显示的工作模式，60代表是在正常模式下工作，45和75分别代表是在繁忙模式和特殊模式，右下角是开关调节按键，左边三个开关从上到下是交通灯各种模式转换开关，右边四个是时间调节开关，从而更具有实用性。

图5.1 PROTEUS仿真图

5.2 硬件实物图

   此次硬件实物的设计分为两部分，一部分是电子器件的设计，另一部分是显示界面的设计。电子器件的设计主要是单片机的最小系统设置、DS1302时钟模块的设置、DS18B20温度模块的设置以及非门74HC04的设置等；显示界面的设置主要是LCD1602液晶显示模块、各个方向数码管倒计时、数码管显示系统工作模式、各个道口的交通灯、人行道的交通灯以及控制开关调节按键的设置。两部分的分开设计可以使实物显得更美观，同时对于实物的器件的修改和调整也提供了更好的条件。也更联系了实际生活，显得简单、整洁和美观。

显示界面如图5.2所示。

图5.2 硬件实物图

结 论

本次基于单片机的交通信号灯控制系统的设计是在一般交通灯的基础上加上时间的智能控制，从而改变各方向通行的时间。因此本次智能交通灯的设计可以更好的解决了车流量较大的十字路口车辆的通行，与一般交通灯相比，它更具有实用性、简单化和智能化。从而也更好的应用到实际生活中，因此具有一定的实用价值。

此次基于单片机的交通信号灯控制系统的设计可以说得到了成功，但是还是存在很多的不足和缺陷。如：工作模式的时间只有三种选择，而不能通过按键进行随意更改，工作模式时间的智能切换也不能进行手动调节，以及对通过道口车流量的统计、车辆速度的检测和拍摄功能等都还没实现，而且此次设计需要用到的电子元器件较多，从经济上不划算，因此本次基于单片机的交通信号灯控制系统的设计也还存在着很大的不足，还有待改善。

致 谢

历时三个月的设计已经告一段落。经过自己不断的搜索努力以及大家的耐心指导和热情帮助，本设计已经基本完成。同时系里兴趣小组实验室的开放和大部分兴趣小组同学也为我的设计提供指导，在他们的帮助和指导下得到了完成。在此对于他们的帮助给与深刻的致谢。

在本次基于单片机的交通信号灯的控制系统设计中一路遇到了很多的困难，首先从开始电路原理图的设计、画PCB图和制板都遇到了困难。先是对芯片的不理解，专业知识的不够从而导致在程序的编写中经常出错。接着是在最后的调试中，由于本次设计分为两块电路板，线路繁多因此也很容易混乱等问题。但是在大家的帮助和鼓励下一一得到了解决。

通过这次设计，使我对自己有了一个深刻的认识。认识到了自己专业知识的不足和专业知识的重要性，同时也理解了理论要联系实际含义。通过这次的设计也检验了自己的学习成果，认识到了自己的不足和缺陷，在今后的工作和学习中将会继续努力，不断完善，从而为今后的发展打下良好的基础。

由于自身水平有限，设计中一定还存在很多不足之处，敬请各位批评指正。

1. 附录单片机程序：
   
2. 1:  十字路口交通灯控制C程序1：
   
3.         /***********************************************************
   
4.                十字路口交通灯控制 C 程序
   
5.         ***********************************************************/
   
6.         #include <reg51.h>
   
7.         #define        uchar        unsigned char
   
8.         #define        uint        unsigned int
   
9.         /*****定义控制位*******************************************/
   
10. sbit   Time_Show_LED1=P2^4;  //Time_Show_LED1(直行时间显示)控制位
    
11. sbit   Time_Show_LED2=P2^5;  //Time_Show_LED2(直行时间显示)控制位
    
12. sbit   SN_LED1=P2^0;             //SN_LED1控制位
    
13. sbit   SN_LED2=P2^1;             //SN_LED2控制位
    
14. sbit   EW_LED1=P2^2;             //EW_LED1控制位
    
15. sbit   EW_LED2=P2^3;             //EW_LED2控制位
    
16. sbit   SN_Yellow=P1^6;       //SN黄灯
    
17. sbit   EW_Yellow=P1^2;       //EW黄灯
    
18. sbit   EW_ManGreen=P3^0;     //EW人行道绿灯
    
19. sbit   SN_ManGreen=P3^1;     //SN人行道绿灯
    
20. sbit   Special_LED=P2^6;     //交通特殊指示灯
    
21. sbit   Busy_LED=P2^7;        //交通繁忙指示灯
    
22. sbit   Nomor_Button=P3^5;    //交通正常按键
    
23. sbit   Busy_Btton=P3^6;      //交通繁忙按键
    
24. sbit   Special_Btton=P3^7;   //交通特殊按键  
    
25. sbit   EW_ManRed=P3^3;       //EW人行道红灯
    
26. sbit   SN_ManRed=P3^4;       //SN人行道红灯
    
27. sbit   x=P1^7;
    
28. sbit   y=P1^3;
    
29. bit    Flag_SN_Yellow;       //SN黄灯标志位
    
30. bit    Flag_EW_Yellow;       //EW黄灯标志位
    
31. char   Time_EW;        //东西方向倒计时单元
    
32. char   Time_SN;        //南北方向倒计时单元
    
33. uchar  EW=60,SN=40,EWL=19,SNL=19;      //程序初始化赋值，正常模式
    
34. uchar  EW1=60,SN1=40,EWL1=19,SNL1=19;  //用于存放修改值的变量
    
35. uchar code table[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};  //0-9段选码
    
36. uchar code S[8]={0x28,0x48,0x98,0x88,0x82,0x84,0x89,0x88};  
    
37. //交通信号灯控制代码
    
38. /**********************延时子程序**************************/
    
39. void Delay(uchar a)
    
40. {
    
41.         uchar        i;
    
42.         i=a;
    
43.         while(i--){;}
    
44.         }
    
45. /*****************显示子函数******************************/
    
46. void Display(void)
    
47.         {
    
48.         uchar h,l;
    
49.         h=Time_EW/10;
    
50.         l=Time_EW%10;
    
51.         P0=table[l];        
    
52.         EW_LED2=1;              //点亮EW_LED2
    
53.         Delay(2);
    
54.         EW_LED2=0;        //熄灭EW_LED2
    
55.         P0=table[h];
    
56.         EW_LED1=1;        //点亮EW_LED1
    
57.         Delay(2);
    
58.         EW_LED1=0;
    
59. 
    
60.         h=Time_SN/10;
    
61.         l=Time_SN%10;
    
62.         P0=table[l];
    
63.         SN_LED2=1;        //点亮SN_LED2
    
64.         Delay(2);
    
65.         SN_LED2=0;
    
66.         P0=table[h];
    
67.         SN_LED1=1;                  //点亮SN_LED1
    
68.         Delay(2);
    
69.         SN_LED1=0;
    
70.                         
    
71.         h= EW1/10;
    
72.         l= EW1%10;
    
73.         P0=table[l];
    
74.         Time_Show_LED1=1;         //点亮Time_Show_LED1
    
75.         Delay(2);
    
76.    Time_Show_LED1=0;
    
77.                
    
78. P0=table[h];
    
79.         Time_Show_LED2=1;        //点亮Time_Show_LED2
    
80.         Delay(2);
    
81.         Time_Show_LED2=0;
    
82.         }
    
83. /**********************外部0中断服务程序******************/
    
84.         void INT0_srv(void)interrupt 0 using 1
    
85.         {
    
86.          EX0=0;               //关中断
    
87.          if(Nomor_Button==0) //测试按键是否按下，按下为正常状态
    
88.           {
    
89.         EW1=60;
    
90.         SN1=40;
    
91.         EWL1=19;
    
92.         SNL1=19;
    
93.         Busy_LED=0;     //关繁忙信号灯
    
94.         Special_LED =0; //关特殊信号灯
    
95.             }
    
96.   if(Busy_Btton==0)   //测试按键是否按下，按下为繁忙状态
    
97.             {
    
98.         EW1=45;
    
99.         SN1=30;
    
100.         EWL1=14;
     
101.         SNL1=14;
     
102.         Special_LED=0;  //关特殊信号灯
     
103.         Busy_LED=1;     //开繁忙信号灯
     
104.         
     
105.             }
     
106.             if(Special_Btton==0)//测试按键是否按下，按下为特殊状态
     
107.             {
     
108.         EW1=75;
     
109.         SN1=55;
     
110.         EWL1=19;
     
111.         SNL1=19;
     
112.         Busy_LED=0;    //关繁忙信号灯
     
113.         Special_LED =1;//开特殊信号灯
     
114.             }                                       
     
115.                         EX0=1;         //开中断
     
116.         }
     
117.         /**********************T0中断服务程序*******************/
     
118.         void timer0(void)interrupt 1 using 1
     
119.         {
     
120.                 static uchar count;
     
121.                 TH0=(65536-50000)/256;
     
122.                 TL0=(65536-50000)%256;
     
123.                 count++;
     
124.                 if(count==10)
     
125.                 {
     
126.                     if(Flag_SN_Yellow==1)  //测试南北黄灯标志位
     
127.                         {SN_Yellow=~SN_Yellow;}
     
128.                     if(Flag_EW_Yellow==1)  //测试东西黄灯标志位
     
129.                         {EW_Yellow=~EW_Yellow;}
     
130.                 }
     
131.                 if(count==20)
     
132.                 {
     
133.             Time_EW--;
     
134.                    Time_SN--;
     
135.                    if(Flag_SN_Yellow==1)  //测试南北黄灯标志位
     
136.                         {SN_Yellow=~SN_Yellow;}
     
137.                    if(Flag_EW_Yellow==1)  //测试东西黄灯标志位
     
138.                         {EW_Yellow=~EW_Yellow;}
     
139.                    count=0;
     
140.                 }
     
141.         }
     
142.         /*********************主程序开始***********************/
     
143.         void        main(void)
     
144.         {
     
145.         Busy_LED=0;
     
146.         Special_LED=0;
     
147.         IT0=1;           //INT0负跳变触发
     
148.         TMOD=0x01; //定时器工作于方式1
     
149.         TH0=(65536-50000)/256; //定时器赋初值
     
150.         TL0=(65536-50000)%256;
     
151.         EA=1;  //CPU开中断总允许
     
152.         ET0=1; //开定时中断
     
153.         EX0=1; //开外部INTO中断
     
154.         TR0=1; //启动定
     
155.             while(1)
     
156.             {                                
     
157.                 /*******S0状态**********/
     
158.         SN_ManRed=0;
     
159.         SN_ManGreen=1;  //SN人行道通行
     
160.         EW_ManRed=1;        //EW人行道禁止
     
161.         EW_ManGreen=0;
     
162.         Flag_EW_Yellow=0;           //EW关黄灯显示信号
     
163.         Time_EW=EW;
     
164.         Time_SN=SN;
     
165.         while(Time_SN>=5)
     
166.                         {   
     
167.                             P1=S[0];        //SN绿灯，EW红灯
     
168.                             Display();
     
169.                         }
     
170.                         /*******S1状态**********/
     
171.                         P1=0x00;
     
172.                         while(Time_SN>=0)
     
173.                         {
     
174.         Flag_SN_Yellow=1; //SN开黄灯信号位
     
175.         P1=P1|0x08;    //保持EW红灯
     
176.         Display();
     
177.                         }
     
178.                         /*******S2状态**********/
     
179.         SN_ManRed=1;      //SN人行道禁止
     
180.         SN_ManGreen=0;
     
181.         EW_ManRed=1;          //EW人行道禁止
     
182.         EW_ManGreen=0;
     
183.         Flag_SN_Yellow=0; //SN关黄灯显示信号
     
184.         Time_SN=SNL;
     
185.         while(Time_SN>=5)
     
186.                         {
     
187.         P1=S[2];      //SN左拐绿灯亮，EW红灯
     
188.         Display();
     
189.                         }
     
190.                         /*******S3状态**********/
     
191.                         P1=0x00;
     
192.                         while(Time_SN>=0)
     
193.                         {
     
194.         //Flag_SN_Yellow=0;        //SN开黄灯信号位
     
195.         x=1;
     
196.         P1=P1|0x08;    //保持EW红灯
     
197.         Display();
     
198.                         }
     
199.                         /***********赋值*********/
     
200.         EW=EW1;
     
201.         SN=SN1;
     
202.         EWL=EWL1;
     
203.         SNL=SNL1;
     
204.                         /*******S4状态**********/
     
205.         SN_ManRed=1;      //SN人行道禁止
     
206.         SN_ManGreen=0;
     
207.         EW_ManRed=0;
     
208.         EW_ManGreen=1;          //EW人行道通行
     
209.         Flag_SN_Yellow=0; //SN关黄灯显示信号
     
210.         Time_EW=SN;
     
211.         Time_SN=EW;
     
212.         while(Time_EW>=5)
     
213.                         {
     
214.                             P1=S[4];          //EW通行，SN红灯
     
215.                                 Display();
     
216.                         }
     
217.                         /*******S5状态**********/
     
218.                         P1=0X00;
     
219.                         while(Time_EW>=0)
     
220.                         {
     
221.         Flag_EW_Yellow=1;//EW开黄灯信号位
     
222.         P1=P1|0x80;    //保持SN红灯
     
223.         Display();
     
224.                         }
     
225.                         /*******S6状态**********/
     
226.         SN_ManRed=1;     //SN人行道禁止
     
227.         SN_ManGreen=0;
     
228.         EW_ManRed=1;         //EW人行道禁止
     
229.         EW_ManGreen=0;
     
230.         Flag_EW_Yellow=0;//EW关黄灯显示信号
     
231.         Time_EW=EWL;
     
232.         while(Time_EW>=5)
     
233.                         {
     
234.         P1=S[6];     //EW左拐绿灯亮，SN红灯
     
235.         Display();
     
236.                         }
     
237.                         /*******S7状态**********/
     
238.                         P1=0X00;
     
239.                         while(Time_EW>=0)
     
240.                         {
     
241.         //Flag_EW_Yellow=0; //EN开黄灯信号位
     
242.         y=1;
     
243.         P1=P1|0x80;    //保持SN红灯
     
244.         Display();
     
245.                         }               
     
246.                         /***********赋值********/
     
247.                         EW=EW1;
     
248.                         SN=SN1;
     
249.                         EWL=EWL1;
     
250.                         SNL=SNL1;
     
251.                 }
     
252.         }
     
253. 
     
254. 2：十字路口交通灯控制C程序2
     
255.         /***********************************************************
     
256.                十字路口交通灯控制 C 程序
     
257.         ***********************************************************/
     
258.         #include <reg51.h>
     
259.         #define        uchar        unsigned char
     
260.         #define        uint        unsigned int
     
261.         /*****定义控制位*******************************************/
     
262.         sbit   EW_Green1 =P1^0;  //EW直行绿灯
     
263.         sbit   EW_Green12 =P1^1; //EW左转绿灯
     
264. sbit   EW_Green13= P1^2; //EW右转绿灯
     
265.         sbit   EW_Yellow1 =P1^3; //EW直行黄灯
     
266.         sbit   EW_Yellow2 =P1^4; //EW左转黄灯
     
267.         sbit   EW_Yellow3 =P1^5; //EW右转黄灯
     
268.         sbit   EW_Red1=P1^6;     //RE直行红灯
     
269.         sbit   EW_Red2 =P1^7;    //RE左转红灯
     
270.         bit    Flag_SN_Yellow;  //SN黄灯标志位
     
271.         bit    Flag_EW_Yellow;  //EW黄灯标志位
     
272.         uchar  EW=60,SN=40,EWL=19,SNL=19;      //程序初始化赋值，正常模式
     
273.         uchar  EW1=60,SN1=40,EWL1=19,SNL1=19;  //用于存放修改值的变量
     
274.         uchar code table[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};  //0-9段选码
     
275.         uchar code S[8]={0xA0,0xA0,0x80,0xC0,0xA0,0xA0,0x20,0x24};  
     
276.         //交通信号灯控制代码
     
277.         /**********************延时子程序**************************/
     
278.         void Delay(uchar a)
     
279.         {
     
280.                 uchar        i;
     
281.                 i=a;
     
282.                 while(i--){;}
     
283.         }
     
284.         /*****************显示子函数******************************/
     
285.         void Display(void)
     
286.         {
     
287.                 uchar h,l;
     
288.                 h=Time_EW/10;
     
289.                 l=Time_EW%10;
     
290.                   P0=table[l];        
     
291.                 EW_LED2=1;              //点亮EW_LED2
     
292.                 Delay(2);
     
293.                 EW_LED2=0;        //熄灭EW_LED2
     
294.                 P0=table[h];
     
295.                 EW_LED1=1;        //点亮EW_LED1
     
296.                 Delay(2);
     
297.                 EW_LED1=0;
     
298. 
     
299.                 h=Time_SN/10;
     
300.                 l=Time_SN%10;
     
301.                 P0=table[l];
     
302.                 SN_LED2=1;        //点亮SN_LED2
     
303.                 Delay(2);
     
304.                 SN_LED2=0;
     
305.                 P0=table[h];
     
306.                 SN_LED1=1;                  //点亮SN_LED1
     
307.                 Delay(2);
     
308.                 SN_LED1=0;
     
309.                         
     
310.                 h= EW1/10;
     
311.                 l= EW1%10;
     
312.                 P0=table[l];
     
313.                 Time_Show_LED1=1;         //点亮Time_Show_LED1
     
314.                 Delay(2);
     
315.            Time_Show_LED1=0;
     
316.                 P0=table[h];
     
317.                 Time_Show_LED2=1;        //点亮Time_Show_LED2
     
318.                 Delay(2);
     
319.                 Time_Show_LED2=0;
     
320.         }
     
321.         /**********************外部0中断服务程序******************/
     
322.         void INT0_srv(void)interrupt 0 using 1
     
323.         {
     
324.                  EX0=0;               //关中断
     
325.             if(Nomor_Button==0) //测试按键是否按下，按下为正常状态
     
326.             {
     
327.         EW1=60;
     
328.         SN1=40;
     
329.         EWL1=19;
     
330.         SNL1=19;
     
331.         Busy_LED=0;     //关繁忙信号灯
     
332.         Special_LED =0; //关特殊信号灯
     
333.             }
     
334.             if(Busy_Btton==0)   //测试按键是否按下，按下为繁忙状态
     
335.             {
     
336.         EW1=45;
     
337.         SN1=30;
     
338.         EWL1=14;
     
339.         SNL1=14;
     
340.         Special_LED=0;  //关特殊信号灯
     
341.         Busy_LED=1;     //开繁忙信号灯
     
342.             }
     
343.             if(Special_Btton==0)//测试按键是否按下，按下为特殊状态
     
344.             {
     
345.         EW1=75;
     
346.         SN1=55;
     
347.         EWL1=19;
     
348.         SNL1=19;
     
349.         Busy_LED=0;    //关繁忙信号灯
     
350.         Special_LED =1;//开特殊信号灯
     
351.             }                                       
     
352.                         EX0=1;         //开中断
     
353.         }
     
354.         /**********************T0中断服务程序*******************/
     
355.         void timer0(void)interrupt 1 using 1
     
356.         {
     
357.                 static uchar count;
     
358.                 TH0=(65536-50000)/256;
     
359.                 TL0=(65536-50000)%256;
     
360.                 count++;
     
361.                 if(count==10)
     
362.                 {
     
363.                     if(Flag_SN_Yellow==1)  //测试南北黄灯标志位
     
364.                         {SN_Yellow=~SN_Yellow;}
     
365.                     if(Flag_EW_Yellow==1)  //测试东西黄灯标志位
     
366.                         {EW_Yellow=~EW_Yellow;}
     
367.                 }
     
368.                 if(count==20)
     
369.                 {
     
370.                     Time_EW--;
     
371.                     Time_SN--;
     
372.                     if(Flag_SN_Yellow==1)  //测试南北黄灯标志位
     
373.                         {SN_Yellow=~SN_Yellow;}
     
374.                     if(Flag_EW_Yellow==1)  //测试东西黄灯标志位
     
375.                         {EW_Yellow=~EW_Yellow;}
     
376.                     count=0;
     
377.                 }
     
378.         }
     
379.         /*********************主程序开始***********************/
     
380.         void        main(void)
     
381.         {
     
382.         Busy_LED=0;
     
383.         Special_LED=0;
     
384.         IT0=1;           //INT0负跳变触发
     
385.         TMOD=0x01; //定时器工作于方式1
     
386.         TH0=(65536-50000)/256; //定时器赋初值
     
387.         TL0=(65536-50000)%256;
     
388.         EA=1;  //CPU开中断总允许
     
389.         ET0=1; //开定时中断
     
390.         EX0=1; //开外部INTO中断
     
391.         TR0=1; //启动定时
     
392.             while(1)
     
393.             {                                
     
394.                 /*******S0状态**********/
     
395.         SN_ManGreen=1;  //SN人行道通行
     
396.         EW_ManGreen=0;
     
397.         Flag_EW_Yellow=0;           //EW关黄灯显示信号
     
398.         Time_EW=EW;
     
399.         Time_SN=SN;
     
400.         while(Time_SN>=5)
     
401.                         {   
     
402.                             P1=S[0];        //SN绿灯，EW红灯
     
403.                             Display();
     
404.                         }
     
405.                         /*******S1状态**********/
     
406.                         P1=0x00;
     
407.                         while(Time_SN>=0)
     
408.                         {
     
409.         x=1;
     
410.         y=1;
     
411.         P1=P1|0xA0;    //保持EW红灯
     
412.         Display();
     
413.                         }
     
414.                         /*******S2状态**********/
     
415.         EW_ManGreen=0;
     
416.         Flag_SN_Yellow=0; //SN关黄灯显示信号
     
417.         Time_SN=SNL;
     
418.         while(Time_SN>=5)
     
419.                         {
     
420.         P1=S[2];      //SN左拐绿灯亮，EW红灯
     
421.         Display();
     
422.                         }
     
423.                         /*******S3状态**********/
     
424.                         P1=0x00;
     
425.                         while(Time_SN>=0)
     
426.                         {
     
427.         Flag_SN_Yellow=1;        //SN开黄灯信号位
     
428.         y=1;
     
429.         c=0;
     
430.         Display();
     
431.                         }
     
432.                         /***********赋值*********/
     
433.         EW=EW1;
     
434.         SN=SN1;
     
435.         EWL=EWL1;
     
436.         SNL=SNL1;
     
437.                         /*******S4状态**********/
     
438.         SN_ManGreen=0;
     
439.         EW_ManGreen=1;          //EW人行道通行
     
440.         Flag_SN_Yellow=0; //SN关黄灯显示信号
     
441.         x=1;
     
442.         d=0;
     
443.         Time_EW=SN;
     
444.         Time_SN=EW;
     
445.         while(Time_EW>=5)
     
446.                         {
     
447.                             P1=S[4];          //EW通行，SN红灯
     
448.                                 Display();
     
449.                         }
     
450.                         /*******S5状态**********/
     
451.                         P1=0X00;
     
452.                         while(Time_EW>=0)
     
453.                         {
     
454.         x=1;
     
455.         P1=P1|0x80;    //保持SN红灯
     
456.         Display();
     
457.                         }
     
458.                         /*******S6状态**********/
     
459.         SN_ManGreen=0;
     
460.         EW_ManGreen=0;
     
461.         Flag_EW_Yellow=0;//EW关黄灯显示信号
     
462.         Time_EW=EWL;
     
463.         while(Time_EW>=5)
     
464.                         {
     
465.         P1=S[6];     //EW左拐绿灯亮，SN红灯
     
466.         Display();
     
467.                         }
     
468.                         /*******S7状态**********/
     
469.                         P1=0X00;
     
470.                         while(Time_EW>=0)
     
471.                         {
     
472.         Flag_EW_Yellow=1; //EN开黄灯信号位
     
473.         x=1;
     
474.         P1=P1|0x20;    //保持SN红灯
     
475.         Display();
     
476.                         }
     
477.                         /***********赋值********/
     
478.                         EW=EW1;
     
479.                         SN=SN1;
     
480.                         EWL=EWL1;
     
481.                         SNL=SNL1;
     
482.                 }
     
483.         }
     
484. 3:万年历程序：
     
485. #include <REG51.H>
     
486. #include <intrins.h>
     
487. //#include "LCD1602.h"
     
488. //#include "DS1302.h"
     
489. #define uint unsigned int
     
490. #define uchar unsigned char
     
491. sbit  DS1302_CLK = P1^7;              //实时时钟时钟线引脚
     
492. sbit  DS1302_IO  = P1^6;              //实时时钟数据线引脚
     
493. sbit  DS1302_RST = P1^5;              //实时时钟复位线引脚
     
494. sbit  wireless_1 = P3^0;
     
495. sbit  wireless_2 = P3^1;
     
496. sbit  wireless_3 = P3^2;
     
497. sbit  wireless_4 = P3^3;
     
498. sbit  zhengchang = P3^5;               //正常模式切换
     
499. sbit  fanmang = P3^6;                  //繁忙模式切换
     
500. sbit  ACC0 = ACC^0;
     
501. sbit  ACC7 = ACC^7;
     
502. char hide_sec,hide_min,hide_hour,hide_day,hide_week,hide_month,hide_year;  //秒,分,时到日,月,年位闪的计数
     
503. void show_time();   //液晶显示程序
     
504. /***********1602液晶显示部分子程序****************/
     
505. 
     
506. //Port Definitions**********************************************************
     
507. sbit LcdRs                = P2^5;
     
508. sbit LcdRw                = P2^6;
     
509. sbit LcdEn          = P2^7;
     
510. sfr  DBPort         = 0x80;                //P0=0x80,P1=0x90,P2=0xA0,P3=0xB0.数据端口
     
511. 
     
512. //内部等待函数**************************************************************************
     
513. unsigned char LCD_Wait(void)
     
514. {
     
515.         LcdRs=0;
     
516.         LcdRw=1;        _nop_();
     
517.         LcdEn=1;        _nop_();
     
518.                                                 
     
519.         LcdEn=0;
     
520.         return DBPort;               
     
521. }
     
522. //向LCD写入命令或数据************************************************************
     
523. #define LCD_COMMAND                        0      // Command
     
524. #define LCD_DATA                        1      // Data
     
525. #define LCD_CLEAR_SCREEN        0x01      // 清屏
     
526. #define LCD_HOMING                  0x02      // 光标返回原点
     
527. void LCD_Write(bit style, unsigned char input)
     
528. {
     
529.         LcdEn=0;
     
530.         LcdRs=style;
     
531.         LcdRw=0;                _nop_();
     
532.         DBPort=input;        _nop_();//注意顺序
     
533.         LcdEn=1;                _nop_();//注意顺序
     
534.         LcdEn=0;                _nop_();
     
535.         LCD_Wait();        
     
536. }
     
537. 
     
538. //设置显示模式************************************************************
     
539. #define LCD_SHOW                        0x04    //显示开
     
540. #define LCD_HIDE                        0x00    //显示关         
     
541. 
     
542. #define LCD_CURSOR                        0x02         //显示光标
     
543. #define LCD_NO_CURSOR                0x00    //无光标                     
     
544. 
     
545. #define LCD_FLASH                        0x01    //光标闪动
     
546. #define LCD_NO_FLASH                0x00    //光标不闪动
     
547. 
     
548. void LCD_SetDisplay(unsigned char DisplayMode)
     
549. {
     
550.         LCD_Write(LCD_COMMAND, 0x08|DisplayMode);        
     
551. }
     
552. 
     
553. //设置输入模式************************************************************
     
554. #define LCD_AC_UP                        0x02
     
555. #define LCD_AC_DOWN                        0x00      // default
     
556. 
     
557. #define LCD_MOVE                        0x01      // 画面可平移
     
558. #define LCD_NO_MOVE                        0x00      //default
     
559. 
     
560. void LCD_SetInput(unsigned char InputMode)
     
561. {
     
562.         LCD_Write(LCD_COMMAND, 0x04|InputMode);
     
563. }
     
564. 
     
565. //初始化LCD************************************************************
     
566. void LCD_Initial()
     
567. {
     
568.         LcdEn=0;
     
569.         LCD_Write(LCD_COMMAND,0x38);           //8位数据端口,2行显示,5*7点阵
     
570.         LCD_Write(LCD_COMMAND,0x38);
     
571.         LCD_SetDisplay(LCD_SHOW|LCD_NO_CURSOR);    //开启显示, 无光标
     
572.         LCD_Write(LCD_COMMAND,LCD_CLEAR_SCREEN);   //清屏
     
573.         LCD_SetInput(LCD_AC_UP|LCD_NO_MOVE);       //AC递增, 画面不动
     
574. }
     
575. 
     
576. //液晶字符输入的位置************************
     
577. void GotoXY(unsigned char x, unsigned char y)
     
578. {
     
579.         if(y==0)
     
580.                 LCD_Write(LCD_COMMAND,0x80|x);
     
581.         if(y==1)
     
582.                 LCD_Write(LCD_COMMAND,0x80|(x-0x40));
     
583. }
     
584. 
     
585. //将字符输出到液晶显示
     
586. void Print(unsigned char *str)
     
587. {
     
588.         while(*str!='\0')
     
589.         {
     
590.                 LCD_Write(LCD_DATA,*str);
     
591.                 str++;
     
592.         }
     
593. }
     
594. /***********DS1302时钟部分子程序******************/
     
595. typedef struct __SYSTEMTIME__
     
596. {
     
597.         unsigned char Second;
     
598.         unsigned char Minute;
     
599.         unsigned char Hour;
     
600.         unsigned char Week;
     
601.         unsigned char Day;
     
602.         unsigned char Month;
     
603.         unsigned char  Year;
     
604.         unsigned char DateString[11];
     
605.         unsigned char TimeString[9];
     
606. }SYSTEMTIME;        //定义的时间类型
     
607. SYSTEMTIME CurrentTime;
     
608. 
     
609. #define AM(X)        X
     
610. #define PM(X)        (X+12)                      // 转成24小时制
     
611. #define DS1302_SECOND        0x80          //时钟芯片的寄存器位置,存放时间
     
612. #define DS1302_MINUTE        0x82
     
613. #define DS1302_HOUR                0x84
     
614. #define DS1302_WEEK                0x8A
     
615. #define DS1302_DAY                0x86
     
616. #define DS1302_MONTH            0x88
     
617. #define DS1302_YEAR                0x8C
     
618. 
     
619. void DS1302InputByte(unsigned char d)         //实时时钟写入一字节(内部函数)
     
620. {
     
621.     unsigned char i;
     
622.     ACC = d;
     
623.     for(i=8; i>0; i--)
     
624.     {
     
625.         DS1302_IO = ACC0;                   //相当于汇编中的 RRC
     
626.         DS1302_CLK = 1;
     
627.         DS1302_CLK = 0;
     
628.         ACC = ACC >> 1;
     
629.     }
     
630. }
     
631. 
     
632. unsigned char DS1302OutputByte(void)         //实时时钟读取一字节(内部函数)
     
633. {
     
634.     unsigned char i;
     
635.     for(i=8; i>0; i--)
     
636.     {
     
637.         ACC = ACC >>1;                                 //相当于汇编中的 RRC
     
638.         ACC7 = DS1302_IO;
     
639.         DS1302_CLK = 1;
     
640.         DS1302_CLK = 0;
     
641.     }
     
642.     return(ACC);
     
643. }
     
644. 
     
645. void Write1302(unsigned char ucAddr, unsigned char ucDa)        //ucAddr: DS1302地址, ucData: 要写的数据
     
646. {
     
647.     DS1302_RST = 0;
     
648.     DS1302_CLK = 0;
     
649.     DS1302_RST = 1;
     
650.     DS1302InputByte(ucAddr);               // 地址，命令
     
651.     DS1302InputByte(ucDa);               // 写1Byte数据
     
652.     DS1302_CLK = 1;
     
653.     DS1302_RST = 0;
     
654. }
     
655. unsigned char Read1302(unsigned char ucAddr)        //读取DS1302某地址的数据
     
656. {
     
657.     unsigned char ucData;
     
658.     DS1302_RST = 0;
     
659.     DS1302_CLK = 0;
     
660.     DS1302_RST = 1;
     
661.     DS1302InputByte(ucAddr|0x01);        // 地址，命令
     
662.     ucData = DS1302OutputByte();         // 读1Byte数据
     
663.     DS1302_CLK = 1;
     
664.     DS1302_RST = 0;
     
665.     return(ucData);
     
666. }
     
667. void DS1302_GetTime(SYSTEMTIME *Time)  //获取时钟芯片的时钟数据到自定义的结构型数组
     
668. {
     
669.         unsigned char ReadValue;
     
670.         ReadValue = Read1302(DS1302_SECOND);
     
671.         Time->Second = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
672.         ReadValue = Read1302(DS1302_MINUTE);
     
673.         Time->Minute = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
674.         ReadValue = Read1302(DS1302_HOUR);
     
675.         Time->Hour = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
676.         ReadValue = Read1302(DS1302_DAY);
     
677.         Time->Day = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);        
     
678.         ReadValue = Read1302(DS1302_WEEK);
     
679.         Time->Week = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
680.         ReadValue = Read1302(DS1302_MONTH);
     
681.         Time->Month = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
682.         ReadValue = Read1302(DS1302_YEAR);
     
683.         Time->Year = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);        
     
684. }
     
685. 
     
686. void DateToStr(SYSTEMTIME *Time)    //将时间年,月,日,星期数据转换成液晶显示字符串,放到数组里DateString[]
     
687. {   if(hide_year<2)                 //这里的if,else语句都是判断位闪烁,<2显示数据,>2就不显示,输出字符串为 2012/05/25
     
688.     {                              
     
689.           Time->DateString[0] = '2';
     
690.           Time->DateString[1] = '0';         
     
691.           Time->DateString[2] = Time->Year/10 + '0';
     
692.           Time->DateString[3] = Time->Year%10 + '0';
     
693.         }
     
694.           else
     
695.             {
     
696.               Time->DateString[0] = ' ';
     
697.               Time->DateString[1] = ' ';                 
     
698.               Time->DateString[2] = ' ';
     
699.               Time->DateString[3] = ' ';
     
700.                 }
     
701.         Time->DateString[4] = '/';
     
702.         if(hide_month<2)
     
703.         {
     
704.           Time->DateString[5] = Time->Month/10 + '0';
     
705.           Time->DateString[6] = Time->Month%10 + '0';
     
706.         }
     
707.           else
     
708.           {
     
709.             Time->DateString[5] = ' ';
     
710.             Time->DateString[6] = ' ';
     
711.           }
     
712.         Time->DateString[7] = '/';
     
713.         if(hide_day<2)
     
714.         {
     
715.           Time->DateString[8] = Time->Day/10 + '0';
     
716.           Time->DateString[9] = Time->Day%10 + '0';
     
717.         }
     
718.           else
     
719.           {
     
720.             Time->DateString[8] = ' ';
     
721.             Time->DateString[9] = ' ';            
     
722.           }
     
723.         if(hide_week<2)
     
724.         {
     
725.           week_value[0] = Time->Week%10 + '0';  //星期的数据另外放到 week_value[]数组里,跟年,月,日的分开存放,因为等一下要在最后显示
     
726.         }
     
727.           else
     
728.           {
     
729.             week_value[0] = ' ';
     
730.           }
     
731.           week_value[1] = '\0';
     
732.         Time->DateString[10] = '\0'; //字符串末尾加 '\0' ,判断结束字符
     
733. }
     
734. 
     
735. void TimeToStr(SYSTEMTIME *Time)  //将时,分,秒数据转换成液晶显示字符放到数组 TimeString[];
     
736. {   if(hide_hour<2)
     
737.     {
     
738.           Time->TimeString[0] = Time->Hour/10 + '0';
     
739.           Time->TimeString[1] = Time->Hour%10 + '0';
     
740.         }
     
741.           else
     
742.             {
     
743.               Time->TimeString[0] = ' ';
     
744.               Time->TimeString[1] = ' ';
     
745.                 }
     
746.         Time->TimeString[2] = ':';
     
747.     if(hide_min<2)
     
748.         {
     
749.           Time->TimeString[3] = Time->Minute/10 + '0';
     
750.           Time->TimeString[4] = Time->Minute%10 + '0';
     
751.         }
     
752.           else
     
753.             {
     
754.               Time->TimeString[3] = ' ';
     
755.               Time->TimeString[4] = ' ';
     
756.                }
     
757.         Time->TimeString[5] = ':';
     
758.     if(hide_sec<2)
     
759.     {
     
760.           Time->TimeString[6] = Time->Second/10 + '0';
     
761.           Time->TimeString[7] = Time->Second%10 + '0';
     
762.     }
     
763.       else
     
764.        {
     
765.          Time->TimeString[6] = ' ';
     
766.              Time->TimeString[7] = ' ';
     
767.        }
     
768.         Time->DateString[8] = '\0';
     
769. }
     
770. void Initial_DS1302(void)   //时钟芯片初始化
     
771. {   
     
772.         unsigned char Second=Read1302(DS1302_SECOND);
     
773.         if(Second&0x80)              //判断时钟芯片是否关闭         
     
774.     {
     
775.         Write1302(0x8e,0x00); //写入允许
     
776.         Write1302(0x8c,0x12); //以下写入初始化时间 日期:12/05/25.星期: 5. 时间: 10:59:55
     
777.         Write1302(0x88,0x05);
     
778.         Write1302(0x86,0x25);
     
779.         Write1302(0x8a,0x05);
     
780.         Write1302(0x84,0x10);
     
781.         Write1302(0x82,0x59);
     
782.         Write1302(0x80,0x55);
     
783.         Write1302(0x8e,0x80); //禁止写入
     
784.         }
     
785. }
     
786. /***********ds18b20子程序*************************/
     
787. /***********ds18b20延迟子函数（晶振12MHz ）*******/
     
788. 
     
789. void delay_18B20(unsigned int i)
     
790. {
     
791.         while(i--);
     
792. }
     
793. 
     
794. /**********ds18b20初始化函数**********************/
     
795. 
     
796. void Init_DS18B20(void)
     
797. {
     
798.          unsigned char x=0;
     
799.          DQ = 1;          //DQ复位
     
800.          delay_18B20(8);  //稍做延时
     
801.          DQ = 0;          //单片机将DQ拉低
     
802.          delay_18B20(80); //精确延时 大于 480us
     
803.          DQ = 1;          //拉高总线
     
804.          delay_18B20(14);
     
805.          x=DQ;            //稍做延时后 如果x=0则初始化成功 x=1则初始化失败
     
806.          delay_18B20(20);
     
807. }
     
808. 
     
809. /***********ds18b20读一个字节**************/  
     
810. unsigned char ReadOneChar(void)
     
811. {
     
812.         uchar i=0;
     
813.         uchar dat = 0;
     
814.         for (i=8;i>0;i--)
     
815.          {
     
816.                   DQ = 0; // 给脉冲信号
     
817.                   dat>>=1;
     
818.                   DQ = 1; // 给脉冲信号
     
819.                   if(DQ)
     
820.                   dat|=0x80;
     
821.                   delay_18B20(4);
     
822.          }
     
823.          return(dat);
     
824. }
     
825. 
     
826. /*************ds18b20写一个字节****************/  
     
827. 
     
828. void WriteOneChar(uchar dat)
     
829. {
     
830.          unsigned char i=0;
     
831.          for (i=8; i>0; i--)
     
832.          {
     
833.                   DQ = 0;
     
834.                  DQ = dat&0x01;
     
835.             delay_18B20(5);
     
836.                  DQ = 1;
     
837.             dat>>=1;
     
838. }
     
839. }
     
840. 
     
841. /**************读取ds18b20当前温度************/
     
842. void ReadTemp(void)
     
843. {
     
844.         unsigned char a=0;
     
845.         unsigned char b=0;
     
846.         unsigned char t=0;
     
847. 
     
848.         Init_DS18B20();
     
849.         WriteOneChar(0xCC);            // 跳过读序号列号的操作
     
850.         WriteOneChar(0x44);         // 启动温度转换
     
851.         delay_18B20(100);       // this message is wery important
     
852.         Init_DS18B20();
     
853.         WriteOneChar(0xCC);         //跳过读序号列号的操作
     
854.         WriteOneChar(0xBE);         //读取温度寄存器等前两个就是温度
     
855.         delay_18B20(100);
     
856.         a=ReadOneChar();            //读取温度值低位
     
857.         b=ReadOneChar();                   //读取温度值高位
     
858.         temp_value=b<<4;
     
859.         temp_value+=(a&0xf0)>>4;               
     
860. }
     
861. void temp_to_str()   //温度数据转换成液晶字符显示
     
862. {
     
863.   TempBuffer[0]=temp_value/10+'0';  //十位
     
864.   TempBuffer[1]=temp_value%10+'0';  //个位
     
865.   TempBuffer[2]=0xdf;   //温度符号
     
866.   TempBuffer[3]='C';
     
867.   TempBuffer[4]='\0';
     
868. }
     
869. void Delay1ms(unsigned int count)
     
870. {
     
871.         unsigned int i,j;
     
872.         for(i=0;i<count;i++)
     
873.         for(j=0;j<120;j++);
     
874. }
     
875. /*延时子程序*/
     
876. void mdelay(uint delay)
     
877. {        uint i;
     
878.          for(;delay>0;delay--)
     
879.                    {for(i=0;i<62;i++) //1ms延时.
     
880.                        {;}
     
881.                    }
     
882. }
     
883. void outkey()                    //跳出调整模式,返回默认显示
     
884. { uchar Second;
     
885.   if(out==0||wireless_1==1)         
     
886.   { mdelay(8);
     
887.         count=0;
     
888.         hide_sec=0,hide_min=0,hide_hour=0,hide_day=0,hide_week=0,hide_month=0,hide_year=0;
     
889.         Second=Read1302(DS1302_SECOND);
     
890.     Write1302(0x8e,0x00); //写入允许
     
891.         Write1302(0x80,Second&0x7f);
     
892.         Write1302(0x8E,0x80);          //禁止写入
     
893.         done=0;           
     
894.         while(out==0);
     
895.         while(wireless_1==1);
     
896.   }
     
897. }
     
898. ///////////////////////////////////////////////////////////////////////
     
899. void Upkey()//升序按键
     
900. {           
     
901.                 Up=1;
     
902.                 if(Up==0||wireless_2==1)
     
903.                           {
     
904.                                    mdelay(8);
     
905.                                        switch(count)
     
906.                                           {case 1:
     
907.                              temp=Read1302(DS1302_SECOND);  //读取秒数
     
908.                                                                   temp=temp+1;  //秒数加1
     
909.                                   up_flag=1;    //数据调整后更新标志
     
910.                                                                   if((temp&0x7f)>0x59)   //超过59秒,清零
     
911.                                   temp=0;                                                                  
     
912.                                                                   break;
     
913.                                            case 2:
     
914.                              temp=Read1302(DS1302_MINUTE);  //读取分数
     
915.                                                                   temp=temp+1;  //分数加1
     
916.                                   up_flag=1;
     
917.                                                                   if(temp>0x59)          //超过59分,清零
     
918.                                                                   temp=0;
     
919.                                                                   break;
     
920.                                            case 3:
     
921.                              temp=Read1302(DS1302_HOUR);  //读取小时数
     
922.                                                                   temp=temp+1;  //小时数加1
     
923.                                   up_flag=1;
     
924.                                                                   if(temp>0x23)   //超过23小时,清零
     
925.                                                                   temp=0;
     
926.                                                                   break;
     
927.                                            case 4:
     
928.                              temp=Read1302(DS1302_WEEK);  //读取星期数
     
929.                                                                   temp=temp+1;  //星期数加1
     
930.                                   up_flag=1;
     
931.                                                                   if(temp>0x7)  
     
932.                                                                   temp=1;
     
933.                                                                   break;
     
934.                                            case 5:
     
935.                                  temp=Read1302(DS1302_DAY);  //读取日数
     
936.                                                                   temp=temp+1;  //日数加1
     
937.                                   up_flag=1;
     
938.                                                                   if(temp>0x31)
     
939.                                                                   temp=1;
     
940.                                                                   break;
     
941.                                            case 6:
     
942.                              temp=Read1302(DS1302_MONTH);  //读取月数
     
943.                                                                   temp=temp+1;  //月数加1
     
944.                                   up_flag=1;
     
945.                                                                   if(temp>0x12)
     
946.                                                                   temp=1;
     
947.                                                                   break;
     
948.                                            case 7:
     
949.                                temp=Read1302(DS1302_YEAR);  //读取年数
     
950.                                                                   temp=temp+1;  //年数加1
     
951.                                   up_flag=1;
     
952.                                                                   if(temp>0x85)
     
953.                                                                   temp=0;
     
954.                                                                   break;
     
955.                                                default:break;
     
956.                                           }
     
957.                                           
     
958.                                    while(Up==0);
     
959.                        while(wireless_2==1);
     
960.                                   }
     
961. }
     
962. ///////////////////////////////////////////////////////////////////////void Downkey()//降序按键
     
963. {            
     
964.                 Down=1;
     
965.             if(Down==0||wireless_3==1)
     
966.                           {
     
967.                                    mdelay(8);
     
968.                                      switch(count)
     
969.                                           {case 1:
     
970.                              temp=Read1302(DS1302_SECOND);  //读取秒数
     
971.                                                                   temp=temp-1;                                    //秒数减1
     
972.                                   down_flag=1;     //数据调整后更新标志
     
973.                                                                   if(temp==0x7f)     //小于0秒,返回59秒
     
974.                                                                   temp=0x59;
     
975.                                                                   break;
     
976.                                            case 2:
     
977.                              temp=Read1302(DS1302_MINUTE);  //读取分数
     
978.                                                                   temp=temp-1;  //分数减1
     
979.                                   down_flag=1;
     
980.                                                                   if(temp==-1)
     
981.                                                                   temp=0x59;      //小于0分,返回59分
     
982.                                                                   break;
     
983.                                            case 3:
     
984.                              temp=Read1302(DS1302_HOUR);  //读取小时数
     
985.                                                                   temp=temp-1;  //小时数减1
     
986.                                   down_flag=1;
     
987.                                                                   if(temp==-1)
     
988.                                                                   temp=0x23;
     
989.                                                                   break;
     
990.                                            case 4:
     
991.                              temp=Read1302(DS1302_WEEK);  //读取星期数
     
992.                                                                   temp=temp-1;  //星期数减1
     
993.                                   down_flag=1;
     
994.                                                                   if(temp==0)
     
995.                                                                   temp=0x7;;
     
996.                                                                   break;
     
997.                                            case 5:
     
998.                                  temp=Read1302(DS1302_DAY);  //读取日数
     
999.                                                                   temp=temp-1;  //日数减1
     
1000.                                   down_flag=1;
      
1001.                                                                   if(temp==0)
      
1002.                                                                   temp=31;
      
1003.                                                                   break;
      
1004.                                            case 6:
      
1005.                              temp=Read1302(DS1302_MONTH);  //读取月数
      
1006.                                                                   temp=temp-1;  //月数减1
      
1007.                                   down_flag=1;
      
1008.                                                                   if(temp==0)
      
1009.                                                                   temp=12;
      
1010.                                                                   break;
      
1011.                                            case 7:
      
1012.                                temp=Read1302(DS1302_YEAR);  //读取年数
      
1013.                                                                   temp=temp-1;  //年数减1
      
1014.                                   down_flag=1;
      
1015.                                                                   if(temp==-1)
      
1016.                                                                   temp=0x85;
      
1017.                                                                   break;
      
1018.                                               default:break;
      
1019.                                          }
      
1020.                                          
      
1021.                                    while(Down==0);
      
1022.                                    while(wireless_3==1);
      
1023.                                   }
      
1024. }
      
1025. void Setkey()//模式选择按键
      
1026. {
      
1027.                 Set=1;
      
1028.                 if(Set==0||wireless_4==1)
      
1029.             {
      
1030.            mdelay(8);
      
1031.            count=count+1;         //Setkey按一次,count就加1
      
1032.                    done=1;                         //进入调整模式
      
1033.            while(Set==0);
      
1034.            while(wireless_4==1);
      
1035.                  }
      
1036. }
      
1037. void keydone()//按键功能执行
      
1038. {        uchar Second;
      
1039.                  if(flag==0)    //关闭时钟,停止计时
      
1040.          { Write1302(0x8e,0x00); //写入允许
      
1041.            temp=Read1302(0x80);
      
1042.            Write1302(0x80,temp|0x80);
      
1043.                Write1302(0x8e,0x80); //禁止写入
      
1044.            flag=1;
      
1045.          }
      
1046.          Setkey();                                            //扫描模式切换按键
      
1047.                  switch(count)
      
1048.                  {case 1:do                                                //count=1,调整秒
      
1049.                           {
      
1050.                  outkey();                           //扫描跳出按钮
      
1051.                                    Upkey();                //扫描加按钮
      
1052.                                    Downkey();              //扫描减按钮
      
1053.                                  if(up_flag==1||down_flag==1)  //数据更新，重新写入新的数据
      
1054.                                    {
      
1055.                                    Write1302(0x8e,0x00); //写入允许
      
1056.                                    Write1302(0x80,temp|0x80); //写入新的秒数
      
1057.                                    Write1302(0x8e,0x80); //禁止写入
      
1058.                                    up_flag=0;
      
1059.                                    down_flag=0;
      
1060.                    }
      
1061. 
      
1062.                                    hide_sec++;          //位闪计数
      
1063.                                    if(hide_sec>3)
      
1064.                                     hide_sec=0;
      
1065.                    show_time();         //液晶显示数据
      
1066.                                   }while(count==2);break;  
      
1067.                   case 2:do                                                //count=2,调整分
      
1068.                           {
      
1069.                                    hide_sec=0;
      
1070.                                    outkey();
      
1071.                                    Upkey();
      
1072.                                    Downkey();
      
1073.                                    if(temp>0x60)
      
1074.                                      temp=0;
      
1075.                                    if(up_flag==1||down_flag==1)
      
1076.                                    {
      
1077.                                    Write1302(0x8e,0x00); //写入允许
      
1078.                                    Write1302(0x82,temp); //写入新的分数
      
1079.                                    Write1302(0x8e,0x80); //禁止写入
      
1080.                                    up_flag=0;
      
1081.                                    down_flag=0;
      
1082.                                    }
      
1083.                                    hide_min++;
      
1084.                                    if(hide_min>3)
      
1085.                                      hide_min=0;
      
1086.                    show_time();
      
1087.                                   }while(count==3);break;
      
1088.                   case 3:do                                                //count=3,调整小时
      
1089.                           {
      
1090.                    hide_min=0;
      
1091.                                    outkey();
      
1092.                                    Upkey();
      
1093.                                    Downkey();
      
1094.                                    if(up_flag==1||down_flag==1)
      
1095.                                    {
      
1096.                                    Write1302(0x8e,0x00); //写入允许
      
1097.                                    Write1302(0x84,temp); //写入新的小时数
      
1098.                                    Write1302(0x8e,0x80); //禁止写入
      
1099.                                    up_flag=0;
      
1100.                                    down_flag=0;
      
1101.                                    }
      
1102.                                    hide_hour++;
      
1103.                                    if(hide_hour>3)
      
1104.                                      hide_hour=0;
      
1105.                    show_time();
      
1106.                                   }while(count==4);break;
      
1107.                   case 4:do                                                //count=4,调整星期
      
1108.                           {
      
1109.                    hide_hour=0;
      
1110.                                    outkey();
      
1111.                                    Upkey();
      
1112.                                    Downkey();
      
1113.                                    if(up_flag==1||down_flag==1)
      
1114.                                    {
      
1115.                                    Write1302(0x8e,0x00); //写入允许
      
1116.                                    Write1302(0x8a,temp); //写入新的星期数
      
1117.                                    Write1302(0x8e,0x80); //禁止写入
      
1118.                                    up_flag=0;
      
1119.                                    down_flag=0;
      
1120.                                    }
      
1121.                                    hide_week++;
      
1122.                                    if(hide_week>3)
      
1123.                                      hide_week=0;
      
1124.                    show_time();
      
1125.                                   }while(count==5);break;
      
1126.                   case 5:do                                                //count=5,调整日
      
1127.                           {
      
1128.                                    hide_week=0;
      
1129.                                    outkey();
      
1130.                                    Upkey();
      
1131.                                    Downkey();
      
1132.                                    if(up_flag==1||down_flag==1)
      
1133.                                    {
      
1134.                                    Write1302(0x8e,0x00); //写入允许
      
1135.                                    Write1302(0x86,temp); //写入新的日数
      
1136.                                    Write1302(0x8e,0x80); //禁止写入
      
1137.                                    up_flag=0;
      
1138.                                    down_flag=0;
      
1139.                                    }
      
1140.                                    hide_day++;
      
1141.                                    if(hide_day>3)
      
1142.                                      hide_day=0;
      
1143.                    show_time();
      
1144.                                   }while(count==6);break;
      
1145.                   case 6:do                                                //count=6,调整月
      
1146.                           {
      
1147.                    hide_day=0;
      
1148.                                    outkey();
      
1149.                                    Upkey();
      
1150.                                    Downkey();
      
1151.                                    if(up_flag==1||down_flag==1)
      
1152.                                    {
      
1153.                                    Write1302(0x8e,0x00); //写入允许
      
1154.                                    Write1302(0x88,temp); //写入新的月数
      
1155.                                    Write1302(0x8e,0x80); //禁止写入
      
1156.                                    up_flag=0;
      
1157.                                    down_flag=0;
      
1158.                                    }
      
1159.                                    hide_month++;
      
1160.                                    if(hide_month>3)
      
1161.                                      hide_month=0;
      
1162.                    show_time();
      
1163.                                   }while(count==7);break;
      
1164.                   case 7:do                                                //count=7,调整年
      
1165.                           {
      
1166.                    hide_month=0;
      
1167.                                    outkey();
      
1168.                                    Upkey();
      
1169.                                    Downkey();
      
1170.                                    if(up_flag==1||down_flag==1)
      
1171.                                    {
      
1172.                                    Write1302(0x8e,0x00); //写入允许
      
1173.                                    Write1302(0x8c,temp); //写入新的年数
      
1174.                                    Write1302(0x8e,0x80); //禁止写入
      
1175.                                    up_flag=0;
      
1176.                                    down_flag=0;
      
1177.                                    }
      
1178.                                    hide_year++;
      
1179.                                    if(hide_year>3)
      
1180.                                      hide_year=0;
      
1181.                    show_time();
      
1182.                                   }while(count==8);break;
      
1183.                   case 8: count=0;hide_year=0;  // 跳出调整模式,返回默认显示状态
      
1184.                       Second=Read1302(DS1302_SECOND);
      
1185.                   Write1302(0x8e,0x00); //写入允许
      
1186.                       Write1302(0x80,Second&0x7f);
      
1187.                       Write1302(0x8E,0x80);          //禁止写入
      
1188.                                   done=0;
      
1189.                   break; //count=7,开启中断,标志位置0并退出
      
1190.                   default:break;
      
1191.                  }
      
1192. }
      
1193. void show_time()   //液晶显示程序
      
1194. {
      
1195.   DS1302_GetTime(&CurrentTime);  //获取时钟芯片的时间数据
      
1196.   TimeToStr(&CurrentTime);       //时间数据转换液晶字符
      
1197.   DateToStr(&CurrentTime);       //日期数据转换液晶字符
      
1198.   ReadTemp();                    //开启温度采集程序
      
1199.   temp_to_str();                 //温度数据转换成液晶字符
      
1200.   GotoXY(12,1);                  //液晶字符显示位置
      
1201.   Print(TempBuffer);             //显示温度
      
1202.   GotoXY(0,1);
      
1203.   Print(CurrentTime.TimeString); //显示时间
      
1204.   GotoXY(0,0);
      
1205.   Print(CurrentTime.DateString); //显示日期
      
1206.   GotoXY(15,0);
      
1207.   Print(week_value);             //显示星期
      
1208.   GotoXY(11,0);
      
1209.   Print("Week");        //在液晶上显示 字母 week
      
1210.   Delay1ms(400);                 //扫描延时
      
1211. }
      
1212. 
      
1213. main()
      
1214. {
      
1215.    flag=1;           //时钟停止标志
      
1216.         LCD_Initial();    //液晶初始化
      
1217.         Init_DS18B20( ) ;      //DS18B20初始化
      
1218.         Initial_DS1302(); //时钟芯片初始化
      
1219.         up_flag=0;
      
1220.         down_flag=0;
      
1221.         done=0;           //进入默认液晶显示
      
1222.         wireless_1=0;
      
1223.         wireless_2=0;
      
1224.         wireless_3=0;
      
1225.         wireless_4=0;
      
1226.         while(1)
      
1227.         {   
      
1228.         while(done==1)
      
1229.           keydone();    //进入调整模式
      
1230.                 while(done==0)
      
1231.              {  
      
1232.             show_time();                //液晶显示数据
      
1233.             flag=0;                  
      
1234.                       Setkey();                                 //扫描各功能键
      
1235. if((CurrentTime.TimeString[0]=='0'
      
1236. && CurrentTime.TimeString[1]=='7'
      
1237. && CurrentTime.TimeString[3]=='0'
      
1238. &&CurrentTime.TimeString[4]=='0')
      
1239. || (CurrentTime.TimeString[0]=='1'
      
1240. && CurrentTime.TimeString[1]=='1'
      
1241. &&CurrentTime.TimeString[3]=='0
      
1242. && CurrentTime.TimeString[4]=='0')
      
1243. ||(CurrentTime.TimeString[0]=='1'
      
1244. &&CurrentTime.TimeString[1]=='7'
      
1245. && CurrentTime.TimeString[3]=='0'
      
1246. && CurrentTime.TimeString[4]=='0') )  
      
1247. fanmang=0;
      
1248. else fanmang=1;
      
1249. if((CurrentTime.TimeString[0]=='0'
      
1250. && CurrentTime.TimeString[1]=='9'
      
1251. && CurrentTime.TimeString[3]=='0'
      
1252. &&CurrentTime.TimeString[4]=='0')
      
1253. || (CurrentTime.TimeString[0]=='1'
      
1254. && CurrentTime.TimeString[1]=='4'
      
1255. &&CurrentTime.TimeString[3]=='0'
      
1256.   && CurrentTime.TimeString[4]=='0')
      
1257. ||(CurrentTime.TimeString[0]=='1'
      
1258. &&CurrentTime.TimeString[1]=='9'
      
1259.   && CurrentTime.TimeString[3]=='0'
      
1260. && CurrentTime.TimeString[4]=='0') )  
      
1261.      zhengchang=0;
      
1262. else zhengchang=1;
      
1263.                  }
      
1264.         }
      
1265. }

复制代码

实物怎么做

.DSN是protues文件 需要安装7.5版本才能打开