蓝桥杯之单片机设计与开发（28）——2013_第四届_蓝桥杯_省赛——“模拟智能灌溉系统”

冷不防 2022-03-10 17:46 249阅读 0赞

昨天还在跟小傻子说不会同时用到DS1302、DS18B20、AD、E2PROM三个及以上模块，今天就被啪啪打脸。=，=

### 1、题目 ###

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hpYW9tb19oYWE_size_16_color_FFFFFF_t_70][] ###

![20190311164729115.png][]

虽然这个题用到了DS1302、AD、E2PROM等三个模块，但是真的很简单。我在调试的过程中，由于记错了蜂鸣器和继电器的控制管脚，导致这俩货一直不能正常工作，后来差了原理图才发现自己记错了。

蜂鸣器buzz是P06控制，继电器relay是P04控制。

### 2、代码 ###

下载链接：[https://download.csdn.net/download/xiaomo\_haa/11012084][https_download.csdn.net_download_xiaomo_haa_11012084]

main.c

#include <stc15.h>
    #include "sys.h"
    
    bit mode = 1;			//0-手动模式，1-自动模式
    bit flag_buzz = 1, flag_relay = 0;
    bit flag_option = 0, flag_write = 0;
    bit flag_100ms = 0;
    u8 wet_value = 50, real_wet;
    u8 Realtime[] = {0x19, 0x03, 0x11, 0x08, 0x30, 0x00, 0x02};
    
    void main(void)
    {
    	static u8 index = 0;
    	
    	All_Init();
    	InitDS1302();
    	Timer0Init();
    	
    	if(Read_E2PROM(0) == 0x12)
    		wet_value = Read_E2PROM(1);
    	
    	EA = 1;
    	while(1)
    	{
    		if(flag_100ms)
    		{
    			flag_100ms = 0;
    			
    			//更新时间程序
    			real_wet = Read_AIN(0x03);
    			GetRealTime(Realtime);
    			
    			//写E2PROM程序
    			if(flag_write == 1)
    			{
    				if(index == 0)
    					Write_E2PROM(index, 0x12);
    				else if(index == 1)
    				{
    					Write_E2PROM(index, wet_value);
    					flag_write = 0;
    					index = 0;
    				}
    				index ++;
    			}
    		}
    		
    		Key_press();
    		Nixie_Show();
    	}
    }

sys.c

#include "sys.h"
    
    
    void All_Init(void)
    {
    	P2 = (P2 & 0x1f) | 0x80;	//打开Y4C（LED）
    	P0 = 0xff;			//关闭LED
    	P2 = (P2 & 0x1f) | 0xe0;	//打开Y7C（数码管）
    	P0 = 0xff;			//关闭数码管
    	P2 = (P2 & 0x1f) | 0xa0;	//打开Y5C
    	P0 = 0x00;			//关闭蜂鸣器、继电器
    	P2 = P2 & 0x1f;			//关闭所有使能
    }
    	
    void Timer0Init(void)		//2毫秒@11.0592MHz
    {
    	AUXR |= 0x80;		//定时器时钟1T模式
    	TMOD &= 0xF0;		//设置定时器模式
    	TL0 = 0x9A;		//设置定时初值
    	TH0 = 0xA9;		//设置定时初值
    	TF0 = 0;		//清除TF0标志
    	TR0 = 1;		//定时器0开始计时
    	ET0 = 1;
    }
    
    void Timer0(void) interrupt 1
    {
    	static u8 T0count1 = 0;
    	
    	//100ms定时程序
    	T0count1 ++;
    	if(T0count1 >= 50)			//100ms
    	{
    		T0count1 = 0;
    		flag_100ms = 1;
    	}
    	
    	if(flag_option == 0)
    		Working_control();
    	
    	Nixie_Scan();
    	Key_Scan();
    }
    
    void Working_control(void)
    {	
    	//手动模式继电器控制程序
    	if((mode == 0) && (flag_relay == 1))
    	{
    		Led_illume(0xfe);
    		P0 = 0x00;
    		P04 = 1;			//打开继电器
    		P2 = (P2 & 0x1f) | 0xa0;	//打开Y5C
    		P2 = P2 & 0x1f;			//关闭所有使能
    	}
    	else if((mode == 0) && (flag_relay == 0))
    	{
    		Led_illume(0xff);
    		P0 = 0x00;
    		P04 = 0;			//关闭继电器
    		P2 = (P2 & 0x1f) | 0xa0;	//打开Y5C
    		P2 = P2 & 0x1f;			//关闭所有使能
    	}
    	
    	//手动模式蜂鸣器控制程序
    	if((real_wet < wet_value) && (flag_buzz == 1) && (mode == 0))
    	{
    		P2 = (P2 & 0x1f) | 0xa0;	//打开Y5C
    		P06 = 1;			//打开蜂鸣器
    		P2 = P2 & 0x1f;			//关闭所有使能
    	}
    	else if(((real_wet >= wet_value) || (flag_buzz == 0)) && (mode == 0))
    	{
    		P06 = 0;			//关闭蜂鸣器
    		P2 = (P2 & 0x1f) | 0xa0;	//打开Y5C
    		P2 = P2 & 0x1f;			//关闭所有使能
    	}
    	
    	//自动模式继电器控制程序
    	if((real_wet < wet_value) && (mode == 1))
    	{
    		Led_illume(0xfd);
    		P0 = 0x00;
    		P04 = 1;			//打开继电器
    		P2 = (P2 & 0x1f) | 0xa0;	//打开Y5C
    		P2 = P2 & 0x1f;			//关闭所有使能
    	}
    	else if((real_wet >= wet_value) && (mode == 1))
    	{
    		Led_illume(0xff);
    		P0 = 0x00;
    		P04 = 0;			//关闭继电器
    		P2 = (P2 & 0x1f) | 0xa0;	//打开Y5C
    		P2 = P2 & 0x1f;			//关闭所有使能
    	}
    }

sys.h

#ifndef _SYS_H_
    #define _SYS_H_
    
    typedef unsigned char u8;
    typedef unsigned int u16;
    typedef unsigned long u32;
    
    #include <stc15.h>
    #include <intrins.h>
    #include "ds1302.h"
    #include "iic.h"
    
    extern bit mode;
    extern bit flag_buzz, flag_relay;
    extern bit flag_option, flag_write;
    extern bit flag_100ms;
    extern u8 wet_value, real_wet;
    extern u8 Realtime[];
    
    
    //function
    void All_Init(void);
    void Timer0Init(void);
    void Working_control(void);
    
    void Key_Scan(void);
    void Key_drive(u8 key);
    void Key_press(void);
    
    void Nixie_Scan(void);
    void Nixie_Show(void);
    unsigned char BCDToNum(unsigned char bcd);
    void Led_illume(u8 dat);
    
    #endif

key.c

#include "sys.h"
    
    u8 KeySta[] = {1, 1, 1, 1};			//键值存储区
    u8 Keybackup[] = {1, 1, 1, 1};	//键值备份区
    
    sbit S4 = P3^3;
    sbit S5 = P3^2;
    sbit S6 = P3^1;
    sbit S7 = P3^0;
    
    //按键扫描函数，在定时器中断里调用
    void Key_Scan(void)
    {
    	static u8 Keybuff[] = {0xff, 0xff, 0xff, 0xff};	//按键缓冲区
    	u8 i = 0;
    	
    	Keybuff[0] = (Keybuff[0] << 1) | S7;
    	Keybuff[1] = (Keybuff[1] << 1) | S6;
    	Keybuff[2] = (Keybuff[2] << 1) | S5;
    	Keybuff[3] = (Keybuff[3] << 1) | S4;
    	
    	for(i = 0; i < 4; i++)
    	{
    		if(Keybuff[i] == 0xff)				//按键松开
    			KeySta[i] = 1;
    		else if(Keybuff[i] == 0x00)		//按键按下
    			KeySta[i] = 0;
    		else				//键值不稳定
    		{}
    	}
    }
    
    void Key_drive(u8 key)
    {
    	//手动模式
    	if(mode == 0)	
    	{
    		if(key == 0)			//S7 切换工作状态
    			mode = 1;
    		else if(key == 1)	//S6 开关蜂鸣器
    			flag_buzz = ~flag_buzz;
    		else if(key == 2)	//S5 打开灌溉系统
    			flag_relay = 1;
    		else if(key == 3)	//S4 关闭灌溉系统
    			flag_relay = 0;
    	}
    	
    	//自动模式
    	else if(mode == 1)
    	{
    		if(key == 0)			//切换工作状态
    			mode = 0;
    		else if(key == 1)	//S6 湿度阈值调整按键
    		{
    			if(flag_option == 0)			//进入设置模式
    				flag_option = 1;
    			else if(flag_option == 1)	//退出设置模式并写E2PROM
    			{
    				flag_option = 0;
    				flag_write = 1;
    			}
    		}
    		else if((key == 2) && (flag_option == 1))	//S5 +1
    		{
    			wet_value ++;
    			if(wet_value >= 99)
    				wet_value = 99;
    		}
    		else if((key == 3) && (flag_option == 1))	//S4 -1
    		{
    			wet_value --;
    			if(wet_value <= 0)
    				wet_value = 0;
    		}
    	}
    }
    
    //检测按键是否按下，在main函数调用
    void Key_press(void)
    {
    	u8 i;
    	
    	for(i = 0; i < 4; i ++)
    	{
    		if(KeySta[i] != Keybackup[i])
    		{
    			if(Keybackup[i] != 0)		//按键松开时操作
    				Key_drive(i);
    			Keybackup[i] = KeySta[i];
    		}
    	}
    }

display.c

#include "sys.h"
    
    u8 code Nixie[] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 
    		0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e, 
    		0xff, 0xbf};	//共阳数码管码字
    u8 NixieBuff[] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};	//数码管显示缓冲区，初值0xff确保启动时都不亮
    
    u8 smg1,smg2,smg3,smg4,smg5,smg6,smg7,smg8;
    
    //数码管显示
    void Nixie_Scan(void)
    {
    	static u8 index = 0;
    	
    	P2 = (P2 & 0x1f) | 0xe0;	//数码管消隐
    	P0 =0xff;
    	
    	P2 = (P2 & 0x1f) | 0xc0;	//数码管片选
    	P0 = 0x01 << index;
    	
    	P2 = (P2 & 0x1f) | 0xe0;	//数码管段选
    	P0 = NixieBuff[index];
    	P2 &= 0x1f;
    	index ++;
    	index &= 0x07;
    }
    
    //数码管显示
    void Nixie_Show(void)
    {
    	if(flag_option == 0)
    	{
    		smg1 = BCDToNum(Realtime[3]) / 10;
    		smg2 = BCDToNum(Realtime[3]) % 10;
    		if((BCDToNum(Realtime[5]) % 10) % 2 == 0)
    			smg3 = 17;
    		else
    			smg3 = 16;
    		smg4 = BCDToNum(Realtime[4]) / 10;
    		smg5 = BCDToNum(Realtime[4]) % 10;
    		smg6 = 16;
    		smg7 = real_wet / 10;
    		smg8 = real_wet % 10;
    	}
    	else if(flag_option == 1)
    	{
    		smg1 = smg2 = 17;
    		smg3 = smg4 = smg5 = smg6 = 16;
    		smg7 = wet_value / 10;
    		smg8 = wet_value % 10;
    	}
    	
    	NixieBuff[0] = Nixie[smg1];
    	NixieBuff[1] = Nixie[smg2];
    	NixieBuff[2] = Nixie[smg3];
    	NixieBuff[3] = Nixie[smg4];
    	NixieBuff[4] = Nixie[smg5];
    	NixieBuff[5] = Nixie[smg6];
    	NixieBuff[6] = Nixie[smg7];
    	NixieBuff[7] = Nixie[smg8];
    }
    
    unsigned char BCDToNum(unsigned char bcd)
    {
    	unsigned char a, b;
    	
    	a = (bcd >> 4);
    	b = bcd & 0x0f;
    	
    	return (a * 10 + b);
    }
    
    void Led_illume(u8 dat)
    {
    	P0 = 0xff;
    	P2 = (P2 & 0x1f) | 0x80;	//打开Y4C（LED）
    	P0 = dat;					//点亮LED
    	P2 = P2 & 0x1f;
    }

ds1302.c

#include "sys.h"
    
    sbit DS1302_IO = P2^3;
    sbit DS1302_CK = P1^7;
    sbit DS1302_CE = P1^3;
    
    void DS1302ByteWrite(unsigned char dat) 
    {
    	unsigned char mask;
    	DS1302_IO = 1;					//拉低IO总线
    	for(mask = 0x01; mask != 0; mask <<= 1)	//低位在前，逐位移出
    	{
    		if((dat&mask) != 0)		//首先输出该位数据
    			DS1302_IO = 1;
    		else
    			DS1302_IO = 0;
    		DS1302_CK = 1;				//拉高时钟线
    		DS1302_CK = 0;				//拉低时钟线，完成一个位的操作
    	}
    	DS1302_IO = 1;  				//写完之后确保释放IO总线
    }  
    
    unsigned char DS1302ByteRead(void)
    {
    	unsigned char mask, dat = 0;
    	
    	for(mask = 0x01; mask != 0; mask <<= 1)	//低位在前，逐位读取
    	{
    		if(DS1302_IO)			//首先读取此时的IO引脚，并设置dat中的对应位
    			dat |= mask;
    
    		DS1302_CK = 1;		//拉高时钟
    		DS1302_CK = 0;		//再拉低时钟，完成一个位的操作
    	}
    	return dat;					//返回读到的字节数据
    } 
    
    void DS1302SingleWrite(unsigned char reg, unsigned char dat)     
    {
    	DS1302_CE = 1;					//使能片选信号
    	DS1302ByteWrite((reg << 1) | 0x80);	//发送写寄存器指令
    	DS1302ByteWrite(dat);		//写入字节数据
    	DS1302_CE = 0;					//除能片选信号
    }
    
    unsigned char DS1302SingleRead(unsigned char reg)
    {
    	unsigned char dat;
    	
    	DS1302_CE = 1;					//使能片选信号
    	DS1302ByteWrite((reg << 1) | 0x81);	//发送读寄存器指令
    	dat = DS1302ByteRead();	//读取字节数据
    	DS1302_CE = 0;					//除能片选信号
    	
    	DS1302_IO = 0;					//单字节读必须加的！
    	
    	return dat;         
    }
    
    void DS1302BurstWrite(unsigned char *dat)
    {
    	unsigned char i;
    	
    	DS1302_CE = 1;
    	DS1302ByteWrite(0xBE);				//发送突发写寄存器指令
    	for(i = 0; i < 7; i ++)				//连续写入8字节数据
    		DS1302ByteWrite(*dat++);        
    	DS1302_CE = 0;      
    }
    
    void DS1302BurstRead (unsigned char *dat)
    {
    	unsigned char i;
    	
    	DS1302_CE = 1;
    	DS1302ByteWrite(0xBF);				//发送突发读寄存器指令
    	for(i = 0; i < 7; i++)				//连续读取8个字节
    		dat[i] = DS1302ByteRead();      
    	DS1302_CE = 0;  
    	
    	DS1302_IO = 0;								//突发读必须加
    }	
    
    void GetRealTime(unsigned char *time)
    {
    	unsigned char buf[8];
    	
    	DS1302BurstRead(buf);
    	time[0] = buf[6];
    	time[1] = buf[4];
    	time[2] = buf[3];
    	time[3] = buf[2];
    	time[4] = buf[1];
    	time[5] = buf[0];
    	time[6] = buf[5];
    }
    
    void SetRealTime(unsigned char *time)
    {
    	unsigned char buf[8];
    	
    	buf[7] = 0;
    	buf[6] = time[0];
    	buf[4] = time[1];
    	buf[3] = time[2];
    	buf[2] = time[3];
    	buf[1] = time[4];
    	buf[0] = time[5];
    	buf[5] = time[6];
    	DS1302BurstWrite(buf);
    }
    
    void InitDS1302(void)
    {
    	unsigned char dat;
    	signed char i = 7;
    	unsigned char timeinit[8] = {0x19, 0x03, 0x11, 0x08, 0x30, 0x00, 0x02};
    	
    	DS1302_CE = 0;								//初始化DS1302通信引脚
    	DS1302_CK = 0;
    	dat = DS1302SingleRead(0);			//读取秒寄存器
    	DS1302SingleWrite(7, 0x00);  	//撤销写保护以允许写入数据
    	SetRealTime(&timeinit);					//设置DS1302时间
    	DS1302SingleWrite(7, 0x80);  	//写保护以禁止写入数据
    }

ds1302.h

#ifndef __DS1302_H
    #define __DS1302_H
    
    void DS1302ByteWrite(unsigned char dat);
    unsigned char DS1302ByteRead(void);
    void DS1302SingleWrite(unsigned char reg, unsigned char dat);
    unsigned char DS1302SingleRead(unsigned char reg);
    void DS1302BurstWrite(unsigned char *dat);
    void DS1302BurstRead (unsigned char *dat);
    void GetRealTime(unsigned char *time);
    void SetRealTime(unsigned char *time);
    void InitDS1302(void);
    
    #endif

iic.c

#include "sys.h"
    
    #define somenop {_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();}    
    
    //总线引脚定义
    sbit SDA = P2^1;  /* 数据线 */
    sbit SCL = P2^0;  /* 时钟线 */
    
    //总线启动条件
    void IIC_Start(void)
    {
    	SDA = 1;
    	SCL = 1;
    	somenop;
    	SDA = 0;
    	somenop;
    	SCL = 0;	
    }
    
    //总线停止条件
    void IIC_Stop(void)
    {
    	SDA = 0;
    	SCL = 1;
    	somenop;
    	SDA = 1;
    }
    
    //应答位控制
    void IIC_Ack(bit ackbit)
    {
    	if(ackbit) 
    	{	
    		SDA = 0;
    	}
    	else 
    	{
    		SDA = 1;
    	}
    	somenop;
    	SCL = 1;
    	somenop;
    	SCL = 0;
    	SDA = 1; 
    	somenop;
    }
    
    //等待应答
    bit IIC_WaitAck(void)
    {
    	SDA = 1;
    	somenop;
    	SCL = 1;
    	somenop;
    	if(SDA)    
    	{   
    		SCL = 0;
    		IIC_Stop();
    		return 0;
    	}
    	else  
    	{ 
    		SCL = 0;
    		return 1;
    	}
    }
    
    //通过I2C总线发送数据
    void IIC_SendByte(unsigned char byt)
    {
    	unsigned char i;
    	for(i=0;i<8;i++)
    	{   
    		if(byt&0x80) 
    		{	
    			SDA = 1;
    		}
    		else 
    		{
    			SDA = 0;
    		}
    		somenop;
    		SCL = 1;
    		byt <<= 1;
    		somenop;
    		SCL = 0;
    	}
    }
    
    //从I2C总线上接收数据
    unsigned char IIC_RecByte(void)
    {
    	unsigned char da;
    	unsigned char i;
    	
    	for(i=0;i<8;i++)
    	{   
    		SCL = 1;
    		somenop;
    		da <<= 1;
    		if(SDA) 
    		da |= 0x01;
    		SCL = 0;
    		somenop;
    	}
    	return da;
    }
    
    unsigned char Read_AIN(unsigned char chn)
    {
    	unsigned char dat, val;
    	EA = 0;
    	IIC_Start();						//IIC总线起始信号							
    	IIC_SendByte(0x90);			//PCF8591的写设备地址		
    	IIC_WaitAck();  		    //等待从机应答		
    	IIC_SendByte(chn); 			//写入PCF8591的控制字节		
    	IIC_WaitAck();  				//等待从机应答						
    	IIC_Stop(); 						//IIC总线停止信号					
    	
    	IIC_Start();						//IIC总线起始信号									
    	IIC_SendByte(0x91); 	  //PCF8591的读设备地址		
    	IIC_WaitAck(); 			    //等待从机应答		
    	dat = IIC_RecByte();	  //读取PCF8591通道3的数据 			
    	IIC_Ack(0); 						//产生非应答信号				
    	IIC_Stop(); 						//IIC总线停止信号		
    	val = (dat * 50) / 255;
    	val *= 2;
    	EA = 1;
    	
    	if(val >= 100)
    		val = 99;
    	
    	return val;	
    }
    
    void Write_E2PROM(unsigned char add, unsigned char dat)
    {
    	EA = 0;
      IIC_Start();
      IIC_SendByte(0xa0);	//发送器件地址
      IIC_WaitAck();
      IIC_SendByte(add);	//发送操作地址
      IIC_WaitAck();
      IIC_SendByte(dat);	//写一字节
      IIC_WaitAck();
      IIC_Stop();
      somenop;
    	EA = 1;
    }
    
    unsigned char Read_E2PROM(unsigned char add)
    {
      unsigned char d;
    	
    	IIC_Start();
    	IIC_SendByte(0xa0); 	//发送器件地址
    	IIC_WaitAck();
    	IIC_SendByte(add);		//发送要操作的地址
    	IIC_WaitAck();
    	IIC_Stop();
    	
    	IIC_Start();
    	IIC_SendByte(0xa1);		//发送读操作
    	IIC_WaitAck();
    	d = IIC_RecByte();	//读一字节
    	IIC_Ack(0);
    	IIC_Stop();
    	return d;
    }

iic.h

#ifndef _IIC_H
    #define _IIC_H
    
    //函数声明
    void IIC_Start(void); 
    void IIC_Stop(void);  
    void IIC_Ack(bit ackbit); 
    void IIC_SendByte(unsigned char byt); 
    bit IIC_WaitAck(void);  
    unsigned char IIC_RecByte(void); 
    unsigned char Read_AIN(unsigned char chn);
    void Write_E2PROM(unsigned char add, unsigned char dat);
    unsigned char Read_E2PROM(unsigned char add);
    
    #endif

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hpYW9tb19oYWE_size_16_color_FFFFFF_t_70]: /images/20220310/cb10390325f546059662b8947872d13e.png
[20190311164729115.png]: /images/20220310/bbec31efd177486d9fc3d778ddaf0e7b.png
[https_download.csdn.net_download_xiaomo_haa_11012084]: https://download.csdn.net/download/xiaomo_haa/11012084