API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 26th, 2019
155
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Arduino 10.59 KB | None | 0 0
raw download clone embed print report
  1. #include <LiquidCrystal.h>
  2. LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
  3.  
  4. unsigned long aktuelleZeit;
  5. unsigned long vergangeneZeit_A;
  6. unsigned long interval_1 = 2000;
  7. int messungPin1 = HIGH;
  8. int messungPin1Alt = HIGH;
  9. byte encoderWert = 1;                             // -1 ( eins weniger als 0 ) == 255
  10. const byte hal = 3;
  11. const byte encoderPinA = 10;                      // Phase A vom Drehencoder
  12. const byte encoderPinB = 11;                      // Phase B vom Drehencoder
  13. const byte tasterEnter = 12;                      // Pin an dem der Encoder Taster angeschlossen ist
  14. int wertSpeichern = 0;                            // gespeicherter Encoderwert
  15. int encoderGedrueckt = 0;                         // Statusspeicher ob Encodertaster betätigt wurde
  16. int encoderTaster = HIGH;                         // Taster im Encoder
  17. int gleisAlt = 1;                                 // Scheibe Position alt
  18. int gleisNeu = 0;                                 // Position welche die Scheibe anfahren soll
  19.  
  20. int schritte = 0;                                 // Schritte die deer Motor (Hallsensor betätigt) zurücklegen muss
  21. int sensor = LOW;
  22. const byte tasterWenden = A3;
  23. int status_tasterWenden = HIGH;
  24. int tasterWenden_gedrueckt = 0;
  25. unsigned long tasterWenden_Druckzeit;
  26.  
  27. unsigned long encoderDruckzeit;                   // Zeit wann der Encodertaster betaetigt wurde
  28. unsigned long entprellZeit = 200;                 // Zeit die nach der betaetigung eines Tasters gewartet wird
  29. unsigned long startZeit;                          // Abfrage begin Sensor an Bühne
  30. unsigned long interval = 2000;                    // Zeitabstand nachdem ein Zustand des Sensors erkannt wird
  31. unsigned long vergangeneZeit = 0;                 // Speichervariable um die Vergangene Zeit zu speichern
  32. int pin_motor_links = A1;                         // Richtungspin an H-Brücke für Links
  33. int pin_motor_rechts = A2;                        // Richtungspin an H-Brücke für Rechts
  34. const byte sensor_referenz = 2;                   // Pin für Sensor Referenz aussen an der Grube (Nullstellung)
  35. int status_sensor_referenz;                       // Speichervariable für Status von Sensor für Referenzfahrt
  36.  
  37. // Statusvariablen
  38. bool nullStellung = false;                      // Speichervariable ob Referenzfahrt erfolgt ist
  39. bool enter = false;                             // Bestaetigung das der Encoder gedrueckt wurde
  40. bool ergebnis = false;                          // Berechnung der Schritte und Richtung beendet/gestartet
  41. bool start = false;                           // Schritte Zaehlen beendet/gestartet
  42. bool drehung = false;                        // 180 Grad Drehung beendet/gestartet
  43. bool motorAnsteuerung = false;                  // Motor steht/läuft
  44.  
  45. void setup() {
  46.   pinMode(sensor_referenz, INPUT);
  47.   pinMode(pin_motor_links, OUTPUT);
  48.   pinMode(pin_motor_rechts, OUTPUT);
  49.   pinMode(encoderPinA, INPUT);
  50.   pinMode(encoderPinB, INPUT);
  51.   pinMode(tasterEnter, INPUT);
  52.   pinMode(hal, INPUT);
  53.   pinMode(tasterWenden, INPUT);
  54.   Serial.begin(9600);
  55.   lcd.begin(16, 2);
  56.   lcd.setCursor(0, 0);
  57.   lcd.print("Drehscheiben-");
  58.   lcd.setCursor(0, 1);
  59.   lcd.print("steuerrung");
  60.   delay (2000);
  61.   //lcd.clear();
  62.   //lcd.begin(16, 2);
  63.   //lcd.setCursor(0, 0);
  64.   //lcd.print("Wert");
  65.   //lcd.setCursor(0, 1);
  66.   //lcd.print(encoderWert);
  67. }
  68.  
  69. void loop() {
  70.   referenzFahrt();
  71.   encoder_lesen();
  72.   schritt();
  73.   schritteZaehlen();
  74.   wenden();
  75. }
  76.  
  77. void referenzFahrt() {
  78.   aktuelleZeit = millis();
  79.   status_sensor_referenz = digitalRead(sensor_referenz);
  80.   if ((nullStellung == false) && (status_sensor_referenz == HIGH)) {
  81.  
  82.     digitalWrite (pin_motor_rechts, HIGH);
  83.     digitalWrite (pin_motor_links, LOW);
  84.     if (millis() - vergangeneZeit_A >= interval_1) {
  85.       Serial.println("2 Sekunden abgelaufen");
  86.       lcd.clear();
  87.       lcd.begin(16, 2);
  88.       lcd.setCursor(0, 0);
  89.       lcd.print("Referenzfahrt");
  90.       lcd.setCursor(0, 1);
  91.       lcd.print("gestartet");
  92.       vergangeneZeit_A = millis();
  93.     }
  94.   }
  95.   else if ((nullStellung == false) && (status_sensor_referenz == LOW)) {
  96.     Serial.println(nullStellung);
  97.     Serial.println(status_sensor_referenz);
  98.     Serial.println(vergangeneZeit_A);
  99.  
  100.     nullStellung = true;
  101.     digitalWrite(pin_motor_rechts, LOW);
  102.     digitalWrite(pin_motor_links, LOW);
  103.     lcd.clear();
  104.     lcd.begin(16, 2);
  105.     lcd.setCursor(0, 0);
  106.     lcd.print("Referenzfahrt");
  107.     lcd.setCursor(0, 1);
  108.     lcd.print("beendet");
  109.     delay(2000);
  110.     lcd.clear();
  111.     lcd.begin(16, 2);
  112.     lcd.setCursor(0, 0);
  113.     lcd.print("Gleis");
  114.     lcd.setCursor(0, 1);
  115.     lcd.print(encoderWert);
  116.   }
  117.  
  118. }
  119.  
  120. void encoder_lesen () {
  121.   messungPin1 = digitalRead(encoderPinA);
  122.   if ((messungPin1 == LOW) && (messungPin1Alt == HIGH) && (nullStellung == true)) {
  123.     if (digitalRead(encoderPinB) == HIGH) {
  124.       encoderWert++ ;
  125.       if (encoderWert > 48) {
  126.         encoderWert = 1;
  127.       }
  128.     } else {
  129.       encoderWert-- ;
  130.       if (encoderWert < 1) {
  131.         encoderWert = 48;
  132.       }
  133.  
  134.     }
  135.  
  136.     lcd.begin(16, 2);
  137.     lcd.setCursor(0, 0);
  138.     lcd.print("Gleis");
  139.     lcd.setCursor(0, 1);
  140.     lcd.print(encoderWert);
  141.   }
  142.   encoderTaster = digitalRead(tasterEnter);
  143.   if (encoderTaster == LOW)
  144.   {
  145.     encoderDruckzeit = millis();
  146.     encoderGedrueckt = 1;
  147.   }
  148.   if ((millis() - encoderDruckzeit > entprellZeit) && encoderGedrueckt == 1) {
  149.     wertSpeichern = encoderWert;
  150.     Serial.println(wertSpeichern);
  151.     encoderGedrueckt = 0;
  152.     enter = true;
  153.  
  154.   }
  155.   messungPin1Alt = messungPin1;
  156. }
  157.  
  158. void schritt () {
  159.   if (enter == true) {
  160.     gleisNeu = wertSpeichern;
  161.     //von = random(schritte_max) + 1;   //von und bis 'auswürfeln'
  162.     //nach = random(schritte_max) + 1;
  163.     Serial.print("Von ");       // Von 1
  164.     Serial.print(gleisAlt);
  165.     Serial.print(" nach ");     // nach 12
  166.     Serial.println(gleisNeu);
  167.     if (gleisAlt > gleisNeu) {
  168.       int schritte_links = (gleisAlt - gleisNeu);
  169.       Serial.println("Entfernung in Drehrichtung links");
  170.       Serial.println(schritte_links);
  171.       Serial.println(" ");
  172.  
  173.       int schritte_rechts = gleisNeu - gleisAlt;
  174.       Serial.println("Entfernung in Drehrichtung rechts");
  175.       Serial.println(schritte_rechts);
  176.       int schritte_rechts_erg = schritte_rechts + 48;
  177.       Serial.println(schritte_rechts_erg);
  178.       Serial.println(" ");
  179.       if (schritte_links >= schritte_rechts_erg) {
  180.         schritte = schritte_rechts_erg;
  181.         pin_motor_links = 0;
  182.         pin_motor_rechts = 255;
  183.         Serial.println("Drehrichtung rechts");
  184.  
  185.       }
  186.       else if (schritte_links < schritte_rechts_erg) {
  187.         schritte = schritte_links;
  188.         pin_motor_links = 255;
  189.         pin_motor_rechts = 0;
  190.         Serial.println("Drehrichtung links");
  191.       }
  192.     }
  193.     if (gleisAlt < gleisNeu) {
  194.       int schritte_links = abs ((gleisNeu - gleisAlt) - 48);
  195.       Serial.println("Entfernung in Drehrichtung links");
  196.       Serial.println(schritte_links);
  197.       Serial.println(" ");
  198.       int schritte_rechts = (gleisNeu - gleisAlt);
  199.       Serial.println("Entfernung in Drehrichtung rechts");
  200.       Serial.println(schritte_rechts);
  201.       Serial.println(" ");
  202.       if (schritte_links >= schritte_rechts) {
  203.         Serial.println("Drehrichtung rechts");
  204.         schritte = schritte_rechts;
  205.         pin_motor_links = 0;
  206.         pin_motor_rechts = 255;
  207.       }
  208.       else if (schritte_links < schritte_rechts) {
  209.         Serial.println("Drehrichtung links");
  210.         schritte = schritte_links;
  211.         pin_motor_links = 255;
  212.         pin_motor_rechts = 0;
  213.       }
  214.     }
  215.  
  216.     enter = false;
  217.     ergebnis = true;
  218.     lcd.clear();
  219.     lcd.begin(16, 2);
  220.     lcd.setCursor(0, 0);
  221.     lcd.print("Drehung start");
  222.     lcd.setCursor(0, 1);
  223.     lcd.print("Restl. Pos.");
  224.     lcd.setCursor(14, 1);
  225.     lcd.print(schritte);
  226.     Serial.println("Schritte");
  227.     Serial.println(schritte);
  228.   }
  229. }
  230.  
  231. void schritteZaehlen () {
  232.  
  233.   sensor = digitalRead (hal);
  234.   startZeit = millis();
  235.   if ((schritte != 0) && (ergebnis == true)) {
  236.     start = true;
  237.     if ((startZeit - vergangeneZeit >= interval) && (sensor == LOW) && (start == true)) {
  238.       vergangeneZeit = startZeit;
  239.       schritte--;
  240.       lcd.clear();
  241.       lcd.begin(16, 2);
  242.       lcd.setCursor(0, 0);
  243.       lcd.print("Drehung start");
  244.       lcd.setCursor(0, 1);
  245.       lcd.print("Restl. Pos.");
  246.       lcd.setCursor(14, 1);
  247.       lcd.print(schritte);
  248.       //Serial.println("Schritte");
  249.       //Serial.println(schritte);
  250.     }
  251.   }
  252.   else if ((schritte == 0) && (start == true)) {
  253.     start = false;
  254.     Serial.println("Ziel");
  255.     lcd.clear();
  256.     lcd.begin(16, 2);
  257.     lcd.print("Drehung");
  258.     lcd.setCursor(0, 0);
  259.     lcd.setCursor(0, 1);
  260.     lcd.print("beendet");
  261.     delay(2000);
  262.     lcd.clear();
  263.     lcd.begin(16, 2);
  264.     lcd.setCursor(0, 0);
  265.     lcd.print("Gleis");
  266.     lcd.setCursor(0, 1);
  267.     lcd.print(encoderWert);
  268.     ergebnis = false;
  269.     drehung = false;
  270.     encoderWert = gleisNeu;
  271.     gleisAlt = gleisNeu;
  272.   }
  273. }
  274.  
  275. void wenden() {
  276.   status_tasterWenden = digitalRead(tasterWenden);
  277.   if ((status_tasterWenden == LOW) && (enter == false) && (nullStellung == true) && (ergebnis == false)) {
  278.     tasterWenden_Druckzeit = millis();
  279.     tasterWenden_gedrueckt = 1;
  280.     drehung = true;
  281.   }
  282.   if ((millis() - tasterWenden_Druckzeit > entprellZeit) && tasterWenden_gedrueckt == 1) {
  283.     if (encoderWert >= 25) {
  284.       int merker1 = 48 - gleisAlt;
  285.       gleisNeu = 24 - merker1;
  286.       schritte = 24;
  287.       Serial.println(gleisAlt);
  288.       tasterWenden_gedrueckt = 0;
  289.       ergebnis = true;
  290.       lcd.clear();
  291.       lcd.begin(16, 2);
  292.       lcd.setCursor(0, 0);
  293.       lcd.print("Drehung start");
  294.       lcd.setCursor(0, 1);
  295.       lcd.print("Restl. Pos.");
  296.       lcd.setCursor(14, 1);
  297.       lcd.print(schritte);
  298.       Serial.println("Schritte");
  299.       Serial.println(schritte);
  300.       encoderWert = gleisNeu;
  301.       Serial.println(" ");
  302.       Serial.println(encoderWert);
  303.       Serial.println(gleisAlt);
  304.       Serial.println(gleisNeu);
  305.     }
  306.     else if (gleisNeu < 25) {
  307.       gleisNeu = gleisAlt + 24;
  308.       schritte = 24;
  309.       Serial.println(gleisAlt);
  310.       tasterWenden_gedrueckt = 0;
  311.       ergebnis = true;
  312.       lcd.clear();
  313.       lcd.begin(16, 2);
  314.       lcd.setCursor(0, 0);
  315.       lcd.print("Drehung start");
  316.       lcd.setCursor(0, 1);
  317.       lcd.print("Restl. Pos.");
  318.       lcd.setCursor(14, 1);
  319.       lcd.print(schritte);
  320.       Serial.println("Schritte");
  321.       Serial.println(schritte);
  322.       encoderWert = gleisNeu;
  323.       Serial.println(" ");
  324.       Serial.println(encoderWert);
  325.       Serial.println(gleisAlt);
  326.       Serial.println(gleisNeu);
  327.     }
  328.   }
  329. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!