Programm Code

const int stepPin = 3; 
const int dirPin = 4; 
int freig1 = 5;
int freig2 = 6;
int voll = 7;
int pump1 = 8;
int pump2 = 9;
int pump3 = 10;
int zylinder = 11;
int myNextion = 1;

 void pos1 (void)
 
          {
          digitalWrite(dirPin,HIGH); // Schlitten fährt zu Position 1
               
             for(int x = 0; x < 2000; x++) 
             {
                  digitalWrite(stepPin,HIGH); 
                  delayMicroseconds(500); 
                  digitalWrite(stepPin,LOW); 
                  delayMicroseconds(500); 
             }         
          }

 void grundpos1 (void)
           {
           digitalWrite(dirPin,LOW); //Schlitten fährt in Grundpostion von Position 1 
              
              for(int x = 0; x < 2000; x++) 
              {
                  digitalWrite(stepPin,HIGH);
                  delayMicroseconds(500);
                  digitalWrite(stepPin,LOW);
                  delayMicroseconds(500);
              }
           }

void pos2 (void)
 
          {
          digitalWrite(dirPin,HIGH); // Schlitten fährt zu Position 1
               
             for(int x = 0; x < 3000; x++) 
             {
                  digitalWrite(stepPin,HIGH); 
                  delayMicroseconds(500); 
                  digitalWrite(stepPin,LOW); 
                  delayMicroseconds(500); 
             }
          }

 void grundpos2 (void)
           {
           digitalWrite(dirPin,LOW); //Schlitten fährt in Grundpostion von Position 1 
              
              for(int x = 0; x < 3000; x++) 
              {
                  digitalWrite(stepPin,HIGH);
                  delayMicroseconds(500);
                  digitalWrite(stepPin,LOW);
                  delayMicroseconds(500);
              }
           }
    
void setup() {
  // Sets the two pins as Outputs
  pinMode(stepPin,OUTPUT); 
  pinMode(dirPin,OUTPUT);
  pinMode(freig1,INPUT);
  pinMode(freig2,INPUT);
  pinMode(voll,INPUT);
  pinMode(pump1,OUTPUT);
  pinMode(pump2,OUTPUT);
  pinMode(pump3,OUTPUT);
  pinMode(zylinder,OUTPUT);
  
  
  }

void loop()  {

  
    String message = myNextion.listen(); /Warten Befehle vom Nextionpanel
  {
    if (message != "") // Eingabe von Touchpanel (Serielle Schnittstelle)

  }
          {
            if (freig1=HIGH,freig2=HIGH);     // Input 1/2 aktiv
         
                int delay = 1000;    //   Motor wird zum ersten Dispenser gefahren
                pos1();      
          }
                {
                delay(10000); // 10 Sekunden delay
                digitalWrite(zylinder,HIGH);
                delay(6000);
                digitalWrite(zylinder,LOW);
                }

                    {
                      int delay = 5000;   // Motor fährt zurück in Grundposition 
                      grundpos1();
                    }
                          {
                            if (freig1=HIGH,freig2=HIGH);     // Input 1/2 aktiv
                               
                               {
                                while(voll=LOW)               // Solange das Glas nicht voll ist läuft die Pumpe 1
                                    {
                                      (pump1,HIGH);         
                                    }           
                                }
                          }     
  }

  {
    if (freig1=1,freig2=1) // Eingabe von Touchpanel (Serielle Schnittstelle)
          {
          if (freig1=HIGH,freig2=HIGH);     // Input 1/2 aktiv
         
                int delay = 1000;    //   Motor wird zum ersten Dispenser gefahren
                pos2();
                
          }
                {
                delay(10000); // 10 Sekunden delay
                digitalWrite(zylinder,HIGH);
                delay(6000);
                digitalWrite(zylinder,LOW);
                }

                    {
                      int delay = 5000;   // Motor fährt zurück in Grundposition 
                      grundpos2();
                    }

                          {
                            if (freig1=HIGH,freig2=HIGH);     // Input 1/2 aktiv
                               
                               {
                                while(voll=LOW)               // Solange das Glas nicht voll ist läuft die Pumpe 1
                                    {
                                      (pump2,HIGH);
                                      
                                    }
                                
                                 
                               }
         
                          }     
  }

}

Schaut euch bitte diesen Code mal an, was hält ihr davon?
Das mit der Seriellen Schnittstelle funktioniert noch nicht, da muss ich mich noch vertiefen.

Ansonsten mal Strg+T drücken, dann sieht es gleich schon viel schöner aus.

Schau dir das Tutorial BlinkWithoutDelay an

Das mit der Seriellen Schnittstelle funktioniert noch nicht, da muss ich mich noch vertiefen.

Es passt auch vieles andere nicht, das ist kein Code sondern irgendwie großer Murks. So viele syntaktische und logische Fehler in einem Mini-Sketch habe ich noch nicht gesehen. Das kann auch bisher nie und nimmer (ohne Mecker) durch den Compiler gegangen sein...

Lesbar ist was anderes.

Wenn du mal schreiben würdest, was du mit der seriellen Schnittstelle meinst und wie du die angeschlossen hast, bräuchten wir nicht raten.

Dann hast du was auf Pin 1 angeschlossen, was soll das machen ?

Ich rate mal, du verwendest einen Uno, da ist Pin 1 reserviert für die USB-Schnittstelle.

Also mehr Informationen würden uns alle helfen, besonders dir, da du dann auch mehr Infos erhalten würdest.

Das mit den "delays" (geht garnicht :wink: ) möchte ich auch noch mal erwähnen, wurde ja schon gesagt.

wie kommst du denn auf solche Geschichten?

while(voll=LOW)               // Solange das Glas nicht voll ist läuft die Pumpe 1
                                    {
                                      (pump1,HIGH);         
                                    }

Sowas compiliert ja nicht mal. Und wenn, kämst du aus der Nummer ja nicht wieder raus.

ElEspanol:
Sowas compiliert ja nicht mal. Und wenn, kämst du aus der Nummer ja nicht wieder raus.

Der Kode lässt sich übersetzen und die while Schleife wird niemals betreten.

Dessen ungeachtet ist er natürlich völliger Quatsch und macht etwas anderes als sein Autor meint(e).

Ich sehe ich muss den Code noch etwas überarbeiten.

Das mit der while schleife kapierie ich jedoch nicht ganz.

Ich möchte eigenlich nur das der Ausgang pump1 solange 1 ist bis der Eingang voll 1 wird.

Auf das Problem mit der Seriellen (Post #4) und den anderen Fragen bist du nicht eingegangen.

Sry, war grad einbisschen viel kritik auf einmal… :frowning:

Dachte ich fang mal mit etwas an ansonsten wird es für mich sehr unübersichtlich.

Jedoch zu den anderen Punkten.

  • ich setze einen Arduino Uno ein, darum habe ich auch den PIN 1 mal für die Serielle Komunikation gewählt, das dieser Punkt nicht wirklich stimmt wollte mich am Wochende mit der Seriellen komunikation mit einem Nextion Panel befassen.

  • und das Problem mit dem delays verstehe ich leider auch noch nicht…:wink:

  • und das Problem mit dem delays verstehe ich leider auch noch nicht...:wink:

Während eines Delay() blockiert dein System. Keine Eingaben möglich. keine andere Aktion.

Das mag dich im Augenblick nicht stören.
Aber auf Dauer ist das wie ein Stock in den Speichen.
Und das wollen wir doch nicht ....
Wir wollen dich glücklich sehen.

Nochmals zur Seriellen Schnittstelle, die verwendet D0 und D1 und sind auch vom USB Port belegt. Da kannst du beim Flashen Probleme bekommen.
Nimm lieber SoftwareSerial dafür.

Danke für den Input für das delay ich werde mal versuchen das Tutorial für das zu finden, bis jetzt habe ich nur solche auf englisch gefunden mach das ganze etwas kompliziert für mich.

Bezüglich der Schnittstelle, habe ich das mit den SoftwareSerial noch nicht ganz verstanden.

Funktioniert das evtl so:

SoftwareSerial myNextion = 1;

void setup() {

pinMode(myNextion,INPUT);

}

SoftwareSerial ist eine zusätzliche Library, die du erst installieren musst.
In den Beispielen findest du, wie die Einstellungen erfolgen müssen.
Du brauchst in jedem Fall 2 Leitungen und 2 Pins dafür.

Schau dir das zur SoftwareSerial zugehörige Beispiel an

Edit: Warst schneller

#include <SoftwareSerial.h>

Das hier ist das einzige das ich unter diesem Sketch bekomme…:frowning:

hangloose:
#include <SoftwareSerial.h>

Das hier ist das einzige das ich unter diesem Sketch bekomme...:frowning:

Verstehe ich nicht.

#include <SoftwareSerial.h>        // Durch diesen Include können wir die Funktionen 
                                   // der SoftwareSerial Bibliothek nutzen.
SoftwareSerial softSerial(1, 2); // Pin 1 ist RX, Pin 2 ist TX.
                                   // Die Funktion softSerial() kann nun wie Serial() genutzt werden.

char c_inChar;   // Jedes empfangene Zeichen kommt kurzzeitig in diese Variable.
String s_input;  // In diesem String speichern wir dann unseren kompletten Text.

void setup()
{
  // Zuerst initialisieren wir die serielle Schnittstelle des Arduino.
  Serial.begin(57600);
  Serial.println("Nachrichten von PuTTY landen hier.");

  // Dann initialisieren wir die serielle Schnittstelle der SoftwareSerial Bibliothek.
  softSerial.begin(57600);
  softSerial.println("Nachrichten vom Arduino landen hier.");
}

void loop() 
{
  // In dieser Schleife warten wir auf einen Text von PuTTY.
  while(softSerial.available() > 0){        // So lange etwas empfangen wird, durchlaufe die Schleife.
    c_inChar = softSerial.read();           // Speichere das empfangene Zeichen in der Variablen c_inChar.
    s_input.concat(c_inChar);               // Füge das Zeichen an den String an, damit wir den kompletten Text erhalten.
    if (c_inChar == '\r') {                 // War das letzte Zeichen ein CR (Carriage Return)?
      Serial.print("PuTTY hat gesagt: ");   // Dann schreibe einen Text auf den Serial Monitor.
      Serial.print(s_input);                // Füge in dieselbe Zeile den empfangenen Text ein
      Serial.print('\n');                   // und schicke noch ein NL (NewLine) für einen Zeilenumbruch hinterher.
      s_input="";                           // Lösche den String für die nächste Nachricht.
    }
  }
  
  // In dieser Schleife warten wir auf einen Text vom Arduino.
  while(Serial.available() > 0){            // So lange etwas empfangen wird, durchlaufe die Schleife.
    c_inChar = Serial.read();               // Speichere das empfangene Zeichen in der Variablen c_inChar.
    s_input.concat(c_inChar);               // Füge das Zeichen an den String an, damit wir den kompletten Text erhalten.
    if (c_inChar == '\r') {                 // War das letzte Zeichen ein NL?
      softSerial.print("Arduino sagt: ");   // Dann schicke die Einleitung zu PuTTY.
      softSerial.print(s_input);            // Füge in dieselbe Zeile den empfangenen Text ein
      softSerial.print('\n');               // und schicke noch ein CR hinterher.
      s_input="";                           // Lösche den String wieder für die nächste Nachricht.
    }
  }
}

Hier habe ich ein Beispiel gefunden, leider verstehe ich den Code noch nicht ganz oder weiss nicht wie ich einen empfangen Befehl vom Panel verarbeiten kann.

Das ist ein schlechtes Beispiel. Du solltest ein Beispiel nehmen, welches mit der Library mitgeliefert wird.

Und nicht die Pins 0 oder 1 verwenden!