Advertisement
Guest User

Untitled

a guest
Apr 27th, 2018
53
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.21 KB | None | 0 0
  1. enum lineStates {
  2. zero, // 000000 <-
  3. one, // 100000
  4. //two, // 110000
  5. three, // 010000
  6. //four, // 011000
  7. five, // 001000
  8. six, // 001100
  9. seven, // 000100
  10. //eight, // 000110
  11. nine, // 000010
  12. //ten, // 000011
  13. eleven, // 000001
  14. twelve, // 000000 ->
  15. thirteen // 000000 -^-
  16.  
  17. };
  18.  
  19.  
  20. //ta bort dubbel och kolla höger/vänster på enkel state
  21.  
  22.  
  23. lineStates lineState = thirteen;
  24. void handleSensors(String sensorReading)
  25. {
  26.  
  27.  
  28.  
  29.  
  30. switch(lineState) {
  31. case zero:
  32. stateZero(sensorReading);
  33. // Serial.print("Zero");
  34. break;
  35. case one:
  36. stateOne(sensorReading);
  37. // Serial.print("One");
  38. break;
  39. //case two:
  40. //stateTwo(sensorReading);
  41. // Serial.print("Two");
  42. //break;
  43. case three:
  44. stateThree(sensorReading);
  45. // Serial.print("Three");
  46. break;
  47. //case four:
  48. //stateFour(sensorReading);
  49. // Serial.print("Four");
  50. //break;
  51. case five:
  52. stateFive(sensorReading);
  53. // Serial.print("Five");
  54. break;
  55. case six:
  56. stateSix(sensorReading);
  57. //Serial.print("Six");
  58. break;
  59. case seven:
  60. stateSeven(sensorReading);
  61. // Serial.print("Seven");
  62. break;
  63. //case eight:
  64. //stateEight(sensorReading);
  65. // Serial.print("Eight");
  66. //break;
  67. case nine:
  68. stateNine(sensorReading);
  69. // Serial.print("Nine");
  70. break;
  71. //case ten:
  72. //stateTen(sensorReading);
  73. // Serial.print("Ten");
  74. //break;
  75. case eleven:
  76. stateEleven(sensorReading);
  77. // Serial.print("Eleven");
  78. break;
  79. case twelve:
  80. stateTwelve(sensorReading);
  81. // Serial.print("Twelve");
  82. break;
  83. case thirteen:
  84. stateThirteen(sensorReading);
  85. // Serial.print("Thirteen");
  86. break;
  87. }
  88. }
  89. /*
  90. * Handle sensor inputs when line is to far to the left ( <- 000000 )
  91. */
  92. void stateZero(String sensorReading)
  93. {
  94. Serial.print("zero: ");
  95. Serial.println(sensorReading);
  96. String importantSensors = sensorReading.substring(0,1);
  97.  
  98. if (importantSensors == "1") {
  99. setSteering(120);
  100. lineState = one;
  101. }
  102. reference_value = 0.4;
  103. }
  104.  
  105. /*
  106. * Handle sensor input when last reading was 100000
  107. */
  108. void stateOne(String sensorReading)
  109. {
  110. Serial.print("one: ");
  111. Serial.println(sensorReading);
  112. String importantSensors = sensorReading.substring(0,2);
  113. reference_value = 0.4;
  114. if (importantSensors == "00") {
  115. setSteering(120);
  116. lineState = zero;
  117. } else if(importantSensors == "11" ||importantSensors == "01") {
  118. setSteering(48);
  119. lineState = three;
  120. // reference_value = ref_speed * 0.8;
  121. }
  122. }
  123.  
  124. /*
  125. * Handle sensor input when last reading was 110000
  126. */
  127. //void stateTwo(String sensorReading)
  128. //{
  129. // String importantSensors = sensorReading.substring(0,2);
  130. // if (importantSensors == "10") {
  131. // setSteering(1500);
  132. // lineState = one;
  133. // } else if (importantSensors == "01") {
  134. // setSteering(1400);
  135. // lineState = three;
  136. // }
  137. //}
  138. /*
  139. * Hande sensor input when last reading was 010000
  140. */
  141. void stateThree(String sensorReading)
  142. {
  143. Serial.print("three: ");
  144. Serial.println(sensorReading);
  145. reference_value = 0.6;
  146. String importantSensors = sensorReading.substring(0,3);
  147. if ((importantSensors == "110") || (importantSensors =="100")) {
  148. setSteering(108);
  149. lineState = one;
  150. } else if ((importantSensors == "011") || (importantSensors == "001")) {
  151. setSteering(48); // sväng tillbaks
  152. lineState = five;
  153. }
  154.  
  155. }
  156.  
  157. /*
  158. * 011000 previous value
  159. */
  160. //void stateFour(String sensorReading)
  161. //{
  162. // String importantSensors = sensorReading.substring(1,3);
  163. // if (importantSensors == "10") {
  164. // setSteering(1400);
  165. // lineState = three;
  166. // } else if (importantSensors == "01") {
  167. // setSteering(1300);
  168. // lineState = five;
  169. // }
  170. //}
  171. /*
  172. * 001000
  173. */
  174. void stateFive(String sensorReading)
  175. {
  176. Serial.print("five: ");
  177. Serial.println(sensorReading);
  178. reference_value = 0.6;
  179. String importantSensors = sensorReading.substring(1,4); // 011100
  180. if ((importantSensors == "110") || (importantSensors == "100")) {
  181. setSteering(72);
  182. lineState = three;
  183. } else if (importantSensors == "011" || importantSensors == "001") {
  184. setSteering(48);
  185. lineState = six;
  186. }
  187. }
  188. /*
  189. * 001100
  190. */
  191. void stateSix(String sensorReading)
  192. {
  193. Serial.print("six: ");
  194. Serial.println(sensorReading);
  195. reference_value = 0.6;
  196. String importantSensors = sensorReading.substring(2,4);
  197. if (importantSensors == "10") {
  198. setSteering(72);
  199. lineState = five;
  200. } else if (importantSensors == "01") {
  201. setSteering(48);
  202. lineState = seven;
  203. }
  204. }
  205. /*
  206. * 000100
  207. */
  208. void stateSeven(String sensorReading)
  209. {
  210. Serial.print("seven: ");
  211. Serial.println(sensorReading);
  212. reference_value = 0.6;
  213. String importantSensors = sensorReading.substring(2,5);
  214. if (importantSensors == "011" || importantSensors == "001") {
  215. setSteering(48);
  216. lineState = nine;
  217. } else if (importantSensors == "110" || importantSensors == "100") {
  218. setSteering(72);
  219. lineState = six;
  220. }
  221. }
  222. /*
  223. * 000110
  224. */
  225. //void stateEight(String sensorReading)
  226. //{
  227. // String importantSensors = sensorReading.substring(3,5);
  228. // if (importantSensors == "10") {
  229. // setSteering(1200);
  230. // lineState = seven;
  231. // } else if (importantSensors == "01") {
  232. // setSteering(1100);
  233. // lineState = nine;
  234. // }
  235. //}
  236. /*
  237. * 000010
  238. */
  239. void stateNine(String sensorReading)
  240. {
  241. Serial.print("nine: ");
  242. Serial.println(sensorReading);
  243. reference_value = 0.6;
  244. String importantSensors = sensorReading.substring(3,6);
  245. if ((importantSensors == "011") || (importantSensors == "001")) {
  246. setSteering(12);
  247. lineState = eleven;
  248. } else if ((importantSensors == "110") || (importantSensors == "100")) {
  249. setSteering(72);
  250. lineState = seven;
  251. }
  252. }
  253. /*
  254. * 000011
  255. */
  256. //void stateTen(String sensorReading)
  257. //{
  258. // String importantSensors = sensorReading.substring(4);
  259. // if (importantSensors == "10") {
  260. // setSteering(1100);
  261. // lineState = nine;
  262. // } else if (importantSensors == "01") {
  263. // setSteering(1000);
  264. // lineState = eleven;
  265. // }
  266. //}
  267. /*
  268. * 000001
  269. */
  270. void stateEleven(String sensorReading)
  271. {
  272. Serial.print("eleven: ");
  273. Serial.println(sensorReading);
  274. String importantSensors = sensorReading.substring(4,6);
  275. reference_value = 0.4;
  276. if (importantSensors == "00") {
  277. setSteering(0);
  278. lineState = twelve;
  279. } else if ((importantSensors == "11" || (importantSensors == "10"))) {
  280. setSteering(72);
  281. lineState = nine;
  282. }
  283. }
  284. /*
  285. * Dissapeared to the right ( 000000 -> )
  286. */
  287. void stateTwelve(String sensorReading)
  288. {
  289. Serial.print("twelve: ");
  290. Serial.println(sensorReading);
  291. reference_value = 0.4;
  292. String importantSensors = sensorReading.substring(5,6);
  293. if (importantSensors == "1") {
  294. setSteering(0);
  295. lineState = eleven;
  296. }
  297. }
  298. /*
  299. * START STATE
  300. */
  301. void stateThirteen(String sensorReading)
  302. {
  303. Serial.print("thirteen: ");
  304. Serial.println(sensorReading);
  305. String importantSensors = sensorReading.substring(2,4);
  306. if (importantSensors == "11") {
  307. setSteering(60);
  308. lineState = six;
  309. }
  310. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement