Een elegante automatische trapverlichting (deel 3)

Hallo en welkom bij een vervolg op de elegante trapverlichtingsserie. Vandaag breiden we het maximale aantal stappen dat onze controller kan regelen uit van slechts 16 tot 992 Fulminate!
Eigenaren van lange trappen moeten dus in staat zijn om de bediening eenvoudig aan te passen aan hun behoeften en wensen.

Deze aanpassing wordt eenvoudig en gemakkelijk uitgevoerd door de programmavariabele "Overall_Stages" aan te passen aan het gewenste aantal trappen van 1 tot 992.

Welnu, de een of de ander vraagt ​​zich misschien af ​​hoe ik dit grote aantal PWM-uitgangen kan bereiken met slechts 20 beschikbare uitgangen van een AZ-Delivery Nano V3. Het geheim zit in de 6 adresbits van de PCA9685. Elke PCA9685 kan 16 PWM-kanalen bieden. De daisy chain-indeling van het bord voorkomt chaos in de kabel en maakt een comfortabele aansluiting van maximaal 62 controllers mogelijk.

Vanwege de binaire adressering van de kaarten kan een van de in totaal 62 adressen in het bereik van 40h tot 7Eh aan één module worden toegewezen. Met 16 uitgangen per module levert dit vervolgens de maximaal mogelijke 992 uitgangen op.

De code is door mij geschreven zodat de adressering van de modules door de gebruiker wordt geabstraheerd en automatisch wordt berekend. Het enige dat nodig is, is het totale aantal trappen in een variabele specificeren en een geschikt aantal modules als een daisy chain aan de I2C-bus toevoegen. De modules moeten in oplopende volgorde worden geadresseerd.

De volgende afbeelding laat zien hoe de modules moeten worden aangesloten en geadresseerd:

Structuur als een daisy chain

 

 

Voor het project van vandaag hebben we nodig:

Nummer

Beschrijving

Opmerking

2

PIR Module HC-SR501 PIR

Bewegingssensor

tot 62

PCA9685 16-kanaals 12 bit PWM-stuurprogramma

Aantal afhankelijk van het aantal trappen / 16

1

Nano V3

 

1

MB102 voedingsadapter

Voor broodplankconstructie

tot 992

IRF520 MOS-stuurprogrammamodule 0-24V 5A

Aantal afhankelijk van het aantal trappen

1

Voeding voor LED / lampen voor de treden

24 volt maximaal

 

Let op: het circuit is niet getest met volledige apparatuur, maar alleen met 2 modules van het type PCA9685. Een volledige assemblage met 62 modules is daarom alleen hier in theorie beschreven. In de praktijk moet rekening worden gehouden met maximale I2C-buslengten, interferentie-immuniteit, schone signaaloverdracht, voldoende gedimensioneerde voedingen, kabels, veilige verbindingen en meer. Alle informatie uit de vorige delen is met name van toepassing op het deel van vandaag.

Hier is de bijgewerkte code voor het onderdeel van vandaag:

 

// Code door Tobias Kuch 2019 mailto: tobias.kuch@googlemail.com
// Code onder GPL 3.0

# opnemen <Draad.h>

#define PWM_Module_Base_Addr 0x40 // 10000000b Het laatste bit van de adresbyte definieert de uit te voeren bewerking. Indien ingesteld op logische 1 0x41 module 2 enz. Adresbereik 0x40 - 0x47 
// een leesbewerking is geselecteerd, terwijl een logische 0 een schrijfbewerking selecteert.
#define OE_Pin  8           // Pin voor uitvoer inschakelen 
#define CPU_LED_Pin 13
#define PIRA_Pin 2
#define PIRB_Pin 3
#define Num_Stages_per_Module 16
#define Vertraging_Stages  5
#define Delay_ON_to_OFF  2  // Minimale vertraging_ON_to_OFF in seconden


int Overall_Stages =  16; // maximaal aantal stappen: 62 x 16 = 992
int delay_per_Stage_in_ms = 200;



int Pwm_Channel = 0;
int Pwm_Channel_Brightness = 0;
dwaas Motion_Trigger_Down_to_Up = fout;
dwaas Motion_Trigger_Up_to_Down = fout;
dwaas On_Delay = fout;
byte PWM-modules = 0;
byte Stadia Links = 0;
// controle onderbreken
byte A60telSeconds24 = 0;
byte Seconden24;

ISR(TIMER1_COMPA_vect)
{   A60telSeconds24++;   als (A60telSeconds24 > 59)   {     A60telSeconds24 = 0;     Seconden24++;     als (Seconden24 > 150)     {       Seconden24 = 0;     }   }
}

nietig ISR_PIR_A()
{   dwaas PinState = digitaal lezen(PIRA_Pin);   als (PinState)   {     als (!(Motion_Trigger_Up_to_Down) en !(Motion_Trigger_Down_to_Up))     {       digitalWrite(CPU_LED_Pin, HOOG);       Motion_Trigger_Down_to_Up = waar;     } // PIR A ausgelöst   } anders   {     digitalWrite(CPU_LED_Pin, LAAG);   }
}

nietig ISR_PIR_B()
{   dwaas PinState = digitaal lezen(PIRB_Pin);   als (PinState)   {     als (!(Motion_Trigger_Down_to_Up) en !(Motion_Trigger_Up_to_Down))     {       digitalWrite(CPU_LED_Pin, HOOG);       Motion_Trigger_Up_to_Down = waar;     } // PIR B ausgelöst   } anders   {     digitalWrite(CPU_LED_Pin, LAAG);   }
}

nietig Init_PWM_Module(byte PWM_ModuleAddr)
{   pinMode(OE_Pin, UITGANG);   pinMode(CPU_LED_Pin, UITGANG);   digitalWrite(OE_Pin, HOOG); // Actieve LOW-Ausgangsaktivierungs-Pin (OE).   Draad.beginVerzending(PWM_ModuleAddr); // Datentransfer initieren   Draad.schrijven(0x00);                       //   Draad.schrijven(0x06);                       // Software opnieuw instellen   Draad.endTransmission();                 // Stoppe Kommunikation - Sende stopbit   vertraging(400);   Draad.beginVerzending(PWM_ModuleAddr); // Datentransfer initieren   Draad.schrijven(0x01);                       // Wähle Mode 2 Register (Command Register)   Draad.schrijven(0x04);                       // Konfiguriere Chip: 0x04: totempaal Ausgang 0x00: open afvoer Ausgang.   Draad.endTransmission();                 // Stoppe Kommunikation - Sende stopbit   Draad.beginVerzending(PWM_ModuleAddr); // Datentransfer initieren   Draad.schrijven(0x00);                      // Wähle Mode 1 Register (Command Register)   Draad.schrijven(0x10);                      // Konfiguriere SleepMode   Draad.endTransmission();                // Stoppe Kommunikation - Sende stopbit   Draad.beginVerzending(PWM_ModuleAddr); // Datentransfer initieren   Draad.schrijven(0xFE);                       // Wähle PRE_SCALE register (Command Register)   Draad.schrijven(0x03);                       // Set Prescaler. Die maximale PWM Frequent ist 1526 Hz wenn das PRE_SCALEer Regsiter auf "0x03h" gesetzt wird. Standaard: 200 Hz   Draad.endTransmission();                 // Stoppe Kommunikation - Sende stopbit   Draad.beginVerzending(PWM_ModuleAddr); // Datentransfer initieren   Draad.schrijven(0x00);                       // Wähle Mode 1 Register (Command Register)   Draad.schrijven(0xA1);                       // Konfiguriere Chip: ERrlaube All Call I2C Adressen, verwende interne Uhr, // Erlaube Auto Increment-functie   Draad.endTransmission();                 // Stoppe Kommunikation - Sende stopbit
}


nietig Init_PWM_Uitvoer(byte PWM_ModuleAddr)
{   digitalWrite(OE_Pin, HOOG); // Actieve LOW-Ausgangsaktivierungs-Pin (OE).   voor ( int z = 0; z < 16 + 1; z++)   {     Draad.beginVerzending(PWM_ModuleAddr);     Draad.schrijven(z * 4 + 6);      // Wähle PWM_Channel_ON_L register     Draad.schrijven(0x00);                     // Wert für o.g. Registreren     Draad.endTransmission();     Draad.beginVerzending(PWM_ModuleAddr);     Draad.schrijven(z * 4 + 7);      // Wähle PWM_Channel_ON_H register     Draad.schrijven(0x00);                     // Wert für o.g. Registreren     Draad.endTransmission();     Draad.beginVerzending(PWM_ModuleAddr);     Draad.schrijven(z * 4 + 8);   // Wähle PWM_Channel_OFF_L register     Draad.schrijven(0x00);        // Wert für o.g. Registreren     Draad.endTransmission();     Draad.beginVerzending(PWM_ModuleAddr);     Draad.schrijven(z * 4 + 9);  // Wähle PWM_Channel_OFF_H register     Draad.schrijven(0x00);             // Wert für o.g. Registreren     Draad.endTransmission();   }   digitalWrite(OE_Pin, LAAG); // Actieve LOW-Ausgangsaktivierungs-Pin (OE).
}

nietig opstelling()
{   // Initalisierung   Serie.beginnen(115200);   pinMode(PIRA_Pin, INVOER);   pinMode(PIRB_Pin, INVOER);   Serie.beginnen(9600);   terwijl (!Serie) {     ; // wacht tot seriële poort verbinding maakt. Nodig voor native USB   }   PWM-modules = Overall_Stages / 16;   Stadia Links = Overall_Stages % 16;   als (Stadia Links >= 1) {     PWM-modules++;   }   Draad.beginnen(); // Initalisiere I2C Bus A4 (SDA), A5 (SCL)   voor (byte ModuleCount = 0; ModuleCount < PWM-modules; ModuleCount++)   {     Init_PWM_Module(PWM_Module_Base_Addr + ModuleCount);     Init_PWM_Uitvoer(PWM_Module_Base_Addr + ModuleCount);   }   onderbreekt();   attachInterrupt(0, ISR_PIR_A, VERANDERING);   attachInterrupt(1, ISR_PIR_B, VERANDERING);   TCCR1A = 0x00;   TCCR1B = 0x02;   TCNT1 = 0;      // Registreren met 0 initialisieren   OCR1A =  33353;      // Output Vergelijk Register vorbelegen   TIMSK1 |= (1 << OCIE1A);  // Timer Vergelijk Interrupt aktivieren   onderbreekt();
}

nietig Down_to_Up_ON()
{   Serie.println("Down_to_Up_ON");   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   voor (byte ModuleCount = 0; ModuleCount < PWM-modules; ModuleCount++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     als ((Stadia Links >= 1) en (ModuleCount == PWM-modules - 1))     {       Calc_Num_Stages_per_Module = Stadia Links;     }     anders     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = 0;     Pwm_Channel_Brightness = 0;     terwijl (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Draad.beginVerzending( PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 8);   // Wähle PWM_Channel_0_OFF_L register       Draad.schrijven((byte)Pwm_Channel_Brightness & 0xFF);        // Wert für o.g. Registreren       Draad.endTransmission();       Draad.beginVerzending( PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 9);  // Wähle PWM_Channel_0_OFF_H register       Draad.schrijven((Pwm_Channel_Brightness >> 8));             // Wert für o.g. Registreren       Draad.endTransmission();       als (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + Vertraging_Stages;         als (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } anders als ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 0;         vertraging(delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}

nietig Up_to_DOWN_ON()
{   Serie.println("Up_to_DOWN_ON");   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   int ModuleCount = PWM-modules - 1;   terwijl (ModuleCount >= 0)   {     Pwm_Channel_Brightness = 0;     als ((Stadia Links >= 1) en (ModuleCount == PWM-modules - 1))     {       Calc_Num_Stages_per_Module =  Stadia Links;     }     anders     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     terwijl (Pwm_Channel > -1)     {       Draad.beginVerzending( PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 8);   // Wähle PWM_Channel_0_OFF_L register       Draad.schrijven((byte)Pwm_Channel_Brightness & 0xFF);        // Wert für o.g. Registreren       Draad.endTransmission();       Draad.beginVerzending(PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 9);  // Wähle PWM_Channel_0_OFF_H register       Draad.schrijven((Pwm_Channel_Brightness >> 8));             // Wert für o.g. Registreren       Draad.endTransmission();       als (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + Vertraging_Stages;         als (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } anders als ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness = 0;         vertraging(delay_per_Stage_in_ms);         Pwm_Channel--;         als ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           breken;         }       }     }     ModuleCount = ModuleCount - 1;   }
}


nietig Down_to_Up_OFF()
{   Serie.println("Down_to_Up_OFF");   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   voor (byte ModuleCount = 0; ModuleCount < PWM-modules; ModuleCount++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     als ((Stadia Links >= 1) en (ModuleCount == PWM-modules - 1))     {       Calc_Num_Stages_per_Module = Stadia Links;     }     anders     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     terwijl (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Draad.beginVerzending( PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 8);   // Wähle PWM_Channel_0_OFF_L register       Draad.schrijven((byte)Pwm_Channel_Brightness & 0xFF);        // Wert für o.g. Registreren       Draad.endTransmission();       Draad.beginVerzending(PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 9);  // Wähle PWM_Channel_0_OFF_H register       Draad.schrijven((Pwm_Channel_Brightness >> 8));             // Wert für o.g. Registreren       Draad.endTransmission();       als (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - Vertraging_Stages;         als (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } anders als ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 4095;         vertraging(delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}


nietig Up_to_DOWN_OFF()
{   Serie.println("Up_to_DOWN_OFF");   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   int ModuleCount = PWM-modules - 1;   terwijl (ModuleCount >= 0)   {     Pwm_Channel_Brightness = 4095;     als ((Stadia Links >= 1) en (ModuleCount == PWM-modules - 1))     {       Calc_Num_Stages_per_Module = Stadia Links;     }     anders     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     terwijl (Pwm_Channel > -1)     {       Draad.beginVerzending(PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 8);   // Wähle PWM_Channel_0_OFF_L register       Draad.schrijven((byte)Pwm_Channel_Brightness & 0xFF);        // Wert für o.g. Registreren       Draad.endTransmission();       Draad.beginVerzending(PWM_Module_Base_Addr + ModuleCount);       Draad.schrijven(Pwm_Channel * 4 + 9);  // Wähle PWM_Channel_0_OFF_H register       Draad.schrijven((Pwm_Channel_Brightness >> 8));             // Wert für o.g. Registreren       Draad.endTransmission();       als (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - Vertraging_Stages;         als (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } anders als ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness =  4095;         vertraging(delay_per_Stage_in_ms);         Pwm_Channel--;         als ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           breken;         }       }     }     ModuleCount = ModuleCount - 1;   }
}

nietig lus()
{   als ((Motion_Trigger_Down_to_Up) en !(Met vertraging) )   {     Seconden24 = 0;     Met vertraging = waar;     Down_to_Up_ON();   }   als ((Met vertraging) en (Seconden24 > Delay_ON_to_OFF) en (Motion_Trigger_Down_to_Up) )   {     Down_to_Up_OFF();     Motion_Trigger_Down_to_Up = fout;     Met vertraging = fout;     Seconden24 = 0;   }   als ((Motion_Trigger_Up_to_Down) en !(Met vertraging) )   {     Seconden24 = 0;     Met vertraging = waar;     Up_to_DOWN_ON();   }   als ((Met vertraging) en (Seconden24 > Delay_ON_to_OFF) en (Motion_Trigger_Up_to_Down))   {     Up_to_DOWN_OFF();     Motion_Trigger_Up_to_Down = fout;     Met vertraging = fout;     Seconden24 = 0;   }
}

 

 

Ich wünsche viel Spaß beim Nachbau und bis zum nächsten Teil der Reihe. Wie vind ik Iet auch alle vorherigen Projekte unter der GitHub Seite https://github.com/kuchto

Für arduinoProjekte für fortgeschritteneSensoren

8 Kommentare

Muharrem

Muharrem

@ Markus ich möchte dein Vorhaben auch realisieren. Könntest du mir bitte behilflich sein.
Ich bedanke mich im Voraus

Markus

Markus

Material:
xx ws2812b Leds (xx = Anzahl je nachdem wieviele man verbrauchen will), Strips oder einzelne
1 Arduino Nano
1 Bluetooth Modul HC-06
2 Bewegungsmelder HC-SR501
1 Lichtsensor
1 Netzteil 5V xx Ampere ( Je nachdem wie viele Leds man verbraucht)
Led Kabel 5 Adrig
Lötkolben und Zinn
Phantasie

Vorwort:
Überlegung war ein Treppenlicht zu bauen, was erkennt wenn oben oder unten jemand die Treppe benutzen möchte. Beim Bauen viel mir immer mehr ein was man machen könnte, so wurde es immer komplexer. So ist das Endergebnis mit Bluetooth mit dem Handy verbunden worden um Farben oder Effekte, sowie verschiedene Daten zu übermitteln. Ein Lichtsensor wurde verbaut, damit die Beleuchtung nicht andauernd anspringt, sondern nur wenn es dunkel genug ist.
Weitere Überlegungen:
Was brauche ich? In meiner zweiten Version habe ich Kabelkanäle genommen, da passte sogar der Nano und das BT Modul rein. Löcher für die Leds in der richtigen Lage der Stufen gebohrt und eingeklebt. Da im Nachhinein noch der Lichtsensor eingebaut wurde, muss ich durch den Kanal ein 5 adriges Led Kabel verlegen. Erste das 5V, Zweite GND, Dritte Datenkabel Leds, Vierte BW2, Fünfte der Lichtsensor. BW1 wird direkt an den nano gemacht.
Hab noch mehrere Versionen in laufe der Entwicklung erstellt, so hab ich auch welche mit Holzleisten gemacht, oder mit einer Fräse unten in den Treppenstufen eine Nut rein gefräst. Möglichkeiten sollte es genug geben. Man muss nur seine Phantasie spielen lassen.
Effekte wurden nach und nach eingebaut. Z.B. Wenn man die Treppe benutzt das die Treppen nach und nach der Richtung die man läuft angehen, und wenn man oben ankommt die langsam hinter sich ausgehen (sieht gut aus). Notbeleuchtung eingebaut, die die Treppe soweit beleuchten das man den Weg findet, man kann die Farbe der Beleuchtung ändern, die Zeiten etc. . Partybeleuchtung eingebaut. Es gibt auch hier noch etliche Möglichkeiten die einem einfallen. Die einzelnen Effekte konnte man dann mit einer App verändern oder ein oder ausschalten.
Meine nächsten Versionen, benutzen den Esp8266 (Wlan statt Bluetooth), so dass ich die Beleuchtung auch in meine Homeautomation per MQTT steuern kann. Dies ist aber noch in der Mache, das verschling doch ganz schön viel Zeit.
Ich weiß das einige nun wahrscheinlich den Code oder die App oder sonst was haben möchte. Ich habe damit aber so viel Zeit verbracht das ich das so nicht machen werde, bin aber bereit zu helfen wenn es im Eigenbau zu Fragen oder Problemen kommt.

Dirk

Dirk

Hallo an alle,
ich komme hier mit einer vielleicht etwas peinlichen Frage weil ich mich vielleicht einfach nur verrechne. Aber ich bin mir unsicher über den Kabelquerschnitt bei der Stromversorgung für die Lampen. Ich möchte Led Ringe verwenden, die wollen 5 Volt und ziehen 0,24 A wenn ich das aus dem Datenblatt richtig lese. Wenn ich jetzt 16 (16 Stufen) Stück parallel mit der nötigen Leistung versorgen will, welchen Kabelquerschnitt braue ich ich dann ohne diese zu Überlasten ? Das sind dann ja schon knapp 20 Watt und das bei 3 Meter Leitungslänge. Will ja nicht die Treppe abfackeln. Oder sollte man mit mehreren Reihenschaltungen und mehr Volt arbeiten. Wäre sehr dankbar für einen Tipp.
Gruß, Dirk

Tobias

Tobias

Hallo Georg,
Die Beleuchtung kommt sehr nahe an das Video, jedoch variiert die Ausschalt Sequenz der Treppe ein bisschen, da immer die nächste Treppenstufe erst dann anfängt, hoch oder herunterzudimmen, wenn die vorherige bereits Ihren Endzustand (aus oder ein) erreicht hat. Im Video passiert das augenscheinlich parallel in der Ausschalt Sequentz. Ich helfe, soweit es zeitlich im Rahmen bleibt, gerne weiter . Mailadresse: tobias.kuch@googlemail.com.
Gruß
Tobias

Tobias

Tobias

Hallo Markus,

Könntest du dein tolles Projekt mit Code für Nano und Handyapp, Aufbauanleitung und Beschreibung dann nicht auch uns allen zur Verfügung stellen ? So hätten auch andere etwas davon
Gruß
Tobias

Uwe

Uwe

Lieber Tobias, hallo AZ-Team,
zuerst Mal danke für die Beiträge und die Mühe damit. Nach den Kommentaren von Wolfgang und Thomas habe ich auch noch einige Ideen.

Zunächst einmal wäre es sinnvoll, bei Fortsetzungen einer Beitragsreihe die Kommentare zu konsolidieren. Es gibt Leser, die auch aus den Kommentaren vielleicht noch Ideen schöpfen können.

Aus den Fragen und Anregungen der Kommentatoren ist zu entnehmen, dass es auch andere Vorschläge gibt. Ich gehe davon aus, dass AZ diese auch gerne veröffentlichen würde, wenn man diese einreicht. Hier wäre vielleicht ein Hinweis angebracht, wie man das macht.

Nun ist der Interessenkreis hier sehr verschieden: AZ-Delivery lebt vom Vertrieb von Komponenten und nutzt die Beiträge dazu, Interesse für sein Portal zu wecken, Es gibt Leser, die sich für die Elektronik interessieren, die jedoch Nachhilfe bei der Programmerstellung benötigen, andere suchen einfach eine Idee zum Nachbauen. Wieder andere haben vielleicht mit Mechanik keinerlei Probleme, denen ist Strom jedoch ein Rätsel. Dazwischen sitzt der Autor und kann es keinem richtig Recht machen – eigentlich wollte er ja nur an seiner Idee teilhaben lassen.

Ich finde die hier vorgestellte Idee super (würde mir auch den Vorschlag von Markus ansehen wollen) – habe als Kybernetiker mit dem Verständnis von Automaten, Startbedingungen und Betrachtung (was wäre wenn…) keine Probleme. Nur habe ich mich nie mit der Programmentwicklung in der Tiefe beschäftigt. Für mich wäre es hilfreich, wenn im Code einige Kommentare drin wären, die das Verständnis des Codes für eine evtl Adaption erleichtern. Hierfür wäre ich sogar bereit, einen Obulus zu bezahlen. Die Anregung hier: vielleicht könnte man unter der Rubrik Literatur ein komplettes “Make” für ?? anbieten, dann mit ausführlichen Hinweisen zu VDE, Code, mechanischer Sicherheit etc?

Georg L.

Georg L.

Hallo Markus, kannst deine Lösung auch gerne teilen, dann können alle nachvollziehen, ob es einfacher ist. @Tobias, funktioniert die Beleuchtung dann wie im Video des ersten Teiles zu sehen?

Markus

Markus

Ich finde das alles zu umständlich, habe selber schon mehrere Treppenbeleuchtung gebaut und programmiert. Habe aber die WS2812 genommen, nano mit Bluetooth Verbindung (mit einer selbstgeschriebenden App um Veränderungen vor zu nehmen) , Mini IR Bewegungssensor PIR AM312. Das ganze läuft Problemlos.

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert