Éclairage d’escalier automatique élégant (partie3)

Bonjour et bienvenue à une continuation de la série élégant éclairage d’escalier. Aujourd’hui, étendre comme le nombre maximum d’escaliers que notre contrôleur peut contrôler à partir de seulement 16 à Fulminate 992 étapes!
Ainsi, même les propriétaires d’un escalier plus long devraient être en mesure d’ajuster facilement le contrôle à leurs fins en fonction de vos besoins et souhaits.

Cet ajustement se fait facilement et facilement en ajustant les variables du programme « Overall_Stages » au nombre désiré d’escaliers de 1 à 992.

Eh bien, l’un ou l’autre peut se demander comment j’atteindras ce grand nombre de sorties PWM à seulement 20 sorties disponibles d’un AZ-Delivery Nano V3. Le secret réside dans les 6 morceaux d’adresse du PCA9685. Chaque PCA9685 peut fournir 16 canaux PWM. La disposition de la chaîne de marguerites de la carte empêche le chaos du câble et permet aux 62 contrôleurs de se connecter confortablement.

En adressant binaire les planches, l’une des 62 adresses d’une portée de 40h à 7Eh peut être attribuée à un module comptant vers le haut. Il en résulte le maximum possible 992 sorties avec 16 sorties par module.

Le code a été écrit par moi de sorte que l’adresse des modules est abstraite par l’utilisateur et est calculée automatiquement. Ce n’est que la somme totale des escaliers à préciser dans une variable et un nombre attrayant de modules à attacher comme une chaîne de marguerites à l’autobus I2C. Dans le cas des modules, il faut prêter attention à une adresse ascendante des modules.

Dans l’image suivante, vous pouvez voir comment les modules doivent être connectés et adressés :

Pour notre projet actuel, nous avons besoin de :

Veuillez noter que le circuit n’a pas été testé avec l’assemblage complet, mais seulement avec 2 modules de type PCA9685. Une assemblée complète avec 62 modules n’est donc Théoriquement Décrit. Dans la pratique, il faut tenir compte des longueurs maximales des autobus I2C, de la sécurité des pannes, de la transmission du signal propre, de l’alimentation suffisamment dimensionnée, des câbles, des connexions sécurisées et plus encore. Toutes les références à cela des parties précédentes s’appliquent en particulier dans la partie d’aujourd’hui.

Voici le code mis à jour pour la partie d’aujourd’hui:

Code par Tobias Kuch 2019 mailto:tobias.kuch@googlemail.com
Code en vertu de GPL 3.0

#include <Fil.H (en)>

#define PWM_Module_Base_Addr 0x40 1000000b Le dernier morceau de l’adresse byte définit l’opération à effectuer. Lorsqu’il est réglé à la logique 1 0x41 module 2 etc. Gamme d’adresses0x40 - 0x47 
sélectionne une opération de lecture tandis qu’un 0 logique sélectionne une opération d’écriture.
#define OE_Pin  8           Pin pour l’activation de sortie 
#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 en secondes


Int Overall_Stages =  16; nombre maximum d’étapes : 62 x 16 et 992
Int delay_per_Stage_in_ms = 200;



Int Pwm_Channel = 0;
Int Pwm_Channel_Brightness = 0;
Bool Motion_Trigger_Down_to_Up = Faux;
Bool Motion_Trigger_Up_to_Down = Faux;
Bool On_Delay = Faux;
Octet PwMModules = 0;
Octet StagesLeft (en) = 0;
interrompre le contrôle
Octet A60telSecondes24 = 0;
Octet Seconds24;

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

Vide ISR_PIR_A()
{   Bool PinState (En) = digitalRead (en)(PIRA_Pin);   Si (PinState (En))   {     Si (!(Motion_Trigger_Up_to_Down) Et !(Motion_Trigger_Down_to_Up))     {       digitalWrite (en)(CPU_LED_Pin, Haute);       Motion_Trigger_Down_to_Up = Vrai;     } PIR A déclenché   } Autre   {     digitalWrite (en)(CPU_LED_Pin, Faible);   }
}

Vide ISR_PIR_B()
{   Bool PinState (En) = digitalRead (en)(PIRB_Pin);   Si (PinState (En))   {     Si (!(Motion_Trigger_Down_to_Up) Et !(Motion_Trigger_Up_to_Down))     {       digitalWrite (en)(CPU_LED_Pin, Haute);       Motion_Trigger_Up_to_Down = Vrai;     } PIR B déclenché   } Autre   {     digitalWrite (en)(CPU_LED_Pin, Faible);   }
}

Vide Init_PWM_Module(Octet PWM_ModuleAddr)
{   pinMode(OE_Pin, Sortie);   pinMode(CPU_LED_Pin, Sortie);   digitalWrite (en)(OE_Pin, Haute); Épingle d’activation de sortie LOW active (OE).   Fil.commenceTransmission(PWM_ModuleAddr); Initier le transfert de données   Fil.Écrire(0x00);                       //   Fil.Écrire(0x06);                       Réinitialisation logicielle   Fil.endTransmission();                 Stop Communication - Envoyer Stop Bit   Retard(400);   Fil.commenceTransmission(PWM_ModuleAddr); Initier le transfert de données   Fil.Écrire(0x01 (en));                       Sélectionnez Mode 2 Registre (Registre de commande)   Fil.Écrire(0x04);                       Configurer Chip: 0x04: sortie de poteau mort 0x00: Sortie de vidange ouverte.   Fil.endTransmission();                 Stop Communication - Envoyer Stop Bit   Fil.commenceTransmission(PWM_ModuleAddr); Initier le transfert de données   Fil.Écrire(0x00);                      Sélectionnez Mode 1 Registre (Registre de commande)   Fil.Écrire(0x10);                      Configurer SleepMode   Fil.endTransmission();                Stop Communication - Envoyer Stop Bit   Fil.commenceTransmission(PWM_ModuleAddr); Initier le transfert de données   Fil.Écrire(0xFE (en));                       Sélectionnez PRE_SCALE inscrivez-vous   Fil.Écrire(0x03);                       Réglez Prescaler. La fréquence maximale pwM est de 1526 Hz si le PRE_SCALEer l’opérateur est réglé à "0x03h". Standard: 200 Hz   Fil.endTransmission();                 Stop Communication - Envoyer Stop Bit   Fil.commenceTransmission(PWM_ModuleAddr); Initier le transfert de données   Fil.Écrire(0x00);                       Sélectionnez Mode 1 Registre (Registre de commande)   Fil.Écrire(0xA1 (en));                       Configurer Chip: ERrlaube All Call I2C adresses, utiliser l’horloge interne, / Autoriser la fonction d’incrément automatique   Fil.endTransmission();                 Stop Communication - Envoyer Stop Bit
}


Vide Init_PWM_Outputs(Octet PWM_ModuleAddr)
{   digitalWrite (en)(OE_Pin, Haute); Épingle d’activation de sortie LOW active (OE).   Pour ( Int Z = 0; Z < 16 + 1; Z++)   {     Fil.commenceTransmission(PWM_ModuleAddr);     Fil.Écrire(Z * 4 + 6);      Sélectionnez PWM_Channel_ON_L inscrivez-vous     Fil.Écrire(0x00);                     Valeur pour le registre ci-dessus     Fil.endTransmission();     Fil.commenceTransmission(PWM_ModuleAddr);     Fil.Écrire(Z * 4 + 7);      Sélectionnez PWM_Channel_ON_H inscrivez-vous     Fil.Écrire(0x00);                     Valeur pour le registre ci-dessus     Fil.endTransmission();     Fil.commenceTransmission(PWM_ModuleAddr);     Fil.Écrire(Z * 4 + 8);   Sélectionnez PWM_Channel_OFF_L inscrivez-vous     Fil.Écrire(0x00);        Valeur pour le registre ci-dessus     Fil.endTransmission();     Fil.commenceTransmission(PWM_ModuleAddr);     Fil.Écrire(Z * 4 + 9);  Sélectionnez PWM_Channel_OFF_H inscrivez-vous     Fil.Écrire(0x00);             Valeur pour le registre ci-dessus     Fil.endTransmission();   }   digitalWrite (en)(OE_Pin, Faible); Épingle d’activation de sortie LOW active (OE).
}

Vide Configuration()
{   Initalisation   Série.Commencer(115200);   pinMode(PIRA_Pin, Entrée);   pinMode(PIRB_Pin, Entrée);   Série.Commencer(9600);   Tandis que (!Série) {     ; attendre que le port en série se connecte. Nécessaire pour l’USB natif   }   PwMModules = Overall_Stages / 16;   StagesLeft (en) = Overall_Stages % 16;   Si (StagesLeft (en) >= 1) {     PwMModules++;   }   Fil.Commencer(); Initalisia I2C Bus A4 (SDA), A5 (SCL)   Pour (Octet ModuleCompte = 0; ModuleCompte < PwMModules; ModuleCompte++)   {     Init_PWM_Module(PWM_Module_Base_Addr + ModuleCompte);     Init_PWM_Outputs(PWM_Module_Base_Addr + ModuleCompte);   }   noInterrupts();   attacherInterrupt(0, ISR_PIR_A, changement);   attacherInterrupt(1, ISR_PIR_B, changement);   TCCR1A (EN) = 0x00;   TCCR1B (EN) = 0x02;   TCNT1 (en) = 0;      Inscription initiale avec 0   OCR1A =  33353;      Pré-documents Output Compare Register   TIMSK1 (en) |= (1 << OCIE1A);  Activez Timer Compare Interrupt   Interrompt();
}

Vide Down_to_Up_ON()
{   Série.println("Down_to_Up_ON");   Octet Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Pour (Octet ModuleCompte = 0; ModuleCompte < PwMModules; ModuleCompte++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     Si ((StagesLeft (en) >= 1) Et (ModuleCompte == PwMModules - 1))     {       Calc_Num_Stages_per_Module = StagesLeft (en);     }     Autre     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = 0;     Pwm_Channel_Brightness = 0;     Tandis que (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Fil.commenceTransmission( PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 8);   Sélectionnez PWM_Channel_0_OFF_L inscrivez-vous       Fil.Écrire((Octet)Pwm_Channel_Brightness & 0xff);        Valeur pour le registre ci-dessus       Fil.endTransmission();       Fil.commenceTransmission( PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 9);  Sélectionnez PWM_Channel_0_OFF_H inscrivez-vous       Fil.Écrire((Pwm_Channel_Brightness >> 8));             Valeur pour le registre ci-dessus       Fil.endTransmission();       Si (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages;         Si (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } Autre Si ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 0;         Retard(delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}

Vide Up_to_DOWN_ON()
{   Série.println("Up_to_DOWN_ON");   Octet Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Int ModuleCompte = PwMModules - 1;   Tandis que (ModuleCompte >= 0)   {     Pwm_Channel_Brightness = 0;     Si ((StagesLeft (en) >= 1) Et (ModuleCompte == PwMModules - 1))     {       Calc_Num_Stages_per_Module =  StagesLeft (en);     }     Autre     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     Tandis que (Pwm_Channel > -1)     {       Fil.commenceTransmission( PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 8);   Sélectionnez PWM_Channel_0_OFF_L inscrivez-vous       Fil.Écrire((Octet)Pwm_Channel_Brightness & 0xff);        Valeur pour le registre ci-dessus       Fil.endTransmission();       Fil.commenceTransmission(PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 9);  Sélectionnez PWM_Channel_0_OFF_H inscrivez-vous       Fil.Écrire((Pwm_Channel_Brightness >> 8));             Valeur pour le registre ci-dessus       Fil.endTransmission();       Si (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + Delay_Stages;         Si (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } Autre Si ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness = 0;         Retard(delay_per_Stage_in_ms);         Pwm_Channel--;         Si ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           Pause;         }       }     }     ModuleCompte = ModuleCompte - 1;   }
}


Vide Down_to_Up_OFF()
{   Série.println("Down_to_Up_OFF");   Octet Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Pour (Octet ModuleCompte = 0; ModuleCompte < PwMModules; ModuleCompte++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     Si ((StagesLeft (en) >= 1) Et (ModuleCompte == PwMModules - 1))     {       Calc_Num_Stages_per_Module = StagesLeft (en);     }     Autre     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Tandis que (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Fil.commenceTransmission( PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 8);   Sélectionnez PWM_Channel_0_OFF_L inscrivez-vous       Fil.Écrire((Octet)Pwm_Channel_Brightness & 0xff);        Valeur pour le registre ci-dessus       Fil.endTransmission();       Fil.commenceTransmission(PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 9);  Sélectionnez PWM_Channel_0_OFF_H inscrivez-vous       Fil.Écrire((Pwm_Channel_Brightness >> 8));             Valeur pour le registre ci-dessus       Fil.endTransmission();       Si (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages;         Si (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } Autre Si ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 4095;         Retard(delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}


Vide Up_to_DOWN_OFF()
{   Série.println("Up_to_DOWN_OFF");   Octet Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Int ModuleCompte = PwMModules - 1;   Tandis que (ModuleCompte >= 0)   {     Pwm_Channel_Brightness = 4095;     Si ((StagesLeft (en) >= 1) Et (ModuleCompte == PwMModules - 1))     {       Calc_Num_Stages_per_Module = StagesLeft (en);     }     Autre     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     Tandis que (Pwm_Channel > -1)     {       Fil.commenceTransmission(PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 8);   Sélectionnez PWM_Channel_0_OFF_L inscrivez-vous       Fil.Écrire((Octet)Pwm_Channel_Brightness & 0xff);        Valeur pour le registre ci-dessus       Fil.endTransmission();       Fil.commenceTransmission(PWM_Module_Base_Addr + ModuleCompte);       Fil.Écrire(Pwm_Channel * 4 + 9);  Sélectionnez PWM_Channel_0_OFF_H inscrivez-vous       Fil.Écrire((Pwm_Channel_Brightness >> 8));             Valeur pour le registre ci-dessus       Fil.endTransmission();       Si (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - Delay_Stages;         Si (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } Autre Si ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness =  4095;         Retard(delay_per_Stage_in_ms);         Pwm_Channel--;         Si ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           Pause;         }       }     }     ModuleCompte = ModuleCompte - 1;   }
}

Vide Boucle()
{   Si ((Motion_Trigger_Down_to_Up) Et !(On_Delay) )   {     Seconds24 = 0;     On_Delay = Vrai;     Down_to_Up_ON();   }   Si ((On_Delay) Et (Seconds24 > Delay_ON_to_OFF) Et (Motion_Trigger_Down_to_Up) )   {     Down_to_Up_OFF();     Motion_Trigger_Down_to_Up = Faux;     On_Delay = Faux;     Seconds24 = 0;   }   Si ((Motion_Trigger_Up_to_Down) Et !(On_Delay) )   {     Seconds24 = 0;     On_Delay = Vrai;     Up_to_DOWN_ON();   }   Si ((On_Delay) Et (Seconds24 > Delay_ON_to_OFF) Et (Motion_Trigger_Up_to_Down))   {     Up_to_DOWN_OFF();     Motion_Trigger_Up_to_Down = Faux;     On_Delay = Faux;     Seconds24 = 0;   }
}

Je vous souhaite beaucoup de plaisir avec la réplique et jusqu’à la prochaine partie de la série. Comme toujours, vous pouvez trouver tous les projets précédents sous la page GitHub https://github.com/kuchto