Giusto Claudio
Infatti poi ci sono le differenze con i cablaggi reali soprattutto i tempi ed i componenti a disposizione.
Però per iniziare è ottimo,soprattutto per chi non ha dimestichezza.
Puoi aiutarmi in Array...mi sono un pò bloccato.
Allora ricapitolando tu vuoi un led che
in base a notte e giorno si deve spegnere e riaccendere
lo faccia con fading
e lo faccia cambiando dinamicamente le attese di accensione e spegnimento in base alla stagione.
Allora parto dal mio codice mandato a suggerimento inizialmente, ovvero questo.
/*Partendo dal fatto che tu devi avere un effetto alba tramonto e quindi
i due valori di attesa sono decisamente diversi devi impostare due attese diverse
e quindi il codice deve sapere se sei in un momento che deve accendere il led
piuttosto che spegnerlo. Adesso il codice porta come 5 secondi di luce e quindi il led
spento e 3 secondi di buio e quindi 3 secondi di led acceso.*/
boolean giorno; //questo booleano ti serve per far capire se si deve accendere piuttosto che spegnere il led e viceversa
int ledPin = 3; // LED
unsigned long tempo; // tempo di riferimento
void setup() {
pinMode(ledPin, OUTPUT); // imposto il pin ledPin come uscita
tempo = millis(); // imposto il tempo di riferimento uguale a millis nel setup;
digitalWrite(ledPin, LOW); // spengo il led inizialmente come se ci fosse luce (condizione iniziale prima dell'esecuzione del programma)
giorno = true; // quindi indico, sempre come valore iniziale, che siamo in un momento in cui il led è spento
}
void loop() {
if (giorno == true) { //------------------------------->se è giorno
if (millis() - tempo >= 5000) { //------------------->se sono passati 5 secondi dall'ultimo aggiornamento
accensioneLed(); //-------------------------------->eseguo l'accensione del led
tempo = millis(); //------------------------------->aggiorno la variabile tempo
giorno = false; //--------------------------------->gli dico che è notte
}
}
else { //---------------------------------------------->se è notte
if (millis() - tempo >= 3000) { //------------------->se sono passati 3 secondi dall'ultimo aggiornamento
spegnimentoLed(); //------------------------------->eseguo lo spegnimento del led
tempo = millis(); //------------------------------->aggiorno la variabile tempo
giorno = true; //---------------------------------->gli dico che è giorno
}
}
}
void accensioneLed() {
for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) {
analogWrite(ledPin, fadeValue);
delay(30);
}
}
void spegnimentoLed() {
for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {
analogWrite(ledPin, fadeValue);
delay(30);
}
}
/*molto meccanicoso perchè non devi gestire nient'altro che un led. Io sarei andato di delay e Switch personalmente,
molto meno ingarbugliato.*/
Con un tocco di programmazione a stati finiti è diventato così:
//---------------------UPDATE 28-01-2018-------------------------------------------
boolean giorno;//------------------>questo booleano ti serve per far capire se si deve accendere piuttosto che spegnere il led e viceversa
boolean estate;//------------------>questo booleano ti serve per far capire se è estate piuttosto inverno
int ledPin = 3;//------------------>LED
unsigned long tempo;//------------->tempo di riferimento per millis()
unsigned long tempoPerGiorno; //--->questa variabile la regoleremo durante il codice dinamicamente tenedo conto della stagione
unsigned long tempoPerNotte; //---->questa variabile la regoleremo durante il codice dinamicamente tenedo conto della stagione
/*---------------------------------IMPORTANTISSIMO LEGGI BENE e RILEGGI MEGLIO questa parte di commento!!!!!!!-------------------------
Per modificare da estate ad inverno dobbiamo aggiungere un evento esterno a questi riferimenti!
Per evento esterno intendo un pulsante, un sensore, o qualsiasi altra cosa vogliamo.
IN QUESTO ESEMPIO userò un semplice contatore che contando 5 cicli di giorno/notte in automatico cambierà stagione
da inverno a estate e viceversa!!!!!!!
------------------TUTTO CHIARO???----------------
--if (tutto_chiaro == TRUE) {
continua a leggere;
}
else {
rileggi il commento;
}
:D
*/
int contatoreGiorni = 1; //questo è il contatore mensionato nel commento
void setup() {
pinMode(ledPin, OUTPUT); // imposto il pin ledPin come uscita
tempo = millis(); // imposto il tempo di riferimento uguale a millis nel setup;
digitalWrite(ledPin, LOW); // spengo il led inizialmente come se ci fosse luce (condizione iniziale prima dell'esecuzione del programma)
giorno = true; // quindi indico, sempre come valore iniziale, che siamo in un momento in cui il led è spento
estate = true; // quindi gli diremo che il giorno dura più della notte ad esempio 10 secondi di giorno (led spento) e 5 secondi di buio (led acceso)
tempoPerGiorno = 10000; //10 secondi durata giorno (led spento) <<PARAMETRO INIZIALE>>
tempoPerNotte = 5000; //5 secondi durata notte (led acceso) <<PARAMETRO INIZIALE>>
}
void loop() {
impostaAttese(); //questa funzione regolerà i tempi di attesa in base alla stagione
if (giorno == true) { //------------------------------->se è giorno
if (millis() - tempo >= tempoPerGiorno) { //--------->può variare da 5 a 10 secondi in funzione della stagione
accensioneLed(); //-------------------------------->eseguo l'accensione del led
tempo = millis(); //------------------------------->aggiorno la variabile tempo
giorno = false; //--------------------------------->gli dico che è notte
}
}
else { //---------------------------------------------->se è notte
if (millis() - tempo >= tempoPerNotte) { //---------->può variare da 5 a 10 secondi in funzione della stagione
spegnimentoLed(); //------------------------------->eseguo lo spegnimento del led
tempo = millis(); //------------------------------->aggiorno la variabile tempo
giorno = true; //---------------------------------->gli dico che è giorno
contatoreGiorni += 1; /*--------------------------->aumento di un giorno il contatore, quando sarà maggiore di 5 cambierà stagione
attraverso la funzione impostaAttese() richiamato ad ogni loop();*/
}
}
}
/*---------------------------NOVITA'----------------------------------------------
La funzione riportata di seguito permetterà di modificare le attese di giorno/notte
in funzione della stagione.
La stagione cambierà automaticamente da estate a inverno ogni 5 cicli di accensione/spegnimento led.
*/
void impostaAttese() {
//per prima cosa controlliamo il contatore se è maggiore di 5 altrmenti salterà tutta la funzione
if (contatoreGiorni > 5) { // se sono passati 5 giorni
contatoreGiorni = 1; //azzero contatore
if (estate == true) { //se adesso conteggiava per l'estate
estate = false; // adesso è inverno
tempoPerGiorno = 5000; //5 secondi durata giorno (led spento)
tempoPerNotte = 10000; //10 secondi durata notte (led acceso)
}
else
{ // se invece conteggiava per inverno
estate = true; //adesso è estate
tempoPerGiorno = 10000; //10 secondi di durata giorno (led spento)
tempoPerNotte = 5000; // 5 secondi di durata notte (led acceso)
}
}
}
//----------------------queste le ho rimaste inveriate a parte la durate del delay()------
void accensioneLed() {
for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) {
analogWrite(ledPin, fadeValue);
delay(20);
}
}
void spegnimentoLed() {
for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {
analogWrite(ledPin, fadeValue);
delay(20);
}
}
/*ECCO I BENEFICI DELLA PROGRAMMAZIONE A STATI FINITI!!! Ho aggiunto una funzione senza stravolgere il codice.
* COME VOLEVASI DIMOSTRARE!
* Prova ad aprire sia il mio vecchio esempio e questo. Mettili di lato uno all'altro e confrontali...
* Saranno pressochè identici... Ho inserito qualche variabile e la funzione impostaAttese().
*/
Provalo e fammi sapere...
PS: nel loop() non è stata proprio menzionata la stagione perché non ce motivo di farlo...
la stagione viene gestita da impostaAttese() richiamata dal loop().
grazie , adesso me lo stampo e lo leggo e ( cerco) di capirci qualcosa,
grazie ancora
p.s.per la variabile stagione avevo procato a gestirla dai tempi di attesa ma non andava ,
e allora ho optato per la soluzione che ti ho postato
questo sistema usando delle variabili per cambiare i tempi di azione lo avevo stufdiato manon mi funzionava , ( inquanto incasinato).
piu o meno ho capito il funzionamento ,senti se ho capito bene
allora tralasciando l impostazione delle variabili , del pin eecccc
non ho capito perche int contatoreGiorni = 1; invece che a zero????
poi te crei delle funzioni void accensioneled spegimento , ed impostaarttese.
che poi richiami nel loop,
da quello che ho capito queste funzioni essendo fuori dal loop, non vengono eseguite se non richiamate
neele roghe dell loop giusto?
mi sa che questo metodo e usato tantissimo 
il loop funziona cosi
per primo va alla funzione attesa e con questa funzione controlla se contatore giorno è > 5
è il primo avvio quindo è ad 1.
salta all else ed imposta la variabile estatew a true e le variabile tempo giorno e notte.
quando contatore arriva a 6
riporta il contatore a 1 e verifica la variabile estate , che pero è ovvio che sia a true percheimpostata dal l else di prima , a questo punto le variabili tempo giorno e notte sono impostate .
e il loop va avanti.
esegue il loop e a seconda del risultato dell if/else va alle funzioni accensione /spegnimento.
coi tempi dovuti dalle variabili temo giorno/notte.
ho capito bene? quindi se devo avere un risultato che viene discriminato da due fattori ,
devo fare 3 funzioni 2 per le discriminati e una per l atuazione ( led , , motori ecc)del programma.
giusto?
grazie
p.s. p.s......
volendo fare il soich Schumacher di zelig , lavorando sulla variabile contatoregiorno ed aggiungendo un altra funzione potrei avere 4 stagioni , dove in due abbiamo 50% e 50% di luce/buio
grazie ancora
albepancio:
..del pin eecccc
non ho capito perche int contatoreGiorni = 1; invece che a zero????
puoi mettere anche 0 ma per contare cinque giorni devi considerare che lo 0 viene considerato.
Quindi per il ciclo contatoreGiorni = 0 sta eseguendo il primo giorno... quindi se vuoi 5 giorni con il contatore che parte da 0 devi metterlo >4 anziché >5.
non vengono eseguite se non richiamate
neele roghe dell loop giusto?
giusto 
per primo va alla funzione attesa e con questa funzione controlla se contatore giorno è > 5
è il primo avvio quindo è ad 1.
salta all else ed imposta la variabile estatew a true e le variabile tempo giorno e notte.
Non salta all'else. quel if (contatoreGiorni > 5) se non è verificato fa saltare tutta la funzione impostaAttese(). solo se è verificato esegue quello che c'è sotto!
volendo fare il soich Schumacher di zelig , lavorando sulla variabile contatoregiorno ed aggiungendo un altra funzione potrei avere 4 stagioni , dove in due abbiamo 50% e 50% di luce/buio
grazie ancora
con un po di ordine nella modalità di impostazione di redazione del codice puoi anche calcolare la traiettorie di Giove che avrà tra 15 anni 2 mesi 3 giorni 24 minuti 3 secondi e 5 millis da quando leggi il post...
Considera che io ho iniziato a scrivere codici proprio come te e la prima volta che ho caricato il blink su Arduino ho pensato "ma se gli do 10 secondi di delay() che fa nel frattempo? allora una delle prime cose che ho studiato e compreso era l'uso di millis() e come creare gli scarti di tempo per l'esecuzione senza bloccare nulla.
Inoltre se questo progetto implica rimanere acceso Arduino per più di 49 giorni ti consiglio di studiati anche "come gestire l'overflow di millis()".
e be teoricamente 365 e qui salta gia il primo problema se faccio 4 stagioni mi vengono 94,25 giorni quindi non posso usare int , ma neanche float giusto?
cmq cerchero su gestire arduino con piu di 49 giorni ,
ma adesso sono un po incasinato perche fra il lavoro e il manuale di c++ della hoepli ho poco tempo da dedicare ad questa cosa :). cmq vedro , gia avere un giorno notte e gia qualcosa
poi se riesco aggiungo la gestione della tramoggia del cibo ( cosa importante perche a volte hanno fatto digiuno perche mi ero scordato ).se nn riesco con un codice solo ( per ora usero due arduino L:) )
grazie mille del tempo che mi avete dedicato
e se ho sparato degli strafalcioni e solo perche mi piace provaare arricvo ad un punto e mi dico ma se aggiungo questo e quello?
grazie ancora
albepancio:
...lavorando sulla variabile contatoregiorno ed aggiungendo un altra funzione potrei avere 4 stagioni , dove in due abbiamo 50% e 50% di luce/buio
grazie ancora
scusa ma a questo punto perché non usi un RTC?
limiti l'utilizzo di millis(), anzi a quel punto andrei proprio di delay()... il codice sarebbe molto più semplice...
Quando vuoi chiedere siamo qui
Io quando ho fatto un circuito proprio come il tuo per un acquario con apposito servomotore per il mangiare e led per illuminare... (l'ho fatto più per gioco)...
usai un RTC e delay() mica millis().
una volta impostata l'ora esatta sul RTC Arduino non faceva altro che ricevere i dati ogni tot dall'RTC e se era ora di mangiare attivava il servo, se era ora di accendere le luci le accendeva, se doveva spegnere le luci le spegneva...
Considera che l'RTC restituisce anche la data oltre che l'ora! quindi sai se sei in estate o inverno, ecc...
:
scusa l ignoranza RTC?????
Acronimo di Real Time Clock. è un modulo con interfaccia i2c che, dopo averlo impostato la prima volta, si comporta come un orologio e calendario... la sua batteria tampone gli permette di continuare a funzionare anche quando Arduino è spento...
scegli quale guida seguire e vedi se ci capisci qualcosa... per il resto siamo SEMPRE qui..
Albepancio ricorda i consigli....un passo alla volta.
albepancio:
... se faccio 4 stagioni mi vengono 94,25 giorni quindi non posso usare int , ma neanche float ...
... ed il problema dov'e' ? ... fai 3 stagioni di 94 giorni ed una di 95, e problema risolto ...
Etemenanki:
... ed il problema dov'e' ? ... fai 3 stagioni di 94 giorni ed una di 95, e problema risolto ...
infatti, ma la gestione dell'overflow la dai per scontata... 
io al posto suo con 2 riga di codice imparerei l'RTC e con altre 3 gli farei fare quello che voglio all'mcu senza svenarmi con millis() overflow delle variabili ecc...
io avrei chiesto l'aggiornamento dell'orario e data ogni 30/60 secondi con delay.
recuperati i suddetti dati avrei impostato le intermittenze alba tramonto in base alla data e le accensioni spegnimento dei led tramite fading bloccando il resto del codice anche per un'ora se avrei voluto un effetto alba/tramonto prolungato... tanto cosa cambia... niente... poi il codice riprendeva dalla richiesta dei dati ogni 30/60 secondi... quindi comunque perennemente aggiornato....
Inoltre, se avevo proprio tempo da perdere, avrei studiato di quanti minuti/secondi si allungano e si accorciano le giornate durante l'anno e avrei tirato su un algoritmo per incrementare o decrementare le ore di luce/buio dinamicamente e giornalmente... Niente di astronomico.... :
Pura matematica...
miky_police:
infatti, ma la gestione dell'overflow la dai per scontata...
io al posto suo con 2 riga di codice imparerei l'RTC e con altre 3 gli farei fare quello che voglio all'mcu senza svenarmi con millis() overflow delle variabili ecc...
Premetto che NON ho letto tutto il thread e quindi ... potrei dire sciocchezze, ma ...
... misurare periodi di tempo di giorni con millis(), se solo serve un MINIMO di precisione, è cosa da dimenticare !!!
Nell'arco di un mese, rischi di essere in anticipo o in ritardo di svariate ore e ... non so se è accettabile.
Quando si parla di operazioni che riguardano tempi così lunghi il suggerimento è SEMPRE un RTC e anche uno di quelli abbastanza precisi come quelli basati su DS3231 ... tanto ormai il costo è veramente irrisorio ...
Guglielmo
Senza tener conto di questo
Nell'arco di un mese, rischi di essere in anticipo o in ritardo di svariate ore e ... non so se è accettabile.
lo avevo già instradato su questo
riguardano tempi così lunghi il suggerimento è SEMPRE un RTC
:
o addirittura una ethernet shield per reperire l'ora tramite NTP.... (non so dare informazioni aggiuntive in merito a quest'ultima perché non l'ho mai utilizzata ne mai posseduta 
..non vedo l'ora che si ferma il criceto tutto incavolato e mi dice "adesso prendi una ethernet shield se no non salgo più sulla ruota")
grazie per le informazioni ho gia visto un paio di tutorial ,
su come visualizzar el ora , su un lcd ,
ora devo capire come usarlo pe ril mi progwetto
grazie ancora
Wire.beginTransmission(0x68);
// il primo byte stabilisce il registro
Wire.write((byte)0x00);
// imposto l’orario e la data
Wire.write((byte)0x00); // 1° byte SECONDI da 0x00 a 0x59// perche fanno 60 secondi??????????giusto?
Wire.write((byte)0x10); // 2° byte MINUTI da 0x00 a 0x59// idem come sopra
Wire.write((byte)0x80 | 0x10); // 3° byte ORE da 0x00 a 0x24// qperche non e 0x23??????
Wire.write((byte)0x01); // 4° byte GIORNO della settimana da 0x01 a 0x07 idem come sopra
Wire.write((byte)0x21); // 5° byte GIORNO del mese da 0x00 a 0x31 idem come sopra
Wire.write((byte)0x03); // 6° byte MESE da 0x00 a 0x12 idem come sopra
Wire.write((byte)0x12); // 7° byte ANNO 0x00 a 0x99 idem come sopra
Wire.endTransmission();
}
e poi qui sostituico il pin alla funzione accensione /spegnimento?
if (Secondigiorno >=start_secondi && Secondigiorno < end_secondi){
digitalWrite(2, HIGH); // eccito il relè collegato al pin2
delay(1000);
releacceso = 1;
}
else
if (releacceso = 1){
digitalWrite(2, LOW); // stacco il relè collegato al pin2
delay(1000);
releacceso = 0;}
}
ho trovato queste parti di codice in un tutorial per l accensione di una luce ,
devo studiarmi questa cosa : Wire.beginTransmission(0x68);
// il primo byte stabilisce il registro
Wire.write((byte)0x00);
// imposto l’orario e la data
scusa mi sono sbagliato come puoi vedere nei post precedentoi ho sempe messo fra code i codici a meno che non fossero composti da una riga.
>albepancio: ti ricordo che in conformità al regolamento, punto 7, devi editare il tuo post qui sopra (quindi NON scrivendo un nuovo post, ma utilizzando il bottone More -> Modify che si trova in basso a destra del tuo post) e racchiudere il codice all'interno dei tag CODE (... sono quelli che in edit inserisce il bottone con icona fatta così: </>, tutto a sinistra). Grazie.
Guglielmo
*P.S.: Ma non li leggete mai gli altri post del forum ? ... solo oggi non so quante volte l'avrò scritto ... * *:-*
Per gestire l'rtc ti basta la libreria che trovi qui. l'aggiungi alle tue librerie tramite l'importazione del file zip e la prima cosa che devi fare aprire il file di esempio riportato nella libreria, ovvero RTClib-->ds3231 e dai un'occhiata.
Questa libreria ti permette di impostare l'orario corretto inizialmente e contestualmente restituisce l'orario aggiornato con un'altra serie print per rendere l'idea di quello che ci puoi fare (funzioni insite nella libreria).
Detto questo, e dato che "adesso" puoi reperire l'ora esatta in ogni momento e il giorno dell'anno, esci fuori dal pensiero di contare da quanto tempo l'mcu sta girando, non serve più. Tu devi comparare l'ora comunicata dall'rtc con gli orari di alba tramonto da te voluti per rimandare alle tue funzioni di fading, ecc. ecc...
Ti do qualche dritta, se riesco 
L'esempio riportato dalla libreria è il seguente:
// Date and time functions using a DS3231 RTC connected via I2C and Wire lib
#include <Wire.h>
#include "RTClib.h"
RTC_DS3231 rtc;
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
void setup () {
#ifndef ESP8266
while (!Serial); // for Leonardo/Micro/Zero
#endif
Serial.begin(9600);
delay(3000); // wait for console opening
if (! rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);
}
if (rtc.lostPower()) {
Serial.println("RTC lost power, lets set the time!");
// following line sets the RTC to the date & time this sketch was compiled
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2014 at 3am you would call:
// rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}
}
void loop () {
DateTime now = rtc.now();
Serial.print(now.year(), DEC);
Serial.print('/');
Serial.print(now.month(), DEC);
Serial.print('/');
Serial.print(now.day(), DEC);
Serial.print(" (");
Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
Serial.print(") ");
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.print(now.minute(), DEC);
Serial.print(':');
Serial.print(now.second(), DEC);
Serial.println();
Serial.print(" since midnight 1/1/1970 = ");
Serial.print(now.unixtime());
Serial.print("s = ");
Serial.print(now.unixtime() / 86400L);
Serial.println("d");
// calculate a date which is 7 days and 30 seconds into the future
DateTime future (now + TimeSpan(7,12,30,6));
Serial.print(" now + 7d + 30s: ");
Serial.print(future.year(), DEC);
Serial.print('/');
Serial.print(future.month(), DEC);
Serial.print('/');
Serial.print(future.day(), DEC);
Serial.print(' ');
Serial.print(future.hour(), DEC);
Serial.print(':');
Serial.print(future.minute(), DEC);
Serial.print(':');
Serial.print(future.second(), DEC);
Serial.println();
Serial.println();
delay(3000);
}
Come puoi notare reperisce i dati uno per volta. Ad esempio: per reperire l'anno non fa altro che chiedere now.year() stessa cosa per il giorno, mese, ora, minuti e secondi... quindi non devi andare a giocare con nessun registro, la libreria lo farà per te (ecco a cosa servono, io le paragono alle dll di windows).
IL PROBLEMA DOVE POTRESTI INCONTRARLO? Ad esempio nel comparare due orari o due date...
Spiego meglio. Come fai a stabilire che le 18:54 e 15 secondi è antecedente alle 19:12 e 3 secondi??
Il metodo più semplice e diffuso (e più postato su questo forum) è quello di trasformare l'ora letta dall'rtc in un intero e stessa cosa per l'ora di comparazione.
Prendo in esame gli orari appena citati. Per trasformare 18:54:15 si crea un int, lo chiami come vuoi, ad esempio rtcAdesso e sarà uguale alla seguente operazione matematica :
(hh x 10.000) + (mm x 1.000) + sec
Se applichiamo la seguente formula al predetto orario otteniamo:
(18 x 10.000) + (54 x 100) + 15 = 185415 che è appunto un intero
adesso trasformo le 19:02 e 3 secondi con lo stesso criterio
(19 x 10.000) + (02 x 100) + 3 = 190203 che è un altro intero.
Adesso viene la comparazione. L'ora letta è più grande dell'ora di riferimento?? ovvero 185415 > 190203 ?
Ovviamente no quindi dobbiamo attendere l'ora di riferimento nel nostro codice...
Dov'è millis() in tutto ciò? Perché ci dobbiamo complicare la vita?[/b]
Adesso vediamo se riesci a dirgli che il 31/01/2018 viene prima del 01/02/2018 e pertanto l'1 febbraio è "più grande" del 31 gennaio...
miky_police:
... Prendo in esame gli orari appena citati. Per trasformare 18:54:15 si crea un int, lo chiami come vuoi, ad esempio rtcAdesso e sarà uguale alla seguente operazione matematica :
(hh x 10.000) + (mm x 1.000) + sec ...
Premesso che NON ti basta affatto un int, (che va da -32768 a +32767), ma ti occorre un long (a 32 bit) altrimenti i calcoli che indichi NON li fai, ma comunque ...
... perché è presa a tutti 'sta smania d reinventare l'acqua caldai e di usare la notazione decimale, invece che lo standard mondiale dello "Unix Time" detto anche "Epoch" (che tutte le librerie calcolano da sole, inclusa quella che tu indichi e che è universale) ? ? ?
Avete le funzioni di libreria ... USATELE invece di reinventarle
Guglielmo
P.S.: Il tempo "Epoch" è un unsigned long (32 bit) che indica il tempo in secondi e quindi un semplice numero con cui fare somme e sottrazioni. Le librerie offrono le funzioni sia per calcolarlo a partire dalla data/ora che, inversamente, ricavare data/ora a partire da esso.
La libreria da te indicata opera in modo "Epoch" su date dal 01.01.2000 al 31.12.2099
Concordo perfettamente. Quando realizzai il mio progetto simile a questo che è oggetto di topic, lo feci con l'utilizzo dall'RTC. All'epoca (quando ne sapevo tanto quanto ne so adesso di fisica quantistica, ovvero niente ) recuperavo i dati dall'RTC, creavo una stringa e comparavo quest'ultima con l'orario che volevo io :o
Metodo grezzo ma funzionale... ovviamente non avevo bisogno di prevedere orari date ecc. quindi non dovevo manipolare niente...
Adesso rileggendo bene l'esempio, in effetti, (e avendo più dimestichezza nell'interpretare i codici) è semplicissimo calcolare di tutto con questa libreria...