Arduino Nano L293D - paste@nosupamu Arduino Nano L293D - paste@nosupamu https://paste.nosupamu.de/ en Arduino Nano L293D https://paste.nosupamu.de/view/b8e258f8 Sun, 24 Sep 2017 20:37:17 +0200 ColdSphinX https://paste.nosupamu.de/view/b8e258f8
  1. #define DEBUG 0
  2.  
  3. //L293D
  4. //Motor A (left)
  5. #define MOTOR_PIN1 9 // Pin 2 of L293
  6. #define MOTOR_PIN2 10 // Pin 7 of L293
  7. //Motor B (right)
  8. #define MOTOR_PIN3 11 // Pin  10 of L293
  9. #define MOTOR_PIN4 12 // Pin  15 of L293
  10.  
  11. //IR Remote
  12. #include <IRremote.h>
  13. #define IR_PIN 8
  14. IRrecv irrecv(IR_PIN);
  15. decode_results ir_results;
  16.  
  17. //Ultrasonic sensor
  18. #define US_TRIG_PIN 7
  19. #define US_ECHO_PIN 6
  20. long duration;
  21. int distance;
  22.  
  23. enum movements{
  24.   UNDEFINED,
  25.   STOP,
  26.   FORWARD,
  27.   BACKWARD,
  28.   LEFT_ROTATE,
  29.   RIGHT_ROTATE,
  30.   LEFT_CIRCLE,
  31.   RIGHT_CIRCLE
  32. };
  33.  
  34. enum movements current_mode;
  35. enum movements next_mode;
  36. boolean evading = false;
  37. boolean moving = false;
  38.  
  39. #define TIME_WAIT 3600
  40.  
  41. void setup() {
  42.   randomSeed(analogRead(0));
  43.   //Set pins as outputs
  44.   pinMode(MOTOR_PIN1, OUTPUT);
  45.   pinMode(MOTOR_PIN2, OUTPUT);
  46.   pinMode(MOTOR_PIN3, OUTPUT);
  47.   pinMode(MOTOR_PIN4, OUTPUT);
  48.   stop();
  49.   current_mode = STOP;
  50.   next_mode = STOP;
  51.   pinMode(US_TRIG_PIN, OUTPUT);
  52.   digitalWrite(US_TRIG_PIN, LOW);
  53.   pinMode(US_ECHO_PIN, INPUT);
  54. #if DEBUG > 0
  55.   Serial.begin(9600);
  56.   Serial.println("IR Receiver Raw Data + Button Decode Test");
  57. #endif
  58.   irrecv.enableIRIn(); // Start the receiver
  59. }
  60.  
  61. void motor_a_stop() {
  62.   digitalWrite(MOTOR_PIN1, LOW);
  63.   digitalWrite(MOTOR_PIN2, LOW);
  64. }
  65.  
  66. void motor_a_forward() {
  67.   digitalWrite(MOTOR_PIN1, LOW);
  68.   digitalWrite(MOTOR_PIN2, HIGH);
  69. }
  70.  
  71. void motor_a_backward() {
  72.   digitalWrite(MOTOR_PIN1, HIGH);
  73.   digitalWrite(MOTOR_PIN2, LOW);
  74. }
  75.  
  76. void motor_b_stop() {
  77.   digitalWrite(MOTOR_PIN3, LOW);
  78.   digitalWrite(MOTOR_PIN4, LOW);
  79. }
  80.  
  81. void motor_b_forward() {
  82.   digitalWrite(MOTOR_PIN3, LOW);
  83.   digitalWrite(MOTOR_PIN4, HIGH);
  84. }
  85.  
  86. void motor_b_backward() {
  87.   digitalWrite(MOTOR_PIN3, HIGH);
  88.   digitalWrite(MOTOR_PIN4, LOW);
  89. }
  90.  
  91. void left_stop() {
  92.   motor_a_stop();
  93. }
  94.  
  95. void right_stop() {
  96.   motor_b_stop();
  97. }
  98.  
  99. void stop() {
  100.   left_stop();
  101.   right_stop();
  102.   moving = false;
  103. }
  104.  
  105. void left_forward() {
  106.   motor_a_backward();
  107.   moving = true;
  108. }
  109.  
  110. void left_backward() {
  111.   motor_a_forward();
  112.   moving = true;
  113. }
  114.  
  115. void right_forward() {
  116.   motor_b_forward();
  117.   moving = true;
  118. }
  119.  
  120. void right_backward() {
  121.   motor_b_backward();
  122.   moving = true;
  123. }
  124.  
  125. void forward() {
  126.   left_forward();
  127.   right_forward();
  128. }
  129.  
  130. void backward() {
  131.   left_backward();
  132.   right_backward();
  133. }
  134.  
  135. void left_rotate() {
  136.   left_backward();
  137.   right_forward();
  138. }
  139.  
  140. void right_rotate() {
  141.   left_forward();
  142.   right_backward();
  143. }
  144.  
  145. void left_circle() {
  146.   left_stop();
  147.   right_forward();
  148. }
  149.  
  150. void right_circle() {
  151.   right_stop();
  152.   left_forward();
  153. }
  154.  
  155. void wait() {
  156.   delay(TIME_WAIT);
  157.   stop();
  158. }
  159.  
  160. void test_movements(){
  161.   forward();
  162.   wait();
  163.   backward();
  164.   wait();
  165.   left_rotate();
  166.   wait();
  167.   right_rotate();
  168.   wait();
  169.   left_circle();
  170.   wait();
  171.   right_circle();
  172.   wait();
  173.   stop();
  174.   wait();
  175. }
  176.  
  177. void ir_decode(){
  178.   switch(ir_results.value){
  179.     /*
  180.      * 0xFF38C7 => 5 (stop)         => STOP
  181.      * 0xFF18E7 => 2 (forward)      => FORWARD
  182.      * 0xFF4AB5 => 8 (backward)     => BACKWARD
  183.      * 0xFF10EF => 4 (left rotate)  => LEFT_ROTATE
  184.      * 0xFF5AA5 => 6 (right rotate) => RIGHT_ROTATE
  185.      * 0xFF7A85 => 3 (right circle) => LEFT_CIRCLE
  186.      * 0xFF30CF => 1 (left circle)  => RIGHT_CIRCLE
  187.      */
  188.     case 0xFF38C7:
  189. #if DEBUG > 0
  190.       Serial.println("Stop (5)");
  191. #endif
  192.       next_mode = STOP;
  193.       break;
  194.  
  195.     case 0xFF18E7:
  196. #if DEBUG > 0
  197.       Serial.println("Forward (2)");
  198. #endif
  199.       next_mode = FORWARD;
  200.       break;
  201.  
  202.     case 0xFF4AB5:
  203. #if DEBUG > 0
  204.       Serial.println("Backward (8)");
  205. #endif
  206.       next_mode = BACKWARD;
  207.       break;
  208.  
  209.     case 0xFF10EF:
  210. #if DEBUG > 0
  211.       Serial.println("Left rotate (4)");
  212. #endif
  213.       next_mode = LEFT_ROTATE;
  214.       break;
  215.  
  216.     case 0xFF5AA5:
  217. #if DEBUG > 0
  218.       Serial.println("Right rotate (6)");
  219. #endif
  220.       next_mode = RIGHT_ROTATE;
  221.       break;
  222.  
  223.     case 0xFF7A85:
  224. #if DEBUG > 0
  225.       Serial.println("Left circle (3)");
  226. #endif
  227.       next_mode = LEFT_CIRCLE;
  228.       break;
  229.  
  230.     case 0xFF30CF:
  231. #if DEBUG > 0
  232.       Serial.println("Right circle (1)");
  233. #endif
  234.       next_mode = RIGHT_CIRCLE;
  235.       break;
  236.  
  237. #if DEBUG > 0
  238.     default:
  239.       Serial.print("Unknown button: ");
  240.       Serial.println(ir_results.value, HEX);
  241. #endif
  242.   }
  243. }
  244.  
  245. void sonic_check(){
  246.   //reset
  247.   digitalWrite(US_TRIG_PIN, LOW);
  248.   delayMicroseconds(2);
  249.   //Set the trigger pin on HIGH state for 10 micro seconds
  250.   digitalWrite(US_TRIG_PIN, HIGH);
  251.   delayMicroseconds(10);
  252.   digitalWrite(US_TRIG_PIN, LOW);
  253.   //Read echo
  254.   duration = pulseIn(US_ECHO_PIN, HIGH);
  255.   //Calculating distance
  256.   distance = duration * 0.034 / 2;
  257. #if DEBUG > 1
  258.   Serial.print("Distance: ");
  259.   Serial.println(distance);
  260. #endif
  261.   if (distance <= 5){
  262.     switch(current_mode){
  263.       case LEFT_ROTATE:
  264.         next_mode = LEFT_ROTATE;
  265.         break;
  266.       case RIGHT_ROTATE:
  267.         next_mode = RIGHT_ROTATE;
  268.         break;
  269.       case LEFT_CIRCLE:
  270.         next_mode = LEFT_ROTATE;
  271.         break;
  272.       case RIGHT_CIRCLE:
  273.         next_mode = RIGHT_ROTATE;
  274.         break;
  275.       default:
  276.         if (random(10) >= 5){
  277.           next_mode = LEFT_ROTATE;
  278.         } else {
  279.           next_mode = RIGHT_ROTATE;
  280.         }
  281.     }
  282.     evading = true;
  283.     //mode_check();
  284.   } else if (evading){
  285.     next_mode = FORWARD;
  286.     evading = false;
  287.   }
  288. }
  289.  
  290. void mode_check(){
  291. #if DEBUG > 2
  292.   Serial.println("Mode: ");
  293.   Serial.print("# Current: ");
  294.   Serial.println(current_mode);
  295.   Serial.print("# Next: ");
  296.   Serial.println(next_mode);
  297. #endif
  298.   if (next_mode != current_mode) {
  299.     switch(next_mode){
  300.       case STOP:
  301.         stop();
  302.         current_mode = STOP;
  303.         break;
  304.       case FORWARD:
  305.         forward();
  306.         current_mode = FORWARD;
  307.         break;
  308.       case BACKWARD:
  309.         backward();
  310.         current_mode = BACKWARD;
  311.         break;
  312.       case LEFT_ROTATE:
  313.         left_rotate();
  314.         current_mode = LEFT_ROTATE;
  315.         break;
  316.       case RIGHT_ROTATE:
  317.         right_rotate();
  318.         current_mode = RIGHT_ROTATE;
  319.         break;
  320.       case LEFT_CIRCLE:
  321.         left_circle();
  322.         current_mode = LEFT_CIRCLE;
  323.         break;
  324.       case RIGHT_CIRCLE:
  325.         right_circle();
  326.         current_mode = RIGHT_CIRCLE;
  327.         break;
  328.     }
  329.   } else {
  330.     delay(500);
  331.   }
  332. }
  333.  
  334. void loop() {
  335.   if (irrecv.decode(&ir_results)){
  336.     ir_decode();
  337.     irrecv.resume(); // receive the next value
  338.   }
  339.   if (moving){
  340.     sonic_check();
  341.   }
  342.   mode_check();
  343. #ifdef DEBUG
  344.     //test_movements()
  345. #endif
  346. }
]]>