Elegante illuminazione automatica delle scale (parte-5)

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:

Immagine dalla parte 4

 

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

 

Numero

Descrizione

Nota

2

Pir Modulo HC-SR501 PIR

Sensore di movimento

fino a 62

PCA9685 16 Canale 12 Bit PWM Driver

Numero a seconda del numero di scale /16

1

Nano V3

 

1

Adattatore di alimentazione MB102

Per la configurazione della breadboard

fino a 992

Modulo driver MOS IRF520 0-24V 5A

Numero a seconda del numero di scale

1

Alimentazione per LED/lampade per i gradini

Massimo 24 volt

1

10 KOhm Rivincita

 

1

Ldr

Re-stand fotografico

 

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

 

Parte 5 - Menu di configurazione

 

 

paramenter

Erklärung

Ritarda da ON a OFF

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

Fasi generali

Numero di Gradini delle Scale

Delay tramite Stage

di Tempo, espresso in MILLISECONDI, attesa per la prossima Scale controllato.

Daylight Brightness Border

Luminosità, la Treppenbeleuchtung inattivo. Maggiore Wertz -> maggiore Luminosità

Delay Stages ON

rel. Fadingzeit all'ACCENSIONE delle Scale. Maggiore è il Valore - > minore Tempo di

Delay Stages OFF

rel. Fadingzeit allo SPEGNIMENTO delle Scale. Maggiore è il Valore - > minore Tempo

 

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

Für arduinoProjekte für fortgeschritteneSensoren

4 Kommentare

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