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:

Voor het project van vandaag hebben we nodig:

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