初始化程序如下参考：
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
. V; Z9 g/ O1 w  MX_USART2_UART_Init();
  MX_TIM1_Init();
        STEPMOTOR_TIMx_Init();                /定时器输出初始化
" a, ?9 R7 Y, u( Z. ~2 E/ g  /* USER CODE BEGIN 2 */
        STEPMOTOR_OUTPUT_DISABLE();        //TMC2160禁止使能
/ U1 f+ ?4 r+ h4 M+ M8 @  /* USER CODE END 2 */
  /* Infinite loop */
6 E" t/ Y" ?5 ~5 y3 n  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
                STEPMOTOR_AxisMoveRel(6400*-2, 5000 , 5000 , 1200);                        //控制TMC2160驱动步进电机反转2圈（32细分，1.8度则一圈需要6400个脉冲）
9 f$ H4 p' S4 M: E1 |3 \% r! y                LedOnOff();                                //LED闪烁处理
                STEPMOTOR_AxisMoveRel(6400*2, 5000 , 5000 , 1200);                        //控制TMC2160驱动步进电机反转2圈（32细分，1.8度则一圈需要6400个脉冲）
/ s1 @3 E$ U( l2 h7 f. y3 R                LedOnOff();                                //LED闪烁处理
    /* USER CODE BEGIN 3 */
  }

//相对位置移动参考(参考硬石的电机开发板资料)
/**
  * 函数功能: 相对位置运动：运动给定的步数
  * 输入参数: step：移动的步数 (正数为顺时针，负数为逆时针).
( }# `* h+ q% Z1 R+ k              accel  加速度,实际值为accel*0.1*rad/sec^2
& }1 v$ c  ~1 M, G4 n. z/ ^5 h              decel  减速度,实际值为decel*0.1*rad/sec^2
9 B. t+ ^3 ~; ~; O& G( q              speed  最大速度,实际值为speed*0.1*rad/sec
  * 返 回 值: 无
1 T6 E# T  u3 d5 f, d& c4 v  * 说    明: 以给定的步数移动步进电机，先加速到最大速度，然后在合适位置开始
, U) W' @  Z- [2 m; u" x0 [  {  *           减速至停止，使得整个运动距离为指定的步数。如果加减速阶段很短并且
, `1 W7 o0 p( M1 @) s  *           速度很慢，那还没达到最大速度就要开始减速
  */
& R9 R/ @8 E+ a; i: Gvoid STEPMOTOR_AxisMoveRel(__IO int32_t step, __IO uint32_t accel, __IO uint32_t decel, __IO uint32_t speed)
{  
  __IO uint16_t tim_count;
& |/ u8 O0 W4 Q  // 达到最大速度时的步数
' j4 X2 b6 {, u) s  __IO uint32_t max_s_lim;
  // 必须要开始减速的步数（如果加速没有达到最大速度）
  __IO uint32_t accel_lim;
$ [0 p" \) {$ Y( L
  if(step < 0) // 步数为负数
( a- r* x. n' l+ P! g  {
    srd.dir = CCW; // 逆时针方向旋转
    STEPMOTOR_DIR_REVERSAL();
    step =-step;   // 获取步数绝对值
7 ^! Y" q1 }4 y- w  P  }
% Y' S/ H$ ^, G  else
  {
    srd.dir = CW; // 顺时针方向旋转
    STEPMOTOR_DIR_FORWARD();
9 d! `2 f: r8 W* S4 L  }
! y# s4 c& H2 E! D0 m  Y! d9 f7 I  
  if(step == 1)    // 步数为1
  {
    srd.accel_count = -1;   // 只移动一步
2 K9 p( @3 y( V  Z    srd.run_state = DECEL;  // 减速状态.
    srd.step_delay = 1000;        // 短延时       
  }
6 v( z5 g6 {$ W6 T* Q% q! R, M3 z  else if(step != 0)  // 如果目标运动步数不为0
5 M& Z) D8 [- r3 d0 |  G, @. G2 w; n; y  {
    // 我们的驱动器用户手册有详细的计算及推导过程

4 g9 n  e+ L3 n2 }8 M7 F  O2 }    // 设置最大速度极限, 计算得到min_delay用于定时器的计数器的值。
, f1 F; I9 ~# n; e+ K    // min_delay = (alpha / tt)/ w
) K! ~" C# Q1 o    srd.min_delay = (int32_t)(A_T_x10/speed);
% t$ E. w/ P  m! o% K
    // 通过计算第一个(c0) 的步进延时来设定加速度，其中accel单位为0.1rad/sec^2
    // step_delay = 1/tt * sqrt(2*alpha/accel)
    // step_delay = ( tfreq*0.676/10 )*10 * sqrt( (2*alpha*100000) / (accel*10) )/100
    srd.step_delay = (int32_t)((T1_FREQ_148 * sqrt(A_SQ / accel))/10);
# y" e0 v6 p3 ~7 S5 t$ N
    // 计算多少步之后达到最大速度的限制
1 P) p' s# g! [6 t! F* h+ b    // max_s_lim = speed^2 / (2*alpha*accel)
1 M5 U# ~9 H' P7 Y; A3 v5 h    max_s_lim = (uint32_t)(speed*speed/(A_x200*accel/10));
    // 如果达到最大速度小于0.5步，我们将四舍五入为0
    // 但实际我们必须移动至少一步才能达到想要的速度
    if(max_s_lim == 0){
; y- H, a  a( Y4 ^& H1 z      max_s_lim = 1;
2 }7 c. u" o: J' }; Q8 N3 t    }

// 计算多少步之后我们必须开始减速
2 Q" Q: D: t4 `) L! o& ]7 L+ K    // n1 = (n1+n2)decel / (accel + decel)
$ q+ S0 @% L$ v, @  w+ @' \    accel_lim = (uint32_t)(step*decel/(accel+decel));
    // 我们必须加速至少1步才能才能开始减速.
0 l, y/ A% J, E- x" q    if(accel_lim == 0){
      accel_lim = 1;
- A# g0 M) z3 x: a# y: I/ t6 P    }
8 P, D5 ^; B6 k; R5 x. z5 b
    // 使用限制条件我们可以计算出减速阶段步数
    if(accel_lim <= max_s_lim){
      srd.decel_val = accel_lim - step;
6 H  t' R# C0 H! k2 E; n7 ~/ B1 V" ~    }
3 T9 ?( E9 N; C! v    else{
      srd.decel_val = -(max_s_lim*accel/decel);
    }
    // 当只剩下一步我们必须减速
    if(srd.decel_val == 0){
/ c0 I# E, w8 s6 _      srd.decel_val = -1;
* z/ W7 h9 G4 U5 ~! [3 _    }

; ]' a# ^6 p. \/ m6 q    // 计算开始减速时的步数
    srd.decel_start = step + srd.decel_val;

* O1 h- ?8 D, h0 K3 s! X4 w    // 如果最大速度很慢，我们就不需要进行加速运动
, z; y( V. Y+ C% v, q    if(srd.step_delay <= srd.min_delay){
% d4 F: i; @3 m! d. i$ o      srd.step_delay = srd.min_delay;
& y# ]: B5 e! M* q/ B7 c- m      srd.run_state = RUN;
' ?* }. }) v4 |6 j* r    }
    else{
      srd.run_state = ACCEL;
    }   
5 u5 ]3 l0 S* K* R    // 复位加速度计数值
    srd.accel_count = 0;
* U/ g5 O- e2 o. G  }
  MotionStatus = 1; // 电机为运动状态
+ w; \7 r( ~' Z. M  tim_count=__HAL_TIM_GET_COUNTER(&htimx_STEPMOTOR);
8 R1 T4 [0 K# S# `  __HAL_TIM_SET_COMPARE(&htimx_STEPMOTOR,STEPMOTOR_TIM_CHANNEL_x,tim_count+srd.step_delay); // 设置定时器比较值
  TIM_CCxChannelCmd(STEPMOTOR_TIMx, STEPMOTOR_TIM_CHANNEL_x, TIM_CCx_ENABLE);                                                                // 使能定时器通道
3 u0 S0 h* k' q# t: h  STEPMOTOR_OUTPUT_ENABLE();
}

//定时器中断函数参考
) O2 ^' S  y8 B  \; Y8 p& T/**
  * 函数功能: 定时器中断服务函数
  * 输入参数: 无
0 Z% S, m! i. ^, S3 V: `+ o9 D  * 返 回 值: 无
  * 说    明: 实现加减速过程
  */
void STEPMOTOR_TIMx_IRQHandler(void)//定时器中断处理
1 e9 A3 W1 ]) }{
4 }, [8 s) _4 L  __IO uint16_t tim_count=0;
  // 保存新（下）一个延时周期
% G( e7 Q6 _4 q4 y  uint16_t new_step_delay=0;
; Y8 P; W% i! p! f; k  // 加速过程中最后一次延时（脉冲周期）.
' c% h8 q6 z2 r$ ?9 P  __IO static uint16_t last_accel_delay=0;
  // 总移动步数计数器
  __IO static uint32_t step_count = 0;
  // 记录new_step_delay中的余数，提高下一步计算的精度
  __IO static int32_t rest = 0;
  //定时器使用翻转模式，需要进入两次中断才输出一个完整脉冲
  __IO static uint8_t i=0;
  
  if(__HAL_TIM_GET_IT_SOURCE(&htimx_STEPMOTOR, STEPMOTOR_TIM_IT_CCx) !=RESET)
  {
$ ]; a9 ], b6 v3 r, ~. \    // 清楚定时器中断
    __HAL_TIM_CLEAR_IT(&htimx_STEPMOTOR, STEPMOTOR_TIM_IT_CCx);
. K# t7 ]* l; O& E; o! p: N) @! n5 m   
4 ~; u# s' Q$ |' D/ R- Y4 _    // 设置比较值
    tim_count=__HAL_TIM_GET_COUNTER(&htimx_STEPMOTOR);
* C2 y' k" x5 U" c  z3 r$ |' Y    __HAL_TIM_SET_COMPARE(&htimx_STEPMOTOR,STEPMOTOR_TIM_CHANNEL_x,tim_count+srd.step_delay);

    i++;     // 定时器中断次数计数值
7 L  H5 j$ C' S! m2 A    if(i==2) // 2次，说明已经输出一个完整脉冲
    {
" e3 N! `1 W6 H+ D. k      i=0;   // 清零定时器中断次数计数值
      switch(srd.run_state) // 加减速曲线阶段
+ d$ ]( [: h2 [8 g1 X6 {      {
        case STOP:
          step_count = 0;  // 清零步数计数器
1 g2 @$ R4 u" H, i1 n          rest = 0;        // 清零余值
( Y# F1 h3 U' j$ }# `0 `1 i          // 关闭通道
          TIM_CCxChannelCmd(STEPMOTOR_TIMx, STEPMOTOR_TIM_CHANNEL_x, TIM_CCx_DISABLE);        
          __HAL_TIM_CLEAR_FLAG(&htimx_STEPMOTOR, STEPMOTOR_TIM_FLAG_CCx);
# y& o/ U/ I+ q- ^+ Z& l          STEPMOTOR_OUTPUT_DISABLE();
+ J5 S, e( K6 L' G: }- s1 `& x          MotionStatus = 0;  //  电机为停止状态     
          break;
+ n  e1 H+ P5 U
& b5 o1 B/ E$ Y' O/ M% h/ K( c" ^1 w, x        case ACCEL:
          step_count++;      // 步数加1
. A7 x' z$ k1 s+ i$ m4 b. X; z          if(srd.dir==CW)
+ B6 u: p$ L1 u          {                 
            step_position++; // 绝对位置加1
+ b1 O9 b# K4 W7 ]; w& H* t8 g5 `          }
          else
          {
            step_position--; // 绝对位置减1
          }
          srd.accel_count++; // 加速计数值加1
' b+ V, M/ t2 m; O2 M9 o# H: z          new_step_delay = srd.step_delay - (((2 *srd.step_delay) + rest)/(4 * srd.accel_count + 1));//计算新(下)一步脉冲周期(时间间隔)
: }3 d& `! J. j0 |/ J          rest = ((2 * srd.step_delay)+rest)%(4 * srd.accel_count + 1);// 计算余数，下次计算补上余数，减少误差
          if(step_count >= srd.decel_start)// 检查是够应该开始减速
          {
% G7 T/ v; m0 J: x8 z( a0 _) h/ U            srd.accel_count = srd.decel_val; // 加速计数值为减速阶段计数值的初始值
1 }  m0 ~" ^5 J0 @            srd.run_state = DECEL;           // 下个脉冲进入减速阶段
( g" t% B- b* _, L5 a9 i          }
) N" }. k8 Z2 e; x          else if(new_step_delay <= srd.min_delay) // 检查是否到达期望的最大速度
6 i! C0 }. `/ ~& y4 t3 W          {
6 t- ^8 b8 b$ b# Z' z8 G" S            last_accel_delay = new_step_delay; // 保存加速过程中最后一次延时（脉冲周期）
            new_step_delay = srd.min_delay;    // 使用min_delay（对应最大速度speed）
            rest = 0;                          // 清零余值
            srd.run_state = RUN;               // 设置为匀速运行状态
          }
          break;

8 g5 D) a  O) |1 W5 O) ]7 ^1 h        case RUN:
          step_count++;  // 步数加1
$ R7 r. m- _  Y7 ^          if(srd.dir==CW)
          {                 
& G* y3 X- z7 y# L% X# l            step_position++; // 绝对位置加1
          }
9 X, j5 L9 u0 s9 k0 A- a+ {          else
+ l7 W2 h2 f& ~0 M7 v( U7 e0 a- Y- c, w          {
- O- T* c8 o; ~5 e* r            step_position--; // 绝对位置减1
          }
          new_step_delay = srd.min_delay;     // 使用min_delay（对应最大速度speed）
          if(step_count >= srd.decel_start)   // 需要开始减速
          {
            srd.accel_count = srd.decel_val;  // 减速步数做为加速计数值
" c" ]- u' N* L/ t6 U            new_step_delay = last_accel_delay;// 加阶段最后的延时做为减速阶段的起始延时(脉冲周期)
  B4 S% S& [- V, }4 T; A            srd.run_state = DECEL;            // 状态改变为减速
          }
          break;

        case DECEL:
          step_count++;  // 步数加1
          if(srd.dir==CW)
; T! A* Z5 @. E3 {  C" A" d          {                 
            step_position++; // 绝对位置加1
/ q$ I3 R! F( I: ^          }
          else
' p  V& a1 k% C# d          {
6 `# R' ^! C# F            step_position--; // 绝对位置减1
          }
3 ]; c3 |- [; d" Q          srd.accel_count++;
: B/ Q9 I8 d# r2 |* G- ?          new_step_delay = srd.step_delay - (((2 * srd.step_delay) + rest)/(4 * srd.accel_count + 1)); //计算新(下)一步脉冲周期(时间间隔)
% \7 d+ M, L  r3 h  }, O          rest = ((2 * srd.step_delay)+rest)%(4 * srd.accel_count + 1);// 计算余数，下次计算补上余数，减少误差
) q+ Z$ A9 T1 p7 v" B% \         
          //检查是否为最后一步
          if(srd.accel_count >= 0)
          {
            srd.run_state = STOP;
& a" x0 t9 S$ ?. i4 L; w          }
          break;
      }      
      srd.step_delay = new_step_delay; // 为下个(新的)延时(脉冲周期)赋值
' G" ^- k: G) F' n    }
  }
# D( y* A. n( E% Q) ~- V}
, b8 V; p: G6 ]6 S8 ~  @

五、开源补充说明
2 T$ ^( X" b3 a+ B; Z3 b    如果确实需要原理图和PCB的用户，请联系我们的客服或管理员私下索取谢谢！

如对文档有疑问或有技术问题需要交流，可联系Trinamic原厂或我们。

技术群：171897584
7 z0 W% X" i& f4 J) |  Y% o公众号：游名开源
$ Z8 w7 E. Q3 S; T

电机相对运动的函数和中断函数看着像硬石开发板里面的代码。

cpsrd570 发表于 2020-5-9 18:22
! \% X3 L- x, e( n* j电机相对运动的函数和中断函数看着像硬石开发板里面的代码。

是的，参考他们的，有说明：写着参考硬石的