Buonasera a tutti. Benchè alle prime armi con Arduino e con la programmazione in C, ho deciso di cimentarmi in un progetto che, sicuramente è piu grande di me.
Pertanto, partendo dai vari progetti di esempio, ho iniziato con il combinare tra di loro le varie esperienze fatte per "far mio" quanto imparavo.
Finchè...acquistati i vari moduli RS485, non ho iniziato a far dialogare le varie schede tra di loro. Semplici messaggi, trasmessi con un codice trovato in rete.
Le trame inviate, sono composte come segue:
A questo punto, ho preso carta e penna (bugia...ho usato un foglio di calcolo) ed ho iniziato a scrivere i vari messaggi che master e slaves, si sarebbero scambiati. Da qualche prova fatta, mi son reso conto di un “limite” imposto dal codice trovato in rete. Non ho approfindito per capire in che modo l'autore (non so se posso citarlo, quindi per il momento mi astengo) abbia affrontato questo “problema”.
Il limite sta nel fatto che, al momento della “costruzione” della trama da inviare, i dati “passati” alla funzione sono mittente, destinatario, tipo di dato, dato 1 e dato 2.
La funzione, prima di calcolare il checksum manipola il tipo di dato in questo modo:
dato_da_inviare = tipo_di_dato << 2
I due bit che vengono liberati, vengon posti a 1 qualora dato 1 o dato 2 fossero o 0.
Va da se che i primi due bit a sinistra (MSB) DEVONO essere a 0 in quanto “spariscono” dopo lo shift: ergo...il numero massimo di tipo di dato sarà 63...diciamo che, per iniziare, non è affatto male!
A questo punto, quindi, ho iniziato a giochicchiare un po con varie schede montate “volanti” su breadboard al fine di imparare a trattare i dati da inviare, prepararli per l'invio e, a ricezione avvenuta, decodificarli nel modo corretto.
Non mi sembra il caso di dilungarmi oltremodo e cerco di venire subito al dunque.
Premesso che, caparbio come sono, vi sarei ipergrato se, anche a costo di farmi insultare, mi aiutaste (almeno per il momento) a capire qual è secondo voi, il giusto approccio: il codice bello e pronto è sicuramente comodo, ma...non mi aiuta a capire.
La struttura della rete, sarà composta in un primo momento da
1 master (Mega 2560) sulla quale verrà montato oltre al modulo di comunicazione seriale, un shield Ethernet per la gestione remota
4 slaves preconfigurati per accettare 8 ingressi digitali, 1 ingresso analogico e 7 uscite (le uscite azioneranno dei relays)
Spero in eventuali sviluppi futuri (slaves con display e tasti navigazine menu, ecc) ma per il momento, non posso mettere troppa carne al fuoco.
Il master, in loop, interroga le varie schede le quali, se non hanno subito variazioni sugli input, rispondono con un ACK (anche se saranno menzionati più tardi, non prendo ancora in considerazione gli input analogici).
Nel caso in cui vi fossero variazioni, il master, attiva/disattiva opportunamente le uscite in base alla programmazione utente.
Nei miei “esperimenti” atti ad apprendere, avevo creato diversi “switch” nel fw del master il quale “reagiva” accendendo o spegnendo un determinato led.
Ma...
Intanto gli ingressi possibili sono 40 (senza contare gli analogici) e le uscite sono 28 piu quelle del master stesso! Quindi, il programma perderebbe un tempo infinito alla ricerca dell'uscita (o gruppo di uscite) da attivare/disattivare.
Inoltre, con una programmazione di questo genere, ogni modifica lato utente, richiede una riscrittura del firmware con i vari problemi del caso.
La mia idea pertanto, prevede:
slaves dotati di “poca intelligenza” delegando la manipolazione delle uscite al master
scrittura della programmazione lato utente su carta SD
possibilità di modificare la programmazione utente via Ethernet
possibilità di inserire etichette per personalizzare ogni ingresso/uscita (16 caratteri se non chiedo troppo...)
Non ho mai affrontato un progetto di questa portata e mi rendo conto che il rischio che la mia presenza diventi il vostro incubo, è davvero concreto!
Personalmente, credo che la strada da percorrere, sia di organizzare in una tabella tutti i dati. Quindi qualcosa del genere:
Indirizzo (byte) rappresenta l'indirizzo della risorsa (01 il master, da 02 a 31 gli slaves, 32 il broadcast)
Pin (byte) rappresenta il pin relativo alla scheda
Ingresso/Uscita (boolean) 1: ingresso – 0: uscita
Etichetta (???) rappresenta l'etichetta visibile sugli eventuali display nonchè sull'applicazione LAN
Gruppo di appartenza (byte) rappresenta il gruppo di cui la risorsa fa parte (1)
Gruppo di destinazione (byte) rappresenta il gruppo a cui punta la risorsa (1)
Note: testo presente su SD ma visibile solo tramite PC. Potrebbe essere utile per scrivere annotazioni inerenti la risorsa in questione
(1): i gruppi potrebbero essere composti anche da un solo elemento.
Detto questo....
Quando il master riceve (e interpreta) la trama in ingresso, avrà a disposizione solo i primi due campi della tabella. Il terzo è ovviamente implicito mentre il quarto, non è importante dal punto di vista funzionale.
Il master, a questo punto, deve leggere dalla tabella il gruppo di appartenza e attivare/disattivare le uscite del gruppo di destinazione.
Sempre che quanto detto fin qui, non sia una castroneria unica, devo ammettere che sono un po perso.
Quindi prima di proseguire la mia avventura, vorrei un vostro parere circa quella che è la mia idea.
Come ho detto, sono alle prime armi con Arduino (ho fatto in passato un po di esperienza con vari PIC ma programmando quasi sempre in ASM o al limite in basic tramite l'IDE) quindi chiedo venia...
Sono parecchio testardo e intendo comunque portare avanti il progetto. Lo scopo finale? Sostanzialmente due...intanto poter installare concretamente qualcosa del genere in casa e soprattutto il piacere di poter dire: l'ho fatto io!
Attendo i vostri commenti, suggerimenti, proposte. Quanto agli insulti...se ne arrivassero, me li terrei!
Grazie a tutti!
