Progetto Acquario 180 lt Tropicale Dolce con Arduino

Ciao a tutti, sono nuovo.
Acquistato il mio primo Arduino Uno R3, un Lcd shield con tastini e un banco relè da 8.

La mia idea è di progettare un controllore che gestisca gli otto rele per controllare:
3 punti luce temporizzati
2 riscaldatori
1 pompa
1 elettrovalvola per CO2
1 alimentatore cibo

La parte luci aldilà della costruzione del controllo e della piastra relè mi sembra la cosa più facile da gestire, una volta inserito l'orologio e programmato accensione e spegnimento delle 3 luci, mi sembra complicata la gestione della programmazione tramite tastierino.

L'idea mia è di gestire il tutto con 2/3 menu
Set Clock
View Menu
Set menu

dove nella sezione del Set menu si immettono i valori di tempi accensione /spegnimento, temperatura minima, ph.

Il resto è una gestione a ciclo giornaliero del'Arduino.

Un altro punto che mi lascia dubbi è la quantità di pin disponibili dopo avere inserito lo shield LCD, se ho fatto bene i conti ce ne sono 5 analogici e sette digitali, visto che devo governare gli otto rele pensavo di usare tutti i digitali+ 1 analogico e usare gli altri analogici per il sensore temperatura e sensore ph.

Aspetto un vostro riscontro sulla fattibilità di quanto ho pensato, se riuscite a scorgere problemi aldifuori della mia comprensione ditemi che sono in attesa del vostro aiuto.

So che il rele è lento ma le posizioni normalmente aperto mi garantiscono una continuità di funzionamento più importante della velocità di reazione.
Aspetto consigli e suggerimenti od eventuali soluzioni alternative.
Premetto che ne so poco e tutto coperto dalla polvere del tempo....

Saluti e Grazie
Andrea

Consiglio la libreria Time e un modulo DS1307

http://playground.arduino.cc/Code/Time

Lo zip contiene anche la libreria complementare TimeAlarms con cui puoi programmare eventi con diverse periodicità, e la DS1307RTC che si occupa della comunicazione con il modulo omonimo via i2c.

Grazie bella risorsa.
Quindi consigli la gestione del tempo da un orologio esterno?
Il modulo che indichi è anche chiamato RTC giusto?

Al momento mi sto cercando di immaginare come gestire la programmazione tramite tastini navigando per menu, non riesco a pensare ad una struttura logica ramificata.
Cioè quello che non riesco ad immaginare è che il sistema aspetti di sapere come agire ma risponda subito con il risultato del pulsante NONE cioè quando non è premuto.
Io ho LCD con i tastini e sono riuscito a farlo funzionare con i programmi di prova in modo corretto ma non riesco a pensare come gestire la cosa su vari livelli.

Il case indirizza al primo livello e poi esce subito, se inserisco dei delay non sballo l'orologio?

Ciao, Andrea

Stai mescolando piani diversi…

RTC = Real Time Clock. Funziona indipendentemente dall’arduino, ha una sua batteria e un suo quarzo (sto guardando il modulo DS1307 della sparkfun che ho davanti). Ogni tanto l’arduino chiede l’ora all’RTC via I2C, e aggiorna i contatori in RAM.
La libreria Time si preoccupa di tutto questo (*), e il risultato è che anche dopo l’accensione o il reset le funzioni year(), month(), ecc. ritornano l’ora corrente senza necessità di reimpostarla ogni volta.

Quindi anche se nel codice usi delay(), l’RTC continua a “tenere il tempo”. Ma delay() non va usata. Per altri motivi :slight_smile:

Per quanto riguarda la velocità di risposta del display alla pressione dei tasti, tutto sta nell’usare la tecnica blink without delay (e non delay(), appunto).
Il programma va strutturato a “stati” anziché in modo sequenziale.

(*) a patto di impostare l’RTC come timesource, vedi documentazione libreria.

Hoop:
So che il rele è lento ma le posizioni normalmente aperto mi garantiscono una continuità di funzionamento più importante della velocità di reazione.

piu che altro la bobina consuma tanto e a volte non si possono attaccare direttamente al pin arduino: tu hai moduli gia fatti o relay semplici?

Visto l'impressionante numero di topic che riguardano l'argomento, dovremmo aprire, sul forum, una sezione "Acquario". :grin: :grin:

Per la gestione dei menù su LCD c'è una bellissima libreria di un utente del forum. --> Arduino Forum

tuxduino:
Stai mescolando piani diversi...

RTC = Real Time Clock. Funziona indipendentemente dall'arduino, ha una sua batteria e un suo quarzo (sto guardando il modulo DS1307 della sparkfun che ho davanti). Ogni tanto l'arduino chiede l'ora all'RTC via I2C, e aggiorna i contatori in RAM.
La libreria Time si preoccupa di tutto questo (*), e il risultato è che anche dopo l'accensione o il reset le funzioni year(), month(), ecc. ritornano l'ora corrente senza necessità di reimpostarla ogni volta.

Quindi anche se nel codice usi delay(), l'RTC continua a "tenere il tempo". Ma delay() non va usata. Per altri motivi :slight_smile:

Per quanto riguarda la velocità di risposta del display alla pressione dei tasti, tutto sta nell'usare la tecnica blink without delay (e non delay(), appunto).
Il programma va strutturato a "stati" anziché in modo sequenziale.

(*) a patto di impostare l'RTC come timesource, vedi documentazione libreria.

Innanzitutto grazie delle risposte.
Purtroppo alcune non mi sono chiarissime... ma ci sto lavorando.
Incominciamo dall'orologio, OK ho capito va per i fatti suoi e questo va bene. Ma dove si attacca? I2C presumo sia un sistema di comunicazione diversa, quella con sei punte?
Tu dici che non bisogna usare delay() e questo mi pare di capirlo. Devo usare la tecnica blink senza delay e qua è nebbia totale...
Cosa significa " a stati" io presumo che sia un modo che nel diagramma di flusso abbia diversi livelli: è così?

Per quello che so di cicli condizionali ......

devo fare in modo di gestire tramite la pressione dei tasti le variabili di controllo del sistema, che se non collegato al PC deve consentire di caricare
Data e ora corrente ( se serve anche con RTC)
Accensione e spegnimento luci: T1on T2off....... T3on T3off
Temperatura
Ph

Io userei un case dove a seconda delle varie pressioni che si esercitano il valore conduca all'immissione del dato voluto, poi finita la dichiarazione dei parametri in assenza per tot tempo di pressione sui tasti tornare al ciclo automatico di gestione delle porte.
E già qui ci starebbe un delay.

Cioè, quello che devo fare più o meno mi è chiaro, ma non so come implementarlo come struttura.
Al momento ho tre elementi
Arduino uno rev3
LCD 1602 con cinque tasti
Shield con otto relay a 5V (montata su scheda)
il tutto acquistato alla fiera.

Poi ho preso LM35DZ

Ho già realizzato senza grandi difficoltà la prova dello shield LCD e dei tasti, la misura della temperatura mediata su 30 valori e mandata al monitor seriale, un utilizzo del LCd come orologio grazie ad una libreria SWRTC trovata qui.

E' la struttura di base della implementazione dati che mi mette in crisi, nel piccolo mi ci trovo, però mettere tutti i pezzi insieme... è diverso.

Grazie, scusate se sono lungo.

la strutturazione del programma è la parte più delicata del software: se imposti male all'inizio sputi sangue fino alla fine. Il delay non s'ha da usare in questi casi perchè un delay per esempio per aspettare la prontezza di un dato di temperatura interrompe tutte le altre operazioni: fintanto che il delay è limitato ad un sensore di temperatura (come era nel thread di danielicuius) il male è minore e si vede solo un mancato aggiornamento dei secondi... diventa decisamente pesante se il delay lo usi per fare l'alba ed il tramonto perchè rischio durante questo periodo di non poter fare nulla ne vedere nulla.

Vedo che siete in tanti a voler fare questo acquario. Ho aiutato danielicious a muovere i primi passi con il suo progetto (senza peraltro sapere all'inizio cosa doveva fare) e penso che tutto sommato sia un progetto abbastanza alla portata e fattibile da un programmatore senza tanto sforzo: mi piacerebbe potervi aiutare perchè il progetto mi appassiona (e chissa mai che un giorno non mi prenda anch'io una vasca) però purtroppo non ho l'hardware necessario per testare le vs situazioni. Devo però dire che ogni uno di voi avrà configurazioni hardware diverse quindi avrete anche programmi diversi per forza di cose.

Il consiglio che vi do è di impostare il programma a blocchi e di concentrarvi inizialmente sulla gestione del display e del menu (a tal fine c'è appunto la famosa libreria di bruinialti menwiz)... quando avete fatto quella il resto è una passeggiata (...il programma di danielicious in pratica già ha orologio e basi di schedulazione dei tramonti...però sarà da accantonare fintanto che non si pensa ad uno schema di menu.

Siamo in tanti a voler fare un controller con Arduino, è vero!
E' anche vero che le poche cose che girano sono costosissime.
In questo hobby ci sono i riccastri che fanno acquari ZEN alla Takashi Amano ( cerca di vedere qualche immagine di questo signore) che sono meravigliosi e tutti gli altri che si arrabattano cercando di rendere la propria vasca bella anche senza spendere migliaia di euro.
Anche qui avere un controllo ben fatto di temperatura ph luce e fertilizzanti è come partire con 100 punti in più.
Le esigenze degli acquari si dividono in due grosse famiglie:
tropicale dolce
tropicale marino
Il tropicale marino ha molte più cose da gestire e non ne sono esperto (il controllo del calcio ad esempio), il reintegro dell'acqua, luci particolari necessarie giorno e notte.
Per uno che vuole iniziare un bel dolce ben piantumato è già una soluzione appagante.
Si riesce grazie ai led e un po di capacità a realizzare illuminazioni molto migliori di un tempo, senza spendere troppo.
Il resto è esperienza da farsi da soli. :stuck_out_tongue:
Se ti vuoi far prendere dalla scimmia dell'acquario basta che cerchi gli acquari ZEN di Takashi Amano e sei fregato!
Sto cercando prorpio di partire da lì, superando le differenze tra la dotazione di brunialti e la mia, e cercando di capire qualcosa.
Andrò a vedere il il progetto che hai citato, spero di risucire ad utilizzare un po' di idee e di codice.

Hoop:
Andrò a vedere il il progetto che hai citato, spero di risucire ad utilizzare un po' di idee e di codice.

non è che ci trovi tanto. è giusto un abbozzo adattato tra l'altro dal sorgente iniziale di daniele. Però si intravvede come si può gestire delle situazioni senza l'uso di delay e facendo partire i fade di alba e tramonto a determinati orari.

Ciao,
vedo che anche tu sei acquario dipendente :D,
qui Arduino Forum stiamo quasi per mettere su un gruppetto di lavoro per un progetto in comune, leggi le premesse e se vuoi ti aggreghi.

Riccardo :slight_smile:

Provo a buttare sul piatto i miei 2 cents, nella speranza di essere utile :slight_smile:

La dura realtà è che un software che gestisca tastiera (nel senso di alcuni pulsanti), LCD, RTC, eventi temporizzati (allarmi), cioè operazioni svolte in base ad un calendario, ed eventualmente comunicazioni seriali, richiede di essere progettato a stati / eventi (spiego meglio dopo), senza l'uso di delay() (come già sottolineato anche da altri). Questo richiede uno sforzo concettuale non piccolo per chi non ha una formazione nell'ambito della programmazione.

Trovo C++ Language - C++ Tutorials ben fatto come introduzione al linguaggio, ma non conosco risorse dello stesso livello che spieghino in modo accessibile ma completo come passare dalla temporizzazione di una sola operazione con delay() all'uso della ipercitata ma imprescindibile (perché scalabile) tecnica "blik without delay".

Un veloce accenno al discorso programmazione sequenziale / programmazione a stati / eventi...

Prendiamo il solito esempio del led lampeggiante.

Modo sequenziale:

loop()
accendi led
attendi 1 s
spegni led
attendi 1 s

Modo ad eventi:

RIT = 1000ms
loop()
if dall'ultima volta in cui ho pilotato il led sono passati RIT millisecondi
inverti stato led
pilota led
memorizza istante attuale
endif

Per capire la fondamentale differenza tra i due esempi, bisogna ricordare che delay() è bloccante, cioè l'esecuzione del codice si ferma per il numero di millisecondi specificati, e null'altro viene eseguito durante l'attesa.
Questo è un grosso problema, perché impedisce al programma di eseguire due o più operazioni contemporaneamente.
Diventa un inferno già soltanto far lampeggiare due led in maniera indipendente.

Nel secondo esempio, invece, il test "se è trascorso un tempo D dall'istante T" richiede un tempo brevissimo, così come l'operazione di pilotaggio del led e di aggiornamento di T.
E' così possibile eseguire altre istruzioni contenute in loop().
Inoltre è possibile inserire altri costrutti analoghi, ciascuno con il suo istante T e il suo valore D, potenzialmente diverso, ottenendo così temporizzazioni contemporanee ed indipendenti.

Esempio:

// temporizzazione led A
unsigned long ledA_prevMillis;
unsigned long ledA_delay = 835;
byte ledA_pin;
// stato led A
boolean ledA_acceso = false;

// temporizzazione led B
unsigned long ledB_prevMillis;
unsigned long ledB_delay = 140;
byte ledB_pin;
// stato led B
boolean ledB_acceso = false;


// supponiamo che entrambi i led siano collegati
// in modo tale che pin alto = led acceso,
// pin basso = led spento
void pilotaLed(byte pin, boolean acceso) {
    if (acceso) {
        digitalWrite(pin, HIGH);
    }
    else {
        digitalWrite(pin, LOW);
    }
}


// gestione stato led A
void ledA_run() {
    if (ledA_acceso) {
        ledA_acceso = false;
    }
    else {
        ledA_acceso = true;
    }
    
    pilotaLed(ledA_pin, ledA_acceso);
}


// gestione stato led B
void ledB_run() {
    if (ledB_acceso) {
        ledB_acceso = false;
    }
    else {
        ledB_acceso = true;
    }
    
    pilotaLed(ledB_pin, ledB_acceso);
}


void setup() {
    pinMode(ledA_pin, OUTPUT);
    pinMode(ledB_pin, OUTPUT);
    
    pilotaLed(ledA_pin, ledA_acceso);
    pilotaLed(ledB_pin, ledB_acceso);
}


void loop() {
    // temporizzazione led A
    if (millis() - ledA_prevMillis > ledA_delay) {
        ledA_prevMillis = millis();
        
        ledA_run();
    }
    
    // temporizzazione led B
    if (millis() - ledB_prevMillis > ledB_delay) {
        ledB_prevMillis = millis();
        
        ledB_run();
    }
}

La buona notizia è che ci sono diverse librerie già pronte che implementano questo modello o utilizzano altre tecniche funzionalmente equivalenti per temporizzare delle funzioni in modo non bloccante. La stessa Time (tramite la libreria complementare TimeAlarms), SimpleTimer, looper, leOS / leOS2, ecc. Cercare nella sezione Playground / Timing.

Questo per rispondere al discorso "blink without delay = nebbia" :slight_smile: e per mostrare un abbozzo di "programmazione a stati" e "astrazione dall'hardware": notare infatti che lo sketch non opera direttamente con digitalWrite(), ma lavora su una variabile di stato slegata dall'hardware per ogni led da controllare. La funzione pilotaLed() serve da "cuscinetto separatore" tra lo stato logico (led acceso o spento) e come tale stato venga mappato sull'hardware (il led potrebbe essere acceso con HIGH o con LOW a seconda dei circuiti a valle del pin dell'Arduino).

Eventuali estensioni dello sketch sono lasciate al lettore come esercizio :stuck_out_tongue:

:relaxed:
Grazie adesso c’è meno nebbia.
Me lo devo rileggere con calma per poter digerire sta botta, e soprattutto usarla.
Concettualmente avevo già chiaro che delay non andasse e altrettanto concettualmente capisco perchè la programmazione a stati libera dal problema di tenere fermo il processore.
Il problema è entrare nella comprensione delle righe di codice, e per questo dovrò assimilare e poi provare a scrivere codice di pugno, altrimenti alla prima riga che scrivo fioccheranno errori logici a pioggia.

Grazie ancora

Il problema è entrare nella comprensione delle righe di codice, e per questo dovrò assimilare e poi provare a scrivere codice di pugno,

Un piano perfetto :slight_smile:

Una sequenza di "esercizi" IMHO molto utile è questa:

  • sketch di lampeggio di un led
  • sketch di rilevamento della pressione / rilascio di un tasto,
  • integrazione dei due: premendo il tasto si avvia il lampeggio, premendolo di nuovo lo si ferma.

E con questo siamo a 2,5 cents...

:slight_smile:

Una domanda invece sull’hardware.
Come ha scritto in precedenza qualcuno il rele’ ciuccia corrente, e se la corrente è troppa non va bene prenderla da Arduino.
Dato che nella mia idea la tensione al sistema viene fornita da un alimentatorea switching che alimenta tutto il progetto, la domanda è la seguente:
Avendo Arduino uno
LCD shield
RTC ds1307
ph probe
tutti attaccati insieme
e poi su banco separato un circuito con un banco di 8 rele pilotati a 5 volt.
http://www.google.it/imgres?num=10&hl=it&tbo=d&biw=1280&bih=709&tbm=isch&tbnid=y8EtVkJPBNihAM:&imgrefurl=http://www.miniinthebox.com/it/8-canali-5v-modulo-rele-shield-per-arduino_p411845.html&docid=48v4qoLwJ9G_QM&imgurl=http://cloud7.lbox.me/images/384x384/201209/8-canali-5v-modulo-rele-shield-per-arduino_tkjono1348813935172.jpg&w=384&h=384&ei=iLXpUM61IeeG4gTs24HIDA&zoom=1&iact=hc&vpx=4&vpy=113&dur=3271&hovh=225&hovw=225&tx=92&ty=112&sig=102568385651199734052&page=1&tbnh=143&tbnw=151&start=0&ndsp=28&ved=1t:429,r:0,s:0,i:88

Cosa faccio?
Alimento arduino e prelevo la tensione di 5v dal pin per alimentare anche il banco rele? Scalda troppo?
Oppure metto un alimentatore dedicato da 5 v e alimento ambedue i blocchi?

Nel primo caso avrei un bel alimentatore da pc portatile in avanzo che dovrebbe bastare alla bisogna (entra nelle specifiche di tensione)
Nel secondo caso è da comprare.
L’idea dell’alimentatore da pc fisso è interessante ma molto rumorosa e ingombrante.

Ciao
Andrea

prendi i 5 volt o quello che hai dall'alimentatore e su quelli ci attacchi l'arduino (Vin e ground)...

attento che dal sito che hai linkato c'è in offerta un modulo a 4 relay ma con fotoaccoppiatore: io ci farei un pensiero perchè questi con 8 ho l'impressione che sei al limite dei consumi sulla porta....per verificarlo potresi leggere gli ohm della bobina e vedere quanti ampere mangiano.

Ciao... Entro anche io nel topic nella speranza di darti una mano con la mia esperienza..
Io ho finito da qualche mese un mio progetto prototipo di un orchidario... (praticamente un acquario senza acqua con dentro le orchidee su zattere di sughero a radice nuda) io come te dovevo avere molti sensori da controllare e gestire sistemi per il controllo interno dell'habitat.
Sono partito,inanzi tutto, con la progettazione di un pcb esterno per l' alimentazione, per creazione dei bus I2c e ISP, per i driver di gestione delle ventole e di altri sistemi che poi ti elenco.
2 sensori luxomertri i2c (misurano la luce interna in alto e in basso della teca)
2 Sensori DH22 per la temperatura e umidità. (a te sicuramente non servono)
1 Sensore DS18B20 waterproof per il controllo della temperatura dell' acqua del raffreddatore. (Questo forse è quello che ti serve se devi misurare la temperatura dell'acqua, io uso un raffredatore per aquari per abbassare la temp interna)
1 Sensore per la qualità dell' aria.
..ecc.. Non vado oltre per il momento perchè non è il topic sul mio progetto, ma se sei interessato ti dirò il resto
I primi consigli che mi sento di darti sono..
1 Fatti un pcb per la gestione dell' alimentazione dei tuoi dispositivi (scheda relè, sensori, ecc..) io per questo uso un alimentatore di un pc e nella pcb porto le alimentazioni stabili di 5v e 3.3v.
2 Se puoi, non usare il ds1307, com RTC, ma dei DS3231SN che sono molto più precisi. Sono in SMD ma eventualmente trovi su adafruit delle schedine apposite.
3 Come ti hanno già suggerito, non usare i delay (o almeno il meno possibile) perchè appunto mentre c'è un delay non hai il controllo.. (io faccio un intero ciclo in un secondo).
4 Io uso un arduino mega perchè i pin mi stavano stretti, quindi se vuoi utilizzare un arduino Uno cerca di usare il più possibile i bus i2c e ISP.
5 Nella progettazione hardware, fai molta attenzione alle interferenze dei relè e di altri sistemi sui sensori e display.

ecco.. magari mentre tu procederai con il progetto ti indicherò dove ho trovato le difficoltà così magari da aiutarti...

alla prossima :wink:

qsecofr:
la strutturazione del programma è la parte più delicata del software: se imposti male all'inizio sputi sangue fino alla fine. Il delay non s'ha da usare in questi casi perchè un delay per esempio per aspettare la prontezza di un dato di temperatura interrompe tutte le altre operazioni: fintanto che il delay è limitato ad un sensore di temperatura (come era nel thread di danielicuius) il male è minore e si vede solo un mancato aggiornamento dei secondi... diventa decisamente pesante se il delay lo usi per fare l'alba ed il tramonto perchè rischio durante questo periodo di non poter fare nulla ne vedere nulla.

Vedo che siete in tanti a voler fare questo acquario. Ho aiutato danielicious a muovere i primi passi con il suo progetto (senza peraltro sapere all'inizio cosa doveva fare) e penso che tutto sommato sia un progetto abbastanza alla portata e fattibile da un programmatore senza tanto sforzo: mi piacerebbe potervi aiutare perchè il progetto mi appassiona (e chissa mai che un giorno non mi prenda anch'io una vasca) però purtroppo non ho l'hardware necessario per testare le vs situazioni. Devo però dire che ogni uno di voi avrà configurazioni hardware diverse quindi avrete anche programmi diversi per forza di cose.

Il consiglio che vi do è di impostare il programma a blocchi e di concentrarvi inizialmente sulla gestione del display e del menu (a tal fine c'è appunto la famosa libreria di bruinialti menwiz)... quando avete fatto quella il resto è una passeggiata (...il programma di danielicious in pratica già ha orologio e basi di schedulazione dei tramonti...però sarà da accantonare fintanto che non si pensa ad uno schema di menu.

Ciao sono Daniele, ringraziano ancora qsecofr per il suo aiuto, e lo quoto in tutto, in particolare sul fatto che ognuno di noi preferisce gestire la vasca a suo piacere, ma tutti noi abbiamo un uso del progetto comune, ossia: ora/data, temperatura, accensione lampade possibilmente tutto gestito tramite MENU.
Ora tutti noi abbiamo in parte pezzi di codice che "più o meno" funzionano secondo le nostre necessità.
Concludo dicendo che dobbiamo lavorare sulla creazione di un menu funzionante, utilizzando la libreria consigliata più su.
Grazie
Daniele

Grazie dei consigli, bello il progetto per l'orchidario.
in realtà però la gestione della temperatura e della luce è molto più semplice in acquario, e con meno sensori.
LA tolleranza per ambedue è maggiore.
Poi bisogna dire che alcune cose le ho già.
LM35 è bello e pronto
e il banco rele già acquistato.
Sul pilotaggio del banco rele vedo scritto solo
SRD-05VDC-SL-C della SONGLE

Visto che già è lì vorrei usarlo, magari poi sostituirlo una volta terminato il progetto, ma ancora tante cose mi mancano.

Parlando dell'alimentazione, parli di costruire un PCB per alimentare il tutto.
La domanda è a che tensione alimento il tutto a 5 V? e con che portata in Ampere?
E poi soprattutto io non ci capisco abbastanza da costruirne uno da solo.
Almeno un circuito di partenza mi serve.
Per l'orologio non ho capito bene, SMD che significa?
La mia idea era di utilizzare uno shield. I2C ?
Va bene, purchè non interferisca con lo shield che volevo mettere sopra (LCD).
Ancora mi rimane da prendere per farlo funzionare la parte più costosa che è la sonda Ph e il circuito di controllo.
In pratica sto cercando di andare avanti per gradi, ma non avendo un sistema già pronto provo i pezzi separatamente.
Lcd testato e usato, Sonda LM35 testata, adesso volevo capire come gestire le 8 uscite che devo impiegare per pilotare i rele.

Grazie
Ciao

ok allora procediamo con ordine...
@danidiscus. hai ragione ma secondo me prima di tutto bisogna un attimo capire esattamente quello che vuole fare con il menù e quindi io direi di fare dei punti su cosa il menù dovrà fare e forse ancora prima di questo lui avrà bisogno di una base hardware testata prima di iniziare a fare il codice, per non trovarci ad un certo punto davanti ad un muro..

Quindi se siete d'accordo farei anche una lista di punti su quello che il nostro arduino dovrà monitorare e controllare/azionare, una lista di punti su cosa il menù dovrà visualizzare e fare.
@hoop: Non ci sono problemi per i relè.. però sarebbe interessante se tu postassi una foto della scheda.
Per l' alimentazione vanno bene anche i soli 5V, tramite un circuito fatto appositamente o al limite prendendo un alimentatore dei pc che ti danno i 12v i 5v e anche i 3,3v.. io preferisco il circuito fatto appositamente.. Per gli ampere dipende da quello che vogliamo alimentare... il mio ha un massimo di 1,5A e alimenta un sacco di roba... per gli schemi ti posso dare anche i miei.. ma prima di tutto io disegnerei su "carta" il progetto... Come ho scritto prima.. "Cosa voglio monitorare e cosa voglio far controllare... Luci, pompa, luce attinica, erogatori d'ossigeno, ecc.." poi andremo a costruire il tuo sistema hardware e software.
Per l' orologio, ti consigliamo quello in in SMD (SMD è il tipo di costruzione del componente, sono quelli più piccoli saldati sulla superficie del PCB e non quelli saldati dentro i fori) perchè è molto più preciso.. Il DS1307 lo avevo provato anche io ma mi sballava qualche secondo ogni 10 gg.. perchè è molto influenzato dalla temperatura esterna... Il DS3231SN è anche acquistabile già montato su pcb che si collegano semplicemente ad arduino, come il DS1307.

Va bene, purchè non interferisca con lo shield che volevo mettere sopra (LCD).

Se ho capito bene il tuo LCD è montato su uno shield ? Posta la foto...
LM35DZ è abbastanza impreciso e risente parecchio delle interferenze esterne... Ma che temperatura devi misurare ? L' acqua immagino... e quindi presumo che lo dovrai immergere.. O sbaglio ?
Certo andiamo avanti a gradi e con ordine.. quindi intanto posta foto schemi e tutto quanto su cui possiamo basarci per iniziare...