STC单片机控制28BYJ-48步进电机
STC单片机4*4按键控制步进电机旋转
28BYJ-48型步进电机说明
步进电机分为反应式、永磁式和混合式三种
我们在这里只讲解28BYJ-48型步进电机的具体含义：
28–步进电机最大有效外径为28毫米
B–表示是步进电机
Y–表示是永磁式
J–表示是减速型
48–表示是4相8拍
| 供电电压 | 相数 | 相电阻 | 步进角度 | 减速比 | 启动频率P.P.S | 转矩 | 噪声db | 绝缘介电强度 |
|---|---|---|---|---|---|---|---|---|
| 5V | 4 | 50±10% | 5.65/64 | 1:64 | ≥500 | ≥300 | ≤35 | 600VAC |
四相永磁式的含义
28BYJ-48步进电机中，里圈含有6个永磁齿的结构叫转子。
外圈与电机外壳固定，共有8个齿，每个齿上缠绕了线圈绕组，正对的两个齿上的绕组串联在一起。
也就是说正对的两个绕组将会同时导通或关闭，因此称为四相。
28BYJ-48工作原理
假定电机的起始状态就如图所示，逆时针方向转动，起始时是 B 相绕组的开关闭合，
B 相绕组导通，那么导通电流就会在正上和正下两个定子齿上产生磁性，这两个定子齿上的
磁性就会对转子上的 0 和 3 号齿产生最强的吸引力，就会如图所示的那样，转子的 0 号齿在
正上、3 号齿在正下而处于平衡状态；此时我们会发现，转子的 1 号齿与右上的定子齿也就
是 C 相的一个绕组呈现一个很小的夹角，2 号齿与右边的定子齿也就是 D 相绕组呈现一个稍
微大一点的夹角，很明显这个夹角是 1 号齿和 C 绕组夹角的 2 倍，同理，左侧的情况也是一
样的。
接下来，我们把 B 相绕组断开，而使 C 相绕组导通，那么很明显，右上的定子齿将对转
子 1 号齿产生最大的吸引力，而左下的定子齿将对转子 4 号齿，产生最大的吸引力，在这个
吸引力的作用下，转子 1、4 号齿将对齐到右上和左下的定子齿上而保持平衡，如此，转子
就转过了起始状态时 1 号齿和 C 相绕组那个夹角的角度。
再接下来，断开 C 相绕组，导通 D 相绕组，过程与上述的情况完全相同，最终将使转子
2、5 号齿与定子 D 相绕组对齐，转子又转过了上述同样的角度。
那么很明显，当 A 相绕组再次导通，即完成一个 B-C-D-A 的四节拍操作后，转子的 0、
3 号齿将由原来的对齐到上下 2 个定子齿，而变为了对齐到左上和右下的两个定子齿上，即
转子转过了一个定子齿的角度。依此类推，再来一个四节拍，转子就将再转过一个齿的角度，
8 个四节拍以后转子将转过完整的一圈，而其中单个节拍使转子转过的角度就很容易计算出
来了，即 360 度/(8*4)=11.25度，这个值被称为步进角度。
还有一种更有性能的工作模式，在单四拍的每两个节拍中插入一个双绕组到通的中间节拍，组成八拍模式。这样会使得电机的整体扭力输出增加，更有劲。
让电机转起来
步进电机一共有5根引线，其中红色为公共端，连接到5V电源，接下来橙黄粉蓝对应ABCD相，如果要导通A相绕组，秩序将橙色线接地即可。以此类推得出八拍模式绕组控制顺序表。
最简单的电机转动程序
该步进电机启动频率为550hz，因此我们只需要控制节拍刷新时间大于1.8ms即可。
#include<reg52.h>
unsigned char code BeatCode ={ //每个节拍对应I/O口的控制代码
0x0E,0x0C,0x0D,0x09,0x0B,0x03,0x07,0x06
};
void delay();
void main()
{
unsigned char tmp; //暂存P1IO口数据
unsigned char i = 0; //节拍输出索引
tmp = P1;
tmp = tmp & 0xF0; //清零P1口低4位
tmp = tmp | BeatCode[i]; //将控制代码赋给低4位
P1 = tmp; //将改变值返还给P1
i++; //索引递增
i = i & 0x07; //每八拍索引值归零
delay();
}
void delay()
{
unsigned int num = 200; //大概2ms延时
while(num--);
}
电机转速缓慢的原因分析
虽然电机成功转动，但是大家可以发现，电机转动速度非常缓慢。其原因则是因为该型号电机为减速电机，其内部普遍用小齿轮带动大齿轮，由参数表可知其减速比为1:64。
因此，步进电机真正旋转一周需要的拍数实际为6464=4096，时间为40962ms=8192ms，则步进角度为360/4096，表中步进角度参数5.625/64也与其吻合。
便于控制转过圈数的改进程序
#include <reg52.h>
void TurnMortor(unsigned long angle); //步进电机转动函数
void main()
{
TurnMortor(360*25); //将转动角度送入函数
while(1);
}
void delay()
{
unsigned int i = 200;
while(i--);
}
void TurnMortor(unsigned long angle)
{
unsigned char tmp; //暂存P1IO口数据
unsigned char index = 0; //节拍输出索引
unsigned char beats = 0; //总节拍数
unsigned char code BeatCode ={ //每个节拍对应I/O口的控制代码
0x0E,0x0C,0x0D,0x09,0x0B,0x03,0x07,0x06
};
beats = (angle/360)*4096; //将角度转化为拍数
while(beats--)
{
tmp = P1; //将P1口数据赋给tmp
tmp = tmp & 0xF0; //清空tmp低四位数据
tmp = tmp | BeatCode[index];
P1 = tmp;
index++; //索引随节拍递增
index = index & 0x07; //索引逢8清零
delay();
}
P1 = P1 | 0x0F; //关闭电机所有相
}
利用中断编写实用性程序
在上述两个程序中，我们都利用了delay()延时函数。例如第二个程序中，大约有200s时间都仅用于延时。在实际的控制系统中，是一定需要避免的。
那么我们可以通过利用中断来使其变成实际控制中可以使用的程序。
#include<reg52.h>
void StartMotor(unsigned long angle);
unsigned long beats = 0;
void main()
{
EA = 1;
ET0 = 1;
TMOD = 0x01;
TH0 = 0xF8;
TL0 = 0x30;
TR0 = 1;
StartMortor(360*25); //旋转25圈
while(1);
}
void StartMortor(unsigned long angle)
{
EA = 0; //关闭中断开关，防止beats运算过程中被打断
beats = (angle/360)*4096;
EA = 1; //重新开启中断
}
void InterruptTimer0() interrupt 1
{
unsigned char tmp;
static unsigned char index = 0;
unsigned char code BeatCode ={ //每个节拍对应I/O口的控制代码
0x0E,0x0C,0x0D,0x09,0x0B,0x03,0x07,0x06
};
TH0 = 0xF8;
TL0 = 0x30;
if(beats != 0)
{
tmp = P1; //将P1口数据赋给tmp
tmp = tmp & 0xF0; //清空tmp低四位数据
tmp = tmp | BeatCode[index];
P1 = tmp;
index++; //索引随节拍递增
index = index & 0x07; //索引逢8清零
beats--;
}
else
{
P1 = P1 | 0x0F; //关闭电机所有相
}
}
说明：
我们所使用的STC89C52 单片机是 8 位单片机，这个 8 位的概念就是说单片机操作数据时都是按 8 位即按1 个字节进行的，那么要操作多个字节（不论是读还是写）就必须分多次进行了。而我们程序中定义的 beats 这个变量是 unsigned long 型，它要占用 4 个字节，那么对它的赋值最少也要分 4 次才能完成了。我们想象一下，假如在完成了其中第一个字节的赋值后，恰好中断发生了，InterruptTimer0 函数得到执行，而这个函数内可能会对 beats 进行减 1 的操作，减法就有可能发生借位，借位就会改变其它的字节，但因为此时其它的字节还没有被赋入新值，于是错误就会发生了，减 1 所得到的结果就不是预期的值了！所以要避免这种错误的发生就得先暂时关闭中断，等赋值完成后再打开中断。而如果我们使用的是 char 或 bit 型变量的话，因为它们都是在 CPU 的一次操作中就完成的，所以即使不关中断，也不会发生错误。
用4*4矩阵按键控制28BYJ-48步进电机
#include<reg52.h>
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 KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
{ 0x31, 0x32, 0x33, 0x26 }, //数字键 1、数字键 2、数字键 3、向上键
{ 0x34, 0x35, 0x36, 0x25 }, //数字键 4、数字键 5、数字键 6、向左键
{ 0x37, 0x38, 0x39, 0x28 }, //数字键 7、数字键 8、数字键 9、向下键
{ 0x30, 0x1B, 0x0D, 0x27 } //数字键 0、ESC 键、 回车键、 向右键
};
unsigned char KeySta[4][4] ={ //记录按键当前状态
{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
};
static long beats = 0;
void StartMortor(signed long angle); //利用angle计算beats节拍数
void EndMortor(); //将beats赋值为0；
void KeyAction(unsigned char keycode); //接收KeyDriver传来的keycode值，将其转化为圈数
void KeyDriver(); //判断哪个按键被按下
void KeyScan(); //按键消抖，控制IO口电平输出
void TurnMortor(); //控制步进电机正转、反转
void main()
{
EA = 1;
ET0 = 1;
TMOD = 0x01;
TH0 = 0xFC;
TL0 = 0x18;
TR = 1;
while(1)
{
KeyDriver(); //调用按键驱动程序
}
}
void StartMortor(signed long angle)
{
EA = 0; //关闭中断开关，防止beats运算过程中被打断
beats = (angle/360)*4096;
EA = 1; //重新开启中断
}
void EndMortor()
{
EA = 0;
beats = 0;
EA = 1;
}
void KeyAction(unsigned char Keycode)
{
static bit DirMortor = 0;
if((Keycode >= 0x31) && (Keycode <= 0x39))
{
if(DirMortor == 0)
{
StartMortor((Keycode-0x30)*360); //将圈数化为角度传入StartMortor函数
}
else
{
StartMortor(-(Keycode-0x30)*360);
}
}
else if(Keycode == 0x26)
{
DirMortor = 0;
}
else if(Keycode == 0x28)
{
DirMortor = 1;
}
else if(Keycode == 0x25)
{
StartMortor(90);
}
else if(Keycode == 0x27)
{
StartMortor(-90);
}
else if(Keycode == 0x1B)
{
EndMortor(); //beats变为0
}
}
void KeyDiver()
{
unsigned char i,j;
static unsigned char backup[4][4] ={
{1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
};
for(i = 0;i < 4;i++)
{
for(j = 0;j < 4;j++)
{
if(Keysta[i][j] != backup[i][j])
{
if(backup[i][j] != 0)
{
KeyAction(KeyCodeMap[i][j]);//判断按下按键，传对应值
}
backup[i][j] = Keysta[i][j];
}
}
}
}
void KeyScan();
{
unsigned char i;
static unsigned char keyout = 0;
static unsigned char Keybuf[4][4] ={
{0xFF,0xFF,0xFF,0xFF},{0xFF,0xFF,0xFF,0xFF},
{0xFF,0xFF,0xFF,0xFF},{0xFF,0xFF,0xFF,0xFF}
};
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;
}
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;
}
}
void TurnMortor();
{
unsigned char tmp;
static signed index = 0;
unsigned char code BeatCode ={ //每个节拍对应I/O口的控制代码
0x0E,0x0C,0x0D,0x09,0x0B,0x03,0x07,0x06
};
if(beats != 0)
{
if(beats > 0)
{
index++;
index = index & 0x07; //满8进为0
beats--;
}
if(beats < 0)
{
index--;
index = index & 0x07; //满-1进为7
beats++;
}
tmp = P1;
tmp = tmp & 0xF0;
tmp = tmp | BeatCode[index];
P1 = tmp;
}
else
{
P1 = P1 | 0x0F;
}
}
void InterruptTimer0() interrupt 1
{
static bit div = 0;
TH0 = 0xFC;
TL0 = 0X18;
KeyScan(); //1ms扫描一次按键
div = ~div;
if(div == 1)
{
TurnMortor(); //2ms执行一次TurnMortor函数
}
}
