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:

Para nuestro proyecto actual necesitamos:

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