Elegante iluminación automática de la escalera (parte3)

Hola y bienvenidos a una continuación de la serie elegante iluminación de escalera. Hoy expandirse como el número máximo de escaleras que nuestro controlador puede controlar de sólo 16 a Fulminate 992 pasos!
Por lo tanto, incluso los propietarios de una escalera más larga deben ser capaces de ajustar fácilmente el control para sus propósitos de acuerdo a sus necesidades y deseos.

Este ajuste se realiza de forma fácil y cómoda ajustando las variables del programa "Overall_Stages" al número deseado de escaleras del 1 al 992.

Bueno, uno u otro puede preguntarse cómo llego a este gran número de salidas PWM en sólo 20 salidas disponibles de un AZ-Delivery Nano V3. El secreto está en los 6 bits de dirección del PCA9685. Cada PCA9685 puede proporcionar 16 canales PWM. El diseño de la cadena de margarita de la placa evita el caos del cable y permite que los controladores de hasta 62 se conecten cómodamente.

Al abordar binariasmente las placas, una de un total de 62 direcciones en el rango de 40h a 7Eh se puede asignar a un módulo contando hacia arriba. Esto da como resultado el máximo de 992 salidas posibles con 16 salidas por módulo.

El código ha sido escrito por mí para que el direccionamiento de los módulos sea abstraído por el usuario y se calcule automáticamente. Es sólo la suma total de las escaleras que se especificarán en una variable y un número atractivo de módulos que se adjuntarán como una cadena margarita al bus I2C. En el caso de los módulos, se debe prestar atención a un direccionamiento ascendente de los módulos.

En la siguiente imagen se puede ver cómo los módulos tienen que estar conectados y dirigidos:

Estructura como una cadena Daisy

 

 

Para nuestro proyecto actual necesitamos:

Número

Descripción

Nota

2

Pir Módulo HC-SR501 PIR

Sensor de movimiento

hasta 62

PCA9685 16 Canal 12 Bit PWM Driver

Número dependiendo del número de escaleras /16

1

Nano V3

 

1

Mb102 Adaptador de fuente de alimentación

Para la configuración de la placa de pan

hasta 992

Módulo de controlador IRF520 MOS 0-24V 5A

Número dependiendo del número de escaleras

1

Fuente de alimentación para LED/lámparas para los pasos

Máximo 24 voltios

 

Tenga en cuenta que el circuito no se ha probado con el montaje completo, sino sólo con 2 módulos de tipo PCA9685. Por lo tanto, un montaje completo con 62 módulos es Teóricamente Descrito. En la práctica, deben tenerse en cuenta las longitudes máximas de los buses I2C, la seguridad de las fallas, la transmisión de señal limpia, las fuentes de alimentación de tamaño suficiente, los cables, las conexiones seguras y más. Todas las referencias a esto de las partes anteriores se aplican en particular en la parte actual.

Aquí está el código actualizado para la parte de hoy:

 

Código de Tobias Kuch 2019 mailto:tobias.kuch@googlemail.com
Código bajo GPL 3.0

#include <Alambre.H>

#define PWM_Module_Base_Addr 0x40 10000000b El último bit del byte de dirección define la operación que se va a realizar. Cuando se establece en lógico 1 0x41 módulo 2 etc. Rango de direcciones0x40 - 0x47 
selecciona una operación de lectura mientras que un 0 lógico selecciona una operación de escritura.
#define OE_Pin  8           Pin para el activador de salida 
#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  Mínimo Delay_ON_to_OFF en segundos


Int Overall_Stages =  16; número máximo de pasos: 62 x 16 x 992
Int delay_per_Stage_in_ms = 200;



Int Pwm_Channel = 0;
Int Pwm_Channel_Brightness = 0;
Bool Motion_Trigger_Down_to_Up = Falso;
Bool Motion_Trigger_Up_to_Down = Falso;
Bool On_Delay = Falso;
Byte PWMModules = 0;
Byte StagesLeft = 0;
interrumpir el control
Byte A60telSeconds24 = 0;
Byte Seconds24;

Isr(TIMER1_COMPA_vect)
{   A60telSeconds24++;   Si (A60telSeconds24 > 59)   {     A60telSeconds24 = 0;     Seconds24++;     Si (Seconds24 > 150)     {       Seconds24 = 0;     }   }
}

Vacío ISR_PIR_A()
{   Bool PinState = digitalRead(PIRA_Pin);   Si (PinState)   {     Si (!(Motion_Trigger_Up_to_Down) Y !(Motion_Trigger_Down_to_Up))     {       digitalWrite(CPU_LED_Pin, Alto);       Motion_Trigger_Down_to_Up = Verdad;     } PIR A activado   } Más   {     digitalWrite(CPU_LED_Pin, Bajo);   }
}

Vacío ISR_PIR_B()
{   Bool PinState = digitalRead(PIRB_Pin);   Si (PinState)   {     Si (!(Motion_Trigger_Down_to_Up) Y !(Motion_Trigger_Up_to_Down))     {       digitalWrite(CPU_LED_Pin, Alto);       Motion_Trigger_Up_to_Down = Verdad;     } PIR B activado   } Más   {     digitalWrite(CPU_LED_Pin, Bajo);   }
}

Vacío Init_PWM_Module(Byte PWM_ModuleAddr)
{   pinMode(OE_Pin, Salida);   pinMode(CPU_LED_Pin, Salida);   digitalWrite(OE_Pin, Alto); Pin de activación de salida BAJO activo (OE).   Alambre.beginTransmisión(PWM_ModuleAddr); Iniciar la transferencia de datos   Alambre.Escribir(0x00);                       //   Alambre.Escribir(0x06);                       Restablecimiento de software   Alambre.endTransmission();                 Detener comunicación - Enviar bit de parada   Retraso(400);   Alambre.beginTransmisión(PWM_ModuleAddr); Iniciar la transferencia de datos   Alambre.Escribir(0x01);                       Seleccionar el registro del modo 2 (registro de comandos)   Alambre.Escribir(0x04);                       Configurar chip: 0x04: salida de polo muerto 0x00: Salida de drenaje abierta.   Alambre.endTransmission();                 Detener comunicación - Enviar bit de parada   Alambre.beginTransmisión(PWM_ModuleAddr); Iniciar la transferencia de datos   Alambre.Escribir(0x00);                      Seleccionar el registro del modo 1 (registro de comandos)   Alambre.Escribir(0x10);                      Configurar SleepMode   Alambre.endTransmission();                Detener comunicación - Enviar bit de parada   Alambre.beginTransmisión(PWM_ModuleAddr); Iniciar la transferencia de datos   Alambre.Escribir(0xFE);                       Seleccione PRE_SCALE registrarse   Alambre.Escribir(0x03);                       Establezca Prescaler. La frecuencia máxima de PWM es de 1526 Hz si el PRE_SCALEer el operador se establece en "0x03h". Estándar: 200 Hz   Alambre.endTransmission();                 Detener comunicación - Enviar bit de parada   Alambre.beginTransmisión(PWM_ModuleAddr); Iniciar la transferencia de datos   Alambre.Escribir(0x00);                       Seleccionar el registro del modo 1 (registro de comandos)   Alambre.Escribir(0xA1);                       Configurar chip: ERrlaube Todas las direcciones I2C de la llamada, utilice el reloj interno, / permita la característica del incremento automático   Alambre.endTransmission();                 Detener comunicación - Enviar bit de parada
}


Vacío Init_PWM_Outputs(Byte PWM_ModuleAddr)
{   digitalWrite(OE_Pin, Alto); Pin de activación de salida BAJO activo (OE).   Para ( Int Z = 0; Z < 16 + 1; Z++)   {     Alambre.beginTransmisión(PWM_ModuleAddr);     Alambre.Escribir(Z * 4 + 6);      Seleccione PWM_Channel_ON_L registrarse     Alambre.Escribir(0x00);                     Valor para el registro anterior     Alambre.endTransmission();     Alambre.beginTransmisión(PWM_ModuleAddr);     Alambre.Escribir(Z * 4 + 7);      Seleccione PWM_Channel_ON_H registrarse     Alambre.Escribir(0x00);                     Valor para el registro anterior     Alambre.endTransmission();     Alambre.beginTransmisión(PWM_ModuleAddr);     Alambre.Escribir(Z * 4 + 8);   Seleccione PWM_Channel_OFF_L registrar     Alambre.Escribir(0x00);        Valor para el registro anterior     Alambre.endTransmission();     Alambre.beginTransmisión(PWM_ModuleAddr);     Alambre.Escribir(Z * 4 + 9);  Seleccione PWM_Channel_OFF_H registrarse     Alambre.Escribir(0x00);             Valor para el registro anterior     Alambre.endTransmission();   }   digitalWrite(OE_Pin, Bajo); Pin de activación de salida BAJO activo (OE).
}

Vacío Configuración()
{   Initalización   Serial.Comenzar(115200);   pinMode(PIRA_Pin, Entrada);   pinMode(PIRB_Pin, Entrada);   Serial.Comenzar(9600);   Mientras (!Serial) {     ; esperar a que el puerto serie se conecte. Necesario para USB nativo   }   PWMModules = Overall_Stages / 16;   StagesLeft = Overall_Stages % 16;   Si (StagesLeft >= 1) {     PWMModules++;   }   Alambre.Comenzar(); Initalisia I2C Bus A4 (SDA), A5 (SCL)   Para (Byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++)   {     Init_PWM_Module(PWM_Module_Base_Addr + ModuleCount);     Init_PWM_Outputs(PWM_Module_Base_Addr + ModuleCount);   }   noInterrupts();   adjuntarInterrupt(0, ISR_PIR_A, cambio);   adjuntarInterrupt(1, ISR_PIR_B, cambio);   TCCR1A = 0x00;   TCCR1B = 0x02;   TCNT1 = 0;      Inicializar registro con 0   OCR1A =  33353;      Predocumentos Registro de Comparación de Salida   TIMSK1 |= (1 << OCIE1A);  Activar interrupción de comparación de temporizadores   Interrumpe();
}

Vacío Down_to_Up_ON()
{   Serial.println("Down_to_Up_ON");   Byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Para (Byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     Si ((StagesLeft >= 1) Y (ModuleCount == PWMModules - 1))     {       Calc_Num_Stages_per_Module = StagesLeft;     }     Más     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = 0;     Pwm_Channel_Brightness = 0;     Mientras (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Alambre.beginTransmisión( PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 8);   Seleccione PWM_Channel_0_OFF_L registrarse       Alambre.Escribir((Byte)Pwm_Channel_Brightness & 0xff);        Valor para el registro anterior       Alambre.endTransmission();       Alambre.beginTransmisión( PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 9);  Seleccione PWM_Channel_0_OFF_H registrar       Alambre.Escribir((Pwm_Channel_Brightness >> 8));             Valor para el registro anterior       Alambre.endTransmission();       Si (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages;         Si (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } Más Si ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 0;         Retraso(delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}

Vacío Up_to_DOWN_ON()
{   Serial.println("Up_to_DOWN_ON");   Byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Int ModuleCount = PWMModules - 1;   Mientras (ModuleCount >= 0)   {     Pwm_Channel_Brightness = 0;     Si ((StagesLeft >= 1) Y (ModuleCount == PWMModules - 1))     {       Calc_Num_Stages_per_Module =  StagesLeft;     }     Más     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     Mientras (Pwm_Channel > -1)     {       Alambre.beginTransmisión( PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 8);   Seleccione PWM_Channel_0_OFF_L registrarse       Alambre.Escribir((Byte)Pwm_Channel_Brightness & 0xff);        Valor para el registro anterior       Alambre.endTransmission();       Alambre.beginTransmisión(PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 9);  Seleccione PWM_Channel_0_OFF_H registrar       Alambre.Escribir((Pwm_Channel_Brightness >> 8));             Valor para el registro anterior       Alambre.endTransmission();       Si (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages;         Si (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } Más Si ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness = 0;         Retraso(delay_per_Stage_in_ms);         Pwm_Channel--;         Si ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           Romper;         }       }     }     ModuleCount = ModuleCount - 1;   }
}


Vacío Down_to_Up_OFF()
{   Serial.println("Down_to_Up_OFF");   Byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Para (Byte ModuleCount = 0; ModuleCount < PWMModules; ModuleCount++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     Si ((StagesLeft >= 1) Y (ModuleCount == PWMModules - 1))     {       Calc_Num_Stages_per_Module = StagesLeft;     }     Más     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Mientras (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Alambre.beginTransmisión( PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 8);   Seleccione PWM_Channel_0_OFF_L registrarse       Alambre.Escribir((Byte)Pwm_Channel_Brightness & 0xff);        Valor para el registro anterior       Alambre.endTransmission();       Alambre.beginTransmisión(PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 9);  Seleccione PWM_Channel_0_OFF_H registrar       Alambre.Escribir((Pwm_Channel_Brightness >> 8));             Valor para el registro anterior       Alambre.endTransmission();       Si (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages;         Si (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } Más Si ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 4095;         Retraso(delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}


Vacío Up_to_DOWN_OFF()
{   Serial.println("Up_to_DOWN_OFF");   Byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Int ModuleCount = PWMModules - 1;   Mientras (ModuleCount >= 0)   {     Pwm_Channel_Brightness = 4095;     Si ((StagesLeft >= 1) Y (ModuleCount == PWMModules - 1))     {       Calc_Num_Stages_per_Module = StagesLeft;     }     Más     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     Mientras (Pwm_Channel > -1)     {       Alambre.beginTransmisión(PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 8);   Seleccione PWM_Channel_0_OFF_L registrarse       Alambre.Escribir((Byte)Pwm_Channel_Brightness & 0xff);        Valor para el registro anterior       Alambre.endTransmission();       Alambre.beginTransmisión(PWM_Module_Base_Addr + ModuleCount);       Alambre.Escribir(Pwm_Channel * 4 + 9);  Seleccione PWM_Channel_0_OFF_H registrar       Alambre.Escribir((Pwm_Channel_Brightness >> 8));             Valor para el registro anterior       Alambre.endTransmission();       Si (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages;         Si (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } Más Si ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness =  4095;         Retraso(delay_per_Stage_in_ms);         Pwm_Channel--;         Si ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           Romper;         }       }     }     ModuleCount = ModuleCount - 1;   }
}

Vacío Bucle()
{   Si ((Motion_Trigger_Down_to_Up) Y !(On_Delay) )   {     Seconds24 = 0;     On_Delay = Verdad;     Down_to_Up_ON();   }   Si ((On_Delay) Y (Seconds24 > Delay_ON_to_OFF) Y (Motion_Trigger_Down_to_Up) )   {     Down_to_Up_OFF();     Motion_Trigger_Down_to_Up = Falso;     On_Delay = Falso;     Seconds24 = 0;   }   Si ((Motion_Trigger_Up_to_Down) Y !(On_Delay) )   {     Seconds24 = 0;     On_Delay = Verdad;     Up_to_DOWN_ON();   }   Si ((On_Delay) Y (Seconds24 > Delay_ON_to_OFF) Y (Motion_Trigger_Up_to_Down))   {     Up_to_DOWN_OFF();     Motion_Trigger_Up_to_Down = Falso;     On_Delay = Falso;     Seconds24 = 0;   }
}

 

 

Te deseo mucha diversión con la réplica y hasta la siguiente parte de la serie. Como siempre, puede encontrar todos los proyectos anteriores en la página de GitHub https://github.com/kuchto

Para arduinoProyectos para avanzados.Sensores

8 comentarios

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.

Deja un comentario

Todos los comentarios son moderados antes de ser publicados

Artículos de blog

  1. Ahora instalamos el esp32 a través de la administración.
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. Transporte Aéreo - programación de ESP mediante redes locales inalámbricas