DMA 原理从 0 到 1:为什么它能解放 CPU?一文讲透 DMA 的工作流程
【福利三:雨露均沾·逢7狂欢】之五:STM32系统时钟PLL故障排除1例
【福利三:雨露均沾·逢7狂欢】之三:AI帮我查BUG
福利三:雨露均沾·逢7狂欢】之二:STM32F407VG串口通信乱码故障的排除
基于STM32F103的I2C主从机通信
OpenBLT移植到STM32F103战舰开发板上适用于所有STM32F103系列的Bootloader
TFT LCD 与 FSMC 的硬件连接大容量 STM32F10xxx FSMC 接口
单片机:初学者该了解的STM32F103基础知识
2025软件工具兔哥知道
STM32之继电器模块
微信公众号
手机版
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_USART2_UART_Init();
MX_TIM1_Init();' q3 h+ L1 z" b; t4 B4 Q# D
STEPMOTOR_TIMx_Init(); /定时器输出初始化: r G6 C7 I7 r9 z% v9 G
/* USER CODE BEGIN 2 */2 S9 T- ^, f/ m4 {! f
STEPMOTOR_OUTPUT_DISABLE(); //TMC2160禁止使能
/* USER CODE END 2 */5 i7 j+ w) S4 X
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)' l1 ^- S- O, H& E# q6 g
{! n2 Q! o5 Y, w& [
/* USER CODE END WHILE */
STEPMOTOR_AxisMoveRel(6400*-2, 5000 , 5000 , 1200); //控制TMC2160驱动步进电机反转2圈(32细分,1.8度则一圈需要6400个脉冲)
LedOnOff(); //LED闪烁处理
STEPMOTOR_AxisMoveRel(6400*2, 5000 , 5000 , 1200); //控制TMC2160驱动步进电机反转2圈(32细分,1.8度则一圈需要6400个脉冲)- O4 q2 {8 m: f1 c( Q8 H
LedOnOff(); //LED闪烁处理7 V' r- g' ]: X( B, z
/* USER CODE BEGIN 3 */
} . `/ A% |$ ?% k) _8 Z1 E" }0 Z
/**: T* C( X+ R1 ?: D, O
* 函数功能: 相对位置运动:运动给定的步数8 @$ `4 ^+ B2 J; M- a0 i# K9 I
* 输入参数: step:移动的步数 (正数为顺时针,负数为逆时针).$ V# w, _) |: b6 f& K
accel 加速度,实际值为accel*0.1*rad/sec^2
decel 减速度,实际值为decel*0.1*rad/sec^27 _$ I3 t% \; ?' G( J" z& q" m! O- k% h
speed 最大速度,实际值为speed*0.1*rad/sec1 |+ H Q- j1 y
* 返 回 值: 无
* 说 明: 以给定的步数移动步进电机,先加速到最大速度,然后在合适位置开始: a9 [' l. W0 Y' z. M! ^
* 减速至停止,使得整个运动距离为指定的步数。如果加减速阶段很短并且# r( r6 Z/ S, c' F
* 速度很慢,那还没达到最大速度就要开始减速
*/
void STEPMOTOR_AxisMoveRel(__IO int32_t step, __IO uint32_t accel, __IO uint32_t decel, __IO uint32_t speed)# c% J3 `7 Q, v5 D: Z4 u' F" p# }. ~
{
__IO uint16_t tim_count;
// 达到最大速度时的步数0 q% I8 `8 |$ t: { C s" I
__IO uint32_t max_s_lim;4 t. O( |& {' F0 Q+ V
// 必须要开始减速的步数(如果加速没有达到最大速度)
__IO uint32_t accel_lim;7 o* G) P& H1 F/ e" z- _$ G
if(step < 0) // 步数为负数, A! c' B5 J0 Z5 S3 i2 f' u
{. c- c9 c6 O1 z0 z/ o6 f
srd.dir = CCW; // 逆时针方向旋转
STEPMOTOR_DIR_REVERSAL();! Q Y! Z5 g5 K* S$ i+ b- j
step =-step; // 获取步数绝对值
}
else8 V9 D9 K2 y2 k1 ?( v' J
{
srd.dir = CW; // 顺时针方向旋转
STEPMOTOR_DIR_FORWARD();7 }" Y L; H( s6 F
}' ?0 {2 s% E3 _# v4 {3 N
if(step == 1) // 步数为1
{
srd.accel_count = -1; // 只移动一步
srd.run_state = DECEL; // 减速状态.3 ?2 f, M5 C; e+ J @
srd.step_delay = 1000; // 短延时 ' R4 H2 V ]) i
}
else if(step != 0) // 如果目标运动步数不为0
{. O' D. B9 C" n2 d" s! o1 Y( f; \0 I
// 我们的驱动器用户手册有详细的计算及推导过程
// 设置最大速度极限, 计算得到min_delay用于定时器的计数器的值。! o/ `; M% g- C' w
// min_delay = (alpha / tt)/ w
srd.min_delay = (int32_t)(A_T_x10/speed);
9 B$ s) {# f1 V/ L& ~1 @
// 通过计算第一个(c0) 的步进延时来设定加速度,其中accel单位为0.1rad/sec^27 f% `. z( L/ ~6 O6 H! s% d
// step_delay = 1/tt * sqrt(2*alpha/accel)
// step_delay = ( tfreq*0.676/10 )*10 * sqrt( (2*alpha*100000) / (accel*10) )/1009 W) O! R# W6 U" ~+ u
srd.step_delay = (int32_t)((T1_FREQ_148 * sqrt(A_SQ / accel))/10);1 {' T4 o; e' ^* b) t5 r, P
// 计算多少步之后达到最大速度的限制 K- g0 L) r6 I! {9 a
// max_s_lim = speed^2 / (2*alpha*accel)
max_s_lim = (uint32_t)(speed*speed/(A_x200*accel/10));
// 如果达到最大速度小于0.5步,我们将四舍五入为0; H( V3 O/ o6 h$ P: s0 h+ Q
// 但实际我们必须移动至少一步才能达到想要的速度
if(max_s_lim == 0){" W; |# @0 u4 Z/ g
max_s_lim = 1;
}
// n1 = (n1+n2)decel / (accel + decel)
accel_lim = (uint32_t)(step*decel/(accel+decel));8 E( s2 ~2 R0 g' R J6 d" E
// 我们必须加速至少1步才能才能开始减速.- s% o- q; l2 k" v9 w" y
if(accel_lim == 0){
accel_lim = 1;
}( R8 d: V1 g L' A5 V/ [
// 使用限制条件我们可以计算出减速阶段步数& v4 ?/ m8 L4 G X( D
if(accel_lim <= max_s_lim){& _6 s* C0 v0 A( @2 o2 F
srd.decel_val = accel_lim - step;, r. N7 g# A1 D; Q3 e3 Q. w! e4 f
}
else{
srd.decel_val = -(max_s_lim*accel/decel);( G# @4 h! V, l O" b b& O
}* E& W' [) \& @+ d% G/ ?
// 当只剩下一步我们必须减速% q: Q n! f" H3 N4 X
if(srd.decel_val == 0){ k% E+ b( O5 G, Q! [ O5 O6 k
srd.decel_val = -1;
}' H3 H* O* l9 _: D/ L( t
// 计算开始减速时的步数
srd.decel_start = step + srd.decel_val;
7 j$ d" a5 w! }; J1 D- s1 e2 d( O
// 如果最大速度很慢,我们就不需要进行加速运动
if(srd.step_delay <= srd.min_delay){) `/ X/ v; r) s: S8 R. L
srd.step_delay = srd.min_delay;
srd.run_state = RUN;" n3 g/ T/ x7 q' Q5 N' z
}2 [. m5 `* I( \7 U4 E- w' k
else{/ r3 z/ @$ X+ P1 `9 s* t
srd.run_state = ACCEL;
}
// 复位加速度计数值6 x9 C( S8 v9 ?- X+ ~
srd.accel_count = 0;" i( _# F5 Q% K; ?/ u1 }7 l2 M* I
}
MotionStatus = 1; // 电机为运动状态
tim_count=__HAL_TIM_GET_COUNTER(&htimx_STEPMOTOR);
__HAL_TIM_SET_COMPARE(&htimx_STEPMOTOR,STEPMOTOR_TIM_CHANNEL_x,tim_count+srd.step_delay); // 设置定时器比较值2 K' m# y4 r. r: ]
TIM_CCxChannelCmd(STEPMOTOR_TIMx, STEPMOTOR_TIM_CHANNEL_x, TIM_CCx_ENABLE); // 使能定时器通道
STEPMOTOR_OUTPUT_ENABLE();
}
/**
* 函数功能: 定时器中断服务函数
* 输入参数: 无
* 返 回 值: 无
* 说 明: 实现加减速过程; y: i; ]" R3 K# t: R5 {8 V
*/2 y1 u! o4 R- y5 A) I+ j _
void STEPMOTOR_TIMx_IRQHandler(void)//定时器中断处理
{ ) `1 H' |1 B0 M0 ?) _, x
__IO uint16_t tim_count=0;7 J) g( Y. A- ^! Q
// 保存新(下)一个延时周期
uint16_t new_step_delay=0;1 r# L* q: w) r1 @2 T7 F4 _
// 加速过程中最后一次延时(脉冲周期).
__IO static uint16_t last_accel_delay=0;' @8 T3 q }( O% j1 ]1 w1 Q. P0 S
// 总移动步数计数器6 t* O3 n" d5 y: D
__IO static uint32_t step_count = 0;" f' T) F# M" d4 z* X) b
// 记录new_step_delay中的余数,提高下一步计算的精度* k) |1 s" A+ l, t! I
__IO static int32_t rest = 0;( ], h- Y9 \/ _6 k/ f; |
//定时器使用翻转模式,需要进入两次中断才输出一个完整脉冲
__IO static uint8_t i=0;6 [/ F5 `* @' ]- t0 K8 o
if(__HAL_TIM_GET_IT_SOURCE(&htimx_STEPMOTOR, STEPMOTOR_TIM_IT_CCx) !=RESET)
{
// 清楚定时器中断
__HAL_TIM_CLEAR_IT(&htimx_STEPMOTOR, STEPMOTOR_TIM_IT_CCx);$ [9 C b! Z0 s; P8 Y4 Z
// 设置比较值0 Q1 l- V$ i1 n) P1 L
tim_count=__HAL_TIM_GET_COUNTER(&htimx_STEPMOTOR);
__HAL_TIM_SET_COMPARE(&htimx_STEPMOTOR,STEPMOTOR_TIM_CHANNEL_x,tim_count+srd.step_delay);
: o% u, p K! p7 F2 U! M: q
i++; // 定时器中断次数计数值
if(i==2) // 2次,说明已经输出一个完整脉冲
{# F/ i a6 w" I& q$ a
i=0; // 清零定时器中断次数计数值
switch(srd.run_state) // 加减速曲线阶段
{, l% P0 \* v; s
case STOP:
step_count = 0; // 清零步数计数器3 _" I: Y/ P0 e" S
rest = 0; // 清零余值+ E( q* Y9 i" Q5 S7 T: |' k
// 关闭通道5 _$ ^# o: A% _* X" ^% y, Y- `
TIM_CCxChannelCmd(STEPMOTOR_TIMx, STEPMOTOR_TIM_CHANNEL_x, TIM_CCx_DISABLE); / q6 ^9 ?* M* a' `
__HAL_TIM_CLEAR_FLAG(&htimx_STEPMOTOR, STEPMOTOR_TIM_FLAG_CCx);
STEPMOTOR_OUTPUT_DISABLE();$ }/ J- n! M+ M6 s& L" X. @, J
MotionStatus = 0; // 电机为停止状态
break;. F& v3 N* Y. W v9 U7 y3 ^) j% p
case ACCEL:$ N- n& c0 A9 a) p9 U* h
step_count++; // 步数加19 L. k) N! z( a* g9 i- E
if(srd.dir==CW). i" p j$ v( x- H: E4 T
{
step_position++; // 绝对位置加1
}
else& _! v6 Z( i7 ?3 R- a% H* g5 @5 x
{
step_position--; // 绝对位置减1
}9 Q9 `3 I! h+ R7 K7 }* F4 w3 L
srd.accel_count++; // 加速计数值加1: B) H/ P; T* H3 s" J
new_step_delay = srd.step_delay - (((2 *srd.step_delay) + rest)/(4 * srd.accel_count + 1));//计算新(下)一步脉冲周期(时间间隔)6 D0 d9 V- m. |
rest = ((2 * srd.step_delay)+rest)%(4 * srd.accel_count + 1);// 计算余数,下次计算补上余数,减少误差- S8 @$ x7 L0 ]4 V" U. ~( j. f7 A
if(step_count >= srd.decel_start)// 检查是够应该开始减速 |9 s/ W' u' I% X8 a: |: S
{- x3 V" I! R. ^/ h- m3 O( x0 A
srd.accel_count = srd.decel_val; // 加速计数值为减速阶段计数值的初始值9 N; y! Y7 H. |+ P3 s. z
srd.run_state = DECEL; // 下个脉冲进入减速阶段) c) @+ b8 d5 {4 b3 t
}
else if(new_step_delay <= srd.min_delay) // 检查是否到达期望的最大速度
{
last_accel_delay = new_step_delay; // 保存加速过程中最后一次延时(脉冲周期)
new_step_delay = srd.min_delay; // 使用min_delay(对应最大速度speed)1 f4 u4 r& J# a( e. a
rest = 0; // 清零余值
srd.run_state = RUN; // 设置为匀速运行状态
}3 _. X& D" b9 V) t
break;" b" @% ]6 W+ u4 ]& W; H
7 |9 h9 _ D/ t1 c/ [" j
case RUN:) w, D% q- i% s! Y- |$ a/ b% @
step_count++; // 步数加1
if(srd.dir==CW)# h: s& u9 @3 x& [1 N( s- ^
{ / O1 Y) i+ g# c' G2 N y* H
step_position++; // 绝对位置加1- V% ]: [' q, N3 g& u- ~5 ?- Q
}$ y+ f% R/ t. w# ?) i9 u
else
{
step_position--; // 绝对位置减1
}
new_step_delay = srd.min_delay; // 使用min_delay(对应最大速度speed), K9 Q" n' E4 [& } y
if(step_count >= srd.decel_start) // 需要开始减速* u% j- r, L3 S$ f
{2 J$ r0 }! ^1 b% O6 u7 J
srd.accel_count = srd.decel_val; // 减速步数做为加速计数值
new_step_delay = last_accel_delay;// 加阶段最后的延时做为减速阶段的起始延时(脉冲周期)3 l2 r" x; h3 J8 @6 a# ]6 C
srd.run_state = DECEL; // 状态改变为减速
}
break;
case DECEL:$ Z! Q+ Q. v, y
step_count++; // 步数加1
if(srd.dir==CW)
{ / S2 ^" ?# L. V. z" Z; z
step_position++; // 绝对位置加10 j8 o" o) j: W9 c! F; }; t# D, C
}' Y7 ^1 ?1 I6 O% L
else
{5 k3 R$ x: F8 K* `3 m" ?
step_position--; // 绝对位置减1
}, {2 n8 |; H7 T
srd.accel_count++;
new_step_delay = srd.step_delay - (((2 * srd.step_delay) + rest)/(4 * srd.accel_count + 1)); //计算新(下)一步脉冲周期(时间间隔)/ |( K1 A# @+ e- R: [1 ]: W- r
rest = ((2 * srd.step_delay)+rest)%(4 * srd.accel_count + 1);// 计算余数,下次计算补上余数,减少误差4 Q! L+ _ g4 X( ]1 O, ^$ k/ X
//检查是否为最后一步! U7 w3 |/ O+ U: U% k, V: y
if(srd.accel_count >= 0)
{" M, t- }) d. z; u
srd.run_state = STOP;
}
break;( I, T9 g6 R, c' X) f5 q5 t4 S4 k
} ; _' y3 R3 U/ }/ ]! j
srd.step_delay = new_step_delay; // 为下个(新的)延时(脉冲周期)赋值
}0 [, p. V2 J9 Q2 {5 y& B# U
}2 X; \+ M( Z: c4 |: u
}
如果确实需要原理图和PCB的用户,请联系我们的客服或管理员私下索取谢谢!- H" y8 N8 ?; a7 m- f2 x! Y% k
* S- o+ T5 ? W. v/ f' k
技术群:171897584
公众号:游名开源6 K+ | ~8 \8 `! R) e: F
是的,参考他们的,有说明:写着参考硬石的