Een elegante automatische trap verlichting (deel 5)

Hallo en welkom bij het laatste deel van de serie "elegante automatische trapverlichting".

 

Vandaag ronden we ons besturingssysteem af met een handige configuratie-optie voor alle bedrijfsparameters. Alle bedrijfsparameters kunnen nu gemakkelijk worden ingesteld via de seriële interface in inactieve status (alle trappenhuisverlichting inactief) en worden opgeslagen in de interne EEPROM van de UC. Dit betekent dat alle instellingen behouden blijven, zelfs na een herstart of in geval van een stroomstoring. Alle instelbare parameters worden afzonderlijk aan het einde van het document uitgelegd. Omdat de functie volledig is geïmplementeerd in software, verandert de technische structuur niet in vergelijking met deel 4 van de serie. Voor de volledigheid moet dit echter opnieuw worden aangetoond:

Foto uit deel 4

 

Ook de lijst met componenten voor de projecten en  alle referenties uit de vorige delen  verander niet:

 

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

1

10 KOhm weerstand

 

1

LDR

Fotoweerstand

 

Het kan ZONDER voorafgaande aanpassing  de volgende code wordt geüpload naar de Arduino:

 

 

# opnemen <Draad.h>
# opnemen <EEPROM.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            // Interne board-LED op pin 13 (voor foutopsporing)
#define PIRA_Pin 2
#define PIRB_Pin 3
#define Num_Stages_per_Module 16
#define LDR_Pin A2                // Analoge pin, waarmee de helderheid moet worden gemeten. (LDR-weerstand)
// #define DEBUG
#define L_Sens_Scope 50
#define MaxInputBufferSize 5 // maximaal 255 tekens aanpassen aan vlcdr


struct WiFiEEPromData
{   // Aanpasbare bedrijfsparameters (constanten)   int Delay_ON_to_OFF = 10;          // Minimale wachttijd tot "Van reeks" in seconden   int Overall_Stages =  8;         // maximaal aantal stappen: 62 x 16 = 992   int delay_per_Stage_in_ms = 100;   int DayLight_Brightness_Border = 600; // Automatische helderheidslimiet - hogere waarde - hogere helderheid   byte Delay_Stages_ON = 20;   byte Delay_Stages_OFF = 20;   char ConfigValid[3]; // Als Config Vaild is, is tag "TK" vereist "
};


// Globale variabelen
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;
dwaas DayLight_Status = waar;
dwaas DLightCntrl = waar;
byte PWM-modules = 0;
byte Stadia Links = 0;
// controle onderbreken
vluchtig byte A60telSeconds24 = 0;
vluchtig byte Seconden24;
// Seriële invoerafhandeling
char TBuffer;
char Cbuffer[MaxInputBufferSize + 1];     // USB-code invoerbuffer
String Sbuffer = "";                      // USB string invoerbuffer
int waarde;                                // USB numerieke invoerbuffer
byte Ccount { 0 };                          // Aantal ontvangen tekens
byte Inptype = 0;
Boolean StrInput = fout;
Boolean Nummer Input = fout;
Boolean Data-invoer = fout;
Boolean Enter-invoer = fout;
byte Menu selectie = 0;
byte MnuState = 0;            // Maximale menudiepte 255 icl sub
WiFiEEPromData MyConfig;


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)
{   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(9600);   pinMode(PIRA_Pin, INVOER);   pinMode(PIRB_Pin, INVOER);   pinMode(OE_Pin, UITGANG);   pinMode(CPU_LED_Pin, UITGANG);   pinMode(LDR_Pin, INVOER);   PWM-modules = MyConfig.Overall_Stages / 16;   Stadia Links = ( MyConfig.Overall_Stages % 16) - 1;   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);   }   als (!(loadEEPROM_Config())) // Load Seetings van EEPROM   {     Serie.println(F("EEPROM-standaardinstellingen opgeslagen."));     MyConfig.Delay_ON_to_OFF = 10;          // Minimale Wartezeit bis zur "Aus Sequenz" in Sekunden     MyConfig.Overall_Stages =  8;         // maximale Stufenanzahl: 62 x 16 = 992     MyConfig.delay_per_Stage_in_ms = 100;     MyConfig.DayLight_Brightness_Border = 600; // Helligkeitsgrenze Automatik - Höherer Wert - Höhere Helligkeit     MyConfig.Delay_Stages_ON = 20;     saveEEPROM_Config();   }   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();   Serie.println(F("Init_Complete"));
}

/ ** Config opslaan in EEPROM * /

dwaas loadEEPROM_Config()
{   dwaas RetValue;   EEPROM.krijgen(0, MyConfig);   EEPROM.einde();   als (Draad(MyConfig.ConfigValid) = Draad("TK"))   {     RetValue = waar;   } anders   {     RetValue = fout; // Instellingen niet gevonden.   }   terug RetValue;
}

/ ** Config opslaan in EEPROM * /
dwaas saveEEPROM_Config()
{   strncpy( MyConfig.ConfigValid , "TK", De grootte van(MyConfig.ConfigValid) );   EEPROM.leggen(0, MyConfig);   EEPROM.einde();   terug waar;
}

dwaas Daglichtstatus ()
{   int Sensorwaarde = 0;   dwaas Winstwaarde = waar;   Sensorwaarde = analoog(LDR_Pin);
#ifdef DEBUG   Serie.afdrukken(F("DayLightStatus:"));   Serie.afdrukken(Sensorwaarde);
#stop als   als (Sensorwaarde > MyConfig.DayLight_Brightness_Border)   {     als ((DayLight_Status) en (Sensorwaarde > MyConfig.DayLight_Brightness_Border + L_Sens_Scope))     {       Winstwaarde = fout;       DayLight_Status = fout;     } anders als (!(DayLight_Status))     {       Winstwaarde = fout;       DayLight_Status = fout;     }
#ifdef DEBUG     Serie.println(F(" UIT"));
#stop als   } anders   {     als ((DayLight_Status) en (Sensorwaarde > MyConfig.DayLight_Brightness_Border - L_Sens_Scope))     {       Winstwaarde = waar;       DayLight_Status = waar;     } anders als (!(DayLight_Status))     {       Winstwaarde = waar;       DayLight_Status = waar;     }
#ifdef DEBUG     Serie.println(F(" AAN"));
#stop als   }   terug Winstwaarde;
}

nietig Down_to_Up_ON()
{
#ifdef DEBUG   Serie.println(F("Down_to_Up_ON"));
#stop als   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 + MyConfig.Delay_Stages_ON;         als (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } anders als ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 0;         vertraging(MyConfig.delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}

nietig Up_to_DOWN_ON()
{
#ifdef DEBUG   Serie.println(F("Up_to_DOWN_ON"));
#stop als   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 + MyConfig.Delay_Stages_ON;         als (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } anders als ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness = 0;         vertraging(MyConfig.delay_per_Stage_in_ms);         Pwm_Channel--;         als ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           breken;         }       }     }     ModuleCount = ModuleCount - 1;   }
}

nietig Down_to_Up_OFF()
{
#ifdef DEBUG   Serie.println(F("Down_to_Up_OFF"));
#stop als   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 - MyConfig.Delay_Stages_OFF;         als (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } anders als ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 4095;         vertraging(MyConfig.delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}

nietig Up_to_DOWN_OFF()
{
#ifdef DEBUG   Serie.println(F("Up_to_DOWN_OFF"));
#stop als   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 - MyConfig.Delay_Stages_OFF;         als (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } anders als ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness =  4095;         vertraging(MyConfig.delay_per_Stage_in_ms);         Pwm_Channel--;         als ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           breken;         }       }     }     ModuleCount = ModuleCount - 1;   }
}

nietig Stages_Light_Control ()
{   als ((Motion_Trigger_Down_to_Up) en !(Met vertraging))   {     DLightCntrl = Daglichtstatus();     als (DLightCntrl)     {       Seconden24 = 0;       Met vertraging = waar;       Down_to_Up_ON();     } anders {       Motion_Trigger_Down_to_Up = fout;     }   }   als ((Met vertraging) en (Seconden24 > MyConfig.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))   {     DLightCntrl = Daglichtstatus();     als (DLightCntrl)     {       Seconden24 = 0;       Met vertraging = waar;       Up_to_DOWN_ON();     } anders {       Motion_Trigger_Up_to_Down = fout;     }   }   als ((Met vertraging) en (Seconden24 > MyConfig.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;   }
}

// Seriële opdrachttolkfuncties -------------------------------

nietig ClearCBuffer ()
{   voor (byte een = 0; MaxInputBufferSize - 1; een++)     Cbuffer[een] = 0;
}

Boolean CheckforserialEvent()
{   terwijl (Serie.beschikbaar()) {     // haal de nieuwe byte:     TBuffer = Serie.lezen();     als (TBuffer > 9 && TBuffer < 14)     {       Cbuffer[Ccount] = 0;       TBuffer = 0;       Serie.afdrukken(char(13));       Serie.blozen();       Serie.println("");       Sbuffer = "";       waarde = 0;       Enter-invoer = waar;       terug waar;     } anders als (TBuffer > 47 && TBuffer < 58 )     {       als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;       } anders {         Serie.afdrukken("#");       }       // Nummerinvoer gedetecteerd       Nummer Input = waar;     }     anders als (TBuffer > 64 && TBuffer < 123 )     {       als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         Serie.afdrukken(char(TBuffer));         Serie.blozen();       }       // Char Char Char Input gedetecteerd       StrInput = waar;     }     anders als ( (TBuffer == 127 )  |  (TBuffer == 8 ) )     {       als ( Ccount > 0)       {         Ccount--;         Cbuffer[Ccount] = 0;         Serie.afdrukken("-");         Serie.blozen();       }     }     anders     {       als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         Serie.afdrukken(char(TBuffer));         Serie.blozen();         // Gegevensinvoer gedetecteerd         Data-invoer = waar;       }       terug fout;     }     terug fout;   }
}

byte SerInputHandler()
{   byte resultaat = 0;   int c;   int d;   int een;   int b;   resultaat = 0;   als (CheckforserialEvent())   {     als ((Nummer Input) en niet (Data-invoer) en niet (StrInput))    //Alleen nummers     {       Sbuffer = "";       waarde = 0;       StrInput = fout;       Nummer Input = fout;       Data-invoer = fout;       Enter-invoer = fout;       een = 0;       b = 0;       c = 0;       d = 0;       Sbuffer = Cbuffer; // Zahl wird AUCH! in SBUFFER übernommen, valt benötigt.       als (Ccount == 1) {         waarde  = Cbuffer[0] - 48 ;       }       als (Ccount == 2) {         een = Cbuffer[0] - 48 ;         een = een * 10;         b = Cbuffer[1] - 48 ;         waarde = een + b;       }       als (Ccount == 3) {         een = Cbuffer[0] - 48 ;         een = een * 100;         b = Cbuffer[1] - 48 ;         b = b * 10;         c = Cbuffer[2] - 48 ;         waarde = een + b + c;       }       als (Ccount == 4) {         een = Cbuffer[0] - 48 ;         een = een * 1000;         b = Cbuffer[1] - 48 ;         b = b * 100;         c = Cbuffer[2] - 48 ;         c = c * 10;         d = Cbuffer[3] - 48 ;         waarde = een + b + c + d;       }       als (Ccount >= 5)       {         Sbuffer = "";         waarde = 0;         Sbuffer = Cbuffer;         ClearCBuffer;         resultaat = 2;       } anders       {         ClearCBuffer;         Ccount = 0;         resultaat = 1;                                                // Nummer retourcode         Nummer Input = fout;         StrInput = fout;         Data-invoer = fout;         Enter-invoer = fout;         Ccount = 0;         terug resultaat;       }     }     als ((StrInput) en niet (Data-invoer))                          // Alleen stringinvoer     {       Sbuffer = "";       Sbuffer = Cbuffer;       waarde = 0;       StrInput = fout;       Nummer Input = fout;       Data-invoer = fout;       Enter-invoer = fout;       Ccount = 0;       ClearCBuffer;       resultaat = 2;                                                 // Nummer retourcode     }     als (Data-invoer) {       Sbuffer = "";       Sbuffer = Cbuffer;       waarde = 0;       StrInput = fout;       Nummer Input = fout;       Data-invoer = fout;       Enter-invoer = fout;       Ccount = 0;       ClearCBuffer;       resultaat = 3;                                               // Nummer retourcode     }     als ((Enter-invoer) en niet (StrInput) en niet (Nummer Input) en niet (Data-invoer))     {       Sbuffer = "";       waarde = 0;       Ccount = 0;       ClearCBuffer;       resultaat = 4;                                               // Nummer retourcode     }     Nummer Input = fout;     StrInput = fout;     Data-invoer = fout;     Enter-invoer = fout;     Ccount = 0;     terug resultaat;   }   terug resultaat;   // Einde CheckforSerialEvent
}

nietig Seriële opdracht Processor()
{   int een;   Inptype = 0;   Inptype = SerInputHandler();   // 0 keine Rückgabe   // 1 nummer   // 2 String   // 3 gegevens   als (Inptype > 0)   {     Menu selectie = 0;     als ((MnuState < 2) && (Inptype == 2)) {       Sbuffer.toUpperCase();  // Voor eenvoudig invoeren van opdrachten     }     als ((Sbuffer == "D") && (MnuState == 0) && (Inptype == 2))   {       Menu selectie = 1;     }     als ((Sbuffer == "O") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 2;     }     als ((Sbuffer == "T") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 3;     }     als ((Sbuffer == "B") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 4;     }     als ((Sbuffer == "N") && (MnuState == 0) && (Inptype == 2))   {       Menu selectie = 5;     }     als ((Sbuffer == "F") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 6;     }     als ((MnuState == 2) && (Inptype == 1))                          {       Menu selectie = 8;     }     als ((MnuState == 3) && (Inptype == 1))                          {       Menu selectie = 9;     }     als ((MnuState == 4) && (Inptype == 1))                          {       Menu selectie = 10;     }     als ((MnuState == 5) && (Inptype == 1))                          {       Menu selectie = 11;     }     als ((MnuState == 6) && (Inptype == 1))                          {       Menu selectie = 12;     }     als ((MnuState == 7) && (Inptype == 1))                          {       Menu selectie = 13;     }     als (MnuState == 10)                                              {       Menu selectie = 21; // Tijd ingesteld     }     als (MnuState == 11)                                              {       Menu selectie = 24; // Tijd ingesteld     }     als (MnuState == 12)                                              {       Menu selectie = 25; // Tijd ingesteld     }     als (MnuState == 13)                                              {       Menu selectie = 27; // Achtergrondset     }     als (MnuState == 14)                                              {       Menu selectie = 29; // ClockFace Set     }     schakelaar (Menu selectie)     {       geval 1:         {           Serie.println("Vertraging AAN naar UIT: (1-65000)");           MnuState = 2;           waarde = 0;           Sbuffer = "";           breken;         }       geval 2:         {           Serie.println("Algemene fasen: (1-992)");           MnuState = 3;           waarde = 0;           Sbuffer = "";           breken;         }       geval 3:         {           Serie.println("Vertraging per fase in ms: (1-65000)");           MnuState = 4;           waarde = 0;           Sbuffer = "";           breken;         }       geval 4:         {           Serie.println("DayLight Brightness Border: (0-65000)");           MnuState = 5;           waarde = 0;           Sbuffer = "";           breken;         }       geval 5:         {           Serie.println("Vertragingsfasen AAN: (1-254)");           MnuState = 6;           waarde = 0;           Sbuffer = "";           breken;         }       geval 6:         {           Serie.println("Vertragingsfasen UIT: (1-254)");           MnuState = 7;           waarde = 0;           Sbuffer = "";           breken;         }       geval 8:         {           MyConfig.Delay_ON_to_OFF = waarde;           saveEEPROM_Config();           Serie.afdrukken(F("Delay_ON_to_OFF ingesteld op:"));           Serie.println(MyConfig.Delay_ON_to_OFF);           MnuState = 0;           Sbuffer = "";           waarde = 0;           breken;         }       geval 9:         {           MyConfig.Overall_Stages = waarde;           saveEEPROM_Config();           Serie.afdrukken(F("Algemene fasen ingesteld op:"));           Serie.println(MyConfig.Overall_Stages);           MnuState = 0;           Sbuffer = "";           waarde = 0;           breken;         }       geval 10:         {           MyConfig.delay_per_Stage_in_ms = waarde;           saveEEPROM_Config();           Serie.afdrukken(F("Vertraging per fase in ms ingesteld op:"));           Serie.println(MyConfig.delay_per_Stage_in_ms);           MnuState = 0;           Sbuffer = "";           waarde = 0;           breken;         }       geval 11:         {           MyConfig.DayLight_Brightness_Border = waarde;           saveEEPROM_Config();           Serie.afdrukken(F("DayLight Brightness Border ingesteld op:"));           Serie.println(MyConfig.DayLight_Brightness_Border);           MnuState = 0;           Sbuffer = "";           waarde = 0;           breken;         }       geval 12:         {           MyConfig.Delay_Stages_ON = waarde;           saveEEPROM_Config();           Serie.afdrukken(F("Vertragingsfasen AAN ingesteld op:"));           Serie.println(MyConfig.Delay_Stages_ON);           MnuState = 0;           Sbuffer = "";           waarde = 0;           breken;         }       geval 13:         {           MyConfig.Delay_Stages_OFF = waarde;           saveEEPROM_Config();           Serie.afdrukken(F("Vertragingsfasen UIT ingesteld op:"));           Serie.println(MyConfig.Delay_Stages_OFF);           MnuState = 0;           Sbuffer = "";           waarde = 0;           breken;         }       standaard:         {           MnuState = 0;           Serie.println(F("-Treppenlichtsteuerung -"));           Serie.afdrukken(F("D - Vertraging AAN tot UIT / Huidige waarde:"));           Serie.println(MyConfig.Delay_ON_to_OFF);           Serie.afdrukken(F("O - Algemene fasen / huidige waarde:"));           Serie.println(MyConfig.Overall_Stages);           Serie.afdrukken(F("T - Vertraging per fase in ms / huidige waarde:"));           Serie.println(MyConfig.delay_per_Stage_in_ms);           Serie.afdrukken(F("B - DayLight Brightness Border / Current Value:"));           Serie.println(MyConfig.DayLight_Brightness_Border );           Serie.afdrukken(F("N - Vertragingsfasen AAN / huidige waarde:"));           Serie.println(MyConfig.Delay_Stages_ON);           Serie.afdrukken(F("F - Vertragingsfasen UIT / Huidige waarde:"));           Serie.println(MyConfig.Delay_Stages_OFF);           Serie.println(F("Typ Cmd en druk op Enter"));           Serie.blozen();           MnuState = 0;           waarde = 0;           Sbuffer = "";         }     }   } // Eingabe erkannt
}

nietig lus()
{   Stages_Light_Control();   Seriële opdracht Processor();
}

 

Nachdem der Code hogelgeladen wurde, können wir uns mit 9600 Baud auf die serielle Schnittstelle verbinden. Nach einem Enter (und inaktivem! Treppenlicht) erscheint folgendes Konfigurationsmenü:

 

Deel 5 - configuratiemenu

 

 

Paramenter

Erklärung

Vertraging AAN naar UIT

Zeit in SEKUNDEN, die die Treppenbeleuchtung vollständig eingeschaltet bleibt

Algemene fasen

Aantal trappen van de trap

Vertraging per fase

Tijd in MILLISECONDEn om te wachten tot de volgende trap wordt benaderd.

Rand van daglichthelderheid

Helderheid waarbij de trapverlichting inactief wordt. Hogere waarde -> hogere helderheid

Vertraging fasen OP

Rel, ik weet niet wat ik moet Vervagen de tijd bij het veranderen van de trap. Hogere waarde - > minder tijd

Vertraging Stadia UIT

Rel, ik weet niet wat ik moet Fading tijd bij het veranderen van de trap. Hogere waarde - > minder tijd

 

Ik wens u veel plezier met de replica. Zoals altijd vindt u alle eerdere projecten onder de GitHub-pagina https://github.com/kuchto

Für arduinoProjekte für fortgeschritteneSensoren

6 Kommentare

Eugen

Eugen

Hallo nochmal! Melde mich, wie versprochen zurück. Habe alles soweit nachgebaut, und es funktioniert alles, bis auf zwei Sachen. Im seriellen Monitor lassen sich die Parameter zwar verändern, leider haben die Änderungen keinerlei Auswirkungen auf den Ablauf des Sketches.
Man kann ändern, was man will, aber das Programm läuft immer nur das eine Szenario ab. Selbst wenn man im Sketch die Variablen verändert, bleibt alles so, wie an Anfang. Mit einer Ausnahme, und zwar die Stufenanzahl lässt sich ändern. Ich weiß nicht, wo der Fehler sich versteckt, vielleicht habe ich etwas falsch gemacht.
Aber: wenn ich den Sketch aus dem Teil 4 hochlade, läuft alles prima und alle Parameter lassen sich wunderbar ändern. Schade, dass es mit dem Seriellen Monitor nicht klappt, aber das Programm aus dem Teil 4 läuft, habe alle Parameter so eingestellt, wie es mir passt.
Vielen Dank für die tolle Anleitung, meine Eltern sind total begeistert!
Viele Grüße

Eugen

Eugen

Hallo Tobias!
Das ist ein super Projekt! So simpel erklärt, so verständlich aufgebaut, einfach toll! Ich bin schon seit 3 Jahren auf der Suche nach einer Anleitung für so eine Treppenbeleuchtung. Eigentlich wollte ich selbständig versuchen, so ein Projekt zu entwickeln, leider fehlte mir immer die Zeit dafür. Jetzt bin ich überzeugt, dass ich es auf jeden Fall nachbauen werde. Die Bauteile sind schon bestellt, ich kann es kaum abwarten, loszulegen! Ich melde mich auf jeden Fall wieder, wenn ich es geschafft habe. Möchte mich aber jetzt schon herzlich bedanken!

Sebastian

Sebastian

Super interessantes Projekt. Ich hoffe dass das Thema W-lan und MQTT noch aufgegriffen wird und genau so genial erklärt wird, wie die anderen Projekte.

Helmut Tack

Helmut Tack

Bei dem Uno (Auslieferung vor 2018) gibt es Problem mit dem Hochladen.
Lösung hier https://forum.digikey.com/t/january-2018-arduino-nano-bootloader-update/1194

Wolfgang

Wolfgang

Super Projekt !!

Das ganze jetzt noch mit Wlan,
dann wäre es perfekt !!!!

LG
Wolfgang

stsc

stsc

Ein NodeMCU mit Steuerung per MQTT wäre auch interessant. Dann könnte man die Treppe in das Homesteuerungssystem einbinden.

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Aanbevolen blog berichten

  1. Installeer ESP32 nu van de raad van bestuur
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP Programmeren via Wi-Fi