CPP 164
ARDUINO SMART CAR SOURCE (Kevin Christen) By theneedyguy on 7th June 2017 04:13:36 PM
  1. /*
  2.  
  3.     Authoren:                      Kevin Christen, Michael Reber
  4.  
  5.     Version:                          1.1
  6.  
  7.     Beschreibung:              Dieses Arduino-Skript steuert den Arduino Smart-Car und lässt ihn verschiedene
  8.  
  9.  
  10.  
  11. */
  12.  
  13.  
  14.  
  15.  
  16.  
  17. // Variabeln für Motor
  18.  
  19. // Hier wird die Pinbelegung festgelegt.
  20.  
  21. // Strom für linken Motor
  22.  
  23. int MOT_L = 10;
  24.  
  25. // Strom für rechten Motor
  26.  
  27. int MOT_R = 5;
  28.  
  29. // Signal für links Rückwarts fahren.
  30.  
  31. int MOT_L_REV = 9;
  32.  
  33. // Signal für links Vorwärts fahren.
  34.  
  35. int MOT_L_VOR = 8;
  36.  
  37. // Signal für rechts Vorwärts fahren.
  38.  
  39. int MOT_R_VOR = 7;
  40.  
  41. // Signal für rechts Rückwarts fahren.
  42.  
  43. int MOT_R_REV = 6;
  44.  
  45.  
  46.  
  47.  
  48.  
  49. // Variabeln für Sensor
  50.  
  51. // Wir speichern das gelesene Signal in dieser Variabel ab.
  52.  
  53. int SENSOR_SIGNAL;
  54.  
  55. // Diese Variabel hält schlusendlich die ausgerechnete Distanz.
  56.  
  57. int SENSOR_VALUE;
  58.  
  59. // Input Pin des Sensors.
  60.  
  61. int SENSOR_INPUT_PIN = 0;
  62.  
  63.  
  64.  
  65. // Definiere Variabeln für Timing.
  66.  
  67. // Diese Werte sind in Milisekunden.
  68.  
  69. int TIME_5 = 5000;
  70.  
  71. int TIME_2 = 2000;
  72.  
  73. int TIME_1 = 1000;
  74.  
  75.  
  76.  
  77. // Variabel für den STATE
  78.  
  79. // Der State wird bei jedem Loop gelesen und entscheidet, welcher Case ausgeführt werden soll.
  80.  
  81. int STATE;
  82.  
  83.  
  84.  
  85. // Variabel für den timer
  86.  
  87. // Diese Variabel ist wichtig, um den STATE zu wechseln. Wir zählen immer
  88.  
  89. int timer;
  90.  
  91.  
  92.  
  93. // Variabel für die Spirale
  94.  
  95. // Diese wird nur im Case für die Spiralchoreographie verändert und benötigt.
  96.  
  97. int SPIRAL;
  98.  
  99.  
  100.  
  101. // Variabeln für die ZICK-ZACK operation
  102.  
  103. // Diese werden nur für den Case Zick-Zack verändert und benötigt.
  104.  
  105. int p_LEFT;
  106.  
  107. int p_RIGHT;
  108.  
  109.  
  110.  
  111. void setup() {
  112.  
  113.  
  114. // Hier legen wir fest, welche Komponenten welchen pinMode haben.
  115.  
  116. pinMode(MOT_L,OUTPUT);
  117.  
  118. pinMode(MOT_L_VOR,OUTPUT);
  119.  
  120. pinMode(MOT_L_REV,OUTPUT);
  121.  
  122. pinMode(MOT_R,OUTPUT);
  123.  
  124. pinMode(MOT_R_VOR,OUTPUT);
  125.  
  126. pinMode(MOT_R_REV,OUTPUT);
  127.  
  128. pinMode(SENSOR_INPUT_PIN,OUTPUT);
  129.  
  130. // Wir öffnen den Serial Monitor. Dieser wurde / wird hier für Debugging verwendet.
  131.  
  132. Serial.begin(9600);
  133.  
  134.  
  135.  
  136. // Wir legen die Werte unserer globalen Veriabeln vor dem loop void fest.
  137.  
  138.  
  139.  
  140. // 255 ist volle Stromzufuhr, 0 keine (p_LEFT, p_RIGHT, SPIRAL)
  141.  
  142. p_LEFT = 255;
  143.  
  144. p_RIGHT = 255;
  145.  
  146. SPIRAL = 255;
  147.  
  148. // Hier legen wir fest, welcher der initiale State ist, in dem das Programm beginnen soll.
  149.  
  150. STATE = 0;
  151.  
  152. // Wir legen die initiale timer Zeit auf 1 Sekunde fest.
  153.  
  154. timer = TIME_1;
  155.  
  156.  
  157.  
  158. // Wichtige Instruktion. Nicht löschen.
  159.  
  160. byte ins[] = {0x4d, 0x61, 0x64, 0x65, 0x20, 0x62, 0x79, 0x20, 0x4b, 0x65, 0x76, 0x69, 0x6e, 0x20, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x4d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x20, 0x52, 0x65, 0x62, 0x65, 0x72};
  161.  
  162. Serial.write(ins, sizeof(ins));
  163.  
  164.  
  165.  
  166. }
  167.  
  168.  
  169.  
  170. void loop() {
  171.  
  172.  
  173. // Hier wird der StateChanger aufgerufen.
  174.  
  175. StateChanger();
  176.  
  177.  
  178.  
  179.  
  180.  
  181. }
  182.  
  183.  
  184.  
  185. /*
  186.  
  187.     Der StateChanger lässt den Smart-Car Choreographien ausführen.
  188.  
  189.     Wir verwenden switch-case, um "pseudo"-Multitasking möglich zu machen.
  190.  
  191. */
  192.  
  193. void StateChanger(){
  194.   switch(STATE){
  195.     // Case 0 ist der Case, der den Wagen vorwärts fahren lässt für 1 Sekunde.
  196.  
  197.     // Case 0 wir aufgerufen, wenn STATE = 0 ist.
  198.  
  199.     case 0:
  200.  
  201.       // Hier wird das Signal des Abstandsmessers zu Beginn der Schlaufe gelesen.
  202.  
  203.       SENSOR_SIGNAL = analogRead(SENSOR_INPUT_PIN);
  204.  
  205.       SENSOR_VALUE=(6762/(SENSOR_SIGNAL-9))-4;
  206.  
  207.       // Wagen fährt vorwärts mit Hilfe der forward Funktion.
  208.  
  209.       forward(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV);
  210.  
  211.       // Timer wird eine milisekunde heruntergezählt.
  212.  
  213.       timer = timer - 1;
  214.  
  215.       // Wenn der timer <= 0 wird hier fortgefahren.
  216.  
  217.       if (timer <= 0){
  218.         // Wir warten 2 Sekunden, wechseln zu state 1 und setzen den timer auf 1 Sekunde.
  219.  
  220.         halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 2000);
  221.  
  222.         // State wird auf 1 gestellt, damit der Case 1 ausgeführt wird.
  223.  
  224.         STATE = 1;
  225.  
  226.         timer = TIME_1;
  227.  
  228.       // Wenn der Sensor merkt, dass etwas im Weg ist, wird hier fortgefahren.
  229.  
  230.       }else if (SENSOR_VALUE <= 10 & SENSOR_VALUE >= 0){
  231.         // Wir weichen aus mit Hilfe der evade Funktion, nachdem wir 100 milisekunden stillgestanden sind.
  232.  
  233.         halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 100);
  234.  
  235.         evade(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV);
  236.  
  237.       }else{
  238.         // Wir tun nichts, wenn beide Bedingungen nicht erfüllt sind.
  239.  
  240.       }
  241.  
  242.     break;
  243.  
  244.     // Case 1 ist der Case, der den Wagen rückwarts fahren lässt für 1 Sekunde.
  245.  
  246.     // Case 1 wir aufgerufen, wenn STATE = 1 ist.
  247.  
  248.     case 1:
  249.  
  250.       // Da wir Rückwärts fahren, messen wir hier den Sensor nicht.
  251.  
  252.       // Die funktion reverse lässt den Wagen rückwärts fahren.
  253.  
  254.       reverse(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV);
  255.  
  256.       // Timer wird eine milisekunde heruntergezählt.
  257.  
  258.       timer = timer - 1;
  259.  
  260.       // Wenn der timer <= 0 wird hier fortgefahren.
  261.  
  262.       if (timer <= 0){
  263.         // 2 Sekunden anhalten, State auf 2 stellen, timer auf 5s stellen.
  264.  
  265.         halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 2000);
  266.  
  267.         STATE = 2;
  268.  
  269.         timer = TIME_5;
  270.  
  271.       }
  272.  
  273.     break;
  274.  
  275.     // Case 2 ist der Case, in dem der Wagen im Kreis fährt for 5 Sekunden
  276.  
  277.     // Case 2 wir aufgerufen, wenn STATE = 2 ist.
  278.  
  279.     case 2:
  280.  
  281.       // Hier wird das Signal des Abstandsmessers zu Beginn der Schlaufe gelesen.
  282.  
  283.       SENSOR_SIGNAL = analogRead(SENSOR_INPUT_PIN);
  284.  
  285.       SENSOR_VALUE=(6762/(SENSOR_SIGNAL-9))-4;
  286.  
  287.       // Die Funktion kreis lässt den Wagen im Kreis fahren. Wir führen einem Rad einfach weniger Strom zu.
  288.  
  289.       kreis(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 255, 190);
  290.  
  291.       // Timer wird eine milisekunde heruntergezählt.
  292.  
  293.       timer = timer - 1;
  294.  
  295.       // Wenn der timer <= 0 wird hier fortgefahren.
  296.  
  297.       if (timer <= 0){
  298.         // Wir warten 2 Sekunden, wechseln zu state 3 und setzen den timer auf 10 Sekunden.
  299.  
  300.         halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 2000);
  301.  
  302.         STATE = 3;
  303.  
  304.         timer = 10000;
  305.  
  306.       // Wenn der Sensor merkt, dass etwas im Weg ist, wird hier fortgefahren.
  307.  
  308.       }else if (SENSOR_VALUE <= 10 & SENSOR_VALUE >= 0){
  309.         // Wir weichen aus mit Hilfe der evade Funktion, nachdem wir 100 milisekunden stillgestanden sind.
  310.  
  311.         halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 100);
  312.  
  313.         evade(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV);
  314.  
  315.       }else{
  316.          // Wir tun nichts, wenn beide Bedingungen nicht erfüllt sind.
  317.  
  318.       }
  319.  
  320.     break;
  321.  
  322.     // Case 3 ist der Case, wo der Wagen eine Spirale fährt.
  323.  
  324.     // Case 3 wir aufgerufen, wenn STATE = 3 ist.
  325.  
  326.     case 3:
  327.  
  328.       // Hier wird das Signal des Abstandsmessers zu Beginn der Schlaufe gelesen.
  329.  
  330.       SENSOR_SIGNAL = analogRead(SENSOR_INPUT_PIN);
  331.  
  332.       SENSOR_VALUE=(6762/(SENSOR_SIGNAL-9))-4;
  333.  
  334.       kreis(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 255, SPIRAL);
  335.  
  336.       timer = timer - 1;
  337.  
  338.       // Wir geben SPIRAL einen Wert zwischen 90 und 255 je nachdem, welchen Wert timer hat. Dazu verwenden wir eine Map, die die Zeit zu Werten zwischen 90 und 255 mappt.
  339.  
  340.       SPIRAL = map(timer, 0, 10000, 90, 255);
  341.  
  342.       // Wenn der timer <= 0 wird hier fortgefahren.
  343.  
  344.       if (timer <= 0){
  345.           // Wir warten 2 Sekunden, wechseln zu state 4 und setzen den timer auf 20 Sekunden und setzen SPIRAL zurück auf 255.
  346.  
  347.           halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 2000);
  348.  
  349.           STATE = 4;
  350.  
  351.           timer = 20000;
  352.  
  353.           SPIRAL = 255;
  354.  
  355.         // Wenn der Sensor merkt, dass etwas im Weg ist, wird hier fortgefahren.
  356.  
  357.         }else if (SENSOR_VALUE <= 10 & SENSOR_VALUE >= 0){
  358.           // Wir weichen aus mit Hilfe der evade Funktion, nachdem wir 100 milisekunden stillgestanden sind.
  359.  
  360.           halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 100);
  361.  
  362.           evade(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV);
  363.  
  364.         }else{
  365.            // Wir tun nichts, wenn beide Bedingungen nicht erfüllt sind.
  366.  
  367.         }
  368.  
  369.      
  370.  
  371.     break;
  372.  
  373.     // Case 4 ist der Case, wo der Wagen ein Zick-Zack Muster fährt.
  374.  
  375.     // Case 4 wir aufgerufen, wenn STATE = 4 ist.
  376.  
  377.     case 4:
  378.  
  379.       // Hier wird das Signal des Abstandsmessers zu Beginn der Schlaufe gelesen.
  380.  
  381.       SENSOR_SIGNAL = analogRead(SENSOR_INPUT_PIN);
  382.  
  383.       SENSOR_VALUE=(6762/(SENSOR_SIGNAL-9))-4;
  384.  
  385.       // Wir benutzen die Funktion kreis, um die Stromzufuhr der einzelnen Motoren zu verändern.
  386.  
  387.       kreis(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, p_LEFT, p_RIGHT);
  388.  
  389.       timer = timer - 1;
  390.  
  391.       // Wenn der timer <= 0 wird hier fortgefahren.
  392.  
  393.       if (timer <= 0){
  394.           // Wir warten 2 Sekunden, wechseln zu state 0 und setzen den timer auf 1 Sekunden und setzen die p_LEFT und p_RIGHT zurück auf 255.
  395.  
  396.           halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 2000);
  397.  
  398.           STATE = 0;
  399.  
  400.           timer = TIME_1;
  401.  
  402.           p_LEFT = 255;
  403.  
  404.           p_RIGHT = 255;
  405.  
  406.         // Wenn der Sensor merkt, dass etwas im Weg ist, wird hier fortgefahren.
  407.  
  408.         }else if (SENSOR_VALUE <= 10 & SENSOR_VALUE >= 0){
  409.           // Wir weichen aus mit Hilfe der evade Funktion, nachdem wir 100 milisekunden stillgestanden sind.
  410.  
  411.           halt(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV, 100);
  412.  
  413.           evade(MOT_L, MOT_R, MOT_L_VOR, MOT_L_REV, MOT_R_VOR, MOT_R_REV);
  414.  
  415.         }else if (timer <= 20000 & timer >= 15000){
  416.           // Wenn timer zwischen 20 und 15 Sekunden, ändere nichts. (fahre geradeaus.)
  417.  
  418.         }else if (timer <= 15000 & timer >= 14000) {
  419.           // Entferne power rechts.
  420.  
  421.           p_RIGHT = 0;
  422.  
  423.         }else if (timer <= 14000 & timer >= 9000) {
  424.           // gib wieder volle power rechts.
  425.  
  426.           p_RIGHT = 255;
  427.  
  428.         }else if (timer <= 9000 & timer >= 8000) {
  429.           // entferne power links
  430.  
  431.           p_LEFT = 0;
  432.  
  433.         }else if (timer <= 8000 & timer >= 3000) {
  434.           // fahre wieder mit beiden rädern.
  435.  
  436.           p_LEFT = 255;
  437.  
  438.         }else{
  439.            // Wir tun nichts, wenn alle Bedingungen nicht erfüllt sind.
  440.  
  441.         }
  442.  
  443.     break;
  444.  
  445.   }
  446.  
  447. }
  448.  
  449.  
  450.  
  451. /*
  452.  
  453.  
  454.  
  455.     Hier sind einige Funktionen, die unsere Motoren ansteuern.
  456.  
  457.  
  458.  
  459. */
  460.  
  461.  
  462.  
  463. // Vorwärts fahren
  464.  
  465. void forward(int POW_L, int POW_R, int SIG_L_VOR, int SIG_L_REV, int SIG_R_VOR, int SIG_R_REV){
  466.   digitalWrite(POW_L, HIGH);
  467.  
  468.   digitalWrite(POW_R, HIGH);
  469.  
  470.   digitalWrite(SIG_L_REV, LOW);
  471.  
  472.   digitalWrite(SIG_R_REV, LOW);
  473.  
  474.   digitalWrite(SIG_L_VOR, HIGH);
  475.  
  476.   digitalWrite(SIG_R_VOR, HIGH);
  477.  
  478. }
  479.  
  480. // Rückwarts fahren
  481.  
  482. void reverse(int POW_L, int POW_R, int SIG_L_VOR, int SIG_L_REV, int SIG_R_VOR, int SIG_R_REV){
  483.   digitalWrite(POW_L, HIGH);
  484.  
  485.   digitalWrite(POW_R, HIGH);
  486.  
  487.   digitalWrite(SIG_L_REV, HIGH);
  488.  
  489.   digitalWrite(SIG_R_REV, HIGH);
  490.  
  491.   digitalWrite(SIG_L_VOR, LOW);
  492.  
  493.   digitalWrite(SIG_R_VOR, LOW);
  494.  
  495. }
  496.  
  497. // Ausweichen
  498.  
  499. void evade(int POW_L, int POW_R, int SIG_L_VOR, int SIG_L_REV, int SIG_R_VOR, int SIG_R_REV){
  500.   digitalWrite(POW_L, HIGH);
  501.  
  502.   digitalWrite(POW_R, HIGH);
  503.  
  504.   digitalWrite(SIG_L_REV, HIGH);
  505.  
  506.   digitalWrite(SIG_R_REV, HIGH);
  507.  
  508.   digitalWrite(SIG_L_VOR, LOW);
  509.  
  510.   digitalWrite(SIG_R_VOR, LOW);
  511.  
  512.   delay(1000);
  513.  
  514.   digitalWrite(POW_L, HIGH);
  515.  
  516.   digitalWrite(POW_R, HIGH);
  517.  
  518.   digitalWrite(SIG_L_REV, HIGH);
  519.  
  520.   digitalWrite(SIG_R_REV, LOW);
  521.  
  522.   digitalWrite(SIG_L_VOR, LOW);
  523.  
  524.   digitalWrite(SIG_R_VOR, LOW);
  525.  
  526.   delay(1000);
  527.  
  528. }
  529.  
  530. // Anhalten
  531.  
  532. void halt(int POW_L, int POW_R, int SIG_L_VOR, int SIG_L_REV, int SIG_R_VOR, int SIG_R_REV, int DELAY){
  533.   digitalWrite(POW_L, HIGH);
  534.  
  535.   digitalWrite(POW_R, HIGH);
  536.  
  537.   digitalWrite(SIG_L_REV, LOW);
  538.  
  539.   digitalWrite(SIG_R_REV, LOW);
  540.  
  541.   digitalWrite(SIG_L_VOR, LOW);
  542.  
  543.   digitalWrite(SIG_R_VOR, LOW);
  544.  
  545.   delay(DELAY);
  546.  
  547. }
  548.  
  549. // Im Kreis fahren (je nach Stromzufuhr zu den Motoren)
  550.  
  551. void kreis(int POW_L, int POW_R, int SIG_L_VOR, int SIG_L_REV, int SIG_R_VOR, int SIG_R_REV, int KREIS_L, int KREIS_R){
  552.   analogWrite(POW_L, KREIS_L);
  553.  
  554.   analogWrite(POW_R, KREIS_R);
  555.  
  556.   digitalWrite(SIG_L_REV, LOW);
  557.  
  558.   digitalWrite(SIG_R_REV, LOW);
  559.  
  560.   digitalWrite(SIG_L_VOR, HIGH);
  561.  
  562.   digitalWrite(SIG_R_VOR, HIGH);
  563.  
  564. }

Paste is for source code and general debugging text.

Login or Register to edit, delete and keep track of your pastes and more.

Raw Paste

Login or Register to edit or fork this paste. It's free.