Danke! Habe nur einen kleinen Fehler entdeckt, wenn ich das sagen darf.
Habe hier das HIGH auf LOW geändert ...
if (werte[9] == 0) {
if (inSpuelen) {
digitalWrite(ventil_1, LOW);
inSpuelen = false;
Serial.println("Spuelen aus");
}
.. und hier ...
else {
//Spülen
inSpuelen = true;
digitalWrite(ventil_1, HIGH);
Serial.println("Spuelen an");
}
das LOW auf HIGH
Im bisherigen Code hatten wir mit HIGH aber den anfänglichen AUS-Zustand definiert oder?
Damit wäre Spülen = LOW (Wasser läuft) und Spülen aus = HIGH (Wasser stop).
Wie denn nun?
Gruß Tommy
Oh, ich dachte immer, HIGH bedeutet LED an bzw. Ventil offen. Und der aktuelle Code arbeitet auch so.
Jetzt müssen wir erst mal klären, was nun richtig ist.
Am Anfang hast Du geschrieben:
Wert 1: 1 oder 0: Ventil 1 aktiv/nicht aktiv
Wert 2: ms vor erster Öffnung
Wert 3: Öffnungdauer in ms
Wert 4: 1 oder 0: Ventil 1: zweite Öffnung ja oder nein
Wert 5: ms vor zweiter Öffnung
Wert 6: Öffnungdauer für zweite Öffnung in ms
Wert 7: 1 oder 0: Ventil 1: dritte Öffnung ja oder nein
Wert 8: ms vor dritter Öffnung
Wert 9: Öffnungdauer für dritte Öffnung in ms
Wert 10: 1 oder 0: öffnen Ventil 1 dauerhaft zum spülenDas bedeutet für mich, es kommt erst die Zeit zu (LED dunkel) und dann die Zeit auf (LED) hell.
Wenn ich den Code aus #56 nehme, kommt zuerstdigitalWrite(ventil_1, HIGH);
LED_timestore = millis();
Serial.print(" HIGH "); Serial.print("Runde: "); Serial.print(runde); Serial.print(" LED_timestore gesetzt auf: "); Serial.println(LED_timestore);
Das ist damit die Dunkelphase uind die ist HIGH. Prüfe das nochmal genau. Nicht dass wir beginnen aneinander vorbei zu schreiben. Gruß Tommy
Du wirst es nicht glauben, aber jetzt bin ich verwirrt.
Betrachten wir mal einen Auszug aus #56:
if (werte[9] == 0) {
if (runde < 3 && werte[runde*3] != 0) {
if (LedStatus == LOW && millis() - LED_timestore >= werte[runde*3+1] ) { // zeit für aus
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" LED_timestore: "); Serial.println(LED_timestore);
digitalWrite(ventil_1, HIGH);
LED_timestore = millis();
Serial.print(" HIGH "); Serial.print("Runde: "); Serial.print(runde); Serial.print(" LED_timestore gesetzt auf: "); Serial.println(LED_timestore);
LedStatus = HIGH;
}
Ich habe das immer so interpretiert: die LED ist ja beim Starten erstmal dunkel, also aus, also LOW.
Mit
LedStatus == LOW && millis() - LED_timestore >= werte[runde*3+1]
überprüfen wir doch, ob die Differenz zwischen der aktuellen Zeit (millis) und der zuletzt gemerkten Zeit (LED_timestore) größer als wert[1] (=Dunkelphase) ist. Falls ja, wird die LED eingeschaltet, also auf HIGH gesetzt.
Sehe ich das komplett falsch? Unabhängig davon geht im Moment ja alles so, wie ich es mir dachte.
Ok, Du hast Recht. Der Denkfehler lag bei mir.
Dann kan es ja weiter gehen. Hast Du Dir mal einfache Strukturen angeschaut?
Gruß Tommy
Puh, freut mich, wenn ich mal nicht daneben lag.
Klar, ich schau mir das mit den Strukturen gerne an. Ich hoffe, dass ich heute noch dazu komme, bin nämlich sehr neugierig, was es damit auf sich hat.
Ich muss heute nur noch meine letzten Dinge vor dem Urlaub für den Job erledigen.
Melde mich aber sicher wieder. Sieh' es als Versprechen oder als Drohung. 
So, ich habe mich mal etwas in die prinzipielle Verwendung in Strukturen eingelesen. Ich erkenne auch die wesentlichen Unterschiede/Vorteile zu den Arrays.
Allerdings erkenne ich in meinem konkreten Fall keinen Vorteil zu einem Array, da ich ja lauter Werte des gleichen Typs schicke, also ganzzahlige Werte.
Bei dem häufig angeführten Beispiel mit Adressen, also einer Kombination aus Text und Zahlen, ist ein struct sicherlich sinnvoll, aber bei meiner Problemstellung auch?
Du darfst nicht nur die eingelesenen Werte sehen, sondern auch die internen Variablen, die die Steuerung für jedes Ventil wieder braucht.
Du willst ja nicht für jedes Ventil einen eigenen Code schreiben.
Ich habe mal folgende Datenstruktur aufgebaut:
const uint8_t feldAnzahl = 10;
const uint8_t ventilAnzahl = 3;
const uint8_t restAnzahl = 4;
const int trenn = 999;
// Pins
const byte ventil_1 = 2;
const byte ventil_2 = 3;
const byte ventil_3 = 4;
uint8_t feldIdx, pufferIdx, ventilIdx;
char puffer[10];
boolean gelesen = false;
// die restlichen 4 Werte für die Kamera und den Blitz
int rest[restAnzahl];
// Die Daten für 1 Ventil
typedef struct ventil {
byte pin;
uint8_t runde;
byte LedStatus;
uint32_t LED_timestore;
boolean inSpuelen;
int werte[feldAnzahl];
};
// Ein Array aus Ventilen mit Initialisierung von pin und runde
ventil ventile[ventilAnzahl] = {
{ventil_1,99},
{ventil_2,99},
{ventil_3,99}
};
Die Pins für die 3 Ventile/LED mußt Du noch kontrollieren.
Nun überlege mal, wie Du das mit einzelnen Variablen und einem großen Array aufbauen würdest. Tu es nicht.
Wenn Dir dieser Daten-Aufbau klar ist, kommt der Rest.
Grup Tommy
Tja, was soll ich sagen. Dankeschön.
Ich kann das schon im Großen und Ganzen nachvollziehen, allerdings habe ich jetzt absolut keine Ahnung das Ganze in Routinen "weiterzuverarbeiten". Deine bisherigen Codes mit arrays waren für mich besser zu durchschauen.
Das hört sich vielleicht jetzt etwas "unverschämt" an, aber so bin ich jetzt eigentlich komplett drauf angewiesen, dass du mir alles fertig machst. Verstehst du? Bitte nicht falsch verstehen!!!
Zusätzlich spielen die letzten vier Werte schon auch noch eine sehr wichtige Rolle.
Das war mir klar und das ist auch nicht verwunderlich. Du wirst in dem Code vieles bekannte aus den vorherigen Versionen wieder finden. Deshalb habe ich auch die Variablennamen wie LED_status beibehalten, obwohl es um ein Ventil geht. So kannst Du aber besser vergleichen.
Die Steuwerung von Kamera und Blitzlicht ist ja völlig unabhängig vom bestehenden Rest. Das kannst Du mit Sicherheit selbst einbauen. Die Werte werden schon mit eingelesen.
// intRead2
// Beispieleingabe Werte (mit NL abschließen)
// 1|5000|1000|1|3000|1000|1|2000|1000|0|999|1|5100|1100|1|3100|1100|1|2100|1100|0|999|1|5200|1200|1|3200|1200|1|2200|1200|0|999|222|333|1|0
#define DEBUG
const uint8_t feldAnzahl = 10;
const uint8_t ventilAnzahl = 3;
const uint8_t restAnzahl = 4;
const int trenn = 999;
// Pins
const byte ventil_1 = 2;
const byte ventil_2 = 3;
const byte ventil_3 = 4;
uint8_t feldIdx, pufferIdx, ventilIdx;
char puffer[10];
boolean gelesen = false;
int rest[restAnzahl];
// Die Daten für 1 Ventil
typedef struct ventil {
byte pin;
uint8_t runde;
byte LedStatus;
uint32_t LED_timestore;
boolean inSpuelen;
int werte[feldAnzahl];
};
// Ein Array aus Ventilen mit Initialisierung von pin und runde
ventil ventile[ventilAnzahl] = {
{ventil_1,99},
{ventil_2,99},
{ventil_3,99}
};
void setup() {
Serial.begin(115200);
Serial.println("Start");
for(byte j=0; j < ventilAnzahl; j++) {
pinMode (ventile[j].pin, OUTPUT);
}
}
void loeschen() {
for (uint8_t j=0; j < ventilAnzahl; j++) {
for (uint8_t i = 0; i < feldAnzahl; i++) {
ventile[j].werte[i] = 0;
}
}
feldIdx = 0;
ventilIdx = 0;
gelesen = false;
}
// return true, wenn ganze Zeile eingelesen, sonst false
boolean einlesen() {
uint32_t startMillis;
char c;
int zahl;
if (Serial.available()) {
//
if (gelesen) loeschen();
c = Serial.read();
if (c == '|' || c == '\n') {
puffer[pufferIdx] = '\0'; // Abschließen der Zeichenkette
zahl = atoi(puffer);
// Serial.println(zahl);
if (zahl == trenn) {
ventilIdx++;
feldIdx = 0;
pufferIdx = 0;
// anzeigen();
}
else {
if (ventilIdx < ventilAnzahl) {
if (feldIdx < feldAnzahl) {
ventile[ventilIdx].werte[feldIdx++] = zahl;
}
}
else {
// die restlichen 4 Felder
if (feldIdx < restAnzahl) {
rest[feldIdx++] = zahl;
}
}
pufferIdx = 0;
}
if (c == '\n') {
gelesen = true;
startMillis = millis();
for (byte j=0; j<ventilAnzahl; j++) {
ventile[j].runde = 0;
ventile[j].LED_timestore = startMillis; // jetzt erst geht die Zeit los
// Serial.println("**** Initialisierung nach Einlesen ****");
// Serial.print("Ventil: "); Serial.print(j); Serial.print("Runde: ");Serial.print(ventile[j].runde);
// Serial.print(" LED_timestore gesetzt auf: "); Serial.println(ventile[j].LED_timestore);
}
return true; // Zeile fertig
}
}
else if (c >= '0' && c <= '9') puffer[pufferIdx++] = c; // Nur Ziffern
}
return false;
}
void anzeigenVentil(byte j) {
Serial.print("------ Ventil "); Serial.print(j); Serial.println(" -------");
Serial.print(" Pin: "); Serial.print(ventile[j].pin);
Serial.print(" LedStatus: ");Serial.print(ventile[j].LedStatus);
Serial.print(" LED_timestore: "); Serial.println(ventile[j].LED_timestore);
Serial.print(" Runde: ");Serial.print(ventile[j].runde);
Serial.print(" inSpuelen: "); Serial.println(ventile[j].inSpuelen); Serial.print(" Werte: ");
for (uint8_t i = 0; i < feldAnzahl; i++) {
Serial.print(ventile[j].werte[i]); Serial.print(" ");
}
Serial.println("");
}
void anzeigenRest() {
Serial.println("------ Rest: ------");
for(byte i = 0; i < restAnzahl; i++) {
Serial.print(rest[i]); Serial.print(" ");
}
Serial.println("");
}
void anzeigen() {
for (byte j=0; j<ventilAnzahl;j++) {
anzeigenVentil(j);
}
anzeigenRest();
Serial.println("");
}
void loop() {
uint32_t aktMillis = millis();
if (einlesen()) anzeigen();
if (!gelesen) return;
for(byte j=0; j < ventilAnzahl; j++) {
if (ventile[j].runde == 0 && ventile[j].werte[9] == 0) {
if (ventile[j].inSpuelen) {
digitalWrite(ventile[j].pin, LOW);
ventile[j].inSpuelen = false;
#ifdef DEBUG
Serial.print("Ventil: ");Serial.print(j);Serial.println(" Spuelen aus");
#endif
}
}
if (ventile[j].runde < 3 && ventile[j].werte[ventile[j].runde*3] != 0) {
if (ventile[j].LedStatus == LOW && aktMillis - ventile[j].LED_timestore >= ventile[j].werte[ventile[j].runde*3+1] ) { // zeit für aus
#ifdef DEBUG
Serial.print("Ventil: ");Serial.print(j);Serial.print(" Millis: "); Serial.print(aktMillis);
Serial.print(" LED_timestore: "); Serial.println(ventile[j].LED_timestore);
#endif
digitalWrite(ventile[j].pin, HIGH);
ventile[j].LED_timestore = aktMillis;
#ifdef DEBUG
Serial.print(" HIGH "); Serial.print(" Runde: "); Serial.print(ventile[j].runde);
Serial.print(" LED_timestore gesetzt auf: "); Serial.println(ventile[j].LED_timestore);
#endif
ventile[j].LedStatus = HIGH;
}
if (ventile[j].LedStatus == HIGH && aktMillis - ventile[j].LED_timestore >= ventile[j].werte[ventile[j].runde*3+2]) { //zeit für an
#ifdef DEBUG
Serial.print("Ventil: ");Serial.print(j);
Serial.print(" Millis: "); Serial.print(aktMillis); Serial.print(" LED_timestore: "); Serial.println(ventile[j].LED_timestore);
#endif
digitalWrite(ventile[j].pin, LOW);
ventile[j].LED_timestore = aktMillis;
ventile[j].LedStatus = LOW;
#ifdef DEBUG
Serial.print(" LOW "); Serial.print(" Runde: "); Serial.println(ventile[j].runde);
#endif
ventile[j].runde++;
}
}
if (ventile[j].runde == 0 && ventile[j].werte[9] == 1) {
//Spülen
ventile[j].inSpuelen = true;
digitalWrite(ventile[j].pin, HIGH);
#ifdef DEBUG
Serial.print("Ventil: ");Serial.print(j); Serial.println("Spuelen an");
#endif
}
}
// Hier kommen dann die Kamera und der Blitz hin. Die sind beide völlig unabhängig
}
Ein Beispiel für die kompletten Daten ist oben mit drin.
Gruß Tommy
Wahnsinn! Du bist irre! Vielen Dank! Unglaublich!
DANKE!!!
Wenn alles läuft, gib uns mal ein paar schöne Tropfenphotos und natürlich den Sketch im Endausbau auch hier veröffentlichen.
Gruß Tommy
photojo:
Bei dem häufig angeführten Beispiel mit Adressen, also einer Kombination aus Text und Zahlen, ist ein struct sicherlich sinnvoll, aber bei meiner Problemstellung auch?
Structs sind bei sowas immer sinnvoll, da man dann Namen für die Variablen hat und eine Zuordnung der Variablen zu einem Objekt.
Das mit dem Array mag für dich verständlich sein, aber wenn ein Fremder den Code liest versteht er nichts.
So, habe mal um Kamera (rest[2] = 1) und Blitz (rest[3] = 1) erweitert.
Meinen Code kann man sicher auch noch wesentlich kürzer halten, aber da fehlen mir die Kenntnisse/Erfahrung.
Nur zur Erklärung, warum ich es zwei Varianten, nur Kamera und Kamera mit Blitz gibt.
Manchmal löse ich die nur die Kamera aus, manchmal auch Kamera und Blitz, dann allerdings mit einer Langzeitbelichtung, d.h. die Kamera ist für wert[1] offen und genau in der Häfte der Öffnungszeit kommt der Blitz.
Geht wunderbar!
EDIT: Wollte den Code hier posten, überschreitet aber die max. erlaubte Zeichenlänge. Und jetzt musste ich 5 Minuten vor dem nächsten Post vergehen lassen.
alles_fertig.ino (8.9 KB)
Prima, wenn es funktioniert. Stellst Du uns noch die Funktionen für Kamera und Blitz hier rein?
Gruß Tommy
photojo:
EDIT: Wollte den Code hier posten, überschreitet aber die max. erlaubte Zeichenlänge. Und jetzt musste ich 5 Minuten vor dem nächsten Post vergehen lassen.
Siehe Post #74
Warum machst Du das doppelt? Der Kamerateil ist ja der gleiche und der Blitz hat eine eigene Steuerung.
Nach meiner Meinung müsste das zum gleichen Ergebnis führen (und rein passen).
// intRead2
// Beispieleingabe Werte (mit NL abschließen)
// 1|500|100|1|300|100|1|200|100|0|999|1|1100|1100|1|3100|1100|1|2100|1100|0|999|1|5200|1200|1|3200|1200|1|2200|1200|0|999|222|333|1|0
#define DEBUG
const uint8_t feldAnzahl = 10;
const uint8_t ventilAnzahl = 3;
const uint8_t restAnzahl = 4;
const int trenn = 999;
// Pins
const byte ventil_1 = 2;
const byte ventil_2 = 3;
const byte ventil_3 = 4;
const byte cam = 11;
const byte flash = 12;
// Parameter für Kamera
unsigned long CAM_timestore;
int CamStatus = LOW;
const uint8_t impuls = 100; //Zeit in ms, Impuls für Kamera und Blitz
// Parameter für Blitz
unsigned long FLASH_timestore;
int FlashStatus = LOW;
boolean abgearbeitet = false; //Kamera und Blitz nur einmal auslösen
boolean abgearbeitet1 = false; //Kamera und Blitz nur einmal auslösen
uint8_t feldIdx, pufferIdx, ventilIdx;
char puffer[10];
boolean gelesen = false;
int rest[restAnzahl];
// Die Daten für 1 Ventil
typedef struct ventil {
byte pin;
uint8_t runde;
byte LedStatus;
uint32_t LED_timestore;
boolean inSpuelen;
int werte[feldAnzahl];
};
// Ein Array aus Ventilen mit Initialisierung von pin und runde
ventil ventile[ventilAnzahl] = {
{ventil_1, 99},
{ventil_2, 99},
{ventil_3, 99}
};
void setup() {
Serial.begin(115200);
Serial.println("Start");
for (byte j = 0; j < ventilAnzahl; j++) {
pinMode (ventile[j].pin, OUTPUT);
}
pinMode (cam, OUTPUT);
pinMode (flash, OUTPUT);
}
void loeschen() {
for (uint8_t j = 0; j < ventilAnzahl; j++) {
for (uint8_t i = 0; i < feldAnzahl; i++) {
ventile[j].werte[i] = 0;
}
}
feldIdx = 0;
ventilIdx = 0;
gelesen = false;
}
// return true, wenn ganze Zeile eingelesen, sonst false
boolean einlesen() {
uint32_t startMillis;
char c;
int zahl;
if (Serial.available()) {
//
if (gelesen) loeschen();
c = Serial.read();
if (c == '|' || c == '\n') {
puffer[pufferIdx] = '\0'; // Abschließen der Zeichenkette
zahl = atoi(puffer);
// Serial.println(zahl);
if (zahl == trenn) {
ventilIdx++;
feldIdx = 0;
pufferIdx = 0;
// anzeigen();
}
else {
if (ventilIdx < ventilAnzahl) {
if (feldIdx < feldAnzahl) {
ventile[ventilIdx].werte[feldIdx++] = zahl;
}
}
else {
// die restlichen 4 Felder
if (feldIdx < restAnzahl) {
rest[feldIdx++] = zahl;
}
}
pufferIdx = 0;
}
if (c == '\n') {
gelesen = true;
startMillis = millis();
for (byte j = 0; j < ventilAnzahl; j++) {
ventile[j].runde = 0;
ventile[j].LED_timestore = startMillis; // jetzt erst geht die Zeit los
CAM_timestore = startMillis;
FLASH_timestore = startMillis;
abgearbeitet = false;
abgearbeitet1 = false;
// Serial.println("**** Initialisierung nach Einlesen ****");
// Serial.print("Ventil: "); Serial.print(j); Serial.print("Runde: ");Serial.print(ventile[j].runde);
// Serial.print(" LED_timestore gesetzt auf: "); Serial.println(ventile[j].LED_timestore);
}
return true; // Zeile fertig
}
}
else if (c >= '0' && c <= '9') puffer[pufferIdx++] = c; // Nur Ziffern
}
return false;
}
void anzeigenVentil(byte j) {
Serial.print("------ Ventil "); Serial.print(j); Serial.println(" -------");
Serial.print(" Pin: "); Serial.print(ventile[j].pin);
Serial.print(" LedStatus: "); Serial.print(ventile[j].LedStatus);
Serial.print(" LED_timestore: "); Serial.println(ventile[j].LED_timestore);
Serial.print(" Runde: "); Serial.print(ventile[j].runde);
Serial.print(" inSpuelen: "); Serial.println(ventile[j].inSpuelen); Serial.print(" Werte: ");
for (uint8_t i = 0; i < feldAnzahl; i++) {
Serial.print(ventile[j].werte[i]); Serial.print(" ");
}
Serial.println("");
}
void anzeigenRest() {
Serial.println("------ Rest: ------");
for (byte i = 0; i < restAnzahl; i++) {
Serial.print(rest[i]); Serial.print(" ");
}
Serial.println("");
}
void anzeigen() {
for (byte j = 0; j < ventilAnzahl; j++) {
anzeigenVentil(j);
}
anzeigenRest();
Serial.println("");
}
void loop() {
uint32_t aktMillis = millis();
if (einlesen()) anzeigen();
if (!gelesen) return;
for (byte j = 0; j < ventilAnzahl; j++) {
if (ventile[j].runde == 0 && ventile[j].werte[9] == 0) {
if (ventile[j].inSpuelen) {
digitalWrite(ventile[j].pin, LOW);
ventile[j].inSpuelen = false;
#ifdef DEBUG
Serial.print("Ventil: "); Serial.print(j); Serial.println(" Spuelen aus");
#endif
}
}
if (ventile[j].runde < 3 && ventile[j].werte[ventile[j].runde * 3] != 0) {
if (ventile[j].LedStatus == LOW && aktMillis - ventile[j].LED_timestore >= ventile[j].werte[ventile[j].runde * 3 + 1] ) { // zeit für aus
#ifdef DEBUG
Serial.print("Ventil: "); Serial.print(j); Serial.print(" Millis: "); Serial.print(aktMillis);
Serial.print(" LED_timestore: "); Serial.println(ventile[j].LED_timestore);
#endif
digitalWrite(ventile[j].pin, HIGH);
ventile[j].LED_timestore = aktMillis;
#ifdef DEBUG
Serial.print(" HIGH "); Serial.print(" Runde: "); Serial.print(ventile[j].runde);
Serial.print(" LED_timestore gesetzt auf: "); Serial.println(ventile[j].LED_timestore);
#endif
ventile[j].LedStatus = HIGH;
}
if (ventile[j].LedStatus == HIGH && aktMillis - ventile[j].LED_timestore >= ventile[j].werte[ventile[j].runde * 3 + 2]) { //zeit für an
#ifdef DEBUG
Serial.print("Ventil: "); Serial.print(j);
Serial.print(" Millis: "); Serial.print(aktMillis); Serial.print(" LED_timestore: "); Serial.println(ventile[j].LED_timestore);
#endif
digitalWrite(ventile[j].pin, LOW);
ventile[j].LED_timestore = aktMillis;
ventile[j].LedStatus = LOW;
#ifdef DEBUG
Serial.print(" LOW "); Serial.print(" Runde: "); Serial.println(ventile[j].runde);
#endif
ventile[j].runde++;
}
}
if (ventile[j].runde == 0 && ventile[j].werte[9] == 1) {
//Spülen
ventile[j].inSpuelen = true;
digitalWrite(ventile[j].pin, HIGH);
#ifdef DEBUG
Serial.print("Ventil: "); Serial.print(j); Serial.println("Spuelen an");
#endif
}
}
// Hier kommen dann die Kamera und der Blitz hin. Die sind beide völlig unabhängig
if (rest[2] == 1) { //Kamera muss sein, sonst macht Blitz keinen Sinn
//Abschnitt für Kamera
if (CamStatus == LOW && abgearbeitet == false) {
//LED_timestore = millis();
if (millis() - CAM_timestore > (rest[0] - rest[1] / 2)) { // zeit für aus
digitalWrite(cam, HIGH);
CAM_timestore = millis();
CamStatus = HIGH;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" CAM_timestore: "); Serial.print(CAM_timestore); Serial.println("Abschnitt HIGH KAMERA");
#endif
}
} else {
if (millis() - CAM_timestore > rest[1] && abgearbeitet == false ) { //zeit für an
digitalWrite(cam, LOW);
CamStatus = LOW;
abgearbeitet = true;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" CAM_timestore: "); Serial.print(CAM_timestore); Serial.println("Abschnitt LOW KAMERA");
#endif
}
}
//Abschnitt für Blitz
if (rest[3] == 1 && FlashStatus == LOW && abgearbeitet1 == false) {
//LED_timestore = millis();
if (millis() - FLASH_timestore > rest[0] ) { // zeit für aus
digitalWrite(flash, HIGH);
FLASH_timestore = millis();
FlashStatus = HIGH;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" FLASH_timestore: "); Serial.print(FLASH_timestore); Serial.println(" Abschnitt HIGH BLITZ *******************************");
#endif
}
} else {
if (millis() - FLASH_timestore > impuls && abgearbeitet1 == false ) { //zeit für an
digitalWrite(flash, LOW);
FlashStatus = LOW;
abgearbeitet1 = true;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" FLASH_timestore: "); Serial.print(FLASH_timestore); Serial.println(" Abschnitt LOW BLITZ *******************************");
#endif
}
}
}
}
Gruß Tommy
Danke!
Aber ich denke, dass dein Code nicht genau dasselbe macht, wenn ich das als Laie so sagen darf.
Es gibt zwei Fälle , wie die Kamera auslösen kann:
Fall 1
rest[]=250,300,1,0 -> Kamera allein: nach rest[0] ms ausgelöst für Konstante impuls
Fall 2
rest[]=250,300,1,1-> Kamera und Blitz mit Langzeitbelichtung: Kamera öffnet nach 250 - 300/2 = 100 ms, nach 300 ms kommt der Blitz für impuls, nach 300ms seit der Öffnung des Verschlusses schließt die Kamera wieder
Eigentlich arbeite ich fast ausschließlich mit Methode 2, weil der Blitz ja im Vergleich zum Verschluss einer Kamera wesentlich präziser ist. Auf diese Weise bekommt man, vorausgesetzt das Ventil liefert immer die gleiche Menge Wasser = Tropfengröße, absolut reproduzierbare Ergebnisse.
Das hatte ich übersehen. Das kann man aber auch einfach zusammenfassen.
Ich kopiere mal nur den Ausschnitt rein.
// Hier kommen dann die Kamera und der Blitz hin. Die sind beide völlig unabhängig
if (rest[2] == 1) { //Kamera muss sein, sonst macht Blitz keinen Sinn
//Abschnitt für Kamera
uint32_t vorlauf = 0, dauer = rest[1];
if (rest[3] == 1) { // mit Blitz
vorlauf = rest[1] / 2;
dauer = impuls;
}
if (CamStatus == LOW && abgearbeitet == false) {
//LED_timestore = millis();
if (millis() - CAM_timestore > (rest[0] - vorlauf)) { // zeit für aus
digitalWrite(cam, HIGH);
CAM_timestore = millis();
CamStatus = HIGH;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" CAM_timestore: "); Serial.print(CAM_timestore); Serial.println("Abschnitt HIGH KAMERA");
#endif
}
} else {
if (millis() - CAM_timestore > dauer && abgearbeitet == false ) { //zeit für an
digitalWrite(cam, LOW);
CamStatus = LOW;
abgearbeitet = true;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" CAM_timestore: "); Serial.print(CAM_timestore); Serial.println("Abschnitt LOW KAMERA");
#endif
}
}
//Abschnitt für Blitz
if (rest[3] == 1 && FlashStatus == LOW && abgearbeitet1 == false) {
//LED_timestore = millis();
if (millis() - FLASH_timestore > rest[0] ) { // zeit für aus
digitalWrite(flash, HIGH);
FLASH_timestore = millis();
FlashStatus = HIGH;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" FLASH_timestore: "); Serial.print(FLASH_timestore); Serial.println(" Abschnitt HIGH BLITZ *******************************");
#endif
}
} else {
if (millis() - FLASH_timestore > impuls && abgearbeitet1 == false ) { //zeit für an
digitalWrite(flash, LOW);
FlashStatus = LOW;
abgearbeitet1 = true;
#ifdef DEBUG
Serial.print("Millis: "); Serial.print(millis()); Serial.print(" FLASH_timestore: "); Serial.print(FLASH_timestore); Serial.println(" Abschnitt LOW BLITZ *******************************");
#endif
}
}
}
Fast gleichen Code an mehreren Stellen gibt immer Probleme, wenn man was ändert und dann den anderen Teil vergißt.
Gruß Tommy