蓝桥杯学习笔记 单片机CT107D 第十三届国赛

已于 2024-05-31 12:20:49 修改
阅读量484 收藏 5
点赞数 11
文章标签： 蓝桥杯 学习 笔记
于 2024-05-18 20:32:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hans_Rudle/article/details/139030526
版权

碎碎念:这一届的难点我觉得在于PWM输出与其他模块之间的冲突，同时如果不使用PCA的话还有定时器之间的冲突的问题。我最开始做的时候并没有在意这些细节上的问题，然后出了许多问题，比如LED和数码管乱闪,IIC时序异常等，现在虽然解决了一部分，但还是有一些瑕疵。

一.题目要求:

自己的一些见解:

关于NE555:

        在测量频率的时候，我发现数码管显示的频率与频率计测出的频率误差较大，排查之后发现问题处在PCA上,因为我时在定时器中调用了超声波，但超声波SendWave的时候会有12*2*8的延时，这段延时对频率测量的影响还是蛮大的，所以我这里新开了一个定时器2用于频率测量.

关于PWM:

        PWM实现的时候，出现LED,数码管乱闪的问题,我初步推测是应为PWM中断的频率太高( 100us)，导致P0口的值非常复杂,而且一开始的时候， 我是每进一次中断都会给P0口赋值，加重了P0口值的混乱。只有我便采取了几种措施.一是提高定时器的计数周期(100us改到200us)，之后不再是每进一次中断对P0口赋值一次,而是在占空比处和计数值为10的时候分别赋值,第三便是在进中断的时候先存好P0口的值，中断结束后将P0原先的值赋值回去.

void Timer1_Service() interrupt 3
{
	unsigned char temp;
	count_times++;
	PWM_times++;
	temp=P0;
	if(count_times==5000)
	{
		dat_F=count_F;
		count_F=0;
		count_times=0;
	}
	if(LED_Flag==1)
	{
		if(count_times%500==0)
		{
			Flash_Flag=~Flash_Flag;
			if(Flash_Flag==1)
			{
				if(SMG_Mode==1)
				{
					LED_Mode=(LED_Mode|0x07)&0xfe;
					SelectHC573(4,LED_Mode);
				}
				else if(SMG_Mode==2)
				{
					LED_Mode=(LED_Mode|0x07)&0xfd;
					SelectHC573(4,LED_Mode);
				}
				else if(SMG_Mode==3)
				{
					LED_Mode=(LED_Mode|0x07)&0xfb;
					SelectHC573(4,LED_Mode);
				}
			}
		else if(Flash_Flag==0)
			{
				LED_Mode|=0x07;
				SelectHC573(4,LED_Mode);
			}
		}
	}
	if(PWM_times==5)
	{
		jdq_Mode|=0x20;		
		PWM_times=0;
	}
	if(PWM_times==Duty)
	{
		jdq_Mode&=0xdf;
	}
	SelectHC573(5,jdq_Mode);
	P0=temp;
}

第二便是PWM影响IIC时序问题，之前采用的是在iic中直接关闭总中断的方式，当时表面上没有什么问题，但拿频率计测量发现，pwm的频率降为800khz左右，不符合要求，之后我看题目要求中对ADC没有时间上的要求，所以将ADC刷新的时间延迟，放在定时器中没-.5s调用一次，整体观感和性能还是不错的，但数码管还有偶尔会闪烁.

关于掉电不丢失:

掉电不丢失有一个点就是是否第一次上电，我的解决方法是在一个内存地址内写入一个标志位(随便写，我这里采用的是0xac),上电的时候先读取标志位，如果读取到了说明不是第一次，之间读取即可，如果读取到的数据不对，则对存放内容的地址空间写入0 

二.代码部分:
main.c
#include <STC15F2K60S2.H>
#include "intrins.h"
#include "iic.h"
sbit S4=P3^3;
sbit S5=P3^2;
sbit S6=P3^1;
sbit S7=P3^0;
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,0x02,0x78,0x00,0x10};
unsigned char SMG_Mode=1;
unsigned char show_Mode=1;
unsigned int dat_F;
unsigned int count_F;
unsigned char shidu;
unsigned char PCA_times;
unsigned char Distance;
unsigned char param_Mode=1;
unsigned char fre_param=90;
unsigned char shidu_param=40;
unsigned char Dis_param=6;
unsigned int count_times;
unsigned char ADC_Value;
unsigned char DAC_Value;
bit PCA_Flag;
unsigned int times;
unsigned char jdq_Mode=0x00;
unsigned char LED_Mode=0xff;
bit LED_Flag;
bit Flash_Flag;
unsigned char Duty;
unsigned char PWM_times;
unsigned char chufa_times;
bit chufa_Flag=0;
unsigned int Key_times;
bit Key_Flag=0;
void Delay_SMG(unsigned int t)
{
	while(t--);
}
void Delay12us()		//@12.000MHz
{
	unsigned char i;

	_nop_();
	_nop_();
	i = 33;
	while (--i);
}

void SelectHC573(unsigned char channel,unsigned char dat)
{
	P2=(P2&0x1f)|0x00;
	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 Display_SMG(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)
	{
		Display_SMG(1,SMG_Nodot[15]);
		Display_SMG(2,SMG_Nodot[chufa_times/10]);
		Display_SMG(3,SMG_Nodot[chufa_times%10]);
		if(show_Mode==1)
		{
			if(dat_F>9999)
			{
				Display_SMG(4,SMG_Nodot[dat_F/10000]);
			}
			if(dat_F>999)
			{
				Display_SMG(5,SMG_Nodot[dat_F%10000/1000]);
			}
			if(dat_F>99)
			{
				Display_SMG(6,SMG_Nodot[dat_F%1000/100]);
			}
			if(dat_F>9)
			{
				Display_SMG(7,SMG_Nodot[dat_F%100/10]);
			}
			Display_SMG(8,SMG_Nodot[dat_F%10]);
		}
		if(show_Mode==2)
		{
			if(dat_F>9999)
			{
				Display_SMG(6,SMG_Nodot[dat_F/10000]);
			}
			Display_SMG(7,SMG_Dot[dat_F%10000/1000]);
			Display_SMG(8,SMG_Nodot[dat_F%1000/100]);
		}
	}
	if(SMG_Mode==2)
	{
		Display_SMG(1,0x89);
		Display_SMG(7,SMG_Nodot[shidu/10]);
		Display_SMG(8,SMG_Nodot[shidu%10]);
	}
	if(SMG_Mode==3)
	{
		Display_SMG(1,SMG_Nodot[10]);
		if(show_Mode==1)
		{
			if(Distance>99)
			{
				Display_SMG(6,SMG_Nodot[Distance/100]);
			}
			if(Distance>9)
			{
				Display_SMG(7,SMG_Nodot[Distance%100/10]);
			}
			Display_SMG(8,SMG_Nodot[Distance%10]);
		}
		if(show_Mode==2)
		{
			Display_SMG(6,SMG_Dot[Distance/100]);
			Display_SMG(7,SMG_Nodot[Distance%100/10]);
			Display_SMG(8,SMG_Nodot[Distance%10]);
		}
	}
	if(SMG_Mode==4)
	{
		Display_SMG(1,0x8c);
		Display_SMG(2,SMG_Nodot[param_Mode]);
		if(param_Mode==1)
		{
			if(fre_param>99)
			{
				Display_SMG(6,SMG_Nodot[fre_param/100]);
			}
			Display_SMG(7,SMG_Dot[fre_param%100/10]);
			Display_SMG(8,SMG_Nodot[fre_param%10]);
		}
		if(param_Mode==2)
		{
			Display_SMG(7,SMG_Nodot[shidu_param/10]);
			Display_SMG(8,SMG_Nodot[shidu_param%10]);
		}
		if(param_Mode==3)
		{
			Display_SMG(7,SMG_Dot[Dis_param/10]);
			Display_SMG(8,SMG_Nodot[Dis_param%10]);
		}
	}
}
void Timer1Init(void)		//200us@12.000MHz
{
	AUXR &= 0xBF;		
	TMOD = 0x06;		
	TL1 = 0x38;		
	TH1 = 0xFF;		
	TF1 = 0;		
	TR1 = 1;		
	EA=1;
	ET1=1;
}
void Timer2Init(void)		//1ms@12.000MHz
{
	AUXR &= 0xFB;		
	T2L = 0x18;		
	T2H = 0xFC;		
	AUXR |= 0x10;		
	IE2=0x04;
}

void Timer0_Init()
{
	TH0=0xff;
	TL0=0xff;
	TR0=1;
	ET0=1;
}
void Timer0_Service() interrupt 1
{
	count_F++;
}
void PCA_Init()
{
	CMOD=0x01;
	CCON=0x00;
	CCAPM0=0x11;
}
void Send_Wave()
{
	unsigned char i;
	for(i=0;i<8;i++)
	{
		TX=0;
		Delay12us();
		TX=1;
		Delay12us();
	}
}
void Measure_Distance()
{
	CH=CL=0;
	Send_Wave();
	CR=1;
	if(PCA_Flag==0)
	{
		Distance=255;
	}
	if(PCA_Flag==1)
	{
		Distance=times*0.017;
	}
}
void PCA_Service() interrupt 7
{
	CR=0;
	if(CCF0==1)
	{
		CCF0=0;
		PCA_Flag=1;
		times=(CCAP0H<<8)|CCAP0L;
	}
	if(CF==1)
	{
		CF=0;
		PCA_Flag=0;
	}
}
void Timer1_Service() interrupt 3
{
	unsigned char temp;
	count_times++;
	PWM_times++;
	temp=P0;
	if(count_times==5000)
	{
		dat_F=count_F;
		count_F=0;
		count_times=0;
	}
	if(LED_Flag==1)
	{
		if(count_times%500==0)
		{
			Flash_Flag=~Flash_Flag;
			if(Flash_Flag==1)
			{
				if(SMG_Mode==1)
				{
					LED_Mode=(LED_Mode|0x07)&0xfe;
					SelectHC573(4,LED_Mode);
				}
				else if(SMG_Mode==2)
				{
					LED_Mode=(LED_Mode|0x07)&0xfd;
					SelectHC573(4,LED_Mode);
				}
				else if(SMG_Mode==3)
				{
					LED_Mode=(LED_Mode|0x07)&0xfb;
					SelectHC573(4,LED_Mode);
				}
			}
		else if(Flash_Flag==0)
			{
				LED_Mode|=0x07;
				SelectHC573(4,LED_Mode);
			}
		}
	}
	if(PWM_times==5)
	{
		jdq_Mode|=0x20;		
		PWM_times=0;
	}
	if(PWM_times==Duty)
	{
		jdq_Mode&=0xdf;
	}
	SelectHC573(5,jdq_Mode);
	P0=temp;
}
void Timer2_Service() interrupt 12
{
	PCA_times++;
	if(PCA_times==125)
	{
		PCA_times=0;
		Measure_Distance();
	}
	if(Key_Flag==1)
	{
		Key_times++;
	}
}
void ADC_Read()
{
	I2CStart();
	I2CSendByte(0x90);
	I2CWaitAck();
	I2CSendByte(0x43);
	I2CWaitAck();
	I2CStop();
	EA=0;
	I2CStart();	
	I2CSendByte(0x91);
	I2CWaitAck();
	ADC_Value=I2CReceiveByte();
	EA=1;
	I2CSendAck(1);
	I2CStop();
	shidu=ADC_Value/255.0*99;
	
}
void DAC_Caculate()
{
	float k;
	k=204.0/(80-shidu_param);
	if(shidu>80)
	{
		DAC_Value=255;
	}
	if(shidu<shidu_param)
	{
		DAC_Value=51;
	}
	if(shidu<80&&shidu>shidu_param)
	{
		DAC_Value=k*(shidu-shidu_param)+51;
	}
}
void DAC_Write()
{
	DAC_Caculate();
	I2CStart();
	I2CSendByte(0x90);
	I2CWaitAck();
	I2CSendByte(0x43);
	I2CWaitAck();
	I2CSendByte(DAC_Value);
	I2CWaitAck();
	I2CStop();
}
unsigned char AT24C02_Read(unsigned char address)
{
	unsigned char temp;
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(address);
	I2CWaitAck();
	
	I2CStart();
	I2CSendByte(0xa1);
	I2CWaitAck();
	temp=I2CReceiveByte();
	I2CSendAck(1);
	I2CStop();
	return temp;
}
void AT24C02_Write(unsigned char dat)
{
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(0x00);
	I2CWaitAck();
	I2CSendByte(dat);
	I2CWaitAck();
	I2CSendByte(0xac);
	I2CWaitAck();
	I2CStop();
}
void Scan_Key()
{
	if(S4==0)
	{
		Delay_SMG(500);
		if(S4==0)
		{
			switch(SMG_Mode)
			{
				case 1:
					SMG_Mode=2;
				break;
				case 2:
					SMG_Mode=3;
					show_Mode=1;
				break;
				case 3:
					SMG_Mode=4;
					param_Mode=1;
				break;
				case 4:
					SMG_Mode=1;
					show_Mode=1;
				break;
			}
		}
		while(S4==0)
		{
			Display_Dynamic();
			ADC_Read();
		}
	}
	if(S5==0)
	{
		Delay_SMG(500);
		if(S5==0)
		{
			if(SMG_Mode==4)
			{
				switch(param_Mode)
				{
					case 1:
						param_Mode=2;
					break;
					case 2:
						param_Mode=3;
					break;
					case 3:
						param_Mode=1;
					break;
				}
			}
		}
		while(S5==0)
		{
			Display_Dynamic();
			ADC_Read();
		}
	}
	if(S6==0)
	{
		Delay_SMG(500);
		if(S6==0)
		{
			if(SMG_Mode==3)
			{
				switch(show_Mode)
				{
					case 1:
						show_Mode=2;
					break;
					case 2:
						show_Mode=1;
					break;
				}
			}
			if(SMG_Mode==4)
			{
				if(param_Mode==1)
				{
					fre_param+=5;
					if(fre_param>120)
					{
						fre_param=10;
					}
				}
				if(param_Mode==2)
				{
					shidu_param+=10;
					if(shidu_param>60)
					{
						shidu_param=10;
					}
				}
				if(param_Mode==3)
				{
					Dis_param+=1;
					if(Dis_param>12)
					{
						Dis_param=1;
					}
				}
			}
		}
		while(S6==0)
		{
			Display_Dynamic();
			ADC_Read();
		}
	}
	if(S7==0)
	{
		Delay_SMG(500);
		if(S7==0)
		{
			while(S7==0)
			{
				Key_Flag=1;
				Display_Dynamic();
				ADC_Read();
			}
			Key_Flag=0;
			if(Key_times>1000)
			{
				if(SMG_Mode==2)
				{
					chufa_times=0;
					AT24C02_Write(chufa_times);
				}
			}
			if(Key_times<=1000)
			{
				if(SMG_Mode==1)
				{
					switch(show_Mode)
					{
						case 1:
							show_Mode=2;
						break;
						case 2:
							show_Mode=1;
						break;
					}
				}
				if(SMG_Mode==4)
				{
					if(param_Mode==1)
					{
						fre_param-=5;
						if(fre_param<10)
						{
							fre_param=120;
						}
					}
					if(param_Mode==2)
					{
						shidu_param-=10;
						if(shidu_param<10)
						{
							shidu_param=60;
						}
					}
					if(param_Mode==3)
					{
						Dis_param-=1;
						if(Dis_param<1)
						{
							Dis_param=12;
						}
					}
				}
			}
			Key_times=0;
		}
	}
}
void PWM_Config()
{
	if(dat_F>fre_param*100)
	{
		Duty=4;
	}
	if(dat_F<fre_param*100)
	{
		Duty=1;
	}
}
void jdq_Control()
{
	if(Distance>Dis_param*10)
	{
		jdq_Mode|=0x10;
		SelectHC573(5,jdq_Mode);
		if(chufa_Flag==1)
		{
			chufa_Flag=0;
			chufa_times++;
			AT24C02_Write(chufa_times);
		}
	}
	if(Distance<Dis_param*10)
	{
		jdq_Mode&=0xef;
		SelectHC573(5,jdq_Mode);
		chufa_Flag=1;
	}
}
void LED_control()
{
	if(SMG_Mode==1||SMG_Mode==2||SMG_Mode==3)
	{
		LED_Flag=1;
	}
	if(SMG_Mode==4)
	{
		LED_Flag=0;
		LED_Mode|=0x07;
	}
	if(dat_F>fre_param)
	{
		LED_Mode&=0xf7;
		SelectHC573(4,LED_Mode);
	}
	if(dat_F<fre_param)
	{
		LED_Mode|=0x08;
		SelectHC573(4,LED_Mode);
	}
	if(shidu>shidu_param)
	{
		LED_Mode&=0xef;
		SelectHC573(4,LED_Mode);
	}
	if(shidu<shidu_param)
	{
		LED_Mode|=0x10;
		SelectHC573(4,LED_Mode);
	}
	if(Distance>Dis_param*10)
	{
		LED_Mode&=0xdf;
		SelectHC573(4,LED_Mode);
	}
	if(Distance<Dis_param*10)
	{
		LED_Mode|=0x20;
		SelectHC573(4,LED_Mode);
	}
}
void Sys_Init()
{
	SelectHC573(4,0xff);
	SelectHC573(5,0x00);
	Timer1Init();
	EA=0;
	Timer0_Init();
	Timer2Init();
	PCA_Init();
	if(AT24C02_Read(0x01)!=0xac)
	{
		AT24C02_Write(0);
	}
	if(AT24C02_Read(0x01)==0xac)
	{
		chufa_times=AT24C02_Read(0x00);
	}
	EA=1;
}
void main()
{
	Sys_Init();
	while(1)
	{
		Display_Dynamic();
		Scan_Key();
		ADC_Read();
		DAC_Write();
		jdq_Control();
		PWM_Config();
		LED_control();
	}
}
 iic.h
/*	#   I2C代码片段说明
	1. 	本文件夹中提供的驱动代码供参赛选手完成程序设计参考。
	2. 	参赛选手可以自行编写相关代码或以该代码为基础，根据所选单片机类型、运行速度和试题
		中对单片机时钟频率的要求，进行代码调试和修改。
*/
#include <STC15F2K60S2.H>
#include "intrins.h"
sbit scl=P2^0;
sbit sda=P2^1;
#define DELAY_TIME	10
//
static void I2C_Delay(unsigned char n)
{
    do
    {
        _nop_();_nop_();_nop_();_nop_();_nop_();
        _nop_();_nop_();_nop_();_nop_();_nop_();
        _nop_();_nop_();_nop_();_nop_();_nop_();		
    }
    while(n--);      	
}

//
void I2CStart(void)
{
    sda = 1;
    scl = 1;
	I2C_Delay(DELAY_TIME);
    sda = 0;
	I2C_Delay(DELAY_TIME);
    scl = 0;    
}

//
void I2CStop(void)
{
    sda = 0;
    scl = 1;
	I2C_Delay(DELAY_TIME);
    sda = 1;
	I2C_Delay(DELAY_TIME);
}

//
void I2CSendByte(unsigned char byt)
{
    unsigned char i;
	
    for(i=0; i<8; i++){
        scl = 0;
		I2C_Delay(DELAY_TIME);
        if(byt & 0x80){
            sda = 1;
        }
        else{
            sda = 0;
        }
		I2C_Delay(DELAY_TIME);
        scl = 1;
        byt <<= 1;
		I2C_Delay(DELAY_TIME);
    }
	
    scl = 0;  
}

//
unsigned char I2CReceiveByte(void)
{
	unsigned char da;
	unsigned char i;
	for(i=0;i<8;i++){   
		scl = 1;
		I2C_Delay(DELAY_TIME);
		da <<= 1;
		if(sda) 
			da |= 0x01;
		scl = 0;
		I2C_Delay(DELAY_TIME);
	}
	return da;    
}

//
unsigned char I2CWaitAck(void)
{
	unsigned char ackbit;
	
    scl = 1;
	I2C_Delay(DELAY_TIME);
    ackbit = sda; 
    scl = 0;
	I2C_Delay(DELAY_TIME);
	
	return ackbit;
}

//
void I2CSendAck(unsigned char ackbit)
{
    scl = 0;
    sda = ackbit; 
	I2C_Delay(DELAY_TIME);
    scl = 1;
	I2C_Delay(DELAY_TIME);
    scl = 0; 
	sda = 1;
	I2C_Delay(DELAY_TIME);
}

Hans_Rudle
关注
  • 11
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CT107D单片机综合训练平台_IAP15
10-17
CT107D单片机综合训练平台是一款专为学习和实践IAP15系列单片机设计的教育工具。这个平台集成了多种功能模块，旨在帮助用户掌握单片机编程、硬件接口设计以及实际应用开发。IAP15系列单片机，如IAP15F2K61S2，具有在...
第十四届蓝桥杯单片机程序（完整工程文件）
03-17
【标题】：“第十四届蓝桥杯单片机程序（完整工程文件）”是指一个包含有参加第十四届“蓝桥杯”全国软件和信息技术专业人才大赛中单片机设计部分的完整工程项目的压缩包。这个标题暗示了该资源可能包括了参赛者或...
蓝桥杯单片机13届国赛
weixin_51864506的博客
05-20 1416
/ pwm 输出的时候会影响 P05 管脚，所以在 led_handle 函数中，离开的时候把通道改了，让他不影响其他功能，例如加一句select573(0)// number 用来存储继电器开关次数并且写入eeprom里，在湿度界面显示并且验证长按是否把number清零和继电器吸合number是否加1。// eeprom_val用来读取eeprom看是否存储正确，在湿度参数下显示用来验证number是否正确存入。// 考试时不用把number和eeprom_val显示出来，练习只用来验证，考试可去掉。
蓝桥杯单片机第十三届国赛 真题+代码
qq_53471484的博客
07-28 1979
蓝桥杯单片机第十三届国赛代码程序
蓝桥杯单片机第十三届国赛真题解析-测评满分代码
2301_80139889的博客
05-20 3028
本篇详细解析了蓝桥杯单片机第十三届国赛真题中的难点及易错点先讲一下有关4t测评是否可靠的问题，本人认为参考意义极大 百分之90都是可信的，特别是对于一些细节上的问题（相反可能一些很明显的显示问题4t会测不出来，这个我们可以很容易的直接观察到），自己在板子上找不出的bug就会在测评中体现出来 所以碰到问题应该先去解决自己代码上的错误（本篇所示代码在开发板上已实现全部功能）注：题目对开发板配置要求为独立按键。
蓝桥杯单片机第十三届国赛
2301_76605333的博客
04-06 670
蓝桥杯单片机第十三届国赛
蓝桥杯第十三届单片机国赛程序
m0_68973448的博客
05-17 5162
做完总体来说感觉一年比一年难了（估计是被骂的），虽然十三届用的底层少，但是做起来困难重重。最难的难点在于定时器安排问题。15F2K60S2系列单片机只有三个定时器，本届题目考到了频率测量、超声波、PWM输出，再加上刷新，每一个都需要一个定时器，比较简单的做法之一是直接用单片机外设PCA来检测超声波，节省定时器资源。（
蓝桥杯学习笔记 CT107D 第十五届省赛
Hans_Rudle的博客
05-05 187
这次蓝桥杯也是有惊无险侥幸拿到省一,准备把这一次省赛更完专注搞国赛去了说一下这次比赛我的问题吧:第一个就是频率测量时定时器的配置，我最开始是两个定时器分布位操作配置，但数码管显示异常，放在一个语句里面一起声明正常第二个就是数码管显示的代码过于复杂，想着能不能简化一些.对于这次的数据包，在参考代码部分没有什么改动，照着去年来即可，就是原理图改动很大，但只需看第一页就行，如果不确定端口再去下面几页找端口，回来对应MCU的端口即可(除了按键其他都写着下图了)
蓝桥杯单片机学习笔记（1）——国信长天CT107竞赛板简述
qq_42879429的博客
03-02 7964
最近因为延期开学，一直呆在家里，有机会学习准备一下蓝桥杯的电子类单片机组的比赛，正好写点东西，将学习的过程记录一下。 这是第一篇学习笔记，我准备简单介绍一下竞赛使用的单片机开发板——CT107开发板。 1. 概述实验板组成部分 关于开发板的相关资料可以从蓝桥杯官网下载。 大赛使用的单片机是IAP15F2K61S2，是STC公司生产的15系列1T型单片机，在1T模式下比传统8051快8-12倍，内...
蓝桥杯单片机串口通信学习提升笔记配套工程
05-19
蓝桥杯单片机串口通信学习提升笔记配套工程 本篇文章除了学习基础，还主要研究学习以下问题： 1.在蓝桥杯单片机实训平台上串口通信实现printf()函数 2.蓝桥杯单片机串口通信发送变量乱码问题 3.接收中断数据处理...
蓝桥杯单片机蓝桥杯单片机.rar
06-04
【标题】：“蓝桥杯单片机蓝桥杯单片机.rar”是一个压缩包文件，主要聚焦于“蓝桥杯”这一知名的编程竞赛中的单片机相关知识。 【描述】：该压缩包内容包含了参赛者自己编写的源代码以及一些参考资料。这表明，此...
2023年蓝桥杯单片机编程笔记.docx
10-27
单片机编程笔记 一、 IO口编程 在单片机编程中，IO口编程是最基本也是最重要的一部分。该开发板使用了573锁存器，通过P2口的5,6,7位连接3-8译码器，扩展出了8个口，其中4个口分别连接4个573锁存器。以ＬＥＤ的...
蓝桥杯14小白月赛题解
qq_73671385的博客
07-16 112
用前缀和求重新启动的次数，特盘端点。分别考虑每一位，组合数。pi/ti,for遍历。
探索Perl语言：入门学习与实战指南
洛秋的博客
07-15 639
Perl（Practical Extraction and Report Language）由Larry Wall于1987年创建，旨在帮助系统管理员简化日常任务。高效灵活：Perl的语法灵活多样，支持多种编程风格（过程式、面向对象等）。强大的文本处理能力：内置强大的正则表达式支持，是处理文本数据的利器。丰富的模块库：通过CPAN（Comprehensive Perl Archive Network）可以方便地获取和使用各类模块。Perl广泛应用于系统管理、Web开发、网络编程、数据库操作等领域。
NumPy库学习之np.random.rand函数
qq_46396470的博客
07-15 156
是 NumPy 库中的一个函数，用于生成随机数。这些随机数是从均匀分布 [0, 1) 中抽取的，即每个数都在0到1之间，但不包括1。
钓鱼攻击 - 基础学习
最新发布
Reset
07-16 396
钓鱼攻击是一种典型的欺诈式攻击手段，攻击者通过伪装成可以信任的角色，利用电子邮件或其他通信渠道向被攻击者发送植入了木马的文档或恶意链接，并诱骗被攻击者点击执行，从而实现对被攻击者计算机的远程控制或恶意程序感染。
python 语法学习 day 7
2303_79973545的博客
07-15 228
-----元组之间可以进行比较，比较的规则是逐个比较元组中的元素。首先比较第一个元素，如果相等，则比较第二个元素，以此类推。如果所有元素都相等，那么元组相等；否则，比较的结果取决于第一个不相等元素的比较结果。题意:统计单词的种类以及数量(忽略大小写)，最终以降序输出（出现次数相同的单词根据单词的大小升序输出）-------掌握如何将一个英语句子中的单词拆出来,并且去掉标点符号。EOF，输入后产生异常-->>捕获异常，结束输入。第一次提交的答案是：先把所有输入值放在列表里面。------字典排序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值