• 【单片机】11-步进电机和直流电机

    1.直流电机

    1.什么是电机

    电能转换为动能

    2.常见电机

    （1）交流电机【大功率】：两相【200W左右】，三相【1000W左右】

    （2）直流电机【小功率】：永磁【真正的磁铁】，励磁【电磁铁】

    （3）步进电机【精确控制功率】，伺服电机【非常精确功率】

    3.直流电机详解

    （1）外观

    （2）接线和工作原理

    在电池位置有VCC和GND

    （3）直流电机的驱动问题：不能用IO口直接驱动

    4.直流电机实验

    （1）直流电机直接接在开发板的主板的VCC和GND引出接口上看电机是否转动，还可以调换VCC和GND看是否反转

    （2）单片机的IO口的数字口，本身的驱动能力非常小（最多20mA级别），这个驱动能力是带不动电动机的。

    （3）一般单片机需要实验专门的驱动芯片来驱动电机。驱动芯片的作用就是把单片机的小电流的控制信号转成逻辑上相同的大电流的驱动源。这就是所谓的弱电控制强电。

    1. #include
    2.  
    3. /**
    5. 	驱动电机驱动直流电机
    6. */
    7.  
    8. sbit ALine=P0^0;
    9. sbit BLine=P0^1;
    10.  
    11. void main(){
    12.  
    13. 	ALine=1;
    14. 	BLine=0;
    15. 	//实际上不会动，因为电流不足
    16. 	while(1);
    17. 	
    18. }
    19.

    2.步进电机理论

    1.什么是步进电机

    1.外观

    2.功能特点

    （1）步进（step）的动起来，可以控制自己转多少

    （2）不是直接给接电就动，要有规律的电才可以动

    （3）以步长为单位，不断的转

    （4）可以控制转多少就停

    3.操作接口

    （1）四线步进电机

    2.步距角：步长

    （1）就是精度，360°的⚪，可以走多少°。

    （2）步长==精度

    （3）步进电机有一个固有步距角，这个参数和步进电机本身有关的。

    （4）步进电机一般情况下只能以固有步距角的整数倍来运动，这一个固有步距角的移动就叫一个节拍。

    （5）电机还有一个比固有步距角更小的运动方法，这种方法叫细分，由电机驱动器来支持的。

    3.相数

    （1）步进电机绕阻的组数

    （2）相数多的步距角越小，越精确，引出的线越多

    4.细分

    （1）电机还有一个比固有步距角更小的运动方法，这种方法叫细分，由电机驱动器来支持的。

    5.极性

    单极性步进电机和双极性步进电机有什么区别？ – AKT Motor and Drive

    单极性和双极性是步进电机最常用的两种驱动架构

    有一些可以通过2种进行驱动。

    我们拿到的步进电机中只有电路（线路），没有驱动。真正的驱动在开发板上。

    1.单极性

    单极性驱动电路使用四颗晶体管来驱动步进电机的两组相位，电机结构则如图1所示包含两组带有中间抽头的线圈，整个电机共有六条线与外界连接。这类电机有时又称为四相电机，但这种称呼容易令人混淆又不正确，因为它其实只有两个相位，精确的说法应是双相位六线式步进电机。六线式步进电机虽又称为单极性步进电机，实际上却能同时使用单极性或双极性驱动电路。

    2.双极性

    双极性步进电机的驱动电路则如图2所示，它会使用八颗晶体管来驱动两组相位。双极性驱动电路可以同时驱动四线式或六线式步进电机，虽然四线式电机只能使用双极性驱动电路，它却能大幅降低量产型应用的成本。双极性步进电机驱动电路的晶体管数目是单极性驱动电路的两倍，其中四颗下端晶体管通常是由微控制器直接驱动，上端晶体管则需要成本较高的上端驱动电路。双极性驱动电路的晶体管只需承受电机电压，所以它不像单极性驱动电路一样需要箝位电路。

    6.拍数

    单相和双相的带载能力不同

    1.单相四拍

    单相：一边的线在工作

    A/   B   A    B/        正转

    B/    A    B    A/      反转   

    解释：想要动起来就在一端有电压差，另外一端没有电压差

    A/   B   A    B/     

    四根线上电平

    A/   A    B    B/   

    0     1    0     0               第一拍

    0      0   1    0                第二拍

    1      0    0   0                第三拍

    0      0    0   1                第四拍

    4个节拍加起来就是一个完整的周期，按照这个周期给步进电机供电，则步进电机就会转动1个步距角（一个步长）。

    2.双相四拍

    双相：两边的线在工作

    A/B   AB    AB/     A/B/        正转

    时序：A/B   AB    AB/     A/B/

                1       0        0         0

                 0       1        0        0

                 0        0       1         0

                 0         0        0        1

                   A        A/        B        B/

    A/B         0          1        1          0                第一拍

    AB         1            0       1       0                  第二拍

    AB/         1          0        0          1                第三拍

    A/B/         0          1        0          1               第四拍

    3.半步八拍

    A/    A/B     B    AB    A      AB/     B/      A/B/【实际上就是单相和双相交互】

    7.控制器和驱动器

    （1）一套步进电机的系统需要三部分：控制器【控制信号】+驱动器【功率部件】+步进电机【负责转动】

    控制器

    （1）控制器就是我们的单片机

    （2）控制器负责产生时序信号

    驱动器

    （1）驱动器一般是接在单片机的IO口上面的专用的电机驱动芯片（比如我们开发板上的TC1508S）

    （2）驱动器负责将时序信号转成功率驱动信号给步进电机用

    7.结论

    我们使用的是两相步进电机

    4.开发板原理图分析说明

    1.原理图分析

    （1）原理图中INA，INB，INC，IND将来要接单片机的IO口，单片机是控制器的，通过单片机的IO口给驱动器芯片输入1或者0的控制信号，控制信号经过TC1508S的转换，从OUTA，OUTB，OUTC，OUTD四个脚输出具有驱动步进电机能力的驱动信号。【将控制信号转换为驱动信号，实际上就是将电流放大输出】

    （2）接线：比如可以用P0端口的4个引脚（实际用P0.0-P0.3)接INA，INB，INC，IND

    （3）输出端本来符号是OUTA，OUTB，OUTC，OUTD，但是开发板上实际是对应则：OA，OB，OC，OD。所以这里有一个对应关系：OUTA-OA，OUTB-OB，OUTC-OC，OUTD-OD。

    （4）但是步进电机上是A,A-,B,B-，让我们方便接线不会接错。

    （5）结合之前讲的步进电机的原理，可知：A-和A+是一个相线线圈的2端，B-和B+是另外一个线圈。

    2.电机驱动芯片数据手册

    https://datasheet.lcsc.com/lcsc/2202252130_Shenzhen-Fuman-Elec-TC1508S_C89480.pdf

    5.步进电机编程实践

    1.接线

    （1）P0端口的P0.0-P0.3接电机驱动芯片TX1508S的4个输入端

    （2）TC1508S的4个输出端接步进电机（按照丝印符号相对于即可）

    （3）根据上面的接线，实际得到的接线逻辑是：P0.0和P0.1对应的一组线圈，而且P0.2和P0.3对应另一组线圈。【注意A+对应OA，A-对应OB,B+对应OC，B-对应OD】

    2.单相四排方式驱动

    1.时序编程

    A/    B    A    B/

    1. #include
    2.  
    3. /**
    5. 	步进电机编程实践1：单相四排
    6. */
    7.  
    8. sbit APositive=P0^0;
    9. sbit ANegative=P0^1;
    10. sbit BPositive=P0^2;
    11. sbit BNegative=P0^3;
    12.  
    13. void delay(unsigned char i){  //i越大，延迟时间越大
    14. 	unsigned char a,b;
    15. 	for(a=i;a>0;a--){
    16. 		for(b=240;b>0;b--);
    17. 	}
    18. }
    19.  
    20.  
    21.  
    22. void main(){
    23.  
    24. 	while(1){
    25. 		//循环内实现1个周期
    26. 		//一个周期其实就是各个节拍依次排列构成的，注意节拍之间要延时
    27. 		//延时时间---控制速度
    28. 		//单相四拍
    29. 		//第一拍：  [A/  B    A    B/]
    30. 		//           1   0    0     0
    31. 		APositive=0;
    32. 		ANegative=1;
    33. 		BPositive=0;   //等于1也可以，只要两个相同即可
    34. 		BNegative=0;   //等于1也可以，只要两个相同即可
    35. 		delay(30);
    36. 		
    37. 		//第二拍：  [A/  B    A    B/]
    38. 		//           0   1    0     0
    39. 		APositive=0;
    40. 		ANegative=0;
    41. 		BPositive=1;   //等于1也可以，只要两个相同即可
    42. 		BNegative=0;   //等于1也可以，只要两个相同即可
    43. 		delay(30);
    44. 		
    45. 		
    46. 		//第3拍：  [A/  B    A    B/]
    47. 		//           0   0    1     0
    48. 		APositive=1;
    49. 		ANegative=0;
    50. 		BPositive=0;   //等于1也可以，只要两个相同即可
    51. 		BNegative=0;   //等于1也可以，只要两个相同即可
    52. 		delay(30);
    53. 		
    54. 		
    55. 		//第3拍：  [A/  B    A    B/]
    56. 		//           0   0    0   1
    57. 		APositive=0;
    58. 		ANegative=0;
    59. 		BPositive=0;   //等于1也可以，只要两个相同即可
    60. 		BNegative=1;   //等于1也可以，只要两个相同即可
    61. 		delay(30);
    62. 		
    63. 	}
    64. 	
    65. }
    66.

    2.转速控制

    转速是由脉冲信号控制的频率控制的，其实就是delay控制的

    延时时间越短，转速越快

    3.正转和反转

    将时序进行反转

    A   A/   B    B/

    B/   B    A/    A

    3.双相四拍方式驱动

    1. #include
    2.  
    3. /**
    5. 	步进电机编程实践2：双相四拍方式驱动
    6. */
    7.  
    8. sbit APositive=P0^0;
    9. sbit ANegative=P0^1;
    10. sbit BPositive=P0^2;
    11. sbit BNegative=P0^3;
    12.  
    13. //延时时间
    14. //延时时间越短，转速越快
    15. #define TIME 30
    16.  
    17.  
    18.  
    19. void delay(unsigned char i){  //i越大，延迟时间越大
    20. 	unsigned char a,b;
    21. 	for(a=i;a>0;a--){
    22. 		for(b=240;b>0;b--);
    23. 	}
    24. }
    25.  
    26.  
    27.  
    28. void main(){
    29.  
    30. 	while(1){
    31. 		//循环内实现1个周期
    32. 		//一个周期其实就是各个节拍依次排列构成的，注意节拍之间要延时
    33. 		//延时时间---控制速度
    34. 		//单相四拍
    35. 		
    36. 		/*
    37. 			正序旋转
    38. 			逆序就是将节拍反过来
    39. 		
    40. 		*/
    41. 		
    42. 		//第一拍：  [A/B  AB    AB/   A/B/]
    43. 		//           1   0    0     0
    44. 		APositive=0;
    45. 		ANegative=1;
    46. 		BPositive=1;   
    47. 		BNegative=0;   
    48. 		delay(TIME);
    49. 		
    50. 		//第二拍：  [A/B  AB    AB/   A/B/]
    51. 		//           0   1    0     0
    52. 		APositive=1;
    53. 		ANegative=0;
    54. 		BPositive=1;   
    55. 		BNegative=0;   
    56. 		delay(TIME);
    57. 		
    58. 		
    59. 		//第3拍：  [A/B  AB    AB/   A/B/]
    60. 		//           0   0    1     0
    61. 		APositive=1;
    62. 		ANegative=0;
    63. 		BPositive=0;   
    64. 		BNegative=1;   
    65. 		delay(TIME);
    66. 		
    67. 		
    68. 		//第3拍：  [A/B  AB    AB/   A/B/]
    69. 		//           0   0    0   1
    70. 		APositive=0;
    71. 		ANegative=1;
    72. 		BPositive=0;   
    73. 		BNegative=1;   
    74. 		delay(TIME);
    75. 		
    76. 		
    77. 	}
    78. 	
    79. }
    80.

    4.半步八拍方式驱动

    速度越慢，动力越大

    1. #include
    2.  
    3. /**
    5. 	步进电机编程实践3：半步八拍方式驱动
    6. */
    7.  
    8. sbit APositive=P0^0;
    9. sbit ANegative=P0^1;
    10. sbit BPositive=P0^2;
    11. sbit BNegative=P0^3;
    12.  
    13. //延时时间
    14. //延时时间越短，转速越快
    15. #define TIME 3
    16.  
    17.  
    18. void delay(unsigned char i){  //i越大，延迟时间越大
    19. 	unsigned char a,b;
    20. 	for(a=i;a>0;a--){
    21. 		for(b=240;b>0;b--);
    22. 	}
    23. }
    24.  
    25.  
    26.  
    27. void main(){
    28.  
    29. 	while(1){
    30. 		//循环内实现1个周期
    31. 		//一个周期其实就是各个节拍依次排列构成的，注意节拍之间要延时
    32. 		//延时时间---控制速度
    33. 		//单相四拍
    34. 		
    35. 		/*
    36. 			正序旋转
    37. 			逆序就是将节拍反过来
    38. 		
    39. 		*/
    40. 		
    41. 		//第一拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    42. 		//           1    0    0    0     0     0     0       0
    43. 		APositive=1;
    44. 		ANegative=0;
    45. 		BPositive=0;   
    46. 		BNegative=0;   
    47. 		delay(TIME);
    48. 	
    49. 		
    50. 		//第2拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    51. 		//          0   1    0    0     0     0     0       0
    52. 		APositive=0;
    53. 		ANegative=1;
    54. 		BPositive=1;   
    55. 		BNegative=0;   
    56. 		delay(TIME);
    57. 	
    58. 	
    59. 		//第3拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    60. 		//           0    0    1    0     0     0     0       0
    61. 		APositive=0;
    62. 		ANegative=0;
    63. 		BPositive=1;   
    64. 		BNegative=0;   
    65. 		delay(TIME);
    66. 	
    67. 	
    68. 			//第4拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    69. 		//           0    0    0      1     0     0     0       0
    70. 		APositive=1;
    71. 		ANegative=0;
    72. 		BPositive=1;   
    73. 		BNegative=0;   
    74. 		delay(TIME);
    75. 	
    76. 	
    77. 			//第5拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    78. 		//           0    0    0    0     1     0     0       0
    79. 		APositive=1;
    80. 		ANegative=0;
    81. 		BPositive=0;   
    82. 		BNegative=0;   
    83. 		delay(TIME);
    84. 	
    85. 	
    86. 			//第6拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    87. 		//           0    0    0    0     0     1     0       0
    88. 		APositive=1;
    89. 		ANegative=0;
    90. 		BPositive=1;   
    91. 		BNegative=1;   
    92. 		delay(TIME);
    93. 	
    94. 	
    95. 			//第7拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    96. 		//           0    0    0    0     0     0     1       0
    97. 		APositive=0;
    98. 		ANegative=0;
    99. 		BPositive=0;   
    100. 		BNegative=1;   
    101. 		delay(TIME);
    102. 	
    103. 	
    104. 	
    105. 			//第8拍：  [A   A/B   B    AB    A    AB/    B/     A/B/]
    106. 		//           0    0    0    0     0     0     0       1
    107. 		APositive=0;
    108. 		ANegative=1;
    109. 		BPositive=0;   
    110. 		BNegative=1;   
    111. 		delay(TIME);
    112.  
    113. 		
    114. 	}
    115. 	
    116. }
    117.
  • 相关阅读:
    【工业设计】设计应注意技术、情感需求和技术发展
    x64dbg 基本使用技巧
    第十四届蓝桥杯模拟赛（第二场）题解·2022年·C/C++
    串的概念及操作
    IVI车载信息娱乐系统的网络安全注意事项
    【定义】三角形行列式和对角行列式
    1、网页结构
    Linux内核（一）
    mysql颗粒归仓
    火柴拼正方形（回溯法实现）
  • 原文地址：https://blog.csdn.net/m0_63077733/article/details/133418185