用自带霍尔霍尔编码器的电机控制小车行进,比如"向左,1米"

Le0

买了两个做双轮自平衡小车的电机装在了从oj买的小车地盘上,想要实现具体的<定向定量>控制.目前摸索出的代码如下:

1. int STBY = 10;
   
2. 
   
3. //motor A引脚初始化
   
4. int PWMA = 6;   //speed control
   
5. int AIN1 = 9;   //Direction
   
6. int AIN2 = 8;   //Direction
   
7. 
   
8. //Motor B引脚初始化
   
9. int PWMB = 5;
   
10. int BIN1 = 11;
    
11. int BIN2 = 12;
    
12. 
    
13. //connect OUTA to digital2
    
14. #define PinA 2
    
15. 
    
16. //connect OUTB to digital3
    
17. #define PinB 3
    
18. 
    
19. int count = 0;  //计数初始化
    
20. 
    
21. unsigned long time = 0, old_time = 0; //time mark时间标记
    
22. unsigned long time_delay = 0; //time mark
    
23. 
    
24. //关于单个消息分为多个文本字段,中间以逗号为分隔标记
    
25. const int NUMBER_OF_FIELDS = 2;     //两个字符段
    
26. int fieldIndex = 0;   //当前字段
    
27. int values[NUMBER_OF_FIELDS];   //保存所有字段的数组
    
28. int Direction = 0;    //小车远东方向
    
29. int Distance = 0;   //小车运行距离
    
30. 
    
31. void setup() {
    
32.   // put your setup code here, to run once:
    
33.   Serial.begin(9600);   //波特率
    
34.   /*引脚输入输出定义*/
    
35.   pinMode(STBY, OUTPUT);
    
36. 
    
37.   pinMode(PWMA, OUTPUT);
    
38.   pinMode(AIN1, OUTPUT);
    
39.   pinMode(AIN2, OUTPUT);
    
40. 
    
41.   pinMode(PWMB, OUTPUT);
    
42.   pinMode(BIN1, OUTPUT);
    
43.   pinMode(BIN2, OUTPUT);
    
44. 
    
45.   pinMode(PinA, INPUT);
    
46.   pinMode(PinB, INPUT);
    
47. 
    
48. }
    
49. 
    
50. 
    
51. void loop() {
    
52.   // put your main code here, to run repeatedly:
    
53. 
    
54.   numberscut();   //切割字符的函数
    
55. 
    
56.   if (digitalRead(PinA))
    
57.   {
    
58.     Code();
    
59.   }
    
60.   Serial.println(count);
    
61. 
    
62.   switch (Direction)
    
63.   {
    
64.     case'0':  //向前
    
65.       move(0, 50, 0);
    
66.       move(1, 50, 0);
    
67.       over(count);
    
68.       break;
    
69.     case'3':    //后
    
70.       move(0, 50, 1);
    
71.       move(1, 50, 1);
    
72.       over(count);
    
73.       break;
    
74.     case'2':    //左
    
75.       move(0, 50, 1);
    
76.       move(1, 50, 0);
    
77.       TurnLeft();
    
78.       over(count);
    
79.       break;
    
80.     case'1':    //右
    
81.       move(0, 50, 0);
    
82.       move(1, 50, 0);
    
83.       TurnRight();
    
84.       over(count);
    
85.       break;
    
86.   }
    
87.   // Serial.println(Direction);
    
88.   //  Serial.println(Distance);
    
89. }
    
90. 
    
91. 
    
92. //切割字符函数定义
    
93. void numberscut()
    
94. {
    
95.   if (Serial.available())
    
96.   {
    
97.     char ch = Serial.read();
    
98.     if (ch >= '0' && ch <= '9')
    
99.     {
    
100.       if (fieldIndex < NUMBER_OF_FIELDS)
     
101.       {
     
102.         values[fieldIndex] = (values[fieldIndex] * 10) + (ch - '0');
     
103.       }
     
104.     }
     
105.     else if (ch == ',')   //逗号是分界线
     
106.     {
     
107.       fieldIndex++;
     
108.     }
     
109.     else    //回车行分别输出方向和距离的值
     
110.     {
     
111.       Direction = values[0];
     
112.       Distance = values[1];
     
113.     }
     
114.   }
     
115. }
     
116. 
     
117. //驱动函数定义
     
118. void move(int motor, int speed, int direction)
     
119. {
     
120.   digitalWrite(STBY, HIGH);
     
121. 
     
122.   boolean inPin1 = LOW;
     
123.   boolean inPin2 = HIGH;
     
124. 
     
125.   if (direction == 1)
     
126.   {
     
127.     inPin1 = HIGH;
     
128.     inPin2 = LOW;
     
129.   }
     
130. 
     
131.   //0是左轮，1是右轮
     
132.   if (motor == 1)
     
133.   {
     
134.     digitalWrite(AIN1, inPin1);
     
135.     digitalWrite(AIN2, inPin2);
     
136.     analogWrite(PWMA, speed);
     
137. 
     
138.   }
     
139.   else {
     
140.     digitalWrite(BIN1, inPin1);
     
141.     digitalWrite(BIN2, inPin2);
     
142.     analogWrite(PWMB, speed);
     
143.   }
     
144. }
     
145. 
     
146. void Code()
     
147. {
     
148.   while ((millis() - time_delay) > 5)    //延时防抖函数
     
149. 
     
150.     count += 1;   //count 计数
     
151. 
     
152.   time_delay = millis();
     
153. 
     
154. }
     
155. 
     
156. //运动设定距离后停止
     
157. void over(int count)
     
158. {
     
159.   while (count >= Distance * 7.42)    //每7.42个脉冲是1毫米
     
160.   {
     
161.     digitalWrite(STBY, LOW);
     
162.   }
     
163. 
     
164. }
     
165. 
     
166. //自身围绕中点左转90度
     
167. void TurnLeft()
     
168. {
     
169.   move(0, 50, 1);
     
170.   move(1, 50, 0);
     
171.   while (count >= 966)     //966mm是已经根据车宽计算过的车体自转四分之一圈的长度
     
172.   {
     
173.     digitalWrite(STBY, LOW);
     
174.   }
     
175. }
     
176. 
     
177. //右转90度
     
178. void TurnRight()
     
179. {
     
180.   move(0, 50, 0);
     
181.   move(1, 50, 1);
     
182.   while (count >= 966)
     
183.   {
     
184.     digitalWrite(STBY, LOW);
     
185.   }
     
186. }

复制代码

然而,,,,,这些个破代码里面有很多很令我很疑惑的bug,由于才疏学浅绞尽奶汁还是搞不定.....
1/编码盘是13线霍尔编码器,电机减速比30:1,倍频之后应该是1560,但是觉得用不了那么精细的脉冲,而且UNO R3只有两个中断,所以就用数字引脚采集脉冲计数.
2/不知道怎么能把一条串行口消息中的"字符和数字"区分出来,所以干脆参考arduino cookbook中的教程全部用数组代替,于是主程序里的csae()就不友好了.
3/电机驱动芯片用的TB6612FNG.