Elegante illuminazione automatica delle scale (parte5)

Salve e benvenuti all'ultima parte della serie "elegante illuminazione automatica delle scale".

Oggi, contraiamo il nostro sistema di controllo con una comoda opzione di configurazione per tutti i parametri di funzionamento. Tutti i parametri operativi possono ora essere comodamente impostati tramite l'interfaccia seriale a riposo (tutte le luci delle scale inattive) e sono memorizzati nell'EEPROM interno degli uC. Pertanto, tutte le impostazioni vengono mantenute anche in caso di riavvio o interruzione dell'alimentazione. Tutti i parametri regolabili sono spiegati singolarmente alla fine del documento. Poiché la funzione è completamente realizzata nel software, la struttura tecnica non cambia rispetto alla parte 4 della serie. Tuttavia, per motivi di completezza, questo dovrebbe essere presentato di nuovo:

L'elenco dei componenti per il progetto e tutti i suggerimenti delle parti precedenti non cambiare:

Può essere Senza regolazione preventiva il seguente codice può essere caricato su Arduino:

#include <Filo.H>
#include <Eeprom.H>

# define PWM_Module_Base_Addr 0x40 (in questo 0x40) 10000000b L'ultimo bit del byte dell'indirizzo definisce l'operazione da eseguire. Se impostato su logico 1 0x41 modulo 2 ecc. Intervallo di indirizzi0x40 - 0x47 
seleziona un'operazione di lettura mentre uno 0 logico seleziona un'operazione di scrittura.
# define OE_Pin  8                 Perno per l'abilitazione dell'uscita 
# define CPU_LED_Pin 13            LED della scheda interna al pin 13 (a scopo di debug)
# define PIRA_Pin 2
# define PIRB_Pin 3
# define Num_Stages_per_Module 16
# define LDR_Pin A2 (in modo inade                Pin analogico per misurare la luminosità. (Rienergismo LDR)
#define DEBUG
# define L_Sens_Scope 50
# define MaxInputBufferSize 5 massimo 255 caratteri per adattarsi a vlcdr


Struct WiFiEEPromData
{   Parametri operativi regolabili (costanti)   Int Delay_ON_to_OFF = 10;          Tempo minimo di attesa per la "Sequenza di spegnimento" in secondi   Int Overall_Stages =  8;         numero massimo di passi: 62 x 16   Int delay_per_Stage_in_ms = 100;   Int DayLight_Brightness_Border = 600; Limite di luminosità automatico - Valore più alto - Luminosità più alta   Byte Delay_Stages_ON = 20;   Byte Delay_Stages_OFF = 20;   Char ConfigValid (Valido)[3]; Se Config è Vaild, è necessario il tag "TK""
};


Variabili globali
Int Pwm_Channel = 0;
Int Pwm_Channel_Brightness = 0;
Bool Motion_Trigger_Down_to_Up = False;
Bool Motion_Trigger_Up_to_Down = False;
Bool On_Delay = False;
Bool DayLight_Status = Vero;
Bool DLightCntrl = Vero;
Byte PWMModules = 0;
Byte Fasi sinistra = 0;
controllo interrupt
Volatile Byte A60telSeconds24 = 0;
Volatile Byte Secondi24;
Gestione dell'input seriale
Char TBuffer (TBuffer);
Char Cbuffer (Cbuffer)[MaxInputBufferSize + 1];     Buffer di input codice USB
Stringa Buffer = "";                      Buffer di input stringa USB
Int Valore;                                USB Nummeric Input Buffer
Byte Conteggio cconteggio { 0 };                          Numero ricevuto Chars
Byte Inptype (Inptype) = 0;
Boolean StrInput = False;
Boolean NumeroIngresso = False;
Boolean DataInput (Input dati) = False;
Boolean Input enter = False;
Byte MenueSelezione = 0;
Byte MnuState = 0;            Profondità massima del menu 255 icl Sub
WiFiEEPromData MyConfig (configurazione in stato di in;


Pvr(TIMER1_COMPA_vect)
{   A60telSeconds24++;   Se (A60telSeconds24 > 59)   {     A60telSeconds24 = 0;     Secondi24++;     Se (Secondi24 > 150)     {       Secondi24 = 0;     }   }
}

Vuoto ISR_PIR_A()
{   Bool PinState = digitalRead (Lettura digitale)(PIRA_Pin);   Se (PinState)   {     Se (!(Motion_Trigger_Up_to_Down) E !(Motion_Trigger_Down_to_Up))     {       digitalWrite (Scrittura digitale)(CPU_LED_Pin, alto);       Motion_Trigger_Down_to_Up = Vero;     } PIR A attivato   } Altro   {     digitalWrite (Scrittura digitale)(CPU_LED_Pin, Basso);   }
}

Vuoto ISR_PIR_B()
{   Bool PinState = digitalRead (Lettura digitale)(PIRB_Pin);   Se (PinState)   {     Se (!(Motion_Trigger_Down_to_Up) E !(Motion_Trigger_Up_to_Down))     {       digitalWrite (Scrittura digitale)(CPU_LED_Pin, alto);       Motion_Trigger_Up_to_Down = Vero;     } PIR B attivato   } Altro   {     digitalWrite (Scrittura digitale)(CPU_LED_Pin, Basso);   }
}

Vuoto Init_PWM_Module(Byte PWM_ModuleAddr)
{   digitalWrite (Scrittura digitale)(OE_Pin, alto); Pin di attivazione dell'uscita LOW attivo (OE).   Filo.beginTransmission(PWM_ModuleAddr); Avviare il trasferimento dei dati   Filo.Scrivere(0x00 (in questo 0x00));                       //   Filo.Scrivere(0x06 (in inglese));                       Ripristino del software   Filo.endTransmission();                 Interrompi comunicazione - Invia bit di arresto   Ritardo(400);   Filo.beginTransmission(PWM_ModuleAddr); Avviare il trasferimento dei dati   Filo.Scrivere(0x01 (in tissuta (in ti);                       Selezionare la modalità 2 Registro (Registro comandi)   Filo.Scrivere(0x04 (in tissuta 0x0);                       Chip di configurazione: 0x04: uscita palo morto 0x00: Uscita di scarico aperta.   Filo.endTransmission();                 Interrompi comunicazione - Invia bit di arresto   Filo.beginTransmission(PWM_ModuleAddr); Avviare il trasferimento dei dati   Filo.Scrivere(0x00 (in questo 0x00));                      Selezionare Modalità 1 Registro (Registro comandi)   Filo.Scrivere(0x10 (in modo 0x10));                      Configurare SleepMode   Filo.endTransmission();                Interrompi comunicazione - Invia bit di arresto   Filo.beginTransmission(PWM_ModuleAddr); Avviare il trasferimento dei dati   Filo.Scrivere(0xFE (in modo 0xFE));                       Seleziona PRE_SCALE registro   Filo.Scrivere(0x03 (in tissuta (in ti);                       Impostare Prescaler. La frequenza PWM massima è 1526 Hz se il PRE_SCALEer l'operatore è impostato su "0x03h". Standard: 200 Hz   Filo.endTransmission();                 Interrompi comunicazione - Invia bit di arresto   Filo.beginTransmission(PWM_ModuleAddr); Avviare il trasferimento dei dati   Filo.Scrivere(0x00 (in questo 0x00));                       Selezionare Modalità 1 Registro (Registro comandi)   Filo.Scrivere(0xA1 (in modo 0xA1));                       Configura chip: ERrlaube Tutti gli indirizzi I2C chiamata, utilizzare l'orologio interno, / Consenti funzione di incremento automatico   Filo.endTransmission();                 Interrompi comunicazione - Invia bit di arresto
}


Vuoto Init_PWM_Outputs(Byte PWM_ModuleAddr)
{   digitalWrite (Scrittura digitale)(OE_Pin, alto); Pin di attivazione dell'uscita LOW attivo (OE).   Per ( Int Z = 0; Z < 16 + 1; Z++)   {     Filo.beginTransmission(PWM_ModuleAddr);     Filo.Scrivere(Z * 4 + 6);      Seleziona PWM_Channel_ON_L registro     Filo.Scrivere(0x00 (in questo 0x00));                     Valore per il registro sopra     Filo.endTransmission();     Filo.beginTransmission(PWM_ModuleAddr);     Filo.Scrivere(Z * 4 + 7);      Seleziona PWM_Channel_ON_H registratore di cassa     Filo.Scrivere(0x00 (in questo 0x00));                     Valore per il registro sopra     Filo.endTransmission();     Filo.beginTransmission(PWM_ModuleAddr);     Filo.Scrivere(Z * 4 + 8);   Seleziona PWM_Channel_OFF_L registrato     Filo.Scrivere(0x00 (in questo 0x00));        Valore per il registro sopra     Filo.endTransmission();     Filo.beginTransmission(PWM_ModuleAddr);     Filo.Scrivere(Z * 4 + 9);  Seleziona PWM_Channel_OFF_H registro     Filo.Scrivere(0x00 (in questo 0x00));             Valore per il registro sopra     Filo.endTransmission();   }   digitalWrite (Scrittura digitale)(OE_Pin, Basso); Pin di attivazione dell'uscita LOW attivo (OE).
}

Vuoto Installazione()
{   Inializzazione   Seriale.Iniziare(9600);   PinMode (Modalità pin)(PIRA_Pin, Input);   PinMode (Modalità pin)(PIRB_Pin, Input);   PinMode (Modalità pin)(OE_Pin, Output);   PinMode (Modalità pin)(CPU_LED_Pin, Output);   PinMode (Modalità pin)(LDR_Pin, Input);   PWMModules = MyConfig (configurazione in stato di in.Overall_Stages / 16;   Fasi sinistra = ( MyConfig (configurazione in stato di in.Overall_Stages % 16) - 1;   Se (Fasi sinistra >= 1) {     PWMModules++;   }   Filo.Iniziare(); Initalisia I2C Bus A4 (SDA), A5 (SCL)   Per (Byte ModuleCount (Conteggio moduli) = 0; ModuleCount (Conteggio moduli) < PWMModules; ModuleCount (Conteggio moduli)++)   {     Init_PWM_Module(PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));     Init_PWM_Outputs(PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));   }   Se (!(loadEEPROM_Config())) Caricamento delle trapunte da EEPROM   {     Seriale.println(D("Impostazioni standard EEPROM salvate."));     MyConfig (configurazione in stato di in.Delay_ON_to_OFF = 10;          Minimo Wartezeit bis zur "Aus Sequenz" a Sekunden     MyConfig (configurazione in stato di in.Overall_Stages =  8;         massimo Stufenanzahl: 62 x 16     MyConfig (configurazione in stato di in.delay_per_Stage_in_ms = 100;     MyConfig (configurazione in stato di in.DayLight_Brightness_Border = 600; Helligkeitsgrenze Automatik - H'herer Wert - Hohere Helligkeit     MyConfig (configurazione in stato di in.Delay_Stages_ON = 20;     saveEEPROM_Config();   }   noInterruzioni();   attachInterrupt (attachInterrupt)(0, ISR_PIR_A, Cambiare);   attachInterrupt (attachInterrupt)(1, ISR_PIR_B, Cambiare);   TCCR1A = 0x00 (in questo 0x00);   TCCR1B = 0x02 (in tissuta 0x0;   TCNT1 (in questo stato in stato di = 0;      Registrare mit 0 initialisieren   OCR1A =  33353;      Output Compare Register vorbelegen   TIMSK1 |= (1 << CIE1A);  Timer Confronta Interrupt aktivieren   Interrompe();   Seriale.println(F("Init_Complete"));
}

/- Salva Config in EEPROM

Bool loadEEPROM_Config()
{   Bool RetValue (RetValue);   Eeprom.Ottieni(0, MyConfig (configurazione in stato di in);   Eeprom.Fine();   Se (Stringa(MyConfig (configurazione in stato di in.ConfigValid (Valido)) = Stringa("TK"))   {     RetValue (RetValue) = Vero;   } Altro   {     RetValue (RetValue) = False; Impostazioni non trovate.   }   Ritorno RetValue (RetValue);
}

/z: Memorizza la configurazione in EEPROM
Bool saveEEPROM_Config()
{   Strncpy( MyConfig (configurazione in stato di in.ConfigValid (Valido) , "TK", Sizeof(MyConfig (configurazione in stato di in.ConfigValid (Valido)) );   Eeprom.Mettere(0, MyConfig (configurazione in stato di in);   Eeprom.Fine();   Ritorno Vero;
}

Bool Stato di DayLight ()
{   Int SensorValue (Valore sensore) = 0;   Bool Returnvalue = Vero;   SensorValue (Valore sensore) = analogicOLettura(LDR_Pin);
#ifdef DEBUG   Seriale.Stampare(F("DayLightStatus: "));   Seriale.Stampare(SensorValue (Valore sensore));
#endif   Se (SensorValue (Valore sensore) > MyConfig (configurazione in stato di in.DayLight_Brightness_Border)   {     Se ((DayLight_Status) E (SensorValue (Valore sensore) > MyConfig (configurazione in stato di in.DayLight_Brightness_Border + L_Sens_Scope))     {       Returnvalue = False;       DayLight_Status = False;     } Altro Se (!(DayLight_Status))     {       Returnvalue = False;       DayLight_Status = False;     }
#ifdef DEBUG     Seriale.println(F("OFF"));
#endif   } Altro   {     Se ((DayLight_Status) E (SensorValue (Valore sensore) > MyConfig (configurazione in stato di in.DayLight_Brightness_Border - L_Sens_Scope))     {       Returnvalue = Vero;       DayLight_Status = Vero;     } Altro Se (!(DayLight_Status))     {       Returnvalue = Vero;       DayLight_Status = Vero;     }
#ifdef DEBUG     Seriale.println(F("ON"));
#endif   }   Ritorno Returnvalue;
}

Vuoto Down_to_Up_ON()
{
#ifdef DEBUG   Seriale.println(F("Down_to_Up_ON"));
#endif   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Per (byte ModuleCount (Conteggio moduli) = 0; ModuleCount (Conteggio moduli) < PWMModules; ModuleCount (Conteggio moduli)++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     Se ((Fasi sinistra >= 1) E (ModuleCount (Conteggio moduli) == PWMModules - 1))     {       Calc_Num_Stages_per_Module = Fasi sinistra;     }     Altro     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = 0;     Pwm_Channel_Brightness = 0;     Mentre (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Filo.beginTransmission( PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 8);   Registro PWM_Channel_0_OFF_L di W'hle       Filo.Scrivere((byte)Pwm_Channel_Brightness & 0xff);        Registro Wert f'r o.g.       Filo.endTransmission();       Filo.beginTransmission( PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 9);  Registro PWM_Channel_0_OFF_H W'hle       Filo.Scrivere((Pwm_Channel_Brightness >> 8));             Registro Wert f'r o.g.       Filo.endTransmission();       Se (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + MyConfig (configurazione in stato di in.Delay_Stages_ON;         Se (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } Altro Se ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 0;         Ritardo(MyConfig (configurazione in stato di in.delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}

Vuoto Up_to_DOWN_ON()
{
#ifdef DEBUG   Seriale.println(F("Up_to_DOWN_ON"));
#endif   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Int ModuleCount (Conteggio moduli) = PWMModules - 1;   Mentre (ModuleCount (Conteggio moduli) >= 0)   {     Pwm_Channel_Brightness = 0;     Se ((Fasi sinistra >= 1) E (ModuleCount (Conteggio moduli) == PWMModules - 1))     {       Calc_Num_Stages_per_Module =  Fasi sinistra;     }     Altro     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     Mentre (Pwm_Channel > -1)     {       Filo.beginTransmission( PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 8);   Registro PWM_Channel_0_OFF_L di W'hle       Filo.Scrivere((byte)Pwm_Channel_Brightness & 0xff);        Registro Wert f'r o.g.       Filo.endTransmission();       Filo.beginTransmission(PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 9);  Registro PWM_Channel_0_OFF_H W'hle       Filo.Scrivere((Pwm_Channel_Brightness >> 8));             Registro Wert f'r o.g.       Filo.endTransmission();       Se (Pwm_Channel_Brightness < 4095)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness + MyConfig (configurazione in stato di in.Delay_Stages_ON;         Se (Pwm_Channel_Brightness > 4095) {           Pwm_Channel_Brightness = 4095;         }       } Altro Se ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness = 0;         Ritardo(MyConfig (configurazione in stato di in.delay_per_Stage_in_ms);         Pwm_Channel--;         Se ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           Pausa;         }       }     }     ModuleCount (Conteggio moduli) = ModuleCount (Conteggio moduli) - 1;   }
}

Vuoto Down_to_Up_OFF()
{
#ifdef DEBUG   Seriale.println(F("Down_to_Up_OFF"));
#endif   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Per (byte ModuleCount (Conteggio moduli) = 0; ModuleCount (Conteggio moduli) < PWMModules; ModuleCount (Conteggio moduli)++)   {     Pwm_Channel = 0;     Pwm_Channel_Brightness = 4095;     Se ((Fasi sinistra >= 1) E (ModuleCount (Conteggio moduli) == PWMModules - 1))     {       Calc_Num_Stages_per_Module = Fasi sinistra;     }     Altro     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Mentre (Pwm_Channel < Calc_Num_Stages_per_Module + 1)     {       Filo.beginTransmission( PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 8);   Registro PWM_Channel_0_OFF_L di W'hle       Filo.Scrivere((byte)Pwm_Channel_Brightness & 0xff);        Registro Wert f'r o.g.       Filo.endTransmission();       Filo.beginTransmission(PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 9);  Registro PWM_Channel_0_OFF_H W'hle       Filo.Scrivere((Pwm_Channel_Brightness >> 8));             Registro Wert f'r o.g.       Filo.endTransmission();       Se (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - MyConfig (configurazione in stato di in.Delay_Stages_OFF;         Se (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } Altro Se ( Pwm_Channel < Num_Stages_per_Module + 1)       {         Pwm_Channel_Brightness = 4095;         Ritardo(MyConfig (configurazione in stato di in.delay_per_Stage_in_ms);         Pwm_Channel++;       }     }   }
}

Vuoto Up_to_DOWN_OFF()
{
#ifdef DEBUG   Seriale.println(F("Up_to_DOWN_OFF"));
#endif   byte Calc_Num_Stages_per_Module = Num_Stages_per_Module;   Int ModuleCount (Conteggio moduli) = PWMModules - 1;   Mentre (ModuleCount (Conteggio moduli) >= 0)   {     Pwm_Channel_Brightness = 4095;     Se ((Fasi sinistra >= 1) E (ModuleCount (Conteggio moduli) == PWMModules - 1))     {       Calc_Num_Stages_per_Module = Fasi sinistra;     }     Altro     {       Calc_Num_Stages_per_Module = Num_Stages_per_Module;     }     Pwm_Channel = Calc_Num_Stages_per_Module;     Mentre (Pwm_Channel > -1)     {       Filo.beginTransmission(PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 8);   Registro PWM_Channel_0_OFF_L di W'hle       Filo.Scrivere((byte)Pwm_Channel_Brightness & 0xff);        Registro Wert f'r o.g.       Filo.endTransmission();       Filo.beginTransmission(PWM_Module_Base_Addr + ModuleCount (Conteggio moduli));       Filo.Scrivere(Pwm_Channel * 4 + 9);  Registro PWM_Channel_0_OFF_H W'hle       Filo.Scrivere((Pwm_Channel_Brightness >> 8));             Registro Wert f'r o.g.       Filo.endTransmission();       Se (Pwm_Channel_Brightness > 0)       {         Pwm_Channel_Brightness = Pwm_Channel_Brightness - MyConfig (configurazione in stato di in.Delay_Stages_OFF;         Se (Pwm_Channel_Brightness < 0) {           Pwm_Channel_Brightness = 0;         }       } Altro Se ( Pwm_Channel >= 0)       {         Pwm_Channel_Brightness =  4095;         Ritardo(MyConfig (configurazione in stato di in.delay_per_Stage_in_ms);         Pwm_Channel--;         Se ( Pwm_Channel < 0)         {           Pwm_Channel = 0;           Pausa;         }       }     }     ModuleCount (Conteggio moduli) = ModuleCount (Conteggio moduli) - 1;   }
}

Vuoto Stages_Light_Control ()
{   Se ((Motion_Trigger_Down_to_Up) E !(On_Delay))   {     DLightCntrl = Stato di DayLight();     Se (DLightCntrl)     {       Secondi24 = 0;       On_Delay = Vero;       Down_to_Up_ON();     } Altro {       Motion_Trigger_Down_to_Up = False;     }   }   Se ((On_Delay) E (Secondi24 > MyConfig (configurazione in stato di in.Delay_ON_to_OFF) E (Motion_Trigger_Down_to_Up) )   {     Down_to_Up_OFF();     Motion_Trigger_Down_to_Up = False;     On_Delay = False;     Secondi24 = 0;   }   Se ((Motion_Trigger_Up_to_Down) E !(On_Delay))   {     DLightCntrl = Stato di DayLight();     Se (DLightCntrl)     {       Secondi24 = 0;       On_Delay = vero;       Up_to_DOWN_ON();     } altro {       Motion_Trigger_Up_to_Down = falso;     }   }   Se ((In ritardo) e (Seconds24 > MyConfig.Delay_ON_to_OFF) e (Motion_Trigger_Up_to_Down))   {     Up_to_DOWN_OFF();     Motion_Trigger_Up_to_Down = falso;     In ritardo = falso;     Seconds24 = 0;   }
}

// Funzioni dell'interprete dei comandi seriali -------------------------------

vuoto ClearCBuffer ()
{   per (byte un' = 0; MaxInputBufferSize - 1; un'++)     Cbuffer[un'] = 0;
}

booleano CheckforserialEvent()
{   mentre (Seriale.a disposizione()) {     // ottieni il nuovo byte:     TBuffer = Seriale.leggere();     Se (TBuffer > 9 && TBuffer < 14)     {       Cbuffer[CCOUNT] = 0;       TBuffer = 0;       Seriale.Stampa(carbonizzare(13));       Seriale.sciacquone();       Seriale.println("");       sBuffer = "";       valore = 0;       ENTERINPUT = vero;       ritorno vero;     } altro Se (TBuffer > 47 && TBuffer < 58 )     {       Se ( CCOUNT < MaxInputBufferSize)       {         Cbuffer[CCOUNT] = TBuffer;         CCOUNT++;       } altro {         Seriale.Stampa("#");       }       // Numero rilevato       NumberInput = vero;     }     altro Se (TBuffer > 64 && TBuffer < 123 )     {       Se ( CCOUNT < MaxInputBufferSize)       {         Cbuffer[CCOUNT] = TBuffer;         CCOUNT++;         Seriale.Stampa(carbonizzare(TBuffer));         Seriale.sciacquone();       }       // Input caratteri Char rilevato       StrInput = vero;     }     altro Se ( (TBuffer == 127 )  |  (TBuffer == 8 ) )     {       Se ( CCOUNT > 0)       {         CCOUNT--;         Cbuffer[CCOUNT] = 0;         Seriale.Stampa("-");         Seriale.sciacquone();       }     }     altro     {       Se ( CCOUNT < MaxInputBufferSize)       {         Cbuffer[CCOUNT] = TBuffer;         CCOUNT++;         Seriale.Stampa(carbonizzare(TBuffer));         Seriale.sciacquone();         // Inserimento dati rilevato         Inserimento dati = vero;       }       ritorno falso;     }     ritorno falso;   }
}

byte SerInputHandler()
{   byte risultato = 0;   int c;   int d;   int un';   int B;   risultato = 0;   Se (CheckforserialEvent())   {     Se ((NumberInput) e non (Inserimento dati) e non (StrInput))    //Solo numeri     {       sBuffer = "";       valore = 0;       StrInput = falso;       NumberInput = falso;       Inserimento dati = falso;       ENTERINPUT = falso;       un' = 0;       B = 0;       c = 0;       d = 0;       sBuffer = Cbuffer; // Zahl wird AUCH! a SBUFFER übernommen, cade benötigt.       Se (CCOUNT == 1) {         valore  = Cbuffer[0] - 48 ;       }       Se (CCOUNT == 2) {         un' = Cbuffer[0] - 48 ;         un' = un' * 10;         B = Cbuffer[1] - 48 ;         valore = un' + B;       }       Se (CCOUNT == 3) {         un' = Cbuffer[0] - 48 ;         un' = un' * 100;         B = Cbuffer[1] - 48 ;         B = B * 10;         c = Cbuffer[2] - 48 ;         valore = un' + B + c;       }       Se (CCOUNT == 4) {         un' = Cbuffer[0] - 48 ;         un' = un' * 1000;         B = Cbuffer[1] - 48 ;         B = B * 100;         c = Cbuffer[2] - 48 ;         c = c * 10;         d = Cbuffer[3] - 48 ;         valore = un' + B + c + d;       }       Se (CCOUNT >= 5)       {         sBuffer = "";         valore = 0;         sBuffer = Cbuffer;         ClearCBuffer;         risultato = 2;       } altro       {         ClearCBuffer;         CCOUNT = 0;         risultato = 1;                                                // Numero codice di ritorno         NumberInput = falso;         StrInput = falso;         Inserimento dati = falso;         ENTERINPUT = falso;         CCOUNT = 0;         ritorno risultato;       }     }     Se ((StrInput) e non (Inserimento dati))                          // Solo input stringa     {       sBuffer = "";       sBuffer = Cbuffer;       valore = 0;       StrInput = falso;       NumberInput = falso;       Inserimento dati = falso;       ENTERINPUT = falso;       CCOUNT = 0;       ClearCBuffer;       risultato = 2;                                                 // Numero codice di ritorno     }     Se (Inserimento dati) {       sBuffer = "";       sBuffer = Cbuffer;       valore = 0;       StrInput = falso;       NumberInput = falso;       Inserimento dati = falso;       ENTERINPUT = falso;       CCOUNT = 0;       ClearCBuffer;       risultato = 3;                                               // Numero codice di ritorno     }     Se ((ENTERINPUT) e non (StrInput) e non (NumberInput) e non (Inserimento dati))     {       sBuffer = "";       valore = 0;       CCOUNT = 0;       ClearCBuffer;       risultato = 4;                                               // Numero codice di ritorno     }     NumberInput = falso;     StrInput = falso;     Inserimento dati = falso;     ENTERINPUT = falso;     CCOUNT = 0;     ritorno risultato;   }   ritorno risultato;   // End CheckforSerialEvent
}

vuoto SerialcommandProcessor()
{   int un';   Inptype = 0;   Inptype = SerInputHandler();   // 0 keine Rückgabe   // 1 Nummer   // 2 String   // 3 Dati   Se (Inptype > 0)   {     MenueSelection = 0;     Se ((MnuState < 2) && (Inptype == 2)) {       sBuffer.toUpperCase();  // Per comandi di facile inserimento     }     Se ((sBuffer == "D") && (MnuState == 0) && (Inptype == 2))   {       MenueSelection = 1;     }     Se ((sBuffer == "O") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 2;     }     Se ((sBuffer == "T") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 3;     }     Se ((sBuffer == "B") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 4;     }     Se ((sBuffer == "N") && (MnuState == 0) && (Inptype == 2))   {       MenueSelection = 5;     }     Se ((sBuffer == "F") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 6;     }     Se ((MnuState == 2) && (Inptype == 1))                          {       MenueSelection = 8;     }     Se ((MnuState == 3) && (Inptype == 1))                          {       MenueSelection = 9;     }     Se ((MnuState == 4) && (Inptype == 1))                          {       MenueSelection = 10;     }     Se ((MnuState == 5) && (Inptype == 1))                          {       MenueSelection = 11;     }     Se ((MnuState == 6) && (Inptype == 1))                          {       MenueSelection = 12;     }     Se ((MnuState == 7) && (Inptype == 1))                          {       MenueSelection = 13;     }     Se (MnuState == 10)                                              {       MenueSelection = 21; // Impostazione dell'ora     }     Se (MnuState == 11)                                              {       MenueSelection = 24; // Impostazione dell'ora     }     Se (MnuState == 12)                                              {       MenueSelection = 25; // Impostazione dell'ora     }     Se (MnuState == 13)                                              {       MenueSelection = 27; // Set di sfondi     }     Se (MnuState == 14)                                              {       MenueSelection = 29; // ClockFace Set     }     interruttore (MenueSelection)     {       Astuccio 1:         {           Seriale.println("Ritardo da ON a OFF: (1-65000)");           MnuState = 2;           valore = 0;           sBuffer = "";           rompere;         }       Astuccio 2:         {           Seriale.println("Fasi complessive: (1-992)");           MnuState = 3;           valore = 0;           sBuffer = "";           rompere;         }       Astuccio 3:         {           Seriale.println("Ritardo per stage in ms: (1-65000)");           MnuState = 4;           valore = 0;           sBuffer = "";           rompere;         }       Astuccio 4:         {           Seriale.println("Bordo luminosità DayLight: (0-65000)");           MnuState = 5;           valore = 0;           sBuffer = "";           rompere;         }       Astuccio 5:         {           Seriale.println("Ritardo fasi ON: (1-254)");           MnuState = 6;           valore = 0;           sBuffer = "";           rompere;         }       Astuccio 6:         {           Seriale.println("Ritardo fasi OFF: (1-254)");           MnuState = 7;           valore = 0;           sBuffer = "";           rompere;         }       Astuccio 8:         {           MyConfig.Delay_ON_to_OFF = valore;           saveEEPROM_Config();           Seriale.Stampa(F("Delay_ON_to_OFF impostato su:"));           Seriale.println(MyConfig.Delay_ON_to_OFF);           MnuState = 0;           sBuffer = "";           valore = 0;           rompere;         }       Astuccio 9:         {           MyConfig.Overall_Stages = valore;           saveEEPROM_Config();           Seriale.Stampa(F("Fasi complessive impostate su:"));           Seriale.println(MyConfig.Overall_Stages);           MnuState = 0;           sBuffer = "";           valore = 0;           rompere;         }       Astuccio 10:         {           MyConfig.delay_per_Stage_in_ms = valore;           saveEEPROM_Config();           Seriale.Stampa(F("Ritardo per stage in ms impostato su:"));           Seriale.println(MyConfig.delay_per_Stage_in_ms);           MnuState = 0;           sBuffer = "";           valore = 0;           rompere;         }       Astuccio 11:         {           MyConfig.DayLight_Brightness_Border = valore;           saveEEPROM_Config();           Seriale.Stampa(F("Bordo luminosità DayLight impostato su:"));           Seriale.println(MyConfig.DayLight_Brightness_Border);           MnuState = 0;           sBuffer = "";           valore = 0;           rompere;         }       Astuccio 12:         {           MyConfig.Delay_Stages_ON = valore;           saveEEPROM_Config();           Seriale.Stampa(F("Delay Stages ON impostato su:"));           Seriale.println(MyConfig.Delay_Stages_ON);           MnuState = 0;           sBuffer = "";           valore = 0;           rompere;         }       Astuccio 13:         {           MyConfig.Delay_Stages_OFF = valore;           saveEEPROM_Config();           Seriale.Stampa(F("Le fasi di ritardo OFF sono impostate su:"));           Seriale.println(MyConfig.Delay_Stages_OFF);           MnuState = 0;           sBuffer = "";           valore = 0;           rompere;         }       predefinito:         {           MnuState = 0;           Seriale.println(F("-Treppenlichtsteuerung -"));           Seriale.Stampa(F("D - Ritardo da ON a OFF / Valore corrente:"));           Seriale.println(MyConfig.Delay_ON_to_OFF);           Seriale.Stampa(F("O - Fasi complessive / valore corrente:"));           Seriale.println(MyConfig.Overall_Stages);           Seriale.Stampa(F("T - Ritardo per stadio in ms / Valore corrente:"));           Seriale.println(MyConfig.delay_per_Stage_in_ms);           Seriale.Stampa(F("B - Bordo luminosità DayLight / Valore corrente:"));           Seriale.println(MyConfig.DayLight_Brightness_Border );           Seriale.Stampa(F("N - Ritardo fasi ON / Valore corrente:"));           Seriale.println(MyConfig.Delay_Stages_ON);           Seriale.Stampa(F("F - Ritardo fasi OFF / Valore corrente:"));           Seriale.println(MyConfig.Delay_Stages_OFF);           Seriale.println(F("Digita Cmd e premi Invio"));           Seriale.sciacquone();           MnuState = 0;           valore = 0;           sBuffer = "";         }     }   } // Eingabe erkannt
}

vuoto ciclo continuo()
{   Stages_Light_Control();   SerialcommandProcessor();
}

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

Mi auguro tanto Divertimento durante la Riproduzione. Come sempre, troverete anche tutti i precedenti Progetti GitHub Pagina https://github.com/kuchto