|
http://sites.schaltungen.at/arduino-sketch/az-delivery Wels, am 2019-12-06BITTE nützen Sie doch rechts OBEN das Suchfeld [ ] [ Diese Site durchsuchen]DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I** DIN A4 ausdrucken (Heftrand 15mm / 5mm) siehe http://sites.schaltungen.at/drucker/sites-prenninger
********************************************************I* ~015_b_PrennIng-a_arduino.sketch-az-delivery (xx Seiten)_1a.pdf
https://www.az-delivery.de/
2.1) .2 ESP8266 Sensordaten auf Webseite ausgeben 3.1) .2 .3 .4 Eine elegante automatische Treppenbeleuchtung 4) ESP8266-01 Relais mit Website steuern
5) 200 kostenlose e-Books
6) Az-Delivery Sensoren
********************************************************I*
von Aihasd
Geringe Größe, geringe Kosten
Montiert auf einem Breakout Board mit zwei Arten von Stiften 10k Pull-Up-Widerstände für die I2C-Schnittstelle mit optionalen Lötbrücken Einfach zu integrieren 
Ein minimales Breakoutboard, um berührungslos Temperaturen per Infrarot zu messen: mit dem GY-906 Infrarot-Thermometer ist es ganz einfach, bestimmte Temperaturen zu messen. Der MLX90614ESF Sensor ist auf einen breiten Messbereich zwischen -40 °C bis 125 °C kalibriert. -40 °C bis 125°C Temperaturbereich des Sensors inkl. Stiftleiste
https://www.aliexpress.com/popular/gy-906-mlx90614.html
https://learn.adafruit.com/using-melexis-mlx90614-non-contact-sensors/wiring-and-test
https://learn.adafruit.com/using-melexis-mlx90614-non-contact-sensors/wiring-and-test
https://learn.sparkfun.com/tutorials/mlx90614-ir-thermometer-hookup-guide/all
https://www.sparkfun.com/datasheets/Sensors/Temperature/MLX90614_rev001.pdf
https://github.com/adafruit/Adafruit-MLX90614-Library
https://www.arduinolibraries.info/libraries/mlx90614
300_d_WILTRONICS-x_GY-906 Infrarot-Temperatursensor Chip MLX90614 - Datenblatt_1a.pdf
300_d_Melix-x_GY-906 Infrarot-Temperatursensor Chip MLX90614 TO-39 - Datenblatt_1a.pdf
300_d_adafruit-x_GY-906 Infrarot-Temperatursensor Melexis MLX90614 mit ARDUINO UNO_1a.pdf
https://cdn-learn.adafruit.com/downloads/pdf/using-melexis-mlx90614-non-contact-sensors.pdf
Die Sensoren kannst du parallel schalten und um die Adressen raus zu bekommen kannst du den
verwenden.
Jewels einzeln abfragen. Und die Pullup-Widerstände 4,7k gegen +5Volt nicht vergessen.
Die Adresse kann man im EEPROM ändern! Und im Datenblatt ist auch ein Schaltbild für mehrere Sensoren
https://www.adafruit.com/datasheets/MLX90614.pdf
Eine Beschreibung habe ich jetzt auch gefunden: Giving an MLX90614 a New Address.
Da steht dann auch, wie eine Temperatur ohne Bibliothek ausgelesen werden kann, sollte diese bei mehreren Sensoren mucken.
Eine typische Pinbelegung bei einem Arduino sieht wie folgt aus:
You may download the MLX90614 Arduino Library & Example (1.15MB) or manually key-in:
#include <Wire.h>#include <Adafruit_MLX90614.h>Adafruit_MLX90614 mlx = Adafruit_MLX90614();void setup() { Serial.begin(9600); Serial.println("Adafruit MLX90614 test"); mlx.begin(); }void loop() { Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempC()); Serial.print("*C\tObject = "); Serial.print(mlx.readObjectTempC()); Serial.println("*C"); Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempF()); Serial.print("*F\tObject = "); Serial.print(mlx.readObjectTempF()); Serial.println("*F"); Serial.println(); delay(500);}
http://qqtrading.com.my/infrared-thermometer-module-gy-906-mlx90614
OLED 0,96" € 5,99
von AZDelivery
Monochromes 0.96"OLED Display mit 128 x 64 Bildpunkten (weiss)
Dieses Display ist mit 3 cm Bildschirmdiagonale sehr klein und durch hohen Kontrast gut lesbar.
Das Display besteht aus 128x64 OLED Bildpunkten die durch den verbauten SSD1306 Chip einzeln gesteuert werden.
Da die Pixel leuchten wird keine Hintergrundbeleuchtung benötigt, was sich positiv auf den Stromverbrauch auswirkt und dem Display den hohen Kontrast verleiht. Es ist ideal für einfache Verwendung mit Mikrocontrollern wie ARDUINO ATmega, STM32, 8051, AVR, PIC, DSP, ARM, MSP430, PLC,TTL-Logik.
Das Display wird über die I2C-Schnittstelle angesteuert und benötigt nur 4 Anschlüsse.
Eine typische Pinbelegung bei einem Arduino sieht wie folgt aus:
In Kombination mit den beiden Arduino Bibliotheken Adafruit GFX und Adafruit SSD1306, welche auch Beispiel-Sketches enthalten, lässt sich das Display schnell programmieren. Details:
Quick-Start-Guide 0,96 Zoll OLED Display
Ganz einfach zum eigenen IR-Thermometer Heut möchten wir Ihnen zeigen, wie Sie mit wenig Bauteilen und nur ein paar Zeilen Code Ihren eigenen IR-Thermometer bauen können. Das fertige Projekt können Sie verwenden, um berührungslos Temperaturen zu messen, an Maschinen oder Ähnlichem. Dezember 4, 2019 Moritz Spranger IR-ThermometerWie man mit unserem GY-906-Modul, einem Nano V3 und einem OLED mit wenigen Zeilen Code ein IR-Thermometer umsetzten kann.
Der Aufbau eignet sich gut zum berührungslosen überwachen von Temperaturen, z.B. an Maschinen, an Heizkörper, an Herdplatten, an Kühlkörper usw.
Wir brauchen also: 1x Nano V3 1x OLED 0.96" 1x GY-906 1x mini-BreadBoard m. Jumper-Wire 1x 9V-Batteriehalter Optional können Sie das Projekt gerne um eine Laserdiode oder ein Button-Modul erweitern. KY-008 Laser Sensor Modul 650nm 5mW 5V für Arduino https://www.az-delivery.de/products/laser-modul?_pos=4&_sid=268bb17cd&_ss=r
KY-004 Taster Modul Sensor Taste Kopf Schalter Schlüsselschalter für Arduino
https://www.az-delivery.de/products/button-modul?_pos=43&_sid=1a80cb7cc&_ss=r
Die Verdrahtung: Nano GY-906 OLED Batterieclip Vin + GND GND GND - 5V Vcc 3.3V Vcc A4 SCL SCL A5 SDA SDA Die notwendigen Librarys: Installieren Sie beide Librarys wie gewohnt über Ihren Bibliotheksverwalter in der Arduino-IDE.
Möchten Sie die aktuellste Version nutzen können Sie diese über GitHub beziehen und als *.zip einbinden, das hat jedoch den Nachteil, neue Version selbst pflegen zu müssen.
Nutzen Sie den Bibliotheksverwalter zur Installation werden Sie durch die IDE benachrichtigt sobald eine neue Version zur Verfügung gestellt wird und können diese durch einen Klick aktualisieren.
Im nachstehenden Screenshot sind die beiden Bibliotheken abgebildet: - GY-906 - auf Github https://github.com/adafruit/Adafruit-MLX90614-Library
Zur Ausgabe der Werte auf dem Display nutzen wir heute die Library von Adafruit: 
This is a library for the MLX90614 temperature sensor https://github.com/adafruit/Adafruit-MLX90614-Library
File > Examples > Adafruit_MLX90614 > mlxtest https://learn.adafruit.com/using-melexis-mlx90614-non-contact-sensors
Hier der Code: #include <Wire.h>#include <Adafruit_MLX90614.h>#include <Adafruit_SSD1306.h>#define SCREEN_WIDTH 128 // OLED display width, in pixels#define SCREEN_HEIGHT 64 // OLED display height, in pixelsAdafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);Adafruit_MLX90614 mlx = Adafruit_MLX90614();void setup() { Serial.begin(9600); Serial.println("Adafruit MLX90614 test"); if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { Serial.println(F("SSD1306 init failed")); for(;;); } display.clearDisplay(); display.setRotation(0); display.setTextSize(1); display.setTextColor(WHITE); display.setCursor(0, 35); display.println("Init..."); display.display(); delay(500); display.clearDisplay(); mlx.begin(); }void loop() { display.clearDisplay(); display.setTextSize(2); display.setCursor(25, 10); display.print(mlx.readAmbientTempC()); //Umgebungstemperatur display.setCursor(95, 10); display.print("C"); display.setTextSize(2); display.setCursor(25, 36); display.print(mlx.readObjectTempC()); //IR-Temperatur display.setCursor(95, 36); display.print("C"); display.display(); Serial.println(); delay(1000);}
Nach der Initialisierung der Hardware in void setup, wird im loop die Umgebungs- und im Anschluss die IR-Temperatur angezeigt. https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/ir-thermometer?
********************************************************I*
2.1) ESP8266 Sensordaten auf Webseite ausgeben 1
Gestern haben wir gezeigt wie einfach unser ESP8266 mit dem MAX6675-Temperatorsensor zusammenarbeitet. Heute möchten wir den Sketch ein wenig erweitern, um die WiFi-Fähigkeit des Moduls auszunutzen.Dafür binden wir die Bibliothek "ESP8266WiFi" ein. Diese übernimmt die Anmeldung an ein bestehendes WLAN, und übernimmt das Senden und Empfangen der Daten an den Client. Mittels "WiFiServer server(80);" starten wir einen Server der auf Port 80 läuft. #include <ESP8266WiFi.h>#include <max6675.h>const char* ssid = "Wlan Name (SSID)";const char* password = "Wlan Schlüssel";int thermoDO = 12;int thermoCS = 13;int thermoCLK = 14;WiFiServer server(80); // Wir richten den Webserver auf Port 80 einMAX6675 thermocouple(thermoCLK, thermoCS, thermoDO); // Wir richten den Temperatursensor ein void setup(){ Serial.begin(115200); Serial.println(); Serial.printf("Verbinde mit %s ", ssid); WiFi.begin(ssid, password); // Versucht mit WLAN Name und Schlüssel zu verbinden while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(" verbunden"); server.begin(); Serial.printf("Webserver gestartet, öffnen Sie %s in einem Webbrowser\n", WiFi.localIP().toString().c_str());}// Inhalt der Weibseite generierenString prepareHtmlPage(){ String htmlPage = String("HTTP/1.1 200 OK\r\n") + "Content-Type: text/html\r\n" + "Connection: close\r\n" + // Die Verbindung wird nach der Übertragung geschlossen "Refresh: 5\r\n" + // Automatisch alle 5 Sekunden neu laden "\r\n" + "<!DOCTYPE HTML>" + "<html>" + "Temperatur in °C: " + String(thermocouple.readCelsius()) + //Ausgabe der Temperatur "</html>" + "\r\n"; return htmlPage;}void loop(){ WiFiClient client = server.available(); // warten auf Verbindung vom Client (Webbrowser) if (client) { Serial.println("\n[Client hat sich verbunden]"); while (client.connected()) { // zeilenweise einlesen was der Client (Webbrowser) anfragt if (client.available()) { String line = client.readStringUntil('\r'); Serial.print(line); // bis zum Ende der Anfrage warten (=Leerzeile) if (line.length() == 1 && line[0] == '\n') { client.println(prepareHtmlPage()); // Antwort ausgeben break; } } } delay(1000); // dem Browser Zeit geben um die Antwort zu empfangen // Die Verbindung schließen: client.stop(); Serial.println("[Client getrennt]"); Serial.print("C = "); Serial.println(thermocouple.readCelsius()); delay(10); }}
Die Ausgabe im Browser sieht dann wie folgt aus:
Wer sich ein Wenig mit den Grundlagen von HTML beschäftigt (Ich empfehle einen Blick auf
https://selfhtml.org/
kann im Abschnitt prepareHtmlPage() das Aussehen und den Inhalt der Seite beliebig anpassen.
Dann können auch mehrere Sensordaten auf einer Seite ausgegeben werden. Der ESP8266 kann sowohl als Webserver, aber auch aus Client fungieren.
Damit bietet der Mikrokontroller viele neue Lösungsansätze und ermöglicht konstengünstig spannende neue Projekte.
KommentarWeblint - Dezember 12, 2019 albin - Dezember 11, 2019 Ulrich Klaas - Dezember 11, 2019 4711engel - Juli 8, 2019 Bernd - Dezember 25, 2018 Hoschy - Juli 13, 2018 Klaus - Juli 6, 2018 michael - Juli 6, 2018
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/esp8266-sensordaten-auf-webseite-ausgeben?
2.2) ESP8266 Sensordaten auf Webseite ausgeben 2 Gestern haben wir gezeigt wie einfach unser ESP8266 mit dem MAX6675-Temperatorsensor zusammenarbeitet. Heute möchten wir den Sketch ein wenig erweitern, um die WiFi-Fähigkeit des Moduls auszunutzen. Dafür binden wir die Bibliothek "ESP8266WiFi" ein. Diese übernimmt die Anmeldung an ein bestehendes WLAN, und übernimmt das Senden und Empfangen der Daten an den Client. Mittels "WiFiServer server(80);" starten wir einen Server der auf Port 80 läuft. #include <ESP8266WiFi.h>#include <max6675.h>const char* ssid = "Wlan Name (SSID)";const char* password = "Wlan Schlüssel";int thermoDO = 12;int thermoCS = 13;int thermoCLK = 14;WiFiServer server(80); // Wir richten den Webserver auf Port 80 einMAX6675 thermocouple(thermoCLK, thermoCS, thermoDO); // Wir richten den Temperatursensor ein void setup(){ Serial.begin(115200); Serial.println(); Serial.printf("Verbinde mit %s ", ssid); WiFi.begin(ssid, password); // Versucht mit WLAN Name und Schlüssel zu verbinden while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(" verbunden"); server.begin(); Serial.printf("Webserver gestartet, öffnen Sie %s in einem Webbrowser\n", WiFi.localIP().toString().c_str());}// Inhalt der Weibseite generierenString prepareHtmlPage(){ String htmlPage = String("HTTP/1.1 200 OK\r\n") + "Content-Type: text/html\r\n" + "Connection: close\r\n" + // Die Verbindung wird nach der Übertragung geschlossen "Refresh: 5\r\n" + // Automatisch alle 5 Sekunden neu laden "\r\n" + "<!DOCTYPE HTML>" + "<html>" + "Temperatur in °C: " + String(thermocouple.readCelsius()) + //Ausgabe der Temperatur "</html>" + "\r\n"; return htmlPage;}void loop(){ WiFiClient client = server.available(); // warten auf Verbindung vom Client (Webbrowser) if (client) { Serial.println("\n[Client hat sich verbunden]"); while (client.connected()) { // zeilenweise einlesen was der Client (Webbrowser) anfragt if (client.available()) { String line = client.readStringUntil('\r'); Serial.print(line); // bis zum Ende der Anfrage warten (=Leerzeile) if (line.length() == 1 && line[0] == '\n') { client.println(prepareHtmlPage()); // Antwort ausgeben break; } } } delay(1000); // dem Browser Zeit geben um die Antwort zu empfangen // Die Verbindung schließen: client.stop(); Serial.println("[Client getrennt]"); Serial.print("C = "); Serial.println(thermocouple.readCelsius()); delay(10); }} Die Ausgabe der Temperatur im seriellen Monitor ist nur zur Fehlersuche. Auf dem Seriellen Monitor sehen wir nun:
Die Ausgabe im Browser sieht dann wie folgt aus:
Wer sich ein Wenig mit den Grundlagen von HTML beschäftigt (Ich empfehle einen Blick auf https://selfhtml.org/) kann im Abschnitt prepareHtmlPage() das Aussehen und den Inhalt der Seite beliebig anpassen.
Dann können auch mehrere Sensordaten auf einer Seite ausgegeben werden. Der ESP8266 kann sowohl als Webserver, aber auch aus Client fungieren. Damit bietet der Mikrokontroller viele neue Lösungsansätze und ermöglicht konstengünstig spannende neue Projekte. KommentarWeblint - Dezember 12, 2019 albin - Dezember 11, 2019 Ulrich Klaas - Dezember 11, 2019 4711engel - Juli 8, 2019 Bernd - Dezember 25, 2018 Hoschy - Juli 13, 2018 Klaus - Juli 6, 2018 michael - Juli 6, 2018
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/esp8266-sensordaten-auf-webseite-ausgeben?
********************************************************I*
3.1) Eine elegante automatische Treppenbeleuchtung (Teil1)Im ersten Teil einer neuen spannenden Reihe eine elegante automatische Treppenbeleuchtung für bis zu maximal 16 Stufen auf, bei der jede einzelne Stufe der Treppe nacheinander als Lauflicht beleuchtet wird, sobald einer der beiden Infrarotmelder, die jeweils einzeln am oberen und am unteren Ende der Treppe angebracht sind, eine Bewegung melden.
Dabei wird jede einzelne Treppe dazu noch sanft per PWM Steuerung auf die maximale Helligkeit hochgedimmt und später bis um erlöschen wieder heruntergedimmt.
Der Zeiträume, in der die Treppe eingeschaltet bleibt, oder die eine Stufe herauf- oder herabdimmt ist dabei frei im Sketch nach eigenem Belieben einstellbar.
Eine solche Lösung gibt es bereits schon kommerziell (hier im Video im Betrieb zu sehen).
Heute zeige ich, wie man eine in der Funktion ähnliche Steuerung mithilfe des Arduinos und einiger externen Bauteilen selbst bauen kann. Wir brauchen für unsere do-it-yourself Treppenbeleuchtung folgende Elektronik-Teile: Anzahl Beschreibung Anmerkung 2 PIR Modul HC-SR501 PIR Bewegungssensor 1 PCA9685 16 Kanal 12 Bit PWM Driver 1 Nano V3 1 MB102 Netzteil Adapter für Breadboardaufbau 1 bis 16 IRF520 MOS Driver Modul 0-24V 5A Anzahl je nach Treppenzahl 1 Netzteil für LED/Lampen für die Stufen max. 24 Volt Im folgenden Schaltplan ist die Kernsteuerung zu sehen. Exemplarisch sind jedoch nur 2 Treiberstufen der maximal möglichen 16 Treiberstufen zu sehen.
Falls mehr Treiberstufen benötigt werden, werden diese sinngemäß wie die beiden eingezeichneten angeschlossen.
Zu beachten ist unbedingt eine sicherheitsgerechte Verwendung von Stromkabeln und Leitungen sowie ein ausreichend dimensioniertes Netzteil.
Das Netzteil muss Überlast geschützt sein und alle Treppenstufenlichter und den Arduino mit stabilisierter Gleichspannung versorgen können ohne überlastet zu werden!
Es besteht Brandgefahr bei nicht sachgerechtem Einbau und/oder Betrieb!
Wir bauen die Schaltung für unsere Treppe wie folgt auf einem Breadboard zum testen auf:
Im nächsten Schritt passen wir den Quellcode des Arduinos an die eigenen Bedürfnisse an. Interessant sind die folgenden 3 Zeilen im Code: #define Num_Stages 15 #define Delay_Stages 10 #define Delay_ON_to_OFF 5 Num_Stages Definiert die Anzahl der zu beleuchtenden Treppen (maximal 16, von 0 anzählend zu beginnen. Maximalwert: 15) Delay_Stages Fade Zeitraum für jede Treppenstufe -> je kleiner der Wert desto größer der Zeitraum, desto langsamer. Delay_ON_to_OFF Zeitraum der vergeht indem die Treppe im Status „an“ verbleibt.
Nachdem wir die werte den eigenen Vorlieben angepasst habe, kann der Code auf den Arduino hochgeladen werden :
// 2019-12-30 Tobias Kuch GPL 3.0#include <Wire.h>#define PWM_Module_Base_Addr 0x40 //10000000b Das letzte Bit des Adressbytes definiert die auszuführende Operation. Bei Einstellung auf logisch 1 0x41 Modul 2//wird ein Lesevorgang auswählt, während eine logische 0 eine Schreiboperation auswählt.#define OE_Pin 8 // Pin für Output Enable#define PIRA_Pin 2#define PIRB_Pin 3#define Num_Stages 15#define Delay_Stages 10#define Delay_ON_to_OFF 30 // Minimum Delay_ON_to_OFF in Secondsbyte Pwm_Channel = 0;int Pwm_Channel_Brightness = 0;bool Motion_Trigger_Down_to_Up = false;bool On_Delay = false;// interrupt Controlbyte A60telSeconds24 = 0;byte Seconds24;ISR(TIMER1_COMPA_vect){ A60telSeconds24++; if (A60telSeconds24 > 59) { A60telSeconds24 = 0; Seconds24++; if (Seconds24 > 150) { Seconds24 = 0; } }}void ISR_PIR_A(){ bool PinState = digitalRead(PIRA_Pin); if (PinState) { Motion_Trigger_Down_to_Up = true; // PIR A ausgelöst }}void ISR_PIR_B(){ bool PinState = digitalRead(PIRB_Pin); if (PinState) { Motion_Trigger_Down_to_Up = true; // PIR B ausgelöst }}void Init_PWM_Module(byte PWM_ModuleAddr){ pinMode(OE_Pin, OUTPUT); digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x01); // Wähle Mode 2 Register (Command Register) Wire.write(0x04); // Konfiguriere Chip: 0x04: totem pole Ausgang 0x00: Open drain Ausgang. Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0x10); // Konfiguriere SleepMode Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0xFE); // Wähle PRE_SCALE register (Command Register) Wire.write(0x03); // Set Prescaler. Die maximale PWM Frequent ist 1526 Hz wenn das PRE_SCALEer Regsiter auf "0x03h" gesetzt wird. Standard : 200 Hz Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0xA1); // Konfiguriere Chip: ERrlaube All Call I2C Adressen, verwende interne Uhr, // Erlaube Auto Increment Feature Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit}void Init_PWM_Outputs(byte PWM_ModuleAddr){ digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). for ( int z = 0; z < 16 + 1; z++) { Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 6); // Wähle PWM_Channel_ON_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 7); // Wähle PWM_Channel_ON_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 8); // Wähle PWM_Channel_OFF_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 9); // Wähle PWM_Channel_OFF_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); } digitalWrite(OE_Pin, LOW); // Active LOW-Ausgangsaktivierungs-Pin (OE).}void setup(){ //Initalisierung pinMode(PIRA_Pin, INPUT); pinMode(PIRB_Pin, INPUT); Serial.begin(9600); Wire.begin(); // Initalisiere I2C Bus A4 (SDA), A5 (SCL) Init_PWM_Module(PWM_Module_Base_Addr); Init_PWM_Outputs(PWM_Module_Base_Addr); noInterrupts(); attachInterrupt(0, ISR_PIR_A, CHANGE); attachInterrupt(1, ISR_PIR_B, CHANGE); TCCR1A = 0x00; TCCR1B = 0x02; TCNT1 = 0; // Register mit 0 initialisieren OCR1A = 33353; // Output Compare Register vorbelegen TIMSK1 |= (1 << OCIE1A); // Timer Compare Interrupt aktivieren interrupts();}void Down_to_Up_ON(){ Pwm_Channel = 0; Pwm_Channel_Brightness = 0; while (Pwm_Channel < Num_Stages + 1) { Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness < 4095) { Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages; if (Pwm_Channel_Brightness > 4095) { Pwm_Channel_Brightness = 4095; } } else if ( Pwm_Channel < Num_Stages + 1) { Pwm_Channel_Brightness = 0; delay(200); Pwm_Channel++; } }}void Down_to_Up_OFF(){ Pwm_Channel = 0; Pwm_Channel_Brightness = 4095; while (Pwm_Channel < Num_Stages + 1) { Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness > 0) { Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages; if (Pwm_Channel_Brightness < 0) { Pwm_Channel_Brightness = 0; } } else if ( Pwm_Channel < Num_Stages + 1) { Pwm_Channel_Brightness = 4095; delay(200); Pwm_Channel++; } }}void loop() { if ((Motion_Trigger_Down_to_Up) and !(On_Delay)) { Seconds24 = 0; On_Delay = true; Down_to_Up_ON(); Motion_Trigger_Down_to_Up = false; } if ((On_Delay) and (Seconds24 > Delay_ON_to_OFF)) { Motion_Trigger_Down_to_Up = false; On_Delay = false; Down_to_Up_OFF(); }} Ich wünsche viel Spaß beim Nachbauen dieses Projektes und bis zum nächsten Teil. https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/eine-elegante-automatische-treppenbeleuchtung-teil1 3.2 Eine elegante automatische Treppenbeleuchtung (Teil2)Willkommen zum zweiten Teil unserer Reihe " elegante Treppenlichtsteuerung". Wie immer in den Projektreihen geht es in den Folgeteilen um eine Verbesserung oder Erweiterungen der Funktion. Im heutigen Teil verbessern wir zunächst die Funktion. Grundsätzlich geht unsere Treppe schon jedes langsam von unten nach oben an, wenn man diese von oben nach unten oder umgekehrt, von unten nach oben betritt. Schöner wäre es jedoch, wenn unsere Treppe sich genau in der Richtung als Lauflicht einschaltet, in der wir die Treppe betreten und danach wieder langsam ausschaltet. Genau um diese Erweiterung soll es im heutigen Teil der Reihe gehen. Das Treppenlicht folgt unseren Schritten, sobald wir die Treppe betreten, unabhängig von der Richtung. Die Parameter und die Schaltung können aus dem ersten Teil der Reihe übernommen werden. Es handelt sich um eine reine Softwareerweiterung.
Num_Stages Definiert die Anzahl der zu beleuchtenden Treppen (maximal 16, von 0 anzählend zu beginnen. Maximalwert: 15) Delay_Stages Fade Zeitraum für jede Treppenstufe -> je kleiner der Wert desto größer der Zeitraum, desto langsamer. Delay_ON_to_OFF Zeitraum der vergeht, indem die Treppe im Status „an“ verbleibt. Nachdem die Werte den eigenen Vorlieben angepasst wurden, kann der erweiterte Code auf den Arduino hochgeladen werden: // 2019 Tobias Kuch GPL 3.0include <Wire.h>#define PWM_Module_Base_Addr 0x40 //10000000b Das letzte Bit des Adressbytes definiert die auszuführende Operation. Bei Einstellung auf logisch 1 0x41 Modul 2//wird ein Lesevorgang auswählt, während eine logische 0 eine Schreiboperation auswählt.#define OE_Pin 8 // Pin für Output Enable#define CPU_LED_Pin 13#define PIRA_Pin 2#define PIRB_Pin 3#define Num_Stages 15#define Delay_Stages 5#define Delay_ON_to_OFF 30 // Minimum Delay_ON_to_OFF in Seconds#define delay_per_Stage_in_ms 200int Pwm_Channel = 0;int Pwm_Channel_Brightness = 0;bool Motion_Trigger_Down_to_Up = false;bool Motion_Trigger_Up_to_Down = false;bool On_Delay = false;// interrupt Controlbyte A60telSeconds24 = 0;byte Seconds24;ISR(TIMER1_COMPA_vect){ A60telSeconds24++; if (A60telSeconds24 > 59) { A60telSeconds24 = 0; Seconds24++; if (Seconds24 > 150) { Seconds24 = 0; } }}void ISR_PIR_A(){ bool PinState = digitalRead(PIRA_Pin); if (PinState) { if (!(Motion_Trigger_Up_to_Down) and !(Motion_Trigger_Down_to_Up)) { digitalWrite(CPU_LED_Pin, HIGH); Motion_Trigger_Down_to_Up = true; } // PIR A ausgelöst } else { digitalWrite(CPU_LED_Pin, LOW); }}void ISR_PIR_B(){ bool PinState = digitalRead(PIRB_Pin); if (PinState) { if (!(Motion_Trigger_Down_to_Up) and !(Motion_Trigger_Up_to_Down)) { digitalWrite(CPU_LED_Pin, HIGH); Motion_Trigger_Up_to_Down = true; } // PIR B ausgelöst } else { digitalWrite(CPU_LED_Pin, LOW); }}void Init_PWM_Module(byte PWM_ModuleAddr){ pinMode(OE_Pin, OUTPUT); pinMode(CPU_LED_Pin, OUTPUT); digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wire.write(0x06); // Software Reset Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit delay(400); Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x01); // Wähle Mode 2 Register (Command Register) Wire.write(0x04); // Konfiguriere Chip: 0x04: totem pole Ausgang 0x00: Open drain Ausgang. Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0x10); // Konfiguriere SleepMode Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0xFE); // Wähle PRE_SCALE register (Command Register) Wire.write(0x03); // Set Prescaler. Die maximale PWM Frequent ist 1526 Hz wenn das PRE_SCALEer Regsiter auf "0x03h" gesetzt wird. Standard : 200 Hz Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0xA1); // Konfiguriere Chip: ERrlaube All Call I2C Adressen, verwende interne Uhr, // Erlaube Auto Increment Feature Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit}void Init_PWM_Outputs(byte PWM_ModuleAddr){ digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). for ( int z = 0; z < 16 + 1; z++) { Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 6); // Wähle PWM_Channel_ON_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 7); // Wähle PWM_Channel_ON_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 8); // Wähle PWM_Channel_OFF_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 9); // Wähle PWM_Channel_OFF_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); } digitalWrite(OE_Pin, LOW); // Active LOW-Ausgangsaktivierungs-Pin (OE).}void setup(){ //Initalisierung Serial.begin(9600); pinMode(PIRA_Pin, INPUT); pinMode(PIRB_Pin, INPUT); Serial.begin(9600); Wire.begin(); // Initalisiere I2C Bus A4 (SDA), A5 (SCL) Init_PWM_Module(PWM_Module_Base_Addr); Init_PWM_Outputs(PWM_Module_Base_Addr); noInterrupts(); attachInterrupt(0, ISR_PIR_A, CHANGE); attachInterrupt(1, ISR_PIR_B, CHANGE); TCCR1A = 0x00; TCCR1B = 0x02; TCNT1 = 0; // Register mit 0 initialisieren OCR1A = 33353; // Output Compare Register vorbelegen TIMSK1 |= (1 << OCIE1A); // Timer Compare Interrupt aktivieren interrupts();}void Down_to_Up_ON(){ Pwm_Channel = 0; Pwm_Channel_Brightness = 0; while (Pwm_Channel < Num_Stages + 1) { Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness < 4095) { Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages; if (Pwm_Channel_Brightness > 4095) { Pwm_Channel_Brightness = 4095; } } else if ( Pwm_Channel < Num_Stages + 1) { Pwm_Channel_Brightness = 0; delay(delay_per_Stage_in_ms); Pwm_Channel++; } }}void Down_to_Up_OFF(){ Pwm_Channel = 0; Pwm_Channel_Brightness = 4095; while (Pwm_Channel < Num_Stages + 1) { Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness > 0) { Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages; if (Pwm_Channel_Brightness < 0) { Pwm_Channel_Brightness = 0; } } else if ( Pwm_Channel < Num_Stages + 1) { Pwm_Channel_Brightness = 4095; delay(delay_per_Stage_in_ms); Pwm_Channel++; } }}void Up_to_DOWN_ON(){ Pwm_Channel = Num_Stages; Pwm_Channel_Brightness = 0; while (Pwm_Channel > -1) { Wire.beginTransmission( PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness < 4095) { Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages; if (Pwm_Channel_Brightness > 4095) { Pwm_Channel_Brightness = 4095; } } else if ( Pwm_Channel >= 0) { Pwm_Channel_Brightness = 0; delay(delay_per_Stage_in_ms); Pwm_Channel--; if ( Pwm_Channel < 0) { Pwm_Channel = 0; break; } } }}void Up_to_DOWN_OFF(){ Pwm_Channel = Num_Stages; Pwm_Channel_Brightness = 4095; while (Pwm_Channel > -1) { Wire.beginTransmission(PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness > 0) { Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages; if (Pwm_Channel_Brightness < 0) { Pwm_Channel_Brightness = 0; } } else if ( Pwm_Channel >= 0) { Pwm_Channel_Brightness = 4095; delay(delay_per_Stage_in_ms); Pwm_Channel--; if ( Pwm_Channel < 0) { Pwm_Channel = 0; break; } } }}void loop(){ if ((Motion_Trigger_Down_to_Up) and !(On_Delay) ) { Seconds24 = 0; On_Delay = true; Down_to_Up_ON(); } if ((On_Delay) and (Seconds24 > Delay_ON_to_OFF) and (Motion_Trigger_Down_to_Up) ) { Down_to_Up_OFF(); Motion_Trigger_Down_to_Up = false; On_Delay = false; Seconds24 = 0; } if ((Motion_Trigger_Up_to_Down) and !(On_Delay) ) { Seconds24 = 0; On_Delay = true; Up_to_DOWN_ON(); } if ((On_Delay) and (Seconds24 > Delay_ON_to_OFF) and (Motion_Trigger_Up_to_Down)) { Up_to_DOWN_OFF(); Motion_Trigger_Up_to_Down = false; On_Delay = false; Seconds24 = 0; }} Ich wünsche viel Spaß beim Nachbauen dieses Projektes und bis zum nächsten Teil. https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/eine-elegante-automatische-treppenbeleuchtung-teil2 Eine elegante automatische Treppenbeleuchtung (Teil3)
Januar 27, 2020 Tobias Kuch
3.3 Eine elegante automatische Treppenbeleuchtung (Teil3)
Hallo und Willkommen zu einer Fortsetzung der Reihe elegante Treppenbeleuchtung. Heute erweitern wie die maximale Treppenstufenanzahl, die unser Controller ansteuern kann von gerade einmal 16 auf Fulminate 992 Treppenstufen! 
Für unser heutiges Projekt benötigen wir:
Anzahl Beschreibung Anmerkung
2 PIR Modul HC-SR501 PIR Bewegungssensor bis 62 PCA9685 16 Kanal 12 Bit PWM Driver Anzahl je nach Treppenzahl /16 1 Nano V3 Microkontroller
1 MB102 Netzteil Adapter für Breadboardaufbau
bis 992 IRF520 MOS Driver Modul 0-24V 5A Anzahl je nach Treppenzahl 1 Netzteil für LED/Lampen für die Stufen Max. 24 Volt Bitte beachtet, dass die Schaltung nicht mit Vollbestückung getestet wurde, sondern nur mit 2 Modulen vom Typ PCA9685. Eine Vollbestückung mit 62 Modulen ist daher hier nur theoretisch beschrieben. In der Praxis sind maximale I2C Buslängen, Störungssicherheit, saubere Signalübertragung, ausreichend dimensionierte Netzteile, Kabel, sichere Verbindungen und mehr zu berücksichtigen. Alle Hinweise dazu aus den vorherigen Teilen gelten insbesondere auch im heutigen Teil. Hier ist der aktualisierte Code für den heutigen Teil: ARDUINO Sketch// Code by Tobias Kuch 2019 mailto:[email protected]// Code under GPL 3.0#include <Wire.h>#define PWM_Module_Base_Addr 0x40 //10000000b Das letzte Bit des Adressbytes definiert die auszuführende Operation. Bei Einstellung auf logisch 1 0x41 Modul 2 etc.. Adressbereich0x40 - 0x47 //wird ein Lesevorgang auswählt, während eine logische 0 eine Schreiboperation auswählt.#define OE_Pin 8 // Pin für Output Enable #define CPU_LED_Pin 13#define PIRA_Pin 2#define PIRB_Pin 3#define Num_Stages_per_Module 16#define Delay_Stages 5#define Delay_ON_to_OFF 2 // Minimum Delay_ON_to_OFF in Secondsint Overall_Stages = 16; // maximale Stufenanzahl: 62 x 16 = 992int delay_per_Stage_in_ms = 200;int Pwm_Channel = 0;int Pwm_Channel_Brightness = 0;bool Motion_Trigger_Down_to_Up = false;bool Motion_Trigger_Up_to_Down = false;bool On_Delay = false;byte PWMModules = 0;byte StagesLeft = 0;// interrupt Controlbyte A60telSeconds24 = 0;byte Seconds24;ISR(TIMER1_COMPA_vect){ A60telSeconds24++; if (A60telSeconds24 > 59) { A60telSeconds24 = 0; Seconds24++; if (Seconds24 > 150) { Seconds24 = 0; } }}void ISR_PIR_A(){ bool PinState = digitalRead(PIRA_Pin); if (PinState) { if (!(Motion_Trigger_Up_to_Down) and !(Motion_Trigger_Down_to_Up)) { digitalWrite(CPU_LED_Pin, HIGH); Motion_Trigger_Down_to_Up = true; } // PIR A ausgelöst } else { digitalWrite(CPU_LED_Pin, LOW); }}void ISR_PIR_B(){ bool PinState = digitalRead(PIRB_Pin); if (PinState) { if (!(Motion_Trigger_Down_to_Up) and !(Motion_Trigger_Up_to_Down)) { digitalWrite(CPU_LED_Pin, HIGH); Motion_Trigger_Up_to_Down = true; } // PIR B ausgelöst } else { digitalWrite(CPU_LED_Pin, LOW); }}void Init_PWM_Module(byte PWM_ModuleAddr){ pinMode(OE_Pin, OUTPUT); pinMode(CPU_LED_Pin, OUTPUT); digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wire.write(0x06); // Software Reset Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit delay(400); Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x01); // Wähle Mode 2 Register (Command Register) Wire.write(0x04); // Konfiguriere Chip: 0x04: totem pole Ausgang 0x00: Open drain Ausgang. Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0x10); // Konfiguriere SleepMode Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0xFE); // Wähle PRE_SCALE register (Command Register) Wire.write(0x03); // Set Prescaler. Die maximale PWM Frequent ist 1526 Hz wenn das PRE_SCALEer Regsiter auf "0x03h" gesetzt wird. Standard : 200 Hz Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0xA1); // Konfiguriere Chip: ERrlaube All Call I2C Adressen, verwende interne Uhr, // Erlaube Auto Increment Feature Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit}void Init_PWM_Outputs(byte PWM_ModuleAddr){ digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). for ( int z = 0; z < 16 + 1; z++) { Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 6); // Wähle PWM_Channel_ON_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 7); // Wähle PWM_Channel_ON_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 8); // Wähle PWM_Channel_OFF_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 9); // Wähle PWM_Channel_OFF_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); } digitalWrite(OE_Pin, LOW); // Active LOW-Ausgangsaktivierungs-Pin (OE).}void setup(){ //Initalisierung Serial.begin(115200); pinMode(PIRA_Pin, INPUT); pinMode(PIRB_Pin, INPUT); Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for native USB } PWMModules = Overall_Stages / 16; StagesLeft = Overall_Stages % 16; if (StagesLeft >= 1) { PWMModules++; } Wire.begin(); // Initalisiere I2C Bus A4 (SDA), A5 (SCL) for (byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++) { Init_PWM_Module(PWM_Module_Base_Addr + ModuleCount); Init_PWM_Outputs(PWM_Module_Base_Addr + ModuleCount); } noInterrupts(); attachInterrupt(0, ISR_PIR_A, CHANGE); attachInterrupt(1, ISR_PIR_B, CHANGE); TCCR1A = 0x00; TCCR1B = 0x02; TCNT1 = 0; // Register mit 0 initialisieren OCR1A = 33353; // Output Compare Register vorbelegen TIMSK1 |= (1 << OCIE1A); // Timer Compare Interrupt aktivieren interrupts();}void Down_to_Up_ON(){ Serial.println("Down_to_Up_ON"); byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; for (byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++) { Pwm_Channel = 0; Pwm_Channel_Brightness = 4095; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } Pwm_Channel = 0; Pwm_Channel_Brightness = 0; while (Pwm_Channel < Calc_Num_Stages_per_Module + 1) { Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness < 4095) { Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages; if (Pwm_Channel_Brightness > 4095) { Pwm_Channel_Brightness = 4095; } } else if ( Pwm_Channel < Num_Stages_per_Module + 1) { Pwm_Channel_Brightness = 0; delay(delay_per_Stage_in_ms); Pwm_Channel++; } } }}void Up_to_DOWN_ON(){ Serial.println("Up_to_DOWN_ON "); byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; int ModuleCount = PWMModules - 1; while (ModuleCount >= 0) { Pwm_Channel_Brightness = 0; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } Pwm_Channel = Calc_Num_Stages_per_Module; while (Pwm_Channel > -1) { Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness < 4095) { Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages; if (Pwm_Channel_Brightness > 4095) { Pwm_Channel_Brightness = 4095; } } else if ( Pwm_Channel >= 0) { Pwm_Channel_Brightness = 0; delay(delay_per_Stage_in_ms); Pwm_Channel--; if ( Pwm_Channel < 0) { Pwm_Channel = 0; break; } } } ModuleCount = ModuleCount - 1; }}void Down_to_Up_OFF(){ Serial.println("Down_to_Up_OFF"); byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; for (byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++) { Pwm_Channel = 0; Pwm_Channel_Brightness = 4095; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } while (Pwm_Channel < Calc_Num_Stages_per_Module + 1) { Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness > 0) { Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages; if (Pwm_Channel_Brightness < 0) { Pwm_Channel_Brightness = 0; } } else if ( Pwm_Channel < Num_Stages_per_Module + 1) { Pwm_Channel_Brightness = 4095; delay(delay_per_Stage_in_ms); Pwm_Channel++; } } }}void Up_to_DOWN_OFF(){ Serial.println("Up_to_DOWN_OFF"); byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; int ModuleCount = PWMModules - 1; while (ModuleCount >= 0) { Pwm_Channel_Brightness = 4095; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } Pwm_Channel = Calc_Num_Stages_per_Module; while (Pwm_Channel > -1) { Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness > 0) { Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages; if (Pwm_Channel_Brightness < 0) { Pwm_Channel_Brightness = 0; } } else if ( Pwm_Channel >= 0) { Pwm_Channel_Brightness = 4095; delay(delay_per_Stage_in_ms); Pwm_Channel--; if ( Pwm_Channel < 0) { Pwm_Channel = 0; break; } } } ModuleCount = ModuleCount - 1; }}void loop(){ if ((Motion_Trigger_Down_to_Up) and !(On_Delay) ) { Seconds24 = 0; On_Delay = true; Down_to_Up_ON(); } if ((On_Delay) and (Seconds24 > Delay_ON_to_OFF) and (Motion_Trigger_Down_to_Up) ) { Down_to_Up_OFF(); Motion_Trigger_Down_to_Up = false; On_Delay = false; Seconds24 = 0; } if ((Motion_Trigger_Up_to_Down) and !(On_Delay) ) { Seconds24 = 0; On_Delay = true; Up_to_DOWN_ON(); } if ((On_Delay) and (Seconds24 > Delay_ON_to_OFF) and (Motion_Trigger_Up_to_Down)) { Up_to_DOWN_OFF(); Motion_Trigger_Up_to_Down = false; On_Delay = false; Seconds24 = 0; }}
Ich wünsche viel Spaß beim Nachbau und bis zum nächsten Teil der Reihe.
Wie immer findet Ihr auch alle vorherigen Projekte unter der GitHub Seite
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/eine-elegante-automatische-treppenbeleuchtung-teil3
Februar 3, 2020 Tobias Kuch
3.4 Eine elegante automatische Treppenbeleuchtung (Teil4)Hallo und Willkommen zu dem vorletzten Teil der Reihe „elegante automatische Treppenbeleuchtung“.
Heute erweitern wir unsere Steuerung um einen lichtempfindlichen Widerstand, der als Helligkeitssensor fungieren soll. Ab einem im Code mit dem Parameter „DayLight_Brightness_Border“ einstellbaren Helligkeitswert, wobei eine höhere Zahl eine höhere Helligkeit symbolisiert, wird die Treppenautomatik ab diesem Wert deaktiviert, sodass nur, wenn es dunkel ist, die Treppe beleuchtet wird. Durch die Verwendung eines LDRs anstatt eines I2C Sensors, wird das ganze etwas unempfindlicher gegen externe Störungen. Als weitere kleine in Verbesserung kann in dieser Version, die Fadingzeit zwischen zwei Stufen beim Ein und ausschalten durch die Parameter „Delay_Stages_ON“ und „Delay_Stages_OFF“ nun getrennt voneinander eingestellt werden. Respektable Ergebnisse lassen sich zum Beispiel dadurch erzielen, indem der Parameter für Ausschalten der einzelnen Treppenstufen größer gewählt wird als der für das einschalten.
Anzahl 1 bis 4 (2 Dargestellt) 
Für unseren heutigen Teil des Projektes benötigen wir: 2 PIR Modul HC-SR501 PIR Bewegungssensor bis 62 PCA9685 16 Kanal 12 Bit PWM Driver Anzahl je nach Treppenzahl /16 1 Nano V3 1 MB102 Netzteil Adapter Für Breadboardaufbau bis 992 IRF520 MOS Driver Modul 0-24V 5A Anzahl je nach Treppenzahl 1 Netzteil für LED/Lampen für die Stufen Maximal 24 Volt 1 10k Ohm Widerstand 1 LDR 03 Fotowiederstand Alle Hinweise aus den vorherigen Teilen gelten auch im heutigen Teil. Nach eigenen Anpassungen und des Hinzufügens der LDR‘s kann der Code hochgeladen werden:
Treppenbeleuchtungs-Sketch
wer den Code so übernimmt:
#include <Wire.h>#define PWM_Module_Base_Addr 0x40 // 10000000b Das letzte Bit des Adressbytes definiert die auszuführende Operation. Bei Einstellung auf logisch 1 0x41 Modul 2 etc.. Adressbereich0x40 - 0x47 // wird ein Lesevorgang auswählt, während eine logische 0 eine Schreiboperation auswählt.#define OE_Pin 8 // Pin für Output Enable #define CPU_LED_Pin 13 // Interne Board LED an Pin 13 (zu Debuggingzwecken)#define PIRA_Pin 2#define PIRB_Pin 3#define Num_Stages_per_Module 16#define LDR_Pin A2 // Analog Pin, über den die Helligkeit gemessen werden soll. (LDR Wiederstand)#define DEBUG#define L_Sens_Scope 50// Anpassbare Betriebsparameter (Konstanten)int Delay_ON_to_OFF = 10; // Minimum Wartezeit bis zur "Aus Sequenz" in Sekundenint Overall_Stages = 8; // maximale Stufenanzahl: 62 x 16 = 992int delay_per_Stage_in_ms = 100;int DayLight_Brightness_Border = 600; // Helligkeitsgrenze Automatik - Höherer Wert - Höhere Helligkeitbyte Delay_Stages_ON = 20;byte Delay_Stages_OFF = 20;// Globale Variablenint Pwm_Channel = 0;int Pwm_Channel_Brightness = 0;bool Motion_Trigger_Down_to_Up = false;bool Motion_Trigger_Up_to_Down = false;bool On_Delay = false;bool DayLight_Status = true;bool DLightCntrl = true;byte PWMModules = 0;byte StagesLeft = 0;// interrupt Controlvolatile byte A60telSeconds24 = 0;volatile byte Seconds24;ISR(TIMER1_COMPA_vect){ A60telSeconds24++; if (A60telSeconds24 > 59) { A60telSeconds24 = 0; Seconds24++; if (Seconds24 > 150) { Seconds24 = 0; } }}void ISR_PIR_A(){ bool PinState = digitalRead(PIRA_Pin); if (PinState) { if (!(Motion_Trigger_Up_to_Down) and !(Motion_Trigger_Down_to_Up)) { digitalWrite(CPU_LED_Pin, HIGH); Motion_Trigger_Down_to_Up = true; } // PIR A ausgelöst } else { digitalWrite(CPU_LED_Pin, LOW); }}void ISR_PIR_B(){ bool PinState = digitalRead(PIRB_Pin); if (PinState) { if (!(Motion_Trigger_Down_to_Up) and !(Motion_Trigger_Up_to_Down)) { digitalWrite(CPU_LED_Pin, HIGH); Motion_Trigger_Up_to_Down = true; } // PIR B ausgelöst } else { digitalWrite(CPU_LED_Pin, LOW); }}void Init_PWM_Module(byte PWM_ModuleAddr){ digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wire.write(0x06); // Software Reset Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit delay(400); Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x01); // Wähle Mode 2 Register (Command Register) Wire.write(0x04); // Konfiguriere Chip: 0x04: totem pole Ausgang 0x00: Open drain Ausgang. Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0x10); // Konfiguriere SleepMode Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0xFE); // Wähle PRE_SCALE register (Command Register) Wire.write(0x03); // Set Prescaler. Die maximale PWM Frequent ist 1526 Hz wenn das PRE_SCALEer Regsiter auf "0x03h" gesetzt wird. Standard : 200 Hz Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit Wire.beginTransmission(PWM_ModuleAddr); // Datentransfer initiieren Wire.write(0x00); // Wähle Mode 1 Register (Command Register) Wire.write(0xA1); // Konfiguriere Chip: ERrlaube All Call I2C Adressen, verwende interne Uhr, // Erlaube Auto Increment Feature Wire.endTransmission(); // Stoppe Kommunikation - Sende Stop Bit}void Init_PWM_Outputs(byte PWM_ModuleAddr){ digitalWrite(OE_Pin, HIGH); // Active LOW-Ausgangsaktivierungs-Pin (OE). for ( int z = 0; z < 16 + 1; z++) { Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 6); // Wähle PWM_Channel_ON_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 7); // Wähle PWM_Channel_ON_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 8); // Wähle PWM_Channel_OFF_L register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_ModuleAddr); Wire.write(z * 4 + 9); // Wähle PWM_Channel_OFF_H register Wire.write(0x00); // Wert für o.g. Register Wire.endTransmission(); } digitalWrite(OE_Pin, LOW); // Active LOW-Ausgangsaktivierungs-Pin (OE).}void setup(){ //Initalisierung Serial.begin(9600); pinMode(PIRA_Pin, INPUT); pinMode(PIRB_Pin, INPUT); pinMode(OE_Pin, OUTPUT); pinMode(CPU_LED_Pin, OUTPUT); pinMode(LDR_Pin, INPUT); PWMModules = Overall_Stages / 16; StagesLeft = (Overall_Stages % 16) - 1; if (StagesLeft >= 1) { PWMModules++; } Wire.begin(); // Initalisiere I2C Bus A4 (SDA), A5 (SCL) for (byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++) { Init_PWM_Module(PWM_Module_Base_Addr + ModuleCount); Init_PWM_Outputs(PWM_Module_Base_Addr + ModuleCount); } noInterrupts(); attachInterrupt(0, ISR_PIR_A, CHANGE); attachInterrupt(1, ISR_PIR_B, CHANGE); TCCR1A = 0x00; TCCR1B = 0x02; TCNT1 = 0; // Register mit 0 initialisieren OCR1A = 33353; // Output Compare Register vorbelegen TIMSK1 |= (1 << OCIE1A); // Timer Compare Interrupt aktivieren interrupts(); Serial.println(F("Init_Complete"));}bool DayLightStatus (){ int SensorValue = 0; bool ReturnValue = true; SensorValue = analogRead(LDR_Pin);#ifdef DEBUG Serial.print(F("DayLightStatus: ")); Serial.print(SensorValue);#endif if (SensorValue > DayLight_Brightness_Border) { if ((DayLight_Status) and (SensorValue > DayLight_Brightness_Border + L_Sens_Scope)) { ReturnValue = false; DayLight_Status = false; } else if (!(DayLight_Status)) { ReturnValue = false; DayLight_Status = false; }#ifdef DEBUG Serial.println(F(" OFF"));#endif } else { if ((DayLight_Status) and (SensorValue > DayLight_Brightness_Border - L_Sens_Scope)) { ReturnValue = true; DayLight_Status = true; } else if (!(DayLight_Status)) { ReturnValue = true; DayLight_Status = true; }#ifdef DEBUG Serial.println(F(" ON"));#endif } return ReturnValue;}void Down_to_Up_ON(){#ifdef DEBUG Serial.println(F("Down_to_Up_ON"));#endif byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; for (byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++) { Pwm_Channel = 0; Pwm_Channel_Brightness = 4095; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } Pwm_Channel = 0; Pwm_Channel_Brightness = 0; while (Pwm_Channel < Calc_Num_Stages_per_Module + 1) { Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness < 4095) { Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages_ON; if (Pwm_Channel_Brightness > 4095) { Pwm_Channel_Brightness = 4095; } } else if ( Pwm_Channel < Num_Stages_per_Module + 1) { Pwm_Channel_Brightness = 0; delay(delay_per_Stage_in_ms); Pwm_Channel++; } } }}void Up_to_DOWN_ON(){#ifdef DEBUG Serial.println(F("Up_to_DOWN_ON "));#endif byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; int ModuleCount = PWMModules - 1; while (ModuleCount >= 0) { Pwm_Channel_Brightness = 0; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } Pwm_Channel = Calc_Num_Stages_per_Module; while (Pwm_Channel > -1) { Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness < 4095) { Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages_ON; if (Pwm_Channel_Brightness > 4095) { Pwm_Channel_Brightness = 4095; } } else if ( Pwm_Channel >= 0) { Pwm_Channel_Brightness = 0; delay(delay_per_Stage_in_ms); Pwm_Channel--; if ( Pwm_Channel < 0) { Pwm_Channel = 0; break; } } } ModuleCount = ModuleCount - 1; }}void Down_to_Up_OFF(){#ifdef DEBUG Serial.println(F("Down_to_Up_OFF"));#endif byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; for (byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++) { Pwm_Channel = 0; Pwm_Channel_Brightness = 4095; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } while (Pwm_Channel < Calc_Num_Stages_per_Module + 1) { Wire.beginTransmission( PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness > 0) { Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages_OFF; if (Pwm_Channel_Brightness < 0) { Pwm_Channel_Brightness = 0; } } else if ( Pwm_Channel < Num_Stages_per_Module + 1) { Pwm_Channel_Brightness = 4095; delay(delay_per_Stage_in_ms); Pwm_Channel++; } } }}void Up_to_DOWN_OFF(){#ifdef DEBUG Serial.println(F("Up_to_DOWN_OFF"));#endif byte Calc_Num_Stages_per_Module = Num_Stages_per_Module; int ModuleCount = PWMModules - 1; while (ModuleCount >= 0) { Pwm_Channel_Brightness = 4095; if ((StagesLeft >= 1) and (ModuleCount == PWMModules - 1)) { Calc_Num_Stages_per_Module = StagesLeft; } else { Calc_Num_Stages_per_Module = Num_Stages_per_Module; } Pwm_Channel = Calc_Num_Stages_per_Module; while (Pwm_Channel > -1) { Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 8); // Wähle PWM_Channel_0_OFF_L register Wire.write((byte)Pwm_Channel_Brightness & 0xFF); // Wert für o.g. Register Wire.endTransmission(); Wire.beginTransmission(PWM_Module_Base_Addr + ModuleCount); Wire.write(Pwm_Channel * 4 + 9); // Wähle PWM_Channel_0_OFF_H register Wire.write((Pwm_Channel_Brightness >> 8)); // Wert für o.g. Register Wire.endTransmission(); if (Pwm_Channel_Brightness > 0) { Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages_OFF; if (Pwm_Channel_Brightness < 0) { Pwm_Channel_Brightness = 0; } } else if ( Pwm_Channel >= 0) { Pwm_Channel_Brightness = 4095; delay(delay_per_Stage_in_ms); Pwm_Channel--; if ( Pwm_Channel < 0) { Pwm_Channel = 0; break; } } } ModuleCount = ModuleCount - 1; }}void Stages_Light_Control (){ if ((Motion_Trigger_Down_to_Up) and !(On_Delay)) { DLightCntrl = DayLightStatus(); if (DLightCntrl) { Seconds24 = 0; On_Delay = true; Down_to_Up_ON(); } else { Motion_Trigger_Down_to_Up = false; } } if ((On_Delay) and (Seconds24 > Delay_ON_to_OFF) and (Motion_Trigger_Down_to_Up) ) { Down_to_Up_OFF(); Motion_Trigger_Down_to_Up = false; On_Delay = false; Seconds24 = 0; } if ((Motion_Trigger_Up_to_Down) and !(On_Delay)) { DLightCntrl = DayLightStatus(); if (DLightCntrl) { Seconds24 = 0; On_Delay = true; Up_to_DOWN_ON(); } else { Motion_Trigger_Up_to_Down = false; } } if ((On_Delay) and (Seconds24 > Delay_ON_to_OFF) and (Motion_Trigger_Up_to_Down)) { Up_to_DOWN_OFF(); Motion_Trigger_Up_to_Down = false; On_Delay = false; Seconds24 = 0; }}void loop(){ Stages_Light_Control ();}
Zur Fehlerdiagnose steht eine serielle Schnittstelle mit 9600 Baud zur Verfügung an der einige Informationen zum aktuellen Status ausgegeben werden:
Ich wünsche viel Spaß beim Nachbau und bis zum letzten Teil der Reihe.
Wie immer findet Ihr auch alle vorherigen Projekte unter der GitHub Seite
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/eine-elegante-automatische-treppenbeleuchtung-teil4?
In unserem eBook für den ESP8266-01 mit Relais haben wir euch erklärt, wie ihr mit den AT befehlen und einem Serial Terminal Programm das Relais schalten könnt. Heute möchten wir euch hier zeigen, wie das mit einer Website funktioniert. Am Ende haben wir 2 Buttons mit Ein und Aus. Legen wir los: Wir benötigen für dieses Projekt ein ESP8266-01 mit Relais und einen entsprechenden Programmieradapter. Damit das Relais schalten wird, müssen wir 2 Befehle an das Relais (bzw. an den Steuer-IC des Relais) senden. A00100A1 AUS byte open[] = {0xA0, 0x01, 0x00, 0xA1}; Serial.write(open, sizeof(open));
A00101A2 EIN byte close[] = {0xA0, 0x01, 0x01, 0xA2}; Serial.write(close, sizeof(close)); Das bauen wir nun in ein Arduino-Sketch:
#include <ESP8266WiFi.h>const char* ssid = "SSID";const char* password = "PASSWORT";WiFiServer server(80);void setup(){ Serial.begin(9600); Serial.println("Starten"); delay(10); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); } server.begin(); Serial.println("IP: "); Serial.println(WiFi.localIP());}int value = 0;void loop(){ WiFiClient client = server.available(); if (client) { String currentLine = ""; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); if (c == '\n') { if (currentLine.length() == 0) { client.println("HTTP/1.1 200 OK"); client.println("Content-type:text/html"); client.println(); client.print("Relais <a href=\"/H\">Einschalten</a><br>"); client.print("Relais <a href=\"/L\">Ausschalten</a><br>"); client.println(); break; } else { currentLine = ""; } } else if (c != '\r') { currentLine += c; } if (currentLine.endsWith("GET /H")) { Serial.println("EIN"); delay(10); byte close[] = {0xA0, 0x01, 0x01, 0xA2}; Serial.write(close, sizeof(close)); } if (currentLine.endsWith("GET /L")) { Serial.println("AUS"); delay(10); byte open[] = {0xA0, 0x01, 0x00, 0xA1}; Serial.write(open, sizeof(open)); } } } client.stop(); }} Wenn wir diesen Sketch nun mit richtigen WLAN-Informationen abändern und auf den ESP übertragen, kann die Website gestartet werden und das Relais geschalten werden.
Viel Spass beim Nachbauen und entwickeln eigener Projekte. https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/esp8266-01-relais-mit-website-steuern? ESP8266-01 Relais mit Website steuernIn unserem eBook für den ESP8266-01 mit Relais haben wir euch erklärt, wie ihr mit den AT befehlen und einem Serial Terminal Programm das Relais schalten könnt. Heute möchten wir euch hier zeigen, wie das mit einer Website funktioniert. Am Ende haben wir 2 Buttons mit Ein und Aus. Legen wir los: Wir benötigen für dieses Projekt ein ESP8266-01 mit Relais und einen entsprechenden Programmieradapter. Damit das Relais schalten wird, müssen wir 2 Befehle an das Relais (bzw. an den Steuer-IC des Relais) senden. A00100A1 AUS byte open[] = {0xA0, 0x01, 0x00, 0xA1}; Serial.write(open, sizeof(open));
A00101A2 EIN byte close[] = {0xA0, 0x01, 0x01, 0xA2}; Serial.write(close, sizeof(close)); Das bauen wir nun in ein Arduino-Sketch:
#include <ESP8266WiFi.h>const char* ssid = "SSID";const char* password = "PASSWORT";WiFiServer server(80);void setup(){ Serial.begin(9600); Serial.println("Starten"); delay(10); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); } server.begin(); Serial.println("IP: "); Serial.println(WiFi.localIP());}int value = 0;void loop(){ WiFiClient client = server.available(); if (client) { String currentLine = ""; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); if (c == '\n') { if (currentLine.length() == 0) { client.println("HTTP/1.1 200 OK"); client.println("Content-type:text/html"); client.println(); client.print("Relais <a href=\"/H\">Einschalten</a><br>"); client.print("Relais <a href=\"/L\">Ausschalten</a><br>"); client.println(); break; } else { currentLine = ""; } } else if (c != '\r') { currentLine += c; } if (currentLine.endsWith("GET /H")) { Serial.println("EIN"); delay(10); byte close[] = {0xA0, 0x01, 0x01, 0xA2}; Serial.write(close, sizeof(close)); } if (currentLine.endsWith("GET /L")) { Serial.println("AUS"); delay(10); byte open[] = {0xA0, 0x01, 0x00, 0xA1}; Serial.write(open, sizeof(open)); } } } client.stop(); }} Wenn wir diesen Sketch nun mit richtigen WLAN-Informationen abändern und auf den ESP übertragen, kann die Website gestartet werden und das Relais geschalten werden.
Viel Spass beim Nachbauen und entwickeln eigener Projekte.
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/esp8266-01-relais-mit-website-steuern?page=2
ESP8266-01 Relais mit Website steuernIn unserem eBook für den ESP8266-01 mit Relais haben wir euch erklärt, wie ihr mit den AT befehlen und einem Serial Terminal Programm das Relais schalten könnt. Heute möchten wir euch hier zeigen, wie das mit einer Website funktioniert. Am Ende haben wir 2 Buttons mit Ein und Aus. Legen wir los: Wir benötigen für dieses Projekt ein ESP8266-01 mit Relais und einen entsprechenden Programmieradapter. Damit das Relais schalten wird, müssen wir 2 Befehle an das Relais (bzw. an den Steuer-IC des Relais) senden. A00100A1 AUS byte open[] = {0xA0, 0x01, 0x00, 0xA1}; Serial.write(open, sizeof(open));
A00101A2 EIN byte close[] = {0xA0, 0x01, 0x01, 0xA2}; Serial.write(close, sizeof(close)); Das bauen wir nun in ein Arduino-Sketch:
#include <ESP8266WiFi.h>const char* ssid = "SSID";const char* password = "PASSWORT";WiFiServer server(80);void setup(){ Serial.begin(9600); Serial.println("Starten"); delay(10); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); } server.begin(); Serial.println("IP: "); Serial.println(WiFi.localIP());}int value = 0;void loop(){ WiFiClient client = server.available(); if (client) { String currentLine = ""; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); if (c == '\n') { if (currentLine.length() == 0) { client.println("HTTP/1.1 200 OK"); client.println("Content-type:text/html"); client.println(); client.print("Relais <a href=\"/H\">Einschalten</a><br>"); client.print("Relais <a href=\"/L\">Ausschalten</a><br>"); client.println(); break; } else { currentLine = ""; } } else if (c != '\r') { currentLine += c; } if (currentLine.endsWith("GET /H")) { Serial.println("EIN"); delay(10); byte close[] = {0xA0, 0x01, 0x01, 0xA2}; Serial.write(close, sizeof(close)); } if (currentLine.endsWith("GET /L")) { Serial.println("AUS"); delay(10); byte open[] = {0xA0, 0x01, 0x00, 0xA1}; Serial.write(open, sizeof(open)); } } } client.stop(); }} Wenn wir diesen Sketch nun mit richtigen WLAN-Informationen abändern und auf den ESP übertragen, kann die Website gestartet werden und das Relais geschalten werden.
Viel Spass beim Nachbauen und entwickeln eigener Projekte.
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/esp8266-01-relais-mit-website-steuern?page=3
********************************************************I*
5) 200 kostenlose e-Books früher je € 0,99
Az-Delivery Quick-Start-Guide
Az-Delivery alle fehlenden e-Books downloaden
https://www.az-delivery.de/collections/kostenlose-e-books
mailto:[email protected]
* in Arbeit - noch nicht vorhanden
303_b_Az-Delivery-x_Quick-Start-Guide - Inhaltsverzeichnis - ARDUINO UNO_4c.xls
Az-Delivery Vertriebs GmbH Bräugasse 9 D-94469 Deggendorf mailto:[email protected] https://www.az-delivery.com  AZDelivery 3 x MQ-2 Gas Sensor Rauch Sensor Luftqualität Modul... Preis: EUR 8,99  AZDelivery Farbsensor TCS230 TCS3200 Farben Sensor Modul für... Preis: EUR 5,99  AZDelivery 3 x GY-BME280 Barometrischer Sensor für Temperatur,... Preis: EUR 14,99  AZDelivery 3 x ADS1115 ADC Modul 16bit 4 Kanäle für Arduino... Preis: EUR 11,99  AZDelivery GY-68 BMP180 Barometrischer Luftdruck und... Preis: EUR 3,99  AZDelivery 3 x HC-SR501 PIR Bewegungssensor Bewegungsmelde... Preis: EUR 5,99  AZDelivery 128 x 64 Pixel 0,96 Zoll OLED I2C Display für... Statt EUR 6,49 Preis: EUR 5,99  AZDelivery 3 x MQ-135 Gas Sensor Luftqualität Modul für... Preis: EUR 7,99  AZDelivery NEO-6M GPS Modul baugleich zu Ublox mit GRATIS EBOOK! Preis: EUR 9,99  AZDelivery Real Time Clock RTC DS3231 I2C Echtzeituhr für... Preis: EUR 6,29  AZDelivery 3 x Bodenfeuchtesensor Hygrometer Boden... Preis: EUR 5,99  AZDelivery MAX6675 Temperatur Sensor mit Sonde K-Typ und... Preis: EUR 6,49  AZDelivery ADS1115 ADC Modul 16bit 4 Kanäle für Arduino und... Preis: EUR 5,49  Aihasd GY-906 MLX90614ESF MLX90614 Berührungslose Temperatur... Preis: EUR 8,99  AZDelivery 3 x GY-521 MPU-6050 3-Achsen-Gyroskop und... Preis: EUR 6,99 DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]ENDE |
