蓝桥杯代码（个人）

已于 2023-05-02 23:11:06 修改
阅读量533 收藏 6
点赞数 1
文章标签： 单片机 stm32 c语言
于 2023-04-08 00:00:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67882696/article/details/130022912
版权

当初跟小蜜蜂学蓝桥杯时写的代码，保存在这里，需要时候回来复习一下

新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
1、系统上电后，关闭 8 个 LED 灯。
2、循环实现 LED 跑马灯控制，控制要求为：
首先，8 个 LED 灯同时闪烁 3 次；
然后，从 L1 灯至 L8 灯依次点亮；
接着，从 L1灯至 L8 灯依次熄灭

#include <REGX52.H>

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

void Sel_HC138(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 LED_Close()
{
	P0=0xFF;
}
	
void Delay(int t)
{
	while(t--);
	while(t--);
}


void LED_Running()
{
	unsigned char i;
	P0=0x00;
	Delay(60000);
	P0=0xFF;
	Delay(60000);
	P0=0x00;
	Delay(60000);
	P0=0xFF;
	Delay(60000);
	P0=0x00;
	Delay(60000);
	P0=0xFF;
	Delay(60000);
	for(i=1;i<=8;i++)
	{
		P0=0xFF<<i;
		Delay(60000);
	}
	for(i=1;i<=8;i++)
	{
		P0=~(0xFF<<i);
		Delay(60000);
	}
}

void main()
{
	LED_Close();
	Sel_HC138(4);
	while(1)
	{
		LED_Running();
		Delay(60000);
	}
	
}
//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//2、循环实现以下功能：
//首先，8 个 LED 灯同时闪烁 3 次；
//接着，从 L1 灯至 L8 灯依次点亮；
//然后，继电器吸合，延时片刻，继电器断开；
//接着，从 L1 灯至 L8 灯依次熄灭；
//最后，蜂鸣器鸣叫一会后关闭。

#include <REGX52.H>

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

void Sel_HC138(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 Close()
{
	P0=0xFF;
	Sel_HC138(4);
}

void LED_Running()
{
	unsigned char i;
	
	Sel_HC138(4);
	
	P0=0x00;
	Delay(60000);
	P0=0xFF;
	Delay(60000);
	P0=0x00;
	Delay(60000);
	P0=0xFF;
	Delay(60000);
	P0=0x00;
	Delay(60000);
	P0=0xFF;
	Delay(60000);
	
	for(i=1;i<=8;i++)
	{
		P0=0xFF<<i;
		Delay(60000);
	}
	
	Sel_HC138(5);
	P0=0x10;
	Delay(60000);
	P0=0x00;
	
	Sel_HC138(4);
	
	for(i=1;i<=8;i++)
	{
		P0=~(0xFF<<i);
		Delay(60000);
	}
	
	Sel_HC138(5);
	P0=0x40;
	Delay(60000);
	P0=0x00;
}
	
void main()
{
	Close();
	while(1)
	{
		LED_Running();
	}
}



//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//2、8 个数码管从左至右，逐个数码管依次显示“0”到“9”的 10 个数字。
//即左边第 1 个数码管依次显示“0”到“9”，其他数码管熄灭；接着左边第 2 个数码管
//依次显示“0”到“9”，其他数码管熄灭...依次类推，直到 8 个数码管显示完成。
//3、8 个数码管同时显示“0”到“9”的 10 个数字和“A”到“F”的 6 个字母。
//4、循环实现上面 2 组数码管的显示功能
#include <REGX52.H>

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

unsigned char SMG[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x88,0x80,0xC6,0xC0,0x86,0x8E};

void Sel_HC138(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 Init()
{
	Sel_HC138(5);
	P0=0x00;
}

void SMG_Running(unsigned char A,B)
{
	Sel_HC138(6);
	P0=(0x01<<(A-1));
	Sel_HC138(7);
	P0=SMG[B];
}
	
void main()
{
	Init();
	while(1)
	{
		unsigned char i,j;
 
		Sel_HC138(6);
		P0=0xFF;
		Sel_HC138(7);
		for(i=0;i<=15;i++)
		{
			P0=SMG[i];
			Delay(60000);
		}
	}
}




//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//2、在 8 位数码管中，左边 4 位数码管显示
//年份“2018”，接着 2 位是分隔符“--”，靠右的
//2 位数码管显示月份。从 1 月份开始，每隔一段
//时间加 1 个月，到 12 月之后又从 1 月开始递增，
//如此循环往复

#include <REGX52.H>

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

unsigned char SMG[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x88,0x80,0xC6,0xC0,0x86,0x8E,0xBF,0x7F};
//依次0123456789ABCDEF—.

void Sel_HC138(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 Init()
{
	Sel_HC138(5);
	P0=0x00;
}

void Runing_SMG(unsigned char A,B)
{
	P0=0xFF;
	Sel_HC138(6);
	P0=(0x01<<(A-1));
	Sel_HC138(7);
	P0=SMG[B];
}

unsigned char Month=1;

void Scan_SMG()
{
	unsigned int Num;
	
	Runing_SMG(1,2);
	Delay(50);
	Runing_SMG(2,0);
	Delay(50);
	Runing_SMG(3,2);
	Delay(50);
	Runing_SMG(4,3);
	Delay(50);
	Runing_SMG(5,16);
	Delay(50);
	Runing_SMG(6,16);
	Delay(50);

	Num++;
	
	if(Num>500)
	{
		Num=0;
		Month++;
		if(Month>12)
		{
			Month=1;
		}
	}
	
	Runing_SMG(7,Month/10);
	Delay(50);
	Runing_SMG(8,Month%10);
	Delay(50);
}

void main()
{
	Init();
	while(1)
	{
		Scan_SMG();
	}
}

//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 CT107D 上 J5 处跳帽接到 2～3 引脚，使 S4、S5、S6 和 S7 成为 4 个独立按键。
//2、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//3、循环扫描按键状态，在确认按键按下时，进行去抖动处理。当 S7 按键按下时，点亮
//L1 指示灯，松开后熄灭；当 S6 按键按下时，点亮 L2 指示灯，松开后熄灭；当 S5 按键按下
//时，点亮 L3 指示灯，松开后熄灭；当 S4 按键按下时，点亮 L4 指示灯，松开后熄灭。
#include <REGX52.H>

sbit S7=P3^0;
sbit S6=P3^1;
sbit S5=P3^2;
sbit S4=P3^3;

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

void Scan_ALKey()
{
	if(S7==0)
	{
		Delay(100);
		if(S7==0)
		{
			P0=0xFE;
			while(S7==0);
			P0=0xFF;
		}
	}
	if(S6==0)
	{
		Delay(100);
		if(S6==0)
		{
			P0=0xFD;
			while(S6==0);
			P0=0xFF;
		}
	}
	if(S5==0)
	{
		Delay(100);
		if(S5==0)
		{
			P0=0xFB;
			while(S5==0);
			P0=0xFF;
		}
	}
	if(S4==0)
	{
		Delay(100);
		if(S4==0)
		{
			P0=0xF7;
			while(S4==0);
			P0=0xFF;
		}
	}
}

void main()
{
	P2=(P2&0x1f)|0x80;
	while(1)
	{
		
		Scan_ALKey();
	}
	
}
	


新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
1、将 CT107D 上 J5 处跳帽接到 2～3 引脚，使 S4、S5、S6 和 S7 成为 4 个独立按键。
2、S7 和 S6 为选择键，确定控制键控制那组 LED 指示灯；S5 和 S4 为控制键，按键按下
时点亮指定的 LED 指示灯，按键松开，LED 指示灯熄灭。
3、按下 S7 按键，点亮 L1 指示灯，S6 按键按下无效，不响应操作；此时 S5 控制 L3 指
示灯，S4 控制 L4 指示灯；再次按下 S7 按键，L1 指示灯熄灭，S6 按键按下有效。
4、按下 S6 按键，点亮 L2 指示灯，S7 按键按下无效，不响应操作；此时 S5 控制 L5 指
示灯，S4 控制 L6 指示灯；再次按下 S6 按键，L2 指示灯熄灭，S7 按键按下有效。
5、在 S7 和 S6 按键都不按下的情况下，即 L1 和 L2 指示灯均未点亮时，控制键不能操
作，S5 和 S4 按键按下无效。
6、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
7、循环扫描按键状态，根据按键的按下情况，进行相应的处理
#include <REGX52.H>

sbit S7=P3^0;
sbit S6=P3^1;
sbit S5=P3^2;
sbit S4=P3^3;

void HC138_4()
{
	P2=(P2&0x1f)|0x80;
}

unsigned char LED_Mode=0;

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

void Scan_ALKey()
{
	if(S7==0)
	{
		Delay(100);
		if(S7==0)
		{
			if(LED_Mode==0)
			{
				LED_Mode=1;
				P0=0xFE;
			}
			else if(LED_Mode==1)
			{
				LED_Mode=0;
				P0=0xFF;
			}
			while(S7==0);
		}
	}
	
	if(S6==0)
	{
		Delay(100);
		if(S6==0)
		{
			if(LED_Mode==0)
			{
				LED_Mode=2;
				P0=0xFD;
			}
			else if(LED_Mode==2)
			{
				LED_Mode=0;
				P0=0xFF;
			}
			while(S6==0);
		}
	}
	
	if(S5==0)
	{
		Delay(100);
		if(S5==0)
		{
			if(LED_Mode==1)
			{
				P0=0xFA;
				while(S5==0);
				P0=0xFE;
			}
			if(LED_Mode==2)
			{
				P0=0xED;
				while(S5==0);
				P0=0xFD;
			}
		}
	}
	
	if(S4==0)
	{
		Delay(100);
		if(S4==0)
		{
			if(LED_Mode==1)
			{
				P0=0xF6;
				while(S4==0);
				P0=0xFE;
			}
			else if(LED_Mode==2)
			{
				P0=0xDD;
				while(S4==0);
				P0=0xFD;
			}
		}
	}
}

void main()
{
	HC138_4();
	P0=0xFF;
	while(1)
	{
		Scan_ALKey();
	}
}
//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 CT107D 上 J5 处跳帽接到 1～2 引脚，使 S4 到 S19 成为 4X4 的矩阵键盘。
//2、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//3、循环扫描矩阵键盘状态，发现有按键按下，等待其松开后，在数码管的最左边 1 位
//显示相应的数字。从左至右，从上到下，依次显示“0”到“F”。即按下 S7，显示“0”，
//按下 S11 显示“1”，按下 S15 显示“2”，按下 S6 显示“4”...依次类推

#include <REGX52.H>

sfr P4=0xC0;

sbit H1=P3^0;
sbit H2=P3^1;
sbit H3=P3^2;
sbit H4=P3^3;

sbit L4=P3^4;
sbit L3=P3^5;
sbit L2=P4^2;
sbit L1=P4^4;

unsigned char code SMG[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 Sel_HC138(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 Running_SMG(unsigned char A,B)
{
	P0=0xFF;
	Sel_HC138(6);
	P0=(0x01<<(A-1));
	Sel_HC138(7);
	P0=SMG[B];
}

unsigned char KeyNum;

void Scan_Key()
{
	L1=0;
	L2=L3=L4=1;
	H1=H2=H3=H4=1;
	if(H1==0)
	{
		Delay(20);
		if(H1==0)
		{
			while(H1==0);
			KeyNum=1;
			Running_SMG(1,KeyNum);
		}
	}
	if(H2==0)
	{
		Delay(20);
		if(H2==0)
		{
			while(H2==0);
			KeyNum=5;
			Running_SMG(1,KeyNum);
		}
	}
	if(H3==0)
	{
		Delay(20);
		if(H3==0)
		{
			while(H3==0);
			KeyNum=9;
			Running_SMG(1,KeyNum);
		}
	}
	if(H4==0)
	{
		Delay(20);
		if(H4==0)
		{
			while(H4==0);
			KeyNum=13;
			Running_SMG(1,KeyNum);
		}
	}
	
	
	L2=0;
	L1=L3=L4=1;
	H1=H2=H3=H4=1;
	if(H1==0)
	{
		Delay(20);
		if(H1==0)
		{
			while(H1==0);
			KeyNum=2;
			Running_SMG(1,KeyNum);
		}
	}
	if(H2==0)
	{
		Delay(20);
		if(H2==0)
		{
			while(H2==0);
			KeyNum=6;
			Running_SMG(1,KeyNum);
		}
	}
	if(H3==0)
	{
		Delay(20);
		if(H3==0)
		{
			while(H3==0);
			KeyNum=10;
			Running_SMG(1,KeyNum);
		}
	}
	if(H4==0)
	{
		Delay(20);
		if(H4==0)
		{
			while(H4==0);
			KeyNum=14;
			Running_SMG(1,KeyNum);
		}
	}
	
	
	
	L3=0;
	L1=L2=L4=1;
	H1=H2=H3=H4=1;
	if(H1==0)
	{
		Delay(20);
		if(H1==0)
		{
			while(H1==0);
			KeyNum=3;
			Running_SMG(1,KeyNum);
		}
	}
	if(H2==0)
	{
		Delay(20);
		if(H2==0)
		{
			while(H2==0);
			KeyNum=7;
			Running_SMG(1,KeyNum);
		}
	}
	if(H3==0)
	{
		Delay(20);
		if(H3==0)
		{
			while(H3==0);
			KeyNum=11;
			Running_SMG(1,KeyNum);
		}
	}
	if(H4==0)
	{
		Delay(20);
		if(H4==0)
		{
			while(H4==0);
			KeyNum=15;
			Running_SMG(1,KeyNum);
		}
	}
	
	
	L4=0;
	L1=L2=L3=1;
	H1=H2=H3=H4=1;
	if(H1==0)
	{
		Delay(20);
		if(H1==0)
		{
			while(H1==0);
			KeyNum=4;
			Running_SMG(1,KeyNum);
		}
	}
	if(H2==0)
	{
		Delay(20);
		if(H2==0)
		{
			while(H2==0);
			KeyNum=8;
			Running_SMG(1,KeyNum);
		}
	}
	if(H3==0)
	{
		Delay(20);
		if(H3==0)
		{
			while(H3==0);
			KeyNum=12;
			Running_SMG(1,KeyNum);
		}
	}
	if(H4==0)
	{
		Delay(20);
		if(H4==0)
		{
			while(H4==0);
			KeyNum=16;
			Running_SMG(1,KeyNum);
		}
	}
}
			
			
void main()
{
	Sel_HC138(4);
	P0=0xFF;
	while(1)
	{
		Scan_Key();
	}
}

//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 CT107D 上 J5 处跳帽接到 2～3 引脚，使 S4 和 S5 按键一端接地，S4 按键的另一
//端接到单片机的 P32/INT0 引脚，S5 按键的另一端接到单片机的 P33/INT1 引脚。
//2、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//3、控制 L1 指示灯循环闪烁。
//4、将 P32/INT0 引脚定义成外部中断，下降沿触发，使能相关中断控制位。即按下 S5
//按键就会产生一个外部中断触发信号，进入外部中断服务函数。
//5、在外部中断服务函数中，点亮 L8 指示灯，延时片刻后，熄灭。
#include <REGX52.H>

sbit L1=P0^0;
sbit L8=P0^7;

unsigned char Mode_Led;

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

void Init_Int0()
{
	IT0=1;
	EX0=1;
	EA=1;
}

void Run_L8()
{
	L8=0;
	Delay(60000);
	Delay(60000);
	Delay(60000);
	L8=1;
}

void Run_L1()
{
	L1=0;
	Delay(60000);
	L1=1;
	Delay(60000);
}

void Servive_Init0() interrupt 0
{
	Mode_Led=1;
}

void main()
{
	P2=(P2&0x1F)|0x80;
	P0=0xFF;
	Init_Int0();
	while(1)
	{
		Run_L1();
		if(Mode_Led==1)
		{
			Run_L8();
			Mode_Led=0;
		}
	}
}



//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//2、利用定时/计数器 T0 的模式 1 实现 50ms 的间隔定时。
//3、在 50ms 间隔定时的基础上，每隔 1 秒 L1 指示灯闪烁一次，即 L1 指示灯循环点亮
//0.5 秒，熄灭 0.5 秒。
//4、每隔 10 秒 L8 指示灯闪烁 1 次，即 L1 指示灯循环点亮5秒，熄灭5秒。
#include <REGX52.H>

sbit L1=P0^0;
sbit L8=P0^7;

unsigned char Num_50ms;

void Init_TF0()
{
	TMOD=0x01;
	
	TH0=(65535-50000)/256;
	TL0=(65535-50000)&256;
	
	ET0=1;
	EA=1;
	
	TR0=1;
}

void Service_TF0() interrupt 1
{
	TH0=(65535-50000)/256;
	TL0=(65535-50000)&256;
	
	Num_50ms++;
	
	if(Num_50ms%10==0)
	{
		L1=~L1;
	}
	
	if(Num_50ms%100==0)
	{
		L8=~L8;
		Num_50ms=0;
	}
}

void main()
{
	P2=(P2&0x1f)|0x80;
	Init_TF0();
	while(1)
	{
		
	}
}
	
//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，利用定时器 T0、
//数码管和 2 个独立按键，设计并实现一个秒表，具有启动、暂停和清零功能。
//1、秒表的显示格式：
//分-秒-0.05 秒（即 50ms）
//如 8 分 26 秒 900 毫秒，显示为：
//08-26-18
//2、独立按键 S4 定义为：启动/暂停，即第 1 次按下启动秒表，再次按下暂停秒表。
//3、独立按键 S5 定义为：清零。
//4、按键均为按下有效。
#include <REGX52.H>

sbit S5=P3^2;
sbit S4=P3^3;

unsigned char Time_50ms,Time_Sec,Time_Min;

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

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

void Sel_HC138(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 Run_SMG(unsigned char A,B)
{
	P0=0xff;
	Sel_HC138(6);
	P0=0x01<<(A-1);
	Sel_HC138(7);
	P0=SMG_NoDot[B];
}

void Init_TF0()
{
	TMOD=0x01;
	
	TH0=(65535-50000)/256;
	TL0=(65535-50000)%256;
	
	TR0=1;
	ET0=1;
	EA=1;
}

void Service_TF0() interrupt 1
{
	TH0=(65535-50000)/256;
	TL0=(65535-50000)%256;

	Time_50ms++;
	if(Time_50ms==20)
	{
		Time_Sec++;
		Time_50ms=0;
		if(Time_Sec==60)
		{
			Time_Min++;
			Time_Sec=0;
			if(Time_Min>60)
			{
				Time_Min=0;
			}
		}
	}
}

void Scan_SMG()
{
	Run_SMG(1,Time_Min/10);
	Delay(50);
	Run_SMG(2,Time_Min%10);
	Delay(50);
	Run_SMG(3,16);
	Delay(50);
	
	Run_SMG(4,Time_Sec/10);
	Delay(50);
	Run_SMG(5,Time_Sec%10);
	Delay(50);
	Run_SMG(6,16);
	Delay(50);
	
	Run_SMG(7,Time_50ms/10);
	Delay(50);
	Run_SMG(8,Time_50ms%10);
	Delay(50);
}

void Scan_Key()
{
	if(S5==0)
	{
		Delay(100);
		if(S5==0)
		{
			TR0=~TR0;
			while(S5==0)
			{
				Scan_SMG();
			}
		}
	}
	
	if(S4==0)
	{
		Delay(100);
		if(S4==0)
		{
			Time_50ms=0;
			Time_Sec=0;
			Time_Min=0;
			while(S4==0)
			{
				Scan_SMG();
			}
		}
	}
}
		
	
void main()
{
	Init_TF0();
	while(1)
	{
		Scan_Key();
		Scan_SMG();
	}
}


//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，利用 PWM 脉宽信
//号实现独立按键 S7 对 L1 指示灯亮度变化的控制：
//1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//2、PWM 脉宽信号的频率为 100Hz。
//3、L1 指示灯有 4 种亮度，分别是：完全熄灭、10%的亮度、50%的亮度和 90%的亮度。
//4、按下 S7 按键，循环切换 

#include <REGX52.H>

sbit S7=P3^0;

unsigned char Change_PWM=0,Count=0,Change_S7=0;

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

void Sel_HC138(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 Scan_Key()
{
	if(S7==0)
	{
		Delay(100);
		if(S7==0)
		{
			if(Change_S7==0)
			{
				Change_S7=1;
				Change_PWM=10;
				P0=0x00;
				TR0=1;
			}
			else if(Change_S7==1)
			{
				Change_S7=2;
				Change_PWM=50;
			}
			else if(Change_S7==2)
			{
				Change_S7=3;
				Change_PWM=90;
			}
			else if(Change_S7==3)
			{
				Change_S7=0;
				Change_PWM=0;
				P0=0xff;
				TR0=0;
			}
			while(S7==0);
		}
	}
}
				
void Init_TF0()
{
	TMOD=0x01;
	
	TH0=(65535-100)/256;
	TL0=(65535-100)%256;
	
	ET0=1;
	EA=1;
}

void Service_TF0() interrupt 1
{
	TH0=(65535-100)/256;
	TL0=(65535-100)%256;
	
	Count++;
	if(Count==Change_PWM)
	{
		P0=0xFF;
	}
	else if(Count==100)
	{
		P0=0x00;
		Count=0;
	}
}
	
void main()
{
	Sel_HC138(4);
	P0=0xff;
	Init_TF0();
	while(1)
	{
		Scan_Key();
	}
}

//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、初始化串口为模式 1，即 8 位 UART 模式，波特率 9600，允许接收。
//2、数据发送采用查询方式，数据接收采用中断方式。
//3、系统上电初始化之后，单片机向上位机发送两个字节：
//0x5a 和 0xa5（串口助手以十六进制 HEX 发送和显示）。
//4、串口每成功接收到一个字节后，在该字节基础上加 1，
//然后通过串口发送回上位机。
//5、注意 89C52 单片机和 IAP15F2K61S2 单片机串口应用的
//差别，使用 9600 波特率时，晶振时钟选择 11.0592MHz
#include <REGX52.H>

unsigned char Receive;

sfr AUXR=0x8E;

void Init_R1()
{
	TMOD=0x20;
	
	TH1=0xFD;
	TL1=0xFD;
	
	TR1=1;
	
	SCON=0x50;
	AUXR=0x00;
	
	ES=1;
	EA=1;
}

void Send_Byte(unsigned char Dat)
{
	SBUF=Dat;
	while(TI==0);
	TI=0;
}

void Service_R1() interrupt 4
{
	if(RI==1)
	{
		RI=0;
		Receive=SBUF;
		Send_Byte(Receive+1);
	}
}
	
void Delay(int t)
{
	while(t--);
}

void main()
{
	Delay(6000);
	Init_R1();
	Send_Byte(0xA0);
	Send_Byte(0x0A);
	while(1);
}

//新建工程，以 I/O 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、初始化串口为模式 1，即 8 位 UART 模式，波特率 9600，允许接收。
//2、数据发送采用查询方式，数据接收采用中断方式。
//3、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯，通过串口向上位机发送
//字符串：“Welcome to XMF system！”，回车换行。
//4、上位机通过串口发送单字节命令，控制单片机的 8 个 LED 灯开关，单片机响应正确
//的控制命令后，完成相应的灯光操作。
//5、上位机通过串口发送单字节命令，读取单片机运行信息，单片机响应正确的读取命
//令后，向上位机返回指定的信息。
//6、上位机与单片机的通信规约如下表
//高四位为A时，低四位由低到高是L1到L4；高四位为B时，低四位由低到高是L5到L8
//发送0xc0时返回~
#include <REGX52.H>

sfr AUXR=0x8E;
unsigned char Command;

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

void Sel_HC138(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 Init_R1()
{
	TMOD=0x20;
	
	TH1=0xfd;
	TL1=0xfd;
	TR1=1;
	
	SCON=0x50;
	AUXR=0x00;
	
	EA=1;
	ES=1;
}

void Send_Byte(unsigned char Dat)
{
	SBUF=Dat;
	while(TI==0);
	TI=0;
}

void Send_String(unsigned char *Str)
{
	while(*Str!='\0')
	{
		Send_Byte(*Str++);
	}
}

void Service_R1() interrupt 4
{
	if(RI==1)
	{
		RI=0;
		Command=SBUF;
	}
}

void Working()
{
	if(Command!=0x00)
	{
		if((Command&0xF0)==0xA0)
		{
			P0=~(Command&0x0F);
			Command=0x00;
		}
		if((Command&0xF0)==0xB0)
		{
			P0=~((Command&0x0F)<<4);
			Command=0x00;
		}
		if((Command&0xF0)==0xC0)
		{
			Send_String("The System is Running\r\n");
			Command=0x00;
		}
	}
}

void main()
{
	Delay(60000);
	
	Sel_HC138(5);
	P0=0x00;
	Sel_HC138(4);
	P0=0xFF;
	Init_R1();
	
	Send_String("The System is Running\r\n");
	while(1)
	{
		Working();
	}
}

//建工程，以 MM 模式编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、系统上电后，关闭蜂鸣器，关闭继电器，关闭 8 个 LED 灯。
//2、循环实现以下功能：
//首先，点亮指示灯低 4 位，关闭高 4 位，延时片刻；
//接着，点亮指示灯的高 4 位，关闭低 4 位，延时片刻；
//然后，关闭所有指示灯。
//接着，依次逐个点亮数码管的所有段码，每次只点亮一个数码管。
//3、外部扩展资源的地址映射关系：
//LED 指示灯---- 0x8000；
//蜂鸣器与继电器----0xa000；
//数码管位选----0xc000；
//数码管段码----0xe000
//4、关于 CT107D 存储器映射扩展 MM 编程模式的设计提示：
//CT107D 平台的 J13 要将 1-2 脚短接，选择 MM 模式。
//程序中引入头文件“absacc.h”，通过 XBYTE 关键字来直接操作扩展资源。
//存储器映射扩展方式要占用单片机的 P3.6 引脚。

#include <REGX52.H>
#include "absacc.h"

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

void Running_LED()
{
	XBYTE[0x8000]=0xF0;
	Delay(60000);
	Delay(60000);
	Delay(60000);
	XBYTE[0x8000]=0x0F;
	Delay(60000);
	Delay(60000);
	Delay(60000);
}
	
void Running_SMG()
{
	unsigned char i;
	for(i=0;i<8;i++)
	{
		XBYTE[0xc000]=0x01<<i;
		XBYTE[0xe000]=0x00;
		Delay(60000);
	}
	XBYTE[0xe000]=0xFF;
	Delay(60000);
}

void main()
{
	while(1)
	{
		Running_SMG();
		Running_LED();
	}
}


//新建工程，编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 IIC 总线的底层驱动代码文件正确移植到工程中。
//2、系统上电后，从 24C04 存储器的 0x01、0x03 和 0x05
//这三个地址单元读取数据。
//3、将 0x01 单元读出的数据进行加 1 操作，如果计算结果
//大于 10，复位为 0，然后将这个结果写回 0x01 单元。
//4、将 0x03 单元读出的数据进行加 2 操作，如果计算结果
//大于 20，复位为 0，然后将这个结果写回 0x03 单元。
//5、将 0x05 单元读出的数据进行加 3 操作，如果计算结果大于 30，复位为 0，然后将
//这个结果写回 0x05 单元。
//6、将三个单元的当前数据从左到右依次显示在数码管上，各个数字之间用“-”分隔。
#include <REGX52.H>
#include "iic.h"

unsigned char Dat_1=0,Dat_2=0,Dat_3=0;

unsigned char code SMG_NoDot[18]={0xc0,0xf9,
    0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
    0x88,0x83,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
		
void Sel_HC138(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 Scan_SMG(unsigned char A,B)
{
	P0=0xFF;
	Sel_HC138(6);
	P0=(0x01<<(A-1));
	Sel_HC138(7);
	P0=SMG_NoDot[B];
}

void Send_24C02(unsigned char Send_add,unsigned char Send_Dat)
{
	IIC_Start();
	IIC_SendByte(0xa0);
	IIC_WaitAck();
	IIC_SendByte(Send_add);
	IIC_WaitAck();
	IIC_SendByte(Send_Dat);
	IIC_WaitAck();
	IIC_Stop();
}

unsigned Write_24C02(unsigned char Write_add)
{
	unsigned char Write_Dat;
	IIC_Start();
	IIC_SendByte(0xa0);
	IIC_WaitAck();
	IIC_SendByte(Write_add);
	IIC_WaitAck();
	IIC_Start();
	IIC_SendByte(0xa1);
	IIC_WaitAck();
	Write_Dat=IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
	return Write_Dat;
}

void Init_System()
{
	Sel_HC138(4);
	P0=0xFF;
	Sel_HC138(5);
	P0=0x00;
	Sel_HC138(6);
	P0=0x00;
}

void Work()
{
	Dat_1=Write_24C02(0x01);
	Delay(100);
	Dat_2=Write_24C02(0x03);
	Delay(100);
	Dat_3=Write_24C02(0x05);
	Delay(100);
	
	Dat_1=Dat_1+1;
	Dat_2=Dat_2+2;
	Dat_3=Dat_3+3;
	if(Dat_1>10)
	{
		Dat_1=0;
	}
	if(Dat_2>20)
	{
		Dat_2=0;
	}
	if(Dat_3>30)
	{
		Dat_3=0;
	}
	
	Send_24C02(0x01,Dat_1);
	Delay(10000);
	Send_24C02(0x03,Dat_2);
	Delay(10000);
	Send_24C02(0x05,Dat_3);
	Delay(10000);
}

void Running_SMG()
{
	Scan_SMG(1,Dat_1/10);
	Delay(100);
	Scan_SMG(2,Dat_1%10);
	Delay(100);
	Scan_SMG(3,16);
	Delay(100);
	Scan_SMG(4,Dat_2/10);
	Delay(100);
	Scan_SMG(5,Dat_2%10);
	Delay(100);
	Scan_SMG(6,16);
	Delay(100);
	Scan_SMG(7,Dat_3/10);
	Delay(100);
	Scan_SMG(8,Dat_3%10);
	Delay(100);
}

void main()
{
	Init_System();
	
	Work();
	
	while(1)
	{
		Running_SMG();
	}
	
}
//新建工程，编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 IIC 总线的底层驱动代码文件正确移植到工程中。
//2、光敏电阻 rd1 接到 PCF8591 的 ANI1 通道；可调电阻
//rb2 接到 PCF8591 的 ANI3 通道。
//3、将 J5 的 23 脚短接，把 S4 设置为独立按键。该按键
//为 PCF8591 的采样通道切换按键。
//4、系统上电后，默认采样 AIN1 通道的光敏电阻的输出
//电压，并将当前的直接转换结果读出，显示在数码管上。显示格式如图，在数码管靠左端的
//三位，显示当前所选择的转换通道，在数码管靠右端的三位，显示该通道的转换结果，没有
//使用的数码管熄灭。
//5、S4 按键按下松开后，进行 PCF8591 的采样通道切换。如果当前采样的是 AIN1 通道，
//那么 S4 按下松开后，则切换至 AIN3 通道，以此类推。
#include <REGX52.H>
#include "iic.h"

sbit S7=P3^0;

unsigned adc1_value=0;
float adc1_volt=0;
unsigned int smg1_volt=0;
//依次是采样，换算，显示
unsigned adc3_value=0;
float adc3_volt=0;
unsigned int smg3_volt=0;

unsigned char Ain=1;

void Sel_HC138(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 code SMG_NoDot[18]={0xc0,0xf9,
    0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
    0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};

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

void Scan_SMG();

unsigned Write_PCF8591()
{
	unsigned char Write_Byte;
	IIC_Start();
	
	IIC_SendByte(0x90);
	IIC_WaitAck();
	
	if(Ain==1)
	{
		IIC_SendByte(0x01);
	}
	else if(Ain==3)
	{
		IIC_SendByte(0x03);
	}
	IIC_WaitAck();
	
	IIC_Stop();
	Scan_SMG();
	
	IIC_Start();
	
	IIC_SendByte(0x91);
	IIC_WaitAck();
	
	Write_Byte=IIC_RecByte();
	IIC_SendAck(1);
	
	IIC_Stop();
	return Write_Byte;
}

void Read_AIN1_AIN3()
{
	if(Ain==1)
	{
		adc1_value=Write_PCF8591();
		adc1_volt=adc1_value*(5.0/255);
		smg1_volt=adc1_volt*100;
	}
	//数据以八个二进制取值，这样我的操作实际是将电阻转化为取五分制满分
	if(Ain==3)
	{
		adc3_value=Write_PCF8591();
		adc3_volt=adc3_value*(5.0/255);
		smg3_volt=adc3_volt*100;
	}
}

void Run_SMG(unsigned char A,B)
{
	P0=0xFF;
	Sel_HC138(6);
	P0=(0x01)<<(A-1);
	Sel_HC138(7);
	P0=SMG_NoDot[B];
}

void Scan_SMG()
{
	if(Ain==1)
	{
		Run_SMG(1,(smg1_volt/100));
		Delay(100);
		Run_SMG(2,(smg1_volt/10)%10);
		Delay(100);
		Run_SMG(3,(smg1_volt%10));
		Delay(100);
		Run_SMG(8,Ain);
		Delay(100);
	}
	
	if(Ain==3)
	{
		Run_SMG(1,(smg3_volt/100));
		Delay(100);
		Run_SMG(2,(smg3_volt/10)%10);
		Delay(100);
		Run_SMG(3,(smg3_volt%10));
		Delay(100);
		Run_SMG(8,Ain);
		Delay(100);
	}
}

void Scan_Key()
{
	if(S7==0)
	{
		Delay(100);
		if(Ain==1)
		{
			Ain=3;
		}
		else if(Ain==3)
		{
			Ain=1;
		}
		
		while(S7==0);
		Scan_SMG();
	}
}
		
void main()
{
	Sel_HC138(4);
	P0=0xff;
	Sel_HC138(5);
	P0=0x00;
	Sel_HC138(7);
	P0=0xff;
	while(1)
	{
		Read_AIN1_AIN3();
		Scan_SMG();
		Scan_Key();
	}
}


//新建工程，编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 IIC 总线的底层驱动代码文件正确移植到工程中。
//2、循环采样 PCF8591 的 AIN3 通道中可调电阻的信号，将
//采样结果转换成电压值，保留 2 位小数，显示在数码管右侧。
//3、将可调电阻的当前采样数据作为 PCF8591 的 D/A 转换参
//数输出模拟电压。
//5、使用万用表测量 J3 的 19 和 20 引脚，即 OUT 和 GND，
//比较可调电阻的采样电压和 DAC 
//自己加了一个可输入模拟电压值
#include <REGX52.H>
#include "iic.h"

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

unsigned char adc_value;
unsigned int smg_volt;
float adc_volt;

void Delay(unsigned int t)
{
	while(t--);
}
		
void Sel_HC138(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 Scan_SMG();

void Read_PCF8591_AIN3()
{
	IIC_Start();
	IIC_SendByte(0x90);
	IIC_WaitAck();
	IIC_SendByte(0x43);
	IIC_WaitAck();
	IIC_Stop();

	Scan_SMG();
	
	IIC_Start();
	IIC_SendByte(0x91);
	IIC_WaitAck();
	
	adc_value=IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
	
	adc_volt=adc_value*(5.0/255);
	smg_volt=adc_volt*100;
}

void Set_PCF8591_DAC(unsigned char dat)
{
	IIC_Start();
	IIC_SendByte(0x90);
	IIC_WaitAck();
	IIC_SendByte(0x43);
	IIC_WaitAck();
	IIC_SendByte(dat);
	IIC_WaitAck();
	IIC_Stop();
}

void Running_SMG(unsigned char A,B)
{
	P0=0xff;
	Sel_HC138(6);
	P0=0x01<<(A-1);
	Sel_HC138(7);
	P0=SMG_NoDot[B];
}

void Scan_SMG()
{
	Running_SMG(6,smg_volt/100);
	Delay(50);
	Running_SMG(7,(smg_volt/10)%10);
	Delay(50);
	Running_SMG(8,smg_volt%10);
	Delay(50);
	Running_SMG(6,17);
	Delay(50);
}

void main()
{
	Sel_HC138(4);
	P0=0xff;
	Sel_HC138(5);
	P0=0x00;
	Sel_HC138(7);
	P0=0xFF;
	while(1)
	{
		Read_PCF8591_AIN3();
		Scan_SMG();
	}
}

//新建工程，编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 DS18B20 的底层驱动代码文件正确移植到工程中。
//2、循环采样启动 DS18B20 进行温度转换。
//3、将 DS18B20 的温度转换结果读出，进行换算，保留 1 位
//小数，并显示在数码管靠右端，显示格式如图。
//4、注意，在进行 DS18B20 底层驱动代码文件移植时，需确
//认单总线的时序参数是否匹配
#include "reg52.h"
#include "onewire.h"

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

unsigned int temp=0;
float temp_ds18b20=0;

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

void Sel_HC138(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 Run_SMG(unsigned char A,B)
{
	P0=0xFF;
	Sel_HC138(6);
	P0=0x01<<(A-1);
	Sel_HC138(7);
	P0=SMG_NoDot[B];
}

void Scan_SMG()
{
	unsigned int C;
	C=temp_ds18b20;
	Run_SMG(6,C/100);

	Run_SMG(7,((C/10)%10));
	
//	Run_SMG(7,16);
//	Delay(100);
	
	Run_SMG(8,C%10);
}

void Read_Tem()
{
	unsigned char LSB,MSB;
	
	init_ds18b20();
	//Scan_SMG();//
	Write_DS18B20(0xCC);
	Write_DS18B20(0x44);
	//Scan_SMG();//
	init_ds18b20();
	//Scan_SMG();//
	Write_DS18B20(0xCC);
	Write_DS18B20(0xBE);
	
	LSB=Read_DS18B20();//低八位
	MSB=Read_DS18B20();//高八位
	//Scan_SMG();
	temp=((MSB<<8)|LSB);
	
	if((temp&0xf800)==0x0000)//高五位没有1，正数
	{
		temp>>=4;
		temp=temp*10;
		temp=temp+(LSB&0x0f)*0.625;
	}//得到一个放大十倍，具有小数点位的温度值
	Scan_SMG();
}
	
//	if((temp&0xf800)==0x0000)
//	{
//		temp_ds18b20=temp*0.625;
//	}
	//这样算出是温度的标准形式
	
void main()
{
	Sel_HC138(4);
	P0=0xff;
	Sel_HC138(5);
	P0=0x00;
	Sel_HC138(7);
	P0=0xff;
	while(1)
	{
		Read_Tem();
		//Scan_SMG();
	}
}

//新建工程，编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、将 DS1302 的底层驱动代码文件正确移植到工程中。
//2、初始化 DS1302 的默认启动参数为：
//20 年 4 月 19 日 23 时 58 分 24 秒，周六。
//3、系统上电后，DS1302 实时时钟从默认参数启动运行，并
//将当前的时、分、秒显示在数码管上，时分秒之间用“-”分隔。
//显示格式如图
#include "reg52.h"
#include "ds1302.h"
unsigned char code SMG_NoDot[18]={0xc0,0xf9,
    0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
    0x88,0x83,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
unsigned char code Write_addr[7]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c};
unsigned char code Read_addr[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d};
unsigned char TIME[7]={0x24,0x58,0x23,0x19,0x04,0x06,0x20};

unsigned char Sec,Hour,Min;

void Sel_HC138(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 Running_SMG(unsigned char A,B)
{
	P0=0xff;
	Sel_HC138(6);
	P0=0x01<<(A-1);
	Sel_HC138(7);
	P0=SMG_NoDot[B];
}

void Init_DS1302()
{
	unsigned char i;
	Write_Ds1302_Byte(0x8e,0x00);
	for(i=0;i<7;i++)
	{
		Write_Ds1302_Byte(Write_addr[i],TIME[i]);
	}
	Write_Ds1302_Byte(0x8e,0x80);
}
		
//void Set_DS1302()
//{
//	Write_Ds1302_Byte(0x8E,0x00);
//	Write_Ds1302_Byte(0x80,Sec);
//	Write_Ds1302_Byte(0x82,Min);
//	Write_Ds1302_Byte(0x84,Hour);
//	Write_Ds1302_Byte(0x8E,0x80);
//}

void Read_DS1302()
{
	Sec=Read_Ds1302_Byte(0x81);
	Min=Read_Ds1302_Byte(0x83);
	Hour=Read_Ds1302_Byte(0x85);
}
	
void Scan_SMG()
{
	Running_SMG(1,Hour>>4);
	Delay(100);
	Running_SMG(2,Hour&0x0f);
	Delay(100);
	Running_SMG(3,16);
	Delay(100);

	Running_SMG(4,Min>>4);
	Delay(100);
	Running_SMG(5,Min&0x0f);
	Delay(100);
	Running_SMG(6,16);
	Delay(100);
	
	Running_SMG(7,Sec>>4);
	Delay(100);
	Running_SMG(8,Sec&0x0f);
	Delay(100);
}

void main()
{
	Sel_HC138(4);
	P0=0xff;
	Sel_HC138(5);
	P0=0x00;
	Sel_HC138(7);
	P0=0xFF;
	Init_DS1302();
	while(1)
	{
		Read_DS1302();
		Scan_SMG();
	}
}
	
//新建工程，编写代码，在 CT107D 单片机综合训练平台上，实现以下功能：
//1、````````````````````````琋E555 定时器发生的信号输入到单片机的 P34 引脚。
//2、单片机的 P34 引脚为定时器 T0 的外部计数信号输入引脚。
//2、系统上电后，关闭蜂鸣器、继电器和 8 个 LED 指示灯。
//3、测量 NE555 定时器产生信号的频率，并在数码管中显示。
//4、显示格式如图，频率数据显示用 6 位数码管，单位是 Hz，当显示长度不足 6 位时，
//未使用到的数码管熄灭，在最左边的 1 位数码管用“F”作为提示符。显示格式如下：
//5、改变 Rb3 可调电位器的电阻大小，可以改变 NE555 定时器产生信号的频率
#include <REGX52.H>

unsigned int Dat,Count_f;
unsigned char Count_t;

unsigned char code SMG[18]=
		{0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
		 0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
 
void Delay(unsigned int t)
{
	while(t--);
}
		 
void Sel_HC138(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 Running_SMG(unsigned char A,B)
{
	P0=0xFF;
	Sel_HC138(6);
	P0=0x01<<(A-1);
	Sel_HC138(7);
	P0=SMG[B];
}

void Scan_SMG()
{
	Running_SMG(1,15);
	Delay(50);
	Running_SMG(3,Dat/10000);
	Delay(50);
	Running_SMG(4,(Dat/1000)%10);
	Delay(50);
	Running_SMG(5,(Dat/100)%10);
	Delay(50);
	Running_SMG(6,(Dat/10)%10);
	Delay(50);
	Running_SMG(7,Dat%10);
	Delay(50);
}
		
void Init_Timer()
{
	TH0 = 0xff;        
	TL0 = 0xff;
	
	TH1 = (65536 - 50000) / 256;        
	TL1 = (65536 - 50000) % 256;
	
	TMOD = 0x16;     //定时器1用方式1，定时；定时器0用方式2，计数
	
  ET0 = 1;
  ET1 = 1;
	EA = 1;
	
	TR0 = 1;
	TR1 = 1;
}

void Service_T0() interrupt 1
{
	Count_f++;
	TH0 = 0xff;        
	TL0 = 0xff;
}

void Service_T1() interrupt 3
{
	TH1=(65535-50000)/256;
	TL1=(65535-50000)%256;
	Count_t++;
	if(Count_t==20)
	{
		Dat=Count_f;
		Count_f=0;
		Count_t=0;
	}
}

void main()
{
	Init_Timer();
	Sel_HC138(7);
	P0=0xff;
	while(1)
	{
		Scan_SMG();
	}
}

一名莽夫
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
蓝桥杯代码
05-02
历年来的蓝桥杯大赛单片机设计与开发组代码，希望给有需要的人
蓝桥杯真题代码
nanfang_yinan的博客
10-15 222
2019年第十届蓝桥杯C/C++ 省赛B组真题 试题G #include<stdio.h> #include<iostream> using namespace std; int main(){ int n; cin>>n; int i=1,j=0; int t=0; while(t!=n){ t=t+i; i=i*2; j++; } int mmax=0;
蓝桥杯比赛提供代码
01-11
蓝桥杯单片机组官方提供代码，包含DS1302，DS18B20，IIC
蓝桥杯练习代码
qq_42214376的博客
10-25 307
蓝桥杯省赛精选
蓝桥杯程序源码
01-11
蓝桥杯比赛的练习题源码，解题的方法，以及蓝桥杯比赛的题目练习。
蓝桥杯嵌入式个人备赛源代码
03-08
蓝桥杯嵌入式个人备赛源代码是指在参加嵌入式个人赛事备赛过程中所涉及的源代码，通常包括各种嵌入式系统的程序设计、算法实现以及硬件控制等方面的代码。在备赛过程中，源代码是参赛选手实现自己想法的关键工具，也...
蓝桥杯代码.zip
04-22
蓝桥杯大赛的难度相对于ACM和程序设计竞赛而言题目要简单一些，比赛形式为个人赛，一共有十道题目，题目难度顺序一般按照由易到难。前面几道题目一般是给出题面问一个特定的答案，只需要在本地计算然后提交答案。...
蓝桥杯个人代码.zip
11-13
《蓝桥杯个人代码.zip》是一个包含多个与51单片机相关的项目代码及解析的压缩包，主要针对“蓝桥杯”比赛的历年试题进行解答。51单片机是一种广泛应用的微控制器，因其易学易用和性价比高而深受初学者和工程师喜爱。...
蓝桥杯代码记录.zip
最新发布
04-22
蓝桥杯大赛的难度相对于ACM和程序设计竞赛而言题目要简单一些，比赛形式为个人赛，一共有十道题目，题目难度顺序一般按照由易到难。前面几道题目一般是给出题面问一个特定的答案，只需要在本地计算然后提交答案。...
蓝桥杯嵌入式个人备赛代码区
04-13
【标题】：“蓝桥杯嵌入式个人备赛代码区” 【内容详解】 蓝桥杯是国内一项具有较高影响力的IT竞赛，特别在嵌入式领域，它为参赛者提供了展示编程能力与解决实际问题的平台。备赛蓝桥杯嵌入式比赛，需要深入理解和...
蓝桥杯相关资料和代码
05-19
STC15芯片资料，仿真资料，开发板原理图，相关软件，相关例程
第九届蓝桥杯国赛代码
04-09
蓝桥杯第九届单片机类代码，要求基本实现，可以完整运行。
个人蓝桥杯代码库
weixin_43913885的博客
01-30 377
蓝桥杯2011年编程大题 8.程序设计（满分15分） 方阵的主对角线之上称为“上三角”。 请你设计一个用于填充n阶方阵的上三角区域的程序。填充的规则是：使用1，2，3….的自然数列，从左上角开始，按照顺时针方向螺旋填充。 例如：当n=3时，输出： 1 2 3 6 4 5 当n=4时，输出： 1 2 3 4 9 10 5 8 6 7 当n=5时，输出： 1 2 3 4 5 12 13 1...
有奖猜谜Java小明很喜欢猜谜语。 最近，他被邀请参加了X星球的猜谜活动。 每位选手开始的时候都被发给777个电子币。 规则是：猜对了，手里的电子币数目翻倍，
Han19980124的博客
09-17 377
有奖猜谜Java 小明很喜欢猜谜语。 最近，他被邀请参加了X星球的猜谜活动。 每位选手开始的时候都被发给777个电子币。 规则是：猜对了，手里的电子币数目翻倍， 猜错了，扣除555个电子币, 扣完为止。 小明一共猜了15条谜语。 战果为：vxvxvxvxvxvxvvx 其中v表示猜对了，x表示猜错了。 请你计算一下，小明最后手里的电子币数目是多少。 请填写表示最后电子币数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 public class Demo01 { publi
蓝桥杯-代码填空之三
继续激情，继续奋斗。
03-13 1848
连续和的平方数— ①连续和的平方数 1+3 = 4,  1+3+5 = 9,  1+3+5+7 = 16 它们的结果都是平方数。 这是偶然的巧合吗？下面代码验证对于累加至1000以内的情况都成立。 int n = 1; for(int i=1; i<1000/2; i++) { n += 2 * i + 1; int m = ______________; if
蓝桥杯分考场解题代码
qq_21563477的博客
02-10 497
蓝桥杯分考场解题代码 试题 历届试题 分考场 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 　　n个人参加某项特殊考试。 　　为了公平，要求任何两个认识的人不能分在同一个考场。 　　求是少需要分几个考场才能满足条件。 输入格式 　　第一行，一个整数n(1<n<100)，表示参加考试的人数。 　　第二行，一个整数m，表示接下来有m行数据 　　以下m行每行的格式为：...
蓝桥杯STC基础代码-基础外设
layyy
05-29 856
蓝桥杯STC基础代码上一章-以定时器计数作为时间轴的模板 上一章-以定时器计数作为时间轴的模板 上一次讲到了利用定时器2计数作为时间轴，根据每个任务特点分配运行时间。 博客网址
2019 蓝桥杯省赛 B 组模拟赛（一） 代码填空：LIS (LIS二分写法)
Romantic Chopin in C Sharp Minor
01-31 640
LIS 是最长上升子序列。什么是最长上升子序列？ 就是给你一个序列，请你在其中求出一段最长严格上升的部分，它不一定要连续。 就像这样：22, 33, 44, 77 和 22, 33, 44, 66 就是序列 22 55 33 4411 77 66 的两个上升子序列，最长的长度是 44。 题目来源 2019 蓝桥杯省赛 B 组模拟赛（一） #include &lt;bits/stdc++....
蓝桥杯单片机组的各模块代码总结（供参考学习）
m0_57761613的博客
06-04 447
这是蓝桥杯单片机组各常考的使用以及总结，供新手朋友参考学习，如有错误，请批评指正。
第十五届蓝桥杯大赛个人赛web
04-16
第十五届蓝桥杯大赛个人赛web是中国著名的计算机竞赛之一，旨在选拔和培养优秀的计算机人才。该比赛主要面向在校大学生，涵盖了计算机科学与技术、软件工程、网络工程等相关专业的知识和技能。 在个人赛web项目中，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值