步进电机驱动之面向对象实现（支持多平台）

已于 2022-12-08 15:30:40 修改
阅读量758 收藏 4
点赞数 1
分类专栏： C语言 ESP32学习笔记 单片机 文章标签： 单片机 嵌入式硬件
于 2022-12-08 15:12:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43940227/article/details/128236884
版权

步进电机驱动

1.前言

以前写过的步进电机驱动，都是针对一个步进电机做的驱动，当到了需要两个、三个步进电机的场景。复制粘贴出几个，再修改函数名来实现。经常容易出错不说，也显得很不优雅。针对这个痛点，我决定重新编译一份通用性强，跨平台的步进电机驱动。针对跨平台、拓展需求，本次驱动设计基于面向对象思维实现。

2.驱动支持说明

驱动支持三种工作模式，模式0：支持正传、反转、停止；模式1：增量控制旋转角度，控制；模式2，指定角度运行。

3.驱动

用户需要根据平台实现引用可用的uint8_t、int16_t、int32_t、uint32_t头文件或者自行实现。

3.1数据类型引用说明

3.2数据类型实现说明

 #define uint8_t       unsigned char
 #define uint16_t      unsigned short
 #define int16_t       short
 #define int32_t       int
 #define uint32_t      unsigned int

3.3c文件

StepMotorObject_typ_t obj_StepMotor1 = {0};

int StepMotor_init(StepMotorObject_typ_t *obj, StepMotorPinSetType *PinHandle, uint8_t inverter, uint8_t mode)
{
    if (obj == NULL)
    {
        return -1;
    }
    obj->status = 1;
    obj->ctr_level_out_high = 1;
    obj->ctr_level_out_low = 0;
    obj->inverter = inverter;
    obj->mode = mode; //工作模式
    obj->index = 0;
    obj->set_angle = 0; //角度设定
    obj->angle_cnt = 0;
    obj->run_angle_record = 0;
    // -------------------------------
    obj->set_fixed_angle = 0;
    obj->fixed_angle_cnt = 0;
    obj->directing_control = 0;

    if (obj->inverter > 0)
    { //输出反向
        obj->ctr_level_out_high = 0;
        obj->ctr_level_out_low = 1;
    }
    obj->PinHandle = PinHandle;
    return 0;
}

static int32_t angleToBeat(int16_t angle)
{ //转换出角度值
    int32_t beat = 0;
    beat = ((angle * 4096) / 360);
    return beat;
}

void ctr_beat_out(StepMotorObject_typ_t *obj, uint8_t index)
{
    uint8_t out_index = 0;

    if (obj == NULL)
    {
        return;
    }

    if (obj->status != 1)
    { //未初始化
        return;
    }

    // obj->PinHandle[StepMotor_A1](1);
    // obj->PinHandle[StepMotor_A2](1);
    // obj->PinHandle[StepMotor_B1](1);
    // obj->PinHandle[StepMotor_B2](1);

    // obj->PinHandle[StepMotor_A1](0);
    // obj->PinHandle[StepMotor_A2](0);
    // obj->PinHandle[StepMotor_B1](0);
    // obj->PinHandle[StepMotor_B2](0);

    out_index = index;
    switch (out_index)
    {
    case 0:
        //---------------      1      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_high);
        break;
    case 1:
        //---------------      2      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_high);
        break;
    case 2:
        //---------------      3      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_high);
        break;
    case 3:
        //---------------      4      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_high);
        break;
    case 4:
        //---------------      5      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_high);
        break;
    case 5:
        //---------------      6      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_low);
        break;
    case 6:
        //---------------      7      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_low);
        break;
    case 7:
        //---------------      8      ----------------------------
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_low);
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_low);
        break;
    default:
        obj->PinHandle[StepMotor_A1](obj->ctr_level_out_high); //关闭输出
        obj->PinHandle[StepMotor_A2](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B1](obj->ctr_level_out_high);
        obj->PinHandle[StepMotor_B2](obj->ctr_level_out_high);
        break;
    }
}
void ctr_beat_out_off(StepMotorObject_typ_t *obj)
{
    if (obj == NULL)
    {
        return;
    }
    if (obj->status != 1)
    { //未初始化
        return;
    }

    obj->PinHandle[StepMotor_A1](obj->ctr_level_out_high); //关闭输出

    obj->PinHandle[StepMotor_A2](obj->ctr_level_out_high);
    obj->PinHandle[StepMotor_B1](obj->ctr_level_out_high);
    obj->PinHandle[StepMotor_B2](obj->ctr_level_out_high);

    //  obj->PinHandle[0](0);
}

void StepMotor_cycle_handle(StepMotorObject_typ_t *obj)
{
    if (obj == NULL)
    {
        return;
    }
    if (obj->status != 1)
    { //未初始化
        return;
    }
    if (obj->mode == 1)
    { //角度控制

        obj->angle_cnt += angleToBeat(obj->set_angle); // 需要增加限幅
        obj->set_angle = 0;                            //清0

        if (obj->run_angle_record < obj->angle_cnt) //正传
        {
            if (obj->run_angle_record < 2147483647)
            {
                obj->run_angle_record++;
            }
            if (++obj->index > 7)
                obj->index = 0;
        }
        else if (obj->run_angle_record > obj->angle_cnt) //反转
        {
            if (obj->run_angle_record > -2147483648)
            {
                obj->run_angle_record--;
            }

            if (obj->index != 0)
            {
                obj->index--;
            }
            else
            {
                obj->index = 7;
            }
        }
        else
        {
            ctr_beat_out_off(obj);
            return;
        }
        ctr_beat_out(obj, obj->index);
    }
    else if (obj->mode == 2)
    {                                                             //指定角度运行
        obj->fixed_angle_cnt = angleToBeat(obj->set_fixed_angle); // 固定角度
        if (obj->run_angle_record < obj->fixed_angle_cnt)         //正传
        {
            if (obj->run_angle_record < 2147483647)
            {
                obj->run_angle_record++;
            }
            if (++obj->index > 7)
            {
                obj->index = 0;
            }

            ctr_beat_out(obj, obj->index);
        }
        else if (obj->run_angle_record > obj->fixed_angle_cnt) //反转
        {
            if (obj->run_angle_record > -2147483648)
            {
                obj->run_angle_record--;
            }
            ctr_beat_out(obj, obj->index);
        }
        else
        {
            ctr_beat_out_off(obj);
        }
    }
    else
    {
        if (obj->directing_control == -1)
        {
            if (++obj->index > 7)
                obj->index = 0;
            ctr_beat_out(obj, obj->index);
        }
        else if (obj->directing_control == 1)
        {
            if (obj->index != 0)
            {
                obj->index--;
            }
            else
            {
                obj->index = 7;
            }
            ctr_beat_out(obj, obj->index);
        }
        else
        {
            ctr_beat_out_off(obj);
            return;
        }
    }
}

int StepMotorSetMode(StepMotorObject_typ_t *obj, uint8_t mode)
{
    if (obj == NULL)
    {
        return -1;
    }
    if (obj->status != 1)
    { //未初始化
        return -2;
    }
    obj->mode = mode; //工作模式
    return 0;
}

int StepMotorSetForwardAngle(StepMotorObject_typ_t *obj, int16_t set_angle)
{
    if (obj == NULL)
    {
        return -1;
    }
    if (obj->status != 1)
    { //未初始化
        return -2;
    }
    if (obj->mode != 1)
    {
        return -3;
    }
    if (set_angle < 0)
    {
        return -3;
    }
    obj->set_angle = set_angle;

    return 0;
}

int StepMotorSetReversalAngle(StepMotorObject_typ_t *obj, int16_t set_angle)
{
    if (obj == NULL)
    {
        return -1;
    }
    if (obj->status != 1)
    { //未初始化
        return -2;
    }
    if (obj->mode != 1)
    {
        return -3;
    }
    if (set_angle < 0)
    {
        return -3;
    }
    obj->set_angle = 0 - set_angle;

    return 0;
}

int StepMotorSetFixedAngle(StepMotorObject_typ_t *obj, int16_t set_fixed_angle)
{
    if (obj == NULL)
    {
        return -1;
    }
    if (obj->status != 1)
    { //未初始化
        return -2;
    }
    if (obj->mode != 2)
    {
        return -3;
    }

    obj->set_fixed_angle = set_fixed_angle;
    return 0;
}

int StepMotorSetForward(StepMotorObject_typ_t *obj)
{
    if (obj == NULL)
    {
        return -1;
    }
    if (obj->status != 1)
    { //未初始化
        return -2;
    }
    if (obj->mode != 0)
    {
        return -3;
    }
    obj->directing_control = 1;
    return 0;
}
int StepMotorSetReversal(StepMotorObject_typ_t *obj)
{
    if (obj == NULL)
    {
        return -1;
    }
    if (obj->status != 1)
    { //未初始化
        return -2;
    }
    if (obj->mode != 0)
    {
        return -3;
    }
    obj->directing_control = -1;
    return 0;
}
int StepMotorSetStop(StepMotorObject_typ_t *obj)
{
    if (obj == NULL)
    {
        return -1;
    }
    if (obj->status != 1)
    { //未初始化
        return -2;
    }
    if (obj->mode != 0)
    {
        return -3;
    }
    obj->directing_control = 0;
    return 0;
}

3.4h文件


/*定义步进电机控制引脚枚举*/
typedef enum StepMotorPin{
  StepMotor_A1=0,
  StepMotor_A2=1,
  StepMotor_B1=2,
  StepMotor_B2=3
}StepMotorPinType;
/*定义引脚操作函数指针类型*/
typedef void (* StepMotorPinSetType)(uint8_t value);

/* 定义步进电机的对象类型 */
typedef struct StepMotorObject {
   uint8_t status;

   uint8_t  ctr_level_out_high; //输出相位1
   uint8_t  ctr_level_out_low;  //输出相位0
   uint8_t  inverter; //输入输出是否为反相器 1反向  0 正常 
   uint8_t  mode;  //工作模式
   uint8_t  index; // 步进

   int16_t  set_angle;  //角度设定
   int32_t  angle_cnt;    
   int32_t  run_angle_record;
   // -------------------------------
    int16_t  set_fixed_angle;
    int32_t  fixed_angle_cnt;   
   // -------------------------------
    int8_t directing_control;
    StepMotorPinSetType *PinHandle;
}StepMotorObject_typ_t;

extern StepMotorObject_typ_t   obj_StepMotor1;

int StepMotor_init(StepMotorObject_typ_t *obj, StepMotorPinSetType *PinHandle, uint8_t inverter, uint8_t mode);
 void ctr_beat_out(StepMotorObject_typ_t *obj, uint8_t index);
void ctr_beat_out_off(StepMotorObject_typ_t *obj);
void StepMotor_cycle_handle(StepMotorObject_typ_t *obj);

int StepMotorSetMode(StepMotorObject_typ_t *obj , uint8_t mode);

int StepMotorSetForwardAngle(StepMotorObject_typ_t *obj, int16_t set_angle);
int StepMotorSetReversalAngle(StepMotorObject_typ_t *obj, int16_t set_angle);

int StepMotorSetFixedAngle(StepMotorObject_typ_t *obj, int16_t set_fixed_angle); 

int StepMotorSetForward(StepMotorObject_typ_t *obj);
int StepMotorSetReversal(StepMotorObject_typ_t *obj);

4使用示例

4.1接口实现

接口部分根据不同平台进项修改，这里以ESP32为例

void StepMotor1_Pin_init(void)
{
    gpio_reset_pin(19);
    /* Set the GPIO as a push/pull output */
    gpio_set_direction(19, GPIO_MODE_OUTPUT);

    gpio_reset_pin(5);
    /* Set the GPIO as a push/pull output */
    gpio_set_direction(5, GPIO_MODE_OUTPUT);

    gpio_reset_pin(25);
    /* Set the GPIO as a push/pull output */
    gpio_set_direction(25, GPIO_MODE_OUTPUT);
    gpio_reset_pin(15);
    /* Set the GPIO as a push/pull output */
    gpio_set_direction(15, GPIO_MODE_OUTPUT);
}
static void StepMotor1_A1(uint8_t value)
{
    if (value)
    {
        gpio_set_level(19, 1);
    }
    else
    {
         gpio_set_level(19, 0);
    }
}
static void StepMotor1_A2(uint8_t value)
{
    if (value)
    {
       gpio_set_level(5, 1);
    }
    else
    {
       gpio_set_level(5, 0);
    }
}
static void StepMotor1_B2(uint8_t value)
{
    if (value)
    {
        gpio_set_level(25, 1);
    }
    else
    {
       gpio_set_level(25, 0);
    }
}
static void StepMotor1_B1(uint8_t value)
{
    if (value)
    {
        gpio_set_level(15, 1);
    }
    else
    {
       gpio_set_level(15, 0);
    }
}
 static StepMotorPinSetType setmotor_PIN[4] = {StepMotor1_A1, StepMotor1_A2, StepMotor1_B1, StepMotor1_B2};

4.2定时器刷新接口

static bool timer_callback(void *args){  
    uint64_t val;
     static uint8_t index = 0;
    BaseType_t pxHigherPriorityTaskWoken = pdFALSE;
    val = timer_group_get_counter_value_in_isr(0, 0);
      StepMotor_cycle_handle(&obj_StepMotor1);  //定时刷新步进电机节拍
    return pxHigherPriorityTaskWoken;
}

4.3初始化于使用

void app_main(void)
{
    timer_config_t config = {
        .alarm_en = 1,
        .counter_en = 0,
        .counter_dir = TIMER_COUNT_UP,
        .auto_reload = 1,
        .divider = 16,
    };
    timer_init(0, 0, &config);
    timer_set_counter_value(0, 0, 0x00ull);
    // timer_set_alarm_value(0, 0, TIMER_FREQ * 3);
   // timer_set_alarm_value(0, 0, 12500); //200HZ
//    timer_set_alarm_value(0, 0, 5000); //500HZ
//   timer_set_alarm_value(0, 0, 25000); //100HZ
 //   timer_set_alarm_value(0, 0, 50000); //50HZ
  timer_set_alarm_value(0, 0, 4800); //
  timer_enable_intr(0, 0);
    timer_isr_callback_add(0, 0, timer_callback, NULL, ESP_INTR_FLAG_IRAM);
     /*启动定时器*/
	timer_start(TIMER_GROUP_0,TIMER_0); //开始计数
    StepMotor1_Pin_init();                               //步进电机初始化端口
    StepMotor_init(&obj_StepMotor1, setmotor_PIN, 1, 2); //配置步进电机工作模式
    StepMotorSetFixedAngle(&obj_StepMotor1,500);        //转动500°
}

5总结

以后再增加步进电机或者移植到别的的单片机钟，不需要再动驱动部分，只需要修改实现4部分接口便可以快速完成步进电机拓展。大大增加了灵活性。

神耀科技
关注
专栏目录
嵌入式计算机系统设计第三次实验报告
qq_49327751的博客
03-31 2864
实验题目：驱动与API设计初步 实验时间：2022.3.21（周一）～2022.4.3（周日） 实验地点：在规定时间中自主寻找合适实验地点并在规定时间内完成 实验条件： 1.STC-B学习板（2021暑假小学期每个学生自己做的） 2.个人电脑：自备 3.Keil、ISP、CH340驱动软件：自备 4.STC-BSP及Demo 程序：教师提供 5.“STC_B学习板”软件支持包使用说明：教师提供 6.C51语言语法：课程提供参考电子书籍，或自找自学 7.STC_BSP源码示范_sys&显示模块（教师提
比较详细的步进电机驱动程序
07-05
57步进电机和基于串口的步进电机28BYJ48的程序，资料较多
015——步进电机模块驱动开发（基于I.MX6uLL、MX-1502和28BYJ-48）
qq_52479948的博客
04-06 1584
 低待机电流 (小于 0.1uA) 低导通内阻 MOSFET 功率开关管— 采用 MOS 工艺设计功率管— 1 通道 1500 毫安功率管内阻 0.36 欧姆— 2 通道 800 毫安功率管内阻 0.47 欧姆 内部集成续流二极管— 无需外接续流二极管 较小的输入电流— 集成约 15K 对地下拉电阻— 3V 驱动信号平均 200uA 输入电流 内置带迟滞效应的过热保护电路 (TSD) 抗静电等级： 3KV (HBM)
步进电机驱动笔记1：STM32+DRV8825模块_初步驱动42步进电机
最新发布
NULL指向我的博客
08-10 1411
今日学习使用STM32 F103C8T6 与DRV8825模块 驱动步进电机
步进电机驱动
weixin_45618930的博客
09-19 552
define STEP_MOTOR_PORT GPIOB //定义IO接口所在组#define STEP_MOTOR_A GPIO_Pin_3 //定义IO接口#define STEP_MOTOR_B GPIO_Pin_4 //定义IO接口#define STEP_MOTOR_C GPIO_Pin_8 //定义IO接口#define STEP_MOTOR_D GPIO_Pin_9 //定义IO接口//初始化//断电状态//固定位置（制动）//#endif。
基于NodeMCU-ESP8266开发板控制步进电机驱动实验
weixin_67183034的博客
05-02 1901
步进电机是将电脉冲信号转变为角位移或线位移的开环控制元步进电机件。在非超载的情况下，电机的转速、停止的位置只取决于脉冲信号的频率和脉冲数，而不受负载变化的影响，当步进驱动器接收到一个脉冲信号，它就驱动步进电机按设定的方向转动一个固定的角度，称为“步距角”，它的旋转是以固定的角度一步一步运行的。可以通过控制脉冲个数来控制角位移量，从而达到准确定位的目的；同时可以通过控制脉冲频率来控制电机转动的速度和加速度，从而达到调速的目的。
步进电机驱动器开发中遇到的问题和解决方法
TMC_CHINA的博客
04-08 1273
介绍电机驱动开发过程中遇到的问题以及TMC如果解决此类问题
mes.rar_C# MES_MES_步进电机控制_电机
09-22
1. **驱动器选择**：选择适合的步进电机驱动器，驱动器将C#的指令转化为电机可以理解的信号。 2. **通信协议**：确定C#程序与驱动器之间的通信协议，如串行通信（RS-232, USB, TCP/IP等）或数字I/O接口。 3. **控制...
STM32F103_motor_control.zip_stm32 步进_stm32-_步进电机 STM32_步进电机 STM
07-14
6. `电机驱动.c/h`：具体的电机驱动代码，实现电机的驱动逻辑。 7. `system_stm32f10x.c`：系统初始化代码，负责设置系统时钟和其他初始化工作。 在实际应用中，开发人员会通过调试这些代码，调整相关参数，以满足...
步进电机生成S曲线上位机
02-12
C#是一种面向对象的编程语言，常用于Windows平台上的应用程序开发，具有丰富的类库和高效性能，适合开发复杂的用户界面。在控制步进电机的应用中，C#的强类型系统和事件驱动编程模型能够简化代码编写，使得程序更加...
指南描述了如何实现小型且高速的中断驱动步进马达控制器.zip
09-12
综上所述，实现小型且高速的中断驱动步进马达控制器涉及C#编程、中断处理、步进电机控制算法以及硬件接口等多个方面的知识。通过精心设计和优化，我们可以构建出一个高效、精确的步进电机控制系统，满足各种自动化和...
C#开发S7-200PLC PPI协议控制步进电机
08-18
在S7-200 PLC中，我们通常会设置输入和输出寄存器，通过改变这些寄存器的值来控制步进电机驱动器，进而驱动电机。 在C#程序中，我们首先需要建立到S7-200 PLC的连接。这通常涉及到初始化连接参数（如IP地址、站号、...
codesys 面向对象分析系列（一）
codesys01的博客
12-18 2362
接口是一个协议、规范；例如电源插座接口，它就是一个规范，中国制定的插座标准；每个厂家插座的生产技术、工艺都不一样。插座的内部实现对于电器来说是完全屏蔽的；但任何厂家只要按照插座标准制作，我们的电器就能正常使用。同一个函数接口，实现不同的功能；比如有动物（Animal）之类别（Class），而且由动物继承出类别鸡（Chicken）和类别狗（Dog），并对同一源自类别动物（父类）之一消息有不同的响应，如类别动物有“叫()”之动作，而类别鸡会“啼叫()”，类别狗则会“吠叫()”，则称之为多态继承。
面向对象的工业程序设计（OOIP）
姚家湾博客
05-05 2154
在现代控制系统中，软件越来越重要，而且越来越庞大。因此，导入计算机领域行之有效的OOP 方法就显得十分重要。控制领域的标准化组织，厂商也不断地做这样的努力。IEC61131-3 的2012 （第三版）中增加了对面向目标程序设计的内容。codsys 提出了连续功能图（CFC ）实现图形化OOP。而IEC61499 更是从一开始就支持面向对象程序设计的理念，复合功能块，子应用，ECC ，算法等概念与OOP 的理念非常地契合。本文讨论控制系统面向对象程序设计的相关内容
My Arduino vol 5 — 面向对象地编写“圆梦小车”程序 -电机
慢慢人生路 一直在迷路
03-11 260
辞职得空，最近主要是看杂七杂八的书为主。前日看到“嵌入式之梦”的BOSS在微博上亮了一下。就想到了随车附送的那段arduino演示程序。我觉得大部分初学者应该都看的好痛苦吧= =。 既然arduino支持c++，我也就以我业余的c++水平写上一段小小的教程望抛砖引雨吧。   阅读本文需要的基本知识：H桥电路基本作用，Arduino开发的基本环境。   第一章 让马达动起来 基本电路...
电机控制的个人解读
豚
05-28 4240
1. FOC与DTC FOC全称Field Oriented Control，磁场定向控制，也有人叫它矢量控制，西门子为它站台。 DTC全称Direct Torque Control，直接转矩控制，ABB为它站台。 参考 矢量控制（Siemens）VS 直接转矩控制（ABB）https://zhuanlan.zhihu.com/p/23489149?refer=zhishixuedia...
基于STM32的步进电机驱动设计
热门推荐
Bit_Dong的博客
08-28 1万+
采用STM32驱动28BYJ4步进电机，实现正转反转，完成角度调整。步进电机是一种将电脉冲转化为角位移的执行机构。当步进驱动器接收到一个脉冲信号，它就驱动步进电机按设定的方向转动------一个固定的角度(及步进角)。可以通过控制脉冲个来控制角位移量，从而达到准确定位的目的;同时可以通过控制脉冲频率来控制电机转动的速度和加速度，从而达到调速的目的。 ULN2003是最常见的电机驱动器IC之一，由7对达林顿晶体管对的阵列组成，每对能够驱动高达500mA和50V的负载。该板上使用了七对中的四对。......
ArduinoUNO实战-第十三章-步进电机驱动实验
Blueeyedboy521的博客
10-21 1824
BJ1对应A，BJ2对应B，BJ3对应C，BJ4对应D。使用28BYJ-48步进电机旋转。当给BJ1高电平1时，A输出0。当给BJ2低电平0时，B输出1。A/B/C/D是相位。
三相混合式多细分步进电机驱动器设计与优势
"本文介绍了基于正弦电流细分驱动原理设计的三相混合式多细分步进电机驱动器，通过电流跟踪和脉宽调制技术改善步进电机的性能，解决低速振动、共振和噪音问题，提升步距角分辨率和驱动器的可靠性。" 在深入探讨三相...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值