蓝桥杯-单片机基础20——第14届省赛真题代码详解

🕗 发布于 2024-04-13 00:06 蓝桥杯 单片机 嵌入式硬件 51单片机 c语言

网上传言说14届最难，实际做下来感觉确实是这样的

本试题，需要将矩阵键盘短接，J3的555定时器输出口与P34短接

1.比赛题目

2.编程的大致思路

首先，完成基础代码与数码管的不同窗口，定义大部分要用到的变量，并测试每个窗口是否显示正常
然后，添加外设模块，并逐个测试模块在不同窗口下的显示效果
接着，进行按键的定义和数值处理函数的优化，将逻辑功能整体实现清晰
最后，对杂七杂八的led等部分进行设置，测试各个功能是否正常

3.编程心得

555定时器，除了要短接引脚，还要用RB3调节频率的数值
光敏电阻数字跳动太大：加1ms延时，加中断刷新，加最后一步等待应答，加临时变量判断数据正确再写入
ds18b20，注意你采用的是不是三位数进行记录
ds1302,最好用中断，每隔1s提取一遍时间到变量中，再用数码管显示
对于刷新频率为1s为单位的变量，可以直接读取ds1302的秒位，判断是否达到1s的整数倍
程序必须要有一个50us的中断处理，有了50us其他的刷新很好确定
对于led的操作。当led的变化有规律时——建立数组存放led的状态。当led没有规律时——一定要学会位运算，直接对变量value_led进行位操作，然后利用中断传入led处理函数
对于io编程模式，要注意对锁存器常关闭。同时采用先赋值P0端口，再打开锁存器方式，这样有效防止数据冲突。
所有的外设，除了555以外，都可以设置一个刷新的标志变量，可以提升系统运行效率

4.代码参考

4.1 头文件

onewire.h ds1302.h iic.h

和上一篇博客一样，和15届官方发的没有区别。为了节省篇幅这里不放出，可以参考上一篇文章，基本没有变动

basecode.h

#ifndef __BASECODE_H__
#define __BASECODE_H__

void select_HC573 ( unsigned char channal );
void state_SMG ( unsigned char pos_SMG , unsigned char value_SMG );
void state_SMG_all ( unsigned char value_SMG_all );
void state_relay ( unsigned char value_relay );
void state_led ( unsigned char value_led );
void init_sys ();
void init_ds1302 ();
void init_temperature ();

#endif

4.2 底层文件

onewire.c ds1302.c iic.c 和常规一样，也和上一篇博客一样

basecode.c


#include <ds1302.h>
#include <onewire.h>
#include <reg52.h>
#include <intrins.h>


//锁存器通道选择函数
void select_HC573 ( unsigned char channal )
{
switch ( channal )
{
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;
}
}

//单位数码管显示函数
void state_SMG ( unsigned char pos_SMG , unsigned char value_SMG )
{
select_HC573 ( 0 );
P0 = 0x01 << pos_SMG;
select_HC573( 6 );
select_HC573 ( 0 );
P0 = value_SMG;
select_HC573( 7 );
select_HC573 ( 0 );
}

//全位数码管静态显示
void state_SMG_all ( unsigned char value_SMG_all )
{
select_HC573 ( 0 );
P0 = 0xff;
select_HC573( 6 );
select_HC573 ( 0 );
P0 = value_SMG_all;
select_HC573( 7 );
select_HC573 ( 0 );
}


//led灯光控制函数
void state_led ( unsigned char value_led )
{
select_HC573 ( 0 );
P0 = 0xff;
select_HC573 ( 4 );
P0 = value_led;
select_HC573 ( 4 );
select_HC573 ( 0 );
}

//初始化系统，关闭继电器和蜂鸣器
void init_sys ()
{
select_HC573 ( 0 );
P0 = 0xff;
select_HC573 ( 4 );
select_HC573 ( 0 );
P0 = 0x00;
select_HC573 ( 5 );
select_HC573 ( 0 );

}



void init_temperature ()
{
unsigned char LSB,MSB;
init_ds18b20();
Write_DS18B20(0xcc);
Write_DS18B20(0x44);

do{
init_ds18b20();
Write_DS18B20(0xcc);
Write_DS18B20(0xbe);

LSB = Read_DS18B20();
MSB = Read_DS18B20();

MSB = ( MSB << 4 ) | ( LSB >> 4 );
}while ( MSB == 85 );
}

4.3主函数文件

#include <reg52.h>
#include <intrins.h>
#include "onewire.h"
#include "iic.h"
#include "ds1302.h"
#include "basecode.h"

sfr P4 = 0xc0;
sfr AUXR = 0x8e;
sbit C1 = P4^4;
sbit C2 = P4^2;
sbit H1 = P3^3;
sbit H2 = P3^2;

unsigned char code duanma[20] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
                                 0x88,0x83,0xc6,0xc0,0x86,0x8e,0xbf,0x7f,0x89,0x8c};
unsigned char code duanma_dot[16]={ 0x40 , 0x79 , 0x24 , 0x30 , 0x19 , 0x12 , 0x02 , 0x78 ,0x00 , 0x10 };
unsigned char code Write_address [7] = { 0x80 , 0x82 , 0x84 , 0x86 , 0x88 , 0x8a , 0x8c};
unsigned char code Read_address [7] = { 0x81 , 0x83 , 0x85 , 0x87 , 0x89 , 0x8b , 0x8d };

//2022year 3month 31day 5 23 59 50
unsigned char date_ds1302 [7] = { 0x50 , 0x50 , 0x23 , 0x31 , 0x03 , 0x05 , 0x22 };

unsigned int humidity = 0;
unsigned char value_led = 0xff;
unsigned char trg_count = 0;
unsigned char trg_time_hour = 0x00;
unsigned char trg_time_min = 0x00;
unsigned char trg_time_second = 0x00;
unsigned int max_temperature = 0;
unsigned int average_temperature = 0;
unsigned int old_temperature = 0;
unsigned int max_humidity = 0;
unsigned int average_humidity = 0;
unsigned int old_humidity = 0;
unsigned char SMG_flag = 1;

void flash_SMG ();
void rd1running ();
void flash_date ();
void valuerunning ();
void keyrunning ();

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

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


bit flash_rd1 = 0;
unsigned char rd1_value = 0;
void rd1running()
{
unsigned char tmp = 0;
if ( flash_rd1 == 1 )
{
I2CStart();
I2CSendByte(0x90);
I2CWaitAck();
I2CSendByte(0x01);
I2CWaitAck();
I2CStop();
Delay1ms();
I2CStart();
I2CSendByte(0x91);
I2CWaitAck();
tmp = I2CReceiveByte();
I2CWaitAck();
I2CSendAck(1);
I2CStop();

flash_rd1 = 0;
}

if ( tmp<220 && tmp>0 )
{
rd1_value = tmp;
}
}

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

_nop_();
_nop_();
i = 32;
j = 236;
k = 16;
do
{
do
{
while (--k);
} while (--j);
rd1running ();
flash_date ();
valuerunning ();
keyrunning ();
} while (--i);
}

bit flash_ds18b20 = 0;
unsigned int temperature = 0;
unsigned int set_temperature =  300;
void flash_temperature ()
{
if ( flash_ds18b20 == 1 )
{
unsigned char LSB,MSB;
old_temperature = temperature;

init_ds18b20();
Write_DS18B20(0xcc);
Write_DS18B20(0x44);
Delay700ms();
init_ds18b20();
Write_DS18B20(0xcc);
Write_DS18B20(0xbe);

LSB = Read_DS18B20();
MSB = Read_DS18B20();

 
temperature = MSB;
temperature = ( temperature << 8 ) | LSB;
temperature = (temperature >> 4)*10 + (LSB & 0x0f)*0.625;

flash_ds18b20 = 0;
}
 
}
 

void init_ds1302 ()
{
unsigned char i;
Write_Ds1302_Byte ( 0x8e , 0x00 );
for ( i=0 ; i<7 ; i++ )
{
Write_Ds1302_Byte ( Write_address[i] , date_ds1302[i] );
}
Write_Ds1302_Byte ( 0x8e , 0x80 );

}

bit flash_ds1302 = 0;
void flash_date()
{
if ( flash_ds1302 == 1 )
{
unsigned char i;
for ( i=0 ; i<7 ; i++ )
{
date_ds1302[i] = Read_Ds1302_Byte ( Read_address[i] );
}

flash_ds1302 = 0;
}
}


//==============================================================================
void init_timer01 ()
{
AUXR &= 0xBF;//定时器时钟12T模式
TMOD = 0x06;//设置定时器模式
TL1 = 0xCE;//设置定时初值
TH1 = 0xFF;//设置定时初值
TF1 = 0;//清除TF1标志
TR1 = 1;//定时器1开始计时

TL0 = 0xFF;//设置定时初值
TH0 = 0xFF;//设置定时初值
TF0 = 0;//清除TF0标志
TR0 = 1;//定时器0开始计时

EA = 1;
ET0 = 1;
ET1 = 1;
}

unsigned int count_timer0 = 0;
void timer0_service () interrupt 1
{
count_timer0 ++;
}
//=============================================================================

bit flag_100ms = 0;
unsigned int count_fre = 0;
unsigned char count_50us = 0;
unsigned char count_5ms = 0;
unsigned char flash_count = 0;//数码管刷新位
unsigned char date_hour;
unsigned char date_min;
unsigned char date_second;
void timer1_service () interrupt 3
{

if ( ++count_50us == 200 )
{
flash_rd1 = 1;
count_50us = 0;
}

if ( count_50us % 40 == 0 ) 
{
if ( SMG_flag == 1 )//窗口1
{
if ( ++flash_count == 9 )
{
flash_count = 0;
}
}
else if ( SMG_flag == 2 )//窗口2
{
if ( ++flash_count > 7 )
{
flash_count = 0;
}
}
else if ( SMG_flag == 3 )//窗口3
{
if ( ++flash_count > 7 )
{
flash_count = 0;
}
}
else if ( SMG_flag == 4 )//窗口4
{
if ( ++flash_count == 9 )
{
flash_count = 0;
}
}
else if ( SMG_flag == 5 )//窗口5
{
if ( ++flash_count > 3 )
{
flash_count = 0;
}
}
else if ( SMG_flag == 6 )//窗口6
{
if ( ++flash_count > 6 )
{
flash_count = 0;
}
}

flash_SMG ();//刷新数码管一位
}

if ( count_50us % 100 == 0 )
{
count_5ms++;
if ( count_5ms == 200 )
{
count_5ms = 0;
count_fre = count_timer0;
count_timer0 = 0;

date_hour = date_ds1302[2];  //时间提取出来显示，数码管才不会闪烁
date_min = date_ds1302[1];
date_second = date_ds1302[0];
}
if ( count_5ms % 20 == 0 )
{
flag_100ms = ~flag_100ms;
}
}

if ( count_50us % 50 == 0 )
{
flash_ds18b20 = 1;
state_led ( value_led );
}

if ( count_50us % 40 == 0 )
{
flash_ds1302 = 1;

}

}

bit rd1_3s = 0;
unsigned char save_SMG_flag = 1;
void valuerunning ()
{
if ( count_fre >= 200 && count_fre <= 2000 )
{
value_led |= 0x10;
old_humidity = humidity;
humidity = count_fre /22.5*10;

if ( max_humidity < humidity )
{
max_humidity = humidity;
}

average_humidity = (average_humidity + humidity)/2;
}
else
{
humidity = 0;
value_led &= 0xef;
}

if ( temperature != 0 )
{
if ( max_temperature < temperature && temperature < 999 )
{
max_temperature = temperature;
}

average_temperature = (average_temperature + temperature)/2;
}

if ( rd1_value < 90 && rd1_3s == 0 )
{
trg_count ++;
trg_time_hour = date_ds1302[2];
trg_time_min = date_ds1302[1];
trg_time_second = date_ds1302[0];
save_SMG_flag = SMG_flag;
}

if ( trg_count != 0 )
{
if ( date_ds1302[0] - trg_time_second <= 0x03 )
{
rd1_3s = 1;
SMG_flag = 6;
}
else
{
if ( rd1_3s == 1 )
{
SMG_flag = save_SMG_flag;
}
rd1_3s = 0;
}
}

if ( SMG_flag == 1 )
{
value_led = ( value_led | 0x07 ) & 0xfe;
}
else if ( SMG_flag == 2 || SMG_flag == 3 || SMG_flag == 4 )
{
value_led = ( value_led | 0x07 ) & 0xfd;
}
else if ( SMG_flag == 6 )
{
value_led = ( value_led | 0x07 ) & 0xfb;
}
else
{
value_led = ( value_led | 0x07 ) ;
}

if ( temperature > set_temperature )
{
if ( flag_100ms == 0 )
{
value_led &= 0xf7;
}
else 
{
value_led |= 0x08;
}
}
else
{
value_led |= 0x08;
}


if ( trg_count >1 && temperature > old_temperature && humidity > old_humidity )
{
value_led &= 0xbf;
}
else
{
value_led |= 0x40;
}



}

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

i = 47;
j = 174;
do
{
while (--j);
} while (--i);
}

bit key9_2s = 0;
bit flag_clear = 0;
unsigned char key9_time = 0x00;
void keyrunning ()
{
C1 = 0;
C2 = H1 = H2 = 1;
if ( H1 == 0 )
{
Delay4ms();
if ( H1 == 0 )//S4
{
switch ( SMG_flag )
{
case 1:
SMG_flag = 2;
break;
case 2:case 3:case 4:
SMG_flag = 5;
break;
case 5:
SMG_flag = 1;
break;
}
while ( H1 == 0 );
}
}
else if ( H2 == 0 )
{
Delay4ms();
if ( H2 == 0 )//S5
{
if ( SMG_flag != 1 )
{
switch ( SMG_flag )
{
case 2:
SMG_flag = 3;
break;
case 3:
SMG_flag = 4;
break;
case 4:
SMG_flag = 2;
break;
}
}
while ( H2 == 0 );
}
}

C2 = 0;
C1 = H1 = H2 = 1;
if ( H1 == 0 )
{
Delay4ms();
if ( H1 == 0 )//S8
{
if ( SMG_flag == 5 )
{
set_temperature += 10;
if ( set_temperature == 1000 )
{
set_temperature = 990;
}
}
while ( H1 == 0 );
}
}
else if ( H2 == 0 )
{
Delay4ms();
if ( H2 == 0 )//S9
{
if ( SMG_flag == 5 )
{
set_temperature -= 10;
if ( set_temperature > 990 )
{
set_temperature = 0;
}
}

while ( H2 == 0 )
{
if ( SMG_flag == 4 && key9_2s == 0 )
{
key9_2s = 1;
key9_time = date_ds1302[0];
}

if ( date_ds1302[0] - key9_time > 0x02 )
{
key9_2s = 0;
flag_clear = 1;
break;
}
}
while ( H2 == 0 );
if ( flag_clear == 1 )
{
trg_count = 0;
trg_time_hour = 0;
trg_time_min = 0;
trg_time_second = 0;
flag_clear = 0;
}
}
}
}




void flash_SMG ()
{
state_SMG_all ( 0xff );

if ( SMG_flag == 1 )
{
switch ( flash_count )
{
case 0 :
state_SMG ( 0 , duanma[date_hour/16] );
break;
case 1 :
state_SMG ( 1 , duanma[date_hour%16] );
break;
case 2 :
state_SMG ( 2 , duanma[16] );
break;
case 3 :
state_SMG ( 3 , duanma[date_min/16] );
break;
case 4 :
state_SMG ( 4 , duanma[date_min%16] );
break;
case 5 :
state_SMG ( 5 , duanma[16] );
break;
case 6 :
state_SMG ( 6 , duanma[date_second/16] );
break;
case 7 :
state_SMG ( 7 , duanma[date_second%16] );
break;
case 8 :
state_SMG_all ( 0xff );
break;
}
}
else if ( SMG_flag == 2 )
{
if ( trg_count == 0 )
{
state_SMG ( 0 , duanma[12] );
}
else
{
switch ( flash_count )
{
case 0 :
state_SMG ( 0 , duanma[12] );
break;
case 1 :
state_SMG ( 2 , duanma[max_temperature/100] );
break;
case 2 :
state_SMG ( 3 , duanma[max_temperature/10%10] );
break;
case 3 :
state_SMG ( 4 , duanma[16] );
break;
case 4 :
state_SMG ( 5 , duanma[average_temperature/100] );
break;
case 5 :
state_SMG ( 6 , duanma_dot[average_temperature/10%10] );
break;
case 6 :
state_SMG ( 7 , duanma[average_temperature%10] );
break;
case 7 :
state_SMG_all ( 0xff );
break;
}
}
}
else if ( SMG_flag == 3 )
{
if ( trg_count == 0 )
{
state_SMG ( 0 , duanma[18] );
}
else
{
switch ( flash_count )
{
case 0 :
state_SMG ( 0 , duanma[18] );
break;
case 1 :
state_SMG ( 2 , duanma[max_humidity/100] );
break;
case 2 :
state_SMG ( 3 , duanma[max_humidity/10%10] );
break;
case 3 :
state_SMG ( 4 , duanma[16] );
break;
case 4 :
state_SMG ( 5 , duanma[average_humidity/100] );
break;
case 5 :
state_SMG ( 6 , duanma_dot[average_humidity/10%10] );
break;
case 6 :
state_SMG ( 7 , duanma[average_humidity%10] );
break;
case 7 :
state_SMG_all ( 0xff );
break;
}
}
}
else if ( SMG_flag == 4 )
{
switch ( flash_count )
{
case 0 :
state_SMG ( 0 , duanma[15] );
break;
case 1 :
state_SMG ( 1 , duanma[trg_count/10] );
break;
case 2 :
state_SMG ( 2 , duanma[trg_count%10] );
break;
case 3 :
if ( trg_count != 0 )
{
state_SMG ( 3, duanma[trg_time_hour/16] );
}
else
{
state_SMG ( 3, 0xff );
}
break;
case 4 :
if ( trg_count != 0 )
{
state_SMG ( 4 , duanma[trg_time_hour%16] );
}
else
{
state_SMG ( 4, 0xff );
}
break;
case 5 :
if ( trg_count != 0 )
{
state_SMG ( 5 , duanma[16] );
}
else
{
state_SMG ( 5, 0xff );
}
break;
case 6 :
if ( trg_count != 0 )
{
state_SMG ( 6 , duanma[trg_time_min/16] );
}
else
{
state_SMG ( 6, 0xff );
}
break;
case 7 :
if ( trg_count != 0 )
{
state_SMG ( 7 , duanma[trg_time_min%16] );
}
else
{
state_SMG ( 7, 0xff );
}
break;
case 8 :
//state_SMG_all ( 0xff );
break;
}
}
else if ( SMG_flag == 5 )
{
switch ( flash_count )
{
case 0 :
state_SMG ( 0 , duanma[15] );
break;
case 1 :
state_SMG ( 6 , duanma[set_temperature/100] );
break;
case 2 :
state_SMG ( 7 , duanma[set_temperature/10%10] );
break;
case 3 :
state_SMG_all ( 0xff );
break;
}
}
else if ( SMG_flag == 6 )
{
switch ( flash_count )
{
case 0 :
state_SMG ( 0 , duanma[14] );
break;
case 1 :
if ( temperature == 0 )
{
state_SMG ( 3 , duanma[10] );
}
else
{
state_SMG ( 3 , duanma[temperature/100] );
}
break;
case 2 :
state_SMG ( 4 , duanma[temperature/10%10] );
break;
case 3 :
state_SMG ( 5 , duanma[16] );
break;
case 4 :
if ( humidity == 0 )
{
state_SMG ( 6 , duanma[10] );
}
else
{
state_SMG ( 6 , duanma[humidity/100] );
}
break;
case 5 :
if ( humidity == 0 )
{
state_SMG ( 7 , duanma[10] );
}
else
{
state_SMG ( 7 , duanma[humidity/10%10] );
}
break;
case 6 :
state_SMG_all ( 0xff );
break;
}
}
}



void main ()
{
init_sys();
init_timer01 ();
init_ds1302 ();
init_temperature ();
state_led ( 0xff );
while ( 1 )
{
keyrunning ();
rd1running ();
flash_date ();
valuerunning ();
flash_temperature ();
}
}

原文地址：https://blog.csdn.net/qq_43323677/article/details/137694727

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：计算机网络----第五天
下一篇：深入go泛型特性之comparable「附案例」

[CUDA] cuda kernel开发记录
包括kernel的一些使用注意事项， launch_bound, __device__, debug排查技巧
阅读更多2024-11-16
【python】掌握 Flask：轻量级 Web 开发框架解析
路由是 Web 开发的基础，负责管理 URL 到视图函数的映射。在 Flask 中，路由定义非常简单，只需使用装饰器即可。这个代码段定义了一个路由，访问该路径时会返回 “Hello, Flask!通过
阅读更多2024-11-16
AI图片分析接口LiteAIServer摄像机实时接入分析平台未戴安全帽检测算法
随着人工智能技术的飞速发展，摄像机实时接入分析平台LiteAIServer工地未佩戴安全帽检测算法应运而生，为工地安全管理带来了革命性的变革。
阅读更多2024-11-16
2024新版pycharm如何切换anaconda虚拟环境
回归正题，导入项目后点击文件=>设置，找到解释器。不得不说这界面改的真不错，看着很舒服。另外在终端用指令切换也是可以的。添加解释器=>添加本地解释器。
阅读更多2024-11-16
计算机提示mfc140u.dll丢失的五种解决方法，了解mfc140u.dll错误的几种修复方法
当你尝试打开某些程序时，突然出现错误提示，告知你系统缺少 mfc140u.dll 文件，这可能让你感到困惑和无助。mfc140u.dll 是 Microsoft Foundation Class (M
阅读更多2024-11-16
k8s 中传递参数给docker容器
在 Kubernetes 中，可以通过多种方式将参数传递给 Dockerfile 或其运行的容器，常见的方式包括使用环境变量、命令行参数、配置文件等。
阅读更多2024-11-16
设计模式之工厂模式，但是宝可梦
作为一个细分了三个种类的设计模式，到底该如何取舍？比起直接new一个对象，使用对应模式的好处到底在哪？简单工厂模式：根据传入的参数决定产出的对象，可以隐藏一些创建的细节适用于需要根据条件创建不同对象的
阅读更多2024-11-16
【深度学习】wsl-ubuntu深度学习基本配置
这里注意一点，你换了源之后就最好不要开代理了，要不然搞不好下载失败，pip和conda都是。
阅读更多2024-11-16
nodejs和npm在gitbash中提示Not Found情况的解决办法
很多小伙伴学习了node以后，在cmd命令行中可以正常的获取node版本和npm版本，但是我们经常使用gitbash来管理git，这时候下载完gitbash后，在gitbash中输入node -v和n
阅读更多2024-11-16
判断子序列
给定一个长度为 n的整数序列 a1,a2,…,an以及一个长度为 m的整数序列 b1,b2,…,bm。请你判断 a序列是否为 b序列的子序列。子序列指序列的一部分项按原有次序排列而得的序列，例如序列
阅读更多2024-11-16