Go Down

Topic: Projekt zur Ermittlung der Dauerbetriebseigenschaften unterschiedlicher Sensoren (Read 6542 times) previous topic - next topic

Hayley_Hay

Danke! Ich fang mal an:

1. Die Berechnung der Restzeit machst Du entweder zentral in loop() und gibst Diese nur aus, wenn Die auch auf's Display soll (und sich geändert hat), oder direkt vor der Ausgabe auf dem Display.
Das klappt soweit, allerdings gibt es einen Speicherüberlauf. Ich berechne
Code: [Select]
remaining_time = (Intervall - ( millis() - Millis)) / 1000;
  elapsed_time = (millis()-Millis)/1000;

elapsed funktioniert, remaining erzeugt (allerdings gerade nur bei pause1) einen Speicherüberlauf an Stelle der 0.

Außerdem möchte ich das Programm insofern abändern, als dass nach jedem x-ten Durchlauf ein neuer Zustand air() angefahren wird. Ich habe es mit einem Zähler am Ende des letzten case versucht, und im loop() dann eine if(counter<=x)-Abfrage vor den Programmdurchlauf gesetzt:

Code: [Select]

  if (SW1_status == HIGH && SW2_status == HIGH && SW3_status == HIGH) {  // Schalter 1+2+3
    if (count_programm <= 3) {
      programm();
    } else {
      Air();
      count_programm = 0;
    }
  }


Leider funktioniert es so nicht, air() wird nicht angefahren.

Ansonsten hätte ich noch eine Frage zu einem bash-Skript das ich gefunden habe und mit dessen Hilfe ich die Daten in eine SQLite-DB schreiben will. Vielleicht kann mir dazu auch jemand hier helfen? Leider habe ich von bash noch viel weniger Ahnung als von C... Der Code macht im Grunde was er soll, allerdings muss ich (nach einem Neustart/Upload des Arduino) die Gerätedatei (ACM0 ... 1 ... ) in Zeile 16 manuell ändern. Wenn der Versuch läuft und aus irgend einem Grund ein Neustart passiert muss das aber automatisch erkannt werden - wie bekomme ich das hin?
Code: [Select]
#!/bin/bash
# Data Slam Script v0.1
# User define Function (UDF)
LogLine(){
  echo -E "`date +%s`,${line}"
 sqlite3 arduino.db3 "insert into control_data(time_stamp, millis, state, elapsed, V1, M1,M2,M3) values (`date +%s`,${line})"
}
### Main script stars here ###
# Store file name
FILE=""
 
# Make sure we get file name as command line argument
# Else read it from standard input device
stty -F /dev/ttyACM0 cs8 115200 ignbrk -brkint -icrnl -imaxbel -opost -onlcr -isig -icanon -iexten -echo -echoe -echok -echoctl -echoke noflsh -ixon -crtscts
if [ "$1" == "" ]; then
   FILE="/dev/ttyACM1"
else
   FILE="$1"
   # make sure file (serial device) exist and is readable
   if [ ! -f $FILE ]; then
  echo "$FILE : does not exists"
  exit 1
   elif [ ! -r $FILE ]; then
  echo "$FILE: can not read"
  exit 2
   fi
fi
# Create Database if it does not exist
 
if [ ! -f "arduino.db3" ]; then
  echo "Creating database"
        sqlite3 arduino.db3 "CREATE TABLE control_data (time_stamp integer , millis integer, state integer, elapsed integer, V1 integer, M1 integer, M2 integer,M3 integer);"
fi
exec 3<&0
exec 0<"$FILE"
while true
do
 
# use $line variable to process line in processLine() function
while read -r line
        do
              LogLine $line
        done
       sleep 50 # This delay can be changed to match the delay of the Arduino
done
exec 0<&3
exit 0

Hayley_Hay

So, kurzes update:
Das Steuerungsprogramm fährt durch, die Zeit wird korrekt berechnet, und die Kommunikation habe ich insofern vereinfacht, als dass nur noch der Sensor-Arduino am RasPi hängt. Um den aktuellen Zustand der Anlage zu erhalten habe ich dazu zwei OUTPUTs inkl GND vom Steuer-Arduino auf zwei INPUTs inkl GND vom Sensor-Arduino gelegt (in der Skizze fehlen die beiden Leitungen, nur GND ist eingezeichnet). Die beiden geben dann die jeweiligen Zustände weiter und werden dann (hoffentlich) mit den Sensordaten und dem timestamp auf den RasPi geschrieben. Es fehlt noch das korrekte Wiedereinsetzen am Unterbrochenen Programmpunkt, aber das ist erst einmal nebensächlich.

Code: [Select]

float vers = 2.5;

#include<Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Belegung der Ein- und Ausgaenge, Relais und Switches, Zustandsvariablen

const byte RY_V1_pin = 3;  // Verdichter
byte RY_V1_state;

const byte RY_M1_pin = 5;  // Magnetventil 1
byte RY_M1_state;

const byte RY_M2_pin = 7;  // Magnetventil 2
byte RY_M2_state;

const byte RY_M3_pin = 9;  // Magnetventil 3
byte RY_M3_state;

const byte SW1_pin = 4;    // Schalter 1
bool SW1_status;
const byte SW2_pin = 6;    // Schalter 2
bool SW2_status;
const byte SW3_pin = 8;    // Schalter 3
bool SW3_status;

const byte trig_A = 2;
const byte trig_B = 13;

// Zeit
const unsigned int long pump_intervall = 325000;// 333000;
const unsigned int long pause_intervall = 20000; // 325000;
const unsigned int long air_intervall = 30000;//60000;
unsigned int long Millis;
unsigned int long Intervall;
unsigned int long schreib_timestore;
unsigned int long remaining_time;
unsigned int long elapsed_time;
const int long schreib_intervall = 1000;

bool A_state;
bool B_state;

void setup() {
  Wire.begin();
  Serial.begin(9600);
  pinMode(RY_M2_pin, OUTPUT);
  pinMode(RY_M1_pin, OUTPUT);
  pinMode(RY_V1_pin, OUTPUT);
  pinMode(trig_A, OUTPUT);
  pinMode(trig_B, OUTPUT);
  pinMode(SW1_pin, INPUT);
  pinMode(SW2_pin, INPUT);
  pinMode(SW3_pin, INPUT);
  digitalWrite(SW1_pin, HIGH);
  digitalWrite(SW2_pin, HIGH);
  digitalWrite(SW3_pin, HIGH);
  lcd.init();
  lcd.clear();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Pumpen/Belueften");
  lcd.setCursor(0, 1);
  lcd.print("Funktion waehlen");
}

void dig_Write() {
  digitalWrite(RY_V1_pin, RY_V1_state);
  digitalWrite(RY_M1_pin, RY_M1_state);
  digitalWrite(RY_M2_pin, RY_M2_state);
  digitalWrite(RY_M3_pin, RY_M3_state);
  digitalWrite(trig_A, A_state);
  digitalWrite(trig_B, B_state);
}

enum ZUSTAENDE {A_to_B, pause_1 , B_to_A, pause_2, pause_0, air};
byte curr_state = pause_2;
byte next_state = A_to_B;
byte prev_state = B_to_A;

const int rounds = 2;
int count_rounds = 0;
int count_global = 0;

void A_B () {
  RY_V1_state = HIGH;
  RY_M1_state = HIGH;
  RY_M2_state = LOW;
  RY_M3_state = LOW;
  A_state = HIGH;
  B_state = LOW;
  dig_Write();
  Millis = millis();
  curr_state = A_to_B;
  return;
}

void B_A () {
  RY_V1_state = HIGH;
  RY_M1_state = LOW;
  RY_M2_state = HIGH;
  RY_M3_state = LOW;
  A_state = LOW;
  B_state = HIGH;
  dig_Write();
  Millis = millis();
  curr_state = B_to_A;
  return;
}

void Air () {
  RY_V1_state = HIGH;
  RY_M1_state = LOW;
  RY_M2_state = LOW;
  RY_M3_state = HIGH;
  A_state = HIGH;
  B_state = HIGH;
  dig_Write();
  Millis = millis();
  curr_state = air;
  return;
}

void pause () {
  RY_V1_state = LOW;
  RY_M1_state = LOW;
  RY_M2_state = LOW;
  RY_M3_state = LOW;
  A_state = LOW;
  B_state = LOW;
  curr_state = pause_0;
  dig_Write();
  Millis = millis();
  return;
}

void programm() {
  if (millis() - Millis >= Intervall) {
    switch (next_state) {

      case A_to_B:
        count_rounds++;
        count_global++;
        prev_state = curr_state;
        A_B();
        next_state = pause_1;
        Intervall = pump_intervall;
        break;

      case pause_1:
        pause();
        prev_state = curr_state;

        next_state = B_to_A;
        Intervall = pause_intervall;
        break;

      case B_to_A:
        prev_state = curr_state;
        B_A();
        next_state = pause_2;
        Intervall = pump_intervall;
        break;

      case pause_2:
        prev_state = curr_state;
        pause();
        if (count_rounds <= rounds)
        {
          next_state = A_to_B;
        }
        else {
          next_state = air;
        }
        Intervall = pause_intervall;
        break;

      case air:
        prev_state = curr_state;
        Intervall = air_intervall;
        Air();
        count_rounds = 0;
        next_state = pause_2;
    }
  }
}


bool readingSwitches() {
  delay(50);
  SW1_status = digitalRead(SW1_pin);
  SW2_status = digitalRead(SW2_pin);
  SW3_status = digitalRead(SW3_pin);
  return SW1_status, SW2_status, SW3_status;
}

void schreiben() {
  if (millis() - schreib_timestore >= schreib_intervall) {
    schreib_timestore = millis();
    Serial.print(millis());
    Serial.print(",");
    Serial.print(curr_state);
    Serial.print(",");
    Serial.print(elapsed_time);
    Serial.print(",");
    Serial.print(RY_V1_state);
    Serial.print(",");
    Serial.print(RY_M1_state);
    Serial.print(",");
    Serial.print(RY_M2_state);
    Serial.print(",");
    Serial.print(RY_M3_state);
    Serial.print(",");
    Serial.print(A_state);
    Serial.print(B_state);
    Serial.println("");
  }
}

void Display() {
  lcd.clear();
  lcd.setCursor(0, 0);

  lcd.print("Runde ");
  lcd.print(count_global);
  lcd.print(" ");
  if (curr_state == 4) {
    lcd.print("- Pause");
  }
  if (curr_state == 0) {
    lcd.print("- A->B");
  }
  if (curr_state == 2) {
    lcd.print("- B->A");
  }
  if (curr_state == 5) {
    lcd.print("- Air");
  }

  lcd.setCursor(0, 1);

  if (next_state == pause_1 || next_state == pause_2 || next_state == pause_0) {
    lcd.print("Pause in");
  }
  if (next_state == A_to_B) {
    lcd.print("A->B in ");
  }
  if (next_state == B_to_A) {
    lcd.print("B->A in ");
  }
  if (next_state == air) {
    lcd.print("Air in ");
  }
  lcd.print(remaining_time);
  lcd.print("s");


  lcd.setCursor(11, 1);
  lcd.print("v");
  lcd.print(vers);
}


void loop() {
  schreiben();

  elapsed_time = (millis() - Millis) / 1000;
  remaining_time = Intervall / 1000 - elapsed_time;

  readingSwitches();

  // alternativ:
  //SW1_status = digitalRead(SW1_pin);
  //SW2_status = digitalRead(SW2_pin);
  //SW3_status = digitalRead(SW3_pin);

  if (SW1_status == HIGH && SW2_status == HIGH && SW3_status == HIGH) {  // Schalter 1+2+3
    //   if (count_programm <= 3) {
    programm();
    // } else {
    //   Air();
    //   count_programm = 0;
    // }
  }

  if (SW1_status == HIGH && SW2_status == HIGH && SW3_status == LOW) {   // Schalter 1+2
    A_B();
  }

  if (SW1_status == HIGH && SW2_status == LOW && SW3_status == HIGH) {   // Schalter 1+3
    B_A();
  }

  if (SW1_status == HIGH && SW2_status == LOW && SW3_status == LOW) {    // Schalter 1
    Air();
  }

  if (SW1_status == LOW && SW2_status == LOW && SW3_status == LOW) { // kein Schalter
    //Millis = millis();
    // if (SW1_status == LOW && SW2_status == LOW && SW3_status == LOW){
    pause();
    //}
  }
  if (SW1_status == LOW && SW2_status == LOW && SW3_status == HIGH) {
    pause();
  }

  if (SW1_status == LOW && SW2_status == HIGH && SW3_status == HIGH) {
    pause();
  }

  Display();
  delay(50);
}



Jetzt habe ich noch folgende Frage: Der von mir als Referenz zu untersuchende Schwimmerschalter benötigt mindestens 24 V. Ich würde ihn entsprechend der Skizze an den vorhandenen Trafo an 230V AC anschließen (rote Leitungen), und den Ausgang mittels Spannungsteiler R1 + R2 (z.B. 1kOhm und 267 kOhm) an den Digitaleingang legen. Von den 230 V einmal abgesehen (die lasse ich mir vor Inbetriebnahme noch mal abnehmen) - passt das so mit den ganzen Verschaltungen von GND oder mach ich mir damit etwas kaputt?


agmue

Der von mir als Referenz zu untersuchende Schwimmerschalter benötigt mindestens 24 V.
24V AC halte ich für keine gute Idee, da der Arduino mit Wechselspannung nichts anfangen kann. Mit galvanisch getrennten 24 V DC sollte es gehen. Wobei es mich immer etwas nervös macht, wenn GND vom Netzteil geschaltet wird. Möglicherweise ja so:

                  Pin7
                   │
24V ─── S1 ─── R1 ─┴─ R2 ─── GND

Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Hayley_Hay

24V AC halte ich für keine gute Idee, da der Arduino mit Wechselspannung nichts anfangen kann.
Danke! Das ist natürlich ein Fehler im Schaltplan.

Quote
                  Pin7
                   │
24V ─── S1 ─── R1 ─┴─ R2 ─── GND


Das klingt gut, dann mach ich das so. edit: Dann habe ich aber keine 24 V mehr für den Schalter, wenn ich da noch 1kOhm davorhänge...

agmue

Dann habe ich aber keine 24 V mehr für den Schalter, wenn ich da noch 1kOhm davorhänge...
Wenn Du den Schalter öffnest, hast Du 24V an den Kontakten. R1 und R2 spielen da keine Rolle. Oder benötigst Du einen minimalen Strom?
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Hayley_Hay

Wenn Du den Schalter öffnest, hast Du 24V an den Kontakten. R1 und R2 spielen da keine Rolle. Oder benötigst Du einen minimalen Strom?
Ich denke nicht, zumindest steht auf dem Schalter nichts davon. Aber wenn er schließt habe ich ja keine 24 V mehr, oder habe ich da etwas übersehen?

agmue

Aber wenn er schließt habe ich ja keine 24 V mehr, ...
Hoffentlich!

... zumindest steht auf dem Schalter nichts davon.
Auf Schaltern steht üblicherweise, welche Spannung und welchen Strom sie maximal schalten können.

Im Datenblatt finden sich dann auch Angaben zur Legierung der Kontakte und den dadurch bedingten minimalen Spannungen und Strömen. Wenn man mit einem Schütz versucht, 1 µA / 5 V zu schalten, können sich Oxidschichten bilden, die nicht mehr durchschlagen werden. Wenn Du solche Dinge berücksichtigen möchtest, mußt Du schon Spezialisten des Fachs befragen und einen Link zum Datenblatt gleich dazu liefern.
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Hayley_Hay

Hoffentlich!
Auf Schaltern steht üblicherweise, welche Spannung und welchen Strom sie maximal schalten können.

Im Datenblatt finden sich dann auch Angaben zur Legierung der Kontakte und den dadurch bedingten minimalen Spannungen und Strömen. Wenn man mit einem Schütz versucht, 1 µA / 5 V zu schalten, können sich Oxidschichten bilden, die nicht mehr durchschlagen werden. Wenn Du solche Dinge berücksichtigen möchtest, mußt Du schon Spezialisten des Fachs befragen und einen Link zum Datenblatt gleich dazu liefern.

Ich denke, der Schalter benötigt eine Minimalspannung, da es sich nicht um einen einfachen mechanischen Schalter handelt, sondern sich in dem Schwimmer irgend eine Elektronik befindet. Ich habe bereits versucht, ihn an den 5V vom Arduino zu betreiben, aber das hat nicht funktioniert oder das Programm abstürzen lassen. Wenn ich also richtig liege, dass bei der von Dir vorgeschlagenen Schaltung nur noch 19 V anliegen, wird vermutlich wieder das selbe passieren. Aber ich werde es morgen einfach mal ausprobieren. Vielen Dank bis hierher!

agmue

... irgend eine Elektronik ...
Meine Aussagen beziehen sich genau auf das, was Du im Schaltplan eingezeichnest hast: einen Schalter als Öffner.
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Hayley_Hay

Meine Aussagen beziehen sich genau auf das, was Du im Schaltplan eingezeichnest hast: einen Schalter als Öffner.
Ah, ok. Das war dann schon wieder mein Fehler. Ich habe hier nur einen Schließer, ursprünglich war es ein Öffner.

edit: Also wäre wohl die ursprüngliche Variante, ergänzt um eine Sperrdiode zwischen Arduino und Schalter eine günstige, sichere Möglichkeit?

agmue

Ob Öffner oder Schließer ist nicht problematish, aber "... irgend eine Elektronik ..." schon. Da halte ich mich komplett zurück.
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Hayley_Hay

Ob Öffner oder Schließer ist nicht problematish, aber "... irgend eine Elektronik ..." schon. Da halte ich mich komplett zurück.
Ok, aber mehr kann ich auch aus dem Datenblatt nicht entnehmen. Die Elektronik ist eine Vermutung, denn wenn es nur ein Schalter wäre würde er ja auch an 5 V funktionieren und die Angabe 24 V - 230 V wäre nicht sinnvoll.

Hayley_Hay

Ich melde mich mal wieder hier mit einem kleinen Update:

Die Übertragung der Daten läuft jetzt stabil über den seriellen Monitor des RasPi, das Skript zur Erstellung der Datenbank funktioniert leider nicht zuverlässig. Trotzdem habe ich so schon einige Stunden an Datenaufzeichnung zusammenbekommen.

Die Steuerung mittels des einen Arduino läuft prinzipiell ebenfalls wie gewünscht (Abfahren des Programms Pumpen - Pause - Pumpen ... Belüften ). Allerdings bleibt es regelmäßig über Nacht stehen, scheinbar (bisher drei Mal) immer an der selben Stelle zum Ende des einen Pumpzyklus nach ca. 28 000 s Gesamtlaufzeit. Ich komme leider nicht dahinter, woran es liegen könnte, zumal ich frühere, einfachere Versionen bereits länger laufen lassen konnte, ohne dass es zu einem Abbruch kam. Blöderweise habe ich dafür keine ordentliche Versionierung.

Vielleicht kommt es irgendwo zu einem Überlauf oder dergleichen? Ich lasse mal den Code hier, vielleicht hat ja jemand eine Idee? Das Problem tritt natürlich nur im Modus 'Programm' auf.

Code: [Select]

#include<Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Belegung der Ein- und Ausgaenge, Relais und Switches, Zustandsvariablen

const byte RY_V1_pin = 3;  // Verdichter
byte RY_V1_state;

const byte RY_M1_pin = 5;  // Magnetventil 1
byte RY_M1_state;

const byte RY_M2_pin = 7;  // Magnetventil 2
byte RY_M2_state;

const byte RY_M3_pin = 9;  // Magnetventil 3
byte RY_M3_state;

const byte SW1_pin = 4;    // Schalter 1
bool SW1_status;
const byte SW2_pin = 6;    // Schalter 2
bool SW2_status;
const byte SW3_pin = 8;    // Schalter 3
bool SW3_status;

const byte trig_A = 2;
const byte trig_B = 13;

bool A_state;
bool B_state;


// Zeit
const unsigned int long pump_intervall = 315000;
const unsigned int long pause_intervall = 20000;
const unsigned int long air_intervall = 30000;

unsigned int long remaining_time;
unsigned int long elapsed_time;

unsigned int long Millis;
unsigned int long Intervall;

unsigned int long schreib_timestore;
const int long schreib_intervall = 1000;


void setup() {
  Wire.begin();
  Serial.begin(9600);

  pinMode(trig_A, OUTPUT);
  pinMode(trig_B, OUTPUT);

  pinMode(RY_M3_pin, OUTPUT);
  digitalWrite(RY_M3_pin, HIGH);

  pinMode(RY_M2_pin, OUTPUT);
  digitalWrite(RY_M2_pin, HIGH);

  pinMode(RY_M1_pin, OUTPUT);
  digitalWrite(RY_M1_pin, HIGH);

  pinMode(RY_V1_pin, OUTPUT);
  digitalWrite(RY_V1_pin, HIGH);

  pinMode(SW1_pin, INPUT);
  pinMode(SW2_pin, INPUT);
  pinMode(SW3_pin, INPUT);
  digitalWrite(SW1_pin, HIGH);
  digitalWrite(SW2_pin, HIGH);
  digitalWrite(SW3_pin, HIGH);

  lcd.init();
  lcd.clear();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Pumpen/Belueften");
  lcd.setCursor(0, 1);
  lcd.print("Funktion waehlen");
}

void dig_Write() {
  digitalWrite(RY_V1_pin, RY_V1_state);
  digitalWrite(RY_M1_pin, RY_M1_state);
  digitalWrite(RY_M2_pin, RY_M2_state);
  digitalWrite(RY_M3_pin, RY_M3_state);
  digitalWrite(trig_A, A_state);
  digitalWrite(trig_B, B_state);
}

enum ZUSTAENDE {
  A_to_B, pause_1 , B_to_A, pause_2, pause_0, air
};

byte curr_state = pause_2;
byte next_state = A_to_B;
byte prev_state = B_to_A;

const int rounds = 2;
int count_rounds = 0;
int count_global = 0;

void A_B () {
  RY_V1_state = LOW;
  RY_M1_state = LOW;
  RY_M2_state = HIGH;
  RY_M3_state = HIGH;
  A_state = 1;
  B_state = 0;
  dig_Write();
  Millis = millis();
  curr_state = A_to_B;
  return;
}

void B_A () {
  RY_V1_state = LOW;
  RY_M1_state = HIGH;
  RY_M2_state = LOW;
  RY_M3_state = HIGH;
  A_state = 0;
  B_state = 1;
  dig_Write();
  Millis = millis();
  curr_state = B_to_A;
  return;
}

void Air () {
  RY_V1_state = LOW;
  RY_M1_state = HIGH;
  RY_M2_state = HIGH;
  RY_M3_state = LOW;
  A_state = 1;
  B_state = 1;
  dig_Write();
  Millis = millis();
  curr_state = air;
  return;
}

void pause () {
  RY_V1_state = HIGH;
  RY_M1_state = HIGH;
  RY_M2_state = HIGH;
  RY_M3_state = HIGH;
  curr_state = pause_0;
  A_state = 0;
  B_state = 0;
  dig_Write();
  Millis = millis();
  return;
}

void programm() {
  if (millis() - Millis >= Intervall) {
    switch (next_state) {

      case A_to_B:
        count_rounds++;
        count_global++;
        prev_state = curr_state;
        A_B();
        next_state = pause_1;
        Intervall = pump_intervall;
        break;

      case pause_1:
        pause();
        prev_state = curr_state;

        next_state = B_to_A;
        Intervall = pause_intervall;
        break;

      case B_to_A:
        prev_state = curr_state;
        B_A();
        next_state = pause_2;
        Intervall = pump_intervall;
        break;

      case pause_2:
        prev_state = curr_state;
        pause();
        if (count_rounds <= rounds)
        {
          next_state = A_to_B;
        }
        else {
          next_state = air;
        }
        Intervall = pause_intervall;
        break;

      case air:
        prev_state = curr_state;
        Intervall = air_intervall;
        Air();
        count_rounds = 0;
        next_state = pause_2;
    }
  }
}

unsigned int long switches_last_millis;
const unsigned int long switches_intervall = 50;

bool readingSwitches() {
  if(millis()- switches_last_millis < switches_intervall) return;
  switches_last_millis += switches_intervall;

  SW1_status = digitalRead(SW1_pin);
  SW2_status = digitalRead(SW2_pin);
  SW3_status = digitalRead(SW3_pin);
  return;
}

void schreiben() {
  if (millis() - schreib_timestore >= schreib_intervall) {
    schreib_timestore = millis();
    Serial.print(millis());
    Serial.print(",");
    Serial.print(curr_state);
    Serial.print(",");
    Serial.print(elapsed_time);
    Serial.print(",");
    Serial.print(RY_V1_state);
    Serial.print(",");
    Serial.print(RY_M1_state);
    Serial.print(",");
    Serial.print(RY_M2_state);
    Serial.print(",");
    Serial.print(RY_M3_state);
    Serial.println("");
  }
}

unsigned int display_last_millis;
const unsigned int display_intervall = 1000;

void Display() {
  if(millis()- display_last_millis < display_intervall) return;
  display_last_millis += display_intervall;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Runde ");
  lcd.print(count_global);
  lcd.print(" ");
  if (curr_state == 4) {
    lcd.print("- Pause");
  }
  if (curr_state == 0) {
    lcd.print("- A->B");
  }
  if (curr_state == 2) {
    lcd.print("- B->A");
  }
  if (curr_state == 5) {
    lcd.print("- Air");
  }
  lcd.setCursor(0, 1);
  if (next_state == pause_1 || next_state == pause_2 || next_state == pause_0) {
    lcd.print("Pause in ");
  }
  if (next_state == A_to_B) {
    lcd.print("A->B in ");
  }
  if (next_state == B_to_A) {
    lcd.print("B->A in ");
  }
  if (next_state == air) {
    lcd.print("Air in ");
  }
  lcd.print(remaining_time);
  lcd.print(" s");
}


void loop() {
  schreiben();

  elapsed_time = (millis() - Millis) / 1000;
  remaining_time = Intervall / 1000 - elapsed_time;

  readingSwitches();

  if (SW1_status == HIGH && SW2_status == HIGH && SW3_status == HIGH) {  // Schalter 1+2+3
    programm();
  }

  if (SW1_status == HIGH && SW2_status == HIGH && SW3_status == LOW) {   // Schalter 1+2
    A_B();
  }

  if (SW1_status == HIGH && SW2_status == LOW && SW3_status == HIGH) {   // Schalter 1+3
    B_A();
  }

  if (SW1_status == HIGH && SW2_status == LOW && SW3_status == LOW) {    // Schalter 1
    Air();
  }

  if (SW1_status == LOW && SW2_status == LOW && SW3_status == LOW) { // kein Schalter
    pause();
    //}
  }
  if (SW1_status == LOW && SW2_status == LOW && SW3_status == HIGH) {
    pause();
  }

  if (SW1_status == LOW && SW2_status == HIGH && SW3_status == HIGH) {
    pause();
  }

  Display();
}



agmue

Code: [Select]
unsigned int display_last_millis;
const unsigned int display_intervall = 1000;

Wenn ich int im Zusammenhang mit millis() sehe, werde ich skeptisch.
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Hayley_Hay

Code: [Select]
unsigned int display_last_millis;
const unsigned int display_intervall = 1000;

Wenn ich int im Zusammenhang mit millis() sehe, werde ich skeptisch.
Danke! Das stell ich mal ab und schau, was die Nacht bringt...

Go Up