Habe jetzt meine Platine mit dem Nano drauf soweit geändert, dass ich die Ledstreifen 1 - 4 auf den Pins 6,5,3,11 habe. Das funktioniert auch soweit.
Das Servo hängt auf dem Pin 8, Das sowieso kein PWM Pin ist.
Was mir allerding aufgefallen ist, dass auf dem PWM Ausgang D3 im abgeschalteten Zustand 0,18 Volt Spannung anliegt. Dadurch glimmt der betreffende Ledstreifen schwach.
Weiß jemand warn das liegen kann?
Wenn du den Code und die Schaltung zeigst: ja. Wie hast du die Spannung gemessen?
Schaltung zeigen bringt nicht viel. Ausgang D3 geht direkt zum Stecker mit Verbindung zum MosFet Modul.
Auch wenn ich den Arduino von der Platine abhebe, ist die Spannung vorhanden.
Spannung gemessen: So wie man Spannung misst: schwarze Strippe auf GND, rote Stripe auf Pin3 des Arduino. Multimeter auf Gleichspannung.
Sorry, aber Spannungen messe ich fast täglich.
Mich wundert es nur, da alles Anderen Ausgänge auf 0 Volt stehen.
Hier mein derzeitiger Code:
```cpp
#include <MobaTools.h>
// Pins für das Servo und Torsteuerung
MoToServo Servo1; // Erstelle ein Servo-Objekt für meinServo
const int servoPin = 8; // Pin für den Servo (PWM)
const int taster = 10; // Pin für das Signal zum Öffnen/Schließen
const int ausfall = 7; // Pin für Ledausfälle
const int relayPin = 2; // Signalpin (D2) (steuert das Relais für Abschalten der Servos), gleichzeitig gibt er an die Beleuchtung das Signal
// Servowinkel
int startAngle = 4; // Aktueller Winkel Servo1, damit nichts spannt - Dieser Winkel wird beim Einschalten gesetzt
int doorAngle = 60; // Zielwinkel für das Servo1
int hindAngle = doorAngle - 5; // Schließwinkel bei Hindernis1
int angle = startAngle; // Aktueller Winkel des Servos
int closedAngle = 0; // gesetzter Schließwinkel
// Kontrollpins für Tor
const int hindernisPin2 = A3; // Eingang Hinderniserkennung Tor2 HG2
const int openStatePin1 = A4; // Eingang ToroffenErkennung1 TO1
// Steuerungsvariablen
bool isOpen = false; // Zustand des Tor1 (offen oder geschlossen / true oder false)
const unsigned long waitDoor = 50; // Wartezeit in ms zwischen den Schritten
const unsigned long interval = 1000; // Intervallzeit
bool runLoop = false; // Variable, um die Schleife zu steuern
bool waiting = false; // Variable, um die Wartezeit zu steuern
bool tasterGedruckt = false; // Tasterstatus
bool moving = false; // Bewegt sich das Servo gerade?
bool hindernis = false; // Variable für Hinderniswarnung obstacleDetected
int hindZahl = 0; // Zähler für Hindernisversuche obstacleRetries
unsigned long hindernisMillis = 0; // Zeitstempel für den nächsten Versuch. obstacleRetryMillis
unsigned long timezuvor = 0; // Variable, um die letzte Zeit zu speichern
bool waitingToOpen = false; // Wird auf true gesetzt, während auf das Öffnen nach einem Hindernis gewartet wird
unsigned long waitToOpenMillis = 0; // Zeitstempel für die 3-Sekunden-Wartezeit
unsigned long previousMillis = 0; // Letzte Zeitmessung
const long intervalHind = 2000; // Intervallzeit in Millisekunden (2 Sekunde)
// Beleuchtung
const int ledPins[] = { 6, 5, 3, 11 };
const int HellPotPin = A1; // Potentiometer für Helligkeitseinstellung
const int ausfallPin = 9; // Schalter für Ausfallhäufigkeit
const int Schweisslicht = 12; // Schweißlicht - simuliert einen schweißvorgang
const int WarnLed = 4; // Warnled bei Hindernis rot blinkend
// LED Zustände
bool ledOn[4] = { false, false, false, false }; // Speichert, ob LED an ist
bool ledStable = false; // Alle LEDs stabil eingeschaltet
// Variablen für die Fehlerlogik beim Licht
unsigned long lastOutageTime = 0;
unsigned long nextOutageInterval = 0;
bool ledOutageActive = false; // Gibt an, ob gerade ein LED-Ausfall stattfindet
int outageLed = -1; // Index der LED, die aktuell ausfällt
// Steuerungsvariablen Licht
int brightness = 255; // Helligkeit der LEDs (über Potentiometer steuerbar)
int ausfallHaeufigkeit = 40; // Häufigkeit der Fehler
bool buttonPressed = false; // Status des Einschaltknopfes
bool ledsOn = false; // Zustand der LEDs (an/aus)
// Hindernis-Warnungslogik LIcht
unsigned long lastHindernisTime = 0;
const unsigned long hindernisInterval = 120000; // 2 Minuten (120.000 ms)
bool hindernisActive = false;
bool ledOutage = false;
//
// *****************************************************
// ********************** setup **********************
// *****************************************************
void setup() {
Serial.begin(9600);
Servo1.attach(servoPin); // Servo an Pin 8
Servo1.setSpeed(0); // setze Speed auf Normal
pinMode(taster, INPUT_PULLUP); // SteuerPin
pinMode(ausfall, INPUT_PULLUP); // Ausfall Steuerpin
pinMode(relayPin, OUTPUT); // SignalPin wird für beide Tore benutzt
pinMode(openStatePin1, INPUT_PULLUP); // Toroffenerkennung auf Eingang mit PullUp setzen
pinMode(hindernisPin2, INPUT); // Hinternis in Garage und 2 auf Eingang mit PullUp setzen
pinMode(ausfallPin, INPUT_PULLUP); // Schalter für Lichtausfälle
pinMode(Schweisslicht, OUTPUT); // Ausgang für Schweißlicht
pinMode(WarnLed, OUTPUT); // Warnled rot
// LED Pins als Ausgang definieren
for (int i = 0; i < 4; i++) {
pinMode(ledPins[i], OUTPUT);
analogWrite(ledPins[i], 0); // LEDs aus
}
digitalWrite(WarnLed, false); // Warnled aus
digitalWrite(relayPin, LOW); // Relais ist standardmäßig ausgeschaltet
// Torstatus abfragen
doorStatus(); // Torstatus setzen
// Zufallszahlengenerator initialisieren
randomSeed(analogRead(A0));
}
//
//
//
// *****************************************************
// ********************** loop **********************
// *****************************************************
void loop() {
unsigned long aktuellMillis = millis();
// Hindernis erkennen und Status setzen
FunkHindernis(); // Hinderniserkennung
// Helligkeit über Potentiometer A1 steuern
int potValue = analogRead(HellPotPin);
brightness = map(potValue, 0, 1023, 100, 255); // Helligkeit von 0 bis 255
// Ausfälle über AusfallPin steuern
if (digitalRead(ausfallPin)) {
ausfallHaeufigkeit = 0; //setze Ausfallhäufigkeit auf 0 - keine Ausfälle
}
//
// Tasterstatus lesen und erkennen, wenn der Taster gedrückt ist
if (!digitalRead(taster) && !tasterGedruckt && !moving) {
tasterGedruckt = true; //Taster wurde gedrückt
moving = true;
Serial.println("Impuls auf Pin 8 eingelangt");
digitalWrite(relayPin, HIGH); // Setze Relais auf ein
Serial.println("Relais ist eingschaltet");
timezuvor = aktuellMillis; //Zeitstempel setzen
}
// Wenn das Servo sich bewegt, führe schrittweise Bewegung aus
if (moving && aktuellMillis - timezuvor >= waitDoor) {
timezuvor = aktuellMillis; // Zeitstempel aktualisieren
// Bewege das Servo in 1-Grad-Schritten
if (!isOpen) {
// Tor öffnen
if (angle < doorAngle) {
angle++; // Winkel um 1 Grad erhöhen
Servo1.write(angle); // Servo auf den neuen Winkel setzen
} else {
Serial.println("Tor ist geöffnet");
// Wenn der Zielwinkel erreicht wurde
moving = false; // Bewegung stoppen
isOpen = true; // Tür ist offen
digitalWrite(relayPin, LOW); // Relais ausschalten
Serial.println("Relais ist ausgschaltet");
ledsOn = true;
turnOnLeds(); // LEDs starten
}
} else {
// Tor aschließen
if (angle > closedAngle) {
angle--; // Winkel um 1 Grad verringern
Servo1.write(angle); // Servo auf den neuen Winkel setzen
} else {
if (!hindernis) { // kein Hindernis
Serial.println("Tor ist geschlossen");
isOpen = false; // Tür ist geschlossen
turnOffLeds(); // LEDs ausschalten
} else { // Hindernis erkannt
Serial.println("Hindernis wurde erkannt!! - Tor nicht geschlossen");
isOpen = true; // Tür ist offen
}
// Wenn der Zielwinkel erreicht wurde
moving = false; // Bewegung stoppen
digitalWrite(relayPin, LOW); // Relais ausschalten
Serial.println("Relais ist ausgschaltet");
}
}
}
// Hinderniswarnung prüfen
if (hindernis && millis() - lastHindernisTime >= hindernisInterval) {
hindernisActive = true; // Hinderniswarnung aktiv
ledOutage = false; // Keine Ledausfälle mehr
Serial.println("Hindernis erkannt! Alle LEDs blinken...");
blinkAllLeds(5); // 5-maliges Blinken aller LEDs
lastHindernisTime = millis(); // Zeitstempel setzen
hindernisActive = false; // Hinderniswarnung aus
}
// Wenn alle LEDs an und stabil sind, Fehler und Hindernislogik verwalten
if (ledsOn && ledStable && !hindernisActive) {
handleLedOutage();
}
// Wenn der Taster losgelassen wird, erlauben, dass er wieder gedrückt werden kann
if (digitalRead(taster)) {
tasterGedruckt = false; // Tasterstatus zurücksetzen
}
// Ausfälle ein- bzw ausschalten
if (digitalRead(ausfall)) {
ledOutage = true;
}
//
}
//
//
//
// *****************************************************
// ******************* Funktionen *******************
// *****************************************************
//Torstatus erkennen
void doorStatus() {
// setzen des Torzustandes bei Tor1
if (!digitalRead(openStatePin1)) { // lesen des Statuseinganges A2
isOpen = true; // setzen des Torzustandes
Serial.println("Tor ist offen"); // setzen des Torzustandes
//Servo1.write(doorAngle); // setzen des Servos1 auf den Startwinkel
if (!ledsOn) {
ledsOn = true;
turnOnLeds(); // LEDs starten
}
Serial.print("Startwinkel gesetzt auf: ");
Serial.println(doorAngle);
angle = doorAngle + 1; // setze Winkel auf Toroffen
} else {
isOpen = false; // setzen des Torzustandes
Servo1.write(startAngle); // Servo auf geschlossen setzen
Serial.println("Tor1 ist geschlossen");
Serial.print("Startwinkel gesetzt auf: ");
Serial.println(startAngle);
angle = startAngle; // setze Winkel auf Startwinkel
}
}
//
// Hindernis erkennen
void FunkHindernis() {
// Hindernis erkennen und Status setzen
// Wenn Hindernis erkannt ist Status false
if (isOpen == true) {
if (digitalRead(hindernisPin2)) {
// Hindernis erkannt
hindernis = true; // Hindernisstatus auf Wahr setzen
closedAngle = hindAngle; // Setze geschlossenen Winkle auf Startwinkel
HindernisWarnung(true, previousMillis, 500); // Warnled blinken lassen
//angle = doorAngle + 1; // setze Winkel auf Toroffen
} else {
// kein Hindernis erkannt
hindernis = false; // Hindernisstatus auf Falsch setzen
closedAngle = startAngle; // setze Winkel auf Hinderniswinkel
HindernisWarnung(false, previousMillis, 500); // Warnled ausschalten
//angle = doorAngle + 1; // setze Winkel auf Toroffen
digitalWrite(WarnLed, false); // Warnled aus
}
}
}
//
// Blinkende rote Led an Pin4, wenn Hindernis oder Tor bewegt sich
void HindernisWarnung(bool warnung, unsigned long &lastMillis, long blinkInterval) {
unsigned long currentMillis = millis();
if (blinkInterval == 0) {
digitalWrite(WarnLed, LOW);
warnung = false;
}
// Wenn die Bedingung erfüllt ist
if (hindernis) {
if (warnung) {
// Wenn das Intervall abgelaufen ist
if (currentMillis - lastMillis >= blinkInterval) {
lastMillis = currentMillis; // Setzt die Zeit zurück
// Schaltet die LED um (ein/aus)
if (digitalRead(WarnLed) == LOW) {
digitalWrite(WarnLed, HIGH); // LED an
} else {
digitalWrite(WarnLed, LOW); // LED aus
}
}
}
} else {
// Stellt sicher, dass die LED ausgeschaltet ist, wenn die Bedingung nicht erfüllt ist
digitalWrite(WarnLed, LOW);
}
}
//
// Funktion zum Einschalten der LEDs mit Flackern
void turnOnLeds() {
Serial.println("Einschalten der LEDs...");
for (int i = 0; i < 4; i++) {
ledOn[i] = true;
simulateStartupFlicker(i); // Simuliert das Einschaltflackern
}
ledStable = true; // Nach dem Einschaltprozess sind alle LEDs stabil
lastOutageTime = millis(); // Startzeit für Fehler zählen
nextOutageInterval = random(10000, 60000); // Erstes Ausfallintervall zufällig zwischen 10 und 60 Sekunden
Serial.println("Alle LEDs sind stabil eingeschaltet.");
}
// Funktion zum Ausschalten der LEDs
void turnOffLeds() {
ledsOn = false;
Serial.println("Ausschalten der LEDs...");
for (int i = 0; i < 4; i++) {
analogWrite(ledPins[i], 0);
ledOn[i] = false;
}
ledStable = false; // LEDs sind ausgeschaltet
Serial.println("Alle LEDs sind ausgeschaltet.");
}
// Simuliert das Flackern der LEDs beim Einschalten
void simulateStartupFlicker(int ledIndex) {
int flickers = random(2, 7); // Anzahl der Flackerzyklen
for (int i = 0; i < flickers; i++) {
analogWrite(ledPins[ledIndex], random(100, brightness)); // Flackernde Helligkeit
delay(random(100, 500)); // Kurze Pause zwischen Flackern
analogWrite(ledPins[ledIndex], 0); // LED kurz aus
delay(random(100, 500));
}
analogWrite(ledPins[ledIndex], brightness); // LED dauerhaft an
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" ist stabil an.");
}
// Funktion zur Verwaltung der zufälligen LED-Ausfälle
void handleLedOutage() {
if (ledOutage) {
unsigned long currentMillis = millis();
// Wenn der Ausfallintervall überschritten ist
if (currentMillis - lastOutageTime >= nextOutageInterval && !ledOutageActive) {
// Zufällige LED auswählen, die ausfallen soll
outageLed = random(0, 4);
ledOutageActive = true;
// Serielle Ausgabe: Fehler startet
Serial.print("LED ");
Serial.print(outageLed);
Serial.println(" fällt aus.");
simulateOutageFlicker(outageLed); // LED flackert beim Ausfall
lastOutageTime = currentMillis; // Zeitstempel setzen
}
// Nach dem Ausfall, LED wieder normal leuchten lassen
if (ledOutageActive) {
// Nach dem Flackern die LED wieder normal anschalten
analogWrite(ledPins[outageLed], brightness);
// Serielle Ausgabe: Fehler beendet
Serial.print("LED ");
Serial.print(outageLed);
Serial.println(" leuchtet wieder normal.");
ledOutageActive = false;
// Nächstes Ausfallintervall berechnen, zwischen 10 und 600 Sekunden
nextOutageInterval = random(ausfallHaeufigkeit - 5000, ausfallHaeufigkeit + 5000);
if (nextOutageInterval < 30000) nextOutageInterval = 30000; // Minimum von 30 Sekunden
if (nextOutageInterval > 600000) nextOutageInterval = 600000; // Maximum von 600 Sekunden
Serial.print("Nächstes Ausfallintervall: ");
Serial.print(nextOutageInterval / 1000);
Serial.println(" Sekunden.");
}
}
}
// Simuliert das Flackern einer LED während eines Ausfalls
void simulateOutageFlicker(int ledIndex) {
int flickers = random(5, 10); // Mehr Flackern beim Ausfall
for (int i = 0; i < flickers; i++) {
analogWrite(ledPins[ledIndex], random(50, brightness)); // Flackernde Helligkeit
delay(random(200, 600)); // Pause zwischen Flackern
analogWrite(ledPins[ledIndex], 0); // LED kurz aus
delay(random(200, 600));
}
analogWrite(ledPins[ledIndex], brightness); // LED wieder normal einschalten
}
// Funktion zum Blinken aller LEDs bei Hinderniswarnung
void blinkAllLeds(int blinkCount) {
unsigned long currentMillis = millis();
for (int i = 0; i < blinkCount; i++) {
for (int j = 0; j < 4; j++) {
analogWrite(ledPins[j], 0); // Alle LEDs aus
}
delay(500); // 500 ms Pause
for (int j = 0; j < 4; j++) {
analogWrite(ledPins[j], brightness); // Alle LEDs wieder an
}
delay(500); // 500 ms Pause
}
}
Dann untersuche mal Deine Platine mit einer starken Lampe und Lupe und kratze um den Anschluß D3 frei. Wo soll sonst die Spannung am D3-Anschluss ohne Prozessor her kommen.
Gruß Tommy
Versuche es mal so:
#include <MobaTools.h>
// Pins für das Servo und Torsteuerung
MoToServo Servo1; // Erstelle ein Servo-Objekt für meinServo
const int servoPin = 8; // Pin für den Servo (PWM)
const int taster = 10; // Pin für das Signal zum Öffnen/Schließen
const int ausfall = 7; // Pin für Ledausfälle
const int relayPin = 2; // Signalpin (D2) (steuert das Relais für Abschalten der Servos), gleichzeitig gibt er an die Beleuchtung das Signal
// Servowinkel
int startAngle = 4; // Aktueller Winkel Servo1, damit nichts spannt - Dieser Winkel wird beim Einschalten gesetzt
int doorAngle = 60; // Zielwinkel für das Servo1
int hindAngle = doorAngle - 5; // Schließwinkel bei Hindernis1
int angle = startAngle; // Aktueller Winkel des Servos
int closedAngle = 0; // gesetzter Schließwinkel
// Kontrollpins für Tor
const int hindernisPin2 = A3; // Eingang Hinderniserkennung Tor2 HG2
const int openStatePin1 = A4; // Eingang ToroffenErkennung1 TO1
// Steuerungsvariablen
bool isOpen = false; // Zustand des Tor1 (offen oder geschlossen / true oder false)
const unsigned long waitDoor = 50; // Wartezeit in ms zwischen den Schritten
const unsigned long interval = 1000; // Intervallzeit
bool runLoop = false; // Variable, um die Schleife zu steuern
bool waiting = false; // Variable, um die Wartezeit zu steuern
bool tasterGedruckt = false; // Tasterstatus
bool moving = false; // Bewegt sich das Servo gerade?
bool hindernis = false; // Variable für Hinderniswarnung obstacleDetected
int hindZahl = 0; // Zähler für Hindernisversuche obstacleRetries
unsigned long hindernisMillis = 0; // Zeitstempel für den nächsten Versuch. obstacleRetryMillis
unsigned long timezuvor = 0; // Variable, um die letzte Zeit zu speichern
bool waitingToOpen = false; // Wird auf true gesetzt, während auf das Öffnen nach einem Hindernis gewartet wird
unsigned long waitToOpenMillis = 0; // Zeitstempel für die 3-Sekunden-Wartezeit
unsigned long previousMillis = 0; // Letzte Zeitmessung
const long intervalHind = 2000; // Intervallzeit in Millisekunden (2 Sekunde)
// Beleuchtung
const int ledPins[] = { 6, 5, 3, 11 };
const int HellPotPin = A1; // Potentiometer für Helligkeitseinstellung
const int ausfallPin = 9; // Schalter für Ausfallhäufigkeit
const int Schweisslicht = 12; // Schweißlicht - simuliert einen schweißvorgang
const int WarnLed = 4; // Warnled bei Hindernis rot blinkend
// LED Zustände
bool ledOn[4] = { false, false, false, false }; // Speichert, ob LED an ist
bool ledStable = false; // Alle LEDs stabil eingeschaltet
// Variablen für die Fehlerlogik beim Licht
unsigned long lastOutageTime = 0;
unsigned long nextOutageInterval = 0;
bool ledOutageActive = false; // Gibt an, ob gerade ein LED-Ausfall stattfindet
int outageLed = -1; // Index der LED, die aktuell ausfällt
// Steuerungsvariablen Licht
int brightness = 255; // Helligkeit der LEDs (über Potentiometer steuerbar)
int ausfallHaeufigkeit = 40; // Häufigkeit der Fehler
bool buttonPressed = false; // Status des Einschaltknopfes
bool ledsOn = false; // Zustand der LEDs (an/aus)
// Hindernis-Warnungslogik LIcht
unsigned long lastHindernisTime = 0;
const unsigned long hindernisInterval = 120000; // 2 Minuten (120.000 ms)
bool hindernisActive = false;
bool ledOutage = false;
//
// *****************************************************
// ********************** setup **********************
// *****************************************************
void setup() {
Serial.begin(9600);
Servo1.attach(servoPin); // Servo an Pin 8
Servo1.setSpeed(0); // setze Speed auf Normal
pinMode(taster, INPUT_PULLUP); // SteuerPin
pinMode(ausfall, INPUT_PULLUP); // Ausfall Steuerpin
pinMode(relayPin, OUTPUT); // SignalPin wird für beide Tore benutzt
pinMode(openStatePin1, INPUT_PULLUP); // Toroffenerkennung auf Eingang mit PullUp setzen
pinMode(hindernisPin2, INPUT); // Hinternis in Garage und 2 auf Eingang mit PullUp setzen
pinMode(ausfallPin, INPUT_PULLUP); // Schalter für Lichtausfälle
pinMode(Schweisslicht, OUTPUT); // Ausgang für Schweißlicht
pinMode(WarnLed, OUTPUT); // Warnled rot
// LED Pins als Ausgang definieren
for (int i = 0; i < 4; i++) {
pinMode(ledPins[i], OUTPUT);
digitalWrite(ledPins[i], 0); // LEDs aus
}
digitalWrite(WarnLed, false); // Warnled aus
digitalWrite(relayPin, LOW); // Relais ist standardmäßig ausgeschaltet
// Torstatus abfragen
doorStatus(); // Torstatus setzen
// Zufallszahlengenerator initialisieren
randomSeed(analogRead(A0));
}
//
//
//
// *****************************************************
// ********************** loop **********************
// *****************************************************
void loop() {
unsigned long aktuellMillis = millis();
// Hindernis erkennen und Status setzen
FunkHindernis(); // Hinderniserkennung
// Helligkeit über Potentiometer A1 steuern
int potValue = analogRead(HellPotPin);
brightness = map(potValue, 0, 1023, 100, 255); // Helligkeit von 0 bis 255
// Ausfälle über AusfallPin steuern
if (digitalRead(ausfallPin)) {
ausfallHaeufigkeit = 0; //setze Ausfallhäufigkeit auf 0 - keine Ausfälle
}
//
// Tasterstatus lesen und erkennen, wenn der Taster gedrückt ist
if (!digitalRead(taster) && !tasterGedruckt && !moving) {
tasterGedruckt = true; //Taster wurde gedrückt
moving = true;
Serial.println("Impuls auf Pin 8 eingelangt");
digitalWrite(relayPin, HIGH); // Setze Relais auf ein
Serial.println("Relais ist eingschaltet");
timezuvor = aktuellMillis; //Zeitstempel setzen
}
// Wenn das Servo sich bewegt, führe schrittweise Bewegung aus
if (moving && aktuellMillis - timezuvor >= waitDoor) {
timezuvor = aktuellMillis; // Zeitstempel aktualisieren
// Bewege das Servo in 1-Grad-Schritten
if (!isOpen) {
// Tor öffnen
if (angle < doorAngle) {
angle++; // Winkel um 1 Grad erhöhen
Servo1.write(angle); // Servo auf den neuen Winkel setzen
} else {
Serial.println("Tor ist geöffnet");
// Wenn der Zielwinkel erreicht wurde
moving = false; // Bewegung stoppen
isOpen = true; // Tür ist offen
digitalWrite(relayPin, LOW); // Relais ausschalten
Serial.println("Relais ist ausgschaltet");
ledsOn = true;
turnOnLeds(); // LEDs starten
}
} else {
// Tor aschließen
if (angle > closedAngle) {
angle--; // Winkel um 1 Grad verringern
Servo1.write(angle); // Servo auf den neuen Winkel setzen
} else {
if (!hindernis) { // kein Hindernis
Serial.println("Tor ist geschlossen");
isOpen = false; // Tür ist geschlossen
turnOffLeds(); // LEDs ausschalten
} else { // Hindernis erkannt
Serial.println("Hindernis wurde erkannt!! - Tor nicht geschlossen");
isOpen = true; // Tür ist offen
}
// Wenn der Zielwinkel erreicht wurde
moving = false; // Bewegung stoppen
digitalWrite(relayPin, LOW); // Relais ausschalten
Serial.println("Relais ist ausgschaltet");
}
}
}
// Hinderniswarnung prüfen
if (hindernis && millis() - lastHindernisTime >= hindernisInterval) {
hindernisActive = true; // Hinderniswarnung aktiv
ledOutage = false; // Keine Ledausfälle mehr
Serial.println("Hindernis erkannt! Alle LEDs blinken...");
blinkAllLeds(5); // 5-maliges Blinken aller LEDs
lastHindernisTime = millis(); // Zeitstempel setzen
hindernisActive = false; // Hinderniswarnung aus
}
// Wenn alle LEDs an und stabil sind, Fehler und Hindernislogik verwalten
if (ledsOn && ledStable && !hindernisActive) {
handleLedOutage();
}
// Wenn der Taster losgelassen wird, erlauben, dass er wieder gedrückt werden kann
if (digitalRead(taster)) {
tasterGedruckt = false; // Tasterstatus zurücksetzen
}
// Ausfälle ein- bzw ausschalten
if (digitalRead(ausfall)) {
ledOutage = true;
}
//
}
//
//
//
// *****************************************************
// ******************* Funktionen *******************
// *****************************************************
//Torstatus erkennen
void doorStatus() {
// setzen des Torzustandes bei Tor1
if (!digitalRead(openStatePin1)) { // lesen des Statuseinganges A2
isOpen = true; // setzen des Torzustandes
Serial.println("Tor ist offen"); // setzen des Torzustandes
//Servo1.write(doorAngle); // setzen des Servos1 auf den Startwinkel
if (!ledsOn) {
ledsOn = true;
turnOnLeds(); // LEDs starten
}
Serial.print("Startwinkel gesetzt auf: ");
Serial.println(doorAngle);
angle = doorAngle + 1; // setze Winkel auf Toroffen
} else {
isOpen = false; // setzen des Torzustandes
Servo1.write(startAngle); // Servo auf geschlossen setzen
Serial.println("Tor1 ist geschlossen");
Serial.print("Startwinkel gesetzt auf: ");
Serial.println(startAngle);
angle = startAngle; // setze Winkel auf Startwinkel
}
}
//
// Hindernis erkennen
void FunkHindernis() {
// Hindernis erkennen und Status setzen
// Wenn Hindernis erkannt ist Status false
if (isOpen == true) {
if (digitalRead(hindernisPin2)) {
// Hindernis erkannt
hindernis = true; // Hindernisstatus auf Wahr setzen
closedAngle = hindAngle; // Setze geschlossenen Winkle auf Startwinkel
HindernisWarnung(true, previousMillis, 500); // Warnled blinken lassen
//angle = doorAngle + 1; // setze Winkel auf Toroffen
} else {
// kein Hindernis erkannt
hindernis = false; // Hindernisstatus auf Falsch setzen
closedAngle = startAngle; // setze Winkel auf Hinderniswinkel
HindernisWarnung(false, previousMillis, 500); // Warnled ausschalten
//angle = doorAngle + 1; // setze Winkel auf Toroffen
digitalWrite(WarnLed, false); // Warnled aus
}
}
}
//
// Blinkende rote Led an Pin4, wenn Hindernis oder Tor bewegt sich
void HindernisWarnung(bool warnung, unsigned long &lastMillis, long blinkInterval) {
unsigned long currentMillis = millis();
if (blinkInterval == 0) {
digitalWrite(WarnLed, LOW);
warnung = false;
}
// Wenn die Bedingung erfüllt ist
if (hindernis) {
if (warnung) {
// Wenn das Intervall abgelaufen ist
if (currentMillis - lastMillis >= blinkInterval) {
lastMillis = currentMillis; // Setzt die Zeit zurück
// Schaltet die LED um (ein/aus)
if (digitalRead(WarnLed) == LOW) {
digitalWrite(WarnLed, HIGH); // LED an
} else {
digitalWrite(WarnLed, LOW); // LED aus
}
}
}
} else {
// Stellt sicher, dass die LED ausgeschaltet ist, wenn die Bedingung nicht erfüllt ist
digitalWrite(WarnLed, LOW);
}
}
//
// Funktion zum Einschalten der LEDs mit Flackern
void turnOnLeds() {
Serial.println("Einschalten der LEDs...");
for (int i = 0; i < 4; i++) {
ledOn[i] = true;
simulateStartupFlicker(i); // Simuliert das Einschaltflackern
}
ledStable = true; // Nach dem Einschaltprozess sind alle LEDs stabil
lastOutageTime = millis(); // Startzeit für Fehler zählen
nextOutageInterval = random(10000, 60000); // Erstes Ausfallintervall zufällig zwischen 10 und 60 Sekunden
Serial.println("Alle LEDs sind stabil eingeschaltet.");
}
// Funktion zum Ausschalten der LEDs
void turnOffLeds() {
ledsOn = false;
Serial.println("Ausschalten der LEDs...");
for (int i = 0; i < 4; i++) {
digitalWrite(ledPins[i], 0);
ledOn[i] = false;
}
ledStable = false; // LEDs sind ausgeschaltet
Serial.println("Alle LEDs sind ausgeschaltet.");
}
// Simuliert das Flackern der LEDs beim Einschalten
void simulateStartupFlicker(int ledIndex) {
int flickers = random(2, 7); // Anzahl der Flackerzyklen
for (int i = 0; i < flickers; i++) {
analogWrite(ledPins[ledIndex], random(100, brightness)); // Flackernde Helligkeit
delay(random(100, 500)); // Kurze Pause zwischen Flackern
digitalWrite(ledPins[ledIndex], 0); // LED kurz aus
delay(random(100, 500));
}
analogWrite(ledPins[ledIndex], brightness); // LED dauerhaft an
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" ist stabil an.");
}
// Funktion zur Verwaltung der zufälligen LED-Ausfälle
void handleLedOutage() {
if (ledOutage) {
unsigned long currentMillis = millis();
// Wenn der Ausfallintervall überschritten ist
if (currentMillis - lastOutageTime >= nextOutageInterval && !ledOutageActive) {
// Zufällige LED auswählen, die ausfallen soll
outageLed = random(0, 4);
ledOutageActive = true;
// Serielle Ausgabe: Fehler startet
Serial.print("LED ");
Serial.print(outageLed);
Serial.println(" fällt aus.");
simulateOutageFlicker(outageLed); // LED flackert beim Ausfall
lastOutageTime = currentMillis; // Zeitstempel setzen
}
// Nach dem Ausfall, LED wieder normal leuchten lassen
if (ledOutageActive) {
// Nach dem Flackern die LED wieder normal anschalten
analogWrite(ledPins[outageLed], brightness);
// Serielle Ausgabe: Fehler beendet
Serial.print("LED ");
Serial.print(outageLed);
Serial.println(" leuchtet wieder normal.");
ledOutageActive = false;
// Nächstes Ausfallintervall berechnen, zwischen 10 und 600 Sekunden
nextOutageInterval = random(ausfallHaeufigkeit - 5000, ausfallHaeufigkeit + 5000);
if (nextOutageInterval < 30000) nextOutageInterval = 30000; // Minimum von 30 Sekunden
if (nextOutageInterval > 600000) nextOutageInterval = 600000; // Maximum von 600 Sekunden
Serial.print("Nächstes Ausfallintervall: ");
Serial.print(nextOutageInterval / 1000);
Serial.println(" Sekunden.");
}
}
}
// Simuliert das Flackern einer LED während eines Ausfalls
void simulateOutageFlicker(int ledIndex) {
int flickers = random(5, 10); // Mehr Flackern beim Ausfall
for (int i = 0; i < flickers; i++) {
analogWrite(ledPins[ledIndex], random(50, brightness)); // Flackernde Helligkeit
delay(random(200, 600)); // Pause zwischen Flackern
digitalWrite(ledPins[ledIndex], 0); // LED kurz aus
delay(random(200, 600));
}
analogWrite(ledPins[ledIndex], brightness); // LED wieder normal einschalten
}
// Funktion zum Blinken aller LEDs bei Hinderniswarnung
void blinkAllLeds(int blinkCount) {
unsigned long currentMillis = millis();
for (int i = 0; i < blinkCount; i++) {
for (int j = 0; j < 4; j++) {
digitalWrite(ledPins[j], 0); // Alle LEDs aus
}
delay(500); // 500 ms Pause
for (int j = 0; j < 4; j++) {
analogWrite(ledPins[j], brightness); // Alle LEDs wieder an
}
delay(500); // 500 ms Pause
}
}