Elegante automatische trapverlichting (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:

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

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ü:

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