Automazione giornaliera differente ogni 24h

_pier:
Mi basta la precisione del minuto. Il calendario che ho non mi riporta i secondi, quindi direi che minuti va più che bene.

Ok quindi hai valori che vanno dalle 00:00 alle 23:59 ...

... in questo caso, per risparmiare memoria, si può usare un trucco caro al nostro "nid69ita" ... moltiplicare le ore per 100 e sommare i minuti ... si avrà un semplice unsigned int (uint16_t) che va da 0 a 2359 quindi ... ti basta un array di interi non segnati fatto così: unsigned int eventArray[365][2] in cui il primo indice è il giorno (ricorda che parte da 0 quindi 0..364), il secondo indice è l'evento (0..1).

Ora, contrariamente a quanto pensa "standardoil" :smiley: ... dato che sono valori FISSI, nessuno a ha mai pensato di metterli in EEPROM, ma in PROGMEM.

Per cui, a livello di codice, quell'array andrà dichiarato come:

const unsigned int eventArray[365][2] PROGMEM = { {evento001_1, evento001_2}, {evento002_1, evento002_2}, .... };

A questo punto (ogni giorno) un singolo elemento protà semplicemente essere letto con la: pgm_read_word(&eventArray[giorno][n_evento]);

Il resto è banale ... :slight_smile:

Guglielmo

gpb01:
Ora, contrariamente a quanto pensa "standardoil" :smiley: ... dato che sono valori FISSI, nessuno a ha mai pensato di metterli in EEPROM, ma in PROGMEM.

sbagliai a scrivere.
Ma dall'ultima volta ho avanzato un 5 kili di cenere, bastano per coprirsi il capo?

Standardoil:
Ma dall'ultima volta ho avanzato un 5 kili di cenere, bastano per coprirsi il capo?

Dovrebbero bastare ... :grin: :grin: :grin:

Guglielmo

Sippero' rimane il problema che scrivere linizializzazione di quella roba lì e operazione tediosa e lunga.
Io a questo ero interessato
Sono 750 (ok ok 730) coppiette di numeri
Non venitemi a dire che è facile facile, come bere un bicchiere d'acqua
Bisogna anche pensare di dargli una controllata, mica di scoprirlo a dicembre di essersi sbagliati

Standardoil:
Sono 750 (ok ok 730) coppiette di numeri
Non venitemi a dire che è facile facile, come bere un bicchiere d’acqua

E capirai che fatica … ma non hai mai scritto a manina lookup-tables ? O array per i font ? :smiley: :smiley: :smiley:

Comunque, lui li ha su un foglio Excel … farà una qualche bella macro/funzione VB che gli prepara già un bel file ASCII con dentro l’array riempito che poi … copia/incolla nel codice :slight_smile:

Guglielmo

gpb01:
E capirai che fatica ... ma non hai mai scritto a manina lookup-tables ? O array per i font ? :smiley: :smiley: :smiley:

Guglielmo

certo, negli anni 80, quando non si chiamavano ancora font, ma polizze.
Lavoravi in Agfa compugrafics?

Standardoil:
Lavoravi in Agfa compugrafics?

NO, ma tutt’ora se guardi come sono fatti i “font” per i vari display grafici NON intelligenti … scopri che sono dei bei array con tutti i bit che disegnano i vari caratteri …

fontdatatype SmallFont[] PROGMEM =
{
0x06, 0x08, 0x20, 0x5f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // sp
0x00, 0x00, 0x00, 0x2f, 0x00, 0x00,   // !
0x00, 0x00, 0x07, 0x00, 0x07, 0x00,   // "
0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14,   // #
0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12,   // $
0x00, 0x23, 0x13, 0x08, 0x64, 0x62,   // %
0x00, 0x36, 0x49, 0x55, 0x22, 0x50,   // &
0x00, 0x00, 0x05, 0x03, 0x00, 0x00,   // '
0x00, 0x00, 0x1c, 0x22, 0x41, 0x00,   // (
0x00, 0x00, 0x41, 0x22, 0x1c, 0x00,   // )
0x00, 0x14, 0x08, 0x3E, 0x08, 0x14,   // *
0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,   // +
0x00, 0x00, 0x00, 0xA0, 0x60, 0x00,   // ,
0x00, 0x08, 0x08, 0x08, 0x08, 0x08,   // -
0x00, 0x00, 0x60, 0x60, 0x00, 0x00,   // .
0x00, 0x20, 0x10, 0x08, 0x04, 0x02,   // /

0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,   // 0
0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,   // 1
0x00, 0x42, 0x61, 0x51, 0x49, 0x46,   // 2
0x00, 0x21, 0x41, 0x45, 0x4B, 0x31,   // 3
0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,   // 4
0x00, 0x27, 0x45, 0x45, 0x45, 0x39,   // 5
0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,   // 6
0x00, 0x01, 0x71, 0x09, 0x05, 0x03,   // 7
0x00, 0x36, 0x49, 0x49, 0x49, 0x36,   // 8
0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,   // 9
0x00, 0x00, 0x36, 0x36, 0x00, 0x00,   // :
0x00, 0x00, 0x56, 0x36, 0x00, 0x00,   // ;
0x00, 0x08, 0x14, 0x22, 0x41, 0x00,   // <
0x00, 0x14, 0x14, 0x14, 0x14, 0x14,   // =
0x00, 0x00, 0x41, 0x22, 0x14, 0x08,   // >
0x00, 0x02, 0x01, 0x51, 0x09, 0x06,   // ?

0x00, 0x32, 0x49, 0x59, 0x51, 0x3E,   // @
0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C,   // A
0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,   // B
0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,   // C
0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C,   // D
0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,   // E
0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,   // F
0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,   // G
0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,   // H
0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,   // I
0x00, 0x20, 0x40, 0x41, 0x3F, 0x01,   // J
0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,   // K
0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,   // L
0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F,   // M
0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F,   // N
0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,   // O

0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,   // P
0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,   // Q
0x00, 0x7F, 0x09, 0x19, 0x29, 0x46,   // R
0x00, 0x46, 0x49, 0x49, 0x49, 0x31,   // S
0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,   // T
0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,   // U
0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,   // V
0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F,   // W
0x00, 0x63, 0x14, 0x08, 0x14, 0x63,   // X
0x00, 0x07, 0x08, 0x70, 0x08, 0x07,   // Y
0x00, 0x61, 0x51, 0x49, 0x45, 0x43,   // Z
0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,   // [
0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55,   // Backslash (Checker pattern)
0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,   // ]
0x00, 0x04, 0x02, 0x01, 0x02, 0x04,   // ^
0x00, 0x40, 0x40, 0x40, 0x40, 0x40,   // _

0x00, 0x00, 0x03, 0x05, 0x00, 0x00,   // `
0x00, 0x20, 0x54, 0x54, 0x54, 0x78,   // a
0x00, 0x7F, 0x48, 0x44, 0x44, 0x38,   // b
0x00, 0x38, 0x44, 0x44, 0x44, 0x20,   // c
0x00, 0x38, 0x44, 0x44, 0x48, 0x7F,   // d
0x00, 0x38, 0x54, 0x54, 0x54, 0x18,   // e
0x00, 0x08, 0x7E, 0x09, 0x01, 0x02,   // f
0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,   // g
0x00, 0x7F, 0x08, 0x04, 0x04, 0x78,   // h
0x00, 0x00, 0x44, 0x7D, 0x40, 0x00,   // i
0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,   // j
0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,   // k
0x00, 0x00, 0x41, 0x7F, 0x40, 0x00,   // l
0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,   // m
0x00, 0x7C, 0x08, 0x04, 0x04, 0x78,   // n
0x00, 0x38, 0x44, 0x44, 0x44, 0x38,   // o

0x00, 0xFC, 0x24, 0x24, 0x24, 0x18,   // p
0x00, 0x18, 0x24, 0x24, 0x18, 0xFC,   // q
0x00, 0x7C, 0x08, 0x04, 0x04, 0x08,   // r
0x00, 0x48, 0x54, 0x54, 0x54, 0x20,   // s
0x00, 0x04, 0x3F, 0x44, 0x40, 0x20,   // t
0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C,   // u
0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,   // v
0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C,   // w
0x00, 0x44, 0x28, 0x10, 0x28, 0x44,   // x
0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C,   // y
0x00, 0x44, 0x64, 0x54, 0x4C, 0x44,   // z
0x00, 0x00, 0x10, 0x7C, 0x82, 0x00,   // {
0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,   // |
0x00, 0x00, 0x82, 0x7C, 0x10, 0x00,   // }
0x00, 0x00, 0x06, 0x09, 0x09, 0x06    // ~ (Degrees)
};

… questo è per i piccoli display OLED 0.96" :smiley:

Guglielmo

Per cui, a livello di codice, quell'array andrà dichiarato come:

const unsigned int eventArray[365][2] PROGMEM = { {evento001_1, evento001_2}, {evento002_1, evento002_2}, .... };

A questo punto (ogni giorno) un singolo elemento protà semplicemente essere letto con la: pgm_read_word(&eventArray[giorno][n_evento]);

ok, credo di esserci. L'array lo compilo in pochi istanti... dopo aver digitalizzato tutto il calendario su un foglio di calcolo! Credo di far presto con una stampa unione in word e giocando un pò sulla formattazione. Utilissimo pure il truchetto di moltiplicare x100 le ore. Davvero grazie!
Poi però sinceramente mi perdo.. ammetto di non aver ancora studiato per bene PROGMEM e il materiale che mi hai dato, ma non ho capito concettualmente come procederesti..
Faresti un confronto tra ora corrente e valori dell'array con un if?

_pier:
Faresti un confronto tra ora corrente e valori dell'array con un if?

Semplicemente alle 00:00 del giorno N recuprei da PROGMEM i due elementi (elementoN_1 ed elementoN_2), li metti in due normali variabili in SRAM e lavori per tutti il giorno confrontando quei valori ... semplice e rapido.

In pratica, dop che hai recuperato i due valori, durante il giorno leggi il RTC, fai lo stesso calcolo (ore x 100 + minuti) e confronti il valore con evento_1 ed evento_2 ... quando uno dei due è uguale sai cosa devi fare :slight_smile:

Guglielmo

Ok, ti ringrazio ancora e ringrazio anche gli altri. Quando avrò un minuto (anzi forse di più..) comincio con il lavoro bruto e digitalizzo quel cavolo di calendario scritto da chissà quale sciamano. E poi mi dedico al codice. Non mancherò di postare il lavoro svolto.

A presto!

Perdonatemi ma mi sta salendo la scimmia e finchè non capisco ogni singolo passaggio, non riesco a star tranquillo.
Avrò un array formato da dati immutabili (const) di tipo intero positivio (unsigned int) parcheggiato nella memoria flash di arduino (PROGMEM).
Finora avevo sempre usato array di questa natura:

array[6] = {5, 4, 3, 10, 11, 6}

e mai

array[6][2] = {{5,3}, {4,2}, {3,7}, {10,3},  {11, 6}, {6,7}}

ignoranza mia.. cambiano i meccanismi?

Quello che non capisco è come faresti il "confronto".
Ad una variabile assegno la data letta dal RTC, che però dovrà assumero un numero da 1 a 365 in base al giorno "corrente". Giusto?

E poi? Se siamo nel giorno n° 214, devo estrarre dall'array i due valori del 213° valore... giusto?

Potresti abbozzarmi un codice?

_pier:
Finora avevo sempre usato array di questa natura:

array[6] = {5, 4, 3, 10, 11, 6}

e mai

array[6][2] = {{5,3}, {4,2}, {3,7}, {10,3},  {11, 6}, {6,7}}

ignoranza mia.. cambiano i meccanismi?

Assolutamente gli stessi meccanismi, solo che hai un indice in più ...

Array ad 1 dimensione pippo[N] è come una cartellina che contiene N fogli, tu dici N e trovi il foglio. Array a 2 dimensioni pluto[M][N] è come un raccoglitore che contiene le suddette cartelline (in numero di M) che contengono i fogli ...
... ti serve i primo indice M per individuare la carellina ed il secondo indice N per individuare il foglio nella cartellina :slight_smile:

Ed il gioco può ovviamente continuare :wink:

Guglielmo

_pier:
Potresti abbozzarmi un codice?

Come hai visto, stando in PROGMEM, per accedere ai valori occorre utilizzare una apposita funzione ...

Immaginiamo di voler recuperare i due eventi del giorno 214 (come da tuo esempio) quindi indice 213. Ci serviranno due variabili in SRAM per salvarli ...

unsigned int evento1, evento2;

Dopo di che, dovrai semplicemente scrivere:

evento1 =  pgm_read_word(&eventArray[213][1]);
evento2 =  pgm_read_word(&eventArray[213][2]);

... ed avrai i valori nelle due variabili.

Guglielmo

Un anno può avere 365 o 366 giorni. È importante per questa applicazione?

Claudio_FF:
Un anno può avere 365 o 366 giorni. È importante per questa applicazione?

Ciao. No, non è importante. Ho un calendario con 365 giorni e mi baso su quello senza pormi il problema.

Eccomi,
ho digitalizzato tutto il calendario (in un foglio di calcolo ho creato 3 colonne, giorno, evento1, evento2) e con una stampa unione in un baleno ho ottenuto i valori utili per popolare l'array.
Non lo posto tutto, ma ottengo qualcosa di questo tipo:

cost unsigned int Calendario1[365][2] PROGMEM = {{445,1915}, {438,1907}, {441, 1912}, ......}

Ora tocca al codice, che ho abbozzato ieri sera a mezzanotte.

#define Rele 2 //Pin a cui collegare il relè
cost unsigned int Calendario1[365][2] PROGMEM = {{445,1915}, {438,1907}, ......} //Calendario
unsigned int OraAttuale = 0           // dichiaro variabile per "estrarre" l'ora attuale
unsigned int GiornoAttuale = 0       // dichiatro varibile per "estrarre" il giorno attuale
#include LIBRERIA PER IL MIO RTC  //  possiedo un DS1302
RTC_DS1302 mioRTC                    // creo l'oggetto per l'RTC, non sono sicuro sia questa la sintassi

void setup() {
pinMode (Rele, OUTPUT);
Serial.begin(9600);
}

void loop() {

GiornoAttuale = fare conteggio dei giorni che sono passati dal primo giorno dell'anno (da 1 a 365);
OraAttuale = (hour()*100)+minute())) //calcolo per ottenere un valore orario da confronatare con l'array, forse la sintassi è da rivedere con la libreria relativa al DS1302

if ((Calendario1[GiornoAttuale][1] || Calendario1[GiornoAttuale][2])=OraAttuale
{DigitalWrite(Rele, HIGH); // do corrente al relè
 delay(250);
DigitalWrite(Rele,LOW);    // tolgo corrente al relè
daley(60000)                 //potrei fermare il codice anche per un'ora poichè, da dato tabellare, i due eventi distano sempre alcune ore lìuno dall'altro. E' utile??
}

Mancano diverse cose tra cui capire bene come funziona un RTC e le relative librerie, ma ho scritto queste righe per capire se, almeno concenttualmente, sta in piedi.
Ora, abbiate pietà di me...

c'é effettivamente qualche errore nella sintassi, che dipende anche da libreria a libreria, ma va abbastanza bene. I punti topici sono:
1)la dichiarazione di oggetto
2)probabilmente l'orologio avrà bisogno di una begin(), presente se necessario nella libreria, e da eseguire nella setup{}
3)la if() per il controllo dei timer é da rifare, perché
A)per leggere la progmem serve una funzione specifica, precedentemente mostrata
B) per fare quello che vuoi é necessario fare il confronto da entrambe le parti della or. Messa così significa fai .... se O esiste array [giorno][0] O array [giorno][1] é uguale a quello che ti serve. La prima sarà sempre vera, quindi sempre passato.

4)no, non crea problemi non fermare il programma, la loop() va all'infinito senza problemi.

Ogni RTC richiede la sua libreria e, spesso, queste librerie hanno metodi divesi, quindi, la prima domanda è ... QUALE RTC esattamente intendi usare? Io NON ti consiglio il DS1302 (come da libreria che hai messo tu), ma ti consiglio di prendere il DS3231 che è molto più preciso (ormai lo trovi per pochi €).

Scelto l'RTC, devi andare nel "library manager" del' IDE e cercare (con l'apposita finestrella di ricerca, in alto a destra del "library manager") la parola DS3231 ... troverai la libreria "DS3231 di Andrew Wickert, ecc. ecc." ... installa quella e vai a studiare gli esempi che ti installa nell'IDE.

Troverai un esempio che è il DS3231_set che ti insegna come "impostare" l'ora del DS3231 ed un esempio DS3231_test che ti insegna come leggere i vari valori (anno, mese. giorno, ora, minuti ...).

Una volta che avrai ben capito i vari metodi che la libreria ti mette a disposizione puoi correggere il tuo codice per utilizzarli, nella giusta forma.

A questo punto ...
... ti servirà ancora un array con i giorni dei singoli mesi che userai per il calcolo del giorno, difatti, il RTC ti da mese e giorno, tu, in base a questi due valori, dovrai calcolare il numero del giorno dall'inizio dell'anno e quindi, dovrai sapere esattamente i giorni di ogni mese per fare le somme. Ottenuto tale valore hai il PRIMO indice del array che ti occorre per recuperare i due eventi.

Sempre l'RTC ti fornisce sia il valore dell'ora che quello dei minuti con i quali fai il calcolo e ottieni il famoso numero decimale.

A quel punto nel loop() dovrai IN CONTINUAZIONE (NON serve alcun delay, non sono cose che si "consumano" se si usano):

  1. leggere ora e minuti ...
  2. verificare se l'ora è 00 e i minuti sono 00; se SI ...
    ... dovrai ricavare mese e giorno per calcolare il famoso indice e con esso recuperare UNA sola volta al giorno i valori dei due eventi che salverai nelle tue variabili di lavoro in SRAM.
  3. calcolare le ore * 100 + i minuti e confrontare il numero ottenuto con gli eventi che hai salvato in SRAM e, SE uno dei due corrisponde, è il momento di fare ciò che quell'evento richiede.
  4. tornare al punto 1.

Buon lavoro :slight_smile:

Guglielmo

Silente:
c'é effettivamente qualche errore nella sintassi, che dipende anche da libreria a libreria, ma va abbastanza bene. I punti topici sono:
1)la dichiarazione di oggetto
2)probabilmente l'orologio avrà bisogno di una begin(), presente se necessario nella libreria, e da eseguire nella setup{}
3)la if() per il controllo dei timer é da rifare, perché
A)per leggere la progmem serve una funzione specifica, precedentemente mostrata
B) per fare quello che vuoi é necessario fare il confronto da entrambe le parti della or. Messa così significa fai .... se O esiste array [giorno][0] O array [giorno][1] é uguale a quello che ti serve. La prima sarà sempre vera, quindi sempre passato.

4)no, non crea problemi non fermare il programma, la loop() va all'infinito senza problemi.

Rispondo punto su punto:

  1. ok, dovrò studiarla in base alla libreria del mio RTC;
  2. credo proprio di si, ma vale il discorso del punto 1, devo chinarmi su qualche appunto...;
  3. A - giusto, me ne ero dimenticato, devo correggere
    B - forse ho sbagliato la sintassi anche qui.. L'array ha due dimensioni e nella mia testa l'If avrebbe funzionato così: SE Calendario1[214][1] (giorno numero 214 preso dalla variabile, primo evento con per esempio valore 457) oppure Calendario1[214][2] (cgiorno numero 214 preso dalla variabile, secondo evento, con per esempio valore 1920) è uguale al valore de OraAttuale (che per esempio nell'istante è 1820) allora fai.... altrimenti non fare nulla.
    L'azione, da fare è la stessa per entrembi gli eventi, quindi ho pensato di eseguirla al verificarsi di una delle due condizioni.
    Il codice fa continuamente il confronto tra l'ora attuale (scritta nel formato HHMM) e i valori dell'array bidimensionale che nel giorno N (es. 214) al primo indice avranno un valore (es. 457) e nel secondo indice (es. 1920). Solo quando uno dei due valori dell'array sarà vero, eseguirà il codice.
  4. Il delay lo pensavo utile, forse fondamentale, perchè una volta verificata la condizione, tale condizione resterà valida per un minuto (per un intero minuto OraAttuale avrà il valore presente in Calendario1[214][1] o presente Calendario1[214][2]). Aspettando un minuti o magari 65 secondi, sono sicuro che alla nuova esecuzione del codice il valore di OraAttuale sia già andato oltre al valore dell'array.

gpb01:
Ogni RTC richiede la sua libreria e, spesso, queste librerie hanno metodi divesi, quindi, la prima domanda è ... QUALE RTC esattamente intendi usare? Io NON ti consiglio il DS1302 (come da libreria che hai messo tu), ma ti consiglio di prendere il DS3231 che è molto più preciso (ormai lo trovi per pochi €).

Scelto l'RTC, devi andare nel "library manager" del' IDE e cercare (con l'apposita finestrella di ricerca, in alto a destra del "library manager") la parola DS3231 ... troverai la libreria "DS3231 di Andrew Wickert, ecc. ecc." ... installa quella e vai a studiare gli esempi che ti installa nell'IDE.

Troverai un esempio che è il DS3231_set che ti insegna come "impostare" l'ora del DS3231 ed un esempio DS3231_test che ti insegna come leggere i vari valori (anno, mese. giorno, ora, minuti ...).

Una volta che avrai ben capito i vari metodi che la libreria ti mette a disposizione puoi correggere il tuo codice per utilizzarli, nella giusta forma.

A questo punto ...
... ti servirà ancora un array con i giorni dei singoli mesi che userai per il calcolo del giorno, difatti, il RTC ti da mese e giorno, tu, in base a questi due valori, dovrai calcolare il numero del giorno dall'inizio dell'anno e quindi, dovrai sapere esattamente i giorni di ogni mese per fare le somme. Ottenuto tale valore hai il PRIMO indice del array che ti occorre per recuperare i due eventi.

Sempre l'RTC ti fornisce sia il valore dell'ora che quello dei minuti con i quali fai il calcolo e ottieni il famoso numero decimale.

A quel punto nel loop() dovrai IN CONTINUAZIONE (NON serve alcun delay, non sono cose che si "consumano" se si usano):

  1. leggere ora e minuti ...
  2. verificare se l'ora è 00 e i minuti sono 00; se SI ...
    ... dovrai ricavare mese e giorno per calcolare il famoso indice e con esso recuperare UNA sola volta al giorno i valori dei due eventi che salverai nelle tue variabili di lavoro in SRAM.
  3. calcolare le ore * 100 + i minuti e confrontare il numero ottenuto con gli eventi che hai salvato in SRAM e, SE uno dei due corrisponde, è il momento di fare ciò che quell'evento richiede.
  4. tornare al punto 1.

Buon lavoro :slight_smile:

Guglielmo

Grazie per i suggerimenti, anche riguardo alla scelta dell'RTC.
L'approccio che adotti te sembra radicalmente diverso dal mio.. Ora me lo studio un po'.