51单片机之路__基础部分完结（学习笔记）
普中科技A3开发板
吐槽一下客服给的代码是真的辣鸡
都没备份他们的代码 直接覆盖了
导航：
一、LED
二、蜂鸣器
三、动态数码管
四、独立按键
五、矩阵按键
六、I/O拓展–74HC595
七、LED点阵
八、直流电机
九、外部中断
十、定时器
十一、EEPROM-IIC总线
LED：
单灯点亮：P2^n ，n∈[0,7]。分别对应8个灯
#include "reg52.h"
sbit led1=P2^0;
sbit led2=P2^1;
sbit led8=P2^7;
void main()
{
led1=0;
led2=0;//0011 1110
led8=0;//第1、2、8灯亮
while(1){}
}
多灯点亮：给P2赋值，将其转换为8位二进制
#include "reg52.h"
#define led P2
void main()
{
led=17; //第1、5灯熄灭
while(1){} //17对应二进制的 0001 0001
} //对应led灯位置 即为 1000 1000
//1、5位为高电平
Q1：如果led=0x11，哪个灯点亮？
A1：当然效果一样。十进制是17，十六进制是0x11。
Q2：对于单灯点亮的例子，用多灯点亮的方式，给P2赋值什么？
A2：第1、2、8灯亮，即0011 1110，倒推回去，0111 1100的十六进制为0x7c，效果一样。
一开始我是转化成二进制，然后从后看，这样1就对应了熄灭的灯（0对应点亮）的位置。
其实在正面 从右往左看，不就是从后面 由左向右吗？当然也可以把板子倒过来，自己能分清是哪个灯就可以。
也就是：
P2.0的数值(第一个灯)对应二进制的最低(右)位；
P2.7的数值(第八个灯)对应二进制的最高(左)位。
闪烁：定义并使用delay(延迟)函数，delay只是个习惯命名，完全可以取别的，这里延迟时间可以自定义。
#include "reg52.h"
sbit led=P2^0; //选择第1个灯
void delay(int i)
{
while(i--);
}
void main()
{
while(1)
{
led=0;
delay(50000); //大约延时450ms
led=1;
delay(50000); //大约延时450ms
}
}
这里每次输入时间参数有些繁琐，如果你多次要用延迟1s、2s，可以这样定义并调用。其他时间以此类推，时间延迟的间隔只是大概，并不精准。
void delay_1s()
{
while(100000--);
}
void delay_2s()
{
while(200000--);
}
delay_1s(); //延迟一秒
delay_2s(); //延迟两秒
流水灯
#include "reg52.h"
#include "intrins.h"
#define led P2
void delay(int i)
{
while(i--);
}
void main()
{
int i;
led=~0x01;
delay(50000);
while(1)
{
for(i=0;i<8;i++)
{
led=~(0x01<<i); //效果等同于led=_crol_(led,1);
delay(50000); //注意：该方法(_crol_)要用intrins库
}
}
}
注意：
led=~0x01; // 1111 1110
_crol_(led,1); //结果为 1111 1101
led=~0x01; // 1111 1110
led<<1; //结果为 1111 1100
可以理解为：
第一种移动后高位补低位
第二种移动后只补0
而我用<<实现同样的效果，是这样一个过程。
0000 0001→→→→0000 0010→→→→1111 1101
<<1(左移1) ~(取反)
_cror_(led,2) 即为右移2位 移动几位由第二个形参决定
返回顶部
蜂鸣器：
#include "reg52.h"
sbit beep=P2^5;
void delay(int i)
{
while(i--);
}
void main()
{
while(1)
{
beep=~beep;
delay(100); //通过修改此延时时间达到不同的发声效果
}
}
可以演奏音乐，并不难，自行探索。
返回顶部
动态数码管：
一、位选：选择你要第几个数码管点亮
对P2^4、3、2的二进制
取反后+1即为对应第n个灯
#include "reg52.h"
sbit LSA=P2^4;
sbit LSB=P2^3;
sbit LSC=P2^2;
LSA=1;LSB=0;LSC=0; //显示第4位
当时按普中的程序走了个小弯路。。。
首先将8个数码管看作0-7个
LSA=1;LSB=1;LSC=1; //显示第0个
LSA=0;LSB=1;LSC=1; //显示第1个
LSA=1;LSB=1;LSC=0; //显示第4个
如何知道是第几个数码管？
旧方法：对110 取反得001 从后看 得对应二进制数值 100（十进制4） 则显示第4位。其实完全可以先定义LSC=0 ，也可以把sbit LSA=P2^4。
无论如何，怎么方便怎么来。这样只需取反，不必从后看(从右向左看)了
二、段选：
如果我要表示sdau四个字母。
以s为例子(其实s也就相当于5)
由于数码管表示的"8"是由7段 以及右下角一个小数点组成
我要点亮AFGCD，则
.(dp) G F E D C B A
对应 0 1 1 0 1 1 0 1 二进制表示
十六进制为6d
位选后将P0赋值为6d即可
#include "reg52.h"
sbit LSA=P2^4;
sbit LSB=P2^3;
sbit LSC=P2^2;
void delay(int i)
{
while(i--);
}
void main()
{ while(1){
LSA=1;LSB=1;LSC=1; //显示第1位
P0=0x6d; //赋值段码
delay(100); //延迟
P0=0x00; //消隐
LSA=1;LSB=1;LSC=0; //显示第2位
P0=0x5e;
delay(100);
P0=0x00;
LSA=1;LSB=0;LSC=1; //显示第3位
P0=0x77;
delay(100);
P0=0x00;
LSA=1;LSB=0;LSC=0; //显示第4位
P0=0x3e;
delay(100);
P0=0x00;
}
}
三、延迟与消隐：
应用如上图，缺一不可，否则造成问题。
1、不消隐位选灯重叠或混乱
2、不delay延迟导致亮度暗
PS：要写入while循环，否则或许第一个灯全段点亮。(至少我的板子如此)
代码重复的地方可以写入for循环，将不同的内容依次放入数组，如下依次显示0-7
#include "reg52.h"
sbit LSA=P2^4;
sbit LSB=P2^3;
sbit LSC=P2^2;
int code smgduan[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,
0x77,0x7c,0x39,0x5e,0x79,0x71};//显示0~9和A~F的值
void delay(int i)
{
while(i--);
}
void main()
{
while(1)
{
int i;
for(i=0;i<8;i++)
{
switch(i) //位选，选择点亮的数码管，
{
case(0):
LSA=1;LSB=1;LSC=1; break;//显示第1位
case(1):
LSA=1;LSB=1;LSC=0; break;//显示第2位
case(2):
LSA=1;LSB=0;LSC=1; break;//显示第3位
case(3):
LSA=1;LSB=0;LSC=0; break;
case(4):
LSA=0;LSB=1;LSC=1; break;
case(5):
LSA=0;LSB=1;LSC=0; break;
case(6):
LSA=0;LSB=0;LSC=1; break;
case(7):
LSA=0;LSB=0;LSC=0; break;//显示第7位
}
P0=smgduan[i];//发送段码
delay(100); //间隔一段时间扫描
P0=0x00;//消隐
}
}
}
返回顶部
独立按键：
按键未按下为高电平1，按下后不松开即为低电平0。
delay延时是为了消除抖动的影响，如图，可以理解为直接跳过抖动部分(10ms~20ms)。否则可能0的瞬间又到了1，最后稳定又到了0，进行了两次取反，由于太快看不到，最终好像没有效果。
以下代码效果为：按下时，第一个灯取相反状态，松开时，第二个灯取相反状态。(两个等初始状态为高电平1熄灭)
#include "reg52.h"
sbit key1=P3^1; //定义第一个独立按键为key1
sbit led1=P2^0; //定义第1个LED灯
sbit led2=P2^1; //定义第2个LED灯
void delay(int i)
{
while(i--);
}
void keypress()
{
if(key1==0) //检测按键key1是否按下
{
delay(1000); //消除抖动 一般大约10ms
if(key1==0) //再次判断按键是否按下
{
led1=~led1; //led1状态取反
}
while(!key1); //检测按键是否松开
if(key1==1) //检测按键key1是否松开
{
delay(1000);
if(key1==1)
{
led2=~led2;
}
}
}
}
void main()
{
while(1) //一直进行检测
{
keypress(); //按键处理函数
}
}
至于不消抖的后果，本人亲测，疯狂按键测试。会有很大几率误判，总之，消抖就对了。
返回顶部
矩阵按键：
先给P1口赋值0x0f（0000 1111）
按下按键变成0x0b（0000 1101）
我们把0x0b定义为第二列
这样就可以知道按键在第二列
先给P1口赋值0xf0 (1111 0000)
按下按键变成0xb0 (1011 0000)
我们把0xb0定义为第二行
这样就可以知道按键在第二行
导线有一端为0则点位为0。所以不会变成1111 0100
#include "reg52.h"
#define GPIO_DIG P0
#define MATRIX_KEY P1
int KeyValue; //用来存放读取到的键值
int code smgduan[17]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
0x88,0x83,0xc6,0xa1,0x86,0x8e};//显示0~9和A~F的值（共阳极）
void delay(int i)
{
while(i--);
}
void KeyDown(void)
{
char a=0;
MATRIX_KEY=0x0f;
if(MATRIX_KEY!=0x0f) //检测按键是否按下
{
delay(1000); //延时10ms进行消抖
if(MATRIX_KEY!=0x0f)//再次检测键盘是否按下
{
//检测列
MATRIX_KEY=0X0F;
switch(MATRIX_KEY)
{
case(0X07): KeyValue=0;break;
case(0X0b): KeyValue=1;break;
case(0X0d): KeyValue=2;break;
case(0X0e): KeyValue=3;break;
}
//检测行
MATRIX_KEY=0XF0;
switch(MATRIX_KEY)
{
case(0X70): KeyValue=KeyValue;break;
case(0Xb0): KeyValue=KeyValue+4;break;
case(0Xd0): KeyValue=KeyValue+8;break;
case(0Xe0): KeyValue=KeyValue+12;break;
}
}
}
while((a<50)&&(MATRIX_KEY!=0xf0)) //检测按键松手检测
{
delay(100);
a++;
}
}
void main()
{
while(1)
{
KeyDown(); //按键判断函数
GPIO_DIG=~smgduan[KeyValue]; //按位取反 变为共阴极对应代码
}
}
返回顶部
I/O拓展–74HC595：
学习过程中看到的每篇文章都提到过它的特点：串行输入，并行输出。
究竟是什么意思？
有一篇文章将其比作手枪弹夹和霰弹枪
上膛是弹夹串行输入，而霰弹枪发射则是并行输出
比喻很生动，但又缺少一些解释，所以再加一些我自己的理解。
首先，看到这有4个引脚需要我们控制。
切记，OE要接GND才有效。
剩下的3个脚可以看作…
| 引脚 | 比喻 | 上升沿作用 |
|---|---|---|
| SER (P34) | 子弹 | \ |
| SRCLK (P36) | 装弹 | 子弹塞入弹夹，之前的子弹下移 |
| RCLK (P35) | 扳机 | 发射8颗子弹 |
装弹与扳机都是上升沿有效。
那么，究竟什么是上升沿有效？
其实就是，当电位由低到高，就会激发作用。
相反，还记得独立按键吗？从高到低的过程，就是下降沿。(不记得点我)
但它不用延迟，为什么？因为它不是按键，没有抖动(maybe)，理想下这样。
Q：我们如何发送一个字节呢？
A：一个字节有八位，看作8个子弹。最高位为第一颗子弹，最低为为第八颗。如，0111 1111 第一个子弹为0。
先装入最高位。这个过程跟进栈类似。
每次要给SER赋值0或1，也就是让这颗子弹为0或1。然后SRCLK就是装弹。
如此循环，8颗装完之后，使用RCLK发射！
要注意，SRCLK和RCLK都要经历一个过程，即电平由低到高的变化，才能实现。
以下代码直接引用普中科技的， 我只修改了注释和一些变量名， 没有进行精简。
这里例程为矩阵led效果展示，请先学习下一节。
#include "reg51.h"
#include "intrins.h"
char ledNum;
//--定义使用的IO口--//
sbit SRCLK=P3^6; //定义：扳机
sbit RCLK=P3^5; // 装弹
sbit SER=P3^4; // 弹夹
sbit LED=P0^7;
void delay(int i)
{
while(i--);
}
void Hc595SendByte(char dat)
{
char i;
SRCLK = 1;
RCLK = 1;
for(i=0;i<8;i++) //发送8位数
{
SER = dat >> 7; //子弹准备塞入弹夹
dat <<= 1; //第一颗已经填入，把第一位丢掉，到最后一位，这里是位运算，如1234 5678 变为 2345 6780
SRCLK = 0; //先变为低电平
_nop_();
_nop_();
SRCLK = 1; //从低到高上升沿，填入子弹，第一颗子弹下移。
//如此循环，填入8个子弹。
}
RCLK = 0;
_nop_();
_nop_();
RCLK = 1; //发射
}
void main()
{
LED=0;
ledNum = ~0x01; //1111 1110 最下面熄灭
while(1)
{
Hc595SendByte(ledNum); //发送数据 点亮LED灯
ledNum = _crol_(ledNum, 1);//变为1111 1110 以此类推
delay(50000);
}
}
实验现象：矩阵LED灯从下往上熄灭，类似流水灯效果
返回顶部
LED点阵：
例如左下角点亮，只需让ROW8=1（高电平），ROW1到ROW7为0 。 COLUMN1=0（低电平），COLUMN2到8为0或1（二极管导电特性）。
点亮列COLUMN：由P0口控制
使第一列亮，可以P0^7=0
P0^7对应二进制最左/高位（参考点亮二极管）
或P0=0x7f（0111 1111）即可。
直观：最高位控制最左边一列
点亮行ROW：由74Hc595输出口控制
输入0xfe
输出1111 1110
二级制从左到右
对应ROW由上到下
此时左下角为熄灭
#include "reg51.h"
#include "intrins.h"
sbit SRCLK=P3^6;
sbit RCLK=P3^5;
sbit SER=P3^4;
sbit LED_Column_1=P0^7;
void Hc595SendByte(char dat1)
{
char a;
SRCLK = 1;
RCLK = 1;
for(a=0;a<8;a++)
{
SER = dat1 >> 7;
dat1 <<= 1;
SRCLK = 0;
_nop_();
_nop_();
SRCLK = 1;
}
RCLK = 0;
_nop_();
_nop_();
RCLK = 1;
}
void main()
{ LED_Column_1=0; //使第一列为低电平。
while(1)
{
Hc595SendByte(0xfe);
}
}
进阶：
显示数字零
#include "reg51.h"
#include返回顶部
直流电机：
一端接地，一端接5V就能转。
可以接一个控制口，如下图所示。
#include "reg52.h"
#include返回顶部
外部中断：
一直没看明白普中给的例程，不是看不明白代码，而是根本感觉不到中断的作用！先放一下他们的代码。
#include "reg52.h"
sbit k3=P3^2; //定义按键 K3
sbit led=P2^0; //定义 P20 口是 led
void delay(u16 i)
{
while(i--);
}
void Int0Init()
{
//设置 INT0
IT0=1;//跳变沿出发方式（下降沿）
EX0=1;//打开 INT0 的中断允许。
EA=1;//打开总中断
}
void main()
{
Int0Init(); // 设置外部中断 0
while(1);
}
void Int0() interrupt 0 //外部中断 0 的中断函数
{
delay(1000); //延时消抖
if(k3==0)
{
led=~led;
}
}
所以，为什么要用中断？这和我用if判断k3是否按下，然后，对led灯操作有什么区别？根本无法体现中断的优越，就这个代码困扰了我半天，让我一直觉得中断就仅仅是个函数。
Q：到底什么是中断？
A：就是让单片机暂停执行main()函数而去执行"中断函数"。
既然让单片机暂停，那必须给它一个信号。
来看看他们的PPT怎么说的。
（P3.2）可由IT0(TCON.0)选择其为低电平有效还是下降沿有效。
当CPU检测到P3.2引脚上出现有效的中断信号时，中断标志IE0(TCON.1)置1，向CPU申请中断。
好了，还是看我解释吧。
IT0=1;//跳变沿出发方式（下降沿）
EX0=1;//打开 INT0 的中断允许。
EA=1;//打开总中断
首先，EX0和EA暂且当做两个开关，都打开，才能用中断。
IT0则是，监听这个信号的方式。
又要去看独立按键那了
(点我去看)
IT0=1;
每次一个下降沿就是一个信号
IT0=0;
低电平是一个信号
不想多说了，看一下我修改的代码，感受一下什么是中断吧。
根本无需定义k3按键，而且采用IT0=1为什么还要消抖？真的无法理解。
#include "reg52.h"
sbit led=P2^0;
void main()
{
//设置 INT0
IT0=1;//跳变沿出发方式（下降沿）
EX0=1;//打开 INT0 的中断允许。
EA=1; //打开总中断
while(1);
}
void Int0() interrupt 0 //外部中断 0 的中断函数
{
led=~led;
}
回去看看普中的，这个是不是简单明了。
返回顶部
定时器/计数器：
振荡脉冲频率为12MHz时，那么它的时钟周期为1/12MHz，一个机器周期=时钟周期X12=1μs。
我的板子振荡脉冲频率11.018398MHz，那么它的时钟周期为1/11.018398MHz，一个机器周期=12/11.018398MHz≈1.08μs
所以为了方便，用12MHz举例。
这有两种方式计时：
第一种，计数位数时16位，由TH0作为高八位，TL0 作为低八位，组成16位加一计数器。
在TR0 =1后单片机开始计时，每经过一个机器周期单片机输出一个脉冲使定时器加一，加到16位全为1时会溢出，使TF0 =1，利用此性质可以去执行相应的功能。
TF0=1当做一个信号。类似于上一节P3^2中断里，将它的下降沿作为信号。
设置初值：
我们要的时间间隔都是1s、2s之类，那么，我们让开始计时到TF0 置1这个时间间隔变成1ms，然后for循环1000次，以此实现计时1s。
若 高八位 TH0 和 低八位 TL0 的初值都为0（即00000000 00000000），当16位全为1时，单片机一共经历了65536个机器周期，时间经过了65536μs。
以单次定时1ms（1000μs）为例。假设16位定时器的初值为x，由于单片机定时固定到达65536溢出，那么（65536-x）*12/12M = 1000，可计算得到x = 64536。
对应16进制为0x3cb0。那么高八位TH0 = 0x3c, 低八位TL0 = 0xb0。
#include "reg52.h"
sbit led=P2^0; //定义P20口是led
void Timer0Init()
{
TMOD|=0X01; //选择为定时器0模式，工作方式1，仅用TR0打开启动。
TH0=0XFC; //给定时器赋初值，定时1ms
TL0=0X18;
ET0=1; //打开定时器0中断允许
EA=1; //打开总中断
TR0=1; //打开定时器
}
void main()
{
Timer0Init(); //定时器0初始化
while(1);
}
void Timer0() interrupt 1
{
static int i;
TH0=0XFC; //给定时器赋初值，定时1ms
TL0=0X18; //11111100 00011000 （64536）
//65536-64536=1000μs
i++;
if(i==1000) //循环1000次 为1000ms=1s
{
i=0;
led=~led;
}
}
实现效果：led灯持续点亮1s，熄灭1s.
#include "reg52.h"
char code smgduan[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//显示0~F的值
char n=0;
void Timer1Init()
{
TMOD|=0X10; //选择为定时器1模式，工作方式1，仅用TR1打开启动。
TH1=0XFC; //给定时器赋初值，定时1ms
TL1=0X18;
ET1=1; //打开定时器1中断允许
EA=1; //打开总中断
TR1=1; //打开定时器
}
void delay(int i)
{
while(i--);
}
void main()
{
Timer1Init(); //定时器1初始化
while(1);
}
void Timer1() interrupt 3
{
int i;
TH1=0XFC; //给定时器赋初值，定时1ms
TL1=0X18;
i++;
if(i==1000)
{
i=0;
P0=smgduan[n++];
if(n==16)n=0;
}
}
实验效果：第一位数码管进行16进制计时
返回顶部
EEPROM-IIC总线：
返回顶部