发新帖我要提问
返回列表
打印
[STM32F1]

STM32F1定时器输出比较翻转模式控制8路步进电机旋转

[复制链接]
808|2
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
beijinglaobai|  楼主 | 2022-8-19 14:21 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
驱动步进电机, 脉冲驱动, ST
  步进电机是将电脉冲信号转变为角位移或线位移的开环控制元件。在非超载的情况下，电机的转速、停止的位置只取决于脉冲信号的频率和脉冲数，而不受负载变化的影响，即给电机加一个脉冲信号，电机则转过一个步距角。这一线性关系的存在，加上步进电机只有周期性的误差而无累积误差等特点。使得在速度、位置等控制领域用步进电机来控制变的非常的简单。
  利用STM32定时器的输出比较翻转模式产生脉冲驱动步进电机运转

首先定时定时器驱动引脚
复制
/* 包含头文件 ----------------------------------------------------------------*/

#include "stm32f1xx_hal.h"



/* 类型定义 ------------------------------------------------------------------*/

typedef struct {

  __IO uint32_t Speed;                        // 转速

  __IO uint32_t Step;             // 步数

}Motor_TypeDef;

extern Motor_TypeDef Motor[8];           //  8个电机



/* 宏定义 --------------------------------------------------------------------*/

#define STEPMOTOR_GROUP1_TIMx                    TIM1

#define STEPMOTOR_GROUP1_TIM_CLK_ENABLE()        __HAL_RCC_TIM1_CLK_ENABLE()

#define STEPMOTOR_GROUP1_TIM_CLK_DISABLE()       __HAL_RCC_TIM1_CLK_DISABLE()

#define STEPMOTOR_GROUP1_TIMx_IRQn               TIM1_CC_IRQn

#define STEPMOTOR_GROUP1_TIMx_IRQHandler         TIM1_CC_IRQHandler

#define STEPMOTOR_GROUP1_TIM_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOA_CLK_ENABLE()     // 输出控制脉冲给电机驱动器



/* 步进电机电机 */

/* 1 */

#define STEPMOTOR_TIM_CHL_1                      TIM_CHANNEL_1

#define STEPMOTOR_TIM_PUL_PORT_1                 GPIOA                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_1                  GPIO_PIN_8                       // 而PLU+直接接开发板的5V(或者3.3V)



/* 2 */

#define STEPMOTOR_TIM_CHL_2                      TIM_CHANNEL_2

#define STEPMOTOR_TIM_PUL_PORT_2                 GPIOA                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_2                  GPIO_PIN_9                       // 而PLU+直接接开发板的5V(或者3.3V)



/* 3 */

#define STEPMOTOR_TIM_CHL_3                      TIM_CHANNEL_3

#define STEPMOTOR_TIM_PUL_PORT_3                 GPIOA                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_3                  GPIO_PIN_10                      // 而PLU+直接接开发板的5V(或者3.3V)



/*-------------------------------------------------------------*/



#define STEPMOTOR_GROUP2_TIMx                    TIM8

#define STEPMOTOR_GROUP2_TIM_CLK_ENABLE()        __HAL_RCC_TIM8_CLK_ENABLE()

#define STEPMOTOR_GROUP2_TIM_CLK_DISABLE()       __HAL_RCC_TIM8_CLK_DISABLE()

#define STEPMOTOR_GROUP2_TIMx_IRQn               TIM8_CC_IRQn

#define STEPMOTOR_GROUP2_TIMx_IRQHandler         TIM8_CC_IRQHandler

#define STEPMOTOR_GROUP2_TIM_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOC_CLK_ENABLE()     // 输出控制脉冲给电机驱动器

/* 4 */

#define STEPMOTOR_TIM_CHL_4                      TIM_CHANNEL_1

#define STEPMOTOR_TIM_PUL_PORT_4                 GPIOC                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_4                  GPIO_PIN_6                       // 而PLU+直接接开发板的5V(或者3.3V)



/* 5 */

#define STEPMOTOR_TIM_CHL_5                      TIM_CHANNEL_2

#define STEPMOTOR_TIM_PUL_PORT_5                 GPIOC                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_5                  GPIO_PIN_7                       // 而PLU+直接接开发板的5V(或者3.3V)



/* 6 */

#define STEPMOTOR_TIM_CHL_6                      TIM_CHANNEL_3

#define STEPMOTOR_TIM_PUL_PORT_6                 GPIOC                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_6                  GPIO_PIN_8                       // 而PLU+直接接开发板的5V(或者3.3V)



/*-------------------------------------------------------------*/

#define STEPMOTOR_GROUP3_TIMx                    TIM3

#define STEPMOTOR_GROUP3_TIM_CLK_ENABLE()        __HAL_RCC_TIM3_CLK_ENABLE()

#define STEPMOTOR_GROUP3_TIM_CLK_DISABLE()       __HAL_RCC_TIM3_CLK_DISABLE()

#define STEPMOTOR_GROUP3_TIMx_IRQn               TIM3_IRQn

#define STEPMOTOR_GROUP3_TIMx_IRQHandler         TIM3_IRQHandler

#define STEPMOTOR_GROUP3_TIM_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOB_CLK_ENABLE()     // 输出控制脉冲给电机驱动器



/* 7 */

#define STEPMOTOR_TIM_CHL_7                      TIM_CHANNEL_3

#define STEPMOTOR_TIM_PUL_PORT_7                 GPIOB                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_7                  GPIO_PIN_0                       // 而PLU+直接接开发板的5V(或者3.3V)



/* 8 */

#define STEPMOTOR_TIM_CHL_8                      TIM_CHANNEL_4

#define STEPMOTOR_TIM_PUL_PORT_8                 GPIOB                            // 对应驱动器的PUL-（驱动器使用共阳接法）

#define STEPMOTOR_TIM_PUL_PIN_8                  GPIO_PIN_1                       // 而PLU+直接接开发板的5V(或者3.3V)



// 定义定时器预分频，定时器实际时钟频率为：72MHz/（STEPMOTOR_TIMx_PRESCALER+1）

#define STEPMOTOR_TIM_PRESCALER               7  // 步进电机驱动器细分设置为：   16  细分



// 定义定时器周期，输出比较模式周期设置为0xFFFF

#define STEPMOTOR_TIM_PERIOD                   0xFFFF

// 定义高级定时器重复计数寄存器值

#define STEPMOTOR_TIM_REPETITIONCOUNTER       0



/* 扩展变量 ------------------------------------------------------------------*/

extern TIM_HandleTypeDef htimx_STEPMOTOR_Group1;

extern TIM_HandleTypeDef htimx_STEPMOTOR_Group2;

extern TIM_HandleTypeDef htimx_STEPMOTOR_Group3;

/* 函数声明 ------------------------------------------------------------------*/



void STEPMOTOR_TIMx_Init(void);

然后做驱动引脚和定时器初始化

复制
#include "StepMotor/bsp_STEPMOTOR.h" 



/* 私有变量 ------------------------------------------------------------------*/

TIM_HandleTypeDef htimx_STEPMOTOR_Group1;

TIM_HandleTypeDef htimx_STEPMOTOR_Group2;

TIM_HandleTypeDef htimx_STEPMOTOR_Group3;



__IO uint16_t Toggle_Pulse = 500;         // 比较输出周期，值越小输出频率越快

Motor_TypeDef Motor[8] ;                 //  8个电机

/* 扩展变量 ------------------------------------------------------------------*/

/* 私有函数原形 --------------------------------------------------------------*/

/* 函数体 --------------------------------------------------------------------*/

/**

  * 函数功能: 驱动器相关GPIO初始化配置

  * 输入参数: 无

  * 返 回 值: 无

  * 说    明: 无

  */

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)

{

  GPIO_InitTypeDef GPIO_InitStruct; 

  

  /* 引脚端口时钟使能 */

  STEPMOTOR_GROUP1_TIM_GPIO_CLK_ENABLE();

  STEPMOTOR_GROUP2_TIM_GPIO_CLK_ENABLE();

  STEPMOTOR_GROUP3_TIM_GPIO_CLK_ENABLE();

  

/*---- Group1 SM GPIO Init ----------*/  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_1;

  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;

  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_1, &GPIO_InitStruct);

  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_2;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_2, &GPIO_InitStruct);

  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_3;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_3, &GPIO_InitStruct);



/*---- Group2 SM GPIO Init ----------*/  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_4;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_4, &GPIO_InitStruct);

  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_5;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_5, &GPIO_InitStruct);

  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_6;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_6, &GPIO_InitStruct);





/*---- Group3 SM GPIO Init ----------*/  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_7;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_7, &GPIO_InitStruct);

  

  /* 驱动器脉冲控制引脚IO初始化 */

  GPIO_InitStruct.Pin = STEPMOTOR_TIM_PUL_PIN_8;

  HAL_GPIO_Init(STEPMOTOR_TIM_PUL_PORT_8, &GPIO_InitStruct);

}



/**

  * 函数功能: 驱动器定时器初始化

  * 输入参数: 无

  * 返 回 值: 无

  * 说    明: 无

  */

void STEPMOTOR_TIMx_Init(void)

{

  TIM_ClockConfigTypeDef sClockSourceConfig;             // 定时器时钟

  TIM_OC_InitTypeDef sConfigOC;                          // 定时器通道比较输出

  

  /* 基本定时器外设时钟使能 */

  STEPMOTOR_GROUP1_TIM_CLK_ENABLE();

  STEPMOTOR_GROUP2_TIM_CLK_ENABLE();

  STEPMOTOR_GROUP3_TIM_CLK_ENABLE();

  

  /* 定时器基本环境配置 */

  htimx_STEPMOTOR_Group1.Instance = STEPMOTOR_GROUP1_TIMx;                          // 定时器编号

  htimx_STEPMOTOR_Group1.Init.Prescaler = STEPMOTOR_TIM_PRESCALER;                  // 定时器预分频器

  htimx_STEPMOTOR_Group1.Init.CounterMode = TIM_COUNTERMODE_UP;                     // 计数方向：向上计数

  htimx_STEPMOTOR_Group1.Init.Period = STEPMOTOR_TIM_PERIOD;                        // 定时器周期

  htimx_STEPMOTOR_Group1.Init.ClockDivision=TIM_CLOCKDIVISION_DIV1;                 // 时钟分频

  htimx_STEPMOTOR_Group1.Init.RepetitionCounter = STEPMOTOR_TIM_REPETITIONCOUNTER;  // 重复计数器

  HAL_TIM_Base_Init(&htimx_STEPMOTOR_Group1);

  

  htimx_STEPMOTOR_Group2 = htimx_STEPMOTOR_Group1;

  htimx_STEPMOTOR_Group2.Instance = STEPMOTOR_GROUP2_TIMx;                          // 定时器编号

  HAL_TIM_Base_Init(&htimx_STEPMOTOR_Group2);

  

  htimx_STEPMOTOR_Group3 = htimx_STEPMOTOR_Group1;

  htimx_STEPMOTOR_Group3.Instance = STEPMOTOR_GROUP3_TIMx;                          // 定时器编号

  HAL_TIM_Base_Init(&htimx_STEPMOTOR_Group3);



  /* 定时器时钟源配置 */

  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;       // 使用内部时钟源

  HAL_TIM_ConfigClockSource(&htimx_STEPMOTOR_Group1, &sClockSourceConfig);

  HAL_TIM_ConfigClockSource(&htimx_STEPMOTOR_Group2, &sClockSourceConfig);

  HAL_TIM_ConfigClockSource(&htimx_STEPMOTOR_Group3, &sClockSourceConfig);



  /* 定时器比较输出配置 */

  sConfigOC.OCMode = TIM_OCMODE_TOGGLE;                // 比较输出模式：反转输出

  sConfigOC.Pulse = Toggle_Pulse;                      // 脉冲数

  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;          // 输出极性

  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_LOW;         // 互补通道输出极性

  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;           // 快速模式

  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;       // 空闲电平

  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;     // 互补通道空闲电平

  

  /* 定时器三通道比较输出 */

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group1, &sConfigOC, STEPMOTOR_TIM_CHL_1);

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group1, &sConfigOC, STEPMOTOR_TIM_CHL_2);

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group1, &sConfigOC, STEPMOTOR_TIM_CHL_3);

  

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group2, &sConfigOC, STEPMOTOR_TIM_CHL_4);

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group2, &sConfigOC, STEPMOTOR_TIM_CHL_5);

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group2, &sConfigOC, STEPMOTOR_TIM_CHL_6);

  

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group3, &sConfigOC, STEPMOTOR_TIM_CHL_7);

  HAL_TIM_OC_ConfigChannel(&htimx_STEPMOTOR_Group3, &sConfigOC, STEPMOTOR_TIM_CHL_8);



  /* 配置定时器中断优先级并使能 */

  HAL_NVIC_SetPriority(STEPMOTOR_GROUP1_TIMx_IRQn, 0, 0);

  HAL_NVIC_EnableIRQ(STEPMOTOR_GROUP1_TIMx_IRQn);

  

  HAL_NVIC_SetPriority(STEPMOTOR_GROUP2_TIMx_IRQn, 0, 0);

  HAL_NVIC_EnableIRQ(STEPMOTOR_GROUP2_TIMx_IRQn);

  

  HAL_NVIC_SetPriority(STEPMOTOR_GROUP3_TIMx_IRQn, 0, 0);

  HAL_NVIC_EnableIRQ(STEPMOTOR_GROUP3_TIMx_IRQn);



}

定时和初始化运行参数

复制
/* 私有变量 ------------------------------------------------------------------*/

__IO uint32_t Step_Cnt[8] = {0};





/**

  * 函数功能: 初始化参数.

  * 输入参数: 无

  * 返 回 值: 无

  * 说    明: 无

  */

void Init_Param()

{

  Motor[0].Speed = 500;   // 速度

  Motor[0].Step = 6400*5; // 转动5圈

  Motor[1].Speed = 800;

  Motor[1].Step = 6400*5;

  Motor[2].Speed = 1100;

  Motor[2].Step = 6400*5;

  Motor[3].Speed = 1400;

  Motor[3].Step = 6400*5;

  Motor[4].Speed = 1700;

  Motor[4].Step = 6400*5;

  Motor[5].Speed = 2000;

  Motor[5].Step = 6400*5;

  Motor[6].Speed = 2300;

  Motor[6].Step = 6400*5;

  Motor[7].Speed = 2600;

  Motor[7].Step = 6400*5;

  Step_Cnt[0]=Step_Cnt[1]=Step_Cnt[2]=Step_Cnt[3]=0;// 步数记录 

  Step_Cnt[4]=Step_Cnt[5]=Step_Cnt[6]=Step_Cnt[7]=0;

}

在定时器中断程序中编辑控制代码

复制
/**

  * 函数功能: 定时器比较输出中断回调函数

  * 输入参数: htim：定时器句柄指针

  * 返 回 值: 无

  * 说    明: 无

  */

__IO  uint8_t i_Cnt[8] = {0};  // 步数计数

void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)

{

  __IO uint16_t count = 0;

  __IO uint8_t ActiveChl = htim->Channel;

/*----第一组电机------------------------------*/  

  if( htim == &htimx_STEPMOTOR_Group1)

  {

    switch(ActiveChl)

    {

      /* 定时器通道1 比较中断*/

      case HAL_TIM_ACTIVE_CHANNEL_1:

        /* 确定比较翻转时间 */

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_1,count+Motor[0].Speed);

        /* 记录脉冲个数 */

        i_Cnt[0] ++;

        if(i_Cnt[0] == 2)

        {

          i_Cnt[0] = 0;

          Step_Cnt[0] ++;

          /* 到达目标脉冲数 停止输出 */

          if(Step_Cnt[0] == Motor[0].Step )

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC1);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_1, TIM_CCx_DISABLE);

          }

        }

        break;

        

      case HAL_TIM_ACTIVE_CHANNEL_2:

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_2,count+Motor[1].Speed);

        i_Cnt[1] ++;

        if(i_Cnt[1] == 2)

        {

          i_Cnt[1] = 0;

          Step_Cnt[1] ++;

          if(Step_Cnt[1] == Motor[1].Step )

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC2);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_2, TIM_CCx_DISABLE);

          }

        }

        break;

        

      case HAL_TIM_ACTIVE_CHANNEL_3:

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_3,count+Motor[2].Speed);

        i_Cnt[2] ++;

        if(i_Cnt[2] == 2)

        {

          i_Cnt[2] = 0;

          Step_Cnt[2] ++;

          if(Step_Cnt[2] == Motor[2].Step )

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC3);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_3, TIM_CCx_DISABLE);

          }

        }

        break;

    }

  }

/*----------------------------------------------*/

  if( htim == &htimx_STEPMOTOR_Group2)

  {

    switch(ActiveChl)

    {

      case HAL_TIM_ACTIVE_CHANNEL_1:

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_4,count+Motor[3].Speed);

        i_Cnt[3] ++;

        if(i_Cnt[3] == 2)

        {

          i_Cnt[3] = 0;

          Step_Cnt[3] ++;

          if(Step_Cnt[3] == Motor[3].Step)

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC1);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_4, TIM_CCx_DISABLE);

          }

        }

        break;

        

      case HAL_TIM_ACTIVE_CHANNEL_2:

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_5,count+Motor[4].Speed);

        i_Cnt[4] ++;

        if(i_Cnt[4] == 2)

        {

          i_Cnt[4] = 0;

          Step_Cnt[4] ++;

          if(Step_Cnt[4] == Motor[4].Step)

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC2);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_5, TIM_CCx_DISABLE);

          }

        }

        break;

        

      case HAL_TIM_ACTIVE_CHANNEL_3:

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_6,count+Motor[5].Speed);

        i_Cnt[5] ++;

        if(i_Cnt[5] == 2)

        {

          i_Cnt[5] = 0;

          Step_Cnt[5] ++;

          if(Step_Cnt[5] == Motor[5].Step)

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC3);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_6, TIM_CCx_DISABLE);

          }

        }

        break;

    }

  }

/*---------------------------------------------------*/

  if( htim == &htimx_STEPMOTOR_Group3)

  {

    switch(ActiveChl)

    {

      case HAL_TIM_ACTIVE_CHANNEL_3:

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_7,count+Motor[6].Speed);

        i_Cnt[6] ++;

        if(i_Cnt[6] == 2)

        {

          i_Cnt[6] = 0;

          Step_Cnt[6] ++;

          if(Step_Cnt[6] == Motor[0].Step)

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC3);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_7, TIM_CCx_DISABLE);

          }

        }

        break;

        

      case HAL_TIM_ACTIVE_CHANNEL_4:

        count=__HAL_TIM_GET_COUNTER(htim);

        __HAL_TIM_SET_COMPARE(htim,STEPMOTOR_TIM_CHL_8,count+Motor[7].Speed);

        i_Cnt[7] ++;

        if(i_Cnt[7] == 2)

        {

          i_Cnt[7] = 0;

          Step_Cnt[7] ++;

          if(Step_Cnt[7] == Motor[7].Step)

          {

            __HAL_TIM_DISABLE_IT(htim,TIM_IT_CC4);

            TIM_CCxChannelCmd(htim->Instance, STEPMOTOR_TIM_CHL_8, TIM_CCx_DISABLE);

          }

        }

        break;

    }

  }

}

  在主程序中调用就可以实现电机运转控制了
复制
      Init_Param();

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group1,STEPMOTOR_TIM_CHL_1);

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group1,STEPMOTOR_TIM_CHL_2);

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group1,STEPMOTOR_TIM_CHL_3);      

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group2,STEPMOTOR_TIM_CHL_4);

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group2,STEPMOTOR_TIM_CHL_5);

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group2,STEPMOTOR_TIM_CHL_6);

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group3,STEPMOTOR_TIM_CHL_7);

      HAL_TIM_OC_Start_IT(&htimx_STEPMOTOR_Group3,STEPMOTOR_TIM_CHL_8);



使用特权

评论回复 赏
沙发
Uriah| | 2022-10-1 15:14 | 只看该作者

会以switch-case的方式出现

使用特权

评论回复 赏
板凳
Bblythe| | 2022-10-1 18:13 | 只看该作者

不要根据不同的参数类型走不同的代码逻辑

使用特权

评论回复 赏
地板
周半梅| | 2023-1-20 07:10 | 只看该作者

只要内存占用量不超过 256.0 就可以用 small 模式编译

使用特权

评论回复 赏
5楼
Pulitzer| | 2023-1-20 08:13 | 只看该作者

一般要进行内存优化，尽量提高内存的使用效率

使用特权

评论回复 赏
6楼
周半梅| | 2023-1-20 09:16 | 只看该作者

让尽可能多的变量使用直接寻址，提高速度

使用特权

评论回复 赏
7楼
童雨竹| | 2023-1-20 10:09 | 只看该作者

超过变量128后必须使用compact模式编译

使用特权

评论回复 赏
8楼
Wordsworth| | 2023-1-20 11:12 | 只看该作者

访问时采用不同的指令，所以并不会占用 RAM 空间

使用特权

评论回复 赏
9楼
Clyde011| | 2023-1-20 12:15 | 只看该作者

极限情况下可以定义的变量可占 247 个字节

使用特权

评论回复 赏
10楼
万图| | 2023-1-20 14:11 | 只看该作者

51 单片机不使用线性编址

使用特权

评论回复 赏
11楼
Uriah| | 2023-1-20 15:14 | 只看该作者

超出 120 个字节则必须用 idata 显式的指定为间接寻址

使用特权

评论回复 赏
12楼
帛灿灿| | 2023-1-20 17:10 | 只看该作者

128以上的某些地址为特殊寄存器使用，不能给程序用

使用特权

评论回复 赏
13楼
Bblythe| | 2023-1-20 18:13 | 只看该作者

small 模式下未指存储类型的变量默认为data型

使用特权

评论回复 赏
返回列表
发新帖 我要提问
高级模式
B Color Image Link Quote Code 收费 Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

beijinglaobai

58

主题

113

帖子

1

粉丝