benötige Hilfe beim Sketch. Da kommt immer die Meldung "was not declared in this scope"
Kurz zum Projekt: Bin absoluter Neuling, was Arduino angeht. Habe das Sketch vom CCC (Chicken Coop Control) kopiert und auf meine Bedürfnisse angepasst. Benötige einfach nur einen Motor, der per LDR auffährt und schließt, und 2 Taster um zusätzlich das Tor von Hand fahren zu können. Klappe hat oben und Unten je einen Reedkontakt NO.
Ich lade das Sketch mal hier hoch, vielleicht kann mir ja jemand helfen oder einen Tipp geben.
//#################################################################################################################//
//#################################################################################################################//
//#################################################################################################################//
// //////////////////////////////////////////////////////////// //
// // HIER WERDEN DIE LICHTSCHWELLWERTE DES LDR EINGESTELLT // //
// // Hier sind Werte von 0 bis 1023 moeglich // //
// // kleine Werte = z.B 40 dunkel / Abend-Daemmerung // //
// große Werte = z.B 550 hell / Morgen-Daemmerung //
// //////////////////////////////////////////////////////////// //
int LDR_SW_MORGEN = 550; // z.B 550 als Lichtschwellwert fuer das Oeffnen am Morgen
int LDR_SW_ABEND = 40; // z.B 40 als Lichtschwellwert fuer das Schließen am Abend
//#################################################################################################################//
//#################################################################################################################//
//#################################################################################################################//
// Deklarieren der Variablen, Konstanten usw.
const byte TASTER_AUF = 2; // Tasterpin zum Oeffnen der HKS
const byte TASTER_ZU = 3; // Tasterpin zum Schließen der HKS
const byte REED_OBEN = 4; // Reed-Kontakt oben
const byte REED_UNTEN = 5; // Reed-Kontakt unten
const byte MOTOR_1 = 6; // MOTOR_PIN +/-
const byte MOTOR_2 = 7; // MOTOR_PIN -/+
const int LDR = A0; // Lichtsensor
bool REEDSTAT_OBEN = 0; // Zwischenspeicher-Variable fuer REED_OBEN
bool REEDSTAT_UNTEN = 0; // Zwischenspeicher-Variable fuer REED_UNTEN
volatile bool ISR_FLAG_AUF = 0; // Flag für INTERRUPT_TASTER_AUF
volatile bool ISR_FLAG_ZU = 0; // Flag für INTERRUPT_TASTER_ZU
int LDR_WERT = 1023; // Zwischenspeicher-Variable für LDR-WERT
//#################################################################################################################//
//#################################################################################################################//
//#################################################################################################################//
void loop()
{
REEDSTAT_OBEN = digitalRead(REED_OBEN); // Einlesen des Reed-Kontakt-Status fuer Oben (offen od. geschlossen)
REEDSTAT_UNTEN = digitalRead(REED_UNTEN); // Einlesen des Reed-Kontakt-Status fuer Unten (offen od. geschlossen)
LDR_WERT = analogRead(LDR); // Einlesen des aktuellen LDR-Wertes
//#################################################################################################################//
//////////////////////////////////////////////
// BEDINGUNGEN : Tastendruck - Interrupt //
//////////////////////////////////////////////
//#################################################################################################################//
//###### BEDINGUNG TASTENDRUCK AUF ###############################################################################//
if (ISR_FLAG_AUF == 1) // Bedingung bei Tastendruck AUF => gesetztes ISR_FLAG_AUF
{
ISR_FLAG_AUF = 0;
while (REEDSTAT_OBEN) // Schleife die solange durchlaufen wird bis REED_OBEN schließt
{
MOTOR_AUF();
REEDSTAT_OBEN = digitalRead(REED_OBEN); // Pruefung ob REED_OBEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung TASTENDRUCK AUF");
}
//###### BEDINGUNG TASTENDRUCK ZU ###############################################################################//
else if (ISR_FLAG_ZU == 1) // Bedingung bei Tastendruck ZU => gesetztes ISR_FLAG_ZU
{
ISR_FLAG_ZU = 0;
while (REEDSTAT_UNTEN) // Schleife die soloange durchlaufen wird bis REED_UNTEN schließt
{
MOTOR_AB();
REEDSTAT_UNTEN = digitalRead(REED_UNTEN); // Pruefung ob REED_UNTEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung TASTENDRUCK ZU"); //(fuer Diagnose-Zwecke)
}
//#################################################################################################################//
//////////////////////////////////////////////
// BEDINGUNGEN : LDR /////////////////////////
//////////////////////////////////////////////
//#################################################################################################################//
//###### BEDINGUNG LDR AUF ####### #####################################################################//
if ((LDR_WERT >= LDR_SW_MORGEN)
{
while (REEDSTAT_OBEN) // Schleife die soloange durchlaufen wird bis REED_OBEN schließt
{
MOTOR_AUF();
REEDSTAT_OBEN = digitalRead(REED_OBEN); // Pruefung ob REED_OBEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung LDR/ZEITRG-AUF"); //(fuer Diagnose-Zwecke)
}
//###### BEDINGUNG LDR ZU ####### ######################################################################//
else if ((LDR_WERT <= LDR_SW_ABEND)
{
while (REEDSTAT_UNTEN) // Schleife die soloange durchlaufen wird bis REED_UNTEN schließt
{
LCD.backlight();
MOTOR_AB();
REEDSTAT_UNTEN = digitalRead(REED_UNTEN); // Pruefung ob REED_UNTEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung LDR/ZEITRG-ZU"); //(fuer Diagnose-Zwecke)
}
//#################################################################################################################//
//////////////////
// FUNKTIONEN : //
//////////////////
//#################################################################################################################//
void WELCOME()
{
LCD.init();
LCD.clear();
LCD.backlight();
LCD.setCursor(0, 0);
LCD.print(" Arduino-CCC ");
LCD.setCursor(0, 1);
LCD.print("V1.23.6 iNerds");
Serial.println("Arduino-CCC V1.23.6 Release 22.10.2021 by iNerds");
delay (3000);
LCD.clear();
LCD.setCursor(0, 0);
LCD.print(" Stable Version ");
LCD.setCursor(0, 1);
LCD.print(" RGB-Version ");
Serial.println("RGB-Version");
delay (3000);
LCD.noBacklight();
}
void INTERRUPT_TASTER_AUF()
{
ISR_FLAG_AUF = 1;
}
void INTERRUPT_TASTER_ZU()
{
ISR_FLAG_ZU = 1;
}
void MOTOR_AUF()
{
digitalWrite(LED_GRUEN, LOW); // Um Mischfarben zu verhindern
digitalWrite(LED_BLAU, (millis() % (BLINK_ON + BLINK_OFF)) < BLINK_ON); //Blinkintervall
digitalWrite(MOTOR_1, HIGH);
digitalWrite(MOTOR_2, LOW);
LCD.setCursor(0, 0);
LCD.print(" HKS OEFFNET ");
LCD.setCursor(0, 1);
LCD.print("CCC-STRG AKTIV ");
//**Serial.println("CCC STATUS ON - KLAPPE OEFFNET"); //(fuer Diagnose-Zwecke)
}
void MOTOR_AB()
{
digitalWrite(LED_ROT, LOW); // Um Mischfarben zu verhindern
digitalWrite(LED_BLAU, (millis() % (BLINK_ON + BLINK_OFF)) < BLINK_ON); //Blinkintervall
digitalWrite(MOTOR_1, LOW);
digitalWrite(MOTOR_2, HIGH);
LCD.setCursor(0, 0);
LCD.print(" HKS SCHLIESST ");
LCD.setCursor(0, 1);
LCD.print("CCC-STRG AKTIV ");
//**Serial.println("CCC STATUS ON - KLAPPE SCHLIESST"); //(fuer Diagnose-Zwecke)
}
void MOTOR_STOP()
{
digitalWrite(MOTOR_1, LOW);
digitalWrite(MOTOR_2, LOW);
digitalWrite(LED_BLAU, LOW);
AUSGABE_LCD();
//**Serial.println("MOTORSTOP wird ausgefuehrt"); //(fuer Diagnose-Zwecke)
}
//#################################################################################################################//
//#################################################################################################################//
//#################################################################################################################//
Und wenn Du jetzt noch ein setup() in Deinen Sketch includierst, dann könnte es was werden, wenn dann die Klammern vollständig sind.
Stichwort STRG-T ....
Mhhh... Rauten sind befreit, ist ja schonmal ein Anfang. Wie kann ich als Laie das setup includieren?
Und was ist mit Strg T gemeint? Sorry für die doofen Fragen, bin neu hier
Was auch immer Du da hast, es scheint nur zusammenkopiert.
Das hat nichts damit zu tun, das Du hier neu bist
Der Code kann so nicht funktionieren.
Lege Dir einen neuen Sketch an.
Fülle den nacheinander auf, mit dem was Du hier vorgestellt hast.
Mit der Tastenkombination STRG-T in der IDE formatierst Du den Sketch.
Damit lassen sich sehr gut Klammerfehler ((LDR_WERT <= LDR_SW_ABEND)
wie diese oder andere feststellen.
Wenn Du dann mit jedem neuen Kompilieren neue Fehler bekommst, las Dich nicht entmutigen, aber der Code ist so...
ich habe mal paar sachen eingefügt . Da ich ein Projekt mit der Hühnerklappe nicht schlecht finden würde. Mich nervt das rauslaufen früh und am abend auch immer mal zumal wenn es dunkel wird der Fuchs gerne mal vorbei kommt .
auch wenn der Code so noch immer nicht geht und sicher erst mal sinnlos ist . aber : Du gibst LED an nur wo hast du angegeben an welchen Pin?
auch das LCD da fehlt das include
hab mal paar sachen verändert . wäre vieleicht ein anfang .
zumal ich damit anfangen würde motorkontakte mit relays zu nutzen .
und auch endschalter einbauen . sonst ist dem Arduino ja nicht bekannt ob das teil jetzt ganz zu ist oder nur halb zu da noch ein Huhn in der klappe steht ! dort müsste man eine Lichtschranke haben damit das Gerät weiß " klappe ist frei jetzt kann ich auch schliessen "
//#################################################################################################################//
//#################################################################################################################//
//#################################################################################################################//
// //////////////////////////////////////////////////////////// //
// // HIER WERDEN DIE LICHTSCHWELLWERTE DES LDR EINGESTELLT // //
// // Hier sind Werte von 0 bis 1023 moeglich // //
// // kleine Werte = z.B 40 dunkel / Abend-Daemmerung // //
// große Werte = z.B 550 hell / Morgen-Daemmerung //
// //////////////////////////////////////////////////////////// //
#include <LiquidCrystal_I2C.h> // Library für dein lcd
LiquidCrystal_I2C lcd(0x27, 16, 2); // I2C address 0x27, vom LCD
int LDR_SW_MORGEN = 550; // z.B 550 als Lichtschwellwert fuer das Oeffnen am Morgen
int LDR_SW_ABEND = 40; // z.B 40 als Lichtschwellwert fuer das Schließen am Abend
//#########################
/* hier müsste man die LED Pin angeben das fehlt */
//#################################################################################################################//
//#################################################################################################################//
//#################################################################################################################//
// Deklarieren der Variablen, Konstanten usw.
const byte TASTER_AUF = 2; // Tasterpin zum Oeffnen der HKS
const byte TASTER_ZU = 3; // Tasterpin zum Schließen der HKS
const byte REED_OBEN = 4; // Reed-Kontakt oben
const byte REED_UNTEN = 5; // Reed-Kontakt unten
const byte MOTOR_1 = 6; // MOTOR_PIN +/-
const byte MOTOR_2 = 7; // MOTOR_PIN -/+
const int LDR = A0; // Lichtsensor
bool REEDSTAT_OBEN = 0; // Zwischenspeicher-Variable fuer REED_OBEN
bool REEDSTAT_UNTEN = 0; // Zwischenspeicher-Variable fuer REED_UNTEN
volatile bool ISR_FLAG_AUF = 0; // Flag für INTERRUPT_TASTER_AUF
volatile bool ISR_FLAG_ZU = 0; // Flag für INTERRUPT_TASTER_ZU
int LDR_WERT = 1023; // Zwischenspeicher-Variable für LDR-WERT
//#################################################################################################################//
//////////////////
// FUNKTIONEN : //
//////////////////
//#################################################################################################################//
void MOTOR_STOP()
{
digitalWrite(MOTOR_1, LOW);
digitalWrite(MOTOR_2, LOW);
// digitalWrite(LED_BLAU, LOW);
lcd.setCursor(0, 0); // move cursor to (0, 0)
lcd.print("Ausgabe"); // print message at (0, 0)
// AUSGABE_lcd(); // was ist ausgabe ?
//**Serial.println("MOTORSTOP wird ausgefuehrt"); //(fuer Diagnose-Zwecke)
}
void MOTOR_AUF()
{
// digitalWrite(LED_GRUEN, LOW); // Um Mischfarben zu verhindern
// digitalWrite(LED_BLAU, (millis() % (BLINK_ON + BLINK_OFF)) < BLINK_ON); //Blinkintervall
digitalWrite(MOTOR_1, HIGH);
digitalWrite(MOTOR_2, LOW);
lcd.setCursor(0, 0);
lcd.print(" HKS OEFFNET ");
lcd.setCursor(0, 1);
lcd.print("CCC-STRG AKTIV ");
//**Serial.println("CCC STATUS ON - KLAPPE OEFFNET"); //(fuer Diagnose-Zwecke)
}
void MOTOR_AB()
{
// digitalWrite(LED_ROT, LOW); // Um Mischfarben zu verhindern
// digitalWrite(LED_BLAU, (millis() % (BLINK_ON + BLINK_OFF)) < BLINK_ON); //Blinkintervall
digitalWrite(MOTOR_1, LOW);
digitalWrite(MOTOR_2, HIGH);
lcd.setCursor(0, 0);
lcd.print(" HKS SCHLIESST ");
lcd.setCursor(0, 1);
lcd.print("CCC-STRG AKTIV ");
//**Serial.println("CCC STATUS ON - KLAPPE SCHLIESST"); //(fuer Diagnose-Zwecke)
}
//#################################################################################################################//
//////////////////
// FUNKTIONEN Ende : //
//////////////////
//#################################################################################################################//
void setup() {
Serial.begin(115200); // serial Monitor start
lcd.init();
lcd.clear();
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print(" Arduino-CCC ");
lcd.setCursor(0, 1);
lcd.print("V1.23.6 iNerds");
Serial.println("Arduino-CCC V1.23.6 Release 22.10.2021 by iNerds");
delay (3000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" Stable Version ");
lcd.setCursor(0, 1);
lcd.print(" RGB-Version ");
Serial.println("RGB-Version");
delay (3000);
lcd.noBacklight();
}
void loop()
{
kontakte();
}
void kontakte() {
REEDSTAT_OBEN = digitalRead(REED_OBEN); // Einlesen des Reed-Kontakt-Status fuer Oben (offen od. geschlossen)
REEDSTAT_UNTEN = digitalRead(REED_UNTEN); // Einlesen des Reed-Kontakt-Status fuer Unten (offen od. geschlossen)
LDR_WERT = analogRead(LDR); // Einlesen des aktuellen LDR-Wertes
//#################################################################################################################//
//////////////////////////////////////////////
// BEDINGUNGEN : Tastendruck - Interrupt //
//////////////////////////////////////////////
//#################################################################################################################//
//###### BEDINGUNG TASTENDRUCK AUF ###############################################################################//
if (ISR_FLAG_AUF == 1) // Bedingung bei Tastendruck AUF => gesetztes ISR_FLAG_AUF
{
ISR_FLAG_AUF = 0;
while (REEDSTAT_OBEN) // Schleife die solange durchlaufen wird bis REED_OBEN schließt
{
MOTOR_AUF();
REEDSTAT_OBEN = digitalRead(REED_OBEN); // Pruefung ob REED_OBEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung TASTENDRUCK AUF");
}
//###### BEDINGUNG TASTENDRUCK ZU ###############################################################################//
else if (ISR_FLAG_ZU == 1) // Bedingung bei Tastendruck ZU => gesetztes ISR_FLAG_ZU
{
ISR_FLAG_ZU = 0;
while (REEDSTAT_UNTEN) // Schleife die soloange durchlaufen wird bis REED_UNTEN schließt
{
MOTOR_AB();
REEDSTAT_UNTEN = digitalRead(REED_UNTEN); // Pruefung ob REED_UNTEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung TASTENDRUCK ZU"); //(fuer Diagnose-Zwecke)
}
//###### BEDINGUNG LDR AUF was auch immer hier passieren soll ###################################################//
/* if ((LDR_WERT >= LDR_SW_MORGEN) // was ist SW_MORGEN
{
while (REEDSTAT_OBEN) // Schleife die soloange durchlaufen wird bis REED_OBEN schließt
{
MOTOR_AUF();
REEDSTAT_OBEN = digitalRead(REED_OBEN); // Pruefung ob REED_OBEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung LDR/ZEITRG-AUF"); //(fuer Diagnose-Zwecke)
}
//###### BEDINGUNG LDR ZU ####### ######################################################################//
else if ((LDR_WERT <= LDR_SW_ABEND)
{
while (REEDSTAT_UNTEN) // Schleife die soloange durchlaufen wird bis REED_UNTEN schließt
{
lcd.backlight();
MOTOR_AB();
REEDSTAT_UNTEN = digitalRead(REED_UNTEN); // Pruefung ob REED_UNTEN "offen" oder "geschlossen" ist
}
MOTOR_STOP();
//**Serial.println("Programm befindet sich in Bedingung LDR/ZEITRG-ZU"); //(fuer Diagnose-Zwecke)
} */
}
void INTERRUPT_TASTER_AUF()
{
ISR_FLAG_AUF = 1;
}
void INTERRUPT_TASTER_ZU()
{
ISR_FLAG_ZU = 1;
}
//#################################################################################################################//
//#################################################################################################################//
//#################################################################################################################//
Hallo,
Hühnerklappen gab es nun ja hier schon so einige. Zu der vorliegenden Variante :
Eigentlich sollten die beiden Interrupt´s ja komplett raus das ist ja völliger Unsinn.
Zudem sehe ich da noch ein weiteres Problem. Wenn nun manuell mittels Taster die Türe zu gefahren wird, dann wird sie von selber wieder aufgehen wenn es noch zu hell ist. Gleiches umgekehrt. Das könnte man ändern , hat aber auch einen anderen Nachteil. Die Türe automatisch nur dann schließen wenn der LDR von hell auf dunkel wechselt und umgekehrt. Damit kann man dann die Türen manuell verfahren , wenn man es vergisst schaltete der LDR. Dann bleibt jedoch immer noch folgendes Problem, wenn der LDR am Abend zu gefahren hat , und man anschließend manuell wieder auf fährt, muss man auch manuell wieder zu fahren. Gleiches gilt umgekehrt. Eine andere Variante mittels Betriebsart Mauell / Auto geht sicher auch.
Damit die Türe nicht bei jeder Wolke auf und zu fährt sollte man eine sinnvolle Hysterese und einen Zeitverzögerung einbauen. z.B es muss 10min dunkel sein damit die Türe zu geht. Es muss 10 min hell sein bevor sie aufgeht.
Eventuell fällt ja einem ja noch die ELWS ein.
Gruß Heinz
Danke erstmal für die vielen antworten. Bin zurzeit auf arbeit sehr eingespannt, und zuhause gehts auch drunter und drüber. Aber bei Gelegenheit werde ich mich nochmal weiter mit der Thematik hier auseinandersetzen
Danke erstmal für deine Mühe. Hätte nie gedacht, dass das alles soooooo kompliziert wird.
Hab es bei Youtube mit der Hühnerklappe + Arduino gesehen und überall wurde es als machbar und total easy beschrieben.
Wahrscheinlich habe ich das Programmieren "von 0 auf lernen" unterschätzt.
Das LCD Display kann eigentlich total vernachlässigt werden, da ich die infos darauf nicht brauche. Eigentlich sind mir auch sämtliche LED wurscht.
Also eine gewisse Rückmeldung in was für einem Schaltzustand dein Programm ist Und Kontrollanzeigen für den LDR und die Tür macht schon Sinn
Wenn du es gaaanz einfach haben willst dann recherchier mal ob man das Amazon-Alexa als Auftrag ansagen kann. Wenn das zu teuer ist, dann ist halt doch selbst programmieren angesagt.
Man programmiert so etwas nicht durch zusammenkopieren. Zusammenkopieren ist wie wenn du das Holz des Hühnerstalls auf einen Haufen wirst und erwartest dass sich das Holz von alleine passend anordnet. Vom Sperrmüll einen Fensterflügel holen (ohne Rahmen und im Baumarkt zwei Scharniere kaufen mach auch keine rein mechanisch funktionierende Hühnerklappe.
Man baut es Stück für Stück auf. Und dadurch versteht man dann auch was man da programmiert hat.
Ein Anfangspunkt ein Programmteil;
Fahre Klappe auf bis reed-kontakt "auf" schließt.
Fahre Klappe zu bis reed-kontakt "zu" schließt
Die beiden Programmteile werden dann später sowohl von hell / dunkel abgefahren als auch von Taster auf / zu
Dann einen Timeout als Sicherheit einbauen. Wenn der Reed-Kontakt wegen Kabelbruch nicht schließt soll das Huhn schließlich nicht stundenlang vom Motor eingeklemmt werden.
Hallo,
ich hab mal einen Sketch für eine einfache Hühnerklappe gemacht der was für Dich sein könnte und dabei auf alles unnötige verzichtet. Die Klappe wird über zwei Taster manuell und einen LDR automatisch gesteuert. Es gibt eine hell->dunkel und eine dunkel->hell Erkennung mit Flanke, damit kann die Klappe auch manuell noch verfahren werden. Ich hab das mit zwei LED´s ohne Motor getestet. Hab versucht das einfach und leicht nachvollziehbar zu machen. Sicher geht das auch anders , aber das ist ja immer so.
Heinz
/* Hühnerklappe Feb.2022
* Die Türe kann mit Taster auf und zu gefahren werden.Oben und
* unten sind Endschalter vorgesehen, zus.eine max Laufzeit.
* Mittels LDR wird bei Schaltwerten die Türe auf und zu gefahren
* Steuerung für einen DC Motor mit Relais. Es gibt eine Verzögerung
* zwischen auf und ab Umschaltung von 100ms (Kurzschluss bei
* Verwendung von Relais).
* LDR hell grosse Werte, dunkel kleine Werte
* Verzögerung für Hell/Dunkel Erkennung anpassen
* Laufzeit anpassen
* Schwellwerte entsp. dem vorliegenden LDR anpassen dafür ein
* ausreichendes Fenster für die Dämmerung berücksichtigen
*/
const uint32_t verzHell = 6000; // sollte sicher 1-2 Minuten sein
const uint32_t verzDunkel = 6000;
const uint32_t maxlaufzeit = 10000;// entsp. anpassen
const int hell = 600; // schaltwert hell Klappe offnen
const int dunkel = 400; // Schaltwert dunkel schliessen
// Pin´s
const byte btnAuf = 2; // Taster
const byte btnAb = 3;
const byte esOben = 4; // Endschalter
const byte esUnten = 5;
const byte motorAuf = 8; // Motoransteuerung
const byte motorAb = 9;
// Hilfsmerker
bool manAuf;
bool manAb;
bool autoAuf; //auto Türe öffnen Flanke
bool autoAb; //auto Türe schließen Flanke
bool oben;
bool unten;
const byte ldrpin = A0; // analoger LDR Pin
int ldr;
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
pinMode(btnAuf, INPUT_PULLUP);
pinMode (btnAb, INPUT_PULLUP);
pinMode(esOben, INPUT_PULLUP);
pinMode(esUnten, INPUT_PULLUP);
pinMode(motorAuf, OUTPUT);
pinMode(motorAb, OUTPUT);
}
void loop() {
// Eingänge einlesen
ldr = analogRead(ldrpin); // LDR einlesen
//Serial.println(ldr);
autoAuf = LDRdunkelhell();
autoAb = LDRhelldunkel();
manAuf = !digitalRead(btnAuf);
manAb = !digitalRead(btnAb);
oben = !digitalRead(esOben);
unten = !digitalRead(esUnten);
Klappe(); // Klappe steuern
}// ende loop
void Klappe() {
static uint32_t start;
static uint32_t auszeit;
bool aus=true;// Motor ist aus
if ((manAuf || autoAuf ) && aus) { // Klappe auf
Serial.println("Klappe auf fahren");
digitalWrite(motorAuf, HIGH);
digitalWrite(motorAb, LOW);
start = millis();
}
else if ((manAb || autoAb) && aus) { // Klappe zu
Serial.println("Klappe zu fahren");
digitalWrite(motorAuf, LOW);
digitalWrite(motorAb, HIGH);
start = millis();
}
else if (manAb) digitalWrite(motorAuf, LOW); // manuell wechseln
else if (manAuf)digitalWrite(motorAb, LOW);
if (millis() - start > maxlaufzeit || oben) { // oben stop
digitalWrite(motorAuf, LOW);
}
if (millis() - start > maxlaufzeit || unten) { // unten stop
digitalWrite(motorAb, LOW);
}
// wenn Motor aus reset auszeit
if (digitalRead(motorAuf) == HIGH || digitalRead(motorAb) == HIGH) {
auszeit = millis();
}
// Umschaltzeit sicherstellen aus >100ms
if (millis() - auszeit > 100) aus = true;
else aus = false;
}
// LDR hell -> dunke Erkennung
bool LDRhelldunkel() {
static uint32_t vorhin;
static bool merker; // Hilfsmerker Flankenerkennung
bool ret; // return Wert
ret = false;
if ( ldr < dunkel) {
if (millis() - vorhin >= verzDunkel && !merker) {
Serial.print("es ist dunkel Wert "); Serial.println(ldr);
ret = true;
merker = true;
}
}
else {
vorhin = millis();
merker = false;
}
return (ret);
}
// LDR dunkel-> hell Erkennung
bool LDRdunkelhell() {
static uint32_t vorhin;
static bool merker; // Hilfsmerker Flankenerkennung
bool ret; // return Wert
ret = false;
if ( ldr > hell) {
if (millis() - vorhin >= verzHell && !merker) {
Serial.print("es ist hell Wert "); Serial.println(ldr);
ret = true;
merker = true;
}
}
else {
vorhin = millis();
merker = false;
}
return (ret);
}
ich versuchs mal