蓝桥杯基础技能训练

已于 2023-03-16 22:46:02 修改
阅读量2k 收藏 28
点赞数 6
分类专栏： 蓝桥杯C51 文章标签： 单片机 嵌入式硬件
于 2023-03-15 20:59:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/artorialili/article/details/129533095
版权

                                   51单片机系统浓缩图

1. HC138译码器

· 用3个输入引脚，实现8个输出引脚，而且这个八个输出引脚中只要一个低电平，所以我们只需要记住真值表就行

 

#include "reg52.h"  



sbit HC138_A = P2^5;        

sbit HC138_B = P2^6;        

sbit HC138_C = P2^7;   


void Init74HC138(unsigned char n)

{

        switch(n)

        {

                case 4:  //LED

                        HC138_A = 0;

                        HC138_B = 0;

                        HC138_C = 1;

                        break;

                case 5:  //蜂鸣器与译码器

                        HC138_A = 1;

                        HC138_B = 0;

                        HC138_C = 1;

                        break;

                case 6:  //数码管位置

                        HC138_A = 0;

                        HC138_B = 1;

                        HC138_C = 1;

                        break;

                case 7:  //数码管内容

                        HC138_A = 1;

                        HC138_B = 1;

                        HC138_C = 1;

                        break;

                case 8:  //关闭所有设备

                        HC138_A = 0;

                        HC138_B = 0;

                        HC138_C = 0;

                        break;

        }

}

由高人指点，这种方法并不好用，因为在译码器切换的时候，他是加上去的，也就是会打开到别的寄存器，所以我们直接使用下面的方法。

2. HC573

 573锁存器有20个引脚，D1~D8是数据输入端，Q1~Q8是数据输出端，LE为锁存控制端。当锁存使能端LE为高时，573的锁存对于数据是透明的（也就是说输出同步）。当锁存使能变低时，符合建立时间和保持时间的数据会被锁存。使用其可以替换HC138，两个功能相同

#include "reg52.h"
void SelectHC573(unsigned channel)
{
     
	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;
	}
             
}

两者的功能相同，因此我们可以简便的来替代一下

void InitHC138 (unsigned char n)  
{
	 switch(n)
	{
		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;
	}
}

 3. 控制LED与继电器

两者都是直接给对应引脚给上电平即可

 

// 任务：
/* 先让奇数的灯闪，再让偶数的灯闪，然后所有的灯闪3下，最后依次点亮所有的灯，然后再依次熄灭，然后循环 */

void LEDRunning()

{
        char i = 0;
        P0 = 0xaa;
        Delay(60000);
        P0 = 0x55;
        Delay(60000);    

        for(i = 0; i < 3; i++)

        {

                P0 = 0x00; //全灭
                Delay(60000);
                P0 = 0xff; //全亮
                Delay(60000);
        }

        for(i = 0; i < 8; i++)

        {
                P0 <<= 1; //按顺序依次闪过
                Delay(60000);
        }

        for(i = 0; i < 8; i++)

        {
                P0 <<= 1;
                P0 |= 1;  //熄灭
                Delay(60000);
        }
}



main()

{

        Init74HC138(4);   //打开LED的138                            
        while(1)
        {
                LEDRunning();                                
        }

}

蜂鸣器与继电器

#include "reg52.h"

void Delay(unsigned int t)
{
	while(t--);
	while(t--);
}

void InitHC138(unsigned char n)
{
	switch(n)
	{
		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;
	}
}

void OutPutP0(unsigned char channel, unsigned char dat)
{
	InitHC138(channel);
	P0 = dat;
}

void LEDRunning()
{
	unsigned char i;
	
	for(i = 0; i < 3; i++)
	{
		OutPutP0(4,0x00);
		Delay(60000);
		Delay(60000);
		OutPutP0(4,0xff);
		Delay(60000);
		Delay(60000);
	}
	
	for(i = 1; i <= 8; i++)
	{
		OutPutP0(4,(0xff << i));
		Delay(60000);
	}
	
	OutPutP0(5,0x10);
	Delay(60000);
	Delay(60000);
	OutPutP0(5,0x00);
	
	InitHC138(4);
	for(i = 1; i <= 8; i++)
	{
		OutPutP0(4,~(0xff << i));
		Delay(60000);
	}
	
	OutPutP0(5,0x40);
	Delay(60000);
	Delay(60000);
	OutPutP0(5,0x00);
}

void InitSystem()
{
	OutPutP0(5,0x00);
}

void main()
{
	InitSystem();
	while(1)
	{
		LEDRunning();
	}
}

4. 数码管

 

 其中a、b、c、d、e、f、g、dp引脚分别对应8个段码，该8个引脚通过74HC573锁存器与单片机的P0端口相连。另外有com1～com4四个公共控制脚，该应用为高电平则使能对应位的数码管。两个F3461BH一共有8个com控制引脚，也是通过74HC573锁存器与单片机的P0端口相连的。因此，在操控数码管显示的过程中也离不开74HC138译码器和74HC573锁存器。

任务：

在 8 位数码管中，左边 4 位数码管显示 年份“2018 ”，接着 2 位是分隔符“--”，靠右的2 位数码管显示月份。从 1 月份开始，每隔一段时间加 1 个月，到 12 月之后又从 1 月开始递增， 如此循环往复。 
#include "reg52.h"

unsigned char code SMG_duanma[18]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,
     0x80,0x90,0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
unsigned char yue=1;
void Delay(unsigned int t)
{
	while(t--);
}


void InitHC138 (unsigned char n)  //ͨµÀÑ¡Ôñ
{
	switch(n)
	{
		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;
	}
}

void ShowSMG_Bit(unsigned char dat,unsigned int pos)
{
	InitHC138(6);   //ÊýÂë¹ÜµÄλÖÃ
	P0=0X01<<pos;
	InitHC138(7);   //ÊýÂë¹ÜµÄÄÚÈÝ
	P0=dat;
}

void Display_SMG()
{
	
	ShowSMG_Bit(SMG_duanma[2],0);
	Delay(500);
	ShowSMG_Bit(SMG_duanma[0],1);
  Delay(500);
	ShowSMG_Bit(SMG_duanma[1],2);
	Delay(500);
	ShowSMG_Bit(SMG_duanma[8],3);
  Delay(500);
	ShowSMG_Bit(SMG_duanma[16],4);
	Delay(500);
	ShowSMG_Bit(SMG_duanma[16],5);
  Delay(500);
	ShowSMG_Bit(SMG_duanma[yue/10],6);
	Delay(500);
	ShowSMG_Bit(SMG_duanma[yue%10],7);
  Delay(500);

}

void Delay2(unsigned int t)
{
	while(t--)
	{
		Display_SMG();
	}
}

void InitSystem()
{
	InitHC138(5);  //¹Ø±Õ¼ÌµçÆ÷
  P0=0x00;
	InitHC138(4);  //´ò¿ªµÆ
	P0=0xff;
 	P2=0x00;  //¹Ø±ÕHC138
}

void main()
{
	 InitSystem();
	while(1)
	{
	  Display_SMG();
		yue++;
		if(yue>12)
			yue=1;
	 Delay2(100);
	}
}

5. 独立按键

一般情况下，独立按键有两个引脚，其中一个通过上拉电阻接到单片机的I/O端口，另外一端接地。也就是说，平时按键没有动作的时候，输出的是高电平，如果有按下动作发生，则输出的是低电平。那么，我们在程序设计的时候，只要扫描跟按键引脚相连的I/O端口，如果发现有低电平产生，则判定该按键处于按下状态。有些时候，电路或者外围有电磁干扰，也会使单片机的I/O端口产生低电平，这种干扰信号会让单片机误认为是按键动作。所以，在扫描按键的时候应该做去抖动处理，把干扰信号过滤掉，从而获得准确的按键状态信号。

任务：
1、将 CT107D 上 J5 处跳帽接到 2～3 引脚，使 S4、S5、S6 和 S7 成为 4 个独立按键。
2、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
3、循环扫描按键状态，在确认按键按下时，进行去抖动处理。当 S7 按键按下时，点亮
L1 指示灯，松开后熄灭；当 S6 按键按下时，点亮 L2 指示灯，松开后熄灭；当 S5 按键按下
时，点亮 L3 指示灯，松开后熄灭；当 S4 按键按下时，点亮 L4 指示灯，松开后熄灭 
#include "reg52.h"
// 按键定义
sbit S7=P3^0;
sbit S6=P3^1;
sbit S5=P3^2;
sbit S4=P3^3;


//灯光定义
sbit L1=P0^0;
sbit L2=P0^1;
sbit L3=P0^2;
sbit L4=P0^3;
sbit L5=P0^4;
sbit L6=P0^5;

void SelectHC138(unsigned char n)
{
	switch(n)
	{
		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;
	}
}
void Delay(unsigned int t)
{
  while(t--);
}
unsigned char flag=0;
void KeyWorking()
{
	if(S7==0)
	{
		Delay(100);
		if(S7==0)
		{
			if(flag==0)
			{
				L1=0;
				flag=1;
			}
			else if(flag==1)
			{
				L1=1;
				flag=0;
			}
			while(S7==0);
		}
	   
	}
	if(S6==0)
	{
		Delay(100);
		if(S6==0)
		{
			if(flag==0)
			{
			  L2=0;
				flag=2;
			}
			else if(flag==2)
			{
				L2=1;
				flag=0;
			}
			while(S6==0);
		}
	   
	}
	if(S5==0)
	{
		Delay(100);
		if(S5==0)
		{
			if(flag==1)
			{
				L3=0;
				while(S5==0);
				L3=1;
			}
			else if(flag==2)
			{
				L5=0;
				while(S5==0);
				L5=1;
			}
		}
	   
	}
	if(S4==0)
	{
		Delay(100);
		if(S4==0)
		{
			if(flag==1)
			{
			 L4=0;
				while(S4==0);
			 L4=1;
			}
		else if(flag==2)
			{
			 L6=0;
			 while(S4==0);
			 L6=1;
			}
			
		}

	}


}
void InitSystem()
{
	SelectHC138(5);
	P0=0x00;
	SelectHC138(4);
	P0=0xff;
}
void main()
{
	InitSystem();
	while(1)
	{
	 KeyWorking();
	
	
	}
	
}

6 .矩阵键盘的使用

与独立按键不同的是，按键的两个引脚都分别连接的单片机的I/O端口，一个作为行信号，另外一个作为列信号。

 对与矩阵键盘，我们只能逐行扫描，然后读取列的状态信号。如果R3行输出低电平，那么黄色按键如果有按下动作的话，那读取C2列信号也应该为低电平，而该行上其他没有按下动作的按键的列信号则为高电平。因此，我们可以得到矩阵键盘的基本扫描步骤：

 <1> R1输出低电平，R2、R3、R4输出高电平，逐个读取判断列信号，如果都为高电平则R1行上没有按键按下。
 <2> R2输出低电平，R1、R3、R4输出高电平，逐个读取判断列信号。
 <3> R3输出低电平，R1、R2、R4输出高电平，发现C2列信号为低电平，那么可以判断得R3行的C2列的按键有按下动作。
 <4> R4输出低电平，R1、R3、R4输出高电平，逐个读取判断列信号。

任务：
1、将 CT107D 上 J5 处跳帽接到 1～2 引脚，使 S4 到 S19 成为 4X4 的矩阵键盘。
2、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
3、循环扫描矩阵键盘状态，发现有按键按下，等待其松开后，在数码管的最左边 1 位
显示相应的数字。从左至右，从上到下，依次显示“ 0 ”到“ F ”。即按下 S7 ，显示“ 0 ”，
按下 S11 显示“ 1 ”，按下 S15 显示“ 2 ”，按下 S6 显示“ 4 ”...依次类推。 
#include "reg52.h"

sfr P4=0xc0;
sbit S1=P3^0;
sbit S2=P3^1;
sbit S3=P3^2;
sbit S4=P3^3;

sbit C1=P4^4;
sbit C2=P4^2;
sbit C3=P3^5;
sbit C4=P3^4;


unsigned char code SMG_DM[18]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,
	0x90,0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};


void Delay(unsigned char t)
{
  while(t--);
}
void SelectHC138(unsigned char n)
{
	switch(n)
	{
		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;
	}
}
unsigned char Key=0;

void SMG_Bit(unsigned char dat)
{
	SelectHC138(6);
	P0=0x01;
	SelectHC138(7);
	P0=dat;
}
void ScanKey()
{
	//==========µÚÒ»ÐÐ
	S1=0;S2=1;S3=1;S4=1;
	if(C1==0)
	{
		Delay(100);
		if(C1==0)
			Key=0;
		while(C1==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C2==0)
	{
		Delay(100);
		if(C2==0)
			Key=1;
		while(C2==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C3==0)
	{
		Delay(100);
		if(C3==0)
			Key=2;
		while(C3==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C4==0)
	{
		Delay(100);
		if(C4==0)
			Key=3;
		while(C4==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	//==========µÚÒ¶þÐÐ
	S1=1;S2=0;S3=1;S4=1;
	if(C1==0)
	{
		Delay(100);
		if(C1==0)
			Key=4;
		while(C1==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C2==0)
	{
		Delay(100);
		if(C2==0)
			Key=5;
		while(C2==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C3==0)
	{
		Delay(100);
		if(C3==0)
			Key=6;
		while(C3==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C4==0)
	{
		Delay(100);
		if(C4==0)
			Key=7;
		while(C4==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	//==========µÚÈýÐÐ
	S1=1;S2=1;S3=0;S4=1;
	if(C1==0)
	{
		Delay(100);
		if(C1==0)
			Key=8;
		while(C1==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C2==0)
	{
		Delay(100);
		if(C2==0)
			Key=9;
		while(C2==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C3==0)
	{
		Delay(100);
		if(C3==0)
			Key=10;
		while(C3==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C4==0)
	{
		Delay(100);
		if(C4==0)
			Key=11;
		while(C4==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	//==========µÚËÄÐÐ
	S1=1;S2=1;S3=1;S4=0;
	if(C1==0)
	{
		Delay(100);
		if(C1==0)
			Key=12;
		while(C1==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C2==0)
	{
		Delay(100);
		if(C2==0)
			Key=13;
		while(C2==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C3==0)
	{
		Delay(100);
		if(C3==0)
			Key=14;
		while(C3==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
	if(C4==0)
	{
		Delay(100);
		if(C4==0)
			Key=15;
		while(C4==0)
		{
			SMG_Bit(SMG_DM[Key]);
		}
	}
}
void InitSystem()
{
	SelectHC138(5);
	P0=0x00;
	SelectHC138(4);
	P0=0xff;
}
void main()
{
	InitSystem();
	while(1)
	{
		//SMG_Bit(SMG_DM[Key]);
		ScanKey();
	}
}

7. 中断相关寄存器

一般来说，51单片机有5个中断源（忽略定时/计数器2），分2个优先级，这个5个中断源按照自然优先级从高到低依次为：
    外部中断0：INT0
    定时/计数器0：TF0
    外部中断1：INT1
    定时/计数器1：TF1    
    串口中断：RI/TI

中断相关的寄存器有4个，每个寄存器都是可以位寻址的，这该编程带来了方便。    其中2个为控制寄存器：IE寄存器与IP寄存器：

 另外2个为中断请求标志：TCON寄存器与SCON寄存器：

 

 一般情况下，中断的处理函数有两个，其一为中断初始化函数，其二为中断服务函数。初始化函数就是一个普通的函数，而中断服务函数却有特殊的格式要求：
    <1> 中断函数没有返回值，也不能带参数。
    <2> 函数名后面要跟一个关键字interrupt，说明这是一个中断服务函数。
    <3> 在关键字interrupt后面要跟上中断号，说明这个中断服务函数是为那个中断服务的。 

8.定时器

 51单片机有两个定时/计数器T0和T1，为16位加法计数器，由低8位TLx和高8位THx两个寄存器组成，最大计数值为65535个计数脉冲。
    该加1计数器的计数脉冲来源有2个：
    <1> 系统时钟振荡器输出的12分频。
    <2> T0或T1引脚输入的外部脉冲信号。
     每接收到一个计数脉冲，计数器就会加1，当计数值累计至全为1时（8位255，13位8191，16位65535），再输入一个计数脉冲，计数器便会溢出回零，并且计数器的溢出是TCON寄存器的TF0或TF1位置1，同时向内核提出中断请求。如果定时/计数器工作于定时模式，则表示间隔定时时间到，如果工作与计数模式，则表示计数值已满。
     假设单片机的外部晶振为12MHz，那么，经过12分频后输入计数器的计数脉冲为1MHz，即每个脉冲的周期为1us。因此定时器T0的16位工作模式最大的定时时间为65535us，65.5ms。如果要定时10ms的话，计数器就不能够从0开始计数了，必须给它一个计数初值。怎么计算这个初值呢？
    要定时10ms，则相当于计数10000个脉冲后计数器的值就到达65535了，那么开始计数的这个地方就是计数初值。
    65535 - 10000 = 55535 = 0xd8ef
    把这个计算得到的初值写入TH0和TL0寄存器即可：
    TH0 = 0xd8；或者 TH0 = (65535 - 10000) / 256;
    TL0 = 0xef; 或者  TL0 = (65535 - 10000) % 256;

定时/计数器相关的寄存器除了计数初值寄存器THx和TLx之外，就是TMOD寄存器和TCON寄存器，务必掌握。
    <1> TMOD模式控制寄存器，不能进行位寻址，只能字节操作。

    <2> TCON中断标志寄存器

定时/计数器的程序设计中，通常有两个函数：初始化函数和中断服务函数。
    在初始化函数中，一般需要进行以下几个配置：
    <1> 配置工作模式，即对TMOD寄存器编程。
    <2> 计算技术初值，即对THx和TLx寄存器进行赋值。
    <3> 使能定时/计数器中断，即ET0或ET1置1。
    <4> 打开总中断，即EA =1。
    <5> 启动定时器，即TR0或TR1置1。
    在中断服务函数中，一般需要进行以下的编程：
    <1> 如果不是自动重装模式，需要对THx和TLx重新赋值。
    <2> 进行间隔定时到达的逻辑处理（越少越好）。

任务：

1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
2、利用定时/计数器 T0 的模式 1 实现 50ms 的间隔定时。
3、在 50ms 间隔定时的基础上，每隔 1 秒 L1 指示灯闪烁一次，即 L1 指示灯循环点亮
0.5 秒，熄灭 0.5 秒。
4、每隔 10 秒 L8 指示灯闪烁 1 次，即 L1 指示灯循环点亮 5 秒，熄灭 5 秒 
#include "reg52.h"  

sbit HC138_A = P2^5;        
sbit HC138_B = P2^6;        
sbit HC138_C = P2^7;        

sbit LED1 = P0^0;        
sbit LED2 = P0^1;        

void Init74HC138(unsigned char n)
{
        switch(n)
        {
                case 4:
                        HC138_A = 0;
                        HC138_B = 0;
                        HC138_C = 1;
                        break;
                case 5:
                        HC138_A = 1;
                        HC138_B = 0;
                        HC138_C = 1;
                        break;
                case 6:
                        HC138_A = 0;
                        HC138_B = 1;
                        HC138_C = 1;
                        break;
                case 7:
                        HC138_A = 1;
                        HC138_B = 1;
                        HC138_C = 1;
                        break;
                case 8:
                        HC138_A = 0;
                        HC138_B = 0;
                        HC138_C = 0;
                        break;
        }
}
/*===============初始化定时器0==================*/
void Init_Timer0()
{
        TMOD = 0x01;                    //16位定时模式
        TH0 = (65536 - 50000) / 256;      //定时50ms
        TL0 = (65536 - 50000) % 256;
        ET0 = 1;                       //使能定时器T0中断
        EA = 1;                       //使能总中断        
        TR0 = 1;                       //启动定时器T0
}
/*============定时器0中断服务函数===============*/
unsigned char count = 0;
void SeviceTimer0() interrupt 1
{
        TH0 = (65536 - 50000) / 256;
        TL0 = (65536 - 50000) % 256;
        count++;
        if(count == 10)                    //0.5秒定时到
        {
                LED1 = ~LED1;
        }
        if(count == 20)                    //1秒定时到
        {
                LED2 = ~LED2;
                count = 0;
        }
}
/*==================主函数======================*/
main()
{
        Init74HC138(4);
        Init_Timer0();
        while(1);
}

9. PWM控制

1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
2、PWM 脉宽信号的频率为 100Hz。
3、L1 指示灯有 4 种亮度，分别是：完全熄灭、10%的亮度、50%的亮度和 90%的亮度。
4、按下 S7 按键，循环切换 L1 指示灯的四种亮度模式 
#include "reg52.h"
#include "HC573.h"
#includd "SMG.h"

sbit L1 = P0^0;
sbit S7 = P3^0;

/*¶¨Ê±Æ÷Ïà¹Ø*/
unsigned char count = 0;

void InitTimer0()
{
	TMOD = 0x01; //ʹÓö¨Ê±Æ÷1µÄ16λģʽ
	TH0 =  (65535 - 100)/256      // ¼ÆÊý³õÖµ
	TL0 =  (65535 - 100)%256
	
	ET0 = 1;
	EA = 1;
	TR0 = 1;
}

void ServiceTimer0() interrupt 1
{
	TH0 =  (65535 - 100)/256      // ¼ÆÊý³õÖµ
	TL0 =  (65535 - 100)%256
	
	count++;
	if(count == pwm_duty)
	{
		L1 = 1;
	}
	if(count == 100)
	{
		L1 = 0;
		count = 0;
	}
}


// °´¼ü
unsigned char stat = 0;
void Scankeys()
{
	if(S7 == 0)
	{
		Delay(200)
		if(S7 == 0)
		{
			switch(stat)
			{
				case 0:
					L1 = 0;  //¿ªµÆ
				  pwm_duty = 10;
				  stat =1;
				break;
				
				case 1:
				  pwm_duty = 50;
				  stat =2;
				break;
				
				case 1:
				  pwm_duty = 90;
				  stat =3;
				break;
				
				case 3:
					L1 = 0;
				  stat = 0;
				break;	
			}
		}
	}
}

10. 串行接口

在串口通信的程序设计中，主要有串口初始化和数据收发两个部分。
    在初始化函数中，基本步骤如下：
    <1> 设置定时器1的工作模式，也就是对TMOD寄存器赋值。
    <2> 计算波特率参数，并赋值给TH1和TL1寄存器。
    <3> 打开定时器1。
        如果使用的是STC 12系统单片机，则要设置AUXR寄存器。
    <4> 设置SCON寄存器。
    <5> 使能串口中断ES。
    <6> 使能总中断EA。

1、初始化串口为模式 1，即 8 位 UART 模式，波特率 9600，允许接收。
2、数据发送采用查询方式，数据接收采用中断方式。
3、系统上电初始化之后，单片机向上位机发送两个字节：
0x5a 和 0xa5（串口助手以十六进制 HEX 发送和显示）。
4、串口每成功接收到一个字节后，在该字节基础上加 1，
然后通过串口发送回上位机。
5、注意 89C52 单片机和 IAP15F2K61S2 单片机串口应用的
差别，使用 9600 波特率时，晶振时钟选择 11.0592MHz。 
#include "reg52.h" 

sfr AUXR=0x8e;

unsigned char tmpRecv;
void Init_Uart()
{
        TMOD=0x20; 
        TH1=0xfd;
        TL1=0xfd; 
        AUXR=0x00;
        TR1=1; 
        SCON = 0x50; 
        ES=1; 
        EA=1; 
}

void SendByte(unsigned char dat)
{
        SBUF = dat; 
        while(TI == 0);
        TI = 0; 
}


main()
{
        Init_Uart();
        SendByte(0x5a);
        SendByte(0xa5);
        while(1);
}

一般情况下，上位机的命令可能不是一个字节，而是多个字节组成的命令帧，有的长度固定，有的长度变化；而且要求返回的数据可能也不是一个字节，可能是一个数组，也有可能是一个字符串等。在蓝桥杯的比赛中，也不可能让你只是收发一个字节而已，因此，在串口这一个单元中，必须多加一个强化环境，掌握多字节的数据帧收发应用。

1、初始化串口为模式 1，即 8 位 UART 模式，波特率 9600，允许接收。
2、数据发送采用查询方式，数据接收采用中断方式。
3、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯，通过串口向上位机发送
字符串：“Welcome to XMF system！”，回车换行。
4、上位机通过串口发送单字节命令，控制单片机的 8 个 LED 灯开关，单片机响应正确
的控制命令后，完成相应的灯光操作。
5、上位机通过串口发送单字节命令，读取单片机运行信息，单片机响应正确的读取命
令后，向上位机返回指定的信息。

串口初始化函数Init_Uart()和单字节发送函数SendByte()就不需要修改，拷过来就能用

<1> 字符发送

<2>字符接收

 <3>命令解析与执行

11.DS18B20温度传感器

在蓝桥杯“单片机设计与开发”赛项中，会提供一个关于DS18B20的库文件，里面有传感器复位、写字节和读字节三个函数。所以，你不一定要把单总线的时序搞清楚，但你一定要把DS18B20的基本操作流程弄明白。

通过单线总线端口访问DS18B20的协议如下：
    步骤1： 复位初始化  
    步骤2： ROM操作指令
    步骤3： DS18B20功能指令

三个重要的指令：

    <1> CCH：跳过ROM指令，忽略64位ROM地址，直接向DS18B20发起各种温度转换指令。
    <2> 44H：温度转换指令，启动DS18B20进行温度转换，转换时间最长为500ms（典型值为200ms），结果保存在高速RAM中。
    <3> BEH：读暂存器指令，读取高速暂存存储器9个字节的内容。

读取一次温度传感器数值的操作：

    <1> 主机对DS18B20进行复位初始化。
    <2> 主机向DS18B20写0xCC命令，跳过ROM。
    <3> 主机向DS18B20写0x44命令，开始进行温度转换。   

    <4> 等待温度转换完成。
    <5> 主机对DS18B20进行复位初始化。
    <6> 主机向DS18B20写0xCC命令，跳过ROM。
    <7> 主机向DS18B20写0xBE命令，依次读取DS18B20发出的从第0一第8，共九个字节的数据。如果只想读取温度数据，那在读完第0和第1个数据后就不再理会后面DS18B20发出的数据即可，或者通过DS18B20复位，停止数据的输出。

（如果你利用大赛提供的DS18B20的库文件，也就是onewire.c和onewire.h，进行程序设计的时候，没能正确的读出温度传感器的数值，对库文件中代码的时序进行适当的调整即可。）、

onewire.h


#include "reg52.h"

sbit DQ = P1^4;  


void Delay_OneWire(unsigned int t) 
{
	while(t--);
}


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

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(50);
	}
	return dat;
}


bit init_ds18b20(void)
{
  	bit initflag = 0;
  	
  	DQ = 1;
  	Delay_OneWire(120);
  	DQ = 0;
  	Delay_OneWire(800);
  	DQ = 1;
  	Delay_OneWire(100); 
    initflag = DQ;     
  	Delay_OneWire(50);
  
  	return initflag;
}
温度传感器任务：
1、将 DS18B20 的底层驱动代码文件正确移植到工程中。
2、循环采样启动 DS18B20 进行温度转换。
3、将 DS18B20 的温度转换结果读出，进行换算，保留 1 位
小数 ，并显示在数码管靠右端，显示格式如图。
4、注意，在进行 DS18B20 底层驱动代码文件移植时，需确
认单总线的 时序参数是否匹配

12. DS1302时钟系统

 DS1302将地址和读写控制放到一个字节里面，形成一个控制字。

为了方便程序设计，我们把读寄存器地址、写寄存器地址和日历时钟寄存器方面用三个数组定义。

任务如下：
1、将 DS1302 的底层驱动代码文件正确移植到工程中。
2、初始化 DS1302 的默认启动参数为：
20 年 4 月 19 日 23 时 58 分 24 秒， 周六 。
3、系统上电后， DS1302 实时时钟从默认参数启动运行，并
将当前的 时、分、秒 显示在数码管上，时分秒之间用“ - ”分隔。
显示格式如图 

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

sbit SCK=P1^7;		
sbit SDA=P2^3;		
sbit RST = P1^3;   // DS1302¸´Î»												

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);			
}

DS1302时钟模块

#include "reg52.h"
#include "ds1302.h"
unsigned char Write_DS1302[7]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c}; //写寄存器
unsigned char Read_DS1302[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};  //读寄存器
unsigned char Timer[7]={0x50,0x59,0x12,0x18,0x04,0x06,0x22};        //日历寄存器

unsigned char code SMG_DM[18]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,
	0x90,0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};

void SelectHC138(unsigned char n)
{
	switch(n)
	{
		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;
	}
}
//时钟初始化
void DS1302_Config()
{
	unsigned char i;
	Write_Ds1302_Byte(0x8e,0x00);
	for(i=0;i<7;i++)
	{
	Write_Ds1302_Byte(Write_DS1302[i], Timer[i]);
	}
	Write_Ds1302_Byte(0x8e,0x80);

}
void Read_DS1302_Timer()
{
	unsigned char i;
	for(i=0;i<7;i++)
	{
	Timer[i]=Read_Ds1302_Byte(Read_DS1302[i]);
	}
	if(Timer[2]>0x12)
	{
		Timer[2]-=0x12;
	}
}
void Delay_SMG(unsigned int t)
{
  while(t--);
}
void SMG_Bit(unsigned char dat,unsigned char pos)
{
	SelectHC138(6);
	P0=0x01<<pos;
	SelectHC138(7);
	P0=SMG_DM[dat];
}
void Display_SMG()
{
	SMG_Bit(Timer[2]/16,0);
	Delay_SMG(100);
	SMG_Bit(Timer[2]%16,1);
	Delay_SMG(100);
	SMG_Bit(16,2);
	Delay_SMG(100);
	SMG_Bit(Timer[1]/16,3);
	Delay_SMG(100);
	SMG_Bit(Timer[1]%16,4);
	Delay_SMG(100);
	SMG_Bit(16,5);
	Delay_SMG(100);
	SMG_Bit(Timer[0]/16,6);
	Delay_SMG(100);
	SMG_Bit(Timer[0]%16,7);
	Delay_SMG(100);
	
	
}

void InitSystem()
{
	SelectHC138(5);
	P0=0x00;
	SelectHC138(4);
	P0=0xff;
}
void main()
{
	InitSystem();
	DS1302_Config();
	while(1)
	{
		Read_DS1302_Timer();
		Display_SMG();
	
	
	}
}

13. 频率测试

#include "reg52.h"
unsigned char code SMG_DM[18]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,
	0x90,0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
unsigned int count_f=0;
unsigned int dat=0;
unsigned char count_s=0;
void SelectHC138(unsigned char n)
{
	switch(n)
	{
		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;
	}
}
//============================ÊýÂë¹ÜÏÔʾ
void Delay_SMG(unsigned int t)
{
  while(t--);
}
void SMG_Bit(unsigned char dat,unsigned char pos)
{
	SelectHC138(6);
	P0=0x01<<pos;
	SelectHC138(7);
	P0=dat;
}
void Display_SMG()
{
	SMG_Bit(SMG_DM[15],0);
	Delay_SMG(500);
	SMG_Bit(0xff,1);
	Delay_SMG(500);
	SMG_Bit(0xff,2);
	Delay_SMG(500);
	if(dat>9999)
	{
	  SMG_Bit(SMG_DM[dat/10000],3);
	  Delay_SMG(500);
	}
	if(dat>999)
	{
	  SMG_Bit(SMG_DM[(dat/1000)%10],4);
	  Delay_SMG(500);
	}
	if(dat>99)
	{
	  SMG_Bit(SMG_DM[(dat/100)%10],5);
	  Delay_SMG(500);
	}
	if(dat>9)
	{
	  SMG_Bit(SMG_DM[(dat/10)%10],6);
	  Delay_SMG(500);
	}
	  SMG_Bit(SMG_DM[dat%10],7);
	  Delay_SMG(500);
}
//===============================¶¨Ê±Æ÷
void Init_Timer()
{
	TMOD=0x16;
	//¶¨Ê±Æ÷0ÓÃ×÷¼ÆÊý  0110
	TH0=0xff;
	TL0=0xff;
	//¶¨Ê±Æ÷1ÓÃ×÷¶¨Ê±   0001
	TH1=(65535-50000)/256;
	TL1=(65535-50000)%256;
	ET0=1;
	ET1=1;
	EA=1;
	
	TR0=1;
	TR1=1;
	
}

void Service_T0() interrupt 1
{
  count_f++;
}
void Service_T1() interrupt 3
{
	
	TH1=(65535-50000)/256;
	TL1=(65535-50000)%256;
	count_s++;
	if(count_s==20)
	{
		dat=count_f;
		count_f=0;
		count_s=0;
	
	}
}
void InitSystem()
{
	SelectHC138(5);
	P0=0x00;
	SelectHC138(4);
	P0=0xff;
}

void main()
{
	InitSystem();
	Init_Timer();
	while(1)
	{
		Display_SMG();

	}
}

14. 2402C存储器使用

在使用前，我们得先明白其是通过IIC总线通信的

没有硬件IIC外设的微处理器中，需要根据总线时序设计IIC接口的驱动程序。包括：起始信号、停止信号、产生应答、等待应答、发送数据和接收数据6个函数。下面以51单片机为例，阐述IIC总线驱动程序的设计。

//IIC

#include "reg52.h"
#include "intrins.h"

#define DELAY_TIME 5

#define SlaveAddrW 0xA0
#define SlaveAddrR 0xA1


sbit SDA = P2^1;  /* Êý¾ÝÏß */
sbit SCL = P2^0;  /* ʱÖÓÏß */

// 延时函数
void IIC_Delay(unsigned char i)
{
    do{_nop_();}
    while(i--);        
}

// 起始信号
void IIC_Start(void)
{
    SDA = 1;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 0;
    IIC_Delay(DELAY_TIME);
    SCL = 0;	
}

//停止信号
void IIC_Stop(void)
{
    SDA = 0;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

//产生答应
void IIC_SendAck(bit ackbit)
{
    SCL = 0;
    SDA = ackbit;  					// 0£ºÓ¦´ð£¬1£º·ÇÓ¦´ð
    IIC_Delay(DELAY_TIME);
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SCL = 0; 
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

//等待答应
bit IIC_WaitAck(void)
{
    bit ackbit;
	
    SCL  = 1;
    IIC_Delay(DELAY_TIME);
    ackbit = SDA;
    SCL = 0;
    IIC_Delay(DELAY_TIME);
    return ackbit;
}

//发送数据
void IIC_SendByte(unsigned char byt)
{
    unsigned char i;

    for(i=0; i<8; i++)
    {
        SCL  = 0;
        IIC_Delay(DELAY_TIME);
        if(byt & 0x80) SDA  = 1;
        else SDA  = 0;
        IIC_Delay(DELAY_TIME);
        SCL = 1;
        byt <<= 1;
        IIC_Delay(DELAY_TIME);
    }
    SCL  = 0;  
}

//接受数据
unsigned char IIC_RecByte(void)
{
    unsigned char i, da;
    for(i=0; i<8; i++)
    {   
    	SCL = 1;
	IIC_Delay(DELAY_TIME);
	da <<= 1;
	if(SDA) da |= 1;
	SCL = 0;
	IIC_Delay(DELAY_TIME);
    }
    return da;    
}

一般情况下，所提供的IIC总线底层驱动代码有“ **.c ”和“ **.h ”两个文件，你需要懂得它们，至少需要了解“ **.h” 头文件，才能正确应用。虽然不再需要编写IIC总线的底层驱动代码，但是对于具体设备的操作还需要结合数据手册来进一步实现，而IIC是需要用在我们的这个24C02存储器当中的

24C02存储器

#include "reg52.h"
#include "iic.h"
unsigned char code SMG_DM[18]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,
	0x90,0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
unsigned char dat1 = 0, dat2 = 0, dat3 = 0;

//字节写操作
void SelectHC138(unsigned char n)
{
	switch(n)
	{
		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;
	}
}
void Delay(unsigned int t)
{
 while(t--);
}
void Write_24C02(unsigned char addr, unsigned char dat)
{
	IIC_Start();		
	IIC_SendByte(0xa0); 	
	IIC_WaitAck();		
	IIC_SendByte(addr); 	
	IIC_WaitAck(); 		
	IIC_SendByte(dat); 	
	IIC_WaitAck();		
	IIC_Stop();		
}

//字节读操作
unsigned char Read_24C02(unsigned char addr)
{
	unsigned char tmp;

	IIC_Start();			
	IIC_SendByte(0xa0); 	
	IIC_WaitAck();		
	IIC_SendByte(addr); 	
	IIC_WaitAck(); 		

	IIC_Start();			
	IIC_SendByte(0xa1); 	
	IIC_WaitAck();		
	tmp = IIC_RecByte();	
	IIC_SendAck(1); 		
	IIC_Stop();				
	return tmp;
}

//数据读写函数
void Read_Write()
{
	dat1 = Read_24C02(0x01);
	dat2 = Read_24C02(0x03);
	dat3 = Read_24C02(0x05);
	
	dat1 = dat1 + 1;
	dat2 = dat2 + 2;
	dat3 = dat3 + 3;
	
	if(dat1 > 10)
		dat1 = 0;
	if(dat2 > 20)
		dat2 = 0;
	if(dat3 > 30)
		dat3 = 0;
	
	Write_24C02(0x01, dat1);
	Delay(1100);
	Write_24C02(0x03, dat2);
	Delay(1100);
	Write_24C02(0x05, dat3);
	Delay(1100);
}
//数码管显示函数
void SMG_Bit(unsigned char dat,unsigned char pos)
{
	SelectHC138(6);
	P0=0x01<<pos;
	SelectHC138(7);
	P0=SMG_DM[dat];
}

//显示函数
void Display_24c02()
{
	SMG_Bit(dat1/10,0);
	Delay(500);
	SMG_Bit(dat1%10,1);
	Delay(500);
	SMG_Bit(16,2);
	Delay(500);
	SMG_Bit(dat2/10,3);
	Delay(500);
	SMG_Bit(dat2%10,4);
	Delay(500);
	SMG_Bit(16,5);
	Delay(500);
	SMG_Bit(dat3/10,6);
	Delay(500);
	SMG_Bit(dat3%10,7);
	Delay(500);
}

// 初始化函数
void InitSystem()
{
	SelectHC138(5);
	P0=0x00;
	SelectHC138(4);
	P0=0xff;
}

void main()
{
	InitSystem();
	Read_Write();
	while(1)
	{
		Display_24c02();
		
	}
	
}

15.PWM呼吸灯

任务如下：
1、将 J5 的 23 脚短接，把 S4 和 S7 设置为 独立按键 。
2、系统上电后，关闭蜂鸣器和继电器， L4 和 L5 指示灯 点亮 ，其余的指示灯熄灭。
3、按下 S4 按键，松开后， L1 到 L8 八个指示灯进行每隔 1 秒的 呼吸流水点亮 。控制流
程为： L1 缓慢 点亮 -> L1 缓慢熄灭-> L2 缓慢 点亮 -> L2 缓慢熄灭... L8 缓慢 点亮 -> L8 缓慢熄
灭-> L1 缓慢 点亮 -> L1 缓慢熄灭... 如此循环往复。
4、再次按下 S4 按键，松开后，L1 到 L8 八个指示灯从当前状态开始 逆向呼吸流水点亮 。
如果当前的水方向为： L1 缓慢 点亮 -> L1 缓慢熄灭-> L2 缓慢 点亮 - >L2 缓慢熄灭... 那么，按
下 S4 按键松开后为：
L2 缓慢 点亮 -> L2 缓慢熄灭-> L1 缓慢 点亮 -> L1 缓慢熄灭-> L8 缓慢 点亮
-> L8 缓慢熄灭-> L7 缓慢 点亮 -> L7 缓慢熄灭... 如此循环往复。
5、对于每个 LED 指示灯，缓慢点亮的时长为 0.5 秒 ，缓慢熄灭的时长为 0.5 秒 。
6、按下 S4 按键时，当前的指示灯暂停流水变化并保持现有的亮度，直到按键松开后，
亮度才开始恢复变化。待当前的亮度变化完成后，才开始改变呼吸流水控制的方向。
7、按下 S7 按键时，在数码管上显示 当前 LED 指示灯的
位置 和 PWM 脉宽调制信号的 占空比 。按键松开后，数码管熄
灭。显示格式如图，在数码管左边的第 1 位数码管显示 LED
指示灯的位置，在数码管右边的 2 位数码管显示 PWM 信号占
空比。例如：当前点亮 L6 指示灯，PWM 信号的占空比为 30%，
那么，数码管最左边的 1 位显示“6”，在最右边的 2 位显示
“30”，其余没有使用的数码管熄灭。
8、按下 S7 按键时，当前的指示灯暂停流水变化并保持现有的亮度，直到按键松开后，
亮度才开始恢复变化 
#include "regx52.h"
#include "absacc.h"
 
sbit S7 = P3^0;
sbit S4 = P3^3;
 
unsigned char pwm = 0;          
unsigned char pwm_duty = 0;              
unsigned char times = 0;        
unsigned char led_go = 0;       
unsigned char stat_go = 0;      
unsigned char stat = 0;         
unsigned char key_puse = 0;     
 
unsigned char code SMG_duanma[18]=
		{0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
		 0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
 
void DelaySMG(unsigned int t)
{
	while(t--);
}
 
void DisplaySMG_Bit(unsigned char pos, unsigned char value)
{
	XBYTE[0xE000] = 0xff;
	XBYTE[0xC000] = 0x01 << pos;
	XBYTE[0xE000] = value;
}
 
void Display_Info(unsigned char pos, unsigned char duty)
{
	DisplaySMG_Bit(0, SMG_duanma[pos]);
	DelaySMG(500);
 
	DelaySMG(500);
	DisplaySMG_Bit(6, SMG_duanma[duty / 10]);
	DelaySMG(500);
	DisplaySMG_Bit(7, SMG_duanma[duty % 10]);	
	DelaySMG(500);
	
	DisplaySMG_Bit(0, 0xff);
	DisplaySMG_Bit(6, 0xff);
	DisplaySMG_Bit(7, 0xff);
}
 
void Init_Timer0()
{
	TMOD = 0x01;
	TH0 = (65535 - 1000) / 256;			
	TL0 = (65535 - 1000) % 256;
	
	ET0 = 1;
	EA = 1;
	TR0 = 1;
}
 
void Service_Timer0() interrupt 1
{
	TH0 = (65535 - 1000) / 256;
	TL0 = (65535 - 1000) % 256;
	
	if(stat_go == 0)      						
      {
        XBYTE[0x8000] = 0xe7;						
        return;
      } 
	
        pwm++;                
  
      if(pwm <= pwm_duty)   
      {
	XBYTE[0x8000] = ~(0x01 << stat);
      }
      else if(pwm <= 10)
      {
        XBYTE[0x8000] = 0xff;
      }
      else
      {
        XBYTE[0x8000] = ~(0x01 << stat);
    
        pwm = 0;
        if(key_puse == 0)     
        {
          times++;
        }
      }
}
 
void LED_Control()
{
  if(times == 5)          
  {
    times = 0;
    if(led_go == 0)       
    {
      pwm_duty = pwm_duty + 1;
      if(pwm_duty == 11)
      {
				pwm_duty = 10;
        led_go = 1;
      }
    }
    else if(led_go == 1)  
    {
      pwm_duty = pwm_duty - 1;
      if(pwm_duty == 255)
      {
				pwm_duty = 0;
        led_go = 0;
        
        if(stat_go == 1)      
        {
          stat++;
          if(stat == 8)
          {
            stat = 0;
          }
        }
        else if(stat_go == 2) 
        {
          stat--;
          if(stat == 255)
          {
            stat = 7;
          }
        }
      }
    }
  }
}
 
void Scan_Keys()
{
	if(S4 == 0)
	{
		DelaySMG(100);
		if(S4 == 0)
		{
			while(S4 == 0)
			{
				key_puse = 1;
			}
			key_puse = 0;
			
      stat_go++;            
      if(stat_go == 3)
      {
        stat_go = 1;
      }
		}
	}
	
	if(S7 == 0)
	{
		DelaySMG(100);
		if(S7 == 0)
		{
			while(S7 == 0)
			{
				key_puse = 1;
				Display_Info(stat + 1, pwm_duty * 10);
			}
			key_puse = 0;
		}
	}
}
 
void Init_System()
{
	//XBYTE[0xA000] = 0xff;
	XBYTE[0xA000] = 0x00;
	XBYTE[0xE000] = 0xff;
	XBYTE[0xC000] = 0xff;
	
	Init_Timer0();
}
 
main()
{
	Init_System();
	while(1)
	{
		LED_Control();
		Scan_Keys();
	}
}

16.超声波测距模块的使用

1、超声波模块的 TX 引脚 接到单片机的 P1.0 引脚， RX 引脚 接到单片机的 P1.1 引脚。
2、利用超声波传感器测量前端障碍物的距离，测量结果
用 厘米 作为单位，显示在数码管 最右边 3 位 。
3、测量距离最大约 100 厘米，当障碍物超出测量范围或
前方无障碍物，以“ F ”为标志，显示在数码管 最左边 1 位 。
4、 超声波传感器测距的工作原理：
首先产生 8 个 40KHz 的超声波信号，通过 TX 引脚 发射出
去，同时 启动定时器 ，计数计数脉冲，接着等待超声波信号的返回。如果超声波传感器接收
到反射回来的信号，则 RX 引脚 变为 低电平 ，这时候 停止定时器 ，读取计数脉冲个数，计算
超声波发射出去到反射回来的时间长度 T。最后根据公式： L = V*T/2 ,计算距离。
其中 V 为 20 摄氏度时的声速，其值约为： 344 米/秒 。 
#include "reg52.h"
#include "intrins.h"

sbit TX = P1^0;
sbit RX = P1^1;

unsigned char code SMG_DuanMa[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,
	0x90,0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf};
unsigned int distance = 0;
void SelectHC573(unsigned char channel)
{
	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;
	}
}

void InitSystem()
{
	SelectHC573(5);
	P0 = 0x00;
	SelectHC573(4);
	P0 = 0xff;
	SelectHC573(0);
}
void DisplaySMG_Bit(unsigned char pos,unsigned char dat)
{
	SelectHC573(7);
	P0 = 0xff;
	SelectHC573(6);
	P0 = 0x01 << pos;
	SelectHC573(7);
	P0 = dat;
	SelectHC573(0);
}

void DelaySMG(unsigned int t)
{
	while(t--);
}

void DisplaySMG()
{
	if(distance == 999)
	{
		DisplaySMG_Bit(0,SMG_DuanMa[15]);
		DelaySMG(500);
	}
	else
	{
		DisplaySMG_Bit(5,SMG_DuanMa[distance / 100]);
		DelaySMG(500);
		DisplaySMG_Bit(6,SMG_DuanMa[distance / 10 % 10]);
		DelaySMG(500);
		DisplaySMG_Bit(7,SMG_DuanMa[distance % 10]);
		DelaySMG(500);	
	}
}
void Delay_12us()
{
	unsigned char i;

	_nop_();
	_nop_();
	i = 33;
	while (--i);
}
void SendWave()
{
	unsigned char j=0;
	for(j=0;j<8;j++)
	{
		TX =1;
		Delay_12us();
		TX=0;
		Delay_12us();
	}
}
void MeasureDistance()
{
	unsigned int time=0;
	TMOD=0x00;
	TH1=0;
	TL1=0;
	SendWave();
	TR1=1;
 	while((RX==1)&&(TF1==0));
  TR1=0;
	if(TF1==0)
	{
		time=TH1;
		time=(time<<8)|TL1;
		distance=time*0.0172;
	}
	else
	{
		TF1=0;
		distance=999;
	}



}


void Delay(unsigned char n)
{
	while(n--)
	{
		DisplaySMG();
	}

}

void main()
{
	InitSystem();
	while(1)
	{
		MeasureDistance();
		Delay(5);
	}
}

17. DAC转换

1、将 IIC 总线 的底层驱动代码文件正确移植到工程中。
2、循环采样 PCF8591 的 AIN3 通道中可调电阻的信号，将
采样结果转换成电压值，保留 2 位小数 ，显示在数码管右侧。
3、将可调电阻的当前采样数据作为 PCF8591 的 D/A 转换 参
数输出模拟电压。
5、使用万用表测量 J3 的 19 和 20 引脚，即 OUT 和 GND ，
比较可调电阻的采样电压和 DAC 输出的实际电压。 
#include "reg52.h"
#include "iic.h"

sbit S4 = P3^3;
sbit S5 = P3^2;
int dat = 0; 
unsigned char code SMGNodot[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
unsigned char code SMGdot[] = {0xBF,0x86,0xDB,0xCF,0xE6,0xED,0xFD,0x87,0xFF,0xEF};
void SelectHC573(unsigned char channel)
{
	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;		
	}
}

void InitSystem()
{
	SelectHC573(4);
	P0 = 0XFF;
	SelectHC573(5);
	P0 = 0X00;
	SelectHC573(7);
	P0 = 0XFF;
	SelectHC573(6);
	P0 = 0XFF;
	SelectHC573(7);
	P0 = 0XFF;
	SelectHC573(0);
}

void DisplaySMG_bit(unsigned char pos, unsigned char value)
{
	SelectHC573(7);
	P0 = 0xff;
	SelectHC573(6);
	P0 = 0x01 << pos;
	SelectHC573(7);
	P0 = value;
}

void DisplayAll_Off()
{
	SelectHC573(7);
	P0 = 0xff;
	SelectHC573(6);
	P0 = 0xff;
	SelectHC573(7);
	P0 = 0xff;
}

unsigned char Show[] = {0,0,0,0,0,0,0,0};

void CatchShow()
{
	Show[7] = ~SMGNodot[dat % 10];
	Show[6] = ~SMGNodot[(dat %100) / 10];
	Show[5] = ~SMGNodot[dat / 100];
	Show[4] = 0xff;
	Show[3] = 0xff;
	Show[2] = 0XFF;
	Show[1] = 0xff;
	Show[0] = 0xff;
}

void DelaySMG(unsigned int t)
{
	while(t--);
}

void DisplayValue()
{	
	unsigned char i;
	CatchShow();
	for(i = 0; i < 8 ; i++)
	{
		DisplaySMG_bit(i,Show[i]);
		DelaySMG(2000);
	}
	DisplayAll_Off();
}

void WriteDA(unsigned char dat)
{
	IIC_Start();
	IIC_SendByte(0x90);
	IIC_WaitAck();
	IIC_SendByte(0x40);
	IIC_WaitAck();
	IIC_SendByte(dat);
	IIC_WaitAck();
	IIC_Stop();	
}

void ScanKeys()
{
	if(S4 == 0)
	{
		DisplayValue();
		if(S4 == 0)
		{
			while(S4 == 0)
			{
				DisplayValue();
				dat += 1;
				if(dat > 255)
				{
					dat = 255;
				}
			}				
		}
	}
	
	if(S5 == 0)
	{
		DisplayValue();
		if(S5 == 0)
		{
			while(S5 == 0)
			{
				DisplayValue();
				dat -= 1;
				if(dat < 0)
				{
					dat = 0;
				}
			}				
		}
	}
}


void main()
{
	InitSystem();
	WriteDA(2*255/5);
	while(1);
}

整体模块技能训练

// 头文件包含
# include "reg52.h" 
# include "iic.h"
# include "onewire.h"     //单总线头文件包含
# include "ds1302.h"      //DS1032时钟模块包含
# include "intrins.h"		 


typedef unsigned char uchar;
typedef unsigned int uint;

sfr AUXR = 0x8e;

//按键引脚定义
sbit S4 = P3^3;
sbit S5 = P3^2;
sbit S6 = P3^1;
sbit S7 = P3^0;

//信号发送与接收
sbit TX = P1^0;				 
sbit RX = P1^1;

//数码管段码
uchar duanma[10] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
//无点断码
uchar duanmadot[10] = {0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};				 

//DS1302 地址
uchar Writeaddr [7] = {0x80,0x82,0x84,0x86,0x88,0x8a,0x8c};
uchar Readaddr [7] = {0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};
uchar Timer[7] = {0x00}; //时间地址自己写入

uchar rb2 = 0;
uint count = 0;         		 
bit smg_f = 0;


//矩阵键盘引脚定义
sfr P4 = 0xC0;

sbit R1 = P3^0;
sbit R2 = P3^1;
sbit R3 = P3^2;
sbit R4 = P3^3;

sbit C1 = P4^4;
sbit C2 = P4^2;
sbit C3 = P3^5;
sbit C4 = P3^4;

//==================573锁存器与138译码器===========================
void SelectHC573(uchar n)
{
	switch (n)
	{
		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;
	}
}
//============================================================


//====================LED=====================

//============================================================


//=====================系统初始化函数=============================
void InitSystem ()
{	
	SelectHC573(4);
	P0 = 0xff;
	SelectHC573(5);
	P0 = 0x00;
	SelectHC573(0);	
}
//============================================================

//=========================PCF8591============================

void ReadRd1 ()
{
	IIC_Start();
	IIC_SendByte(0x90);
	IIC_WaitAck();
	IIC_SendByte(0x03);	
	IIC_WaitAck();

   	IIC_Start();
	IIC_SendByte(0x91);
	IIC_WaitAck();
	rb2 = IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
}

/
void PCFADC ()
{
	IIC_Start();
	IIC_SendByte(0x90);
	IIC_WaitAck();
	IIC_SendByte(0x43);	
	IIC_WaitAck();

   	IIC_Start();
	IIC_SendByte(0x91);
	IIC_WaitAck();
	rb2 = IIC_RecByte();	
	IIC_SendAck(1);
	IIC_Stop();	
}

void PCFDAC (uchar dat)
{
	IIC_Start();
	IIC_SendByte(0x90);
	IIC_WaitAck();
	IIC_SendByte(0x40);	
	IIC_WaitAck();
	IIC_SendByte(dat);	  
	IIC_WaitAck();
	IIC_Stop();	
}
//============================================================


//=======================AT24C02==============================
uchar Read24c02 (uchar addr)
{
	uchar temp;

	IIC_Start();
	IIC_SendByte(0xa0);
	IIC_WaitAck();
	IIC_SendByte(addr);	
	IIC_WaitAck();

   	IIC_Start();
	IIC_SendByte(0xa1);
	IIC_WaitAck();
	temp = IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
	
	return temp;		
}

void Write24c02 (uchar addr,uchar dat)
	IIC_Start();
	IIC_SendByte(0xa0);
	IIC_WaitAck();
	IIC_SendByte(addr);	
	IIC_WaitAck();
	IIC_SendByte(dat);
	IIC_WaitAck();
	IIC_Stop();		
}
//============================================================

//=======================DS18B20==============================
void Read_Temp ()								
{
	uchar LSB;
	uchar MSB;

	init_ds18b20();
	Write_DS18B20(0xcc);
	Write_DS18B20(0x44);
	init_ds18b20();
	Write_DS18B20(0xcc);
	Write_DS18B20(0xbe);
	
	LSB = Read_DS18B20();
	MSB = Read_DS18B20();
	tem = (MSB << 8) | LSB;
	
	if ((tem & 0xf800) == 0x0000)	  
	{
		tem = tem >> 4;
	}
	
}
//============================================================

//=======================DS1302===============================
void Write_Timer ()								  
{
	uchar i;
	Write_Ds1302_Byte(0x8e,0x00);
	for (i = 0;i <= 7;i++)
	{
		Write_Ds1302_Byte(Writeaddr[i],Timer[i]);		
	}
	Write_Ds1302_Byte(0x8e,0x80);	
}

void Read_Timer ()
{
	uchar i;
	for (i = 0;i <= 7;i++)
	{
		Timer[i] = Read_Ds1302_Byte(Readaddr[i]);		
	}	
}


uchar BCD_add(uchar dat)
{
	dat = dat + 1;
	switch (dat)
	{
		case 10:dat = 16;break;
		case 26:dat = 32;break;
		case 42:dat = 48;break;
		case 58:dat = 64;break;
		case 74:dat = 80;break;
		case 90:dat = 0;break;	
	}
	return dat;
}

//??BCD??
uchar BCD_minus(uchar dat)
{
	dat = dat - 1;
	switch (dat)
	{
		case -1:dat =89;break;
		case 79:dat = 73;break;
		case 63:dat = 57;break;
		case 47:dat = 41;break;
		case 31:dat = 25;break;
		case 15:dat = 9;break;	
	}
	return dat;
}
//============================================================

//=========================NE555频率计=============================

void InitTime ()
{
	TMOD = 0x16;

	TH1 = (65535 - 100) / 256;
	TL1 = (65535 - 100) % 256;
	TH0 = 0xff;
	TL0 = 0xff;
	
	TR0 = 1;
	TR1 = 1;
	ET0 = 1;
	ET1 = 1;
	EA = 1;	
}

void ServiceT0 () interrupt 1
{
	f_c ++;
}

void ServiceT1 () interrupt 3
{
	TH1 = (65535 - 100) / 256;
	TL1 = (65535 - 100) % 256;
	
	count++;
	if (count >= 10000)
	{
		dat_f = f_c;
		count = 0;
		f_c = 0;
	}

	count++;
	if (count >= 10000)
	{
		count = 0;
		smg_f = ~smg_f;
	}
	
				   
	pwm_c ++;
	if (pwm_c >= pwm_t)
	{
		pwm_f = 0;
		if (pwm_c >= 100)
		{
			pwm_c = 0;
			pwm_f = 1;
		}
	}	
}
//============================================================

//=======================中断服务函数=============================
void InitINT0 ()
{
	IT0 = 1;
	EX0 = 0;
	EA = 1;	
}

void ServiceINT0 () interrupt 0
{
	//L8 = 0;
	//Delay (60000);
	//L8 = 1;	
}
//============================================================

//========================串口通信========================		  //=================================================
void InitUart ()
{
	TMOD = 0x21;
	TH1 = 0xfd;					  
	TL1 = 0xfd;
	TR1 = 1;
	ES = 1;
	EA = 1;

	AUXR = 0x00;
	SCON = 0x50;
}

void ServiceUart ()	interrupt 4
{
	if (RI == 1)
	{
		command = SBUF;
		RI = 0;
	}
}

void SendByte (uchar dat)
{
	SBUF = dat;
	while (TI == 0);
	TI = 0;
}

void SendString (uchar* addr)
{
	uchar i = 0;
	while (*addr != '\0')
	{
		SendByte(*addr);
		addr = addr + 1;
	}
}

void ExecuteCommand ()
{
	if (command != 0x00)
	{
		switch (command & 0xf0)
		{
			case: 0xa0:
				//
				command = 0x00;
				break;
			case: 0xb0:
				//
				command = 0x00;
				break;
				//...
		}
	}
}
//============================================================

//====================数码管显示==========================
void Delay_SMG (uint t)
{
	while (t--);	
} 

void ShowSMG_Bit (uchar pos,uchar dat)
{
	SelectHC573(7);
	P0 = 0xff;
	SelectHC573(6);
	P0 = 0x01 << pos - 1;
	SelectHC573(7);
	P0 = dat;
	SelectHC573(0);		
}

void All_SMG (uchar dat)
{
	SelectHC573(6);
	P0 = 0xff;
	SelectHC573(7);
	P0 = dat;	
}

void ShowSMG ()
{
	if (k4 == 0)
	{
		ShowSMG_Bit(1,0xc1);
		Delay_SMG (500);
		ShowSMG_Bit(6,duanmadot[dat_u / 100]);
		Delay_SMG (500);
		ShowSMG_Bit(7,duanma[(dat_u / 10) % 10]);
		Delay_SMG (500);
		ShowSMG_Bit(8,duanma[dat_u % 10]);
		Delay_SMG (500);	
	}
	else if (k4 == 1)
	{
		ShowSMG_Bit(1,0x8e);
		Delay_SMG (500);
		if (dat_f > 99999)
		{
			ShowSMG_Bit(3,duanma[(dat_f / 100000) % 10]);
			Delay_SMG (500);	
		}
		if (dat_f > 9999)
		{
			ShowSMG_Bit(4,duanma[(dat_f / 10000) % 10]);
			Delay_SMG (500);	
		}
		if (dat_f > 999)
		{
			ShowSMG_Bit(5,duanma[(dat_f / 1000) % 10]);
			Delay_SMG (500);
		}
		if (dat_f > 99)
		{
			ShowSMG_Bit(6,duanma[(dat_f / 100) % 10]);
			Delay_SMG (500);
		}
		if (dat_f > 9)
		{
			ShowSMG_Bit(7,duanma[(dat_f / 10) % 10]);
			Delay_SMG (500);
		}
		ShowSMG_Bit(8,duanma[(dat_f / 1) % 10]);
		Delay_SMG (500);	
	}
	All_SMG(0xff);	
}
//============================================================

//==================按键延时========================
void DelayKey (uchar t)
{
	while (t--);
}

void ScanKey ()
{
	if (S4 == 0)
	{
		DelayKey (100);
		if (S4 == 0)
		{
			while (S4 == 0)
			{
			}
		}
	}
	if (S5 == 0)
	{
		DelayKey (100);
		if (S5 == 0)
		{
			while (S5 == 0)
			{
			}
		}
	}
	if (S6 == 0)
	{
		DelayKey (100);
		if (S6 == 0)
		{
			while (S6 == 0)
			{
			}
		}
	}
	if (S7 == 0)
	{
		DelayKey (100);
		if (S7 == 0)
		{
			while (S7 == 0)
			{
			}
		}
	}
}
//============================================================

//====================矩阵键盘==========================
void Scanjuzhenjianpan (void)
{
	R1 = 0;
	R2 = R3 = R4 = 1;
	C1 = C2 = C3 = C4 = 1;
	if (C1 == 0)
    {}
	else if (C2 == 0)
	{}
	else if (C3 == 0)
	{}
	else if (C4 == 0)
	{}
	
	R2 = 0;
	R1 = R3 = R4 = 1;
	C1 = C2 = C3 = C4 = 1;
	if (C1 == 0)
	{
		
	}
	else if (C2 == 0)
	{}
	else if (C3 == 0)
	{}
	else if (C4 == 0)
	{}
	
}

//============================================================

//==========================???=============================
void Delay12us()	
{
	unsigned char i;

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

void SendWave ()									  //40KHZ,8?????,TX??
{
	uchar i;
	for (i = 0;i < 8;i++)
	{
		TX = 1;
		Delay12us();
		TX = 0;
		Delay12us();
	}
}

void DistanceMeasure ()								
{
	TMOD &= 0x0f;	
	TH1 = 0x00;	
	TL1 = 0x00;

	SendWave ();

	TR1 = 1;
	while ((RX == 1) && (TF1 == 0)); 
	TR1 = 0;

	if (TF1 == 1)
	{
		distance = 999;
		TF1 = 0;					
	}
	else 
	{
		time = (TH1 << 8) | TL1;
		distance = time * 0.0172;	   
	}
}

void Delay (uchar n)								  
{
	while (n--)
	{
	   ShowSMG ();
	}
}
//=========================================================

//====================主函数========================
void main ()
{
	while (1)
	{
		Delay(10);
	}
}
/

——————————————————分界线————————————————

░░░░░░░░░▄▄

░░░░░░░░░█░█

░░░░░░░░░█░█

░░░░░░░░█░░█

░░░░░░░█░░░█

█████▄▄█░░░████

▓▓▓▓█░░░░░░░░░░░░█

▓▓▓▓█░░░░░░░░░░░░█

▓▓▓▓█░░░░░░░░░░░░█

▓▓▓▓█░░░░░░░░░░░░█

▓▓▓▓█░░░░░░░░░░░░█

▓▓▓▓█████░░░░░░░░

████▀░░░▀▀██████▀​

                                                                      ------------------------------------------->> To Be Continue

WanGxxxx.
关注
专栏目录
自用蓝桥杯练习
qq_50729590的博客
03-17 346
2020年第十届C/C++ B组第一场蓝桥杯省赛真题 第一题：跑步训练（5分） 题目描述 小明要做一个跑步训练。 初始时，小明充满体力，体力值计为 10000 。如果小明跑步，每分钟损耗 600 的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。 小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0 ，他就停止锻炼。 请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案。答案中只填写数，不填写单位。 题目分析 首.
蓝桥杯练习
ZZPIGKK的博客
04-07 4207
蓝桥杯
蓝桥杯练习题库
04-01
每一年都会举办蓝桥杯大赛，软件类的比赛题多是算法为主，多练多敲。
蓝桥杯 练习系统所有题（包括VIP题）
03-15
蓝桥杯 练习系统所有题（包括VIP题） 蓝桥杯 练习系统所有题（包括VIP题）
蓝桥杯 基础练习全解 答案+解析 共17题 python
m0_63174529的博客
05-02 84
不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~给大家准备的学习资料包括但不限于：Python 环境、pycharm编辑器/永久激活/翻译插件python 零基础视频教程Python 界面开发实战教程Python 爬虫实战教程Python 数据分析实战教程python 游戏开发实战教程Python 电子书100本。
蓝桥杯基础技能训练课件.zip
08-21
本资料中包含了单片机设计与开发概述、LED指示灯的基本控制、蜂鸣器与继电器的基本控制、共阳数码管的静态显示等方面来阐述蓝桥杯基础技能训练课件
蓝桥杯基础技能训练：单片机设计开发课件
资源摘要信息:"本压缩包文件名为'蓝桥杯基础技能训练课件.zip'，包含了关于蓝桥杯竞赛的单片机设计与开发相关的基础技能训练课件。蓝桥杯是一种面向计算机与信息科学领域大学生的算法与程序设计竞赛，而单片机是该...
蓝桥杯单片机-基础技能训练（15个单元全部源码）.zip
最新发布
08-22
蓝桥杯单片机-基础技能训练（15个单元全部源码）
蓝桥杯单片机-基础技能训练-全部15个源码
03-13
"蓝桥杯单片机-基础技能训练-全部15个源码"是一个针对初学者或参赛者准备的实践教程，旨在通过一系列实例帮助学习者掌握单片机编程的基础知识和技能。以下是这些源码案例所涵盖的关键知识点： 1. **LED跑马灯**：这...
蓝桥杯 基础+算法训练代码（C语言）
11-11
本压缩包文件“蓝桥杯 基础+算法训练代码（C语言）”则是一份宝贵的资源，包含了作者自己编写以及从网络上收集的通过蓝桥杯官网训练库100%验证的代码。这份资源对于准备参加蓝桥杯或者想要提升C语言编程与算法能力的...
74HC138(中文资料)
10-12
概述 D74HC138D 是一种三通道输入、八通道输出译码器,主要应用于消费类电子产品。
蓝桥杯2015年省赛：熊怪吃核桃（填空）
今天会营业的博客
01-14 471
题目描述 本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 森林里有一只熊怪，很爱吃核桃。不过它有个习惯，每次都把找到的核桃分成相等的两份，吃掉一份，留一份。如果不能等分，熊怪就会扔掉一个核桃再分。第二天再继续这个过程，直到最后剩一个核桃了，直接丢掉。 有一天，熊怪发现了15431543个核桃，请问，它在吃这些核桃的过程中，一共要丢掉多少个核桃。 运行限制 最大运行时间：1s 最大运行内存: 128M #include<stdio.h> #include..
蓝桥杯入门训练小结
sunnyLKX的博客
01-22 778
终于开始了蓝桥杯的准备！入门的几道题做下来我的感悟是：会考一些我们之前不是很重视但是很重要的小细节。 第一题：A+B问题 这题就是最基础大家都做了无数遍的A+B题目连源码都给了我也没什么可说的了 第二题：序列求和 从第二题起就开始挖坑啦！乍一看很简单有木有？来，让我们一起愉快的跳坑，序列求和是不是，来来来，先来个大循环，什么1,000,000,000是不是？给你个i
1.74HC138控制LED发光
qq_43537819的博客
10-29 3015
74HC138 三八译码器的应用三八译码器，就是把 3 种输入状态翻译成 8 种输出状态。从图所能看出来的74HC138 有 1～6 一共是 6 个输入引脚，但是其中 4、5\6 这三个引脚是使能引脚。使能引脚和我们前边讲 74HC245 的 OE 引脚是一样的，这三个引脚如果不符合规定的输入要求，Y0 到 Y7 不管你输入的 1、2、3 引脚是什么电平状态，总是高电平。
74hc138译码器实验c语言程序,基于74hc138译码器实验分析 详解74hc138译码器实验
weixin_39627201的博客
05-18 3134
描述关于74hc138译码器实验你知道多少？本文将主要为你详细分析74hc138译码器实验，在进行实验之前我们先了解一下74hc138译码器。74hc138译码器74HC138是一款高速CMOS器件，74HC138引脚兼容低功耗肖特基TTL(LSTTL)系列。74HC138译码器可接受3位二进制加权地址输入(A0，A1和A2)，并当使能时，提供8个互斥的低有效输出(Y0至Y7)。74HC138特有...
数码管点亮与显示
2201_75464397的博客
02-29 1543
简单介绍了数码管的点亮原理，数码管显示函数
蓝桥杯单片机代码精要
huangqinglong008的博客
04-03 801
led低电平点亮0xff全部关闭，0x00打开全部原理图y6c选位置，y7设置值p0=0x00;po
蓝桥杯单片机-蜂鸣器和继电器
qq_53471484的博客
12-07 342
ULN2003就是一个非门，而HC573锁存器和HC138译码器LED里讲过。蜂鸣器一端接VCC，只需给另一端BUZZ低电平即可让他叫，即令P0^6 = 1；反之，给高电平则不叫，即令P0^6 = 0。继电器一端接VCC，只需给另一端RELAY低电平即可让吸合，即令P0^4 = 1；反之，给高电平则不吸合，即令P0^4 = 0。
【蓝桥杯单片机笔记3】独立按键&矩阵键盘
silver321的博客
01-23 825
内容来自小蜜蜂老师~ 独立按键 题目要求： 代码： #include "reg52.h" sbit S7 = P3^0; sbit S6 = P3^1; sbit S5 = P3^2; sbit S4 = P3^3; sbit L1 = P0^0; sbit L2 = P0^1; sbit L3 = P0^2; sbit L4 = P0^3; sbit L5 = P0^4; sbit L6 = P0^5; void HC138(unsigned char m) { switch(m
写一个类似于#include<reg52.h>sbit LED = P0^0;sbit ADDR0 = P1^0;sbit ADDR1 = P1^1;sbit ADDR2 = P1^2;sbit ADDR3 = P1^3;sbit ENLED = P1^4;void main() //void即函数类型{ //以下为声明语句部分 unsigned int i = 0; //定义一个无符号整型变量i，并赋初值0 //以下为执行语句部分 ENLED = 0; //U3、U4两片74HC138总使能 ADDR3 = 1; //使能U3使之正常输出 ADDR2 = 1; //经U3的Y6输出开启三极管Q16 ADDR1 = 1; ADDR0 = 0; while (1) { LED = 0; //点亮小灯 for (i=0; i<30000; i++); //延时一段时间 LED = 1; //熄灭小灯 for (i=0; i<30000; i++); //延时一段时间 }}的代码，要求：用 STC89C52 单片机作为核心控制元件，6 位 LED 数码管作为显示器，设计数字倒计时 器： LED 数码管显示倒计时时间，时、分、秒各用两位数码管。
06-06
好的，以下是一个类似于#include<reg52.h>sbit LED = P0^0;sbit ADDR0 = P1^0;sbit ADDR1 = P1^1;sbit ADDR2 = P1^2;sbit ADDR3 = P1^3;sbit ENLED = P1^4;void main() //void即函数类型{ //以下为声明语句部分 unsigned int i = 0; //定义一个无符号整型变量i，并赋初值0 //以下为执行语句部分 ENLED = 0; //U3、U4两片74HC138总使能 ADDR3 = 1; //使能U3使之正常输出 ADDR2 = 1; //经U3的Y6输出开启三极管Q16 ADDR1 = 1; ADDR0 = 0; while (1) { LED = 0; //点亮小灯 for (i=0; i<30000; i++); //延时一段时间 LED = 1; //熄灭小灯 for (i=0; i<30000; i++); //延时一段时间 }}的代码，使用 STC89C52 单片机和 6 位 LED 数码管实现数字倒计时器的代码： ```c #include <reg52.h> // STC89C52 头文件 // 数码管位选控制引脚 sbit LSA = P2^2; sbit LSB = P2^3; sbit LSC = P2^4; // 数码管段选控制引脚 sbit LED = P0; // 定义计时时间，单位为秒 unsigned int second = 60; unsigned int minute = 30; unsigned int hour = 1; // 延时函数 void delay(unsigned int i) { while(i--); } // 数码管显示函数 void display(unsigned char num, unsigned char pos) { switch(pos) { case 0: LSA = 0; LSB = 0; LSC = 0; LED = num; break; // 显示百位 case 1: LSA = 1; LSB = 0; LSC = 0; LED = num; break; // 显示十位 case 2: LSA = 0; LSB = 1; LSC = 0; LED = num; break; // 显示个位 case 3: LSA = 1; LSB = 1; LSC = 0; LED = num; break; // 显示百分位 case 4: LSA = 0; LSB = 0; LSC = 1; LED = num; break; // 显示十分位 case 5: LSA = 1; LSB = 0; LSC = 1; LED = num; break; // 显示秒分位 default: break; } } // 主函数 void main() { unsigned int i, j, k; while(1) { ENLED = 0; // U3、U4 两片 74HC138 总使能 ADDR3 = 1; // 使能 U3 使之正常输出 ADDR2 = 1; // 经 U3 的 Y6 输出开启三极管 Q16 ADDR1 = 1; ADDR0 = 0; for(i = hour; i < 24; i++) { // 时 for(j = minute; j < 60; j++) { // 分 for(k = second; k < 60; k++) { // 秒 display(i/10, 0); // 显示百位 delay(10); display(i%10, 1); // 显示十位 delay(10); display(j/10, 2); // 显示个位 delay(10); display(j%10, 3); // 显示百分位 delay(10); display(k/10, 4); // 显示十分位 delay(10); display(k%10, 5); // 显示秒分位 delay(10); } second = 0; // 秒清零 } minute = 0; // 分清零 } hour = 0; // 时清零 } } ``` 需要注意的是，此代码中的数码管显示函数、延时函数和计时时间定义与之前的代码相同，但需要添加使能信号和地址信号控制部分，才能通过 74HC138 译码器控制 6 位数码管。具体实现方式可以参考 74HC138 的数据手册。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

WanGxxxx.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值