蛋疼的机翻 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（）是昂贵的，因为它需要一个平方根来计算的。
     

复制代码

囧囧-科技大神粉

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.
更新电机。这必须调用反复，使电机的举动。

卓泰科技

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

囧囧-科技大神粉

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的样子

囧囧-科技大神粉

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

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

囧囧-科技大神粉

慢速——保持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. }
    

复制代码

囧囧-科技大神粉

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

囧囧-科技大神粉

囧囧-科技大神粉 发表于 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、多圈的精密电阻，却是太难调节了

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

囧囧-科技大神粉

囧囧-科技大神粉 发表于 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-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——步进电机的分贝数