蛋疼的机翻 AccelStepper Class Reference 【步进电机库】

囧囧-科技大神粉

囧囧-科技大神粉 发表于 2015-2-16 15:38
maichongjiangeSet = maichongjiangeSet*(maichongjiangeMax-maichongjiangeMin)/1024+maichongjiang ...

尼玛只要把电阻分压对应到圈/每秒上，就能实现感官上的无极调速
我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. 
     
204. 
     

复制代码

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

囧囧-科技大神粉

囧囧-科技大神粉 发表于 2015-2-16 15:38

现在，如果用摇杆代替微动按钮与电位器
则所需端口由2个数字口加一个模拟口，变成了2个模拟口

而程序的相应变化则在于


a，速度调节方式，若源用原程序不变，则会导致

1，速度一开始就是中位数，初始速度是否过快
2，一旦放手，则在自回复的情况下，速度又会回到原速


b，转动方向上，必须分段以应对，即电压低于某区间
则为方向1，高于某电压则为方向2，一次解决摇杆
初始状态不在中间的问题
，，，，，，，，分割线，，，，，，，，，

具体做法，现定义a0接y轴控制速度，a1接x轴控制

方向


//a0

maichongjiangeSet = analogRead(0)*(maichongjiangeMax-maichongjiangeMin)/1000+maichongjiangeMin;//0-1023


//a1  大致思想就这样，当然还缺乏平滑处理
int  pinval2＝analogRead(1);
if(pinval2＞700)fangxiang＝0;
else  if(pinval2＜300)fangxiang＝1;

囧囧-科技大神粉

囧囧-科技大神粉 发表于 2015-2-14 23:36
囧囧-科技大神粉========================此处用easydriver代替TB6560

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、多圈的精密电阻，却是太难调节了

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

囧囧-科技大神粉

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

囧囧-科技大神粉

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

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

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. if (micros()-time2 > maichongjiange){
    
34. 
    
35.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
    
36.         maichongjsq=maichongjsq%4;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
    
37. 
    
38. 
    
39. if(maichongjsq==0)digitalWrite(9, HIGH);
    
40. else digitalWrite(9, LOW);
    
41. 
    
42. 
    
43.          time2= micros();
    
44. }
    
45. 
    
46. 
    
47. 
    
48. 
    
49. 
    
50. if(bianhua && baochi){
    
51. 
    
52.                 if(micros()-time1>300 && maichongjiange>100){
    
53.                 maichongjiange--;
    
54.                 time1=micros();
    
55.                 }
    
56. 
    
57.   }else if(baochi){
    
58. 
    
59.                  if(micros()-time1>300 && maichongjiange<8000){
    
60.   maichongjiange++;
    
61.   time1=micros();
    
62.         }
    
63. 
    
64. }
    
65. 
    
66. 
    
67. if(maichongjiange==100 || maichongjiange==8000){
    
68.          bianhua=!bianhua;
    
69.          baochi=0;
    
70. 
    
71. if(millis()-time3>3000){
    
72. 
    
73. baochi=1;
    
74. time3=millis();
    
75. }
    
76. 
    
77. }
    
78. 
    
79. 
    
80. 
    
81. 
    
82. }
    

复制代码

囧囧-科技大神粉

卓泰科技 发表于 2015-2-13 20:33
翻译的还不错，基本可以看懂。

第一个我翻译完后，发现没具体例子，根本就不会用，悲剧啊！～～～

囧囧-科技大神粉

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. 
    
12. long quantime=0;
    
13. 
    
14. long maichongpinlv = 0;//脉冲频率
    
15. float lilunquanshu=0;//理论圈数
    
16. 
    
17. /////////////////////////////////////
    
18. 
    
19. #include <AccelStepper.h>
    
20. 
    
21. AccelStepper Xaxis(1, 9, 8); // pin 9 = step, pin 8 = direction
    
22. int pps=200;
    
23. unsigned long time1=millis();
    
24. 
    
25. void setup() {
    
26.   Serial.begin(9600);
    
27. 
    
28.   lcd.init();   
    
29.   lcd.backlight();
    
30.   //////////////////////////////////////
    
31.   Xaxis.setMaxSpeed(2200);
    
32.   Xaxis.setSpeed(pps);
    
33. 
    
34. }
    
35. 
    
36. void loop() {  
    
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.    Xaxis.runSpeed();
    
49. 
    
50.    if (millis() - time1 > 1000 && pps<2000){
    
51. 
    
52. 
    
53. lcd.setCursor(0, 0);
    
54. lcd.print(ACS712PinValx);
    
55. lcd.print("mA p:");
    
56. lcd.println(pps);//每秒脉冲数
    
57. lcd.println("      ");//
    
58.      ////////////////////////
    
59.      pps=pps+30;
    
60.      Xaxis.setSpeed(pps);
    
61.      time1=millis();
    
62.    }
    
63. }
    

复制代码

1、恒定速度的切换，另外，ACS712 可以在没接通电机前测试一下精度，185mV/A，精度大概是1/37 A，约正负27ma的样子

卓泰科技

翻译的还不错，基本可以看懂。

囧囧-科技大神粉

Basic Usage

You can create multiple AccelStepper objects, giving a unique name to each motor. AccelStepper can manage any number of motors, as long as you repetitively call their "run" functions.

您可以创建多个AccelStepper对象，每个电机提供一个唯一的名称。 AccelStepper可以管理任何数量的电动机，只要你反复地叫他们“跑”的功能。
Defining & Configuring Motors

定义和配置电动机

AccelStepper mystepper(1, pinStep, pinDirection);
A stepper motor controlled by a dedicated driver board.
由专门的驱动板控制的步进电机。

AccelStepper mystepper(2, pinA, pinB);
A bipolar stepper motor controlled by an H-Bridge circuit.
由H桥circuit.n控制的双极步进电机。

AccelStepper mystepper(4, pinA1, pinA2, pinB1, pinB2);
A unipolar stepper motor, controlled by 4 transistors.
单极步进电机，由4个晶体管控制。

mystepper.setMaxSpeed(stepsPerSecond);
Sets the maximum speed. The default is very slow, so this must be configured. When controlled by setting position, the stepper will accelerate to move at this maximum speed, and decelerate as it reaches the destination.
设置的最大速度。缺省值是很慢的，因此必须进行配置。当通过设定位置控制时，步进将加快移动至在该最大速度，减速，因为它到达目的地。

mystepper.setAcceleration(stepsPerSecondSquared);
Sets the acceleration to be used, in steps per second per second.
设置要使用的加速，在每秒每第二步骤。

========================================================
Position Based Control
基于位置控制

mystepper.moveTo(targetPosition);
Move the motor to a new absolute position. This returns immediately. Actual movement is caused by the run() function.
移动电机到一个新的绝对位置。这立即返回。实际运动由run（）函数引起的。


mystepper.move(distance);
Move the motor (either positive or negative) relative to its current position. This returns immediately. Actual movement is caused by the run() function.
动马达（或正或负）相对于它的当前位置。这立即返回。实际运动由run（）函数引起的。


mystepper.currentPosition();
Read the motor's current absolution position.
读取电机的绝对位置。


mystepper.distanceToGo();
Read the distance the motor is from its destination position. This can be used to check if the motor has reached its final position.
读取距离电机从目标位置。可如果电机已到达其最终位置用来检查。


mystepper.run();
Update the motor. This must be called repetitively to make the motor move.
更新电机。这必须调用反复，使电机的举动。


mystepper.runToPosition();
Update the motor, and wait for it to reach its destination. This function does not return until the motor is stopped, so it is only useful if no other motors are moving.
更新电机，并等待它到达目的地。此函数不返回，直到电机停止，所以它是只有在没有其他电机正在有用。

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

Speed Based Control
基于速度控制

mystepper.setSpeed(stepsPerSecond);
Set the speed, in steps per second. This function returns immediately. Actual motion is caused by called runSpeed().
设定速度，以每秒的步骤。该函数立即返回。实际运动是由称为runSpeed（）。

mystepper.runSpeed();
Update the motor. This must be called repetitively to make the motor move.
更新电机。这必须调用反复，使电机的举动。