STM32驱动CAN总线电机

于 2024-09-09 11:55:01 发布
阅读量152 收藏 11
点赞数 6
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74923758/article/details/142000251
版权

电机的种类特别多，小型机器人（无人机、无人车）上普遍使用直流无刷电机，航模使用的一般是高速低扭矩，车模一般通过减速器低速实现高扭矩。

一般电机与电机驱动器配套使用，用的话只需要知道如何供电和如何给控制信号就行了。本文使用大疆的M3508电机，使用CAN总线进行控制，长相如图所示。

在这里插入图片描述

CAN总线是汽车行业的应用标准，稍微大型的电机很多是CAN总线控制的。CAN总线是一种现场总线，具有速度快、传输距离远、连接节点多的优点，具有错误检测、错误通知和错误恢复功能，使得其特别适合工业过程监控设备的互联。CAN总线的知识点很复杂，现在还有升级版CAN-Open

回到我们的电机，众所周知伺服电机有位置伺服、速度伺服、力伺服，大家一定也听过电机的三闭环控制，也就是位置环——速度环——电流环，如图所示，根据控制目标的不同，从外环到内环分别对应电机的位置伺服、速度伺服与力伺服，也可以说三种模式：位置模式、速度模式、转矩模式。

在这里插入图片描述

电机一般要配合驱动控制器使用，有的驱动器很牛皮，里面做好了三种模式，控制器给位置信号、速度信号就行了。有的次一点，只做了速度伺服，有的更次，啥也没做。我们今天用的大疆M33508电机就啥也没做，，，驱动器只是上报电机的速度、电流、转角、温度等信息，需要控制器去读这些信息，然后做闭环计算，控制器将计算结果传输给驱动器，再去控制电机电流。这里我们主要是做速度伺服。上图变成这样。

在这里插入图片描述

使用CAN总线实现大疆M3508电机的速度闭环控制

这里我们需要对电机做一个速度闭环控制，由于大疆电机提供了例程，所以我直接移植了它的代码，当然有些地方做了修改。

创建一个motor_pid.h和motor_pid.c文件（其实完全可以用上一章写的pid.c和pid.h文件，这里因为是官方提供的例程，所以直接用了）。

motor_pid.h文件：

#ifndef __MOTOR_PID_H
#define __MOTOR_PID_H
/* Includes ------------------------------------------------------------------*/
#include "stm32f7xx_hal.h"

enum
{
    LLAST = 0,
    LAST = 1,
    NOW = 2,

    POSITION_PID,
    DELTA_PID,
};
typedef struct __pid_t
{
    float p;
    float i;
    float d;

    float set[3]; //目标值,包含NOW， LAST， LLAST上上次
    float get[3]; //测量值
    float err[3]; //误差

    float pout; //p输出
    float iout; //i输出
    float dout; //d输出

    float pos_out;      //本次位置式输出
    float last_pos_out; //上次输出
    float delta_u;      //本次增量值
    float delta_out;    //本次增量式输出 = last_delta_out + delta_u
    float last_delta_out;

    float max_err;
    float deadband; //err < deadband return
    uint32_t pid_mode;
    uint32_t MaxOutput;     //输出限幅
    uint32_t IntegralLimit; //积分限幅

    void (*f_param_init)(struct __pid_t *pid, //PID参数初始化
                         uint32_t pid_mode,
                         uint32_t maxOutput,
                         uint32_t integralLimit,
                         float p,
                         float i,
                         float d);
    void (*f_pid_reset)(struct __pid_t *pid, float p, float i, float d); //pid三个参数修改

} pid_t;

void PID_struct_init(
    pid_t *pid,
    uint32_t mode,
    uint32_t maxout,
    uint32_t intergral_limit,

    float kp,
    float ki,
    float kd);

float pid_calc(pid_t *pid, float fdb, float ref);

#endif

motor_pid.c文件：

/* Includes ------------------------------------------------------------------*/
#include "motor_pid.h"
#include "mytype.h"
#include <math.h>
//#include "cmsis_os.h"

#define ABS(x)		((x>0)? (x): (-x)) 

void abs_limit(float *a, float ABS_MAX){
    if(*a > ABS_MAX)
        *a = ABS_MAX;
    if(*a < -ABS_MAX)
        *a = -ABS_MAX;
}
/*参数初始化--------------------------------------------------------------*/
static void pid_param_init(
    pid_t *pid, 
    uint32_t mode,
    uint32_t maxout,
    uint32_t intergral_limit,
    float 	kp, 
    float 	ki, 
    float 	kd)
{
    
    pid->IntegralLimit = intergral_limit;
    pid->MaxOutput = maxout;
    pid->pid_mode = mode;
    
    pid->p = kp;
    pid->i = ki;
    pid->d = kd;
    
}
/*中途更改参数设定(调试)------------------------------------------------------------*/
static void pid_reset(pid_t	*pid, float kp, float ki, float kd)
{
    pid->p = kp;
    pid->i = ki;
    pid->d = kd;
}

/**
    *@bref. calculate delta PID and position PID
    *@param[in] set： target
    *@param[in] real	measure
    */
float pid_calc(pid_t* pid, float get, float set){
    pid->get[NOW] = get;
    pid->set[NOW] = set;
    pid->err[NOW] = set - get;	//set - measure
    if (pid->max_err != 0 && ABS(pid->err[NOW]) >  pid->max_err  )
		return 0;
	if (pid->deadband != 0 && ABS(pid->err[NOW]) < pid->deadband)
		return 0;
    
    if(pid->pid_mode == POSITION_PID) //位置式p
    {
        pid->pout = pid->p * pid->err[NOW];
        pid->iout += pid->i * pid->err[NOW];
        pid->dout = pid->d * (pid->err[NOW] - pid->err[LAST] );
        abs_limit(&(pid->iout), pid->IntegralLimit);
        pid->pos_out = pid->pout + pid->iout + pid->dout;
        abs_limit(&(pid->pos_out), pid->MaxOutput);
        pid->last_pos_out = pid->pos_out;	//update last time 
    }
    else if(pid->pid_mode == DELTA_PID)//增量式P
    {
        pid->pout = pid->p * (pid->err[NOW] - pid->err[LAST]);
        pid->iout = pid->i * pid->err[NOW];
        pid->dout = pid->d * (pid->err[NOW] - 2*pid->err[LAST] + pid->err[LLAST]);
        
        abs_limit(&(pid->iout), pid->IntegralLimit);
        pid->delta_u = pid->pout + pid->iout + pid->dout;
        pid->delta_out = pid->last_delta_out + pid->delta_u;
        abs_limit(&(pid->delta_out), pid->MaxOutput);
        pid->last_delta_out = pid->delta_out;	//update last time
    }
    
    pid->err[LLAST] = pid->err[LAST];
    pid->err[LAST] = pid->err[NOW];
    pid->get[LLAST] = pid->get[LAST];
    pid->get[LAST] = pid->get[NOW];
    pid->set[LLAST] = pid->set[LAST];
    pid->set[LAST] = pid->set[NOW];
    return pid->pid_mode==POSITION_PID ? pid->pos_out : pid->delta_out;
//	
}

/**
    *@bref. special calculate position PID @attention @use @gyro data!!
    *@param[in] set： target
    *@param[in] real	measure
    */
float pid_sp_calc(pid_t* pid, float get, float set, float gyro){
    pid->get[NOW] = get;
    pid->set[NOW] = set;
    pid->err[NOW] = set - get;	//set - measure
    
    
    if(pid->pid_mode == POSITION_PID) //位置式p
    {
        pid->pout = pid->p * pid->err[NOW];
				if(fabs(pid->i) >= 0.001f)
					pid->iout += pid->i * pid->err[NOW];
				else
					pid->iout = 0;
        pid->dout = -pid->d * gyro/100.0f;	
        abs_limit(&(pid->iout), pid->IntegralLimit);
        pid->pos_out = pid->pout + pid->iout + pid->dout;
        abs_limit(&(pid->pos_out), pid->MaxOutput);
        pid->last_pos_out = pid->pos_out;	//update last time 
    }
    else if(pid->pid_mode == DELTA_PID)//增量式P
    {
       pid->pout = pid->p * (pid->err[NOW] - pid->err[LAST]);
       pid->iout = pid->i * pid->err[NOW];
       pid->dout = pid->d * (pid->err[NOW] - 2*pid->err[LAST] + pid->err[LLAST]);
       
       abs_limit(&(pid->iout), pid->IntegralLimit);
       pid->delta_u = pid->pout + pid->iout + pid->dout;
       pid->delta_out = pid->last_delta_out + pid->delta_u;
       abs_limit(&(pid->delta_out), pid->MaxOutput);
       pid->last_delta_out = pid->delta_out;	//update last time
    }
    
    pid->err[LLAST] = pid->err[LAST];
    pid->err[LAST] = pid->err[NOW];
    pid->get[LLAST] = pid->get[LAST];
    pid->get[LAST] = pid->get[NOW];
    pid->set[LLAST] = pid->set[LAST];
    pid->set[LAST] = pid->set[NOW];
    return pid->pid_mode==POSITION_PID ? pid->pos_out : pid->delta_out;
//	
}
/*pid总体初始化-----------------------------------------------------------------*/
void PID_struct_init(
    pid_t* pid,
    uint32_t mode,
    uint32_t maxout,
    uint32_t intergral_limit,
    
    float 	kp, 
    float 	ki, 
    float 	kd)
{
    /*init function pointer*/
    pid->f_param_init = pid_param_init;
    pid->f_pid_reset = pid_reset;
//	pid->f_cal_pid = pid_calc;	
//	pid->f_cal_sp_pid = pid_sp_calc;	//addition
		
    /*init pid param */
    pid->f_param_init(pid, mode, maxout, intergral_limit, kp, ki, kd);
	
}

再创建一个motor.h和motor.c文件，用于写电机PID控制的应用代码。

motor.h内容为：

#ifndef __MOTOR
#define __MOTOR

#include "stm32f7xx_hal.h"
#include "mytype.h"
#include "can.h"

/*电机的参数结构体*/
typedef struct{
	int16_t	 	speed_rpm;
    int16_t  	real_current;
    int16_t  	given_current;
    uint8_t  	hall;
	uint16_t 	angle;				//abs angle range:[0,8191]
	uint16_t 	last_angle;	//abs angle range:[0,8191]
	uint16_t	offset_angle;
	int32_t		round_cnt;
	int32_t		total_angle;
	u8			buf_idx;
	u16			angle_buf[FILTER_BUF_LEN];
	u16			fited_angle;
	u32			msg_cnt;
}moto_measure_t;

#define motor_num 6		//电机数量

/* Extern  ------------------------------------------------------------------*/
extern moto_measure_t  moto_chassis[];

u8 get_moto_measure(moto_measure_t *ptr, CAN_HandleTypeDef* hcan);
u8 set_moto_current(CAN_HandleTypeDef* hcan, s16 SID, s16 iq1, s16 iq2, s16 iq3, s16 iq4);
#endif

motor.c文件：

#include "can.h"
#include "motor.h"
//#include "cmsis_os.h"

moto_measure_t moto_chassis[motor_num] = {0};		//4 chassis moto
moto_measure_t moto_info;

void get_total_angle(moto_measure_t *p);
void get_moto_offset(moto_measure_t *ptr, CAN_HandleTypeDef* hcan);

/*******************************************************************************************
  * @Func			void get_moto_measure(moto_measure_t *ptr, CAN_HandleTypeDef* hcan)
  * @Brief    接收通过CAN发过来的信息
  * @Param		
  * @Retval		None
  * @Date     2015/11/24
 *******************************************************************************************/
u8 get_moto_measure(moto_measure_t *ptr, CAN_HandleTypeDef* hcan)
{
	if(HAL_CAN_Receive(hcan,CAN_FIFO0,0)!=HAL_OK) return 0;//接收数据	

	ptr->last_angle = ptr->angle;
	ptr->angle = (uint16_t)(hcan->pRxMsg->Data[0]<<8 | hcan->pRxMsg->Data[1]) ;
	ptr->real_current  = (int16_t)(hcan->pRxMsg->Data[2]<<8 | hcan->pRxMsg->Data[3]);
	ptr->speed_rpm = ptr->real_current;	//这里是因为两种电调对应位不一样的信息
	ptr->given_current = (int16_t)(hcan->pRxMsg->Data[4]<<8 | hcan->pRxMsg->Data[5])/-5;
	ptr->hall = hcan->pRxMsg->Data[6];
	if(ptr->angle - ptr->last_angle > 4096)
		ptr->round_cnt --;
	else if (ptr->angle - ptr->last_angle < -4096)
		ptr->round_cnt ++;
	ptr->total_angle = ptr->round_cnt * 8192 + ptr->angle - ptr->offset_angle;
	return hcan->pRxMsg->DLC;
}

/*this function should be called after system+can init */
void get_moto_offset(moto_measure_t *ptr, CAN_HandleTypeDef* hcan)
{
	ptr->angle = (uint16_t)(hcan->pRxMsg->Data[0]<<8 | hcan->pRxMsg->Data[1]) ;
	ptr->offset_angle = ptr->angle;
}

#define ABS(x)	( (x>0) ? (x) : (-x) )
/**
*@bref 电机上电角度=0， 之后用这个函数更新3510电机的相对开机后（为0）的相对角度。
	*/
void get_total_angle(moto_measure_t *p){
	
	int res1, res2, delta;
	if(p->angle < p->last_angle){			//可能的情况
		res1 = p->angle + 8192 - p->last_angle;	//正转，delta=+
		res2 = p->angle - p->last_angle;				//反转	delta=-
	}else{	//angle > last
		res1 = p->angle - 8192 - p->last_angle ;//反转	delta -
		res2 = p->angle - p->last_angle;				//正转	delta +
	}
	//不管正反转，肯定是转的角度小的那个是真的
	if(ABS(res1)<ABS(res2))
		delta = res1;
	else
		delta = res2;

	p->total_angle += delta;
	p->last_angle = p->angle;
}

u8 set_moto_current(CAN_HandleTypeDef* hcan, s16 SID, s16 iq1, s16 iq2, s16 iq3, s16 iq4)
{
	hcan->pTxMsg->StdId = SID;
	hcan->pTxMsg->IDE = CAN_ID_STD;
	hcan->pTxMsg->RTR = CAN_RTR_DATA;
	hcan->pTxMsg->DLC = 0x08;
	hcan->pTxMsg->Data[0] = iq1 >> 8;
	hcan->pTxMsg->Data[1] = iq1;
	hcan->pTxMsg->Data[2] = iq2 >> 8;
	hcan->pTxMsg->Data[3] = iq2;
	hcan->pTxMsg->Data[4] = iq3 >> 8;
	hcan->pTxMsg->Data[5] = iq3;
	hcan->pTxMsg->Data[6] = iq4 >> 8;
	hcan->pTxMsg->Data[7] = iq4;
	
	//HAL_CAN_Transmit(hcan, 1000);

	if(HAL_CAN_Transmit(&CAN1_Handler,1000)!=HAL_OK) return 1;     //发送
    return 0;	
}

motor.c文件：

#include "can.h"
#include "motor.h"
//#include "cmsis_os.h"

moto_measure_t moto_chassis[motor_num] = {0};		//4 chassis moto
moto_measure_t moto_info;

void get_total_angle(moto_measure_t *p);
void get_moto_offset(moto_measure_t *ptr, CAN_HandleTypeDef* hcan);

/*******************************************************************************************
  * @Func			void get_moto_measure(moto_measure_t *ptr, CAN_HandleTypeDef* hcan)
  * @Brief    接收通过CAN发过来的信息
  * @Param		
  * @Retval		None
  * @Date     2015/11/24
 *******************************************************************************************/
u8 get_moto_measure(moto_measure_t *ptr, CAN_HandleTypeDef* hcan)
{
	if(HAL_CAN_Receive(hcan,CAN_FIFO0,0)!=HAL_OK) return 0;//接收数据	

	ptr->last_angle = ptr->angle;
	ptr->angle = (uint16_t)(hcan->pRxMsg->Data[0]<<8 | hcan->pRxMsg->Data[1]) ;
	ptr->real_current  = (int16_t)(hcan->pRxMsg->Data[2]<<8 | hcan->pRxMsg->Data[3]);
	ptr->speed_rpm = ptr->real_current;	//这里是因为两种电调对应位不一样的信息
	ptr->given_current = (int16_t)(hcan->pRxMsg->Data[4]<<8 | hcan->pRxMsg->Data[5])/-5;
	ptr->hall = hcan->pRxMsg->Data[6];
	if(ptr->angle - ptr->last_angle > 4096)
		ptr->round_cnt --;
	else if (ptr->angle - ptr->last_angle < -4096)
		ptr->round_cnt ++;
	ptr->total_angle = ptr->round_cnt * 8192 + ptr->angle - ptr->offset_angle;
	return hcan->pRxMsg->DLC;
}

/*this function should be called after system+can init */
void get_moto_offset(moto_measure_t *ptr, CAN_HandleTypeDef* hcan)
{
	ptr->angle = (uint16_t)(hcan->pRxMsg->Data[0]<<8 | hcan->pRxMsg->Data[1]) ;
	ptr->offset_angle = ptr->angle;
}

#define ABS(x)	( (x>0) ? (x) : (-x) )
/**
*@bref 电机上电角度=0， 之后用这个函数更新3510电机的相对开机后（为0）的相对角度。
	*/
void get_total_angle(moto_measure_t *p){
	
	int res1, res2, delta;
	if(p->angle < p->last_angle){			//可能的情况
		res1 = p->angle + 8192 - p->last_angle;	//正转，delta=+
		res2 = p->angle - p->last_angle;				//反转	delta=-
	}else{	//angle > last
		res1 = p->angle - 8192 - p->last_angle ;//反转	delta -
		res2 = p->angle - p->last_angle;				//正转	delta +
	}
	//不管正反转，肯定是转的角度小的那个是真的
	if(ABS(res1)<ABS(res2))
		delta = res1;
	else
		delta = res2;

	p->total_angle += delta;
	p->last_angle = p->angle;
}

u8 set_moto_current(CAN_HandleTypeDef* hcan, s16 SID, s16 iq1, s16 iq2, s16 iq3, s16 iq4)
{
	hcan->pTxMsg->StdId = SID;
	hcan->pTxMsg->IDE = CAN_ID_STD;
	hcan->pTxMsg->RTR = CAN_RTR_DATA;
	hcan->pTxMsg->DLC = 0x08;
	hcan->pTxMsg->Data[0] = iq1 >> 8;
	hcan->pTxMsg->Data[1] = iq1;
	hcan->pTxMsg->Data[2] = iq2 >> 8;
	hcan->pTxMsg->Data[3] = iq2;
	hcan->pTxMsg->Data[4] = iq3 >> 8;
	hcan->pTxMsg->Data[5] = iq3;
	hcan->pTxMsg->Data[6] = iq4 >> 8;
	hcan->pTxMsg->Data[7] = iq4;
	
	//HAL_CAN_Transmit(hcan, 1000);

	if(HAL_CAN_Transmit(&CAN1_Handler,1000)!=HAL_OK) return 1;     //发送
    return 0;	
}

motor.c里面主要实现两个函数，一个是get_moto_measure(moto_measure_t *ptr, CAN_HandleTypeDef* hcan)，用于获得各个电机的当前信息，一个是set_moto_current(CAN_HandleTypeDef* hcan, s16 SID, s16 iq1, s16 iq2, s16 iq3, s16 iq4)，用来经过PID计算后，设置电机电流（速度PID输出的是电流）。

之后进入while（1）循环，查询电机当前速度（get_moto_measure），然后依次对四个电机进行PID计算(pid_calc)，然后一次性将四个电机的PID计算结果输送到CAN总线(set_moto_current)。这里我还做了加减速处理，避免电机速度调整太快超过PID的输出限幅。

拿铁不拿铁
关注
  • 6
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STM32的CAN总线调试经验分享
一名热爱技术的工程师的博客。分享技术干货，记录美好生活。永远相信美好的事情即将发生。
03-21 9715
本文简单介绍了在STM32F407上的CAN总线调试过程，解决了一个数据接收的问题，简单整理了一下调试的过程和思路。
stm32通过CAN通信控制电机
12-05
CAN总线是一种多主站的串行通信总线，具有高可靠性和抗干扰性，常用于汽车电子、工业自动化等领域。STM32F407内置了CAN控制器，支持CAN 2.0B协议，可以发送和接收标准帧和扩展帧，帧格式灵活，数据传输速率可高达1...
基于STM32单片机CAN总线步进电机正反转控制器设计22-096
单片机设计开发
03-10 625
22-096、STM32单片机CAN总线的步进电机控制器设计-主从机-CAN-ULN2003-KEY产品功能描述：本设计由2个板子组成，即A板和B板，两板之间通过CAN进行通讯。A板由STM32F103C8T6单片机核心板电路+ULN2003驱动步进电机控制电路+CAN模块电路组成。B板由STM32F103C8T6单片机核心板电路+按键电路+CAN模块电路组成。1、通过B板子上的按键可以控制A板子上步进电机的正转、反转、停止。
在STM32中：CAN总线驱动
没有余地 EliasJie
10-10 4661
在STM32中：CAN总线原理与驱动引脚定义STM32 CAN总线原理图CAN总线原理ISO/OSI 基本参照模型ISO11898和ISO11519-2 物理层的不同点CAN 类型 -------CAN-High线 -------CAN-Low线程序演示 引脚定义 在STM32F103C8T6引脚定义中， PA11对应CAN_RX PA12对应CAN_TX STM32 CAN总线原理图 Header 2X2 是跳线端子（可以删掉） Header 2 接线端子 TJA
基于STM32电机驱动学习笔记
weixin_74157522的博客
04-26 9264
直流有刷电机（Brushed DC Motor）是内含电刷装置的将直流电能转换成机械能的电动机。特点结构简单、操控方便、成本低廉等特点电刷和换向器之间有摩擦，导致换向时产生电火花易产生电磁干扰，故障多，维护工作量大，寿命短主要应用场景：各类电动玩具，电动自行车，印刷机械等等原理左手定则（死去的记忆偷袭我）中间镂空的位置是为了保持转子换向的直流有刷电机（BDC）是一种内含电刷装置的将直流电能转换成机械能的电动机。在允许的范围之内，供电即可工作，只需要调整电压，即可调整电机的转速。
STM32之CAN通信
热门推荐
韦东山嵌入式专栏
06-08 5万+
23.1关于 CAN 23.1.1 CAN 电气特性与协议 控制器局域网（Controller Area Network，CAN），是由德国BOSCH（博世）公司开发，是目前国际上应用最为广泛的现场总线之一。其特点是可拓展性好，可承受大量数据的高速通信，高度稳定可靠，因此常应用于汽车电子领域、工业自动化、医疗设备等高要求环境。 CAN总线有两个ISO国际标准：ISO11519 和ISO11898。 ISO11519定义了通信速率为10～125Kbps的低速CAN通信标准，属于开环总线，传输速率为40Kbp
STM32的CAN总线的基本原理及实现过程
nandycooh
09-09 2139
目录 1、什么是CAN 2、CAN协议的特点 3、ISO11898标准下的物理层特征 4、CAN 协议的5 种类型帧 4.1、总线仲裁介绍 4.2、位时序 5、STM32 CAN控制器简介 5.1、标识符筛选器 5.2、STM32 CAN模式 5.3、STM32 CAN发送流程 5.4、STM32 CAN接收流程 5.5、STM32 CAN位时序 1、什么是CAN ...
STM32入门教程——CAN驱动经验文档
03-23 685
以下是一个基于STM32F407微控制器的CAN通讯例程，该例程将展示如何使用STM32 HAL库来初始化CAN外设，发送和接收CAN消息。确保你的STM32F407开发板已经连接到CAN转接器，并且CAN_H和CAN_L线已经正确连接到CAN总线上。- 详细说明如何发送CAN数据，包括构建CAN消息、选择适当的缓冲区和发送机制。- 说明如何配置CAN引脚（CAN_RX和CAN_TX）的GPIO设置。- 根据你的CAN总线速度和系统时钟，你可能需要调整CAN的位时间配置。
【零基础 STM32通过CAN通信驱动Maxon电机】第三章 STM32 CAN通信回环模式测试及Maxon电机通信
qq_52340095的博客
12-06 2062
本章进行了简单的STM32 CAN通信控制Maxon电机进行PPM模式测试。相关知识还需要在实验当中不断学习。后续可能会更新复杂控制相关代码。先摆一会~
基于STM32（HAL）的CAN通信驱动伺服电机
qq_52552006的博客
07-13 7078
基于STM32（HAL库）的CAN通信驱动伺服电机，使用电机的通信协议，使用CAN数据发送。
基于STM32和CAN总线的全向移动平台控制系统设计.pdf
06-28
通过CAN总线网络，STM32可以与电机驱动器之间进行数据交换，传输速度达到了1M/S。在软件设计方面，通过DMA数据传输，能够快速读取传感器数据，并通过PID算法对数据进行处理和反馈，从而实现精确控制。 在实际应用中...
STM32 CANOPEN 电机驱动
03-30
5. 融合马达驱动：集成马克松电机的驱动代码，确保电机控制命令通过PDO正确地发送到CAN总线，并接收电机的状态反馈。 6. 测试与调试：通过CAN分析器或示波器验证CAN通信的正确性，以及马达的实际运行效果。 项目...
基于CAN总线和STM32的智能步进电机驱动模块设计.pdf
06-30
为了改进传统步进电机驱动控制系统的缺点，本研究设计了基于CAN总线和STM32微控制器的智能步进电机驱动模块，采用分布式控制体系，通过现场总线技术实现了基于高性能MCU的集中控制及上下位机之间的实时通信。...
0.3 学习Stm32经历过的磨难
2302_79677613的博客
08-27 1080
MDK报错 Browse information not available
构建STM32智能平衡车项目：PID控制算法与蓝牙通信技术
嵌入式极客小张
09-05 1539
本项目基于STM32单片机，采用嵌入式C++语言实现了一款智能平衡车，核心技术栈包括PID控制算法和蓝牙通信模块。通过使用MPU6050传感器实时获取车体的姿态信息，系统能够精确计算倾斜角度，并通过PID控制算法动态调整电机速度，从而保持平衡。电机驱动模块采用L298N，确保平衡车在不同地形上稳定行驶。此外，HC-05蓝牙模块实现了与手机的无线通信，用户可以通过手机APP实时监控平衡车状态并进行远程控制。项目的设计不仅提升了平衡车的操控性和安全性，还为短途出行提供了便捷的解决方案。
STM32智能家居语音系统
m0_74676415的博客
09-04 1449
基于STM32构建的智能家居语音控制系统，采用ESP8266（01s）作为关键的WiFi模块。这一系统通过机智云开发平台实现与ESP8266的高效通信，遵循平台规范的协议，确保数据的可靠传输。系统支持WIFI_AIRLINK_MODE，实现一键智能配网，简化用户的设置过程。 通过专用的手机APP，用户可以实时监测家中的环境参数，包括温度、湿度、气体浓度和光照强度等。此外，用户还可以便捷地控制家中的灯光与风扇开关，将智能家居的便捷性与舒适性完美结合，提升了现代居住空间的智能化体验。该系统不仅
STM32 ADC+DMA导致写FLASH失败
最新发布
qq_48211392的博客
09-08 296
网上有人说写FLASH之前需要__disable_irq()禁用中断，写FLASH结束再恢复中断，我这么做了但是还是无法写成功（不开启ADC+DMA连续转换前是可以写FLASH的），于是就把连续转换改成了手动软件触发，每次需要ADC数据的时候就软件触发一次，这样才可以正常写入FLASH，也不知道为什么；将ADC的DMA中断调整为最高，且增大ADCHAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buffer, ADC_Buffer_Size);
2.门锁_STM32_舵机设备实现
Fresh_man111的博客
09-04 1376
门锁的开启和关闭，就是电机来控制。这里不进行实际门锁机械结构的设计，选择用舵机或者电机转动一定的角度，就代表门锁开启。
stm32通过can总线控制伺服电机
12-16
STM32是一款由STMicroelectronics公司生产的32位微控制器，它具有丰富的外设和功能，包括用于控制CAN总线的硬件模块。CAN总线是一种广泛应用于工业控制领域的串行通信协议，可以实现设备之间的可靠数据传输。 要通过CAN总线控制伺服电机，首先需要在STM32上配置CAN总线硬件模块，并编写相应的软件程序。在硬件方面，可以通过连接STM32的CAN总线引脚和外部的CAN总线收发器来建立CAN网络。在软件方面，需要编写CAN总线的初始化代码，设置CAN总线的波特率、滤波器和中断功能等。 然后，需要编写伺服电机控制的代码，包括位置控制、速度控制、电流控制等。这些控制命令可以通过CAN总线发送到伺服驱动器，实现对伺服电机的控制。同时，可以通过CAN总线接收伺服电机的状态信息，如位置、速度、电流等，以实现闭环控制。 通过STM32和CAN总线控制伺服电机具有许多优势，如实时性好、传输速率高、系统可靠性强等。此外，STM32具有丰富的外设和处理能力，可以实现复杂的控制算法和实时数据处理。因此，STM32通过CAN总线控制伺服电机在工业控制和机器人应用中具有广泛的应用前景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值