http://sites.schaltungen.at/arduino-sketch/

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2018-05-20

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
DIN A4  ausdrucken   (Heftrand 15mm / 5mm)     siehe     http://sites.schaltungen.at/drucker/sites-prenninger
~015_b_PrennIng-a_arduino.sketch- (xx Seiten)_1a.pdf

ARDUINO UNO R3 Board mit ATmega328p (DIP)

ATMEGA328 pinout diagram

ARDUINO UNO pinout diagram

Handbuch der analogen Elektronik
Burkhardt Kainka




Gebundene Ausgabe – 2000
Franzis Verlag (2000)
ISBN-10: 3772351948
ISBN-13: 978-3772351945
Verpackungsabmessungen: 23x16x2,6 cm
Handbuch der analogen Elektronik

Ein gutes Buch für Einsteiger, leicht und verständlich geschrieben, mit vielen Beispielen, einfachen Versuchs- und Meßaufbauten
(um einmal kurz nachgebaut zu werden), sowie einigen Tabellen.
Auch für den erfahrenen Elektroniker ist es ein Buch um einmal wieder etwas nachzuschlagen, sich Anregungen zu holen oder Vergessenes wieder aufzufrischen.





********************************************************I*

2 Arduino – Einführungen

Eine kurze Suche im Internet mit den Begriffen „Arduino“ und „Tutorial“ oder „Arduino“ und „Programmierhandbuch“ fördert eine stattliche Anzahl sehr brauchbarer Quellen zutage.
Sie erfüllen unterschiedliche Bedürfnisse auf unterschiedlichen Niveaus.
Nützlicher als ein weiteres Tutorial / Handbuch könnte eine Zusammenfassung der Quellen sein.

Allgemeine Tutorials und Handbücher

Arduino Programmier-Handbuch (Alt)  (25 Seiten) vorh.
Deutsch; 25 Seiten; nicht ganz taufrisch; solide Grundlagen der Programmierung inklusive der Ablaufsteuerung mit „if“, „while“ und „switch“; kurze, grundlegende Hardwarekunde zum Anschluss von LED, Taster, PullUp, Motor mit Freilaufdiode, PWM etc auf den letzten 4 Seiten.

Quelle:

http://www.freeduino.de/de/books/arduino-prorammier-handbuch
http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf


Arduino Programmier-Handbuch (Neu) (24 Seiten) vorh.
Deutsch; 24 Seiten; scheinbar eine aktualisierte Auflage des zuvor genannten Handbuchs
www.ov-meschede.de/workshop/Arduino%20Programmierhandbuch.pdf


Von Null auf Arduino in 4 Stunden (82 Seiten) vorh.
Deutsch; 82 Folien; groß gedruckt sehr reich bebildert legt Marc Schaffer neben einer allgemeinen Einführung in die Entwicklungsumgebung insbesondere wert auf den richtigen Umgang mit der Hardware.

Vor dem ersten Handanlegen unbedingt empfehlenswert. Die 4 Stunden sind gut investiert.
www.marc-schaffer.ch/data/Arduino101.pdf


Arduino Mikrocontroller-Programmierung mit Arduino und Freeduino von Ulli Sommer (265 Seiten) vorh.
Deutsch; 265 Seiten; ein komplettes eBook von Franzis; kostenlos bei Registrierung;
Ausführliche Grundlagen der Programmierung auch mit „bit“-Schieberei;
bei dem „Preis“ muss man das haben, denn auch wenn es etwas alt ist („Duemilanove“ als aktueller Arduino UNO R3), aber es stimmen die Grundlagen.
Der I2C-Bus findet eine ausführliche Würdigung, verschiedene „Experimente“ / Aufbauten mit Hardware werden intensiv beleuchtet.
Keine Literatur für den Superschnelleinstieg, aber eine ordentliche Referenz.
x704_d_ARDUINO-x_25035-1 Arduino Mikrocontroller-Programmierung mit Arduino-Freeduino (265 Seiten)_1a.pdf
www.elo-web.de/elektronik/angebot/praxisbuch-arduino-aktion


Arduino-Anleitung des Leibniz-Gymnasiums (40 Seiten) vorh.
Arduino Anleitung von J. Gräber 2017.2
Deutsch; 48 Seiten auf 24 Folien; Einführungen und Aufgabenstellungen mit Tipps angepasst auf das Niveau interessierter Anfänger; insbesondere die Aufgaben und Tipps zum Selbststudium fundieren den Wert dieses Tutorials.

Auch die H-Brücke findet Eingang in den Fundus. Aufgrund der Erläuterungen in den Quelltexten für ein Selbststudium am Wochenende auch ohne die Vielfalt eigener Bauteile gut geeignet.
https://lg.rw.schule-bw.de/home/wp-content/uploads/2017/04/Arduino-Anleitung-2017.2-Teil-I.pdf
300_b_ARDUINO-x_Arduino-Anleitung-2017.2-Teil-I (40 Seiten)_1a.pdf
www.leibniz-gymnasium-rw.de/files/1382632539_arduino_anleitung.pdf



Mikrocontroller einsetzen und programmieren des Friedrich-Schiller Gymnasiums in Marbach (23 Seiten) vorh.
Deutsch; 23 Seiten; als kurzes Nachschlagewerk intendiert und geeignet; die Stärke liegt in den unterschiedlichen Ansteuerungsmöglichkeiten für Aktoren und den eigenen Sensoren und deren Erklärungen.
715_d_fritz-x_ARDUINO Mikrocontroller einsetzen und programmieren - Manuskript (23 Seiten)_1a.pdf
http://moodle.alexander-von-humboldt-realschule.de/file.php/1/arduino_in_schule.pdf
www.schule-bw.de/unterricht/faecher/nwt/unterrichtseinheiten/kurs/micro_pics/manuskript.pdf

Arduino Tutorial.pdf

Quelle:

http://esg-bretten.de/nuetzliche-dokumente.html?file=files/esg/Downloadbereich/NwT/10/Mikrocontroller/MC1_Skript_Arduino_Tutorial.pdf


Arduino Homepage:
http://www.arduino.cc/

Tutorials:
http://www.kriwanek.de/index.php/de/arduino
http://www.kriwanek.de/index.php/de/arduino/wie-beginnen
http://www.kriwanek.de/index.php/de/arduino/boards
http://www.kriwanek.de/index.php/de/arduino/shields
http://www.kriwanek.de/index.php/de/arduino/module
http://www.kriwanek.de/index.php/de/arduino/displays
http://www.kriwanek.de/index.php/de/arduino/displays/435-serielles-lcd-display-sparkfun
http://www.kriwanek.de/index.php/de/arduino/sensoren
http://www.kriwanek.de/index.php/de/arduino/aktoren
x715_d_Kriwanek-x_ARDUINO UNO Rev.3 AVR-uC-Grundlagen-Kurs (225 Seiten)_1a.pdf


Quelle:

http://www.arduino-tutorial.de/grundlagen/

1. Spannung und Strom
   Was ist der Unterschied von Spannung und Strom? Wann braucht man das Eine, wann das Andere?
2. Gleich- und Wechselstrom
   Gleichstrom hat einen Minus- und einen Pluspol, Wechselstrom wechselt sich die Stromrichtung.
3. PWM
   PWM bedeutet Pulse Width Modulation und beschreibt ein Verfahren, bei dem der Strom in schneller Abfolge ein- und abgeschalten wird.
4. TTL
   TTL (Transistor-Transistor-Logik) bezeichnet einen Standard für Integrierte Schaltungen (ICs).
5. Isolator
   Isolatoren nennt man Materialien, die keinen oder nur sehr schlecht elektrischen Strom leiten.
6. Leiter
   Als Leiter werden Materialien bezeichnet, die einen sehr kleinen elektrischen Widerstand besitzen.
7. Halbleiter
   Halbleiter sind entweder Isolator oder Leiter, je nachdem, wie man verschiedene halbleitende Schichten kombiniert oder verschaltet.
8. THT und SMD
   Für die Montage auf Leiterplatten (auch Platinen oder PCBs) gibt es diese zwei grundlegende Verfahren.
9. Datenblatt
   Die Bedienungsanleitung für elektronische Bauteile.

Quelle:

http://www.arduino-tutorial.de/einfuhrung/

Quelle:

http://www.arduino-tutorial.de/advanced/     ARDUINO UNO R3 Sketche

1. Verstärkung durch Transistor
   Transistoren sind elektronische Schalter.
2. Schaltrelais
   Elektrisch geschaltene elektromagnetische Schalter.
3. Motorsteuerung direkt per Arduino
   Was gibt es zu Beachten?
4. Motorsteuerung mit einem Schaltrelais
   Einfach und effizient.
5. Motorsteuerung mit einem Transistor
   Regelbarkeit des Motors.
6. Motorsteuerung mit einer MOS-FET Brücke
   Nur zur Info – lieber einen H-Bridge IC verwenden.
7. Motorsteuerung mit einem H-Bridge IC
   So wird ein Motor gesteuert.
8. Motorsteuerung via Fahrtenregler
   Out-Of-The-Box-Lösung
9. Motorsteuerung eines Schrittmotors (Stepper Motor)
   Spannend und Winkelgenau.
10. Accelerometer
    Beschleunigungssensor
11. Arduino Shields
    Einfaches und stabiles Erweitern des Funktionsumfangs.
12. Arduino-Schematics
    Interessant, was ein Schaltplan offenbart.
13. Barebones-Arduino
    Arduino aus wenigen Teilen selbst bauen
14. Arduino Bootloader auf ATMEGA Chip übertragen
    So kann man einen billigen Mikrocontroller in ein Arduino verwandeln.
15. Vom Breadboard zum Produkt
    So startet man eine Kleinserienproduktion mit Arduino-Chip
16. Handy als Arduino Input
    Alte Handys gehören eben doch nicht in den Müll.
17. Abstandsmessung
    mit dem Sharp GP2Y0A21YK IR Entfernungsmesser
18. Liquid Crystal Displays (LCDs)
    So kann man ein LCD ans Arduino anschließen.
19. Funkübertragung von Messwerten mit dem RF Link Modul
    So lassen sich Daten über kürzere Distanzen übertragen.
20. Viele LEDs mit Arduino steuern – WS2812
    Wenn man LEDs mit Arduino steuern möchte, stößt man schnell an die Grenzen der verfügbaren Kanäle. LEDs mit integrierten Controllern lösen dieses Problem einfach und effizient.
21. Wie steuert man einen Motorfader mit Arduino?
    Motorfader sind motorisierte Potentiometer und wie dafür gemacht, von Arduino gesteuert zu werden.
22. Arduino zu MySQL via Wifi
    Wie kann man Daten vom Arduino in eine MySQL-Datenbank schicken?

Quelle:

http://www.arduino-tutorial.de/programmieren/

1. Programmstruktur
   So ist ein Arduino Programm aufgebaut.
2. Variablen
   Speichern von Daten ist leicht.
3. Befehle
   Hört aufs Wort!
4. Methoden
   So gruppiert man Befehle sinnvoll. Wer will schon alles dreimal sagen?
5. Operatoren
   Die kleinen Helfer.
6. Abfragen
   Frage und Dir wird geantwortet werden.
7. Schleifen
   Das lernten wir noch im Kindergarten, oder?
8. Bibliotheken
   Mehr Power für Dein Projekt!

http://www.arduino-tutorial.de/platinen-herstellen/

1. Platinenlayout mit Fritzing (comming soon)
2. Fritzing Fab Platinenservice
3. Löten Grundlagen
4. Löten von SMD Bauteilen (comming soon)

http://www.arduino-tutorial.de/schaltungen/

1. ATMEGA
2. Gleichrichterschaltung
3. Spannungsregler
4. FTDI FT232 RL

http://www.arduino-tutorial.de/bauteile-2/

http://www.arduino-tutorial.de/category/videoworkshop/
VideoWorkShop ARDUINO lernen
Arduino Lernen Episode 001 – Elektronische Grundlagen
Arduino Lernen Episode 002 – Arduino Überblick
Arduino Lernen Episode 003 – Digital Out mit Blink
Arduino Lernen Episode 004 – Digital Out mit SOS
Arduino Lernen Episode 005 – Breadboard Prototyping
Arduino Lernen Episode 006 – Digital In mit einem Taster
Arduino Lernen Episode 007 – Verstärkung mit einem Transistor
Arduino Lernen Episode 008 – Analog Out mit Fading
Arduino Lernen Episode 009 – Analog In mit Servo und Pott
Arduino Lernen Episode 010 – Analog In mit Servo und LDR
Arduino Lernen Episode 011 – Serielle Kommunikation
Arduino Lernen Episode 012 – FIRMATA
Arduino Lernen Episode 013 – Platinenlayout mit Fritzing
Arduino Lernen Episode 014 – Module Quelle:

http://popovic.info/html/arduino/arduinoUno_1.html

Diese Einführungbasiert auf den Tutorialsauf arduino.cc, der Einführungvon .:oomlout:.,
Tipps aus der Literatur,dem arduino-Forumund den IC-Tutorialsvon doctronics.
Eigentlich istbei diesen hervorragenden Quellenkeineigenes, weiteres Skript mehr nötig.
Bei meinenSchülern enstand jedoch der Wunsch nach einem an denUnterricht angelehnten, deutschsprachigenSkript.

• Vorwort
• Inhaltsverzeichnis
• Basics und I/O
  • AllgemeineProgrammstruktur
  • Blinkende Leuchtdiode
  • Dimmen einer LEDmittels PWM (Pulsweitenmodulation)
  • Digitale Werteerfassen
  • Analoge Werte erfassen
  • Helligkeitmittels LDR messen
  • Temperaturmittels NTC messen
  • Tönemittels Lautsprecher ausgeben
  • Welche Arten von Speicher gibtes?
  • Watch dog timer
• Kontrollstrukturen
  • Entscheidungen mit if()
  • Welches sind diewichtigsten Vergleichsoperatoren?
  • Wiederholungen mitwhile()
  • Wiederholungen mitfor()
  • Arrays (eindimensional)
• SpezielleBauteile und Bibliotheken
  • 7-Segment-Anzeige
  • RS-Flipflop
  • I2C-Portexpander
  • I2C-Uhr (RTC)
  • LCD
  • Serielles LCD
  • Temperaturmessungmittels LS35DZ
  • LichtschrankemittelsReflexoptokoppler CNY70 (kurze Distanz)
  • Lichtschrankemittels TEMIC K153P (kurze Distanz)
  • GabellichtschrankeTCST2000 (CNY35)
  • AbstandssensorGP2 Y0A02 YK0F(mittlere Distanz)
  • UltraschallEntfernungsmesser Parallax PING))) (2 cm bis 3 m)
  • Ultraschall-Entfernungsmesser HC- SR04 (2 cm bis 4 m)
  • Getriebemotormit dem L293D ansteuern
  • GeschwindigkeiteinesGetriebemotors regulieren
  • Servomotor vonHand (PWM) ansteuern
  • ServomotorunterVerwendung der Bibliothek ansteuern
  • BipolarenSteppermittels L293D ansteuern
• Debouncen (Tasterentprellen)
  • per Software
  • per Hardware
• Interrupts
• Serielle Schnittstelle
• Shields
  • LCD-keypad-shield(hier mit RTC)
  • Network: Aktuelle Temperaturauf Webseite ausgeben
  • Network-Shield:Tweets versenden
  • WiFi-Shield
    
  • XBee-Sockel+ WLAN Modul (RN-171)
  • Xbee
• Assembler
• Processing
• Atmega328 (mit und ohne Arduino Board)
• • Uno imArduino-Boardprogrammieren und umpflanzen
  • Bootloadermit dem Uno-Boardauf einen nacktenAtmega 328 brennen
• Anhang:Einklein wenig Physik
  • Vorwiderstandberechnen
  • DieSpannungsteilerschaltung
  • Pull-upundpull-down-Widerstände
  • InternePull-up-Widerstände
  • Transistor alsVerstärker
  • Festspannungsregler
  • Beispiel:Steuernmit einem Relais
• Literatur
• Links

Seite steht unter dercreative-commons-LizenzCC BY-SA.


Video-Tutorials:
http://www.arduino-tutorial.de/category/videoworkshop/
http://mr.intermediadesign.de/tag/arduino/
http://maxtechtv.de/category/arduino/beginner/


Quelle:

www.arduinospielwiese.de



Quellen mit spezifischen Lösungen und Sammlungen von Lösungen

Die folgenden Links stehen für sich und sind aufgrund ihrer Reichhaltigkeit nicht in wenigen Sätzen zusammenzufassen.


Englisch
tronixstuff.com/
learn.adafruit.com
learn.sparkfun.com/tutorials

Quelle:
http://technik-garage.de/category/arduino/

http://technik-garage.de/mikrocontroller/arduino-einfuehrungen/

3 Englischsprachige Arduino-Einführungen / Tutorials

https://www.instructables.com/Arduino-Energiez%C3%A4hler-F%C3%BCr-Solaranlage/
https://pitrium.de/arduino-energiezaehler https://youtu.be/FVCoN79ZJg8
https://www.youtube.com/watch?v=FVCoN79ZJg8
https://drive.google.com/drive/folders/1YfOalbRkXCv2qN93jo1VhX9bqR5d_aL1
Der verwendete Stromsensor (CT Sensor) ist speziell für Strommessung in Wechselstromanwendungen realisiert.

Wie man den CT Sensor mit Arduino verwendet, zeigt diese Anleitung Current Sensor Sketch

Quelle:

https://www.aeq-web.com/arduino-current-sensor-power-electricity-meter/

Arduino Current Power Sensor - Strom und Leistung im Wechselstromkreis messen
https://www.youtube.com/watch?v=jRj1q8037Rk floatToString.h
ACS709 Stromsensor Breakout Board -75 to +75A.fzpz
strom_und_spannung.pde  (strom_und_spannung.iso ???)

strom_und_Spannung.fz ARDUINO UNO
Schaltuhr für Außenbeleuchtung mit Dämmerungsschalter und Bewegungsmelder

// Projekt: KJS Schaltuhr mit Dämmerungsschalter und Bewegungsmelder
// Datei: KJS_RTC_Schaltuhr_Sensoren
// Thema: RTC-Uhr als Schaltuhr mit Dämmerungsschalter und Bewegungsmelder
// mit automatischer Umschaltung auf Sommerzeit für Außenbeleuchtung
// Hardware: Arduino Uno, 8 x 2 LCD-Display, DS3231, AM312, Photowiderstand
// Autor: Karl-Josef Schneider
// Bearbeitung: erstellt am 26.03.2021, letzte Änderungen am 11.04.2021
//..!....1....!....2....!....3....!....4....!....5....!....6....!....7....!....8....!


// Libraries hinzufügen -------------------------------------------------------------
#include <Wire.h> // Lib zur I2C-Kommunikation
#include <LiquidCrystal_I2C.h> // Lib für das LCD-Display über I2C
#include "RTClib.h" // Lib für die Real Time Clock
#include <EEPROM.h> // Lib für das interne EEPROM

// Setup LCD-Display ----------------------------------------------------------------
LiquidCrystal_I2C lcd(0x27, 8, 2); // HEX-Adresse 0x27,8 Zeichen,2 Zeilen

// Setup Real Time Clock ------------------------------------------------------------
RTC_DS3231 RTC;


// Variablen deklarieren ------------------------------------------------------------
// Variablen für Digital-Pins --------------------------------------
#define Taster_OK 13 // Taster für Bestätigung nach Eingabe
#define Taster_Plus 11 // Taster um Wert zu erhöhen
#define Taster_Minus 12 // Taster um Wert zu erniedrigen
const int TastePin[] = {10, 9, 8, 7}; // Nummern der Tast-Pins
const int LEDPin[] = {3, 4, 5, 6}; // Nummern der Output-Pins
const byte pins = 4; // Anzahl der Pins
int OK = 1; // OK-Pin auf 1 setzen
int Stunden, Minuten; // Zeitvariablen für Taster
int Ein_Stunde, Ein_Minute; // Einschaltzeit
int Aus_Stunde, Aus_Minute; // Ausschaltzeit
int Uhr_h, Uhr_m, Uhr_s; // Variablen für Uhrzeit
int Sommer; // Sommerzeit true/false
const int LDR = A0; // Pin für LDR Eingang
const int Relais = 2; // Pin für Relais Ausgang
int LDR_Wert = 0; // Wert für LDR = 0
const int PIR = A1; // Pin für Bewegungsmelder

// Zeit-Variablen --------------------------------------
bool dunkel = false; // Merker Schwellwertunterschreitung
bool action = false; // Merker für ausgelöste Aktion
unsigned long dunkel_Start = 0; // Merker für Begin der Dunkelphase

// Startroutine ---------------------------------------------------------------------
void setup(){
Serial.begin(9600); // Seriellen Monitor starten
for (byte i = 0; i < pins; i++) {
pinMode(TastePin[i], INPUT_PULLUP); // Pins = Inputs mit PullUp
pinMode(LEDPin[i], OUTPUT); } // Pins = Outputs
digitalWrite(LEDPin[0], HIGH); // Pin 6 = HIGH nach Booten
lcd.init(); // LCD starten
lcd.backlight(); // Hintergrundbeleuchtung einschalten
RTC.begin(); // Uhr starten

// Wenn Uhrzeit neu gesetzt werden soll, sonst auskommentieren !!!
// RTC.adjust(DateTime(__DATE__, __TIME__)); // Zeit vom PC einlesen
//EEPROM.update(0, 7);EEPROM.update(1, 15);
//EEPROM.update(2, 1);EEPROM.update(3, 10);

Ein_Stunde = EEPROM.read(0); // Einschaltzeit Stunde einlesen
Ein_Minute = EEPROM.read(1); // Einschaltzeit Minute einlesen
Aus_Stunde = EEPROM.read(2); // Ausschaltzeit Stunde einlesen
Aus_Minute = EEPROM.read(3); // Ausschaltzeit Minute einlesen
pinMode(Taster_OK, INPUT_PULLUP); // Pin = Input mit PullUp
pinMode(Taster_Plus, INPUT_PULLUP); // Pin = Input mit PullUp
pinMode(Taster_Minus, INPUT_PULLUP); // Pin = Input mit Pullup
pinMode(Relais, OUTPUT); // Pin = Output
digitalWrite(Relais, HIGH); // Relais Output bei Start HIGH
pinMode(PIR, INPUT); // Pin = Input Bewegungsmelder
pinMode(A2,OUTPUT); // Pin = Output Bewegungsmelder
digitalWrite(A2, HIGH); // Bewegungsmelder bei Start HIGH
}

// Ende Startroutine -----------------------------------------------------------

// Hauptroutine =====================================================================
void loop() { // Schleife starten
Sommer = Sommerzeit(); // Abfrage Sommerzeit
// Schaltungslogik --------------------------------------
// Der Schalter soll bei einsetzender Dunkelheit die Lampe einschalten, jedoch nur
// bis zu einer bestimmten Nachtzeit (Ausschaltzeit) aktiv bleiben. Nach Pause bis
// zur zu einer bestimmten Tageszeit (Einschaltzeit) wird das System wieder aktiv.
// In der Pausenzeit wird der Bewegungsmelder aktiviert.

DateTime now = RTC.now(); // Datum und Zeit ermitteln
if (int(now.hour()) > Aus_Stunde &&
int(now.minute()) > Aus_Minute &&
int(now.hour()) < Ein_Stunde &&
int(now.minute()) < Ein_Minute) { // Bewegungsmelder ------------------
if (digitalRead(PIR) == HIGH) { // wenn Bewegung erkannt wurde
digitalWrite(A2, LOW); } // Relaisausgang = LOW > Relais EIN
else { // wenn keine Bewegung erkannt wurde
digitalWrite(A2, HIGH); } } // Relaisausgang = HIGH > Relais AUS

else { // Dämmerungsschalter ----------------
Serial.print(dunkel_Start);Serial.print(" ");
Serial.println(millis()-dunkel_Start);
LDR_Wert = analogRead(LDR)/10.23; // LDR-Wert in % abfragen
if (LDR_Wert < 30) { // wenn der Wert < 30 (Dunkelheit)
if (!dunkel) { // ja, gerade eben unterschritten?
dunkel_Start = millis(); // Startzeit für Dunkelphase merken
dunkel = true; } // Merker dass es Dunkel ist setzen
else { // wenn die Dunkelphase schon läuft
if (millis() - dunkel_Start > 60000){ // schon seit 60 Sekunden dunkel?
if (!action) { // Aktion bereits ausgeführt?
digitalWrite(Relais, LOW); // Relaisausgang = LOW > Relais EIN
action = true; } }}} // Merker setzen, Action ausgeführt
else { // Schwellwert nicht unterschritten
if (action) { // ist Aktion gestartet?
digitalWrite(Relais, HIGH); // Relaisausgang = HIGH > Relais AUS
action = false; // Merker für Aktion zurücksetzen
if (dunkel) { // ist Dunkelphase gestartet?
dunkel = false; } }} // Merker für Dunkelphase zurücksetzen
}

// Betriebsmodus über Taster abfragen --------------------------------------------
for (byte i = 0; i < pins; i++) {
if (!digitalRead(TastePin[i])) { // invers, weil mit Pullups betrieben
Serial.print(i); Serial.println(F(" pressed"));
for (byte j = 0; j < pins; j++) {

Serial.print(j);
if (i == j) { // Einschalten des gedrückten Pins
digitalWrite(LEDPin[j], HIGH);
Serial.println(F("--> HIGH")); }
else { // Ausschalten der übrigen Pins
digitalWrite(LEDPin[j], LOW);
Serial.println(F("--> LOW")); }}}}

// Normalbetrieb -----------------------------------------------------------------
if (digitalRead(LEDPin[0]) == HIGH) { // Normalbetrieb
Uhrzeit(); } // Uhrzeit anzeigen

// Uhrzeit einstellen ------------------------------------------------------------
if (digitalRead(LEDPin[1]) == HIGH) { // Modus Uhrzeit einstellen
lcd.setCursor(0,1);lcd.print("Uhr-Zeit");// Display Anzeige Einschaltzeit
digitalWrite(LEDPin[0],LOW); // LEDPin Betrieb auf LOW
UhrStellen(); } // Uhrzeit einstellen
digitalWrite(LEDPin[1],LOW); // LEDPin UhrStellen wieder auf LOW
digitalWrite(LEDPin[0],HIGH); // LEDPin Betrieb wieder auf HIGH

// Einschaltzeit einstellen ------------------------------------------------------
if (digitalRead(LEDPin[2]) == HIGH) { // Modus Einschaltzeit einstellen
lcd.setCursor(0,0);lcd.print(" "); // Cursor 1. Zeile
if (Ein_Stunde <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Ein_Stunde);lcd.print(":"); // Stunden anzeigen
if (Ein_Minute <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Ein_Minute); lcd.print(" "); // Minuten anzeigen
lcd.setCursor(0,1);lcd.print("Ein-Zeit");// Display Anzeige Einschaltzeit
digitalWrite(LEDPin[0],LOW); // LEDPin Betrieb auf LOW
Einschaltzeit(); } // Einschaltzeit einstellen
digitalWrite(LEDPin[2],LOW); // LEDPin Einschaltzeit wieder auf LOW
digitalWrite(LEDPin[0],HIGH); // LEDPin Betrieb wieder auf HIGH

// Ausschaltzeit einstellen ------------------------------------------------------
if (digitalRead(LEDPin[3]) == HIGH) { // Modus Ausschaltzeit einstellen
lcd.setCursor(0,0);lcd.print(" "); // Cursor 1. Zeile
if (Aus_Stunde <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Aus_Stunde);lcd.print(":"); // Stunden anzeigen
if (Aus_Minute <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Aus_Minute); lcd.print(" "); // Minuten anzeigen
lcd.setCursor(0,1);lcd.print("Aus-Zeit");// Display Anzeige Ausschaltzeit
digitalWrite(LEDPin[0],LOW); // LEDPin Betrieb auf LOW

Ausschaltzeit(); } // Ausschaltzeit einstellen
digitalWrite(LEDPin[3],LOW); // LEDPin Ausschaltzeit wieder auf LOW
digitalWrite(LEDPin[0],HIGH); // LEDPin Betrieb wieder auf HIGH
}

// Ende Hauptroutine ===========================================================

// Subroutine Uhrzeit ---------------------------------------------------------------
void Uhrzeit() {
DateTime now = RTC.now(); // Datum und Zeit ermitteln
Uhr_h = int(now.hour()); // Stunden ermitteln
if (Sommer == true) { // bei Sommerzeit
Uhr_h = int(now.hour()+1); } // 1 Stunde addieren
lcd.setCursor(0, 0); // Cursor Position=0, Zeile=0
if (Uhr_h <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Uhr_h); // Stunden anzeigen
lcd.print(":");
Uhr_m = int(now.minute()); // Minuten ermitteln
if (Uhr_m <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Uhr_m); // Stunden anzeigen
lcd.print(":");
Uhr_s = int(now.second()); // Sekunden ermitteln
if (Uhr_s <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Uhr_s); // Stunden anzeigen
lcd.setCursor(0,1); // Cursor Position=0, Zeile=1
lcd.print("Betrieb "); // Uhrzeit
}

// Ende Uhrzeit ----------------------------------------------------------------

// Subroutine Sommerzeit ermitteln --------------------------------------------------
boolean Sommerzeit() {
DateTime now = RTC.now();
if (now.month()<3 || now.month()>10) return false; // keine Sommerzeit Jan - Dez
if (now.month()>3 && now.month()<10) return true; // Sommerzeit Apr bis Sep
if (now.month()==3 && now.day()<25) return false; // keine Sommerzeit bis 25.März
if (now.month()==10 && now.day()<25) return true; // Sommerzeit bis 25.Okt.
if (now.month()==3 && (now.hour() + 24 * now.day())
>=(1 + 24*(31 - (5 * now.year() /4 + 4) % 7))
|| now.month()==10 && (now.hour() + 24 * now.day())
<(1 + 24*(31 - (5 * now.year() /4 + 1) % 7)))
return true;
else
return false;
}

// Ende Sommerzeit -------------------------------------------------------------


// Subroutine Uhr stellen -----------------------------------------------------------
void UhrStellen(){
DateTime now = RTC.now(); // Datum und Zeit auslesen
Stunden = int(now.hour()); // Stunden ermitteln
Minuten = int(now.minute()); // Minuten ermitteln
Taster(); // Abfrage Taster
RTC.adjust(DateTime(now.year(),now.month(),now.day(),Stunden, Minuten,0));
} // Ende Uhr stellen ------------------------------------------------------------

// Subroutine Einschaltzeit einstellen ----------------------------------------------
void Einschaltzeit(){
Stunden = Ein_Stunde; // Stunden übernehmen
Minuten = Ein_Minute; // Minuten übernehmen
Taster(); // Abfrage Taster
Ein_Stunde = Stunden; // neue Stunden übernehmen
Ein_Minute = Minuten; // neue Minute übernehmen
EEPROM.update(0, Ein_Stunde); // neue Stunden ins EEPROM schreiben
EEPROM.update(1, Ein_Minute); // neue Minuten ins EEPROM schreiben
Serial.print ("Einschaltzeit ");
Serial.print (Ein_Stunde); Serial.print (":");
Serial.println (Ein_Minute);
}

// Ende Einschaltzeit ----------------------------------------------------------
// Subroutine Ausschaltzeit einstellen ----------------------------------------------
void Ausschaltzeit(){
Stunden = Aus_Stunde; // Stunden übernehmen
Minuten = Aus_Minute; // Minuten übernehmen
Taster(); // Abfrage Taster
Aus_Stunde = Stunden; // neue Stunden übernehmen
Aus_Minute = Minuten; // neue Minute übernehmen
EEPROM.update(2, Aus_Stunde); // neue Stunden ins EEPROM schreiben
EEPROM.update(3, Aus_Minute); // neue Minuten ins EEPROM schreiben
Serial.print ("Ausschaltzeit ");
Serial.print (Aus_Stunde); Serial.print (":");
Serial.println (Aus_Minute);
}

// Ende Einschaltzeit ----------------------------------------------------------

// Subroutine Taster abfragen -------------------------------------------------------
void Taster() {
lcd.setCursor(0,0);lcd.print(">> "); // Display Anzeige setzen
if (Stunden <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Stunden);lcd.print(":"); // Stunden anzeigen
if (Minuten <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Minuten); // Minuten anzeigen
OK = 1; // OK auf 1 setzen
while(OK == 1) { // solange OK = 1
delay(200); // Pause
if (digitalRead(Taster_Plus) == LOW) { // wenn Taster "+" gedrückt wird
delay(200); // Pause
if(Stunden>22) Stunden =0; // um 23 Uhr auf 0 setzen
else Stunden ++; } // sonst 1 Stunde addieren
if (digitalRead(Taster_Minus) == LOW) { // wenn Taster "-" gedrückt wird
delay(200); // Pause
if(Stunden<=0) Stunden =23; // um 0 Uhr auf 23 setzen
else Stunden --; } // sonst 1 Stunde subtrahieren
OK = digitalRead(Taster_OK); // Taste "OK" abfragen
lcd.setCursor(3, 0); // Cursor Position=0, Zeile=0
if (Stunden <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Stunden); } // Stunden anzeigen
lcd.setCursor(0,0); // Display Anzeige Set
if (Stunden <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Stunden);lcd.print(":"); // Stunden anzeigen
if (Minuten <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Minuten);lcd.print(" <<"); // Minuten anzeigen
OK = 1; // OK auf 1 setzen
while(OK == 1) { // solange OK = 1
delay(200); // Pause
if (digitalRead(Taster_Plus) == LOW) { // wenn Taster "+" gedrückt wurde
delay(200); // Pause
if(Minuten>59) Minuten =0; // bei > 59 Minuten auf 0 setzen
else Minuten ++; } // sonst 1 Minute addieren
if (digitalRead(Taster_Minus) == LOW) { // wenn Taste "-" gedrückt wurde
delay(200); // Pause
if(Minuten<=0) Minuten =59; // bei < 0 Minuten auf 59 setzen
else Minuten --; } // sonst 1 Minute subtrahieren
OK = digitalRead(Taster_OK); // Taste "OK" abfragen
lcd.setCursor(3, 0); // Cursor Position=0, Zeile=0
if (Minuten <10){ lcd.print("0");} // führende 0 anzeigen
lcd.print(Minuten); } // Minuten anzeigen
}

// Ende Taster abfragen --------------------------------------------------------

https://gist.github.com/karljosefschneider/30731126ce8ccf22f5837baca2ddb0dd
12V Light Control Switch Photoresistor Relay Module Detection Sensor
Model: XH-M131

********************************************************I*