基于8051控制步进电机并具有屏幕LCD12864可控菜单选项

已于 2024-01-27 21:47:36 修改
阅读量406 收藏 7
点赞数
文章标签： 51单片机 单片机
于 2022-07-21 22:56:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheTwoDe/article/details/125922342
版权

基于8051系统控制步进电机28BYJ-48,并且通过LCD12864可选菜单选择步进电机运行模式

步进电机控制部分

28BYJ48.C

#include "28BYJ48.H"
#include "LCD12864.H"
unsigned char delay_ms(unsigned int ms, unsigned char Range)
{
    unsigned int i;
    unsigned char j, FSOC;

    for(i = ms; i > 0; i--)
    {
        for(FSOC = 12; FSOC > 0; FSOC--)
        {
            for(j = 96; j > 0; j--)
            {
                switch(Range)
                {
                    case 0: //Just Delay
                    {

                    } break;

                    case 1: //LimitSwitch
                    {
                        if(LimitSwitch == 0)
                        {
                            return 1;
                        }
                    }
                    break;

                    case 2://
                    {
                        if(!Start)
                        {
                            return 2;
                        }

                        if(!Back)
                        {
                            return 3;
                        }
                    }
                    break;
                }
            }
        }
    }

    return 0;
}

void step_motor_28BYJ48_send_pulse(unsigned char Step, bit Dir)
{


    if(Dir == 0) 	//如果为逆时针旋转
    {
        Step = 7 - Step; //调换节拍信号
    }

    switch(Step)//8个节拍控制：A->AB->B->BC->C->CD->D->DA
    {
        case 0:
            IN1_A = 1;
            IN2_B = 0;
            IN3_C = 0;
            IN4_D = 0;
            break;

        case 1:
            IN1_A = 1;
            IN2_B = 1;
            IN3_C = 0;
            IN4_D = 0;
            break;

        case 2:
            IN1_A = 0;
            IN2_B = 1;
            IN3_C = 0;
            IN4_D = 0;
            break;

        case 3:
            IN1_A = 0;
            IN2_B = 1;
            IN3_C = 1;
            IN4_D = 0;
            break;

        case 4:
            IN1_A = 0;
            IN2_B = 0;
            IN3_C = 1;
            IN4_D = 0;
            break;

        case 5:
            IN1_A = 0;
            IN2_B = 0;
            IN3_C = 1;
            IN4_D = 1;
            break;

        case 6:
            IN1_A = 0;
            IN2_B = 0;
            IN3_C = 0;
            IN4_D = 1;
            break;

        case 7:
            IN1_A = 1;
            IN2_B = 0;
            IN3_C = 0;
            IN4_D = 1;
            break;

        default:
            IN1_A = 0;
            IN2_B = 0;
            IN3_C = 0;
            IN4_D = 0;
            break;//停止相序
    }
}
//电机初始化
bit MOTOR28BYJ48Init(bit Dir)
{
    unsigned char step;
    unsigned char step1;

    while(1)
    {
        step_motor_28BYJ48_send_pulse(step++, Dir);

        if(step == 8)
        {
            step = 0;
            step1++;
            //转180度
            if(step1 == 255)
            {
                return 1;
            }
        }

        if(delay_ms(1, 1))
        {
            return 0;
        }
    }
}
28BYJ48.H

#include <STC8.H>
#ifndef __28BYJ48_H__
#define __28BYJ48_H__


//端口定义
sbit LimitSwitch = P4 ^ 3;

sbit IN1_A = P6 ^ 0;
sbit IN2_B = P6 ^ 1;
sbit IN3_C = P6 ^ 2;
sbit IN4_D = P6 ^ 3;
//端口定义

void step_motor_28BYJ48_send_pulse(unsigned char Step, bit Dir);
unsigned char delay_ms(unsigned int ms, unsigned char Range);
bit MOTOR28BYJ48Init(bit Dir);
#endif

 LCD12864实现部分，可以切换为Oled12864以及其他屏幕

LCD12864.C

#include "LCD12864.H"


void DelayLCD()
{
    unsigned char i, j;

    for(i = 0; i < 12; i++)
    {
        for(j = 0; j < 32; j++)
        {

        }
    }
}

//-->整数转换函数
char* itoa(int num, char* str, int radix)
{
    char index[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; //索引表
    char temp;//临时变量，交换两个值时用到
    unsigned unum;//存放要转换的整数的绝对值,转换的整数可能是负数
    int i = 0, j, k; //i用来指示设置字符串相应位，转换之后i其实就是字符串的长度；转换后顺序是逆序的，有正负的情况，k用来指示调整顺序的开始位置;j用来指示调整顺序时的交换。

    //获取要转换的整数的绝对值
    if(radix == 10 && num < 0) //要转换成十进制数并且是负数
    {
        unum = (unsigned) - num; //将num的绝对值赋给unum
        str[i++] = '-'; //在字符串最前面设置为'-'号，并且索引加1
    }
    else unum = (unsigned)num; //若是num为正，直接赋值给unum

    //转换部分，注意转换后是逆序的
    do
    {
        str[i++] = index[unum % (unsigned)radix]; //取unum的最后一位，并设置为str对应位，指示索引加1
        unum /= radix; //unum去掉最后一位

    }
    while(unum); //直至unum为0退出循环

    str[i] = '\0'; //在字符串最后添加'\0'字符，c语言字符串以'\0'结束。

    //将顺序调整过来
    if(str[0] == '-') k = 1; //如果是负数，符号不用调整，从符号后面开始调整
    else k = 0; //不是负数，全部都要调整

    for(j = k; j <= (i - 1) / 2; j++) //头尾一一对称交换，i其实就是字符串的长度，索引最大值比长度少1
    {
        temp = str[j]; //头部赋值给临时变量
        str[j] = str[i - 1 + k - j]; //尾部赋值给头部
        str[i - 1 + k - j] = temp; //将临时变量的值(其实就是之前的头部值)赋给尾部
    }

    return str;//返回转换后的字符串
}
//-->读忙函数
void CheckBusy(void)
{
    RS = 0;
    RW = 1;
    EN = 1;

    while((DataPort & 0x80) == 0x80);

    EN = 0;
}
//-->写指令
void WriteCmd(unsigned char CmdCode)
{
    CheckBusy();
    RS = 0;
    RW = 0;
    EN = 1;
    DataPort = CmdCode;
    DelayLCD();
    EN = 0;
}
//-->写数据
void WriteData(unsigned char DataCode)
{
    CheckBusy();
    RS = 1;
    RW = 0;
    EN = 1;
    DataPort = DataCode;
    DelayLCD();
    EN = 0;
}
//-->LCD12864初始化
void InitLCD(void)
{
    RSB = 1;
    RST = 0;
    DelayLCD();
    RST = 1;
    WriteCmd(0x30);

    WriteCmd(0x30);

    WriteCmd(0x0c);

    WriteCmd(0x02);

    WriteCmd(0x01);

    BLA = 0;

    LCD_String(0, 0, "显示器显示无误!!");
    LCD_String(0, 1, "显示器显示无误!!");
    LCD_String(0, 2, "显示器显示无误!!");
    LCD_String(0, 3, "显示器显示无误!!");
}

//-->发送字符串
void LCD_String(unsigned char x, unsigned char y, unsigned char  *Str)
{
    switch(y)
    {
        case 0:
            WriteCmd(0x80 + x);
            break;

        case 1:
            WriteCmd(0x90 + x);
            break;

        case 2:
            WriteCmd(0x88 + x);
            break;

        case 3:
            WriteCmd(0x98 + x);
            break;

        default:
            break;
    }

    while(*Str > 0)
    {
        WriteData(*Str);
        DelayLCD();
        Str++;
    }
}

LCD12864.H

#include <STC8.H>

#ifndef __LCD12864_H__
#define __LCD12864_H__

//端口定义
#define DataPort P7
sbit RS = P1 ^ 1;
sbit RW = P1 ^ 2;
sbit EN = P1 ^ 3;
sbit RSB = P4 ^ 4;
sbit NC  = P1 ^ 5;
sbit RST = P1 ^ 0;
sbit BLA = P1 ^ 4;

sbit LED1 = P5 ^ 5;
sbit LED2 = P4 ^ 1;
sbit BUZZ = P2 ^ 1;
sbit Start = P6 ^ 7;
sbit Back  = P6 ^ 6;
sbit Up    = P6 ^ 5;
sbit Down  = P6 ^ 4;
sbit Sure  = P4 ^ 3;
//端口定义

/********************
******函数定义******/
//-->整数转换函数
char* itoa(int num, char* str, int radix);
//-->读忙函数
void CheckBusy(void);
//-->写指令
void WriteCmd(unsigned char CmdCode);
//-->写数据
void WriteData(unsigned char DataCode);
//-->LCD12864初始化
void InitLCD(void);
//-->发送字符串
void LCD_String(unsigned char x, unsigned char y, unsigned char *s);
//-->用于稳定时序的延时
void DelayLCD();
/********************
******函数定义******/

#endif

主函数部分

#include <STC8.H>

#include "28BYJ48.H"
#include "LCD12864.H"

bit StartFlag = 0;

bit Laout2Flag = 0;

//储存模式
bit Laout3FlagA;
bit Laout3FlagB;
bit Laout3FlagC;
//储存角度
bit Laout4FlagA;
bit Laout4FlagB;
bit Laout4FlagC;
//储存速度
bit Laout5FlagA;
bit Laout5FlagB;
bit Laout5FlagC;

void UI(unsigned char Layout, unsigned char Mode)
{


    switch(Layout)
    {
        //开机界面
        case 0:
        {
            WriteCmd(0x01);
            LCD_String(0, 0, "->初始化未完成<0");
            LCD_String(0, 1, "显示器显示无误!!");
            LCD_String(0, 2, "限位开关检测异常");
            LCD_String(0, 3, "当前状态循环自检");
        }
        break;

        //自检完成待机界面
        case 1:
        {
            WriteCmd(0x01);
            LCD_String(0, 0, "->初始化已完成<1");
            LCD_String(0, 1, "长按启动按钮开启");
            LCD_String(0, 2, "限位开关检测无误");
            LCD_String(0, 3, "自检完毕等侯操作");

        }
        break;

        //选择模式开启电机
        case 2:
        {
            if(!Laout2Flag)
            {
                WriteCmd(0x01);
                WriteCmd(0x01);
                LCD_String(0, 0, "->选择模式开机<2");
                LCD_String(0, 1, "A>顺时针转动");
                LCD_String(0, 2, "B>逆时针转动");
                LCD_String(0, 3, "C>循环转动");
                Laout2Flag = 1;
            }

            switch(Mode)
            {
                case 0:
                {
                    LCD_String(0, 1, "+>顺时针转动");
                    LCD_String(0, 2, "B>");
                    LCD_String(0, 3, "C>");
                }
                break;

                case 1:
                {
                    LCD_String(0, 1, "A>");
                    LCD_String(0, 2, "+>逆时针转动");
                    LCD_String(0, 3, "C>");
                }
                break;

                case 2:
                {
                    LCD_String(0, 1, "A>");
                    LCD_String(0, 2, "B>");
                    LCD_String(0, 3, "+>循环转动");
                }
                break;
            }
        }
        break;

        //选择模式开启电机
        case 3:
        {
            if(!Laout2Flag)
            {
                WriteCmd(0x01);
                WriteCmd(0x01);
                LCD_String(0, 0, "->选择转动模式<3");
                LCD_String(0, 1, "->转动45度");
                LCD_String(0, 2, "->转动90度");
                LCD_String(0, 3, "->按下启动转动");
                Laout2Flag = 1;
            }

            switch(Mode)
            {
                case 0:
                {
                    LCD_String(0, 1, "+>");
                    LCD_String(0, 2, "->");
                    LCD_String(0, 3, "->");
                }
                break;

                case 1:
                {
                    LCD_String(0, 1, "->");
                    LCD_String(0, 2, "+>");
                    LCD_String(0, 3, "->");
                }
                break;

                case 2:
                {
                    LCD_String(0, 1, "->");
                    LCD_String(0, 2, "->");
                    LCD_String(0, 3, "+>");
                }
                break;
            }

        }
        break;

        //选择转速
        case 4:
        {
            if(!Laout2Flag)
            {
                WriteCmd(0x01);
                WriteCmd(0x01);
                LCD_String(0, 0, "->选择转动速度<4");
                LCD_String(0, 1, "->低速");
                LCD_String(0, 2, "->中速");
                LCD_String(0, 3, "->高速");
                Laout2Flag = 1;
            }

            switch(Mode)
            {
                case 0:
                {
                    LCD_String(0, 1, "+>");
                    LCD_String(0, 2, "->");
                    LCD_String(0, 3, "->");
                }
                break;

                case 1:
                {
                    LCD_String(0, 1, "->");
                    LCD_String(0, 2, "+>");
                    LCD_String(0, 3, "->");
                }
                break;

                case 2:
                {
                    LCD_String(0, 1, "->");
                    LCD_String(0, 2, "->");
                    LCD_String(0, 3, "+>");
                }
                break;
            }
        }
        break;

        case 5:
        {
            if(!Laout2Flag)
            {
                WriteCmd(0x01);
                WriteCmd(0x01);
                LCD_String(0, 0, "->按下启动开始<5");
                LCD_String(0, 1, "模式:");

                LCD_String(0, 2, "速度:");

                LCD_String(0, 3, "状态:");

                Laout2Flag = 1;
            }

            if(Laout3FlagA)
            {
                LCD_String(3, 1, "顺时");
            }

            if(Laout3FlagB)
            {
                LCD_String(3, 1, "逆时");
            }

            if(Laout3FlagC)
            {
                LCD_String(3, 1, "循环");
            }

            if(Laout4FlagA)
            {
                LCD_String(5, 1, "45度");
            }

            if(Laout4FlagB)
            {
                LCD_String(5, 1, "90度");
            }

            if(Laout4FlagC)
            {
                LCD_String(5, 1, "按键");
            }

            if(Laout5FlagA)
            {
                LCD_String(3, 2, "低速");
            }

            if(Laout5FlagB)
            {
                LCD_String(3, 2, "中速");
            }

            if(Laout5FlagC)
            {
                LCD_String(3, 2, "高速");
            }

            if(StartFlag)
            {
                LCD_String(3, 3, "开启");
            }
            else
            {
                LCD_String(3, 3, "关闭");
            }

        }
        break;
    }
}



void  main(void)
{

    unsigned char ModeFlag;
    unsigned char Mode, Angle, Speed;
    unsigned char Buff1, Buff2, Buff3;

    RSTCFG = 0X10;
    P1M0 = 0X1F;
    P1M1 = 0X00;
    P7M0 = 0XFF;
    P7M1 = 0XFF;

    InitLCD();

    //显示开机界面
    UI(0, ModeFlag);

    //等待限位开关
    //while(LimitSwitch);
    while(MOTOR28BYJ48Init(LED2))
    {
        LED2 = !LED2;
    }

    //显示自检完成待机界面
    UI(1, ModeFlag);

    //等待按下启动按钮
    while(Start);


Layout2:
    {
//*****************************************
//    Layout = 2；
        Laout2Flag = 0;
        //显示2菜单
        UI(2, ModeFlag);

        //等待确认
        ModeFlag = 0;


        while(Sure)
        {


            if(Up == 0)
            {
                while(!Up);

                ModeFlag++;
            }

            if(Down == 0)
            {
                while(!Down);

                ModeFlag--;
            }

            if(ModeFlag == 3)
            {
                ModeFlag = 0;
            }

            if(ModeFlag == 255)
            {
                ModeFlag = 2;
            }

            UI(2, ModeFlag);
        }

        //存储转动模式
        switch(ModeFlag)
        {
            case 0:
            {
                Laout3FlagA = 1;
                Laout3FlagB = 0;
                Laout3FlagC = 0;
            }
            break;

            case 1:
            {
                Laout3FlagA = 0;
                Laout3FlagB = 1;
                Laout3FlagC = 0;
            }
            break;

            case 2:
            {
                Laout3FlagA = 0;
                Laout3FlagB = 0;
                Laout3FlagC = 1;
            }
            break;
        }

    }
Layout3:
    {
//*****************************************
//    Layout = 3;
        Laout2Flag = 0;
        //等待确认
        ModeFlag = 0;

        UI(3, ModeFlag);

        while(!Sure);

        while(Sure)
        {
            if(Up == 0)
            {
                while(!Up);

                ModeFlag++;
            }

            if(Down == 0)
            {
                while(!Down);

                ModeFlag--;
            }

            if(Back == 0)
            {
                while(!Back);

                goto Layout2;
            }

            if(ModeFlag == 3)
            {
                ModeFlag = 0;
            }

            if(ModeFlag == 255)
            {
                ModeFlag = 2;
            }

            UI(3, ModeFlag);
        }

        //储存角度
        switch(ModeFlag)
        {
            case 0:
            {
                Laout4FlagA = 1;
                Laout4FlagB = 0;
                Laout4FlagC = 0;
            }
            break;

            case 1:
            {
                Laout4FlagA = 0;
                Laout4FlagB = 1;
                Laout4FlagC = 0;
            }
            break;

            case 2:
            {
                Laout4FlagA = 0;
                Laout4FlagB = 0;
                Laout4FlagC = 1;
            }
            break;
        }
    }
Layout4:
    {
//*****************************************
//    Layout = 4;
        Laout2Flag = 0;
        //等待确认
        ModeFlag = 0;

        UI(4, ModeFlag);

        while(!Sure);

        while(Sure)
        {
            if(Up == 0)
            {
                while(!Up);

                ModeFlag++;
            }

            if(Down == 0)
            {
                while(!Down);

                ModeFlag--;
            }

            if(Back == 0)
            {
                while(!Back);

                goto Layout3;
            }

            if(ModeFlag == 3)
            {
                ModeFlag = 0;
            }

            if(ModeFlag == 255)
            {
                ModeFlag = 2;
            }

            UI(4, ModeFlag);
        }

        //储存角度
        switch(ModeFlag)
        {
            case 0:
            {
                Laout5FlagA = 1;
                Laout5FlagB = 0;
                Laout5FlagC = 0;
            }
            break;

            case 1:
            {
                Laout5FlagA = 0;
                Laout5FlagB = 1;
                Laout5FlagC = 0;
            }
            break;

            case 2:
            {
                Laout5FlagA = 0;
                Laout5FlagB = 0;
                Laout5FlagC = 1;
            }
            break;
        }

    }
Layout5:
    {
//*****************************************
//    Layout = 5;
        Laout2Flag = 0;
        StartFlag = 0;
        //等待确认
        ModeFlag = 0;


        UI(5, ModeFlag);


        while(Start)
        {

            if(Back == 0)
            {
                while(!Back);

                goto Layout4;
            }
        }

        while(!Start);

        StartFlag = 1;

        UI(5, ModeFlag);
    }

//*****************************************

    while(1)
    {
        if(!Back)
        {
            while(!Back);

            goto Layout5;
        }

        if(!Start)
        {
            while(!Start);

            goto Layout5;
        }

Motor:



        Mode = Angle = Speed = 0;
        {
            if(Laout3FlagA)
                Mode = 1;

            if(Laout3FlagB)
                Mode = 2;

            if(Laout3FlagC)
                Mode = 3;

            //
            if(Laout4FlagA)
                Angle = 64;

            if(Laout4FlagB)
                Angle = 128;

            if(Laout4FlagC)
                Angle = 255;

            //
            if(Laout5FlagA)
                Speed  = 15;

            if(Laout5FlagB)
                Speed  = 10;

            if(Laout5FlagC)
                Speed  = 1;

            while(Start || Back)
            {
                if(!Back)
                {
                    while(!Back);

                    goto Layout4;
                }

                //step_motor_28BYJ48_send_pulse(Buff1++, Buff2 );

                if(Mode == 1)
                {
                    Buff2 = 0;
                }

                if(Mode == 2)
                {
                    Buff2 = 1;
                }

                if(Mode == 3)
                {
                    if(Buff1 == Angle)
                    {
                        Buff2 = !Buff2;
                        Buff1 = 0;
                    }
                }

                if(Angle == Buff1)
                {
                    Buff1 = 0;
                    goto Layout5;
                }

                if(Angle == 255)
                {
                    while(Sure)
                    {
                        if(!Start)
                        {
                            while(!Start);

                            break;
                        }

                        if(!Back)
                        {
                            while(!Back);

                            goto Layout4;
                        }
                    }
                }

                if(Buff3 == 8)
                {
                    Buff3 = 0;
                    Buff1++;
                }

                step_motor_28BYJ48_send_pulse(Buff3++, Buff2 );

                if(delay_ms(Speed, 2) == 2)
                {
                    while(!Start);

                    while(!Back);

                    goto Layout5;
                }

//                switch(delay_ms(Speed, 2)){
//                    case 2:
//                    {
//                        while(!Start);
//                        goto Motor;
//                    }break;
//                    case 3:
//                    {
//                        while(!Back);
//                        goto Layout5;
//                    }break;
//                }
            }
        }

    }
}

使用说明：

该代码为屎山代码，不保证移植能用，主函数与28BYJ48.C关联密切，其中按键未使用中断也能够快速跳出死循环代码段，具体实现详情看代码。

双层芝士多汁牛排堡
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LCD12864 菜单部分编写
jeek_we的博客
03-20 4995
需要创建一个菜单的结构体，以便建立链表 typedef struct menu { //定义一个菜单 uint8_t range_from,range_to; //当前显示的项开始及结束序号 uint8_t itemCount;//项目总数 uint8_t selected;//当前选择项 char menuItems[SUBMENUS][17];//菜单项...
基于单片机的步进电机角度控制_单片机_步进电机_角度控制_
10-03
本项目“基于单片机的步进电机角度控制”旨在利用单片机精确地驱动步进电机，以实现对电机转动角度的精细化控制。 步进电机是一种将电脉冲信号转化为角位移的执行元件，它的转动角度与输入脉冲的数量成正比。在本...
步进电机控制系统+LCD状态显示+详细源码注释+proteus仿真（超详细）
留缘的博客
06-05 1万+
功能 实现的功能如下： 1）实现电机正转和反转； 2）实现一定范围内的电机转速变化； 3）通过2x4键盘控制电机的启动、停止、正反转、加减速、时间的修改和转速设置的清零，并配合LCD屏幕显示系统运行状态； 4）显示电机运行当前状态，包括（启动、停止、正转、反转、加速、减速、修改小时、修改分钟等）； 5）LCD显示北京时间，可调整小时和分钟（秒钟不可修改），可以加可以减； 6）配有电机运行指示灯，电机运转时，指示灯亮起，电机停止时，指示灯灭掉，用来指示电机是否运行； 7）配有复位按键，运行出错
Proteus8.6版本+ STM32F103驱动LCD12864显示程序+按键+ADC
wqndxjr的博客
06-01 8095
# Proteus8.6版本+ STM32F103驱动LCD12864显示程序+按键+ADC ## 一、开发环境介绍 STM32F103仿真驱动点亮LCD12864 proteus 8.6 版本+ STM32f103 程序基于keil集成开发环境编写 ## 二、项目功能介绍 该项目程序中实现了 1、程序实现了LCD12864的点亮显示 2、程序中实现了STM32的AD采样 3、程序中实现运算放大等电路 4、程序中实现了按键控制操作 通过滑动变阻器加放大器实时改变输入值。后边加上lcd128.
基于80C51汇编/C语言的步进电机驱动程序
fmy_xfk的博客
09-10 2452
单片机实习：用汇编或C语言在80C51单片机上编写步进电机驱动程序。
一、LCD12864(带字库的)使用教程:
热门推荐
private_void_main的博客
05-03 9万+
一、LCD12864简介 LCD12864液晶显示，也就是屏幕上总共有128*64 ，个点，每个点就只有两种状态亮和不亮 我这里使用的就是带字库的，直接可以显示中文，不需要自己去编码，发送数据使用8位并行模式。 我这里不介绍怎么显示图片,不介绍指令,知识快速入门得到显示结果 二、引脚介绍 1.一共有20个引脚，重要的只有那么几个 3~VO就是调节对比度的，相当于调节每个点显示...
Proteus仿真stc89c51正反调速控制uln2003步进电机lcd12864显示状态
最新发布
01-15
功能说明： 1.使用Proteus8.10仿真stc89c51正反调速控制uln2003步进电机。 2.运行参数显示屏LCD12864显示。...按键控制步进电机正反转并可调速 说明帖子：https://editor.csdn.net/md/?articleId=124651871
基于STM32步进电机多细分控制的设计
01-20
本文主要介绍了一种基于STM32的混合式步进电机控制方案，STM32产生PWM（脉宽调制信号），利用PWM完成DAC转换，通过PWMDAC的输出电压实现对步进电机的多细分控制。该设计相比利用DAC数模转换芯片的设计方案具有电路...
西门子1200脉冲控制步进电机实例，4个步进马达
07-19
2. **脉冲控制步进电机**：步进电机是一种精确的位置控制电机，通过发送脉冲信号来控制电机的旋转角度。在PLC中，可以通过定时器和计数器来生成脉冲序列，实现对步进电机的精确步进控制。每个脉冲使电机转过固定的...
基于单片机的步进电机转速控制.doc
12-03
基于单片机的步进电机转速控制 本设计基于单片机控制的步进电机设计课题，旨在实现电机的启停、正反转和调速的目的。该设计涵盖了步进电机的基本原理、单片机控制原理、步进电机驱动器的设计、步进电机的调速控制...
LCD12864多级菜单
03-04
用51单片机写的LCD12864串口多级菜单程序。
基于单片机和LCD12864的简易计算器
02-18
本设计以单片机为核心，用LCD12864显示编写而成的简易计算器，能实现10以内的加减乘除，硬件电路采用Protues搭建，程序采用Keil编写，用两者的连调实现计算器的效果。
12864实现菜单( 可以实现多级菜单，容易学习)
08-29
自己写的，送给需要的懂的人。 资源共享，减少重复劳动！！！ 12864 实现菜单在，单片机控制中作为人机交换中起了很大的作用，就像叫一个人用高科技的设备，但是复杂，但是做成菜单一样玩起来和手机没什么区别简单。很好用希望同志 笑纳咯 要看效果可以到我的博客看看： ///http://blog.csdn.net/zxianyong/archive/2009/08/05/4413967.aspx
stm32单片机lcd12864并行程序
07-27
本例基于stm32单片机的lcd12864液晶的并行显示程序。测试稳定。
LCD12864_GUI.C
01-28
LCD12864_GUI.C LCD12864_GUI.C
51单片机导航旋钮控制Lcd12864
qq_45827426的博客
07-19 1493
参考电路 效果 没有字库，代码太长就不贴出来了，写的也不是很好，想要的私信我就好了
LCD12864的上下翻页
sjh2100的博客
11-17 1364
上下翻页的思路最后是这个样子的。 高亮某行用一个变量处理，例如i=0，取值范围为0-3，根据上下按键循环处理。记录前一个高亮位置，取消该行高亮，然后对新行高亮。 翻页则对于（关键行 and up_press ）or（关键行 and down_press ）进行判断并调整显示内容。 这个显示内容通常是4行汉字。 //调整序号已经调整完 //由调整后的序号配合按键，决定选择内容首尾序号 if(Index_Change_UP_DOWM==0)//up键盘按下 { if(MenuItemIndex=
STC 单片机行列式按键测试 LCD12864输出显示
czhaii的专栏
02-14 837
/*控制器测试程序IAP15W4K61S4板2017 1 9***/ /*按键测试按键2017 1 10 12864串口 *******/ #include <STC15F2K60S2.h> #include "intrins.h" #define uint unsigned int ...
基于ZigBee的城市照明监控系统网关节点的软硬件设计
12-31 652
　　路灯和景观灯是城市夜晚一道亮丽的风景线，也是城市中必需的公用照明设施。城市照明监控系统是一种监测与控制的集成系统。一套高效的城市照明监控系统可以节省大量的人力物力。但目前，我国城市照明监控技术还比较落后，存在很多问题。主要表现在目前的城市照明灯光大多采用分散手控和时控的方式，即在路灯配电箱...
基于单片机的步进电机加减速的控制方法.ppt
11-16
本研究针对步进电机的启动停止控制进行了深入研究，并提出了一种基于单片机控制的步进电机加减速离散控制方法。经过多次运行验证，该方法达到了预期的控制效果。 在步进电机的运行过程中，通常需要经历加速、匀速...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值