蓝桥杯单片机第八届省赛真题及代码

最新推荐文章于 2024-04-08 06:30:00 发布
最新推荐文章于 2024-04-08 06:30:00 发布
阅读量764 收藏 9
点赞数 1
分类专栏： 蓝桥杯单片机比赛学习 文章标签： 单片机 蓝桥杯 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58872950/article/details/129895237
版权

 

 

 

代码： 

main.c

#include "key.h"
#include "timer.h"
#include "smg.h"
#include "onewire.h"
#include "ds1302.h"

void System_Init()
{
	Slect_573(0, 0x00);
	Slect_573(4, 0xff);
	Slect_573(5, 0x00);
	SMG_Display_All(0xff);
	Set_time(0x23, 0x59, 0x50);
	temp_init();
	Timer0Init();
}

void main()
{
	System_Init();
	while(1)
	{
		SMG_Display();
		key_scan();
		control();
	}
}

ds1302.c

/*	# 	DS1302代码片段说明
	1. 	本文件夹中提供的驱动代码供参赛选手完成程序设计参考。
	2. 	参赛选手可以自行编写相关代码或以该代码为基础，根据所选单片机类型、运行速度和试题
		中对单片机时钟频率的要求，进行代码调试和修改。
*/								

//
#include "ds1302.h"

void Write_Ds1302(unsigned  char temp) 
{
	unsigned char i;
	for (i=0;i<8;i++)     	
	{ 
		SCK = 0;
		SDA = temp&0x01;
		temp>>=1; 
		SCK=1;
	}
}   

//
void Write_Ds1302_Byte( unsigned char address,unsigned char dat )     
{
 	RST=0;	_nop_();
 	SCK=0;	_nop_();
 	RST=1; 	_nop_();  
 	Write_Ds1302(address);	
 	Write_Ds1302(dat);		
 	RST=0; 
}

//
unsigned char Read_Ds1302_Byte ( unsigned char address )
{
 	unsigned char i,temp=0x00;
 	RST=0;	_nop_();
 	SCK=0;	_nop_();
 	RST=1;	_nop_();
 	Write_Ds1302(address);
 	for (i=0;i<8;i++) 	
 	{		
		SCK=0;
		temp>>=1;	
 		if(SDA)
 		temp|=0x80;	
 		SCK=1;
	} 
 	RST=0;	_nop_();
 	SCK=0;	_nop_();
	SCK=1;	_nop_();
	SDA=0;	_nop_();
	SDA=1;	_nop_();
	return (temp);			
}

void Set_time(uchar hour, uchar min, uchar sec)
{
	Write_Ds1302_Byte(0x8e, 0x00);
	Write_Ds1302_Byte(0x80, sec);
	Write_Ds1302_Byte(0x82, min);
	Write_Ds1302_Byte(0x84, hour);
	Write_Ds1302_Byte(0x8e, 0x80);
}

char hour=0,min=0,sec=0; 
void Read_time()
{
	hour=Read_Ds1302_Byte(0x85);
	min=Read_Ds1302_Byte(0x83);
	sec=Read_Ds1302_Byte(0x81);
}

uchar F_timeout=0;
extern volatile char hour_param,min_param,sec_param;
extern volatile uint count1;

void control()
{
	if((hour_param==((hour/16)*10+hour%16))&&
		(min_param==((min/16)*10+min%16))&&
		(sec_param==((sec/16)*10+sec%16)))
	{
		F_timeout=1;
		count1=0;
		
	}
}

ds1302.h

#ifndef __DS1302_H
#define __DS1302_H

#include "stc15f2k60s2.h"
#include "intrins.h"
#include "smg.h"

sbit SCK=P1^7;
sbit SDA=P2^3;
sbit RST=P1^3;

#define   uchar  unsigned char
#define   uint   unsigned int

void Write_Ds1302(unsigned  char temp) ;
void Write_Ds1302_Byte( unsigned char address,unsigned char dat );
unsigned char Read_Ds1302_Byte ( unsigned char address );
void Set_time(uchar hour, uchar min, uchar sec);
void Read_time();
void control();

#endif

onewire.c

/*	# 	单总线代码片段说明
	1. 	本文件夹中提供的驱动代码供参赛选手完成程序设计参考。
	2. 	参赛选手可以自行编写相关代码或以该代码为基础，根据所选单片机类型、运行速度和试题
		中对单片机时钟频率的要求，进行代码调试和修改。
*/

#include "onewire.h"
void Delay_OneWire(unsigned int t)  
{
	unsigned char i;
	while(t--){
		for(i=0;i<12;i++);
	}
}

//
void Write_DS18B20(unsigned char dat)
{
	unsigned char i;
	for(i=0;i<8;i++)
	{
		DQ = 0;
		DQ = dat&0x01;
		Delay_OneWire(5);
		DQ = 1;
		dat >>= 1;
	}
	Delay_OneWire(5);
}

//
unsigned char Read_DS18B20(void)
{
	unsigned char i;
	unsigned char dat;
  
	for(i=0;i<8;i++)
	{
		DQ = 0;
		dat >>= 1;
		DQ = 1;
		if(DQ)
		{
			dat |= 0x80;
		}	    
		Delay_OneWire(5);
	}
	return dat;
}

//
bit init_ds18b20(void)
{
  	bit initflag = 0;
  	
  	DQ = 1;
  	Delay_OneWire(12);
  	DQ = 0;
  	Delay_OneWire(80);
  	DQ = 1;
  	Delay_OneWire(10); 
    initflag = DQ;     
  	Delay_OneWire(5);
  
  	return initflag;
}

void temp_init()
{
	uchar h,l;
	uint temp;
	
	init_ds18b20();
	Write_DS18B20(0xcc);
	Write_DS18B20(0x44);
	
	do{
		init_ds18b20();
		Write_DS18B20(0xcc);
		Write_DS18B20(0xbe);
		l=Read_DS18B20();
		h=Read_DS18B20();
		temp=(h<<8)|l;
	}while(temp==1360);
}

float Read_temp()
{
	uchar h,l;
	uint temp;
	float temp_f;
	
	init_ds18b20();
	Write_DS18B20(0xcc);
	Write_DS18B20(0x44);
	
	init_ds18b20();
	Write_DS18B20(0xcc);
	Write_DS18B20(0xbe);
	l=Read_DS18B20();
	h=Read_DS18B20();
	temp=(h<<8)|l;
	if((temp&0xf800)==0x00)
	{
		temp_f=temp*0.0625;
	}
	
	return temp_f;
	
}

onewire.h

#ifndef __ONEWIRE_H
#define __ONEWIRE_H

#include "stc15f2k60s2.h"
#include "smg.h"

sbit DQ=P1^4;

void Delay_OneWire(unsigned int t) ;
void Write_DS18B20(unsigned char dat);
unsigned char Read_DS18B20(void);
bit init_ds18b20(void);
void temp_init();
float Read_temp();

#endif

key.c

#include "key.h"

sbit s4=P3^3;
sbit s5=P3^2;
sbit s6=P3^1;
sbit s7=P3^0;

char hour_param=0,min_param=0,sec_param=0;
uchar key7_flag=0,key6_flag=0;
extern volatile uchar display_flag;
extern volatile char hour,min,sec;
extern volatile uchar F_timeout;
void key_scan()
{
	if(s4==0)//"-"
	{
		delay_ms(10);
		if(s4==0)
		{
			F_timeout=0;
			Slect_573(4, 0xff);
			
			if(key6_flag)//闹钟设置
			{
				if(key6_flag==1)//时
				{
					hour_param--;
					if(hour_param<0)
						hour_param=23;
				}
				if(key6_flag==2)//分
				{
					min_param--;
					if(min_param<0)
						min_param=59;
				}
				if(key6_flag==3)//秒
				{
					sec_param--;
					if(sec_param<0)
						sec_param=59;
				}
			}
			
			if(key7_flag)//时间设置
			{
				if(key7_flag==1)//时
				{
					hour=(hour/16)*10+hour%16;
					hour--;
					if(hour<0)
						hour=23;
					hour=(hour/10)*16+hour%10;
				}
				
				if(key7_flag==2)//分
				{
					min=(min/16)*10+min%16;
					min--;
					if(min<0)
						min=59;
					min=(min/10)*16+min%10;
				}
				
				if(key7_flag==3)//秒
				{
					sec=(sec/16)*10+sec%16;
					sec--;
					if(sec<0)
						sec=59;
					sec=(sec/10)*16+sec%10;
				}
				Set_time(hour, min, sec);
				
			}
			while(s4==0)
			{
				if((key6_flag==0)&&(key7_flag==0))
					display_flag=1;
				SMG_Display();
			}
			display_flag=0;
		}
	}
	
	
	if(s5==0)//"+"
	{
		delay_ms(10);
		if(s5==0)
		{
			F_timeout=0;
			Slect_573(4, 0xff);
			
			if(key6_flag)//闹钟设置
			{
				if(key6_flag==1)//时
				{
					hour_param++;
					if(hour_param>23)
						hour_param=0;
				}
				if(key6_flag==2)//分
				{
					min_param++;
					if(min_param>59)
						min_param=0;
				}
				if(key6_flag==3)//秒
				{
					sec_param++;
					if(sec_param>59)
						sec_param=0;
				}
			}
			
			if(key7_flag)//时间设置
			{
				if(key7_flag==1)//时
				{
					hour=(hour/16)*10+hour%16;
					hour++;
					if(hour>23)
						hour=0;
					hour=(hour/10)*16+hour%10;
				}
				
				if(key7_flag==2)//分
				{
					min=(min/16)*10+min%16;
					min++;
					if(min>59)
						min=0;
					min=(min/10)*16+min%10;
				}
				
				if(key7_flag==3)//秒
				{
					sec=(sec/16)*10+sec%16;
					sec++;
					if(sec>59)
						sec=0;
					sec=(sec/10)*16+sec%10;
				}
				Set_time(hour, min, sec);
			}
			while(s5==0)
			{
				SMG_Display();
			}
		}
	}
	
	
	if(s6==0)
	{
		delay_ms(10);
		if(s6==0)
		{
			F_timeout=0;
			Slect_573(4, 0xff);
			
			key6_flag++;
			if(key6_flag>3)
				key6_flag=0;
			while(s6==0)
			{
				SMG_Display();
			}
		}
	}
	
	
	if(s7==0)
	{
		delay_ms(10);
		if(s7==0)
		{
			F_timeout=0;
			Slect_573(4, 0xff);
			
				key7_flag++;
			if(key7_flag>3)
				key7_flag=0;
			
			while(s7==0)
			{
				SMG_Display();
			}
		}
	}
}

key.h

#ifndef __KEY_H
#define __KEY_H

#include "stc15f2k60s2.h"
#include "smg.h"

void key_scan();

#endif

smg.c

#include "smg.h"

//-------共阳数码管的段码编码表（无小数点）--------
unsigned char code SMG_NoDot[10]={0xc0,0xf9,
    0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
//-------共阳数码管的段码编码表（带小数点）--------
unsigned char code SMG_Dot[10]={0x40,0x79,
    0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};

void Delay1ms()		//@12.000MHz
{
	unsigned char i, j;

	i = 12;
	j = 169;
	do
	{
		while (--j);
	} while (--i);
}

void delay_ms(uint ms)
{
	while(ms--)
	{
		Delay1ms();
	}
}

void Slect_573(uchar channel, uchar dat)
{
	P0=dat;
	switch(channel)
	{
		case 4:
			P2=(P2&0X1F)|0X80;
		break;
		case 5:
			P2=(P2&0X1F)|0XA0;
		break;
		case 6:
			P2=(P2&0X1F)|0XC0;
		break;
		case 7:
			P2=(P2&0X1F)|0XE0;
		break;
		case 0:
			P2=(P2&0X1F)|0X00;
		break;
	}
	P2=(P2&0X1F)|0X00;
}

void SMG_Display_Bit(uchar pos, uchar value)
{
	Slect_573(6, 0x01<<pos-1);
	Slect_573(7, value);
	delay_ms(2);
	Slect_573(6, 0x01<<pos-1);
	Slect_573(7, 0xff);
}

void SMG_Display_All(uchar value)
{
	Slect_573(6, 0xff);
	Slect_573(7, value);
}

extern volatile char hour,min,sec;
extern volatile uchar key7_flag,key6_flag;
extern volatile uint count;
extern volatile char hour_param,min_param,sec_param;

uchar display_flag=0;

void SMG_Display()
{
	float temp_f=0;
	uint temp_smg=0;
	
	switch(display_flag)
	{
		case 0:
			if((key6_flag==0)&&(key7_flag==0))
			{
				Read_time();

				SMG_Display_Bit(1, SMG_NoDot[hour/16]);
				SMG_Display_Bit(2, SMG_NoDot[hour%16]);
				SMG_Display_Bit(3, 0xbf);
				SMG_Display_Bit(4, SMG_NoDot[min/16]);
				SMG_Display_Bit(5, SMG_NoDot[min%16]);
				SMG_Display_Bit(6, 0xbf);
				SMG_Display_Bit(7, SMG_NoDot[sec/16]);
				SMG_Display_Bit(8, SMG_NoDot[sec%16]);
			}
			if(key7_flag==1)
			{
				if(count<100)
				{
					SMG_Display_Bit(1, SMG_NoDot[hour/16]);
					SMG_Display_Bit(2, SMG_NoDot[hour%16]);
				}
				SMG_Display_Bit(3, 0xbf);
				SMG_Display_Bit(4, SMG_NoDot[min/16]);
				SMG_Display_Bit(5, SMG_NoDot[min%16]);
				SMG_Display_Bit(6, 0xbf);
				SMG_Display_Bit(7, SMG_NoDot[sec/16]);
				SMG_Display_Bit(8, SMG_NoDot[sec%16]);
			}
			if(key7_flag==2)
			{
				SMG_Display_Bit(1, SMG_NoDot[hour/16]);
				SMG_Display_Bit(2, SMG_NoDot[hour%16]);
				SMG_Display_Bit(3, 0xbf);
				if(count<100)
				{
					SMG_Display_Bit(4, SMG_NoDot[min/16]);
					SMG_Display_Bit(5, SMG_NoDot[min%16]);
				}
				SMG_Display_Bit(6, 0xbf);
				SMG_Display_Bit(7, SMG_NoDot[sec/16]);
				SMG_Display_Bit(8, SMG_NoDot[sec%16]);
			}
			if(key7_flag==3)
			{
				SMG_Display_Bit(1, SMG_NoDot[hour/16]);
				SMG_Display_Bit(2, SMG_NoDot[hour%16]);
				SMG_Display_Bit(3, 0xbf);
				SMG_Display_Bit(4, SMG_NoDot[min/16]);
				SMG_Display_Bit(5, SMG_NoDot[min%16]);
				SMG_Display_Bit(6, 0xbf);
				if(count<100)
				{
					SMG_Display_Bit(7, SMG_NoDot[sec/16]);
					SMG_Display_Bit(8, SMG_NoDot[sec%16]);
				}
			}
			
			if(key6_flag==1)
			{
				SMG_Display_Bit(1, SMG_NoDot[hour_param/10]);
				SMG_Display_Bit(2, SMG_NoDot[hour_param%10]);
				SMG_Display_Bit(3, 0xbf);
				SMG_Display_Bit(4, SMG_NoDot[min_param/10]);
				SMG_Display_Bit(5, SMG_NoDot[min_param%10]);
				SMG_Display_Bit(6, 0xbf);
				SMG_Display_Bit(7, SMG_NoDot[sec_param/10]);
				SMG_Display_Bit(8, SMG_NoDot[sec_param%10]);
			}
			if(key6_flag==2)
			{
				SMG_Display_Bit(1, SMG_NoDot[hour_param/10]);
				SMG_Display_Bit(2, SMG_NoDot[hour_param%10]);
				SMG_Display_Bit(3, 0xbf);
				SMG_Display_Bit(4, SMG_NoDot[min_param/10]);
				SMG_Display_Bit(5, SMG_NoDot[min_param%10]);
				SMG_Display_Bit(6, 0xbf);
				SMG_Display_Bit(7, SMG_NoDot[sec_param/10]);
				SMG_Display_Bit(8, SMG_NoDot[sec_param%10]);
			}
			if(key6_flag==3)
			{
				SMG_Display_Bit(1, SMG_NoDot[hour_param/10]);
				SMG_Display_Bit(2, SMG_NoDot[hour_param%10]);
				SMG_Display_Bit(3, 0xbf);
				SMG_Display_Bit(4, SMG_NoDot[min_param/10]);
				SMG_Display_Bit(5, SMG_NoDot[min_param%10]);
				SMG_Display_Bit(6, 0xbf);
				SMG_Display_Bit(7, SMG_NoDot[sec_param/10]);
				SMG_Display_Bit(8, SMG_NoDot[sec_param%10]);
			}
			
		break;
		
		case 1:
			temp_f=Read_temp();
			temp_smg=temp_f;
			SMG_Display_Bit(6, SMG_NoDot[temp_smg/10]);
			SMG_Display_Bit(7, SMG_NoDot[temp_smg%10]);
			SMG_Display_Bit(8, 0xc6);
		break;
	}
	
}

smg.h

#ifndef __SMG_H
#define __SMG_H

#include "stc15f2k60s2.h"
#include "onewire.h"
#include "ds1302.h"

#define   uchar  unsigned char
#define   uint   unsigned int

void Delay1ms();
void delay_ms(uint ms);
void Slect_573(uchar channel, uchar dat);
void SMG_Display_Bit(uchar pos, uchar value);
void SMG_Display_All(uchar value);
void SMG_Display();

#endif

timer.c

#include "timer.h"

void Timer0Init(void)		//10毫秒@12.000MHz
{
	AUXR &= 0x7F;		//定时器时钟12T模式
	TMOD &= 0xF0;		//设置定时器模式
	TL0 = 0xF0;		//设置定时初值
	TH0 = 0xD8;		//设置定时初值
	TF0 = 0;		//清除TF0标志
	TR0 = 1;		//定时器0开始计时
	
	EA=1;
	ET0=1;
	
}

uchar led_stat=0xff;
uint count=0,count1=0;
extern volatile uchar F_timeout;

void Timer0()  interrupt 1
{
	count++;
	count1++;
	if(count==200)
		count=0;
	if(F_timeout==1)
	{
		if(count1==20)
		{
			count1=0;
			if(led_stat&0x01==0x01)
				led_stat &= ~0x01; 
			else
				led_stat |= 0x01;
			Slect_573(4, led_stat);
		}
	}
	
}

timer.h

#ifndef __TIMER_H
#define __TIMER_H

#include "stc15f2k60s2.h"
#include "smg.h"

void Timer0Init(void);

#endif

Do My Best
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第八届蓝桥杯单片机省赛题目解析
qq_53221728的博客
08-26 8851
第八届蓝桥杯单片机省赛题目解析 这次题目还是一样用到了三大模块（按键、LED、数码管），还用了实时时钟（DS1302）和DS18B20。其中DS18B20上一届也考过。这里面的单个模块都不难，题目也很好理解，写题目最重要的就是自己的思路和逻辑是否正确了。 1 数码管显示 数码管就只有两种模式显示，一种是时钟显示，另一种是闹钟显示，分别通过按键s7，s6来控制。 2 LED显示 当时钟和闹钟的值一致时，L1以0.2秒为
蓝桥杯备赛学习笔记（第八届省赛）
m0_75111375的博客
01-23 638
DS18B20是我们进阶要学习的一个外设，下面是温度转换和读取的流程，第二张是对于正温度和负温度做的处理，我给出的示例代码是只读取温度的整数部分，小数部分直接舍去，比赛很少有读取小数的情况，所以第二张图大家了解就可以。最后是实时更新时间的代码，把从地址读出的数据放回到存储数组中，就可以实时更新，在比赛中ds1302，ds18b20的驱动函数都会给出，大家不用担心还要自己写驱动的问题！巧妙地运用了位运算，在历年的真题中数码管显示都是重中之重的，请大家仔细学习！以下学习内容来自小蜜蜂老师！
蓝桥杯单片机第八届省赛程序简化
2301_76250094的博客
04-08 207
【代码】蓝桥杯单片机第八届省赛程序简化。
蓝桥杯单片机第八届省赛程序设计题
2301_80600743的博客
01-18 489
更多详细代码🐧983954083。
蓝桥杯单片机第8届省赛程序题参考答案
因心，三人水的博客
02-11 1799
蓝桥杯单片机第8届省赛程序题参考答案
蓝桥杯单片机第八届省赛——源码及设计思路
Sol-itude的博客
03-30 1093
距离蓝桥杯省赛还有10天，要抓紧练习了，不知道是这一届简单还是自己厉害了的原因，用了一天就做出来了，还是叫大佬帮了一个小忙，时间也不少，还能再做几届。 废话不多说，先看原题 MAIN.C #include<reg51.h> #include<onewire.h> #include<intrins.h> #define uchar unsigned char #define uint unsigned int sfr AUXR = 0x8e; sfr T2H =
蓝桥杯单片机第八届省赛真题
02-28
基于单片机的电子时钟
2016第八届蓝桥杯省赛试题及答案
02-17
2016第八届蓝桥杯省赛试题及答案
蓝桥杯单片机第八届初赛试题-电子钟-工程代码
05-19
蓝桥杯单片机第八届初赛试题-电子钟-工程代码，已实现题目所有要求，压缩包内是完整的工程文件，希望能够帮助到大家。
蓝桥杯第十一届省赛准备之历年真题.zip
02-15
为准备十一届蓝桥杯省赛，我历经千辛万苦收集了部分历年的省赛真题。该试题集供南昌大学以及其他高等院校的同学下载使用，不收取任何积分！
蓝桥杯第十五届电子赛省赛单片机组真题压缩包
最新发布
04-13
蓝桥杯第十五届电子赛省赛单片机组真题压缩包
第8届蓝桥杯单片机省赛-客观题参考答案与解析.pdf
08-05
第8届蓝桥杯单片机省赛-客观题参考答案与解析.pdf
蓝桥杯单片机组第八届省赛-电子时钟
03-23
蓝桥杯单片机组省赛，第八届数字电子时钟，功能全部实现，带注释
第八届蓝桥杯大赛省赛（电子类）资源数据包（单片机）
07-14
河南省第八届蓝桥杯大赛省赛（电子类）资源数据包 单片机版本
第八届蓝桥杯省赛试题及代码
05-10
作者参加第八届蓝桥杯，平时自己练习的源代码，希望可以给下一届学弟学妹参考，其中可能有需要改进的地方，仅供参考。
蓝桥杯单片机省赛 第八届（代码+分析）
tuygre的博客
03-06 4129
蓝桥杯电子类单片机 2022年备赛 南京信息工程大学 代码 注释
8届蓝桥杯单片机省赛
m0_54929728的博客
03-30 604
main.c #include "sys.h" #include "ds1302.h" void main() { InitSystem(); Timer0Init(); Set_DS1302(); while(1) { KeyScans(); Get_DS1302(); DisplaySMG(); if(led_k) { if(led) OperateLed(1,0); else OperateLed(1,1); } ...
蓝桥杯单片机9届省赛真题
04-07
很高兴为您介绍蓝桥杯单片机9届省赛真题。蓝桥杯是中国最具影响力的计算机学与技术竞赛之一，旨培养和选拔优秀的计算机人才。单片机是其中一个比赛项目，要求参赛选手在规定时间内完成一系列的编程任务。 以下是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Do My Best

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值