• STM32实战总结：HAL之电机

    电机基础知识参考：

    51单片机外设篇：电机_路溪非溪的博客-CSDN博客

    无刷电机和有刷电机

    先详细了解有刷电机：

    带你了解（有刷）电机工作原理_哔哩哔哩_bilibili

    再详细了解无刷电机：

    无刷直流电机工作原理_哔哩哔哩_bilibili

    二者有何异同？

    无刷电机和有刷电机都是一种直流电机。

    有另外一种说法：很多人在知识上一直有这么个误区，以为无刷电机是直流电机，其实不然，无刷电机属于交流电机，是三相交流永磁电机的一种，输入模型无刷电机3根导线的电流是交流电，只不过这种交流电不是50HZ的市电正弦波，而是从无刷电机控制器（俗称无刷电调）调制出来的三相交变矩形波，频率比50HZ高很多，且随电机转速变化而变化。

    输入的都是直流，只是无刷电机通过内部的控制器后，形成了一个交流电。了解即可，不必纠结。

    有刷电机是所有电机中最基础的，不仅具有启动快速、制动及时、调速平稳、控制简单等优点，并且结构简单，价格便宜。比如我们小时候玩得四驱车里面就有一个小的装置（马达）这就是有刷电机。

    但是电刷也是让有刷电机寿命短的主要原因。由于电刷持续的相互滑动和摩擦，电刷会不断磨损消耗，有刷电机必须经常进行维护更换电刷。

    带刷的电机是磁极固定、线圈转动；而无刷马达则为线圈固定、磁极旋转。在无刷电机中，通过霍尔传感器，感知永磁体磁极的位置，然后根据这种感知，利用电子线路，在保证产生正确方向磁力的线圈中适时切换电流的方向来驱动电机。将有刷电机的不足消除。

    没有电刷的摩擦，电机里的火花跟电机都没有；无刷电机没有摩擦力、转速快且省电；无刷电机在没有电刷摩擦的情况下，几乎不需要额外保养。
    无刷电机比有刷电机在很多性能方面都要高一些，在价格方面也是。无论是控制电路还是电机本身，其成本和价格都比同级别的有刷电机高很多。

    再谈步进电机

    电机分为直流电机和交流电机，直流电机分为有刷直流电机和无刷直流电机。

    那么，步进电机是什么呢？它是直流电机还是交流电机？

    步进电机没有分交流与直流，如果是单极性控制方式，步进电机流过的电流是单方向，双极性控制时，步进电机流过电流是交流电。但控制步进电机的驱动器的供电电源分直流版和交流版，不同厂家的产品是有些差异，如EZM872是直流版，工作电压是18~80VDC；EZM872H是交流版，工作电压是18~80VAC。一般情况下，建议用直流版本，交流版本易出现电机急刹车时导致驱动器损坏。

    先了解大概原理：

    【动画演示】步进电机的原理，学了这么多年电工，终于搞明白了_哔哩哔哩_bilibili

    步进电机相对于无刷电机来说，可以精准控制。

    更多参考：

    什么是步进电机？步进电机的特点,分类与原理！-电子发烧友网

    单极性和双极性步进电机：

    15.2-步进电机实验--步进电机极性区分_哔哩哔哩_bilibili

    电机相数：

    所谓“相数”，就是线圈组数（不要认为是定子数）。二、三、四、五相步进电机分别对应有2、3、4、5组线圈。这 N 个绕组要均匀地镶嵌在定子上，因此定子的磁极数必定是 N 的整数倍，因此，转子转一圈的步数应该是 N 的整数倍。步进电机外部的接线和定子相数没有必然的联系。是根据实际运用的需要来决定的。

    看这个：

    会不会认为是8相的？因为有8个定子；会不会认为是4相的？因为可能两个定子绕一组线圈；其实，相数和定子数并没有必然联系。

    上面的是2相的，因为有2组线圈，引出来4根线。

    所以该图是两项四线步进电机。

    线圈有各种各样的绕法，也有不同的引线方式，所以，相数和线数等并不是固定的，需要针对特定的电机进行具体分析。无特定规律。不必纠结。

    四大驱动方式：

    步进电机4大驱动方式：单拍、双拍、半步、细分_哔哩哔哩_bilibili

    伺服电机

    简单来说，步进电机加上反馈电路，就构成了伺服电机。

    对比直流电机、步进电机和伺服电机：

    3种电机介绍（直交流、步进、伺服）_哔哩哔哩_bilibili

    有刷直流电机的功能实现

    选择有刷直流电机时通常需要考虑：

    尺寸

    扭力

    驱动电压

    驱动电流

    等等

    要求：实现有刷直流电机的启停、正反转和加减速。

    驱动方式1：

    只能打开和关闭，不能变速与换向，用继电器、BJT或MOS开关控制通断即可。

    驱动方式2：

    可以打开和关闭，可以变速但不能换向，此时用PWM波来控制电子开关即可。其实，改变驱动电压也是可以的，但是频繁改变驱动电压比较麻烦。通过改变PWM波地占空比可以灵活地调整电机速度，改变PWM占空比实际上就是改变其有效电流。

    驱动方式3：

    可以打开和关闭，可以变速，也可以换向，就需要用PWM控制桥路。通常使用集成IC，比如LV8548MC

    注意：单片机本身的电压不足以驱动电机，所以通常会通过单片机的高低电平来控制某些开关的通断，以此来接通电路，实现更高电压的接入。

    MX初始化

    因为是使用PWM波，所以，按照之前的定时器来初始化即可。

    这里使用TIM3的其中一个空闲通道即可。

    具体参考：

    STM32实战总结：HAL之PWM蜂鸣器_路溪非溪的博客-CSDN博客

    关键代码实现

    1. /* Includes ------------------------------------------------------------------*/
    2. #include "MyApplication.h"
    3.  
    4. /* Private define-------------------------------------------------------------*/
    5.  
    6. /* Private variables----------------------------------------------------------*/
    7.  
    8. /* Private function prototypes------------------------------------------------*/      
    9. static void Start(void);    //直流电机启动
    10. static void Stop(void);	    //直流电机停止
    11. static void Direction_Adjust(void);        //直流电机方向调整
    12. static void Speed_Adjust(Speed_Change_t);  //直流电机速度调整
    13. 	
    14. /* Public variables-----------------------------------------------------------*/
    15.  
    16. //定义结构体类变量
    17. DC_Motor_t DC_Motor = 
    18. {
    19.   Stop_State,
    20. 	Forward_State, 
    21. 	Speed_50,
    22. 	
    23. 	Start,
    24. 	Stop,
    25. 	Direction_Adjust,
    26. 	Speed_Adjust
    27. };
    28.  
    29. /*
    30. 	* @name   Start
    31. 	* @brief  直流电机启动
    32. 	* @param  None
    33. 	* @retval None      
    34. */
    35. static void Start(void)
    36. {
    37. 	//启动电机
    38. 	if(DC_Motor.Direction == Forward_State)
    39. 	{
    40. 		HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
    41. 	}
    42. 	else
    43. 	{
    44. 		HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_4);
    45. 	}
    46. 	
    47. 	//更新电机状态
    48. 	DC_Motor.Status = Start_State;
    49. }
    50.  
    51. /*
    52. 	* @name   Stop
    53. 	* @brief  直流电机停止
    54. 	* @param  None
    55. 	* @retval None      
    56. */
    57. static void Stop(void)
    58. {
    59. 	//停止电机
    60. 	HAL_TIM_PWM_Stop(&htim3,TIM_CHANNEL_3);
    61. 	HAL_TIM_PWM_Stop(&htim3,TIM_CHANNEL_4);
    62. 	//更新电机状态
    63. 	DC_Motor.Status = Stop_State;
    64. }
    65.  
    66. /*
    67. 	* @name   Direction_Adjust
    68. 	* @brief  直流电机方向调整
    69. 	* @param  None
    70. 	* @retval None      
    71. */
    72. static void Direction_Adjust(void)
    73. {
    74. 	if(DC_Motor.Status == Start_State)
    75. 	{
    76. 		if(DC_Motor.Direction == Reverse_State)
    77. 		{
    78. 			//停止转动电机
    79. 			HAL_TIM_PWM_Stop(&htim3,TIM_CHANNEL_4);
    80. 			//延时100ms,待电机停止
    81. 			HAL_Delay(100);
    82. 			//正向转动电机
    83. 			HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
    84. 			//更新电机方向标识
    85. 			DC_Motor.Direction = Forward_State;
    86. 		}
    87. 		else
    88. 		{
    89. 			//停止转动电机
    90. 			HAL_TIM_PWM_Stop(&htim3,TIM_CHANNEL_3);
    91. 			//延时100ms,待电机停止
    92. 			HAL_Delay(100);
    93. 			//反向转动电机
    94. 			HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_4);
    95. 			//更新电机方向标识
    96. 			DC_Motor.Direction = Reverse_State;
    97. 		}
    98. 	}
    99. }
    100.  
    101. /*
    102. 	* @name   Speed_Adjust
    103. 	* @brief  直流电机速度调整
    104. 	* @param  Speed_Change -> 速度变化
    105. 	* @retval None      
    106. */
    107. static void Speed_Adjust(Speed_Change_t Speed_Change)
    108. {
    109. 	if(DC_Motor.Status == Start_State)
    110. 	{
    111. 		if(Speed_Change == Speed_up)
    112. 		{
    113. 			//增大电机速度
    114. 			switch(DC_Motor.Speed)
    115. 			{
    116. 				case Speed_50:	DC_Motor.Speed = Speed_60;  break;
    117. 				case Speed_60:	DC_Motor.Speed = Speed_70;  break;
    118. 				case Speed_70:	DC_Motor.Speed = Speed_80;  break;
    119. 				case Speed_80:	DC_Motor.Speed = Speed_90;  break;
    120. 				case Speed_90:	DC_Motor.Speed = Speed_100; break;
    121. 				case Speed_100:	DC_Motor.Speed = Speed_100; break;
    122. 				default: DC_Motor.Speed = Speed_50;         
    123. 			}
    124. 		}
    125. 		else
    126. 		{
    127. 			//减小电机速度
    128. 			switch(DC_Motor.Speed)
    129. 			{
    130. 				case Speed_50:	DC_Motor.Speed = Speed_50;  break;
    131. 				case Speed_60:	DC_Motor.Speed = Speed_50;  break;
    132. 				case Speed_70:	DC_Motor.Speed = Speed_60;  break;
    133. 				case Speed_80:	DC_Motor.Speed = Speed_70;  break;
    134. 				case Speed_90:	DC_Motor.Speed = Speed_80;  break;
    135. 				case Speed_100:	DC_Motor.Speed = Speed_90;  break;
    136. 				default: DC_Motor.Speed = Speed_90;         
    137. 			}
    138. 		}
    139. 		
    140. 		//更新PWM占空比
    141. 		TIM3->CCR3 = DC_Motor.Speed;
    142. 		TIM3->CCR4 = DC_Motor.Speed;
    143. 	}
    144. }
    145. /********************************************************
    146.   End Of File
    147. ********************************************************/

    单极性步进电机的功能实现

    注意：

    在非超载的情况下，电机的转速、停止的位置只取决于脉冲信号的频率和脉冲数，而不受负载变化的影响。

    具体驱动的拍数参考：

    51单片机外设篇：电机_路溪非溪的博客-CSDN博客

    步进电机的转速通常不会太快。有的最大为500HZ，即2ms走一步。

    MX中初始化相关的GPIO即可。

    另外，可初始化一个定时器，用来实现各节拍之间的延时。

    关键代码：

    1. /* Includes ------------------------------------------------------------------*/
    2. #include "MyApplication.h"
    3.  
    4. /* Private define-------------------------------------------------------------*/
    5.  
    6. /* Private variables----------------------------------------------------------*/
    7.  
    8. /* Private function prototypes------------------------------------------------*/      
    9. static void Direction_Adjust(void);        //步进电机方向调整
    10. static void Speed_Adjust(Speed_Change_t);  //步进电机速度调整
    11. static void Step_One_Pulse(void);          //步进电机步进一个脉冲
    12.  
    13. /* Public variables-----------------------------------------------------------*/
    14.  
    15. //定义结构体类变量
    16. Unipolar_Step_Motor_t Unipolar_Step_Motor = 
    17. {
    18.   Stop_State,
    19. 	Forward_State, 
    20. 	Speed_6,
    21. 	0,
    22. 	Drive_Mode_8_Beats,
    23. 	0,
    24. 	(uint16_t)4096,
    25. 	
    26. 	Direction_Adjust,
    27. 	Speed_Adjust,
    28. 	Step_One_Pulse
    29. };
    30.  
    31. /*
    32. 	* @name   Direction_Adjust
    33. 	* @brief  直流电机方向调整
    34. 	* @param  None
    35. 	* @retval None      
    36. */
    37. static void Direction_Adjust(void)
    38. {
    39. 	if(Unipolar_Step_Motor.Status == Start_State)
    40. 	{
    41. 		//调整电机运行方向
    42. 		if(Unipolar_Step_Motor.Direction == Reverse_State)
    43. 		{
    44. 			Unipolar_Step_Motor.Direction = Forward_State;
    45. 		}
    46. 		else
    47. 		{
    48. 			Unipolar_Step_Motor.Direction = Reverse_State;
    49. 		}
    50. 		
    51. 		Unipolar_Step_Motor.Circle = Circle_Set_Value;
    52. 		Unipolar_Step_Motor.Pulse_Cnt = 0;
    53. 		Display.Disp_HEX(Disp_NUM_6,Unipolar_Step_Motor.Circle,Disp_DP_OFF);
    54. 	}
    55. }
    56.  
    57. /*
    58. 	* @name   Speed_Adjust
    59. 	* @brief  直流电机速度调整
    60. 	* @param  Speed_Change -> 速度变化
    61. 	* @retval None      
    62. */
    63. static void Speed_Adjust(Speed_Change_t Speed_Change)
    64. {
    65. 	uint8_t temp;
    66. 	
    67. 	if(Unipolar_Step_Motor.Status == Start_State)
    68. 	{
    69. 		if(Speed_Change == Speed_up)
    70. 		{
    71. 			//增大电机速度
    72. 			switch(Unipolar_Step_Motor.Speed)
    73. 			{
    74. 				case Speed_1: Unipolar_Step_Motor.Speed = Speed_2; temp = 2; break;
    75. 				case Speed_2: Unipolar_Step_Motor.Speed = Speed_3; temp = 3; break;
    76. 				case Speed_3: Unipolar_Step_Motor.Speed = Speed_4; temp = 4; break;
    77. 				case Speed_4: Unipolar_Step_Motor.Speed = Speed_5; temp = 5; break;
    78. 				case Speed_5: Unipolar_Step_Motor.Speed = Speed_6; temp = 6; break;
    79. 				case Speed_6: Unipolar_Step_Motor.Speed = Speed_7; temp = 7; break;
    80. 				case Speed_7: Unipolar_Step_Motor.Speed = Speed_8; temp = 8; break;
    81. 				case Speed_8: Unipolar_Step_Motor.Speed = Speed_9; temp = 9; break;
    82. 				case Speed_9: Unipolar_Step_Motor.Speed = Speed_9; temp = 9; break;
    83. 				default:Unipolar_Step_Motor.Speed = Speed_6; temp = 6; 
    84. 			}
    85. 		}
    86. 		else
    87. 		{
    88. 			//减小电机速度
    89. 			switch(Unipolar_Step_Motor.Speed)
    90. 			{
    91. 				case Speed_1: Unipolar_Step_Motor.Speed = Speed_1; temp = 1; break;
    92. 				case Speed_2: Unipolar_Step_Motor.Speed = Speed_1; temp = 1; break;
    93. 				case Speed_3: Unipolar_Step_Motor.Speed = Speed_2; temp = 2; break;
    94. 				case Speed_4: Unipolar_Step_Motor.Speed = Speed_3; temp = 3; break;
    95. 				case Speed_5: Unipolar_Step_Motor.Speed = Speed_4; temp = 4; break;
    96. 				case Speed_6: Unipolar_Step_Motor.Speed = Speed_5; temp = 5; break;
    97. 				case Speed_7: Unipolar_Step_Motor.Speed = Speed_6; temp = 6; break;
    98. 				case Speed_8: Unipolar_Step_Motor.Speed = Speed_7; temp = 7; break;
    99. 				case Speed_9: Unipolar_Step_Motor.Speed = Speed_8; temp = 8; break;
    100. 				default:Unipolar_Step_Motor.Speed = Speed_6; temp = 6; 
    101. 			}
    102. 		}
    103. 		
    104. 		//更新定时器7的计时重装载寄存器
    105. 		TIM7 ->ARR = Unipolar_Step_Motor.Speed;
    106. 		
    107. 		//更新数码管速度显示
    108. 		Display.Disp_HEX(Disp_NUM_1,temp,Disp_DP_OFF);
    109. 	}
    110. }
    111.  
    112. /*
    113. 	* @name   Step_One_Pulse
    114. 	* @brief  步进电机步进一个脉冲
    115. 	* @param  Speed_Change -> 速度变化
    116. 	* @retval None      
    117. */
    118. static void Step_One_Pulse(void)
    119. {
    120. 	static uint8_t Position = 0;
    121. 	
    122. 	//单四拍
    123. 	if(Unipolar_Step_Motor.Drive_Mode == Drive_Mode_Single_4_Beats)
    124. 	{
    125. 		if(Unipolar_Step_Motor.Direction == Forward_State)
    126. 		{
    127. 			//正向步进  A - D - C - B
    128. 			switch(Position)
    129. 			{
    130. 				case 0: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    131. 				case 1: CLR_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    132. 				case 2: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; CLR_Motor_D; break;
    133. 				case 3: CLR_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    134. 				default: System.Error_Handler();
    135. 			}
    136. 		}
    137. 		else
    138. 		{
    139. 			//反向步进  A - B - C - D
    140. 			switch(Position)
    141. 			{
    142. 				case 0: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    143. 				case 1: CLR_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    144. 				case 2: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; CLR_Motor_D; break;
    145. 				case 3: CLR_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    146. 				default: System.Error_Handler();
    147. 			}
    148. 		}
    149. 		
    150. 		//更新位置信息
    151. 		if((++Position) == 4)
    152. 				Position = 0;
    153. 	}
    154. 	
    155. 	//双四拍
    156. 	if(Unipolar_Step_Motor.Drive_Mode == Drive_Mode_Double_4_Beats)
    157. 	{
    158. 		if(Unipolar_Step_Motor.Direction == Forward_State)
    159. 		{
    160. 			//正向步进  DA - CD - BC - AB
    161. 			switch(Position)
    162. 			{
    163. 				case 0: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    164. 				case 1: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; SET_Motor_D; break;
    165. 				case 2: CLR_Motor_A; SET_Motor_B; SET_Motor_C; CLR_Motor_D; break;
    166. 				case 3: SET_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    167. 				default: System.Error_Handler();
    168. 			}
    169. 		}
    170. 		else
    171. 		{
    172. 			//反向步进  DA - AB - BC - CD
    173. 			switch(Position)
    174. 			{
    175. 				case 0: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    176. 				case 1: SET_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    177. 				case 2: CLR_Motor_A; SET_Motor_B; SET_Motor_C; CLR_Motor_D; break;
    178. 				case 3: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; SET_Motor_D; break;
    179. 				default: System.Error_Handler();
    180. 			}
    181. 		}
    182. 		
    183. 		//更新位置信息
    184. 		if((++Position) == 4)
    185. 				Position = 0;
    186. 	}
    187. 	
    188. 	//单八拍
    189. 	if(Unipolar_Step_Motor.Drive_Mode == Drive_Mode_8_Beats)
    190. 	{
    191. 		if(Unipolar_Step_Motor.Direction == Forward_State)
    192. 		{
    193. 			//正向步进 A - DA - D - CD - C - BC - B - AB
    194. 			switch(Position)
    195. 			{
    196. 				case 0: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    197. 				case 1: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    198. 				case 2: CLR_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    199. 				case 3: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; SET_Motor_D; break;
    200. 				case 4: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; CLR_Motor_D; break;
    201. 				case 5: CLR_Motor_A; SET_Motor_B; SET_Motor_C; CLR_Motor_D; break;
    202. 				case 6: CLR_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    203. 				case 7: SET_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    204. 				default:System.Error_Handler();
    205. 			}
    206. 		}
    207. 		else
    208. 		{
    209. 			//反向步进 A - AB - B - BC - C -CD - D - DA 
    210. 			switch(Position)
    211. 			{
    212. 				case 0: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    213. 				case 1: SET_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break; 
    214. 				case 2: CLR_Motor_A; SET_Motor_B; CLR_Motor_C; CLR_Motor_D; break;
    215. 				case 3: CLR_Motor_A; SET_Motor_B; SET_Motor_C; CLR_Motor_D; break;
    216. 				case 4: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; CLR_Motor_D; break; 
    217. 				case 5: CLR_Motor_A; CLR_Motor_B; SET_Motor_C; SET_Motor_D; break;
    218. 				case 6: CLR_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    219. 				case 7: SET_Motor_A; CLR_Motor_B; CLR_Motor_C; SET_Motor_D; break;
    220. 				default: System.Error_Handler();
    221. 			}
    222. 		}
    223. 		
    224. 		//更新位置信息
    225. 		if((++Position) == 8)
    226. 				Position = 0;
    227. 	}
    228. }
    229. /********************************************************
    230.   End Of File
    231. ********************************************************/

    双极性步进电机的功能实现

    双极性成本高（因为有两个电流方向，所以需要2个H桥共8个MOS管），但是结构简单。

    驱动方式：

    关键代码如下：

    1. /* Includes ------------------------------------------------------------------*/
    2. #include "MyApplication.h"
    3.  
    4. /* Private define-------------------------------------------------------------*/
    5.  
    6. /* Private variables----------------------------------------------------------*/
    7.  
    8. /* Private function prototypes------------------------------------------------*/      
    9. static void Direction_Adjust(void);        //步进电机方向调整
    10. static void Speed_Adjust(Speed_Change_t);  //步进电机速度调整
    11. static void Step_One_Pulse(void);          //步进电机步进一个脉冲
    12.  
    13. /* Public variables-----------------------------------------------------------*/
    14.  
    15. //定义结构体类变量
    16. Bipolar_Step_Motor_t Bipolar_Step_Motor = 
    17. {
    18.   Stop_State,
    19. 	Forward_State,
    20. 	Speed_6,
    21. 	0,
    22. 	//Drive_Mode_Single_4_Beats,
    23. 	Drive_Mode_Double_4_Beats,
    24. 	//Drive_Mode_8_Beats,
    25. 	0,
    26. 	(uint8_t)48,  //4拍，一圈转48次
    27. 	//(uint8_t)96,  //8拍，一圈转96次
    28. 	
    29. 	Direction_Adjust,
    30. 	Speed_Adjust,
    31. 	Step_One_Pulse
    32. };
    33.  
    34. /*
    35. 	* @name   Direction_Adjust
    36. 	* @brief  直流电机方向调整
    37. 	* @param  None
    38. 	* @retval None      
    39. */
    40. static void Direction_Adjust(void)
    41. {
    42. 	if(Bipolar_Step_Motor.Status == Start_State)
    43. 	{
    44. 		//调整电机运行方向
    45. 		if(Bipolar_Step_Motor.Direction == Reverse_State)
    46. 		{
    47. 			Bipolar_Step_Motor.Direction = Forward_State;
    48. 		}
    49. 		else
    50. 		{
    51. 			Bipolar_Step_Motor.Direction = Reverse_State;
    52. 		}
    53. 		
    54. 		Bipolar_Step_Motor.Circle = Circle_Set_Value;
    55. 		Bipolar_Step_Motor.Pulse_Cnt = 0;
    56. 		Display.Disp_HEX(Disp_NUM_6,Bipolar_Step_Motor.Circle/10,Disp_DP_OFF);
    57. 		Display.Disp_HEX(Disp_NUM_5,Bipolar_Step_Motor.Circle%10,Disp_DP_OFF);
    58. 	}
    59. }
    60.  
    61. /*
    62. 	* @name   Speed_Adjust
    63. 	* @brief  直流电机速度调整
    64. 	* @param  Speed_Change -> 速度变化
    65. 	* @retval None      
    66. */
    67. static void Speed_Adjust(Speed_Change_t Speed_Change)
    68. {
    69. 	uint8_t temp;
    70. 	
    71. 	if(Bipolar_Step_Motor.Status == Start_State)
    72. 	{
    73. 		if(Speed_Change == Speed_up)
    74. 		{
    75. 			//增大电机速度
    76. 			switch(Bipolar_Step_Motor.Speed)
    77. 			{
    78. 				case Speed_1: Bipolar_Step_Motor.Speed = Speed_2; temp = 2; break;
    79. 				case Speed_2: Bipolar_Step_Motor.Speed = Speed_3; temp = 3; break;
    80. 				case Speed_3: Bipolar_Step_Motor.Speed = Speed_4; temp = 4; break;
    81. 				case Speed_4: Bipolar_Step_Motor.Speed = Speed_5; temp = 5; break;
    82. 				case Speed_5: Bipolar_Step_Motor.Speed = Speed_6; temp = 6; break;
    83. 				case Speed_6: Bipolar_Step_Motor.Speed = Speed_7; temp = 7; break;
    84. 				case Speed_7: Bipolar_Step_Motor.Speed = Speed_8; temp = 8; break;
    85. 				case Speed_8: Bipolar_Step_Motor.Speed = Speed_9; temp = 9; break;
    86. 				case Speed_9: Bipolar_Step_Motor.Speed = Speed_9; temp = 9; break;
    87. 				default:Bipolar_Step_Motor.Speed = Speed_6; temp = 6; 
    88. 			}
    89. 		}
    90. 		else
    91. 		{
    92. 			//减小电机速度
    93. 			switch(Bipolar_Step_Motor.Speed)
    94. 			{
    95. 				case Speed_1: Bipolar_Step_Motor.Speed = Speed_1; temp = 1; break;
    96. 				case Speed_2: Bipolar_Step_Motor.Speed = Speed_1; temp = 1; break;
    97. 				case Speed_3: Bipolar_Step_Motor.Speed = Speed_2; temp = 2; break;
    98. 				case Speed_4: Bipolar_Step_Motor.Speed = Speed_3; temp = 3; break;
    99. 				case Speed_5: Bipolar_Step_Motor.Speed = Speed_4; temp = 4; break;
    100. 				case Speed_6: Bipolar_Step_Motor.Speed = Speed_5; temp = 5; break;
    101. 				case Speed_7: Bipolar_Step_Motor.Speed = Speed_6; temp = 6; break;
    102. 				case Speed_8: Bipolar_Step_Motor.Speed = Speed_7; temp = 7; break;
    103. 				case Speed_9: Bipolar_Step_Motor.Speed = Speed_8; temp = 8; break;
    104. 				default:Bipolar_Step_Motor.Speed = Speed_6; temp = 6; 
    105. 			}
    106. 		}
    107. 		
    108. 		//更新定时器7的计时重装载寄存器
    109. 		TIM7 ->ARR = Bipolar_Step_Motor.Speed;
    110. 		
    111. 		//更新数码管速度显示
    112. 		Display.Disp_HEX(Disp_NUM_1,temp,Disp_DP_OFF);
    113. 	}
    114. }
    115.  
    116. /*
    117. 	* @name   Step_One_Pulse
    118. 	* @brief  步进电机步进一个脉冲
    119. 	* @param  Speed_Change -> 速度变化
    120. 	* @retval None      
    121. */
    122. static void Step_One_Pulse(void)
    123. {
    124. 	static uint8_t Position = 0;
    125. 	
    126. 	//单四拍
    127. 	if(Bipolar_Step_Motor.Drive_Mode == Drive_Mode_Single_4_Beats)
    128. 	{
    129. 		if(Bipolar_Step_Motor.Direction == Forward_State)
    130. 		{
    131. 			//正向步进  A1 - B2 - A2 - B1
    132. 			switch(Position)
    133. 			{
    134. 				case 0: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    135. 				case 1: CLR_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    136. 				case 2: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    137. 				case 3: CLR_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    138. 				default: System.Error_Handler();
    139. 			}
    140. 		}
    141. 		else
    142. 		{
    143. 			//反向步进  A1 - B1 - A2 - B2
    144. 			switch(Position)
    145. 			{
    146. 				case 0: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    147. 				case 1: CLR_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    148. 				case 2: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    149. 				case 3: CLR_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    150. 				default: System.Error_Handler();
    151. 			}
    152. 		}
    153. 		
    154. 		//更新位置信息
    155. 		if((++Position) == 4)
    156. 				Position = 0;
    157. 	}
    158. 	
    159. 	//双四拍
    160. 	if(Bipolar_Step_Motor.Drive_Mode == Drive_Mode_Double_4_Beats)
    161. 	{
    162. 		if(Bipolar_Step_Motor.Direction == Forward_State)
    163. 		{
    164. 			//正向步进  A1B2 - B2A2 - A2B1 - B1A1
    165. 			switch(Position)
    166. 			{
    167. 				case 0: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    168. 				case 1: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; SET_Motor_B2; break;
    169. 				case 2: CLR_Motor_A1; SET_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    170. 				case 3: SET_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    171. 				default: System.Error_Handler();
    172. 			}
    173. 		}
    174. 		else
    175. 		{
    176. 			//反向步进  A1B1 - B1A2 - A2B2 - B2A1
    177. 			switch(Position)
    178. 			{
    179. 				case 0: SET_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    180. 				case 1: CLR_Motor_A1; SET_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    181. 				case 2: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; SET_Motor_B2; break;
    182. 				case 3: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    183. 				default: System.Error_Handler();
    184. 			}
    185. 		}
    186. 		
    187. 		//更新位置信息
    188. 		if((++Position) == 4)
    189. 				Position = 0;
    190. 	}
    191. 	
    192. 	//单八拍
    193. 	if(Bipolar_Step_Motor.Drive_Mode == Drive_Mode_8_Beats)
    194. 	{
    195. 		if(Bipolar_Step_Motor.Direction == Forward_State)
    196. 		{
    197. 			//正向步进  A1 - A1B2 - B2 - B2A2 - A2 - A2B1 - B1 - B1A1
    198. 			switch(Position)
    199. 			{
    200. 				case 0: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    201. 				case 1: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    202. 				case 2: CLR_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    203. 				case 3: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; SET_Motor_B2; break;
    204. 				case 4: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    205. 				case 5: CLR_Motor_A1; SET_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    206. 				case 6: CLR_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    207. 				case 7: SET_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    208. 				default:System.Error_Handler();
    209. 			}
    210. 		}
    211. 		else
    212. 		{
    213. 			//反向步进 A1 - A1B1 - B1 - B1A2 - A2 - A2B2 - B2 - B2A1
    214. 			switch(Position)
    215. 			{
    216. 				case 0: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    217. 				case 1: SET_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    218. 				case 2: CLR_Motor_A1; SET_Motor_B1; CLR_Motor_A2; CLR_Motor_B2; break;
    219. 				case 3: CLR_Motor_A1; SET_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    220. 				case 4: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; CLR_Motor_B2; break;
    221. 				case 5: CLR_Motor_A1; CLR_Motor_B1; SET_Motor_A2; SET_Motor_B2; break;
    222. 				case 6: CLR_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    223. 				case 7: SET_Motor_A1; CLR_Motor_B1; CLR_Motor_A2; SET_Motor_B2; break;
    224. 				default:System.Error_Handler();
    225. 			}
    226. 		}
    227. 		
    228. 		//更新位置信息
    229. 		if((++Position) == 8)
    230. 				Position = 0;
    231. 	}
    232. }
    233. /********************************************************
    234.   End Of File
    235. ********************************************************/

     

  • 相关阅读:
    我从自动化测试转为测试开发，资深测试总结测试开发技术栈，提升之路......
    Element Plus 组件库相关技术：7. 组件实现的基本流程及 Icon 组件的实现
    docker安装minio
    python代码反编译
    经典算法之希尔排序（Shell‘s Sort）
    Spring(三)
    实现一个支持多线程的Web服务器，能够处理多个客户端请求
    mediasoup udp端口分配策略
    极智AI | 大模型优化技术PagedAttention
    【Kubernetes】Pod——k8s中最重要的对象之一
  • 原文地址：https://blog.csdn.net/qq_28576837/article/details/127962740