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

囧囧-科技大神粉

1. http://www.airspayce.com/mikem/arduino/AccelStepper/classAccelStepper.html#a73bdecf1273d98d8c5fbcb764cabeea5ac3523e4cf6763ba518d16fec3708ef23
   
2. 
   
3. 支持对步进电机加速等等。更多…
   
4. 公共类型
   
5. 枚举
   
6. MotorInterfaceType {  //电机接口类型
   
7.   FUNCTION = 0, DRIVER = 1, FULL2WIRE = 2, FULL3WIRE = 3,
   
8.   FULL4WIRE = 4, HALF3WIRE = 6, HALF4WIRE = 8
   
9. }
   
10. 符号名为pin的数量。使用这个在AccelStepper针参数构造函数提供一个符号名的别针。
    
11. FUNCTION        
    
12. 使用功能接口,实现你自己的驱动程序功能(仅内部使用)
    
13. DRIVER        
    
14. 步进驱动,2线驱动。
    
15. FULL2WIRE        
    
16. 2线整步
    
17. FULL3WIRE        
    
18. 3线整步
    
19. FULL4WIRE        
    
20. 4线整步
    
21. HALF3WIRE        
    
22. 3线半步
    
23. HALF4WIRE        
    
24. 4线半步
    
25. 
    
26. Public Member Functions//公共成员函数
    
27. 
    
28. 
    
29. 
    
30. AccelStepper (uint8_t interface=AccelStepper::FULL4WIRE, uint8_t pin1=2, uint8_t pin2=3, uint8_t pin3=4, uint8_t pin4=5, bool enable=true)
    
31. 
    
32. 参数
    
33. [in]        interface
    
34. 引脚数接口。1，2，4或8个都支持，但它是优选使用 MotorInterfaceType  符号名
    
35. AccelStepper::DRIVER (1) 指步进驱动器（与步骤和方向引脚）。如果还需要一个能线，调用 setEnablePin()  施工后。您也可以使用反转引脚setPinsInverted().
    
36. AccelStepper::FULL2WIRE （2）指2线步进（需要2个引脚）。
    
37. AccelStepper::FULL3WIRE（3）指3线步进，如HDD主轴（需要3引脚）。
    
38. AccelStepper::FULL4WIRE （4）意味着一个4线步进（4引脚 需要）。
    
39. AccelStepper::HALF3WIRE (6) means a 3 wire half stepper, such as HDD spindle (3 pins required)
    
40. AccelStepper::HALF4WIRE （8）指4线半步进（4引脚需要）默认为 AccelStepper::FULL4WIRE   (4) pins.
    
41. 
    
42. [in]        pin1（步）
    
43. Arduino的数字引脚数电机引脚1.默认为引脚2.对于 AccelStepper::DRIVER  (interface==1), 这是步骤输入到驱动器。从低到高的转变意味step）
    
44. [in]        pin2（驱动方向）
    
45. Arduino的数字引脚数电机引脚2.默认为引脚3.对于 AccelStepper::DRIVER  (interface==1), 这是方向输入的驱动程序。高意味着前进。
    
46. 
    
47. [in]        pin3
    
48. Arduino的数字引脚数电机引脚3.默认为引脚4.
    
49. 
    
50. in]        pin4
    
51. Arduino的数字引脚数电机引脚4.默认为引脚5.
    
52. 
    
53. [in]        enable
    
54. 如果这是1（默认）， enableOutputs()  将被调用，以使输出引脚的施工时间。
    
55. 
    
56. References DIRECTION_CCW, enableOutputs(), and setAcceleration().
    
57. 
    
58. AccelStepper (void(*forward)(), void(*backward)())
    
59. 可选的构造，将调用自己的功能向前和向后的步骤。 你可以有多个同时步进，所有运动以不同的速度和加速度，只要你调用它们的run（） 在足够频繁的时间间隔功能。
    
60. 当前位置被设置为0，目标位置被设定为0。
    
61. MaxSpeed and Acceleration 默认为1.0。
    
62. 任何运动初始化应 发生前，  无引脚使用或初始化。
    
63. 
    
64. 参数
    
65. [in]        forward
    
66. 空隙返回程序，这将使向前一步
    
67. [in]        backward
    
68. 空隙返回程序，这将使倒退
    
69. References DIRECTION_CCW, and setAcceleration().
    
70. 
    
71. void         moveTo (long absolute)
    
72. 设置目标位置. run() 函数将试图将电动机(每次调用最多一步)从当前位置到目标位置的最近调用这个函数。注意：moveTo 也会重新计算速度对下一步骤。如果你要使用恒速运动，应该调用setSpeed() 后调用moveTo().
    
73. 
    
74. 参数
    
75. [in]        absolute
    
76. 所需的绝对位置。负为0的位置逆时针。
    
77. Examples:
    
78. Bounce.pde, MultiStepper.pde, Overshoot.pde, ProportionalControl.pde, Quickstop.pde, and Random.pde.
    
79. References computeNewSpeed().
    
80. Referenced by move(), and runToNewPosition().
    
81. 
    
82. void         move (long relative)
    
83. 设置目标位置相对于当前位置
    
84. 参数
    
85. 
    
86. [in]        relative
    
87. 所需的位置相对于当前位置。负是从当前位置逆时针。
    
88. References moveTo().
    
89. Referenced by stop().
    
90. 
    
91. 
    
92. boolean         run ()
    
93. 投票电机和步骤，如果一步是因为，实施加速度
    
94. 和减速到acheive目标位置。必须以最小的步骤的时间间隔称之为尽可能频繁地，但至少一次，最好是在主回路。请注意，每个调用 run() 将至多一个步，然后，只有当一个步是由于，基于当前速度和自最后步骤的时间。
    
95. 
    
96. 返回
    
97. 真 ， 如果电机仍在运行到目标位置。
    
98. 
    
99. Examples:
    
100. Bounce.pde, MultiStepper.pde, Overshoot.pde, Quickstop.pde, and Random.pde.
     
101. References computeNewSpeed(), distanceToGo(), and runSpeed().
     
102. Referenced by runToPosition().
     
103. 
     
104. boolean         runSpeed ()
     
105. 轮询电机，并加强它 如果一个步骤是因为，实施恒定的速度通过最近一次调用的设置为setSpeed().必须每步的时间间隔称此尽可能频繁地，但至少一次，
     
106. 返回
     
107. 真的，如果电机得到进一步加强。
     
108. 
     
109. Examples:
     
110. ConstantSpeed.pde.
     
111. References DIRECTION_CW, and step().
     
112. Referenced by run(), and runSpeedToPosition().
     
113. 
     
114. 
     
115. void         setMaxSpeed (float speed)
     
116. 设置允许的最大速度。在 run() 函数将加速上升的速度通过该功能设定。注意：最高速度可达到取决于你的处理器和时钟速度。
     
117. 参数
     
118. [in]        speed
     
119. 所需的最大速度在每秒步骤。
     
120. 必须>0。注意事项：速度超过了处理器所支持的最高速度在非线性加速和减速可能会导致。
     
121. void         setAcceleration (float acceleration)
     
122. 设定加速/减速速率。
     
123. Parameters
     
124. [in]        acceleration
     
125. 所需的加速的步/秒秒，acceleration>0.0。这是一种昂贵的调用，因为它需要一个平方根来计算的。尽量少用
     
126. Examples:
     
127. Blocking.pde, Bounce.pde, MultiStepper.pde, Overshoot.pde, Quickstop.pde, and Random.pde.
     
128. References computeNewSpeed().
     
129. Referenced by AccelStepper().
     
130. 
     
131. void         setSpeed (float speed)
     
132. 设置所需的恒定速度与使用 runSpeed().
     
133. 参数
     
134. [in]        speed
     
135. 所需的恒定速度在每秒步骤。正为顺时针。每秒超过1000步的速度是不可靠的。非常慢的速度可以设置（如0.00027777对每小时一次，大约。速度精度取决于Arduino的结晶。抖动取决于你如何频繁调用 runSpeed()函数。
     
136. float         speed ()
     
137. 最近设置的速度
     
138. 返回
     
139. 最近的速度在每秒步
     
140. Referenced by setMaxSpeed(), and setSpeed().
     
141. long         distanceToGo ()
     
142. 从当前位置到目标位置的距离。
     
143. 返回
     
144. 从当前位置到在步骤目标位置的距离。正为顺时针从当前位置。
     
145. Examples:
     
146. Bounce.pde, MultiStepper.pde, and Random.pde.
     
147. Referenced by computeNewSpeed(), and run().
     
148. 
     
149. 
     
150. long         targetPosition ()
     
151. 最近设置的目标位置。
     
152. 返回
     
153. 在步骤目标位置。正为顺时针方向从0位置。
     
154. long         currentPosition ()
     
155. 当前电动机位置。
     
156. 返回
     
157. 在步骤的当前电动机位置。正为顺时针方向从0位置。
     
158. 例如：
     
159. Bounce.pde, MultiStepper.pde, Overshoot.pde, and Quickstop.pde.
     
160. void         setCurrentPosition (long position)
     
161. 重置马达的当前位置，使得无论电动机恰好是正确的，现在被认为是新的0位置。可用来设定一个初始的硬件定位运动后步进零位。具有当前马达速度设置为0的副作用。
     
162. [in]        position
     
163. 设置步进电机现在的位置
     
164. void         runToPosition ()
     
165. 使电机的当前选定的恒定速度（前进或后退）到目标位置和阻塞，直到它在位置上。不使用此事件循环，因为它会阻止。
     
166. Examples:
     
167. Quickstop.pde.
     
168. References run().
     
169. Referenced by runToNewPosition().
     
170. 
     
171. boolean         runSpeedToPosition ()
     
172. 运行在当前选择的速度，直到到达目标位置不执行加速度。
     
173. 返回
     
174. 1，如果它在运行？//true if it stepped
     
175. void         runToNewPosition (long position)
     
176. 移动电机到新的目标位置和阻塞，直到它在位置上。不使用此事件循环，因为它会阻止。
     
177. [in]        position
     
178. 新的目标位置。
     
179. Examples:
     
180. Blocking.pde, and Overshoot.pde.
     
181. References moveTo(), and runToPosition().
     
182. 
     
183. void         stop ()
     
184. 设置一个新的目标位置，导致步进停止尽可能快，使用当前的速度和加速度的参数。
     
185. Examples:
     
186. Quickstop.pde.
     
187. References move().
     
188. 
     
189. virtual void         disableOutputs ()
     
190. 通过设置他们都LOW根据您的电子产品的设计，这可能在电源关闭的电机线圈，省电禁用电机引脚输出。这是非常有用的支持Arduino的低功耗模式：睡眠，然后重新启用期间禁用输出 withenableOutputs()  前再次加强。
     
191. virtual void         enableOutputs ()
     
192. 通过设置电机引脚输出模式使电机引脚输出。由构造自动调用。
     
193. References FULL3WIRE, FULL4WIRE, HALF3WIRE, and HALF4WIRE.
     
194. Referenced by AccelStepper().
     
195. 
     
196. void         setMinPulseWidth (unsigned int minWidth)
     
197. 设置由步进驱动所允许的最小脉冲宽度。最小实际脉冲宽度为大约20微秒。时间小于20微秒，通常会导致在20微秒左右。
     
198. [in]        minWidth
     
199. 的最小脉冲宽度为微秒。
     
200. 
     
201. void         setEnablePin (uint8_t enablePin=0xff)
     
202. 设置步进驱动器的使能引脚数量。 0xFF的指示未使用（默认）。否则，如果一个引脚设置，引脚将在何时开启enableOutputs() 调用并关机的时候disableOutputs() 调用
     
203. Parameters
     
204. [in]        enablePin
     
205. 电机使Arduino的数字引脚数
     
206. See Also
     
207. setPinsInverted
     
208. 
     
209. void         setPinsInverted (bool directionInvert=false, bool stepInvert=false, bool enableInvert=false)
     
210. 设置反转步进驱动器引脚
     
211. 参数
     
212. [in]        directionInvert        为True变换方向针，假的非反转
     
213. [in]        stepInvert        为True反转步销，假的非反转
     
214. [in]        enableInvert        为True反转使能引脚，假（默认值）的非反转
     
215. 
     
216. void         setPinsInverted (bool pin1Invert, bool pin2Invert, bool pin3Invert, bool pin4Invert, bool enableInvert)
     
217. 设置反转2，3和4线步进针脚
     
218. 参数
     
219. [in]        pin1Invert        为True反转PIN1，假的非反转
     
220. [in]        pin2Invert        为True反转PIN2码，假的非反转
     
221. [in]        pin3Invert        为True反转PIN3，假的非反转
     
222. [in]        pin4Invert        为True反转PIN4，假的非反转
     
223. [in]        enableInvert        为True反转使能引脚，假（默认值）的非反转
     
224. 
     
225. 
     
226. Protected Types//保护类型
     
227. 
     
228. Direction { DIRECTION_CCW = 0, DIRECTION_CW = 1 }
     
229. 转向指示器符号名马达转动的方向。
     
230. 枚举
     
231. DIRECTION_CCW
     
232. 顺时针方向。
     
233. DIRECTION_CW
     
234. 逆时针方向。
     
235. 
     
236. Protected Member Functions
     
237. 
     
238. //受保护的成员函数
     
239. void         computeNewSpeed ()
     
240. 强制库来计算一个新的瞬时速度，并设置为当前的速度。这就是所谓的库：
     
241. ～在每一步之后
     
242. ～在通过setMaxSpeed() 改变setMaxSpeed之后
     
243. ～在通过setAcceleration()改变setAcceleration之后
     
244. ～在通过move() or moveTo() 改变目标位置（相对或绝对）之后
     
245. virtual void         setOutputPins (uint8_t mask)
     
246. 低电平函数来设置电机输出引脚位0掩码对应_pin[0]位掩码1对应_pin[1]您可以覆盖这impment，例如串行芯片输出insted的直接使用输出引脚
     
247. Examples:
     
248. MotorShield.pde.
     
249. References FULL3WIRE, FULL4WIRE, HALF3WIRE, and HALF4WIRE.
     
250. Referenced by disableOutputs(), step1(), step2(), step3(), step4(), step6(), and step8().
     
251. 
     
252. virtual void         step (long step)
     
253. 所谓以执行步骤。只有当需要的新的一步调用。子类可以重写，以实现新的步进接口。缺省调用step1(), step2(), step4() or step8() ，这取决于对步进定义的管脚数。
     
254. Parameters
     
255. [in]        step        当前步相位数（0到7）
     
256. virtual void         step0 (long step)
     
257. 所谓执行使用步进功能（pins = 0），只有当需要的新的一步称为步。调用_forward() or _backward() 来执行步
     
258. [in]        step        当前步相位数（0到7）
     
259. virtual void         step1 (long step)
     
260. 叫上执行步进驱动器的步骤（例如那里pins == 1）。只有当需要的新的一步调用。子类可以重写，以实现新的步进接口。
     
261. 默认设置或清除步骤的pin1步骤的输出，  并设置_pin2向所希望的方向的输出。 步骤引脚（_pin1）是脉冲1微秒 这是最低STEP脉冲宽度为3967的驱动程序。
     
262. [in]        step        当前步相位数（0到7）
     
263. References setOutputPins().
     
264. Referenced by step().
     
265. 
     
266. virtual void         step2 (long step)
     
267. 所谓的执行上2针电机的一个步骤。只有当需要的新的一步调用。子类可以重写，以实现新的步进接口。默认设置或清除PIN1和PIN2的输出
     
268. virtual void         step3 (long step)
     
269. 所谓的执行上3针电机，如HDD主轴的一步。只有当需要的新的一步调用。子类可以重写，以实现新的步进接口。默认设置或清除的PIN1，PIN2，Pin3输出
     
270. virtual void         step4 (long step)
     
271. 所谓执行一个4针电机的一个步骤。只有当需要的新的一步调用。子类可以重写，以实现新的步进接口。默认设置或清除PIN1，PIN2，PIN3，PIN4的输出。
     
272. virtual void         step6 (long step)
     
273. 所谓的执行上3针电机，如HDD主轴的一步。只有当需要的新的一步调用。子类可以重写，以实现新的步进接口。默认设置或清除的PIN1，PIN2，3脚输出
     
274. virtual void         step8 (long step)
     
275. 所谓执行一个4针半步r电机的一个步骤。只有当需要的新的一步调用。子类可以重写，以实现新的步进接口。默认设置或清除PIN1，PIN2，PIN3，PIN4的输出。
     
276. 
     
277. 
     
278. 详细说明
     
279. 支持步进电机加速等等。
     
280. 这定义了单个2或4引脚的步进电机，或具有fdriver芯片步进启动子，可选的加速，减速，绝对定位命令等多个同时步进机都支持，都以不同的速度和加速度移动。
     
281. =================
     
282. 运算
     
283. 此模块通过计算在微秒的步的时间。由调用者被改变后的各步与速度和加速度参数之后的步的时间被重新计算。每个步骤的时间被记录在微秒。在run（）函数步骤电机一次，如果的新的一步到期。该run（）函数必须被频繁调用直到电机是在所需的位置，在这之后时间运行（）什么也不做。
     
284. =============
     
285. 定位
     
286. 位置由一个符号长整型指定。在施工时，马达的当前位置被认为是0正的位置是沿顺时针方向从初始位置;负位置是逆时针。当前位置可以初始化定位之后被改变对于实例。
     
287. ===============
     
288. 警告
     
289. 这是一个开环控制器：如果电机摊位或oversped，AccelStepper不会有当电机确实是一个正确的想法（因为电机的实际位置的任何反馈。我们只知道，我们认为这是相对的。到初始开始点）。
     
290. ===============
     
291. 性能
     
292. 可以可靠地支撑最快电机速度是每秒约4000步在16兆赫上的Arduino如乌诺等更快的处理器的时钟频率可以支持更快步进速度。然而，比下降到非常低的速度（远小于1每秒）也支持的任何速度更小，所提供的run（）函数被调用足够频繁到步骤电动机每当需要的速度设定。调用setAcceleration（）是昂贵的，因为它需要一个平方根来计算的。
     

复制代码

囧囧-科技大神粉

卓泰科技 发表于 2015-2-24 18:03
想要精确输出脉冲，试试定时器

外部定时器 +　arduino的外部中断？

卓泰科技

想要精确输出脉冲，试试定时器

囧囧-科技大神粉

大材小用，泪流满面的arduino
对于步进电机驱动器的控制要点在于，输出脉冲的尽量稳定。这就要求，充当控制器的单片机要专注，尽量减少其他无关的事情
比如串口通信，在9600下，哪怕4个字节的接收，也会带来3.6ms的延迟，在400us为周期下，这就是9个脉冲周期了
所以，如果字节数太多，就必然影响脉冲，所以，单字节控制，依靠ASCII码进行定义的控制方式就出现了～～～

1. /*
   
2. 纯串口控制
   
3.   加入脱机控制
   
4. */
   
5. 
   
6. 
   
7. //电机的高电平持续时间 us
   
8. int maichongjiangeMax=1260;
   
9. int maichongjiangeMin=120;
   
10. long maichongjiangeSet=600;
    
11. 
    
12. //电机的高电平持续时间的初始值 0us
    
13. int maichongjiange=0;
    
14. 
    
15. //脉冲的占空比为1/maichongzhankongbi
    
16. int maichongzhankongbi=4;
    
17. 
    
18. //加减速时速度每隔300us变化一次
    
19. int jiajiansubianhuashijian=300;
    
20. 
    
21. 
    
22. ////////////////////////////////////////////
    
23. int kongzhifangshi;//控制方式，低电平则为串口控制，高电平为按键控制
    
24. int jsq1=0;
    
25. int tempint;
    
26. char kongzhimingling[5];
    
27. 
    
28. boolean testxinxi=0;
    
29. 
    
30. 
    
31. boolean fangxiang=0;//电机转动方向标识
    
32. int maichongjsq=0;//脉冲计数器
    
33. 
    
34. 
    
35. unsigned long time1=micros();
    
36. unsigned long time2=micros();
    
37. 
    
38. 
    
39. void setup(){
    
40. 
    
41. //为防止意外，先行定义为20%的运行速度
    
42. kongzhimingling[0]=fangxiang+48;
    
43. kongzhimingling[1]=49;
    
44. kongzhimingling[2]=48;
    
45. kongzhimingling[3]=79;//ascII 79=O ON
    
46. 
    
47. Serial.begin(9600);
    
48. 
    
49. 
    
50. /*
    
51. 暂定A0 analogRead（0）的值来确定转速
    
52. 为方便演示，此处为使用1K 多圈精密可调电阻，A0就接在中间脚上
    
53. 那么可见，其电压大致为0-5v之间，现在就电压区间进行分级
    
54. 如果粗分为10档，就意味着每100个返回单位对应10%的速度
    
55. */
    
56. 
    
57. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
58. pinMode(8, OUTPUT);// CW+,方向
    
59. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
60. 
    
61. digitalWrite(7, HIGH);//电机默认脱机
    
62. digitalWrite(8, LOW);//
    
63. digitalWrite(9, LOW);
    
64. 
    
65. }
    
66. 
    
67. 
    
68. void loop(){
    
69. 
    
70. 
    
71. 
    
72. 
    
73.    while (Serial.available() > 0) {
    
74. 
    
75.     //丧心病狂的1位控制，0延迟，纯ASCII分拆
    
76.         //定义1 0-9表示转速，每一个表示10%
    
77.         //定义2 A正转、B反转
    
78.         //定义3 C联机、D脱机
    
79.        
    
80.    tempint=Serial.read();
    
81.    
    
82.    //调速度
    
83.    if(tempint>47 && tempint< 58) maichongjiangeSet = 625/(0.5+4.5*(tempint-48)/10);//0-1023
    
84.    //调方向
    
85.    if(tempint==65)digitalWrite(8, 0);
    
86.    if(tempint==66)digitalWrite(8, 1);
    
87.     //脱机
    
88.    if(tempint==67)digitalWrite(7, 0);
    
89.    if(tempint==68)digitalWrite(7, 1);
    
90.    
    
91.    tempint=0;
    
92. 
    
93. }
    
94. 
    
95. 
    
96. 
    
97. 
    
98. 
    
99. 
    
100. //加速过程
     
101. while(maichongjiange>maichongjiangeSet){
     
102.   jiasu();
     
103.   maichongqudong();
     
104.   }
     
105. 
     
106.   //加减过程
     
107. while(maichongjiange<maichongjiangeSet){
     
108.   jiansu();
     
109.   maichongqudong();
     
110.   }
     
111. 
     
112. //在脉冲频率无变化的时候驱动电机正常运行
     
113. maichongqudong();
     
114. 
     
115. 
     
116. 
     
117. 
     
118. 
     
119. }
     
120. 
     
121. 
     
122. 
     
123. 
     
124. 
     
125. 
     
126. void jiasu() //脉冲加速过程
     
127. {
     
128. 
     
129. if(micros()-time1>jiajiansubianhuashijian && maichongjiange>maichongjiangeMin){//加速过程，xxx us加速一次，加速到 yyy为止
     
130. maichongjiange--;
     
131. time1=micros();
     
132. }
     
133. 
     
134. }
     
135. 
     
136. void jiansu()//脉冲减速过程
     
137. {
     
138. 
     
139. if(micros()-time1>jiajiansubianhuashijian && maichongjiange<maichongjiangeMax){
     
140. maichongjiange++;
     
141. time1=micros();
     
142. }
     
143. 
     
144. }
     
145. 
     
146. 
     
147. void maichongqudong()//脉冲驱动
     
148. {
     
149. 
     
150. 
     
151. 
     
152. //步进电机控制脉冲
     
153. if (micros()-time2 > maichongjiange){
     
154. 
     
155.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
156.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
157. 
     
158.         if(maichongjsq==0)digitalWrite(9, HIGH);//输出控制步进电机的电平
     
159.         else digitalWrite(9, LOW);
     
160. 
     
161.      time2= micros();
     
162. }
     
163. 
     
164. }
     
165. 
     
166. 
     

复制代码

囧囧-科技大神粉

djc5-3 反向时减速在加速的过程太快，导致噪音，所以直接去掉


/*
纯串口控制
  加入脱机控制
*/


//电机的高电平持续时间 us
int maichongjiangeMax=1260;
int maichongjiangeMin=120;
long maichongjiangeSet=600;

//电机的高电平持续时间的初始值 0us
int maichongjiange=0;

//脉冲的占空比为1/maichongzhankongbi
int maichongzhankongbi=4;

//加减速时速度每隔300us变化一次
int jiajiansubianhuashijian=300;


////////////////////////////////////////////
int kongzhifangshi;//控制方式，低电平则为串口控制，高电平为按键控制
int jsq1=0;
int tempint;
char kongzhimingling[5];

boolean testxinxi=0;


boolean fangxiang=0;//电机转动方向标识
int maichongjsq=0;//脉冲计数器


unsigned long time1=micros();
unsigned long time2=micros();


void setup(){

//为防止意外，先行定义为20%的运行速度
kongzhimingling[0]=fangxiang+48;
kongzhimingling[1]=49;
kongzhimingling[2]=48;
kongzhimingling[3]=79;//ascII 79=O ON

Serial.begin(9600);


/*
暂定A0 analogRead（0）的值来确定转速
为方便演示，此处为使用1K 多圈精密可调电阻，A0就接在中间脚上
那么可见，其电压大致为0-5v之间，现在就电压区间进行分级
如果粗分为10档，就意味着每100个返回单位对应10%的速度
*/

pinMode(7, OUTPUT);// EN+,脱机，高电平有效
pinMode(8, OUTPUT);// CW+,方向
pinMode(9, OUTPUT);// CLK+,频率（转速）

digitalWrite(7, HIGH);//电机默认脱机
digitalWrite(8, LOW);//
digitalWrite(9, LOW);

}


void loop(){




   while (Serial.available() > 0) {

    //格式：方向（1位），速度百分比（2位）,脱机（1位） 如012O / 012F
//kongzhimingling[jsq1]= Serial.read();
   tempint=Serial.read();

if(jsq1==0){   

  if(tempint==48 || tempint==49)kongzhimingling[0]= tempint;        

  }else if(jsq1==1 || jsq1==2){
          
  if(tempint>47 && tempint<58)kongzhimingling[jsq1]= tempint;        

}else if(jsq1==3){

   if(tempint==79 || tempint==70) kongzhimingling[3]= tempint;
}

if(jsq1<3)delayMicroseconds(1200);
jsq1++;


testxinxi=1;
  }

  if(testxinxi){
   testxinxi=0;
   jsq1=0;
   Serial.print("get:");
      Serial.println(kongzhimingling);  

//脱机
if(kongzhimingling[3]==79)digitalWrite(7, LOW);
else if(kongzhimingling[3]==70){
  digitalWrite(7, HIGH);
  Serial.println("off-line");
}

   //速度调节

   maichongjiangeSet = 625/(0.5+4.5*((kongzhimingling[1]-48)*10+kongzhimingling[2]-48)/100);//0-1023

   Serial.print("maichongjiangeSet:");
      Serial.println(maichongjiangeSet);  

   //方向调节

  if(kongzhimingling[0]-48 != fangxiang){ //有效高电平且现在电机转速与设置相反

     Serial.println("change");


  //2、记录新的方向
  fangxiang=!fangxiang;

  //3、反方向
  digitalWrite(8, fangxiang);



  }else  Serial.println("keep");


}






//加速过程
while(maichongjiange>maichongjiangeSet){
  jiasu();
  maichongqudong();
  }

  //加减过程
while(maichongjiange<maichongjiangeSet){
  jiansu();
  maichongqudong();
  }

//在脉冲频率无变化的时候驱动电机正常运行
maichongqudong();





}






void jiasu() //脉冲加速过程
{

if(micros()-time1>jiajiansubianhuashijian && maichongjiange>maichongjiangeMin){//加速过程，xxx us加速一次，加速到 yyy为止
maichongjiange--;
time1=micros();
}

}

void jiansu()//脉冲减速过程
{

if(micros()-time1>jiajiansubianhuashijian && maichongjiange<maichongjiangeMax){
maichongjiange++;
time1=micros();
}

}


void maichongqudong()//脉冲驱动
{



//步进电机控制脉冲
if (micros()-time2 > maichongjiange){

        maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
        maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0

        if(maichongjsq==0)digitalWrite(9, HIGH);//输出控制步进电机的电平
        else digitalWrite(9, LOW);

     time2= micros();
}

}

囧囧-科技大神粉

卓泰科技 发表于 2015-2-19 18:11
囧囧大神威武

上程序，蓝牙的
控制上
正：1
反：0
速度上：axx，a其实是占位符

1. /*
   
2. djc3 无极调速 + 串口控制
   
3. 规定Pin4口为一个判断点，
   
4. 低电平则为串口控制，高电平为按键控制
   
5. 对串口的输入做限制，必须为数字
   
6. 
   
7. */
   
8. 
   
9. 
   
10. //电机的高电平持续时间 us
    
11. int maichongjiangeMax=1260;
    
12. int maichongjiangeMin=120;
    
13. long maichongjiangeSet;
    
14. 
    
15. //电机的高电平持续时间的初始值 0us
    
16. int maichongjiange=0;
    
17. 
    
18. //脉冲的占空比为1/maichongzhankongbi
    
19. int maichongzhankongbi=4;
    
20. 
    
21. //加减速时速度每隔300us变化一次
    
22. int jiajiansubianhuashijian=300;
    
23. 
    
24. 
    
25. ////////////////////////////////////////////
    
26. int kongzhifangshi;//控制方式，低电平则为串口控制，高电平为按键控制
    
27. int jsq1=0;
    
28. int tempint;
    
29. char kongzhimingling[4];
    
30. 
    
31. 
    
32. 
    
33. boolean testxinxi=0;
    
34. 
    
35. int Pinval;//存储IO口（Pin5、Pin6）高低电平的值
    
36. 
    
37. boolean fangxiang=0;//电机转动方向标识
    
38. int maichongjsq=0;//脉冲计数器
    
39. 
    
40. 
    
41. unsigned long time1=micros();
    
42. unsigned long time2=micros();
    
43. 
    
44. 
    
45. void setup(){
    
46. 
    
47. //为防止意外，先行定义为20%的运行速度
    
48. kongzhimingling[0]=fangxiang+48;
    
49. kongzhimingling[1]=49;
    
50. kongzhimingling[2]=48;
    
51. 
    
52. 
    
53. Serial.begin(9600);
    
54. 
    
55. //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向） 输入状态，就读取值来确定电机的转动方向
    
56. pinMode(5, INPUT);  
    
57. pinMode(6, INPUT);  
    
58. 
    
59. /*
    
60. 暂定A0 analogRead（0）的值来确定转速
    
61. 为方便演示，此处为使用1K 多圈精密可调电阻，A0就接在中间脚上
    
62. 那么可见，其电压大致为0-5v之间，现在就电压区间进行分级
    
63. 如果粗分为10档，就意味着每100个返回单位对应10%的速度
    
64. */
    
65. 
    
66. pinMode(7, OUTPUT);// EN+,脱机，高电平有效
    
67. pinMode(8, OUTPUT);// CW+,方向
    
68. pinMode(9, OUTPUT);// CLK+,频率（转速）
    
69. 
    
70. digitalWrite(7, LOW);//电机默认联机
    
71. digitalWrite(8, LOW);//
    
72. digitalWrite(9, LOW);
    
73. 
    
74. }
    
75. 
    
76. 
    
77. void loop(){
    
78. 
    
79. kongzhifangshi = digitalRead(4);
    
80. 
    
81. if(kongzhifangshi==1){
    
82. 
    
83. //转速调节,通过可变电阻实现无极调速
    
84. 
    
85.   //可能是读取过于频繁，导致夹杂着无效数值，所以此处做个循环
    
86.   do
    
87.   {
    
88. maichongjiangeSet = analogRead(0);//0-1023
    
89. }while(maichongjiangeSet >1024);
    
90. 
    
91. // 25% us =1000,000/(圈/每秒*400*4)=625/(0.5【min】+4.5×analogRead(0)/1024)
    
92. //即把电压线性到转速上
    
93.   maichongjiangeSet = 625/(0.5+4.5*maichongjiangeSet/1024);//0-1023
    
94. 
    
95. fangxiangchange(); //转动方向的切换
    
96. 
    
97. }else{
    
98. 
    
99. 
    
100.    while (Serial.available() > 0) {
     
101. 
     
102.     //格式：方向（1位），速度百分比（2位） 如012
     
103. //kongzhimingling[jsq1]= Serial.read();
     
104. if(jsq1==0){        
     
105.   tempint=Serial.read();
     
106.   if(tempint==48 || tempint==49)kongzhimingling[0]= tempint;        
     
107. }else{
     
108.   tempint=Serial.read();
     
109.   if(tempint>47 && tempint<58)kongzhimingling[jsq1]= tempint;        
     
110. 
     
111. }
     
112. 
     
113. delayMicroseconds(1200);
     
114. jsq1++;
     
115. if(jsq1==3) jsq1=0;
     
116. 
     
117. testxinxi=1;
     
118.   }
     
119. 
     
120.   if(testxinxi){
     
121.    testxinxi=0;
     
122.    jsq1=0;
     
123.    Serial.print("get:");
     
124.       Serial.println(kongzhimingling);  
     
125.    //速度调节
     
126. 
     
127. 
     
128.    maichongjiangeSet = 625/(0.5+4.5*((kongzhimingling[1]-48)*10+kongzhimingling[2]-48)/100);//0-1023
     
129. 
     
130.    Serial.print("maichongjiangeSet:");
     
131.       Serial.println(maichongjiangeSet);  
     
132. 
     
133.    //方向调节
     
134. 
     
135.   if(kongzhimingling[0]-48 != fangxiang){ //有效高电平且现在电机转速与设置相反
     
136. 
     
137.      Serial.println("change");
     
138. 
     
139. 
     
140.   //1、把速度降到最低
     
141.   while(maichongjiange<maichongjiangeMax){
     
142.   jiansu();
     
143.   maichongqudong();
     
144.   }
     
145. 
     
146. // Serial.println("jiansuOK");
     
147. 
     
148.   //2、记录新的方向
     
149.   fangxiang=!fangxiang;
     
150. 
     
151.   //3、反方向
     
152.   digitalWrite(8, fangxiang);
     
153. 
     
154.   //4、在把速度加到原来值
     
155.   while(maichongjiange<maichongjiangeSet){
     
156.   jiasu();
     
157.   maichongqudong();
     
158.   }
     
159. 
     
160.   //Serial.println("jiasuOK");
     
161. 
     
162.   }else  Serial.println("keep");
     
163. 
     
164. 
     
165. }
     
166. 
     
167. 
     
168. 
     
169. 
     
170. }
     
171. 
     
172. 
     
173. 
     
174. //加速过程
     
175. while(maichongjiange>maichongjiangeSet){
     
176.   jiasu();
     
177.   maichongqudong();
     
178.   }
     
179. 
     
180.   //加减过程
     
181. while(maichongjiange<maichongjiangeSet){
     
182.   jiansu();
     
183.   maichongqudong();
     
184.   }
     
185. 
     
186. //在脉冲频率无变化的时候驱动电机正常运行
     
187. maichongqudong();
     
188. 
     
189. 
     
190. 
     
191. 
     
192. 
     
193. }
     
194. 
     
195. 
     
196. 
     
197. 
     
198. 
     
199. 
     
200. void jiasu() //脉冲加速过程
     
201. {
     
202. 
     
203. if(micros()-time1>jiajiansubianhuashijian && maichongjiange>maichongjiangeMin){//加速过程，xxx us加速一次，加速到 yyy为止
     
204. maichongjiange--;
     
205. time1=micros();
     
206. }
     
207. 
     
208. }
     
209. 
     
210. void jiansu()//脉冲减速过程
     
211. {
     
212. 
     
213. if(micros()-time1>jiajiansubianhuashijian && maichongjiange<maichongjiangeMax){
     
214. maichongjiange++;
     
215. time1=micros();
     
216. }
     
217. 
     
218. }
     
219. 
     
220. 
     
221. void maichongqudong()//脉冲驱动
     
222. {
     
223. 
     
224. 
     
225. 
     
226. //步进电机控制脉冲
     
227. if (micros()-time2 > maichongjiange){
     
228. 
     
229.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
230.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
231. 
     
232.         if(maichongjsq==0)digitalWrite(9, HIGH);//输出控制步进电机的电平
     
233.         else digitalWrite(9, LOW);
     
234. 
     
235.      time2= micros();
     
236. }
     
237. 
     
238. }
     
239. 
     
240. 
     
241. void fangxiangchange() //转动方向的切换
     
242. {
     
243. 
     
244. 
     
245. 
     
246.   //关于反向，虽然直接对引脚进行控制也是可以的，但加入一个，减速——取反——加速的过程应该更好
     
247. /*本例中，
     
248. pin7, EN+,脱机，高电平有效
     
249. pin8, CW+,方向
     
250. pin9, CLK+,频率（转速）
     
251. 已经用掉了，假设加减速、方向都由外部控制，那么很显然，就会出现2种控制方式：
     
252. A、模拟方式，即通过测量2个点电阻变化所导致的分压变化，即可实现强弱、方向的调节，具体类似于ACS712的读取，此方式可以类似于“无级变速”
     
253. B、数字方式，即通过摇杆或4个微动开关，来分别实现加减速、方向的切换
     
254. 
     
255. 就实际操作而言，速度上测电阻分压，方向上用微动开关比较合适，即用2个数字口+1个PWM口实现具体控制
     
256. */
     
257. 
     
258. Pinval = digitalRead(5);  //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
259. 
     
260. if(Pinval==1 && fangxiang){ //有效高电平且现在电机转速与设置相反
     
261. 
     
262. //1、把速度降到最低
     
263. while(maichongjiange<maichongjiangeMax){
     
264. jiansu();
     
265. maichongqudong();
     
266.     }
     
267. //2、反方向
     
268. digitalWrite(8, LOW);
     
269. //3、记录新的方向
     
270. fangxiang=0;
     
271. //4、在把速度加到原来值
     
272. while(maichongjiange<maichongjiangeSet){
     
273. jiasu();
     
274. maichongqudong();
     
275.     }
     
276. 
     
277. }
     
278. 
     
279. Pinval = digitalRead(6);  //pin5（High pin8 输出 LOW 默认）、pin6（High pin8 输出 High 方向）
     
280. 
     
281. if(Pinval==1 && !fangxiang){ //有效高电平且现在电机转速与设置相反
     
282. 
     
283. //1、把速度降到最低
     
284. while(maichongjiange<maichongjiangeMax){
     
285. jiansu();
     
286. maichongqudong();
     
287.     }
     
288. //2、反方向
     
289. digitalWrite(8, HIGH);
     
290. //3、记录新的方向
     
291. fangxiang=1;
     
292. //4、在把速度加到原来值
     
293. while(maichongjiange<maichongjiangeSet){
     
294. jiasu();
     
295. maichongqudong();
     
296.     }
     
297. 
     
298. }
     
299. 
     
300. 
     
301. 
     
302. 
     
303. }
     

复制代码

卓泰科技

囧囧大神威武

囧囧-科技大神粉

TNND 土豆的流畅完全不能看，算了@百度盘，原始视频


http://pan.baidu.com/s/1kTHv6T5

囧囧-科技大神粉

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

复制代码

囧囧-科技大神粉

为了控制的迁移，串口控制是必须的：

当然，还是有待完善的地方，那就是对于串口字符串的检验

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

复制代码