菜鸟玩步进电机 与 TB6560 驱动频率的测试

hi55234

作案工具如下：
1、2相42步进电机一个（57、39啥的也可以啊）
2、TB6560驱动板一块（别问我为啥选这个，我不会告诉你是因为接线很方便、我已经不喜欢动烙铁了）
3、杜邦线导线若干，面包板一块、2.54的排针若干
4、主角：arduino pro mini一块，当然了，用其他的也可以，推荐nano，免烙铁

一、步进电机接线图（别问我为啥选2相的，说多了都是泪，2相驱动器20多元，5相驱动器100+，是穷）


问：LZ你丫倒是好，有文档知道哪组是哪组，我这没文档的怎么破？
答：

通过上图可知，A，~A 是联通的，B 和~B 是联通。那么，A 和~A 是一组a，B 和~B 是一组b。
不管是两相四相，四相五线，四相六线步进电机。内部构造都是如此。至于究竟是四线，五线，还是六线。就要看A 和~A 之间，B 和B~之间有没有公共端com抽线。如果a 组和b 组各自有一个com 端，则该步进电机六线，如果a 和b 组的公共端连在一起，则是5线的。
所以，要弄清步进电机如何接线，只需把a 组和b 组分开。用万用表打。
四线：由于四线没有com 公共抽线，所以，a 和b 组是绝对绝缘的，不连通的。所以，用万用表测，不连通的是一组。
五线：由于五线中，a 和b 组的公共端是连接在一起的。用万用表测，当发现有一根线和其他几根线的电阻是相当的，那么，这根线就是公共com 端。对于驱动五线步进电机，公共com 端不连接也是可以驱动步进电机的。
六线：a 和b 组的公共抽线com 端是不连通的。同样，用万用表测电阻，发现其中一根线和其他两根线阻止是一样的，那么这根线是com 端，另2 根线就属于一组。对于驱动四相六线步进电机，两根公共com 端不接先也可以驱动该步进电机的。

问：A+/B+ 如何区分
答：A+/B+是自己定义的，只需要区分出两个绕组 则可 。起始方向反了，调换其中一个绕组的两根接线

二：TB6560接线图
说多了都是泪，当时没注意，用的共阴接法，EN+直接接了5V，一直在脱机，从来不转动，来回折腾了我2-3小时，尼玛啊

hi55234

程序部分····················
先看一个失败的程序，原帖地址是
http://www.instructables.com/id/ ... driver/all/?lang=zh

别问我为啥要翻出这贴，我是菜鸟一个，怎么驱动都不知道，能不向前辈取经么？

失败的原因：

Connection to arduino
pin 9 (Step pin) to CLK+,
pin 8 (Dir pin) to CW+,
CLK- and CW- connect to GND arduino.
Do not connect EN+ and EN- to any ARDUINO PIN.

引脚9—— CLK+,
引脚8——CW +，
CLK——GND （Arduino）
CW -——GND （Arduino）
EN - 悬空，或者-——GND （Arduino）
EN + 悬空，或者-——GND （Arduino）【属于脱机控制引脚，高电平脱机，我的悲剧所在，低电频工作】

It only works for 1/8 step ( S3 and S4 on) and 1/16 step (S4 only on), half and full bridge does not work (for my case).
简单的讲，电机就是只能工作驱动器在1/8、1/16细分上（不是只有你，谁用你这个频率都这鸟样）

PS：理论计算，0.2ms就一个周期，一秒有5000个周期，一个周期1.8度（一般就这值），换言之这是要电机一秒转个25圈，尼玛哪个步进电机能转这么快？出问题不是明摆着的吗？

PS：实际，因为arduino运行速度问题，16M，实际脉冲也就1500-1600的样子，换言之，一秒8圈完全是不成立的，所以表现出过载堵转，电机啸叫


且看程序如下：

1. int Distance = 0; // Record the number of steps we've taken
   
2. 
   
3. void setup() {
   
4. 
   
5. pinMode(8, OUTPUT);
   
6. pinMode(9, OUTPUT);
   
7. digitalWrite(8, LOW);
   
8. digitalWrite(9, LOW);
   
9. 
   
10. }
    
11. 
    
12. void loop() {
    
13. 
    
14. digitalWrite(9, HIGH);
    
15. delayMicroseconds(100);
    
16. digitalWrite(9, LOW);
    
17. delayMicroseconds(100);
    
18. Distance = Distance + 1;
    
19. // record this step
    
20. // Check to see if we are at the end of our move
    
21. // two rotation for 1/8 bridge and 1 rotation for 1/6 bridge (for this code)
    
22. 
    
23. 
    
24. if (Distance == 3200) { // We are! Reverse direction (invert DIR signal)
    
25. if (digitalRead(8) == LOW) {
    
26. digitalWrite(8, HIGH);
    
27. }else {
    
28. digitalWrite(8, LOW);
    
29. }
    
30. // Reset our distance back to zero since we're
    
31. // starting a new move
    
32. Distance = 0; // Now pause for half a second delay(500);
    
33. }
    
34. 
    
35. }

复制代码

hi55234

程序部分2·············
既然原程序，出问题出在频率过快，电机跟不上，那么新的程序，自然是要找到合适的脉冲频率
然后拿出传说中的分贝计，开始愉快的寻找最低噪音的运行期间吧

工具：
1、i2C 1602
2、ACS712 5A看总功耗


PS：脉冲时间不在长，经测，就算5us也是足够让他转了

1. #include <Wire.h>
   
2. #include <LiquidCrystal_I2C.h>
   
3. LiquidCrystal_I2C lcd(0x26,16,2);  // I2C 1602转接板的地址
   
4. 
   
5. 
   
6. int ACS712PinPin=0;//A0读取ACS712Pin 5A的电压的针脚
   
7. int ACS712PinVal=0;//A0读取ACS712Pin 5A的电压值（0-1023）
   
8. float ACS712PinValx=0;//A0读取ACS712Pin 5A的电压（换算为mV）
   
9. int mySensVals [4];//四次取均值，待平均的值暂存数组中
   
10. int jsq1=0;//四次取均值，取到第几次的计数器
    
11. int maichongjiange=5;//脉冲间隔
    
12. 
    
13. unsigned long time1=millis();
    
14. 
    
15. 
    
16. int maichongpinlv = 0;//脉冲频率
    
17. float lilunquanshu=0;//理论圈数
    
18. 
    
19. boolean fangxiang=1;
    
20. 
    
21. void setup(){
    
22. Serial.begin(9600);
    
23. 
    
24.   lcd.init();   
    
25.   lcd.backlight();
    
26. 
    
27. pinMode(8, OUTPUT);
    
28. pinMode(9, OUTPUT);
    
29. 
    
30. digitalWrite(8, LOW);
    
31. digitalWrite(9, LOW);
    
32. }
    
33. 
    
34. 
    
35. void loop(){
    
36. 
    
37. //电流读取部分
    
38. ACS712PinVal=analogRead(ACS712PinPin);
    
39. mySensVals [jsq1]=ACS712PinVal;
    
40. jsq1++;
    
41. 
    
42. if(jsq1==4){
    
43. jsq1=0;
    
44. ACS712PinValx=(mySensVals [0]+mySensVals [1]+mySensVals [2]+mySensVals [3])*0.25;
    
45. ACS712PinValx=(ACS712PinValx*4.8-2433)*1000/185;
    
46. }
    
47. 
    
48. 
    
49. //每隔2秒，变化一次脉冲间隔，
    
50. if (millis() - time1 > 2000){
    
51. time1=millis();
    
52. 
    
53. lcd.setCursor(0, 0);
    
54. lcd.print(ACS712PinValx);
    
55. lcd.print("mA ");
    
56. 
    
57. if(maichongjiange<3000)maichongjiange=maichongjiange+10;
    
58. else maichongjiange=5;
    
59. lcd.println(maichongjiange);//
    
60. 
    
61. 
    
62. lcd.setCursor(0, 1);
    
63. lcd.print(maichongpinlv);
    
64. lcd.print(" Hz ");//
    
65. lilunquanshu=maichongpinlv/200;
    
66. lcd.print("V:");//
    
67. lcd.print(lilunquanshu);//
    
68. lcd.println(" ");//
    
69. 
    
70. maichongpinlv=0;
    
71. 
    
72. //fangxiang=!fangxiang;
    
73. //digitalWrite(8, fangxiang);
    
74.   }
    
75. 
    
76. 
    
77. 
    
78. //步进电机控制信号
    
79. digitalWrite(9, HIGH);
    
80. delayMicroseconds(maichongjiange);
    
81. digitalWrite(9, LOW);
    
82. delayMicroseconds(1000);
    
83. maichongpinlv++;
    
84. 
    
85. 
    
86. }

复制代码

hi55234

结论：日本的42电机可以很安静，47db的噪音完全可以和环境噪音相媲美，简单的说就是拿到手上，几乎听不到声音～～～关键是频率要适当，哪怕是2相，不细分，也可以相当的安静

==============================
作案工具：















==========================

测试程序

1. #include <Wire.h>
   
2. #include <LiquidCrystal_I2C.h>
   
3. LiquidCrystal_I2C lcd(0x26,16,2);  // I2C 1602转接板的地址
   
4. 
   
5. 
   
6. int ACS712PinPin=0;//A0读取ACS712Pin 5A的电压的针脚
   
7. int ACS712PinVal=0;//A0读取ACS712Pin 5A的电压值（0-1023）
   
8. float ACS712PinValx=0;//A0读取ACS712Pin 5A的电压（换算为mV）
   
9. int mySensVals [4];//四次取均值，待平均的值暂存数组中
   
10. int jsq1=0;//四次取均值，取到第几次的计数器
    
11. int maichongjiange=1500;//脉冲间隔
    
12. long pps=0;
    
13. 
    
14. unsigned long time1=millis();
    
15. long quantime=0;
    
16. 
    
17. long maichongpinlv = 0;//脉冲频率
    
18. float lilunquanshu=0;//理论圈数
    
19. 
    
20. boolean fangxiang=1;
    
21. 
    
22. void setup(){
    
23. Serial.begin(9600);
    
24. 
    
25.   lcd.init();   
    
26.   lcd.backlight();
    
27. 
    
28. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
29. pinMode(8, OUTPUT);// CW+,方向
    
30. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
31. 
    
32. digitalWrite(7, LOW);
    
33. digitalWrite(8, LOW);
    
34. digitalWrite(9, LOW);
    
35. }
    
36. 
    
37. 
    
38. void loop(){
    
39. 
    
40. //电流读取部分
    
41. ACS712PinVal=analogRead(ACS712PinPin);
    
42. mySensVals [jsq1]=ACS712PinVal;
    
43. jsq1++;
    
44. 
    
45. if(jsq1==4){
    
46. jsq1=0;
    
47. ACS712PinValx=(mySensVals [0]+mySensVals [1]+mySensVals [2]+mySensVals [3])*0.25;
    
48. ACS712PinValx=(ACS712PinValx*4.8-2433)*1000/185;
    
49. }
    
50. 
    
51. 
    
52. //每隔2秒，变化一次脉冲间隔，
    
53. //if (millis() - time1 > 3000){
    
54. 
    
55. if (maichongpinlv== 20000){ //跑100圈，计时
    
56.          
    
57. quantime=millis() - time1;
    
58.          //digitalWrite(7, HIGH);
    
59. 
    
60. 
    
61. lcd.setCursor(0, 0);
    
62. lcd.print(ACS712PinValx);
    
63. lcd.print("mA pps:");
    
64. pps=250000/maichongjiange;
    
65. lcd.println(pps);//每秒脉冲数
    
66. lcd.println("      ");//
    
67. 
    
68. 
    
69. lcd.setCursor(0, 1);
    
70. lcd.print(quantime);//多少毫秒转一圈
    
71. lcd.print("ms/r ");//
    
72. pps=maichongjiange*4;
    
73. lcd.print(pps);//一个脉冲周期的毫秒数
    
74. lcd.print("ms");
    
75. lcd.println("      ");//
    
76. 
    
77. maichongpinlv=0;
    
78. //fangxiang=!fangxiang;
    
79. //digitalWrite(8, fangxiang);
    
80. delay(5000);
    
81. 
    
82. //digitalWrite(7, LOW);
    
83. if(maichongjiange>750)maichongjiange=750;
    
84. else if(maichongjiange>375)maichongjiange=375;
    
85. else if(maichongjiange>250)maichongjiange=250;
    
86. else if(maichongjiange>188)maichongjiange=188;
    
87. else  digitalWrite(7, HIGH);//脱机，高电平有效
    
88. 
    
89. time1=millis();
    
90.   }
    
91. 
    
92. 
    
93. 
    
94. //步进电机控制信号
    
95. 
    
96. 
    
97. digitalWrite(9, HIGH);
    
98. delayMicroseconds(maichongjiange);
    
99. digitalWrite(9, LOW);
    
100. delayMicroseconds(maichongjiange);
     
101. delayMicroseconds(maichongjiange);
     
102. delayMicroseconds(maichongjiange);
     
103.                
     
104. maichongpinlv++;
     
105. 
     
106. 
     
107. }
     

复制代码

迷你强

干得漂亮。数据详实。。。。。

chqiyi

这贴实在太精彩了，文风风趣，且易懂，详实实用，绝对要顶！！！

haichaofine

也买了4个TB6560，两个57步进电机（二手）！步进电机的最大转速的确的纠结！频率太高就堵转或啸叫！当时是在MCH3上调的！曾经在百度上搜的有人说步进电机转速可以1000+，不知如何达到的！

hsr18299

hi55234 发表于 2015-2-9 10:26
结论：日本的42电机可以很安静，47db的噪音完全可以和环境噪音相媲美，简单的说就是拿到手上，几乎听不到声 ...

有試過調低工作電流對步進電機的影響嗎?

hi55234

haichaofine 发表于 2015-2-9 22:26
也买了4个TB6560，两个57步进电机（二手）！步进电机的最大转速的确的纠结！频率太高就堵转或啸叫！当时是在 ...

你的脉冲频率与步进电机的移动是同步的吗？
以1.8度的为例，只要2k hz就能达到600转每分，所以厂商给的42步进资料别说1000转，就是2500转也是可以的，至于目前圈数慢的问题，我认为还是失步太严重了，而归根到底应该控制频率有问题～～～







而我目前的数据：




我认为，是输入驱动器的频率有问题～～～即一个控制信号过去，还没操作完成，第二个控制信号就过去了～～～
直接导致了失步～～～

=====================================================

1. int maichongjiange=8000;//脉冲间隔us
   
2. 
   
3. boolean bianhua=1;
   
4. boolean baochi=0;
   
5. 
   
6. int maichongjsq=0;
   
7. 
   
8. 
   
9. unsigned long time1=micros();
   
10. unsigned long time2=micros();
    
11. unsigned long time3=millis();
    
12. 
    
13. 
    
14. boolean fangxiang=1;
    
15. 
    
16. void setup(){
    
17. Serial.begin(9600);
    
18. 
    
19. 
    
20. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
21. pinMode(8, OUTPUT);// CW+,方向
    
22. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
23. 
    
24. digitalWrite(7, LOW);
    
25. digitalWrite(8, LOW);
    
26. digitalWrite(9, LOW);
    
27. }
    
28. 
    
29. 
    
30. void loop(){
    
31. 
    
32. 
    
33. //步进电机控制脉冲
    
34. if (micros()-time2 > maichongjiange){
    
35. 
    
36.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
    
37.         maichongjsq=maichongjsq%4;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
    
38. 
    
39.         if(maichongjsq==0)digitalWrite(9, HIGH);//输出控制步进电机的电平
    
40.         else digitalWrite(9, LOW);
    
41. 
    
42.      time2= micros();
    
43. }
    
44. 
    
45. 
    
46. //步进电机加减速的控制，加减速的实质，就是缩短了控制信号的周期，每次增减 取模数的整数倍us，在此为4us
    
47. //“baochi”确保在该加减时才加减
    
48. 
    
49. if(bianhua && baochi){
    
50. 
    
51.                                 if(micros()-time1>300 && maichongjiange>100){//加速过程，xxx us加速一次，加速到 yyy为止
    
52.                 maichongjiange--;
    
53.                 time1=micros();
    
54.                 }
    
55. 
    
56.   }else if(baochi){
    
57. 
    
58.                  if(micros()-time1>300 && maichongjiange<8000){
    
59.                  maichongjiange++;
    
60.                  time1=micros();
    
61.                 }
    
62. 
    
63. }
    
64. 
    
65. 
    
66. //保持既定的速度
    
67. if(maichongjiange==100 || maichongjiange==8000){
    
68.          baochi=0;//达到既定速度后锁死，不再进行加减速
    
69. 
    
70.           if(millis()-time3>3000){ //在目标速度运行一段时间后，再解锁，并减速
    
71.                          
    
72.                          bianhua=!bianhua;
    
73.              baochi=1;
    
74.              time3=millis();
    
75.           }
    
76. 
    
77. }
    
78. 
    
79. 
    
80. //关于反向，虽然直接对引脚进行控制也是可以的，但加入一个，减速——取反——加速的过程应该更好
    
81. /*本例中，
    
82. pin7, EN+,脱机，高电平有效
    
83. pin8, CW+,方向
    
84. pin9, CLK+,频率（转速）
    
85. 已经用掉了，假设加减速、方向都由外部控制，那么很显然，就会出现2种控制方式：
    
86. A、模拟方式，即通过测量2个点电阻变化所导致的分压变化，即可实现强弱、方向的调节，具体类似于ACS712的读取，此方式可以类似于“无级变速”
    
87. B、数字方式，即通过摇杆或4个微动开关，来分别实现加减速、方向的切换
    
88. 
    
89. 就实际操作而言，速度上测电阻分压，方向上用微动开关比较合适，即用2个数字口+1个PWM口实现具体控制
    
90. */
    
91. 
    
92. 
    
93. }
    

复制代码

========================此处用easydriver代替TB6560

2呆呆

学习了{:soso_e100:}

hi55234

PPS=Pulse Per Second 秒脉冲
7、电机的共振点：————整步共振（54—60r/min）
&#160;&#160;&#160;&#160;&#160; 步进电机均有固定的共振区域，二、四相感应子式步进电机的共振区一般在180-250pps之间（步距角1.8度）或在400pps左右（步距角为0.9度），电机驱动电压越高，电机电流越大，负载越轻，电机体积越小，则共振区向上偏移，反之亦然，为使电机输出电矩大，不失步和整个系统的噪音降低，一般工作点均应偏移共振区较多。


1、现象：电机低速时振动或失步，高速时正常：这是驱动电压过高引起。
2\电机低速时正常，高速时失步：这是驱动电压过低引起。
电机长时间低速运转无发热现象（电机正常工作时可高达70至80度）驱动电流过小时，
电机工作时过热：驱动电流过大的原因。

解决方法：调节驱动器电流、驱动电压或更换驱动器。

2、
现象：电机低速或高速时不转动或者失步；负载过大。
电机起动或停止时有失步或振动；电机出力过大。
解决方法：调节驱动器电流或更换电机。

1、脉冲信号的产生。
&#160;&#160;&#160;&#160;&#160; 脉冲信号一般由单片机或CPU产生，一般脉冲信号的占空比为0.3-0.4左右，电机转速越高，占空比则越大。

4、力矩与功率换算
&#160;&#160;&#160;&#160; 步进电机一般在较大范围内调速使用、其功率是变化的，一般只用力矩来衡量，力矩与功率换算如下：
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; P= Ω·M
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; Ω=2π·n/60
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; P=2πnM/60
&#160;&#160;&#160; 其P为功率单位为瓦，Ω为每秒角速度，单位为弧度，n为每分钟转速，M为力矩单位为牛顿·米
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160; P=2πfM/400(半步工作）
&#160;&#160;&#160;&#160; 其中f为每秒脉冲数（简称PPS)

(二）、应用中的注意点
&#160;&#160;&#160;&#160;&#160; 1、步进电机应用于低速场合---每分钟转速不超过1000转，（0.9度时6666PPS)，最好在1000-3000PPS(0.9度）间使用，可通过减速装置使其在此间工作，此时电机工作效率高，噪音低。
&#160;&#160;&#160;&#160;&#160; 2、步进电机最好不使用整步状态，整步状态时振动大。

&#160; 5、电机在较高速或大惯量负载时，一般不在工作速度起动，而采用逐渐升频提速，一电机不失步，二可以减少噪音同时可以提高停止的定位精度。

7、电机不应在振动区内工作，如若必须可通过改变电压、电流或加一些阻尼的解决。
&#160;&#160;&#160;&#160;&#160; 8、电机在600PPS（0.9度）以下工作，应采用小电流、大电感、低电压来驱动。

hi55234

1. #include <Wire.h>
   
2. #include <LiquidCrystal_I2C.h>
   
3. LiquidCrystal_I2C lcd(0x26,16,2);  // I2C 1602转接板的地址
   
4. 
   
5. 
   
6. int ACS712PinPin=0;//A0读取ACS712Pin 5A的电压的针脚
   
7. int ACS712PinVal=0;//A0读取ACS712Pin 5A的电压值（0-1023）
   
8. long ACS712PinValx=0;//A0读取ACS712Pin 5A的电压（换算为mV）
   
9. int mySensVals[10];//四次取均值，待平均的值暂存数组中
   
10. int jsq1=0;//四次取均值，取到第几次的计数器
    
11. int maichongjiange=100;//脉冲间隔
    
12. long pps=0;
    
13. 
    
14. int maichongjsq=0;
    
15. 
    
16. int jsq3=0;
    
17. 
    
18. unsigned long time1=millis();
    
19. unsigned long time2=micros();
    
20. unsigned long time3=millis();
    
21. long quantime=0;
    
22. 
    
23. long maichongpinlv = 0;//脉冲频率
    
24. float lilunquanshu=0;//理论圈数
    
25. 
    
26. boolean fangxiang=1;
    
27. 
    
28. void setup(){
    
29. Serial.begin(9600);
    
30. 
    
31.   lcd.init();   
    
32.   lcd.backlight();
    
33. 
    
34. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
35. pinMode(8, OUTPUT);// CW+,方向
    
36. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
37. 
    
38. digitalWrite(7, LOW);
    
39. digitalWrite(8, LOW);
    
40. digitalWrite(9, LOW);
    
41. }
    
42. 
    
43. 
    
44. void loop(){
    
45. 
    
46.   //电流读取部分
    
47. ACS712PinVal=analogRead(ACS712PinPin);
    
48. mySensVals[jsq1]=ACS712PinVal;
    
49. jsq1++;
    
50. 
    
51. 
    
52. if(jsq1==10){
    
53. jsq1=0;
    
54. time1=millis()-time1;
    
55. ACS712PinValx=(mySensVals[0]+mySensVals[1]+mySensVals[2]+mySensVals[3]+mySensVals[4]+mySensVals[5]+mySensVals[6]+mySensVals[7]+mySensVals[8]+mySensVals[9])*0.1;
    
56. ACS712PinValx=(ACS712PinValx-455)*4.69*1000/185;
    
57. 
    
58.   Serial.println(ACS712PinValx);//-1234
    
59. 
    
60. /*
    
61. 1、497是acs712在不通电时的所取到的模拟值，每个值代表（vcc-GND）/1023 mv
    
62. 2、4.69=（vcc-GND）/1023，因为实测只有4.88v的样子
    
63. 3、acs712 5A ，是每185mv/A,所以每mv表示1000/185 mA
    
64. */
    
65.          //digitalWrite(7, HIGH);
    
66. 
    
67.   }
    
68.   
    
69. 
    
70. /*  步进电机控制信号
    
71. High-----------| Low-----------|  Low-----------|  Low-----------|
    
72. maichongjiange | maichongjiange| maichongjiange | maichongjiange |
    
73. 
    
74. */
    
75. 
    
76. if (micros()-time2 > maichongjiange){
    
77.          
    
78.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
    
79.         maichongjsq=maichongjsq%4;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
    
80. 
    
81. 
    
82. if(maichongjsq==0)digitalWrite(9, HIGH);
    
83. else digitalWrite(9, LOW);
    
84. 
    
85.   
    
86.         time2= micros();
    
87. }
    
88. 
    
89. 
    
90. 
    
91. 
    
92. }
    

复制代码

hi55234

慢速——保持3s——平滑加速——快速——保持3s  循环

PS：i2c 1602 打印速度慢，延迟会导致电机转速慢，且不顺畅（破坏了脉冲频率）

1. 
   
2. int maichongjiange=8000;//脉冲间隔us
   
3. 
   
4. boolean bianhua=1;
   
5. boolean baochi=0;
   
6. 
   
7. int maichongjsq=0;
   
8. 
   
9. 
   
10. unsigned long time1=micros();
    
11. unsigned long time2=micros();
    
12. unsigned long time3=millis();
    
13. 
    
14. 
    
15. boolean fangxiang=1;
    
16. 
    
17. void setup(){
    
18. Serial.begin(9600);
    
19. 
    
20. 
    
21. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
22. pinMode(8, OUTPUT);// CW+,方向
    
23. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
24. 
    
25. digitalWrite(7, LOW);
    
26. digitalWrite(8, LOW);
    
27. digitalWrite(9, LOW);
    
28. }
    
29. 
    
30. 
    
31. void loop(){
    
32. 
    
33. 
    
34. if (micros()-time2 > maichongjiange){
    
35.          
    
36.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
    
37.         maichongjsq=maichongjsq%4;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
    
38. 
    
39. 
    
40. if(maichongjsq==0)digitalWrite(9, HIGH);
    
41. else digitalWrite(9, LOW);
    
42. 
    
43.   
    
44.         time2= micros();
    
45. }
    
46. 
    
47. 
    
48. 
    
49. 
    
50. 
    
51. if(bianhua && baochi){
    
52.          
    
53.                 if(micros()-time1>300 && maichongjiange>100){
    
54.                 maichongjiange--;
    
55.                 time1=micros();
    
56.                 }
    
57. 
    
58.   }else if(baochi){
    
59.        
    
60.                  if(micros()-time1>300 && maichongjiange<8000){
    
61.   maichongjiange++;
    
62.   time1=micros();
    
63.         }
    
64. 
    
65. }
    
66. 
    
67. 
    
68. if(maichongjiange==100 || maichongjiange==8000){
    
69.          bianhua=!bianhua;
    
70.          baochi=0;
    
71. 
    
72. if(millis()-time3>3000){
    
73.          
    
74. baochi=1;
    
75. time3=millis();
    
76. }
    
77. 
    
78. }
    
79. 
    
80. 
    
81. 
    
82. 
    
83. }
    
84. 
    

复制代码

hi55234

针对9楼的接法，一个可变电阻+2个微动的程序

1. 
   
2. //电机的高电平持续时间 us
   
3. int maichongjiangeMax=8000;
   
4. int maichongjiangeMin=100;
   
5. long maichongjiangeSet;
   
6. 
   
7. //电机的高电平持续时间的初始值 8000us
   
8. int maichongjiange=8000;
   
9. 
   
10. //脉冲的占空比为1/maichongzhankongbi
    
11. int maichongzhankongbi=4;
    
12. 
    
13. //加减速时速度每隔300us变化一次
    
14. int jiajiansubianhuashijian=300;
    
15. 
    
16. 
    
17. ////////////////////////////////////////////
    
18. 
    
19. int Pinval;//存储IO口（Pin5、Pin6）高低电平的值
    
20. 
    
21. boolean fangxiang=0;//电机转动方向标识
    
22. int maichongjsq=0;//脉冲计数器
    
23. 
    
24. 
    
25. unsigned long time1=micros();
    
26. unsigned long time2=micros();
    
27. 
    
28. 
    
29. void setup(){
    
30. 
    
31. Serial.begin(9600);
    
32. 
    
33. //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向） 输入状态，就读取值来确定电机的转动方向
    
34. pinMode(5, INPUT);  
    
35. pinMode(6, INPUT);  
    
36. 
    
37. /*
    
38. 暂定A0 analogRead（0）的值来确定转速
    
39. 为方便演示，此处为使用1K 多圈精密可调电阻，A0就接在中间脚上
    
40. 那么可见，其电压大致为0-5v之间，现在就电压区间进行分级
    
41. 如果粗分为10档，就意味着每100个返回单位对应10%的速度
    
42. */
    
43. 
    
44. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
45. pinMode(8, OUTPUT);// CW+,方向
    
46. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
47. 
    
48. digitalWrite(7, LOW);//电机默认联机
    
49. digitalWrite(8, LOW);//
    
50. digitalWrite(9, LOW);
    
51. }
    
52. 
    
53. 
    
54. void loop(){
    
55. 
    
56. 
    
57. 
    
58. 
    
59. //转速调节,通过可变电阻实现无极调速
    
60.   
    
61.   //可能是读取过于频繁，导致夹杂着无效数值，所以此处做个循环
    
62.   do
    
63.   {
    
64. maichongjiangeSet = analogRead(0);//0-1023
    
65. }while(maichongjiangeSet >1024);
    
66.   
    
67.   maichongjiangeSet = maichongjiangeSet*(maichongjiangeMax-maichongjiangeMin)/1024+maichongjiangeMin;//0-1023
    
68. 
    
69. 
    
70. //加速过程
    
71. while(maichongjiange>maichongjiangeSet){
    
72.   jiasu();
    
73.   maichongqudong();
    
74.   }
    
75. 
    
76.   //加减过程
    
77. while(maichongjiange<maichongjiangeSet){
    
78.   jiansu();
    
79.   maichongqudong();
    
80.   }
    
81. 
    
82. //在脉冲频率无变化的时候驱动电机正常运行
    
83. maichongqudong();
    
84. 
    
85. 
    
86. fangxiangchange(); //转动方向的切换
    
87. 
    
88. 
    
89. }
    
90. 
    
91. 
    
92. 
    
93. 
    
94. 
    
95. 
    
96. void jiasu() //脉冲加速过程
    
97. {
    
98. 
    
99. if(micros()-time1>jiajiansubianhuashijian && maichongjiange>maichongjiangeMin){//加速过程，xxx us加速一次，加速到 yyy为止
    
100. maichongjiange--;
     
101. time1=micros();
     
102. }
     
103. 
     
104. }
     
105. 
     
106. void jiansu()//脉冲减速过程
     
107. {
     
108. 
     
109. if(micros()-time1>jiajiansubianhuashijian && maichongjiange<maichongjiangeMax){
     
110. maichongjiange++;
     
111. time1=micros();
     
112. }
     
113. 
     
114. }
     
115. 
     
116. 
     
117. void maichongqudong()//脉冲驱动
     
118. {
     
119. 
     
120. 
     
121. 
     
122. //步进电机控制脉冲
     
123. if (micros()-time2 > maichongjiange){
     
124. 
     
125.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
126.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
127. 
     
128.         if(maichongjsq==0)digitalWrite(9, HIGH);//输出控制步进电机的电平
     
129.         else digitalWrite(9, LOW);
     
130. 
     
131.      time2= micros();
     
132. }
     
133. 
     
134. }
     
135. 
     
136. 
     
137. void fangxiangchange() //转动方向的切换
     
138. {
     
139. 
     
140. 
     
141. 
     
142.   //关于反向，虽然直接对引脚进行控制也是可以的，但加入一个，减速——取反——加速的过程应该更好
     
143. /*本例中，
     
144. pin7, EN+,脱机，高电平有效
     
145. pin8, CW+,方向
     
146. pin9, CLK+,频率（转速）
     
147. 已经用掉了，假设加减速、方向都由外部控制，那么很显然，就会出现2种控制方式：
     
148. A、模拟方式，即通过测量2个点电阻变化所导致的分压变化，即可实现强弱、方向的调节，具体类似于ACS712的读取，此方式可以类似于“无级变速”
     
149. B、数字方式，即通过摇杆或4个微动开关，来分别实现加减速、方向的切换
     
150. 
     
151. 就实际操作而言，速度上测电阻分压，方向上用微动开关比较合适，即用2个数字口+1个PWM口实现具体控制
     
152. */
     
153. 
     
154. Pinval = digitalRead(5);  //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
155. 
     
156. if(Pinval==1 && fangxiang){ //有效高电平且现在电机转速与设置相反
     
157. 
     
158. //1、把速度降到最低
     
159. while(maichongjiange<maichongjiangeMax){
     
160. jiansu();
     
161. maichongqudong();
     
162.     }
     
163. //2、反方向
     
164. digitalWrite(8, LOW);
     
165. //3、记录新的方向
     
166. fangxiang=0;
     
167. //4、在把速度加到原来值
     
168. while(maichongjiange<maichongjiangeSet){
     
169. jiasu();
     
170. maichongqudong();
     
171.     }
     
172. 
     
173. }
     
174. 
     
175. Pinval = digitalRead(6);  //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
176. 
     
177. if(Pinval==1 && !fangxiang){ //有效高电平且现在电机转速与设置相反
     
178. 
     
179. //1、把速度降到最低
     
180. while(maichongjiange<maichongjiangeMax){
     
181. jiansu();
     
182. maichongqudong();
     
183.     }
     
184. //2、反方向
     
185. digitalWrite(8, HIGH);
     
186. //3、记录新的方向
     
187. fangxiang=1;
     
188. //4、在把速度加到原来值
     
189. while(maichongjiange<maichongjiangeSet){
     
190. jiasu();
     
191. maichongqudong();
     
192.     }
     
193. 
     
194. }
     
195. 
     
196. 
     
197. 
     
198. 
     
199. }
     
200. 
     
201. 
     
202. 
     

复制代码

  maichongjiangeSet = maichongjiangeSet*(maichongjiangeMax-maichongjiangeMin)/1024+maichongjiangeMin
转速=1000000*1.8/maichongjiangeSet


在说一下这个程序的特色，即分压阻值与转速是幂函数，即转速=1/（a*R+b），

类似于下图：X轴是阻值，Y轴是转速



简单来说，就是虽然阻值的变化是线性的，但速度的增加却是指数型的
具体来说就是，开始的时候，速度变化很快，而后变化越发的不明显
这个对手动调节来说，恐怕不是很舒服，所以解决方式为：
1、对阻值与速度进行手工映射
2、修改速度与阻值的对应关系

1. 
   
2. //电机的高电平持续时间 us
   
3. int maichongjiangeMax=3584;
   
4. int maichongjiangeMin=207;
   
5. long maichongjiangeSet;
   
6. 
   
7. //电机的高电平持续时间的初始值 8000us
   
8. int maichongjiange=8000;
   
9. 
   
10. //脉冲的占空比为1/maichongzhankongbi
    
11. int maichongzhankongbi=4;
    
12. 
    
13. //加减速时速度每隔300us变化一次
    
14. int jiajiansubianhuashijian=100;
    
15. 
    
16. 
    
17. ////////////////////////////////////////////
    
18. 
    
19. int Pinval;//存储IO口（Pin5、Pin6）高低电平的值
    
20. 
    
21. boolean fangxiang=0;//电机转动方向标识
    
22. int maichongjsq=0;//脉冲计数器
    
23. 
    
24. 
    
25. unsigned long time1=micros();
    
26. unsigned long time2=micros();
    
27. 
    
28. 
    
29. void setup(){
    
30. 
    
31. Serial.begin(9600);
    
32. 
    
33. //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向） 输入状态，就读取值来确定电机的转动方向
    
34. pinMode(5, INPUT);  
    
35. pinMode(6, INPUT);  
    
36. 
    
37. /*
    
38. 暂定A0 analogRead（0）的值来确定转速
    
39. 为方便演示，此处为使用1K 多圈精密可调电阻，A0就接在中间脚上
    
40. 那么可见，其电压大致为0-5v之间，现在就电压区间进行分级
    
41. 如果粗分为10档，就意味着每100个返回单位对应10%的速度
    
42. */
    
43. 
    
44. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
45. pinMode(8, OUTPUT);// CW+,方向
    
46. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
47. 
    
48. digitalWrite(7, LOW);//电机默认联机
    
49. digitalWrite(8, LOW);//
    
50. digitalWrite(9, LOW);
    
51. }
    
52. 
    
53. 
    
54. void loop(){
    
55. 
    
56. 
    
57. 
    
58. 
    
59. //转速调节,通过可变电阻实现无极调速
    
60.   
    
61.   //可能是读取过于频繁，导致夹杂着无效数值，所以此处做个循环
    
62.   do
    
63.   {
    
64. maichongjiangeSet = analogRead(0);//0-1023
    
65. }while(maichongjiangeSet >1024);
    
66.   
    
67. //被注释掉的，其起转速随测试点的电压降低而成指数增加，简单的说就是不好控制，开始太慢，之后激增
    
68. // maichongjiangeSet = maichongjiangeSet*(maichongjiangeMax-maichongjiangeMin)/1024+maichongjiangeMin;//0-1023
    
69. //映射表 28段
    
70. /*
    
71. 1/2细分                                                        对应分压
    
72. R/min        步/s        us/步 占空比25%        序号        1024
    
73. 180         1200         833         208         1        922
    
74. 162         1080         926         231         2        829
    
75. 146         972         1029         257         3        746
    
76. 131         875         1143         286         4        672
    
77. 118         787         1270         318         5        605
    
78. 106         709         1411         353         6        544
    
79. 96                 638         1568         392         7        490
    
80. 86                 574         1742         436         8        441
    
81. 77                 517         1936         484         9        397
    
82. 70                 465         2151         538         10        357
    
83. 63                 418         2390         597         11        321
    
84. 56                 377         2656         664         12        289
    
85. 51                 339         2951         738         13        260
    
86. 46                 305         3278         820         14        234
    
87. 41                 275         3643         911         15        211
    
88. 37                 247         4047         1012         16        190
    
89. 33                 222         4497         1124         17        171
    
90. 30                 200         4997         1249         18        154
    
91. 27                 180         5552         1388         19        138
    
92. 24                 162         6169         1542         20        124
    
93. 22                 146         6854         1714         21        112
    
94. 20                 131         7616         1904         22        101
    
95. 18                 118         8462         2116         23        91
    
96. 16                 106         9402         2351         24        82
    
97. 14                 96                 10447         2612         25        74
    
98. 13                 86                 11608         2902         26        66
    
99. 12                 78                 12898         3224         27        60
    
100. 10                 70                 14331         3583         28        54
     
101. 
     
102. */
     
103. if(maichongjiangeSet>922)maichongjiangeSet=208;
     
104. else if(maichongjiangeSet>829)maichongjiangeSet=231;
     
105. else if(maichongjiangeSet>746)maichongjiangeSet=257;
     
106. else if(maichongjiangeSet>672)maichongjiangeSet=282;
     
107. else if(maichongjiangeSet>605)maichongjiangeSet=318;
     
108. else if(maichongjiangeSet>544)maichongjiangeSet=353;
     
109. else if(maichongjiangeSet>490)maichongjiangeSet=392;
     
110. else if(maichongjiangeSet>441)maichongjiangeSet=436;
     
111.   else if(maichongjiangeSet>397)maichongjiangeSet=484;
     
112.   else if(maichongjiangeSet>357)maichongjiangeSet=538;
     
113.   else if(maichongjiangeSet>321)maichongjiangeSet=597;
     
114.   else if(maichongjiangeSet>289)maichongjiangeSet=664;
     
115.   else if(maichongjiangeSet>260)maichongjiangeSet=738;
     
116.   else if(maichongjiangeSet>234)maichongjiangeSet=820;
     
117.    else if(maichongjiangeSet>211)maichongjiangeSet=911;
     
118.    else if(maichongjiangeSet>190)maichongjiangeSet=1012;
     
119.     else if(maichongjiangeSet>171)maichongjiangeSet=1124;
     
120.         else if(maichongjiangeSet>154)maichongjiangeSet=1249;
     
121.         else if(maichongjiangeSet>138)maichongjiangeSet=1388;
     
122.         else if(maichongjiangeSet>124)maichongjiangeSet=1542;
     
123.         else if(maichongjiangeSet>112)maichongjiangeSet=1714;
     
124.         else if(maichongjiangeSet>101)maichongjiangeSet=1904;
     
125.         else if(maichongjiangeSet>91)maichongjiangeSet=2116;
     
126.         else if(maichongjiangeSet>82)maichongjiangeSet=2351;
     
127.         else if(maichongjiangeSet>74)maichongjiangeSet=2612;
     
128.         else if(maichongjiangeSet>66)maichongjiangeSet=2902;
     
129.         else if(maichongjiangeSet>60)maichongjiangeSet=3224;
     
130.         else maichongjiangeSet=3583;
     
131. //min
     
132. 
     
133. 
     
134. 
     
135. 
     
136. 
     
137. 
     
138. 
     
139. //加速过程
     
140. while(maichongjiange>maichongjiangeSet){
     
141.   jiasu();
     
142.   maichongqudong();
     
143.   }
     
144. 
     
145.   //加减过程
     
146. while(maichongjiange<maichongjiangeSet){
     
147.   jiansu();
     
148.   maichongqudong();
     
149.   }
     
150. 
     
151. //在脉冲频率无变化的时候驱动电机正常运行
     
152. maichongqudong();
     
153. 
     
154. 
     
155. fangxiangchange(); //转动方向的切换
     
156. 
     
157. 
     
158. }
     
159. 
     
160. 
     
161. 
     
162. 
     
163. 
     
164. 
     
165. void jiasu() //脉冲加速过程
     
166. {
     
167. 
     
168. if(micros()-time1>jiajiansubianhuashijian && maichongjiange>maichongjiangeMin){//加速过程，xxx us加速一次，加速到 yyy为止
     
169. maichongjiange--;
     
170. time1=micros();
     
171. }
     
172. 
     
173. }
     
174. 
     
175. void jiansu()//脉冲减速过程
     
176. {
     
177. 
     
178. if(micros()-time1>jiajiansubianhuashijian && maichongjiange<maichongjiangeMax){
     
179. maichongjiange++;
     
180. time1=micros();
     
181. }
     
182. 
     
183. }
     
184. 
     
185. 
     
186. void maichongqudong()//脉冲驱动
     
187. {
     
188. 
     
189. 
     
190. 
     
191. //步进电机控制脉冲
     
192. if (micros()-time2 > maichongjiange){
     
193. 
     
194.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
195.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
196. 
     
197.         if(maichongjsq==0)digitalWrite(9, HIGH);//输出控制步进电机的电平
     
198.         else digitalWrite(9, LOW);
     
199. 
     
200.      time2= micros();
     
201. }
     
202. 
     
203. }
     
204. 
     
205. 
     
206. void fangxiangchange() //转动方向的切换
     
207. {
     
208. 
     
209. 
     
210. 
     
211.   //关于反向，虽然直接对引脚进行控制也是可以的，但加入一个，减速——取反——加速的过程应该更好
     
212. /*本例中，
     
213. pin7, EN+,脱机，高电平有效
     
214. pin8, CW+,方向
     
215. pin9, CLK+,频率（转速）
     
216. 已经用掉了，假设加减速、方向都由外部控制，那么很显然，就会出现2种控制方式：
     
217. A、模拟方式，即通过测量2个点电阻变化所导致的分压变化，即可实现强弱、方向的调节，具体类似于ACS712的读取，此方式可以类似于“无级变速”
     
218. B、数字方式，即通过摇杆或4个微动开关，来分别实现加减速、方向的切换
     
219. 
     
220. 就实际操作而言，速度上测电阻分压，方向上用微动开关比较合适，即用2个数字口+1个PWM口实现具体控制
     
221. */
     
222. 
     
223. Pinval = digitalRead(5);  //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
224. 
     
225. if(Pinval==1 && fangxiang){ //有效高电平且现在电机转速与设置相反
     
226. 
     
227. //1、把速度降到最低
     
228. while(maichongjiange<maichongjiangeMax){
     
229. jiansu();
     
230. maichongqudong();
     
231.     }
     
232. //2、反方向
     
233. digitalWrite(8, LOW);
     
234. //3、记录新的方向
     
235. fangxiang=0;
     
236. //4、在把速度加到原来值
     
237. while(maichongjiange<maichongjiangeSet){
     
238. jiasu();
     
239. maichongqudong();
     
240.     }
     
241. 
     
242. }
     
243. 
     
244. Pinval = digitalRead(6);  //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
245. 
     
246. if(Pinval==1 && !fangxiang){ //有效高电平且现在电机转速与设置相反
     
247. 
     
248. //1、把速度降到最低
     
249. while(maichongjiange<maichongjiangeMax){
     
250. jiansu();
     
251. maichongqudong();
     
252.     }
     
253. //2、反方向
     
254. digitalWrite(8, HIGH);
     
255. //3、记录新的方向
     
256. fangxiang=1;
     
257. //4、在把速度加到原来值
     
258. while(maichongjiange<maichongjiangeSet){
     
259. jiasu();
     
260. maichongqudong();
     
261.     }
     
262. 
     
263. }
     
264. 
     
265. 
     
266. 
     
267. 
     
268. }
     
269. 
     
270. 
     
271. 
     

复制代码

但映射版也有问题：
1、就实际感知而言，初期确实有点慢，人的感官也远不数字精确，依旧觉得前期慢，后期快
2、多圈的精密电阻，却是太难调节了

所以，具体的映射恐怕还要修改

hi55234

尼玛只要把电阻分压对应到圈/每秒上，就能实现感官上的无极调速
我TM前面的程序怎么写成对应周期长度了

1. 
   
2. //电机的高电平持续时间 us
   
3. int maichongjiangeMax=1260;
   
4. int maichongjiangeMin=120;
   
5. long maichongjiangeSet;
   
6. 
   
7. //电机的高电平持续时间的初始值 0us
   
8. int maichongjiange=0;
   
9. 
   
10. //脉冲的占空比为1/maichongzhankongbi
    
11. int maichongzhankongbi=4;
    
12. 
    
13. //加减速时速度每隔300us变化一次
    
14. int jiajiansubianhuashijian=300;
    
15. 
    
16. 
    
17. ////////////////////////////////////////////
    
18. 
    
19. int Pinval;//存储IO口（Pin5、Pin6）高低电平的值
    
20. 
    
21. boolean fangxiang=0;//电机转动方向标识
    
22. int maichongjsq=0;//脉冲计数器
    
23. 
    
24. 
    
25. unsigned long time1=micros();
    
26. unsigned long time2=micros();
    
27. 
    
28. 
    
29. void setup(){
    
30. 
    
31. Serial.begin(9600);
    
32. 
    
33. //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向） 输入状态，就读取值来确定电机的转动方向
    
34. pinMode(5, INPUT);
    
35. pinMode(6, INPUT);
    
36. 
    
37. /*
    
38. 暂定A0 analogRead（0）的值来确定转速
    
39. 为方便演示，此处为使用1K 多圈精密可调电阻，A0就接在中间脚上
    
40. 那么可见，其电压大致为0-5v之间，现在就电压区间进行分级
    
41. 如果粗分为10档，就意味着每100个返回单位对应10%的速度
    
42. */
    
43. 
    
44. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
45. pinMode(8, OUTPUT);// CW+,方向
    
46. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
47. 
    
48. digitalWrite(7, LOW);//电机默认联机
    
49. digitalWrite(8, LOW);//
    
50. digitalWrite(9, LOW);
    
51. }
    
52. 
    
53. 
    
54. void loop(){
    
55. 
    
56. 
    
57. 
    
58. 
    
59. //转速调节,通过可变电阻实现无极调速
    
60. 
    
61. //可能是读取过于频繁，导致夹杂着无效数值，所以此处做个循环
    
62. do
    
63. {
    
64. maichongjiangeSet = analogRead(0);//0-1023
    
65. }while(maichongjiangeSet >1024);
    
66. 
    
67. // 25% us =1000,000/(圈/每秒*400*4)=625/(0.5【min】+4.5×analogRead(0)/1024)
    
68. //即把电压线性到转速上
    
69. maichongjiangeSet = 625/(0.5+4.5*maichongjiangeSet/1024);//0-1023
    
70. 
    
71. 
    
72. //加速过程
    
73. while(maichongjiange>maichongjiangeSet){
    
74. jiasu();
    
75. maichongqudong();
    
76. }
    
77. 
    
78. //加减过程
    
79. while(maichongjiange<maichongjiangeSet){
    
80. jiansu();
    
81. maichongqudong();
    
82. }
    
83. 
    
84. //在脉冲频率无变化的时候驱动电机正常运行
    
85. maichongqudong();
    
86. 
    
87. 
    
88. fangxiangchange(); //转动方向的切换
    
89. 
    
90. 
    
91. }
    
92. 
    
93. 
    
94. 
    
95. 
    
96. 
    
97. 
    
98. void jiasu() //脉冲加速过程
    
99. {
    
100. 
     
101. if(micros()-time1>jiajiansubianhuashijian && maichongjiange>maichongjiangeMin){//加速过程，xxx us加速一次，加速到 yyy为止
     
102. maichongjiange--;
     
103. time1=micros();
     
104. }
     
105. 
     
106. }
     
107. 
     
108. void jiansu()//脉冲减速过程
     
109. {
     
110. 
     
111. if(micros()-time1>jiajiansubianhuashijian && maichongjiange<maichongjiangeMax){
     
112. maichongjiange++;
     
113. time1=micros();
     
114. }
     
115. 
     
116. }
     
117. 
     
118. 
     
119. void maichongqudong()//脉冲驱动
     
120. {
     
121. 
     
122. 
     
123. 
     
124. //步进电机控制脉冲
     
125. if (micros()-time2 > maichongjiange){
     
126. 
     
127. maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
128. maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
129. 
     
130. if(maichongjsq==0)digitalWrite(9, HIGH);//输出控制步进电机的电平
     
131. else digitalWrite(9, LOW);
     
132. 
     
133. time2= micros();
     
134. }
     
135. 
     
136. }
     
137. 
     
138. 
     
139. void fangxiangchange() //转动方向的切换
     
140. {
     
141. 
     
142. 
     
143. 
     
144. //关于反向，虽然直接对引脚进行控制也是可以的，但加入一个，减速——取反——加速的过程应该更好
     
145. /*本例中，
     
146. pin7, EN+,脱机，高电平有效
     
147. pin8, CW+,方向
     
148. pin9, CLK+,频率（转速）
     
149. 已经用掉了，假设加减速、方向都由外部控制，那么很显然，就会出现2种控制方式：
     
150. A、模拟方式，即通过测量2个点电阻变化所导致的分压变化，即可实现强弱、方向的调节，具体类似于ACS712的读取，此方式可以类似于“无级变速”
     
151. B、数字方式，即通过摇杆或4个微动开关，来分别实现加减速、方向的切换
     
152. 
     
153. 就实际操作而言，速度上测电阻分压，方向上用微动开关比较合适，即用2个数字口+1个PWM口实现具体控制
     
154. */
     
155. 
     
156. Pinval = digitalRead(5); //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
157. 
     
158. if(Pinval==1 && fangxiang){ //有效高电平且现在电机转速与设置相反
     
159. 
     
160. //1、把速度降到最低
     
161. while(maichongjiange<maichongjiangeMax){
     
162. jiansu();
     
163. maichongqudong();
     
164. }
     
165. //2、反方向
     
166. digitalWrite(8, LOW);
     
167. //3、记录新的方向
     
168. fangxiang=0;
     
169. //4、在把速度加到原来值
     
170. while(maichongjiange<maichongjiangeSet){
     
171. jiasu();
     
172. maichongqudong();
     
173. }
     
174. 
     
175. }
     
176. 
     
177. Pinval = digitalRead(6); //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
178. 
     
179. if(Pinval==1 && !fangxiang){ //有效高电平且现在电机转速与设置相反
     
180. 
     
181. //1、把速度降到最低
     
182. while(maichongjiange<maichongjiangeMax){
     
183. jiansu();
     
184. maichongqudong();
     
185. }
     
186. //2、反方向
     
187. digitalWrite(8, HIGH);
     
188. //3、记录新的方向
     
189. fangxiang=1;
     
190. //4、在把速度加到原来值
     
191. while(maichongjiange<maichongjiangeSet){
     
192. jiasu();
     
193. maichongqudong();
     
194. }
     
195. 
     
196. }
     
197. 
     
198. 
     
199. 
     
200. 
     
201. }
     
202. 
     
203. 
     

复制代码

25% 周期长度us——步进电机的分贝数