本学习基于金沙滩电子科技http://www.kingst.org ，并且有江科大的一些知识补充

需要的软件

	软件下载链接

介绍

单片机，英文Micro Controller Unit，简称MCU

内部集成了CPU、RAM、ROM、定时器、中断系统、通讯接口等一系列电脑的常用硬件功能

单片机的任务是信息采集 (依靠传感器)、处理 (依靠CPU) 和硬件设备 (例如电机，LED等) 的控制

单片机跟计算机相比，单片机算是一个袖珍版计算机，一个芯片就能构成完整的计算机系统。但在性能上，与计算机相差甚远，但单片机成本低、体积小、结构简单，在生活和工业控制领域大有所用同时，学习使用单片机是了解计算机原理与结构的最佳选择

74HC138

38译码器

真值表

对应字母

C	B	A
ADDR2	ADDR1	ADDR0
G2	G1
ENLED	ADDR3

单片机的内部资源

Flash——程序存储空间，早期单片机是OTPROM。
RAM——数据存储空间。
SFR——特殊功能寄存器。

LED

点亮第一个LED灯

第一课，点亮第一个电容,呸，LED灯

学习步骤

根据提供的资料看开发板的原理图，对应需要的端口
给对应的端口赋值（高电平，低电平）
1. 单片机采用TTL电平技术
TTL电平信号规定，+5V等价于逻辑“1”，0V等价于逻辑“0”(采用二进制来表示数据时)。这样的数据通信及电平规定方式，被称做TTL（晶体管-晶体管逻辑电平）信号系统。
1. 使用16进制进行赋值
进制转换在线工具
3. 下载hex到单片机

代码及演示

#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()
{
	ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;

	LED = 0;
	while(1);
}

LED闪烁

延时低于20ms,即频率小于50Hz人眼难以看出小灯的闪烁变化

延时

代码及演示

#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()
{
	unsigned int i = 0;		   //定义一个无符号整形i

	ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;
	while(1)
	{	
		LED = 0;
		for(i=0; i<30000; i++);
		LED = 1;
		for(i=0; i<30000; i++);
	}
}

流水灯

前置知识

8个LED发光二极管，分别对应单片机IO口的P0.0到P0.7口，8个单片机IO口组成一个字节，在程序编写过程中，可以直接用P0来进行操作。

C语言的8位二进制数代表了8个IO口

16进制控制单个LED

C语言位运算

移位

各二进位全部左/右移若干位，高/低位丢弃，低/高位补0

左移 << 右移 >>

X<<1 X>>1

左移，最低位填0补充；右移，最高位填0补充

0xF0 1111 0000 1110 0000 0111 1000

取反

按位取反符号 ~

取反后1变成0，0变成1

0x0F取反后成为 0xF0,即0000 1111->1111 0000

代码及演示

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

void main()
{
	unsigned char cnt = 0;
	unsigned int i=0;
	ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;

	while(1)
	{
		P0 = ~(0x01 <<cnt);
		for(i=0; i<30000; i++);
		cnt++;
		if(cnt>=8)
		{
			cnt = 0;
		}
	}

}

定时器

逻辑运算

前置知识

时钟周期：单片机时序中的最小单位，具体计算的方法就是时钟源分之一。

机器周期：我们的单片机完成一个操作的最短时间。

定时器：打开定时器后，定时器"存储寄存器"的值经过一个机器周期自动加1，也就是说，机器周期是定时器的计数周期。

定时器

TH/TL——定时器存储寄存器

计算方式

前提：

markdown

   1. 频率：频率是单位时间内完成周期性变化的次数
      2.一个时钟周期 = 12 个机器周期

计算方式：

markdown

  假设我们单片机的晶振是11.0592MHz，那么一秒钟可产生的机器周期数 11.0592MHz / 12 = 921600 个，
如果我们要定时50 ms，即0.05 s,所以需要921600 * 0.05 = 46080个机器周期。而如果我们的定时器工作
在16位定时器/计数器模式，那么最大值为 2^16=65536,所以初值设置为 65536-46080 = 19456。
十六进制写法为：
TH0 = 0X4c;
TL0 = 0x00;
十进制写法为：
TH0 = (65536-46080)/256;
TL0 = (65536-46080)%256;
(16位二进制数对256求模得到的是高八位，同理求余得到的是低八位)

网页计算器

	TH0 和 TL0 计算器

TCON——定时器控制寄存器

TF0

定时器0溢出标记，记录溢出次数

比如,一天24小时,通过溢出记录是第几天

清零

软件清零
硬件清零（进入定时器中断时）

TR0

定时器0运行控制位,TR0 = 0停止,TR0 = 1 开始

TMOD——定时器模式寄存器

M1/M0工作模式

示例(自动重装)

溢出后,自动重装,TL0初始值变为0x55

定时器/计数器模式1示意图

使用定时器的方法

TMOD

位	7	6	5	4	3	2	1	0
符号	GATE(T1)	C/T(T1)	M1(T1)	M0(T1)	GATE(T0)	C/T(T0)	M1(T0)	M0(T0)
复位值	0	0	0	0	0	0	0	0

示例代码（LED闪烁）

#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()
{
	unsigned char cnt = 0;
	unsigned char flag = 0; 
	//unsigned int i=0;
	ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;

	TMOD = 0x01;
	TH0 = 0xB8; // x * 12 /11059200  = 0.2 x = 18432 TH0 = 65535 + 1 - x 
	TL0 = 0x00;
	TR0 = 1;
	
	while(1)
	{
		if(TF0 == 1)
		{
			TF0 = 0;
			TH0 = 0xB8;
			TL0 = 0x00;
			cnt++;
			if(cnt>=50)
			{
				cnt = 0;
				P0 = ~(0x01<<flag);
				flag++;
				if(flag>=8){
					flag = 0;
			}
		}
	}
 }
}

静态数码管

数码管原理图

本单片机为共阳极数码管

给与低电平亮

数码管真值表

字符	0	1	2	3	4	5	6	7
数值	0xC0	0xF9	0xA4	0xB0	0x99	0x92	0x82	0xF8
字符	8	9	A	B	C	D	E	F
数值	0x80	0x90	0x88	0x83	0xC6	0xA1	0x86	0x8E

数码管显示0 -F（静态）

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

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

void main()
{
	unsigned char cnt = 0;
	unsigned char sec = 0;	

	ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 0;
	ADDR1 = 0;
	ADDR0 = 0;

	TMOD = 0x01;
	TH0 = 0xB8;
	TL0 = 0x00;
	TR0 = 1;
	while(1)
	{
		if(TF0 == 1)
		{
			TF0 = 0;
			TH0 = 0xB8;
			TL0 = 0x00;
			cnt++;
			if(cnt >= 50)
			{
				cnt = 0;
				P0 = LedChar[sec];
				
				if(sec >= 15)
				{
					sec = 0;
				}
				else
				{
					sec++;
				}
			}

		}
	}
}

动态数码管

原理

多个数码管显示数字的时候，我们实际上是轮流点亮数码管(一个时刻只有一个数码管是亮的)，利用人眼的视觉暂留现象(也叫**余晖效应 **)
刷新周期<10ms(100Hz无闪烁)
刷新速度没必要过快

代码

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

unsigned char code LedChar[]={
	0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
	0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
	};
unsigned char LedBuff[6]={
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
	};

void main()
{
	unsigned int cnt = 0;
	unsigned long sec = 0;
	unsigned char i = 0;

	ENLED = 0;
	ADDR3 = 1;
	TMOD = 0x01;
	TH0 = 0xFC;
	TL0 = 0x67;
	TR0 = 1;

	while(1)
	{
		if(TF0 ==1)
		{
			TF0 = 0;
			TH0 = 0xFC;
			TL0 = 0x67;
			cnt++;
			if(cnt >= 1000)   
			{
				cnt = 0;
				sec++;
				LedBuff[0] = LedChar[sec%10];
				LedBuff[1] = LedChar[sec/10%10];
				LedBuff[2] = LedChar[sec/100%10];
				LedBuff[3] = LedChar[sec/1000%10];
				LedBuff[4] = LedChar[sec/10000%10];
				LedBuff[5] = LedChar[sec/100000%10];
			}

			if(i == 0)
			{ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0];}
			else if(i == 1)
			{ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1];}
			else if(i == 2)
			{ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2];}
			else if(i == 3)
			{ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3];}
			else if(i == 4)
			{ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4];}
			else if(i == 5)
			{ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5];}

		}
	}
}

中断

中断使能寄存器

中断查询序列

进入中断的条件

打开中断（EA,ET0）
符合中断条件
中断入口正确 interrupt x
计算方法：
x * 8 + 3 = 中断向量地址

中断优先级

当设置为默认中断固有优先级时：

当几个中断同时发生时，则先处理中断优先级高的中断程序，在处理任意中断期间发生中断，都不会响应。

当配置了中断优先级，即抢占优先级

同时发生中断，优先级高的先响应，在处理任意中断时，发生同级别或低级的中断，则不响应，发生优先级更高的中断时，则先处理高优先级中断，处理完毕，再回来处理当前中断。

应用

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

unsigned char code LedChar[]={
	0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
	0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
	};
unsigned char LedBuff[6]={
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
	};


unsigned int cnt = 0;

void main()
{
	
	unsigned long sec = 0;
	

	ENLED = 0;
	ADDR3 = 1;
	TMOD = 0x01;
	TH0 = 0xFC;
	TL0 = 0x67;
	TR0 = 1;
	EA = 1;
	ET0 = 1;

	while(1)
	{
	   	if(cnt >= 1000)
		{
			cnt = 0;
			sec++;
			LedBuff[0] = LedChar[sec%10];
			LedBuff[1] = LedChar[sec/10%10];
			LedBuff[2] = LedChar[sec/100%10];
			LedBuff[3] = LedChar[sec/1000%10];
			LedBuff[4] = LedChar[sec/10000%10];
			LedBuff[5] = LedChar[sec/100000%10];
		}		    
	}
}

 unsigned char i = 0; 
void InterruptTimer0()  interrupt 1		 
{
	TH0 = 0xFC;
	TL0 = 0x67;
	cnt++;
	P0 = 0xFF;
	switch(i)
	{
		case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0];break;
		case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1];break;
		case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2];break;
		case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3];break;
		case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4];break;
		case 5: ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5];break;
		default:break;
	}
}

点阵

点阵LED原理

8 * 8 = 64 个小灯

学习步骤

取模软件的应用
点阵流动字母的显示

实际上是多个图片的切换

利用二维数组达到横向图片切换

代码

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

unsigned char code image[30][8] = {
    {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},  //动画帧1
	{0xFF,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0x7F},  
	{0xFF,0x3F,0x7F,0x7F,0x7F,0x7F,0x7F,0x3F},  
	{0xFF,0x1F,0x3F,0x3F,0x3F,0x3F,0x3F,0x1F},  
	{0xFF,0x0F,0x9F,0x9F,0x9F,0x9F,0x9F,0x0F},  
    {0xFF,0x87,0xCF,0xCF,0xCF,0xCF,0xCF,0x87},  
    {0xFF,0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3},  
    {0xFF,0xE1,0x73,0x73,0x73,0xF3,0xF3,0xE1},  
    {0xFF,0x70,0x39,0x39,0x39,0x79,0xF9,0xF0},  
    {0xFF,0x38,0x1C,0x1C,0x1C,0x3C,0x7C,0xF8},  
    {0xFF,0x9C,0x0E,0x0E,0x0E,0x1E,0x3E,0x7C},  
    {0xFF,0xCE,0x07,0x07,0x07,0x0F,0x1F,0x3E},  
    {0xFF,0x67,0x03,0x03,0x03,0x07,0x0F,0x9F},  
    {0xFF,0x33,0x01,0x01,0x01,0x03,0x87,0xCF},  
    {0xFF,0x99,0x00,0x00,0x00,0x81,0xC3,0xE7},  
    {0xFF,0xCC,0x80,0x80,0x80,0xC0,0xE1,0xF3},  
    {0xFF,0xE6,0xC0,0xC0,0xC0,0xE0,0xF0,0xF9},  
    {0xFF,0x73,0x60,0x60,0x60,0x70,0x78,0xFC},  
    {0xFF,0x39,0x30,0x30,0x30,0x38,0x3C,0x7E},  
    {0xFF,0x9C,0x98,0x98,0x98,0x9C,0x1E,0x3F},  
    {0xFF,0xCE,0xCC,0xCC,0xCC,0xCE,0x0F,0x1F},  
    {0xFF,0x67,0x66,0x66,0x66,0x67,0x07,0x0F},  
    {0xFF,0x33,0x33,0x33,0x33,0x33,0x03,0x87},  
    {0xFF,0x99,0x99,0x99,0x99,0x99,0x81,0xC3},  
    {0xFF,0xCC,0xCC,0xCC,0xCC,0xCC,0xC0,0xE1},  
    {0xFF,0xE6,0xE6,0xE6,0xE6,0xE6,0xE0,0xF0},  
    {0xFF,0xF3,0xF3,0xF3,0xF3,0xF3,0xF0,0xF8},  
    {0xFF,0xF9,0xF9,0xF9,0xF9,0xF9,0xF8,0xFC},  
    {0xFF,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFE},  
    {0xFF,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFF}   //动画帧30
};

void main()
{
	EA = 1;
	ENLED = 0;
	ADDR3 = 0;
	TMOD =0x01;
	TH0 = 0xFC;
	TL0 = 0x67;
	ET0 = 1;
	TR0 = 1;
	while(1);
}

void InterruptTimer0() interrupt 1
{
	static unsigned char i = 0;
	static unsigned char tmr = 0;
	static unsigned char index = 0;

	TH0 = 0xfc;
	TL0 = 0x67;

	P0 = 0xFF;
	switch(i)
	{
		case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=image[index][0]; break;
		case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=image[index][1]; break;
		case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=image[index][2]; break;
		case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=image[index][3]; break;
		case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=image[index][4]; break;
		case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=image[index][5]; break;
		case 6: ADDR2=1; ADDR1=1; ADDR0=0; i++; P0=image[index][6]; break;
		case 7: ADDR2=1; ADDR1=1; ADDR0=1; i=0; P0=image[index][7]; break;
		default: break;
	}

	tmr++;
	if(tmr >= 250)
	{
		tmr = 0;
		index++;
		if(index>= 30)
		{
			index = 0;
		}
	}
}

单片机最小系统解析

电源

常用单片机的电源系统有5V系统和3.3V系统这两种。常用的数字电路系统的电源类别有24V、12V、5V、3.3V、2.5V、1.8V。

晶振

复位

上电复位：

复位时间t = 1.2RC 故：t = 1.2 * 4.7K *0.1uF = 564us, 大于两个机器周期约2us，故能起到复位作用。

手动复位：人手按下按键的时间一般100ms以上，快的也有几十ms,故满足复位条件。18欧的电阻作用是放电时，K、R、C形成闭合回路，**消除干扰 **。

独立按键

独立按键原理

矩阵按键变独立按键

按键消抖

按下按键数码管+1出现跳动问题

通过代码的延时来解决抖动问题

#include <reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

sbit KEY4 = P2^7;

// 数码管显示的字符编码
unsigned char code LedChar[] = {
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};

// 延时函数
void delay() {
    unsigned int i = 1000;
    while (i--);
}

void main() {
    bit backup = 1;   // 用于记录按钮按下状态的备份
    bit keybuf = 1;   // 用于记录按钮当前状态
    unsigned char cnt = 0;  // 计数器

    ENLED = 0;
    ADDR3 = 1;
    ADDR2 = 0;
    ADDR1 = 0;
    ADDR0 = 0;
    P2 = 0xF7;
    P0 = LedChar[cnt]; // 初始化数码管显示

    while (1) {
        keybuf = KEY4; // 读取按钮当前状态
        if (keybuf != backup) { // 如果按钮状态发生变化
            delay(); // 延时防抖
            if (keybuf == KEY4) { // 如果按钮仍然处于按下状态
                if (backup == 0) { // 如果之前是按下的状态
                    cnt++; // 计数器递增
                    if (cnt >= 10) {
                        cnt = 0;
                    }
                    P0 = LedChar[cnt]; // 更新数码管显示
                }
                backup = KEY4; // 更新按钮状态备份
            }
        }
    }
}

连续读取判断是否抖动

void InterruptTimer0() interrupt 1
{
	static unsigned char keybuf = 0xFF;

	TH0 = 0xF8;
	TL0 = 0xCD;

	keybuf = (keybuf <<1) |KEY4;	 
	if(keybuf == 0x00)
	{
		KeySta = 0;
	}
	else if(keybuf == 0xFF)
	{
		KeySta = 1;
	}
	else
	{
	}

矩阵按键

代码（去抖动）

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

sbit KEY_IN_1 = P2^4;
sbit KEY_IN_2 = P2^5;
sbit KEY_IN_3 = P2^6;
sbit KEY_IN_4 = P2^7;
sbit KEY_OUT_1 = P2^3;
sbit KEY_OUT_2 = P2^2;
sbit KEY_OUT_3 = P2^1;
sbit KEY_OUT_4 = P2^0;

unsigned char code LedChar[]={
	0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
	0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
	};
unsigned char KeySta[4][4] = { 
	{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
	};

void main()
{
    unsigned char i, j;
    // 初始值全为1（未按下）
    unsigned char backup[4][4] = {
        {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
    };

    // 允许全局中断
    EA = 1;
  
    ENLED = 0;
    
    ADDR3 = 1;
    ADDR2 = 0;
    ADDR1 = 0;
    ADDR0 = 0;
    // 设置定时器0工作在方式1
    TMOD = 0x01;
    // 设置定时器0的初始值
    TH0 = 0xFC;
    TL0 = 0x67;
    // 允许定时器0中断
    ET0 = 1;
    // 启动定时器0
    TR0 = 1;
    // 初始化LED显示为LedChar数组中的第一个字符
    P0 = LedChar[0];

    // 主循环
    while(1)
    {
        for(i=0; i<4; i++)
        {
            for(j=0; j<4; j++)
            {
                // 检测状态是否发生变化
                if(backup[i][j] != KeySta[i][j])
                {
                    // 如果按键按下
                    if(backup[i][j] == 0)
                    {
                        // 在LED数码管上显示相应字符
                        P0 = LedChar[i*4+j];
                    }
                    // 更新备份数组
                    backup[i][j] = KeySta[i][j];
                }
            }
        }
    }
}

// 定时器0中断服务程序
void InterruptTimer0() interrupt 1
{
    // 静态变量，记录当前扫描的行号
    static unsigned char keyout = 0;
    unsigned char i = 0;
    // 静态二维数组，保存按键缓冲区，初始值为0xFF
    static unsigned char keybuf[4][4] = {
        {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF}
    };

    // 重置定时器0的初始值
    TH0 = 0xFC;
    TL0 = 0x67;

    // 将键盘输入值放入按键缓冲区
    keybuf[keyout][0] = (keybuf[keyout][0] <<1) | KEY_IN_1;
    keybuf[keyout][1] = (keybuf[keyout][1] <<1) | KEY_IN_2;
    keybuf[keyout][2] = (keybuf[keyout][2] <<1) | KEY_IN_3;
    keybuf[keyout][3] = (keybuf[keyout][3] <<1) | KEY_IN_4;

    // 检测按键状态
    for(i=0; i<4; i++)
    {
        if((keybuf[keyout][i] & 0x0F) == 0x00)
        {
            // 按键按下
            KeySta[keyout][i] = 0;
        }
        else if((keybuf[keyout][i] & 0x0F) == 0x0F)
        {
            // 按键释放
            KeySta[keyout][i] = 1;
        }
    }

    // 切换到下一行
    keyout++;
    keyout = keyout & 0x03;
    switch(keyout)
    {
        case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
        case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0;  break;
        case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
        case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0;  break;
        default: break;
    }
}

代码

独立按键控制LED亮灭

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

sbit LED9 = P0^7;
sbit LED8 = P0^6;
sbit LED7 = P0^5;
sbit LED6 = P0^4;

sbit KEY1 = P2^4;
sbit KEY2 = P2^5;
sbit KEY3 = P2^6;
sbit KEY4 = P2^7;

void main(){
	ENLED = 0;
	ADDR3 = 1;
	ADDR2 = 1;
	ADDR1 = 1;
	ADDR0 = 0;
	P2 = 0xF7;
	
	while(1){
		LED9 = KEY1;
		LED8 = KEY2;
		LED7 = KEY3;
		LED6 = KEY4;
	}
	
}

单片机IO口的结构

上下拉电阻

上拉电阻就是将不确定的信号通过一个电阻拉到高电平，同时此电阻起到一个限流的作用，下拉就是下拉到低电平。

1、OC门要输出高电平，外部必须加上拉电阻。

2、加大普通IO口的驱动能力。

3、起到限流的作用。

4、抵抗电磁干扰。

选取原则

步进电机

电机分类

驱动类电机
1. 洗衣机、汽车
控制类电机
1. 步进电机-----照相机、机器人—控制转动角度

28BYJ-48步进电机

参数

八拍工作模式

八拍工作方式的英文名是half-stepping，英文表达很形象，转子从A转到AB中间，再有AB中间转到B，好似每次只走了半步。因此线圈通电顺序是：A-AB-B-BA’-A’-A’B’-B’-B’A（我用A‘代替了图中的“A非”）。八拍工作模式最大的好处就是扭矩大。

PS：四相电机的叫法可能存在一定问题（误导性），因为准确说它其实只有两组相位，四相=两组相位，图一中的定子也是成对命名的（A+/A-，B+/B-），所以图一中的步进电机更好的称呼是双相位五线式步进电机。当然主流叫法仍是五线四相，叫起来顺口，还是尽量使用“四相”称呼以方便交流。

内部结构

控制参数

蜂鸣器

分类

蜂鸣器

压电式蜂鸣器:电陶瓷片发音电磁式蜂鸣器:线圈通电,电动发音,体积较小有源蜂鸣器，指震荡源有源放鸣器内部带了震荡源无源蜂鸣器，价格便宜，但是可以产生高低音

D4：蓄流二极管，防止关断时，对三极管造成损伤

蜂鸣器是感性元器件


#include <reg52.h>

sbit BUZZ = P1^6;  //蜂鸣器控制引脚

unsigned int code NoteFrequ[] = {  //中音1-7和高音1-7对应频率列表
    523,  587,  659,  698,  784,  880,  988,  //中音1-7
    1047, 1175, 1319, 1397, 1568, 1760, 1976  //高音1-7
};
unsigned int code NoteReload[] = { //中音1-7和高音1-7对应的定时器重载值
    65536 - (11059200/12) / (523*2),  //中音1
    65536 - (11059200/12) / (587*2),  //2
    65536 - (11059200/12) / (659*2),  //3
    65536 - (11059200/12) / (698*2),  //4
    65536 - (11059200/12) / (784*2),  //5
    65536 - (11059200/12) / (880*2),  //6
    65536 - (11059200/12) / (988*2),  //7
    65536 - (11059200/12) / (1047*2), //高音1
    65536 - (11059200/12) / (1175*2), //2
    65536 - (11059200/12) / (1319*2), //3
    65536 - (11059200/12) / (1397*2), //4
    65536 - (11059200/12) / (1568*2), //5
    65536 - (11059200/12) / (1760*2), //6
    65536 - (11059200/12) / (1976*2), //7
};
bit enable = 1;   //蜂鸣器发声使能标志
bit tmrflag = 0;  //定时器中断完成标志
unsigned char T0RH = 0xFF;  //T0重载值的高字节
unsigned char T0RL = 0x00;  //T0重载值的低字节

void PlayTwoTiger();

void main()
{
    unsigned int i;
    
    EA = 1;       //使能全局中断
    TMOD = 0x01;  //配置T0工作在模式1
    TH0 = T0RH;
    TL0 = T0RL;
    ET0 = 1;      //使能T0中断
    TR0 = 1;      //启动T0
    
    while (1)
    {
        PlayTwoTiger();  //播放乐曲--两支老虎
        for (i=0; i<40000; i++);  //停止一段时间
    }
}
/* 两只老虎乐曲播放函数 */
void PlayTwoTiger()
{
    unsigned char beat;   //当前节拍索引
    unsigned char note;   //当前节拍对应的音符
    unsigned int time = 0;      //当前节拍计时
    unsigned int beatTime = 0;  //当前节拍总时间
    unsigned int soundTime = 0; //当前节拍需发声时间
    //两只老虎音符表
    unsigned char code TwoTigerNote[] = {
        1,   2,   3, 1,    1,   2,   3, 1,   3, 4, 5,   3, 4, 5,
        5,6, 5,4, 3, 1,    5,6, 5,4, 3, 1,   1, 5, 1,   1, 5, 1,
    };
    //两只老虎节拍表，4表示一拍，1就是1/4拍，8就是2拍
    unsigned char code TwoTigerBeat[] = {
        4,   4,   4, 4,    4,   4,   4, 4,   4, 4, 8,   4, 4, 8,
        3,1, 3,1, 4, 4,    3,1, 3,1, 4, 4,   4, 4, 8,   4, 4, 8,
    };
    
    for (beat=0; beat<sizeof(TwoTigerNote); )  //用节拍索引作为循环变量
    {
        while (!tmrflag);  //每次定时器中断完成后，检测并处理节拍
        tmrflag = 0;
        if (time == 0)  //当前节拍播完则启动一个新节拍
        {
            note = TwoTigerNote[beat] - 1;
            T0RH = NoteReload[note] >> 8;
            T0RL = NoteReload[note];
            //计算节拍总时间，右移2位相当于除4，移位代替除法可以加快执行速度
            beatTime = (TwoTigerBeat[beat] * NoteFrequ[note]) >> 2;
            //计算发声时间，为总时间的0.75，移位原理同上
            soundTime = beatTime - (beatTime >> 2);
            enable = 1;  //指示蜂鸣器开始发声
            time++;
        }
        else  //当前节拍未播完则处理当前节拍
        {
            if (time >= beatTime)  //当前持续时间到达节拍总时间时归零，
            {                      //并递增节拍索引，以准备启动新节拍
                time = 0;
                beat++;
            }
            else  //当前持续时间未达到总时间时，
            {
                time++;   //累加时间计数
                if (time == soundTime)  //到达发声时间后，指示关闭蜂鸣器，
                {                       //插入0.25*总时间的静音间隔，
                    enable = 0;         //用以区分连续的两个节拍
                }
            }
        }
    }
}
/* T0中断服务函数，用于控制蜂鸣器发声 */
void InterruptTimer0() interrupt 1
{
    TH0 = T0RH;   //重新加载重载值
    TL0 = T0RL;
    tmrflag = 1;
    if (enable)   //使能时反转蜂鸣器控制电平
        BUZZ = ~BUZZ;
    else          //未使能时关闭蜂鸣器
        BUZZ = 1;
}

UART串口通信

通信方式

并行通信：通信时数据的各个位同时传送，可以实现字节为单位通信，但是通信线多占用资源多，成本高。

串行通信，一次只能发送一位，(每一位的持续时间----波特率baud)要发送8次才能发送一个字节。

RS232通信接口

三种基本通信类型

单工通信：只允许一方向另外一方传送信息，另一方不能回传信息，比如电视遥控器、收音机广播等。
半双工通信：数据可以在双方之间传播，同一时刻只能其中一方发给另外一方，比如对讲机就是典型半双工。
全双工通信：发送数据的同时也能够接收数据，两者同步进行，比如我们的电话通信。

串口通信程序的基本步骤

配置串口为模式1。
配置定时器T1为模式2，即自动重装模式。
根据波特率计算TH1和TL1的初值，如果有需要可以使用PCON进行波特率加倍。
打开定时器控制寄存器TR1，让定时器跑起来。

#include<reg52.h>
void ConfigUART(unsigned int baud);

void main()
{
	ConfigUART(9600);

	while(1)
	{
		while(!RI);
		RI = 0;
		SBUF = SBUF + 1;//第一个是发送buffer，第二个是接收
		while(!TI);
		TI = 0;		
	}
}

void ConfigUART(unsigned int baud)//配置波特率
{
	SCON = 0x50;
	TMOD &= 0X0F;
	TMOD |= 0x20;
	TH1 = 256 - (11059200/12/32)/baud;
	TL1 = TH1;
	ET1 = 0;//T1用作波特率发生器的时候，就不能用T1产生中断
	TR1 = 1;
}

//使用中断，不占用主循环
#include <reg52.h>

void ConfigUART(unsigned int baud);

void main()
{
    EA = 1;   //使能总中断
    ConfigUART(9600);  //配置波特率为9600
    while(1);
}
void ConfigUART(unsigned int baud)
{
    SCON  = 0x50;  //配置串口为模式1
    TMOD &= 0x0F;  //清零T1的控制位
    TMOD |= 0x20;  //配置T1为模式2
    TH1 = 256 - (11059200/12/32)/baud;  //计算T1重载值
    TL1 = TH1;     //初值等于重载值
    ET1 = 0;       //禁止T1中断
    ES  = 1;       //使能串口中断
    TR1 = 1;       //启动T1
}

void InterruptUART() interrupt 4
{
	if(RI)
	{
		RI = 0;
		SBUF = SBUF + 1;
	}
	if(TI)
	{
		TI = 0;
	}
}

1602液晶

1602液晶的认识

1602液晶读写时序

通信时序解析

I2C总线与EEPROM

I2C总线(协议)

I^2^C(Inter－Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备( 特别是外部存储器件)。
UART通信只需要一条线即可完成，I2C总线是由数据线SDA和时钟SCL构成的串行总线，可发送和接收数据。
从应用上来讲，UART通信多用于板间通信，I2C通信多用于板内通信。

EEPROM(器件)

24Cxx 存储量xxk bit 24C02即 256字节
可重复擦写30w到100w次
数据可保存100年

EEPROM写数据流程

第一步：首先是I2C的起始信号，接着跟上首字节，即EEPROM的地址和读写位的组合，读写方向上选择“写”操作。
第二步：发送要写入数据的EEPROM内部存储地址。
第三步：发送要存储的数据第一个字节、第二个字节... ...。
1. 写数据(单片机发送)过程中，每个字节结束后EEPROM都会回应一个“应答位0”，告诉我们写EEPROM成功，如果没有应答表示未成功。
2. 写数据过程中，每成功写入一个字节，EEPROM地址自动加1，当加到最大值，会溢出。

EEPROM读数据流程

第一步：首先是I2C的起始信号，接着跟上首字节，即EEPROM的地址和读写位的组合，读写方向上选择“写”操作。
第二步：发送要读取的EEPROM内部存储地址。
第三步：重新发送I2C的起始信号和器件地址，并且在方向位选择“读”操作。
**在这三步中，每一个字节实际上都是在“写”，因此EEPROM都会回应一个“应答位0”。**
第四步：读取从器件发回的数据，每读一个字节，如果还想继续读下一个字节，就发送一个“应答位0”，如果不想继续读了，就发送一个“非应答位1”。
应答位： ACK 非应答位：NACK

实时时钟DS1302

BCD码的概念

1. BCD码(Binary-Coded Decimal)即二-十进制代码
2. 0 ~ 9 : 0b0000 ~ 0b1001
3. 主要应用：时间、日期、年月在单片机系统中的存储、显示等。

SPI时序的初步认识

SPI时序的初步认识1

SPI ：Serial Peripheral Interface 是一种高速的、全双工、同步通信总线。
应用：单片机和EEPROM、实时时钟、数字信号处理器

SSEL：片选，也写做SCS，从设备片选使能信号。
SCLK：时钟，也写作SCK，由主机产生，和SCL类似
MOSI：主机输出从机输入，Master Output/Slave Input，主机给从机发送指令或者数据的通道。
MISO：主机输入从机输出，Master Input/Slave Output，主机读取从机的状态或者数据的通道

SPI的四种模式

实时时钟芯片DS1302

DS1302是一个实时时钟芯片，可以提供秒、分、小时、日期、月、年等信息，并且还有软件自动调整的能力，可以通过配置AM/PM来决定采用24小时格式还是12小时格式。
拥有31字节数据存储RAM。
串行I/O通信方式，相对并行来说比较节省IO口的使用。
DS1302的工作电压比较宽，在2.0～5.5V的范围内都可以正常工作。
DS1302这种时钟芯片功耗一般都很低，它在工作电压2.0V的时候，工作电流小于300nA。
DS1302共有8个引脚，有两种封装形式，一种是DIP-8封装，芯片宽度（不含引脚）是300mil，一种是SOP-8封装，有两种宽度，一种是150mil，一种是208mil。
当供电电压是5V的时候，兼容标准的TTL电平标准，这里的意思是，可以完美的和单片机进行通信。
由于DS1302是DS1202的升级版本，所以所有的功能都兼容DS1202。此外DS1302有两个电源输入，一个是主电源，另外一个是备用电源，比如可以用电池或者大电容，这样做是为了在系统掉电的情况下，我们的时钟还会继续走。

DS1302寄存器介绍

![image-20240217205951344](https://image-1319612571.cos.ap-shanghai.myqcloud.com/202402172059461.png)

DS1302单字节写操作时序

红外通信

红外发射管和接收管

信号调制原理

红外遥控发送接收原理图

NEC协议红外遥控器

DS1302红外通信

需要的软件 ​

介绍 ​

74HC138 ​

38译码器 ​

真值表 ​

对应字母 ​

单片机的内部资源 ​

LED ​

点亮第一个LED灯 ​

学习步骤 ​

代码及演示 ​

LED闪烁 ​

延时 ​

代码及演示 ​

流水灯 ​

前置知识 ​

16进制控制单个LED ​

C语言位运算 ​

移位 ​

取反 ​

代码及演示 ​

定时器 ​

逻辑运算 ​

前置知识 ​

定时器 ​

TH/TL——定时器存储寄存器 ​

计算方式 ​

前提： ​

计算方式： ​

网页计算器 ​

TCON——定时器控制寄存器 ​

TF0 ​

清零 ​

TR0 ​

TMOD——定时器模式寄存器 ​

M1/M0工作模式 ​

示例(自动重装) ​

定时器/计数器模式1示意图 ​

使用定时器的方法 ​

TMOD ​

示例代码（LED闪烁） ​

静态数码管 ​

数码管原理图 ​

本单片机为共阳极数码管 ​

数码管真值表 ​

数码管显示0 -F（静态） ​

动态数码管 ​

原理 ​

代码 ​

中断 ​

中断使能寄存器 ​

中断查询序列 ​

进入中断的条件 ​

中断优先级 ​

当设置为默认中断固有优先级时： ​

当配置了中断优先级，即抢占优先级 ​

应用 ​

点阵 ​

点阵LED原理 ​

学习步骤 ​

代码 ​

单片机最小系统解析 ​

电源 ​

晶振 ​

复位 ​

独立按键 ​

独立按键原理 ​

矩阵按键变独立按键 ​

按键消抖 ​

通过代码的延时来解决抖动问题 ​

连续读取判断是否抖动 ​

矩阵按键 ​

代码（去抖动） ​

代码 ​

独立按键控制LED亮灭 ​

单片机IO口的结构 ​

单片机IO口的结构 ​

上下拉电阻 ​

选取原则 ​

步进电机 ​

需要的软件

介绍

74HC138

38译码器

真值表

对应字母

单片机的内部资源

LED

点亮第一个LED灯

学习步骤

代码及演示

LED闪烁

延时

代码及演示

流水灯

前置知识

16进制控制单个LED

C语言位运算

移位

取反

代码及演示

定时器

逻辑运算

前置知识

定时器

TH/TL——定时器存储寄存器

计算方式

前提：

计算方式：

网页计算器

TCON——定时器控制寄存器

TF0

清零

TR0

TMOD——定时器模式寄存器

M1/M0工作模式

示例(自动重装)

定时器/计数器模式1示意图

使用定时器的方法

TMOD

示例代码（LED闪烁）

静态数码管

数码管原理图

本单片机为共阳极数码管

数码管真值表

数码管显示0 -F（静态）

动态数码管

原理

代码

中断

中断使能寄存器

中断查询序列

进入中断的条件

中断优先级

当设置为默认中断固有优先级时：

当配置了中断优先级，即抢占优先级

应用

点阵

点阵LED原理

学习步骤

代码

单片机最小系统解析

电源

晶振

复位

独立按键

独立按键原理

矩阵按键变独立按键

按键消抖

通过代码的延时来解决抖动问题

连续读取判断是否抖动

矩阵按键

代码（去抖动）

代码

独立按键控制LED亮灭

单片机IO口的结构

单片机IO口的结构

上下拉电阻

选取原则

步进电机