kostenloser Webspace werbefrei: lima-city


Steuerung mit Arduino

lima-cityForumProgrammiersprachenSonstige Programmiersprachen

  1. Autor dieses Themas

    reith

    reith hat kostenlosen Webspace.

    Ich arbeite an einer Rechenreinigungssteuerung mit einer Arduino UNO. Ich stehe jetzt vor dem Problem das ich einen Ausgangszustand bis zum Eintreffen eines anderen Ereigniss speichern kann.
    zB. wenn Rechenreinigungshaken unten ankommt, gibt ein Endschalter der Steuerung zurück, dass der Hacken unten ist.
    Jetzt soll der Hacken gehoben werden (der untere Endschalter geht wieder auf AUS) bis ein anderer Endschalter meldet das der Hacken oben ist.
    Kann mir bitte jemand einen Tip geben.
  2. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

  3. Vorweg ganz auf die Schnelle:

    Dein geschildertes Teilproblem lässt sich durch eine IF-Bedinung beschreiben und zwar gemäß folgendem Pseudo-Code:

    If eingang = wert then ausgang = wert


    Damit das ganze aber jetzt korrekt funktioniert und auch zu etwas Nutze ist musst du deinen zu steuerden Prozess als Gesamtheit betrachten.

    Dann zerlegst du ihn in einzelne Steuerungsaufgaben und realisierst jede dieser Aufgaben in deiner Steuerung

    Am Schluss verknüpfst du die einzelen Aufgaben so mit Bedingungen das am schluss das gewünschte Verhaten entsteht, ggf. ist dazu dann die Erarbeitung weiterer Steuerungsaufgaben erforderlich die sich aus den grundlegenden Funktionen der Maschine zunächst nicht ohne Weiteres ableiten lassen.

    Wenn du Willens und fähig bist die nötigen Funktionen samt der verbauten Hardware (besonders Sensoren und Aktoren) zu beschreiben bin ich und die anderen Arduino bastler hier im Forum sicher in der Lage dich bei deiner Aufgabe zu unterstützen.

    Ansonsten findest du aber auch in der Dokumentation der Arduino IDE ausreichend Hinweise und Beispiele um es dir selbst zu erarbeiten. Eines sei vorweg noch angemerkt, ein Arduino kann von sich aus keine ernsthafte Hardware ansteuern, es ist also eine elektronische / elektrische / mechanische Nachbearbeitung der Steuersignale für eine echte Anwendung unumgänglich.
  4. Autor dieses Themas

    reith

    reith hat kostenlosen Webspace.

    Danke für die Antwort. Ich habe das Problem gelöst indem ich den "Heben - Ausgang" auslese und mit den "Endschalter - unten" verknüpfe.
    Derzeit verwende ich einen Versuchsaufbau mit einer Arduino UNO und einem LCD KeypadShield um die Programmierung zu lernen. Die Analogen Signale simuliere ich mit Potis.
    Später wird für die Wasserpegelwerte (Vor.- bzw. Nach Rechen) eine Drucksonde, die 4-20mA ausgibt verwendet. Das mA Signal werde ich mit einem 250Ohm Widerstand umwandeln. Mit dem Ausgängen werde ich Optokoppler ansteuern.

    Als Eingänge benötige ich:
    Start Einzeldurchlauf
    Hacke oben
    Hacke unten
    Störung-Motorschutz gelöst
    Störung-Schlaffseil

    Als Ausgänge:
    Hacke senken
    Hacke heben
    Störung

    Mir ist bewusst das ich mit diesem Versuchsaufbau zuwenige I/O habe, daher werde ich später ein serielles LCD Display verwenden.
    Da die Rechenreinigungshacke in eine Richtung etwa eine Minute unterwegs ist, möchte ich diese Zeitdauer überwachen um einen möglichen Schaden zu verhindern. Dazu fehlt mir leider noch eine Idee.

    Nachfolgend meine Code: Ich würde gern die Zeit zwischen "unterer Endlage(12) und oberer Endlage(2)"überwachen und an der "OUTPUT Störungs_LED(13) ausgeben.

    #include <LiquidCrystal.h>             //Sample using LiquidCrystal library
    
    
    LiquidCrystal lcd(8, 9, 4, 5, 6, 7); 
    
    const int analogInPin = A1;   // Istwert vor Rechen
    const int analogInPin2 = A2;  // Istwert nach Rechen
    const int analogInPin3 = A3;  // Sollwert Pegeldifferenz
    const int diffPin = 11;       // OUTPUT Pegeldifferenz_LED
    const int defaultPin = 13;    // OUTPUT Störungs_LED
    const int obenPin = 2;        // INPUT obere Endlage
    const int untenPin = 12;      // INPUT untere Endlage
    const int hebenPin = 3;       // OUTPUT Heben
    
    int sensorValue = 0;        // Eingabewert Poti vor Rechen
    int sensorValue2 = 0;       // Eingabewet Poti nach Rechen
    int outputValue = 0;        // Ausgabewert Poti vor Rechen
    int outputValue2 = 0;       // Ausgabewert Poti nach Rechen
    int defButton = 0;          // Rückgabe Zustand Störung
    int buttonState0 = 0;       // Rückgabe Zustand untere Endlage
    int buttonState1 = 0;       // Rückgabe Zustand obere Endlage
    int potiDiff = 0;           // Eingabewert Poti Pegeldifferenz Sollwert
    int diffValue = 0;          // Ausgabewert Poti Pegeldifferenz Sollwert
    int hebenState = 0;         // Rückgabe Zustand Heben
    
    
    void setup() {
      // initialize serial communications at 9600 bps:
      Serial.begin(9600); 
      lcd.begin(16,2);
      pinMode(diffPin, OUTPUT); //OUTPUT Pegeldifferenz_LED
      pinMode(defaultPin, OUTPUT); //OUTPUT Störungs_LED
      pinMode(obenPin, INPUT);
      pinMode(untenPin, INPUT);
      pinMode(hebenPin, OUTPUT);
    
    }
    
    void loop() {
      
      // Heben 
      buttonState0 = digitalRead(untenPin);
      buttonState1 = digitalRead(obenPin);
      hebenState = digitalRead(hebenPin);
      
      if (((buttonState0 == HIGH) || (hebenState == HIGH))&&(defButton == LOW)&&(buttonState1 == LOW))    {     
        // turn LED on:    
        digitalWrite(hebenPin, HIGH);  
      } 
      else {
        // turn LED off:
        digitalWrite(hebenPin, LOW); 
      }
    
     
    // Auslesen des Störungsausgang
      defButton = digitalRead(defaultPin); 
      
    
    // Abfrage Störung  
       if ((outputValue-125 < 0) || 
           (outputValue2-125 < 0) || 
           (outputValue-125 > 495) ||
           (outputValue2-125 > 495))  {
             
        digitalWrite(defaultPin, HIGH);
      }
      else {
        digitalWrite(defaultPin, LOW);
      }
       
    // Abfrage Pegeldifferenz   
      if ((outputValue - outputValue2 >= diffValue) && (defButton == LOW)) {
        digitalWrite(diffPin, HIGH);
      }
      else {
        digitalWrite(diffPin, LOW);
      }
      
      // Auslesen der Analogen Eingänge
      sensorValue = analogRead(analogInPin); 
      sensorValue2 = analogRead(analogInPin2); 
      potiDiff = analogRead(analogInPin3);  
      // Analoge Eingänge zu Analoge Ausgänge umrechnen
      outputValue = map(sensorValue, 0, 1023, 0, 625); 
      outputValue2 = map(sensorValue2, 0, 1023, 0, 625);  
      diffValue = map(potiDiff, 0, 1023, 0, 50);
      
      Serial.print("Vor Rechen = " );                       
      Serial.print(outputValue);      
      Serial.print("\t Nach Rechen = ");      
      Serial.print(outputValue2);
      Serial.print("\t Differenz = ");      
      Serial.println(outputValue - outputValue2);
      
     // "Diff. und VR" ins Display schreiben
      lcd.setCursor(0,0);
       lcd.print("Diff.  VR");
     // Ausgang Analogwert vor Rechen schreiben
       lcd.setCursor(11,0);
       if (((outputValue-125)>=0) && ((outputValue-125) < 495))   {
         lcd.println(outputValue-125);
       }
       else  {
         lcd.println("???");
       }
     // "cm" schreiben  
       lcd.setCursor(14,0);
       lcd.print("cm");
     // Pegeldifferenz schreiben
       lcd.setCursor(0,1);
       lcd.println(diffValue);
     // "cm" schreiben
       lcd.setCursor(2,1);
       lcd.print("cm");
     // "NR" schreiben
       lcd.setCursor(7,1);
       lcd.print("NR");
     // Ausgang Analogwert vor Rechen schreiben
       lcd.setCursor(11,1);
       if (((outputValue2-125)>=0) && ((outputValue2-125) < 495))  {
         lcd.println(outputValue2-125);
       }
       else  {
         lcd.println("???");
       }
     // "cm" schreiben
       lcd.setCursor(14,1);
       lcd.print("cm"); 
       
    }


    Danke im Voraus für einen guten Tip

    Beitrag zuletzt geändert: 23.3.2014 17:48:22 von reith
  5. Die Laufzeit deiner Bewegung kannst du am Besten mit der millis() Funktion überwachen.

    Am sinnvollsten geht das wenn du dir zum Beginn des Vorgangs die aktuelle Ausgabe von millis() in einer Variable speicherst.

    Dann läuft dein Vorgang ab und du speicherst dir zum Abschluss die dann aktuelle Ausgabe von millis().

    Aus der Differenz (dur = millis_ende - millis_start)ermittelst du dann die Laufzeit deines Vorgangs (dur), wenn dein Vorgang länger dauert als eine vorbestimmte Zeit kannst du dann eine Fehlermeldung auslösen.

    if dur >= maxdur then...

    siehe auch: http://arduino.cc/en/Reference/Millis#.Uy8TTM6a8xU

    Beitrag zuletzt geändert: 23.3.2014 18:07:01 von fatfox
  6. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

Dir gefällt dieses Thema?

Über lima-city

Login zum Webhosting ohne Werbung!