蓝桥杯学习笔记 单片机CT107D 第十届国赛代码部分

于 2024-05-28 20:39:57 发布
阅读量390 收藏 3
点赞数 5
文章标签： 蓝桥杯 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hans_Rudle/article/details/139276902
版权

碎碎念:好久没写串口，来个串口熟悉熟悉，结果发现好多问题

一.题目要求:

 个人的一些见解：这一届两个比较少见的点就是串口通信收发不定长数据和按键长按短按的识别

具体可以看这两篇文章 蓝桥杯学习笔记 单片机CT107D 按键短按，长按的识别_兰倩单片机长按短按怎么写-CSDN博客

 蓝桥杯学习笔记 单片机CT107D 串口通信_ct107d平台外设程序学习心得-CSDN博客

先说串口吧,对于不定长数据的发送可利用指针指向字符串数组中的值挨个发送直到最后('\0')

void UART_Service() interrupt 4
{
	if(RI==1)
	{
		RI=0;
		Receive[len++]=SBUF;
	}
}

对于之后字符串的处理，我采用了比较投机取巧的方法，就是字符串中元素一个一个判断，判断完成后将数组清零

void UART_deal()
{
	unsigned char i;
	if(Receive[0]=='S'&&Receive[1]=='T')
	{
		UART_SendByte('$');
		UART_SendByte(Distance/10+48);
		UART_SendByte(Distance%10+48);
		UART_SendByte(',');
		UART_SendByte(T_smg/1000+48);
		UART_SendByte(T_smg%1000/100+48);
		UART_SendByte('.');
		UART_SendByte(T_smg%100/10+48);
		UART_SendByte(T_smg%10+48);
		SendString("\r\n");
	}
	else if(Receive[0]=='P'&&Receive[1]=='A'&&Receive[2]=='R'&&Receive[3]=='A')
	{
		UART_SendByte('#');
		UART_SendByte(Dis_param/10+48);
		UART_SendByte(Dis_param%10+48);
		UART_SendByte(',');
		UART_SendByte(T_param/10+48);
		UART_SendByte(T_param/10+48);
		SendString("\r\n");
	}
	else if(Receive[0]!=0)
	{
		SendString("error\r\n");
	}
	len=0;
	for(i=0;i<4;i++)
	{
		Receive[i]=0;
	}
}

其实上述代码的数据发送也用了比较取巧的方法，就是将一个字符串分成几段挨个发出去，当然也可以用spritnf将字符串拼接后发送。但我使用的时候使用unsigned char 类型会出问题，不得己全部换成了 int类型

int Distance
sprintf(string,"$%d,%.2f\r\n",Distance,T);
SendString(string);

按键长短按问题的识别我采用的策略是按下按键后立即进入while循环并开始按键相关的计时，松开按键后关闭计时，之后判断时间执行相应的操作:

中断函数的配置 

void Timer0_Service() interrupt 1
{
	times++;
	if(times==125)
	{
		Measure_Distance();
	}
	if(Key_Flag==1)            //打开按键定时标志位
	{
		Key_times++;
	}
}

按键中的配置（设计长按的两个部分）

void Scan_Key()
{
	C1=0;C2=1;
	R1=R2=1;
	if(R1==0)
	{
		Delay_SMG(500);
		if(R1==0)
		{
			Key_Flag=1;                                //打开定时标志位
			while(R1==0)
			{
				Display_Dynamic();
				DS18B20_Read();
			}
			Key_Flag=0;                               //关闭定时标志位
			if(Key_times<1000)                        //开始计时
			{                
				if(SMG_Mode!=4&&SMG_Mode!=5)
				{
					SMG_Mode=4;
				}
				else if(SMG_Mode==4||SMG_Mode==5)
				{
					SMG_Mode=1;
					AT24C02_Write(++change_times);
				}
			}
			if(Key_times>1000)
			{
				DAC_Flag=~DAC_Flag;
			}
			Key_times=0;
		}
		while(R1==0)
		{
			Display_Dynamic();
			DS18B20_Read();
		}
	}
	if(R2==0)
	{
		Delay_SMG(500);
		if(R2==0)
		{
			Key_Flag=1;
			while(R2==0)
			{
				Display_Dynamic();
				DS18B20_Read();
			}
			Key_Flag=0;
			if(Key_times<1000)
			{
								if(SMG_Mode!=4&&SMG_Mode!=5)
				{
					switch(SMG_Mode)
					{
						case 1:
							SMG_Mode=2;
						break;
						case 2:
							SMG_Mode=3;
						break;
						case 3:
							SMG_Mode=1;
						break;
					}
				}
				else if(SMG_Mode==4||SMG_Mode==5)
				{
					switch(SMG_Mode)
					{
						case 4:
							SMG_Mode=5;
						break;
						case 5:
							SMG_Mode=4;
						break;
					}
				}
			}
			if(Key_times>=1000)
			{
				change_times=0;
				AT24C02_Write(change_times);
			}
			Key_times=0;
		}
	}
}
 二.代码实现
main.c
#include <STC15F2K60S2.H>
#include "stdio.h"
#include "intrins.h"
#include "onewire.h"
#include "iic.h"
sbit C1=P3^5;
sbit C2=P3^4;
sbit R1=P3^2;
sbit R2=P3^3;
sbit TX=P1^0;
code unsigned char SMG_Nodot[] =
{0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e};
code unsigned char SMG_Dot[] =
{0x40,0x79,0x24,0x30,0x19,0x12,0x12,0x78,0x00,0x10};
unsigned char SMG_Mode=1;
float T;
unsigned int T_smg;
int Distance;
unsigned int change_times;
unsigned char T_param=30;
unsigned char Dis_param=35;
unsigned char times;
unsigned int PCA_times;
unsigned char PCA_Flag;
unsigned char jiaoyan;
unsigned int Key_times=0;
bit Key_Flag;
unsigned char len;
unsigned char Receive[5];
unsigned char string[20];
bit DAC_Flag=1;
unsigned char DAC_Value;
unsigned char LED_Mode=0xff;
void Delay_SMG(unsigned int t)
{
	while(t--);
}
void Delay12us()		//@12.000MHz
{
	unsigned char i;

	_nop_();
	_nop_();
	i = 33;
	while (--i);
}
void SendWave()
{
	unsigned char i;
	for(i=0;i<8;i++)
	{
		TX=1;
		Delay12us();
		TX=0;
		Delay12us();
	}
}
void SelectHC573(unsigned char channel,unsigned char 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(unsigned char pos ,unsigned char dat)
{
	SelectHC573(6,0x01<<(pos-1));
	SelectHC573(7,dat);
	Delay_SMG(500);
	SelectHC573(6,0x01<<(pos-1));
	SelectHC573(7,0xff);
}
void Display_Dynamic()
{
	if(SMG_Mode==1)
	{
		SMG_Display(1,SMG_Nodot[15]);
		SMG_Display(5,SMG_Nodot[T_smg/1000]);
		SMG_Display(6,SMG_Dot[T_smg%1000/100]);
		SMG_Display(7,SMG_Nodot[T_smg%100/10]);
		SMG_Display(8,SMG_Nodot[T_smg%10]);
	}
	if(SMG_Mode==2)
	{
		SMG_Display(1,0xc7);
		SMG_Display(7,SMG_Nodot[Distance/10]);
		SMG_Display(8,SMG_Nodot[Distance%10]);
	}
	if(SMG_Mode==3)
	{
		SMG_Display(1,SMG_Dot[0]);
		if(change_times>10000)
		{
			SMG_Display(4,SMG_Nodot[change_times/10000]);
		}
		if(change_times>1000)
		{
			SMG_Display(5,SMG_Nodot[change_times%10000/1000]);
		}
		if(change_times>100)
		{
			SMG_Display(6,SMG_Nodot[change_times%1000/100]);
		}
		if(change_times>10)
		{
			SMG_Display(7,SMG_Nodot[change_times%100/10]);
		}
		SMG_Display(8,SMG_Nodot[change_times%10]);
	}
	if(SMG_Mode==4)
	{
		SMG_Display(1,0x92);
		SMG_Display(4,SMG_Nodot[1]);
		SMG_Display(7,SMG_Nodot[T_param/10]);
		SMG_Display(8,SMG_Nodot[T_param%10]);
	}
	if(SMG_Mode==5)
	{
		SMG_Display(1,0x92);
		SMG_Display(4,SMG_Nodot[2]);
		SMG_Display(7,SMG_Nodot[Dis_param/10]);
		SMG_Display(8,SMG_Nodot[Dis_param%10]);
	}
}
void Measure_Distance()
{
	CH=CL=0;
	SendWave();
	CR=1;
	if(PCA_Flag==0)
	{
		Distance=99;
	}
	if(PCA_Flag==1)
	{
		Distance=PCA_times*0.017;
		if(Distance>=99)
		{
			Distance=99;
		}
	}
}
void Timer0Init(void)		//1??@12.000MHz
{
	AUXR &= 0x7F;		//?????12T??
	TMOD &= 0xF0;		//???????
	TL0 = 0x18;		//??????
	TH0 = 0xFC;		//??????
	TF0 = 0;		//??TF0??
	TR0 = 1;		//???0????
	ET0=1;
	EA=1;
}
void UartInit(void)		//9600bps@12.000MHz
{
	SCON = 0x50;		//8???,?????
	AUXR &= 0xBF;		//???1???Fosc/12,?12T
	AUXR &= 0xFE;		//??1?????1???????
	TMOD &= 0x0F;		//?????1?16???????
	TL1 = 0xE6;		//??????
	TH1 = 0xFF;		//??????
	ET1 = 0;		//?????1??
	TR1 = 1;		//?????1
	ES=1;
}

void PCA_Init()
{
	CMOD=0x01;
	CCON=0x00;
	CCAPM0=0x11;
}
void Timer0_Service() interrupt 1
{
	times++;
	if(times==125)
	{
		Measure_Distance();
	}
	if(Key_Flag==1)
	{
		Key_times++;
	}
}
void PCA_Service() interrupt 7
{
	CR=0;
	if(CF==1)
	{
		CF=0;
		PCA_Flag=0;
	}
	if(CCF0==1)
	{
		CCF0=0;
		PCA_times=CCAP0H<<8|CCAP0L;
		PCA_Flag=1;
	}
}
void UART_SendByte(unsigned char dat)
{
	SBUF=dat;
	while(TI==0);
	TI=0;
}
void SendString(unsigned char *str)
{
	while(*str!='\0')
	{
		UART_SendByte(*str++);
	}
}
void UART_Service() interrupt 4
{
	if(RI==1)
	{
		RI=0;
		Receive[len++]=SBUF;
	}
}
void UART_deal()
{
	unsigned char i;
	if(Receive[0]=='S'&&Receive[1]=='T')
	{
		UART_SendByte('$');
		UART_SendByte(Distance/10+48);
		UART_SendByte(Distance%10+48);
		UART_SendByte(',');
		UART_SendByte(T_smg/1000+48);
		UART_SendByte(T_smg%1000/100+48);
		UART_SendByte('.');
		UART_SendByte(T_smg%100/10+48);
		UART_SendByte(T_smg%10+48);
		SendString("\r\n");
	}
	else if(Receive[0]=='P'&&Receive[1]=='A'&&Receive[2]=='R'&&Receive[3]=='A')
	{
		UART_SendByte('#');
		UART_SendByte(Dis_param/10+48);
		UART_SendByte(Dis_param%10+48);
		UART_SendByte(',');
		UART_SendByte(T_param/10+48);
		UART_SendByte(T_param/10+48);
		SendString("\r\n");
	}
	else if(Receive[0]!=0)
	{
		SendString("error\r\n");
	}
	len=0;
	for(i=0;i<4;i++)
	{
		Receive[i]=0;
	}
}
void DS18B20_Read()
{
	unsigned char MSB,LSB;
	unsigned int temp;
	init_ds18b20();
	Display_Dynamic();
	Write_DS18B20(0xcc);
	Write_DS18B20(0x44);
	Display_Dynamic();
	init_ds18b20();
	Display_Dynamic();
	Write_DS18B20(0xcc);
	Write_DS18B20(0xbe);
	LSB=Read_DS18B20();
	MSB=Read_DS18B20();
	Display_Dynamic();
	temp=MSB<<8|LSB;
	T=temp*0.0625;
	T_smg=T*100;
}
void AT24C02_Write(unsigned int dat)
{
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(0x00);
	I2CWaitAck();
	I2CSendByte(dat>>8);
	I2CWaitAck();
	I2CSendByte(dat);
	I2CWaitAck();
	I2CSendByte(0xff);
	I2CWaitAck();
	I2CStop();
}
void AT24C02_Read(unsigned char address)
{
	unsigned char MSB,LSB;
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(address);
	I2CWaitAck();
	if(address==0x00)
	{
		I2CStart();
		I2CSendByte(0xa1);
		I2CWaitAck();
		MSB=I2CReceiveByte();
		I2CSendAck(0);
		LSB=I2CReceiveByte();
		I2CSendAck(1);
		I2CStop();
		change_times=MSB<<8|LSB;
	}
	if(address==0x02)
	{
		I2CStart();
		I2CSendByte(0xa1);
		I2CWaitAck();
		jiaoyan=I2CReceiveByte();
		I2CSendAck(1);
		I2CStop();
	}
}
void DAC_Caculate()
{
	if(Distance<Dis_param)
	{
		DAC_Value=102;
	}
	if(Distance>Dis_param)
	{
		DAC_Value=204;
	}
	if(DAC_Flag==0)
	{
		DAC_Value=51*0.4;
	}
}
void DAC_Write()
{
	DAC_Caculate();
	I2CStart();
	I2CSendByte(0x90);
	I2CWaitAck();
	I2CSendByte(0x43);
	I2CWaitAck();
	I2CSendByte(DAC_Value);
	I2CWaitAck();
	I2CStop();
}
void Scan_Key()
{
	C1=0;C2=1;
	R1=R2=1;
	if(R1==0)
	{
		Delay_SMG(500);
		if(R1==0)
		{
			Key_Flag=1;
			while(R1==0)
			{
				Display_Dynamic();
				DS18B20_Read();
			}
			Key_Flag=0;
			if(Key_times<1000)
			{
				if(SMG_Mode!=4&&SMG_Mode!=5)
				{
					SMG_Mode=4;
				}
				else if(SMG_Mode==4||SMG_Mode==5)
				{
					SMG_Mode=1;
					AT24C02_Write(++change_times);
				}
			}
			if(Key_times>1000)
			{
				DAC_Flag=~DAC_Flag;
			}
			Key_times=0;
		}
		while(R1==0)
		{
			Display_Dynamic();
			DS18B20_Read();
		}
	}
	if(R2==0)
	{
		Delay_SMG(500);
		if(R2==0)
		{
			Key_Flag=1;
			while(R2==0)
			{
				Display_Dynamic();
				DS18B20_Read();
			}
			Key_Flag=0;
			if(Key_times<1000)
			{
								if(SMG_Mode!=4&&SMG_Mode!=5)
				{
					switch(SMG_Mode)
					{
						case 1:
							SMG_Mode=2;
						break;
						case 2:
							SMG_Mode=3;
						break;
						case 3:
							SMG_Mode=1;
						break;
					}
				}
				else if(SMG_Mode==4||SMG_Mode==5)
				{
					switch(SMG_Mode)
					{
						case 4:
							SMG_Mode=5;
						break;
						case 5:
							SMG_Mode=4;
						break;
					}
				}
			}
			if(Key_times>=1000)
			{
				change_times=0;
				AT24C02_Write(change_times);
			}
			Key_times=0;
		}
	}
	C1=1;C2=0;
	R1=R2=1;
	if(R1==0)
	{
		Delay_SMG(500);
		if(R1==0)
		{
			if(SMG_Mode==4)
			{
				T_param+=2;
				if(T_param>99)
				{
					T_param=99;
				}
			}
			if(SMG_Mode==5)
			{
				Dis_param+=5;
				if(Dis_param>99)
				{
					Dis_param=99;
				}
			}
		}
		while(R1==0)
		{
			Display_Dynamic();
			DS18B20_Read();
		}
	}
	if(R2==0)
	{
		Delay_SMG(500);
		if(R2==0)
		{
			if(SMG_Mode==4)
			{
				if(T_param>0)
				{
					T_param-=2;
				}
			}
			if(SMG_Mode==5)
			{
				if(Dis_param>0)
				{
					Dis_param-=5;
				}
			}
		}
		while(R2==0)
		{
			Display_Dynamic();
			DS18B20_Read();
		}
	}
}
void Sys_Init()
{
	SelectHC573(4,0xff);
	SelectHC573(5,0x00);
	Timer0Init();
	PCA_Init();
	UartInit();
	AT24C02_Read(0x02);
	if(jiaoyan==0xff)
	{
		AT24C02_Read(0x00);
	}
	if(jiaoyan!=0xff)
	{
		AT24C02_Write(0);
	}
}
void LED_Control()
{
	if(T>T_param)
	{
		LED_Mode&=0xfe;
		SelectHC573(4,LED_Mode);
	}
	if(T<T_param)
	{
		LED_Mode|=0x01;
		SelectHC573(4,LED_Mode);
	}
	if(Distance>Dis_param)
	{
		LED_Mode&=0xfd;
		SelectHC573(4,LED_Mode);
	}
	if(Distance<Dis_param)
	{
		LED_Mode|=0x02;
		SelectHC573(4,LED_Mode);
	}
	if(DAC_Flag==1)
	{
		LED_Mode&=0xfb;
		SelectHC573(4,LED_Mode);
	}
	if(DAC_Flag==0)
	{
		LED_Mode|=0x04;
		SelectHC573(4,LED_Mode);
	}
}
void main()
{
	Sys_Init();
	while(1)
	{
		Display_Dynamic();
		DS18B20_Read();
		Scan_Key();
		UART_deal();
		DAC_Write();
		LED_Control();
	}
}

Hans_Rudle
关注
第十届蓝桥杯单片机完整程序
m0_56936436的博客
09-24 1876
蓝桥杯单片机第十届
蓝桥杯单片机第七届国赛笔记
weixin_56043766的博客
05-07 897
第七届蓝桥杯单片机组国赛笔记： 做完这届题目之后有很多感触和一些好的思想，想分享一下顺便巩固巩固 1.摆脱标志位的依赖： 好的编程我认为是用最简洁，清晰的程序 ，“最近的路径” 去实现某个功能。如果遇到问题就做标志位这种方法我认为有点low了，对思维和编程能力的提高效果微乎其微，以后的编程中我也一定要避免这个问题。 2.再写完程序后，发现现象不对，一定要进行总结，为什么不对，效果没出来的原因是什么？ 3.制造寄存器，（这是我起的名字）这个套路非常，非常，非常实用本次题目。 下面就开始正文了： 别被题目吓
蓝桥杯十届国赛_单片机_程序设计部分（大学组）.pdf
11-07
蓝桥杯十届国赛_单片机_程序设计部分（大学组）.pdf 蓝桥杯十届国赛_单片机_程序设计部分（大学组）.pdf
蓝桥杯单片机组国赛第十届(附源码
最新发布
2302_79441705的博客
05-22 813
蓝桥杯单片机国赛第十届详细解析+源码
第十届蓝桥杯大赛选手资源数据包（单片机）
03-22
驱动代码说明 1-本文件夹中提供的驱动代码供参赛选手完成程序设计参考之用。 2-选手可以自行编写相关代码或以该代码为基础，根据试题中的时钟频率要求，调整延时间隔。 3-提供驱动代码的测试环境：IAP15F2K61S2单片机 @12MHz。 DS1302
蓝桥杯单片机组历年真题（更新至第十届国赛/省赛）.zip
04-09
第十届 蓝桥杯 单片机设计与开发项目 省赛 第二部分 程序设计试题（70 分） 1、 基本要求 1.1 使用大赛组委会提供的国信长天单片机竞赛实训平台，完成本试题的程序设计 与调试。 1.2 选手在程序设计与调试过程中，可参考组委会提供的“资源数据包”。 1.3 请注意：程序编写、调试完成后选手应通过考试系统提交完整、可编译的 Keil 工程文件。选手提交的工程文件应是最终版本，要求 Keil 工程文件以准考证 号（8 位数字）命名，工程文件夹内应包含以准考证号命名的 hex 文件，该 hex 文件是成绩评审的依据。不符合以上文件提交要求的作品将被评为零分或者被 酌情扣分。 1.4 请勿上传与作品工程文件无关的其它文件。 2、 竞赛板配置要求 2.1将 IAP15F2K61S2 单片机内部振荡器频率设定为 12MHz。 2.2键盘工作模式跳线 J5 配置为 BTN 独立按键模式。 2.3扩展方式跳线 J13 配置为 IO 模式。 2.4请注意：选手需严格按照以上要求配置竞赛板，编写和调试程序，不符合以上 配置要求的作品将被评为零分或者被酌情扣分。 1. 采用 IAP15F2K61S2 作为省赛指定单片机芯片。 2. 省赛竞赛和训练平台为 CT107D 开发板。 3. 比赛时间： 5小时 4. 比赛形式： 以开发板为基础进行编程完成相关任务 和 相关电路设计
蓝桥杯单片机第十届
weixin_46138138的博客
03-08 928
全部文件：提取码：azxy #include "STC15F2K60S2.h" #include "intrins.h" #include "iic.h" typedef unsigned char u8; typedef unsigned int u16; sbit S4=P3^3; sbit S5=P3^2; sbit S6=P3^1; sbit S7=P3^0; // 0 1 2 3 4 5 6 7 8 9 u8 code duan[1
蓝桥杯_蓝桥杯单片机_ct107d_
09-30
包括矩阵键盘 温度传感 存储器等有关硬件调试好的程序以及几届比赛题写好的代码 及一些蓝桥杯板子其他的相关资料（板子原理图等）
蓝桥杯单片机蓝桥杯单片机.rar
06-04
参考资料部分可能包括了教程、笔记、讲义等，为学习单片机基础知识和提高编程能力提供了辅助材料。 【标签】：“蓝桥杯”是一个专门针对信息技术、软件工程和电子设计等领域的全国性大学生竞赛，旨在培养和选拔优秀...
蓝桥杯单片机代码——CT107D ( 指导书配套官方代码 )
01-21
1、蓝桥杯单片机基本外设的代码里面都有 2、我其他文章的底层代码都来自这里
第十届蓝桥杯（单片机组）
03-24
第十届蓝桥杯之单片机设计与开发的试题，分为客观题和编程部分。
第十届蓝桥杯单片机
w396255075的博客
02-20 460
注意事项：led的控制需要先进行与操作后再进行赋值，0x03是读取电位器上的电压，0x43 dac功能是 写入数据 数码管的开关，将它与上其他的标志位进行控制 #include <STC15F2K60S2.H> #include "iic.h" #define uchar unsigned char #define uint unsigned int uint date,count,dat,volt; bit jiemian,ad_mode,led_mode,smg_mode; unsig
蓝桥杯单片机第十届省赛
qq_57148959的博客
02-17 790
蓝桥杯单片机第十届省赛
【蓝桥杯单片机】第十届省赛
qq_46690542的博客
05-29 1318
#include "reg52.h" #include "iic.h" sbit L1 = P0^0; sbit L2 = P0^1; sbit L3 = P0^2; sbit L4 = P0^3; sbit L5 = P0^4; sbit S7 = P3^0; sbit S6 = P3^1; sbit S5 = P3^2; sbit S4 = P3^3; unsigned char rb2; unsigned int k4 = 0; unsigned int k5 = 0; unsigned...
蓝桥杯单片机设计与开发决赛-第十届
weixin_44913454的博客
07-02 535
这里的代码是主文件的代码，其他的头文件之前已经提供，下面的代码仅提供思路，不提供原理，如有错误请及时留言提醒。 #include <stc15f2k60s2.h> #include <intrins.h> #include "iic.h" #include "onewire.h" #include <stdio.h> typedef unsigned int uint; code uchar TAB[] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99
蓝桥杯单片机省赛 第八届（代码+分析）
tuygre的博客
03-06 4197
蓝桥杯电子类单片机 2022年备赛 南京信息工程大学 代码 注释
CT107D蓝桥杯单片机编程资料
09-10
参加第六届蓝桥杯单片机设计大赛，分享些经验给大家学习！
蓝桥杯单片机第10届_电压方波发生器
k7780的博客
08-02 584
题目 代码 这一届考的内容和以前的基本一样，没整那么变换，就是多了个NE555，国赛经常考的模块，就劝退了很多人，其实也就只是把定时器设为计数模式，很简单 timer.c #include <timer.h> void TimerInit(void) //1毫秒@12.000MHz { AUXR &= 0xBF; //定时器时钟12T模式 TMOD &= 0x0F; TMOD |= 0X05; //设置定时器模式 TL1 = 0x18; //设置
蓝桥杯单片机第十届国赛
qq_53371998的博客
06-18 3449
今天是第十三届蓝桥杯单片机国赛的比赛时间，刚比完，简单说一下感想，这次国赛必须要用到三个定时器，昨天刚看了定时器2的使用，不太熟练，所以写的也不是很好，超声波和频率有点冲突，就个人而言，我觉得这一届最大的难点也就是在这里了，其他的应该没什么难的，个人感觉。虽然没有写的很好，但是总体思路还可以说一下，怎么解决定时器问题。定时器0必须用来测量频率，定时器1必须用来超声波测距，那么还需要一个定时器来实现一些外设的定时，比如数码管的2ms扫描一次，再比如按键的20ms扫描一次，所以这一届国赛，需要用到三个定时器。.
【蓝桥杯单片机国赛 第十届】
热门推荐
qq_45720531的博客
03-21 1万+
蓝桥杯国赛模块讲解做题思路首先smg长短矩阵按键串口收发问题首先附上标准代码DS18B20超声波AT24c02最后串口的问题 做题思路 首先写上要做的模块，界面，晓得细节 一页纸就能让你不用看pdf即可写出整套题这种 简单示范： 首先smg void smg() { P2 = (P2&0x1f)|0xc0; P0 = T_COM[smg_i]; P2 = (P2&0x1f); P2 = (P2&0x1f)|0xe0; P0 = ~table[smg_i]; P2 = (P2&a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值