iotgemini – introduzione all’architettura e protocolli ... · 2 – architettura e protocolli...
TRANSCRIPT
IOTGEMINI – Introduzione all’architettura e protocolli
Un progetto open source
Introduzione all'architettura e protocolli
Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
Un progetto open source alimentato da IOTGEMINI
Introduzione all'architettura e protocolli
Ultimo Aggiornamento 28/01/2019
1
IOTGEMINI
Introduzione all'architettura e protocolli
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
2
Appendice
1 – Introduzione all’applicazione ..................................................................................................................... 3
1.1 – Topologia di rete ................................................................................................................................... 4
1.2 – Come un Periferico viene installato ...................................................................................................... 5
1.3 – Le comunicazioni radio che avvengono tra Smart Gateway e Periferico ............................................. 7
1.4 – Come gli INPUT e OUTPUT vengono mappati su un Periferico ............................................................ 8
2 – Architettura e protocolli di comunicazione sullo Smart Gateway .......................................................... 11
2.1 – Introduzione ....................................................................................................................................... 11
2.2 – Il compito svolto dalla routine rfpi.c ................................................................................................... 13
2.3 – Come la GUI o applicativi leggono i dati e impartiscono comandi ..................................................... 13
3 – FIFO ............................................................................................................................................................ 15
3.1 – FIFO GUICMD ...................................................................................................................................... 15
3.2 – FIFO RFPI RUN ..................................................................................................................................... 16
3.3 – FIFO RFPI STATUS ................................................................................................................................ 17
3.4 – FIFO NET NAME .................................................................................................................................. 18
3.5 – FIFO RFPI PERIPHERAL ........................................................................................................................ 19
4 – Protocollo Radio ........................................................................................................................................ 21
4.1 – Il pacchetto di 16byte per ogni TX/RX ................................................................................................ 21
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
3
1 – Introduzione all’applicazione
L'architettura IOTGEMINI prevede un PC o Embedded PC, che chiameremo Smart Gateway, con collegato
transceiver radio IOTGEMINI.
L'applicazione operante sull' Smart Gateway è ideata per controllare una rete di senosri/attuatori che
chiameremo periferiche. Ogni periferica può fare diverse azioni. Tutte le periferiche devono obbedire a
questa architettura e rispettare i protocolli.
Questo documento spiega l’architettura, al fine di dare gli strumenti per progettare una periferica o
perlomeno per interagire in modo corretto con una esistente.
Un esperto programmatore può implementare la grafica per la periferica o creare un controllo specifico sul
software in esecuzione sullo Smart Gateway.
Il software di base (scaricabile) in esecuzione sullo Smart Gateway è composto da un applicativo WEB,
basato sul linguaggio php, che chiamiamo GUI ( GUI : Graphics User Interface). la GUI comunica con una
routine di basso livello attraverso delle FIFO (file scritti in RAM). La routine di basso livello è scritta in C e
generalmente viene avviata come servizio chiamato rfpi. Il rfpi viene eseguito quando lo Smart Gateway
viene acceso e gestisce la comunicazione seriale con il modulo radio e garantisce la corretta
ricetrasmissione di dati tra Smart Gateway e i periferici della rete. Il modulo radio invia e riceve dati
alle/dalle periferiche usando un protocollo a 16bytes.
Il sistema operativo usato è Linux.
Tutti i file GUI sono tenuti sotto il percorso:
/var /www
La routine rfpi.c è nel percorso :
/etc/rfpi
Le FIFO invece vengono create nel percorso:
/etc/rfpi/fifo
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
4
1.1 – Topologia di rete
La rete è gestita dallo Smart Gateway, assegna un indirizzo ad ogni Periferico che viene installato,
ne raccoglie i dati che vengono poi resi disponibili via Internet.
La figura 1.1.1 e 1.1.2 rappresentano l’accesso ai dati attraverso la rete per mezzo di vari dispositivi
come PC o Smart Phone collegati in diversi modi:
Figura: 1.1.1 – Esempio di accesso dati via rete Internet
Figura: 1.1.2 – Esempio di accesso dati via rete locale
Lo Smart Gateway quindi può inoltrare i dati al richiedente se connesso ad un router. Il tipo di
connessione con il router può essere WiFi o Ethernet.
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
5
1.2 – Come un Periferico viene installato
Quando un Periferico arriva sul luogo, dove deve essere installato, non conosce nessun riferimento
della rete operante in tal luogo. Quindi non può effettuare nessuna comunicazione con lo Smart
Gateway fino a quando non conosce l’indirizzo di esso e lo Smart Gateway deve conoscere
l’indirizzo del Periferico per poterlo gestire.
Per risolvere tale problema un pulsante è stato messo a bordo del Periferico (figura 1.2.1) il quale
un volta premuto porta il Periferico in ascolto su un indirizzo conosciuto che chiamiamo indirizzo-
password.
Figura: 1.2.1 – Esempio di pulsante per installare nella rete il Periferico
A questo punto un comando sullo Smart Gateway porta esso su stessa rete con indirizzo-password
ed incomincia la comunicazione con il nuovo Periferico.
Lo Smart Gateway si occupa di assegnargli gli indirizzi usati nella rete di tale luogo. A questo punto
interroga il periferico chiedendo il nome e le funzioni (nome e funzioni assegnati in fase di
fabbricazione) del nuovo Periferico.
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
6
La figura 1.2.2 riassume le comunicazioni scambiate tra lo Smart Gateway e il nuovo Periferico.
Figura: 1.2.2 – Comunicazioni scambiate in fase di installazione di un nuovo Periferico
Quando gli indirizzi sono stati assegnati il Periferico si auto configura su tali indirizzi e lo Smart
Gateway aggiunge nel file di mappatura una linea per il nuovo Periferico.
Lo Smart Gateway quindi ora conosce le funzionalità del Periferico e le rende disponibili all’utente
finale.
Fase C
Smart Gateway
1 – Richiesta Nome Periferico
Periferico
2 – Risposta con nome
Fase A
Smart Gateway
1 – Assegnazione indirizzi per configurazione rete
Periferico
2 – Risposta di avvenuta configurazione
Fase B
Smart Gateway
1 – Richiesta identificativo Periferico, numero IO, numero Funzioni
Periferico
2 – Risposta con numero identificativo, numero IO, numero Funzioni
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
7
1.3 – Le comunicazioni radio che avvengono tra Smart Gateway e Periferico
Lo Smart Gateway si comporta come master, può effettuare una richiesta di dati ad un Periferico o
impartire un comando come rappresentato nelle figure 1.3.1 e 1.3.2.
Figura: 1.3.1 – Richiesta dati
Figura: 1.3.2 – Comando
Il periferico può disporre del privilegio di svegliarsi da solo e di mandare lo stato di un input.
Questo privilegio del Periferico è stato dato per risolvere il problema di de localizzare l’attuazione
di un comando a fronte di un evento/input accaduto in un altro ambiente.
Figura: 1.3.3 – Esempio esecuzione comando a fronte di input de localizzato
2 – Notifica via
radio il nuovo
stato dell’input
1 - Input
Cambia
Stato
Smart Gateway Periferico
(soggiorno)
Smart Gateway
1 – Richiesta dato sensore X
Periferico
2 – Risposta con dato del sensore X
Smart Gateway
1 – Comando attiva relè X
Periferico
2 - Periferico esegue il comando
Periferico (locale
caldaia)
3 – Comando di
cambiare stato su
output
Smart Gateway
3 – Richiesta stato relè X
Periferico
4 – Risposta con stato del relè X eseguito
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
8
Come si deduce dalla figura 1.3.3 il Periferico installato in soggiorno notifica il cambiamento di un
input allo Smart Gateway che di conseguenza invia un comando di cambio stato output al Periferico
nel locale caldaia.
Si era pensato anche di far colloquiare direttamente il primo Periferico con il secondo ma di
conseguenza comportava che ogni Periferico avesse una mappa dell’ambiente. Inoltre la logica di
attivazione di un output X su un Periferico X doveva poter essere aggiornabile per eventuali futuri
cambiamenti. Questo comportava una moltitudine di logiche sparse nei vari Periferici, quindi
passando dallo Smart Gateway tutte le logiche rimangono raggruppate in questo ultimo oggetto
semplificando l’architettura e i relativi aggiornamenti.
1.4 – Come gli INPUT e OUTPUT vengono mappati su un Periferico
Ad ogni INPUT e OUTPUT è necessario assegnare un ID progressivo che parte da 0.
Facendo un esempio:
Un periferico con
- 2 INPUT digitali,
- 1 INPUT analogico
- 1 OUTPUT Digitale
- 1 OUTPUT Analogico
Avrà i seguenti ID:
- Primo INPUT digitale ID = 0
- Secondo INPUT digitale ID = 1
- Terzo INPUT Analogico ID = 2
- Primo OUTPUT Digitale ID = 0
- Secondo OUTPUT Analogico ID = 1
E buona norma assegnare gli ID partendo dagli IO digitali e per ultimi lasciare gli IO Analogici.
Quindi quando lo Smart Gateway richiede uno stato di un INPUT inserirà nella richiesta l’ID di un
INPUT mappato.
Il pannello di controllo (la GUI) che crea lo Smart Gateway per tale periferica potrà essere costruito
in modo generico come una serie di valori degli INPUT ed OUTPUT che si ferma al numero
massimo di INPUT e numero massimo di OUTPUT che vengono notificati dal periferico nella fase
B (figura 1.2.2) dell’installazione.
Oppure il pannello di controllo può essere costruito appositamente per tale periferico, conoscendo il
numero identificativo (fase B dell’installazione). Ad un numero identificativo corrisponde un solo
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
9
periferico con una serie di INPUT e OUTPUT conosciuti a priori, quindi lo Smart Gateway dato il
numero identificativo cercherà (se esiste) un pannello di controllo fatto appositamente per esso.
Nella GUI del software base il pannello di controllo e installato sotto la directory:
/var/www/lib/peripheral_X
Dove X indica il numero identificativo.
Il file:
/var/www/lib/list_cpanel_peripherals.php
Contiene la lista dei pannelli di controllo disponibili, quindi lo Smart Gateway elabora questo file e
se trova la corrispondenza per il numero identificativo del periferico installato, caricherà il pannello
di controllo (costruito appositamente), altrimenti caricherà un pannello di controllo generico.
Facendo un esempio pratico:
il periferico dell'immagine sotto stante ha mappati gli IO come segue:
Figura: 1.4.1 – Sensore-Attuatore ID per input e output
Per questo periferico appena visto il numero identificativo è il 3, quindi vediamo che il pannello di
controllo è contenuto sotto la directory:
/var/www/lib/peripheral_3
Input Digitale ID = 0
Output Digitale ID = 1
Nessun ID assegnato
perché usato nelle
funzioni per comandi
Infrarosso
Input Analogico ID = 2
Output Digitale ID = 0
Input Analogico ID = 1
Ottiene il primo ID libero
Sia come output/input
Ottiene il primo ID libero
Sia come output/input
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
10
Dentro il file “list_cpanel_peripherals.php” troviamo quindi il seguente listato:
………
include'./lib/peripheral_3/cpanel_3.php'; //library with the control panel for the third peripheral (Sensore-Attuatore)
………
}else if($idperipheral==3){
//peripheral with 2 sensors, 2 relay, 1 digital input, 2 GPIO, Infrared RX and TX
peripheral_3($id, $idperipheral, $name, $address, $numInput, $numOutput, $arrayNameInput, $arrayStatusInput,
$arrayNameOutput, $arrayStatusOutput);
return 1;
………
Quindi per ogni periferico ci sarà un “include” e una “if” come quella del codice riportato sopra.
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
11
2 – Architettura e protocolli di comunicazione sullo Smart Gateway
2.1 – Introduzione
L’architettura implementata su questo sistema è stata pensata per un sistema scalare. In questo
modo diversi periferici possono essere installati e controllati in modo diverso.
Sullo Smart Gateway una routine programmata in linguaggio C si occupa di interpretare i dati
ricevuti dalla radio, di fornire informazioni leggibili ad altre applicazioni, prendere comandi da altre
applicazioni, tradurre tali comandi e inviarli via radio.
Tutta la logica fatta da questa routine chiamata rfpi.c viene riassunta nella figura 2.1.1:
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
12
Figura: 2.1.1 – Funzionamento della routine rfpi.c operante sullo Smart Gateway
La GUI comunica tramite le FIFO con la routine rfpi.c che ha il compito di comunicare con le
periferiche tramite il transceiver radio.
Le periferiche analizzano i dati ricevuti e li eseguono rispondendo se necessario.
Tutte le FIFO sono spiegate nei capitoli seguenti come anche il protocollo di comunicazione di 16
byte che viene utilizzato per la comunicazione tra lo Smart Gateway e le periferiche.
Transceiver Radio
Smart Gateway
Periferico
Applicativi scrivono
comandi dentro il
FIFO nominato
GUI CMD
Esempio di
applicativo
con grafica
Comandi e Dati
Periferico
RFPI.C interpreta i
comandi letti nella
FIFO GUI CMD
RFPI.C scrive i dati
dentro le tre FIFO
Applicativi possono
leggere i dati dalle
tre FIFO
Comunicazione seriale
tra RFPI.C e il firmware
operante nella radio
Comunicazione wireless tra
radio e radio
RFPI.C è un software scritto in
linguaggio C.
Questo software è sempre operante
La radio integra un microcontrollore che svolge la
funzione di ricevere dati dalla radio e di convertirli, per
poi inviarli via seriale. Viceversa riceve dati via seriale e li
converte per essere spediti via radio.
Gli applicativi possono inviare quindi i dati via Internet. Quindi poi l’utente finale
disporrà di un interfaccia grafica per vedere e controllare tali dati.
FIFO GUI CMD
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
13
2.2 – Il compito svolto dalla routine rfpi.c
La routine rfpi.c è importante che esista perché fa da tramite tra la Radio e la GUI o applicativi. La
rfpi.c rende trasparente tutte quelle operazioni di configurazione della radio e di gestione della rete e
dell’indirizzamento univoco per ogni periferico.
Le comunicazioni logiche descritte nel capitolo precedente vengono proprio svolte dalla routine
rfpi.c, come l’installazione di un nuovo periferico. L’applicativo non dovrà mai occuparsi di
assegnare indirizzi a un Periferico, alla GUI o applicativo gli rimarrà il semplice compito di leggere
la struttura dati (dove sono contenuti gli stati di tutti gli input/output dei Periferici installati) e
quindi di impartire dei comandi.
Come introdotto e riassunto con la figura 2.1.1 l’applicativo può svolgere queste funzioni
leggendo/scrivendo dalle/nelle FIFO. Di seguito verrà spiegata cosa viene scritto dentro a queste
FIFO e come usarle.
2.3 – Come la GUI o applicativi leggono i dati e impartiscono comandi
La GUI o gli applicativi leggono i dati da tre FIFO e con un'altra FIFO possono impartire comandi.
In questo caso le FIFO non sono altro che dei file scritti sulla RAM dello Smart Gateway. Questi
file vengono aggiornati e letti dalla routine rfpi.c.
I file sono stati scritti su memoria RAM piuttosto che sulla memoria SD perché la memoria SD ha
un numero limitato di scritture.
L’applicativo non deve far altro che fare una semplice lettura di un file.
Qui una breve descrizione dei file FIFO:
- FIFO GUICMD: Questa FIFO viene scritta dall’applicativo e poi letta dalla routine rfpi.c
che ne interpreta il contenuto e quindi invierà tramite Radio i comandi.
Questa FIFO però è anche usata per impartire comandi alla stessa routine rfpi.c, come ad
esempio la scelta del nome della rete, oppure il cambio di nome logico di un Periferico.
- FIFO RFPIRUN: Questa FIFO viene letta dall’applicativo e scritta dalla routine rfpi.c.
All’interno vi è contenuto lo stato della rfpi.c come gli errori. Un esempio di errore è la
mancanza di comunicazione seriale con la Radio, all’interno quindi ci sarà scritto
“ERROR002”.
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
14
- FIFO RFPISTATUS:Questa FIFO viene letta dall’applicativo e scritta dalla routine rfpi.c.
La FIFO viene aggiornata quando viene impartito un comando. Le notifiche vengono rese
disponibili solo per un periodo limitato di circa due secondi. A fronte di un comando
impartito come il cambio di stato output potrebbe verificarsi che il Periferico non risponda,
quindi all’interno di questa FIFO troveremo scritto “NOTX” per due secondi, dopo i due
secondi ritornerà scritto “OK” che indica che la routine rfpi.c sta girando regolarmente.
- FIFO NETNAME: Questa FIFO viene letta dall’applicativo e scritta dalla routine rfpi.c.
Dentro vi è scritto il nome della rete Radio.
- FIFO PERIPHERAL: Questa FIFO viene letta dall’applicativo e scritta dalla routine
rfpi.c. Dentro vi è tutta la struttura dati di tutti gli input e output di ogni Periferico installato.
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
15
3 – FIFO
3.1 – FIFO GUICMD
FIFO scritto dal GUI e letta dal RFPI.C
Notazioni:
- Nome utilizzato per aprire la FIFO: fifoguicmd
- Percorso dove leggere il FIFO: / tmp / fifoguicmd
- Tipo: usato per dare il comando per l'applicazione rfpi.c
Tabella comandi:
CMD
(TAG0)
TYPE
(TAG1)
VALORE1
(TAG2)
VALORE2
(TAG3) commenti
NAME NET mionomerete NULL //imposta il nome della rete
NAME PERI mioperifericonome indirizzo //assegna nominativo al periferico
PERIOUT id_posizione id_output valore_output //assegna un valore ad un output
FIND NEW PERI NULL //avvia la procedure d’installazione nuovo periferico
DELETE PERI id_position NULL //disinstalla uno specifico periferico
STATUS ERROR GOT NULL //notifica alla routine chel’erroreemesso è statoricevuto
STATUS RFPI GOT NULL //notifica alla routine che lo stato è statoricevuto
REFRESH PERI STATUS ALL
//avvia una procedura dove la routine rfpi.c interroga via
radio tutti I periferici installati, quindi aggiorna la struttura
dati
DATA RF address_peri 16byte_esadecimali_ascii
//invia al periferico con address_peri 16 byte scritti in
esadecimale con formato ASCII
RTC SET hh:mm:ss NULL //imposta RTC
RFPI.C GUI
4 TAG
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
16
Le maiuscole e le parole in grassetto sono dei comandi, tutte le minuscole e parole corsive sono
i dati inseriti dall'applicativo GUI.
- CMD: identifica il tipo di comando e quali dati verranno eseguiti.
- TYPE: è un secondo parametro per identificare il comando.
- Valore1, Valore2: Vengono utilizzati per assegnare un valore o identificare una periferica o
un comando.
- Ogni NULL è solo utilizzato per completare le 4 colonne. Tra tutti i parametri e dopo il 4 °
parametro uno spazio deve essere inserito.
- id_posizione: si riferisce al periferico. Il primo periferico installato avrà posizione 0, il secondo
avrà posizione 1 e così via. Passando all’rfpi.c la posizione del periferico che si vuole
comandare, in automatico tirerà su il relativo indirizzo del periferico per poi inviargli via
radio i relativi comandi/dati.
- 16byte_esadecimali_ascii : si vuole intendere che se bisogna inviare il valore 255 per tutti i 16 byte
allora per ogni byte si scriverà in lettere FF. Quindi per 16 byte avremo:
- FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
- Ovviamente il periferico ricevente non capirà questi 16 valori perché per esempio i primi
due byte devono essere sempre quelli di filtro “R” e “B” che scritti in esadecimale sono
rispettivamente 0x52 e 0x42. Poi ci deve ancora essere un byte che indica il comando come
ad esempio “o” che in esadecimale diventa 0x6F (vedi protocollo di comunicazione radio).
Riscrivendo i 16 byte sostituendo i primi 3 byte con “RBo” viene fuori:
- 52426FFFFFFFFFFFFFFFFFFFFFFFFFFF
3.2 – FIFO RFPI RUN
FIFO scritto dal RFPI.C e letta dalla GUI.
Notazioni:
• Nome utilizzato per aprire la FIFO: fiforfpirun
• Percorso dove leggere il FIFO: / tmp / fiforfpirun
• Tipo: usato da GUI te per ottenere gli errori o lo stato di inizializzazione dell'applicazione
rfpi.c
RFPI.C GUI 1 TAG
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
17
Descrizione: l'applicazione rfpi.c scrive in questo FIFO quando si verifica un errore nella fase di
inizializzazione, nel caso in cui nessun errore è riscontrato allora in questo FIFO ci sarà scritto
"TRUE".
Tabella valori dentro la FIFO:
INIT STATUS (TAG0) In this column there are the comments
TRUE // la routine rfpi.c è stata inizializzata senza errori
ERROR001 //Impossibile inizializzare i GPIO per il controllo della radio
ERROR002 // nessuna comunicazione seriale con la radio
ERROR003 // il nome (indirizzo) della rete non è stato definito
3.3 – FIFO RFPI STATUS
FIFO scritto dal RFPI.C e letta dalla GUI.
Notazioni:
• Nome utilizzato per aprire la FIFO: fiforfpistatus
• percorso dove leggere il FIFO: / tmp / fiforfpistatus
• Tipo: la GUI ottiene lo stato di un evento dalla routine rfpi.c. Evento generato da un
comando.
Descrizione: la routine rfpi.c scrive dentro uno stato differente da “OK” a fronte di un evento
generato da un comando. Quando viene impartito un comando tramite il FIFO DATA RFPI allora
l'applicazione rfpi.c scrive in questa FIFO RFPI STATUS il nuovo stato per 5 volte ogni volta è
distanziato da un ritardo di 0,4 secondi.
RFPI.C GUI 1 TAG
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
18
Tabella valori dentro la FIFO:
STATO (TAG0) Scritto per Generato da commenti
OK
Sempre se non
ci sono altre
comunicazioni …
// sempre scritto se non si sono
verificati eventi
NOTX 5 volte
CMD = PERIOUT
scrittodentro laFIFO
GUICMD
// quando non c’è comunicazione
con il periferico
NOPERI 5 volte
CMD = FIND
scrittodentro la FIFO
GUICMD
// quando l’installazione di un
periferico non è andata a buon fine
address_peri
16byte_esadecimali_ascii 5 volte
CMD = DATA RF
Scritto dentro la FIFO
GUICMD
// a fronte del commando “DATA
RFaddress_peri
16byte_esadecimali_ascii” scritto nella
FIFO GUICMD può essere ricevuta
una risposta dal periferico che
quindi verrà scritta dentro questa
FIFO RFPISTATUS
3.4 – FIFO NET NAME
FIFO scritto dal RFPI.C e letta dalla GUI.
Notazioni:
• Nome utilizzato per aprire la FIFO: fifonetname
• Percorso dove leggere il FIFO: / tmp / fifonetname
• Digitare: la GUI ottiene il nome della rete radio
Descrizione: l'applicazione rfpi.c scrive in questa FIFO il nome della rete impostata.
Tabella valori dentro la FIFO:
Nome Rete (TAG0) Commenti
Nome_della_rete // qui è sempre scritto il nome della rete
RFPI.C GUI 1 TAG
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
19
3.5 – FIFO RFPI PERIPHERAL
FIFO scritto dal RFPI.C e letta dalla GUI.
Notazioni:
• nome utilizzato per aprire il FIFO: fifoperipheral
• percorso dove leggere il FIFO: / tmp / fifoperipheral
• Tipo: la GUI riceve tutti i dati per ogni periferica
Descrizione: la routine rfpi.c scrive 3 linee per ogni periferica installata
Le scritte in corsivo sono l’esempio di quello che può apparire nelle linee.
“ID posizione” è la posizione nella lista, la prima periferica ha valore 0, la seconda ha valore 1 e così
via.
“N” è il numero di ingressi o uscite.
“Address” è l’indirizzo scritto in caratteri ASCII in formato esadecimale.
RFPI.C GUI
3 LINES for each peripheral
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
20
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
21
4 – Protocollo Radio
4.1 – Il pacchetto di 16byte per ogni TX/RX
Il protocollo della radio invia 16 byte alle periferiche e se le periferiche rispondono riceverà sempre
16bytes. Nei 16 byte è presente un filtro, un comando e poi i dati.
Segue la tabella con i comandi indispensabili, che ogni periferica deve riconoscere e analizzare.
Identificativo_H e _L *: è il numero di identificazione univoco, che viene utilizzato per identificare
il tipo di periferica. Questo numero identificherà quindi il pannello di controllo da associare.
B0 e B1 sono utilizzati come filtro.
Descrizionicomandi:
• B2 = 'o':
Imposta l'uscita identificato dal “ID_output” con il valore dato nel byte B3. Periferica non
risponderà.
• B2 = 'p':
Interroga la periferica, la periferica risponderà con lo stesso B0, B1, B2 e B3, ma in B4
scrive il valore dell'uscita.
• B2 = 'i':
Interroga la periferica, la risposta sarà con gli stessi B0, B1, B2 e B3, ma in B4 sarà scritto
il valore dell'ingresso.
• B2 = 'w':
Invia gli indirizzi della rete.La periferica non risponde.
IOTGEMINI – Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
22
• B2 = 'n':
La periferica risponderà con il suo nome.Il nome non può essere più lungo di 13 caratteri.
• B2 = 't':
La periferica quando riceve la B2 = t risponde con 2 byte che identificano il tipo di
periferico (numero intero univoco) il numero di ingressi e uscite, che sono controllabili e
poi la versione del firmware.
• B2 = 'f':
Abilita / disabilitala funzione speciale identificata dal “ID_funzione” che è programmata
nella periferica. I “data” sono parametri che vengono usati come voluti. Se si usa questo
comando uno speciale pannello di controllo deve essere costruito nella GUI.
• B2 = 'u':
La periferica risponderà aggiungendo lo “stato_funzione” che può essere uguale a 1 (la
funzione è disabilitata), o altri valori compresi tra 2 e 255, usato per dire ABILITATO o
interpretato in modo differente, dipende dal tipo di periferico. Se si usa questo comando uno
speciale pannello di controllo deve essere costruito nella GUI.
La radio trasmette i TAG in grassetto e non evidenziati, che vengono poi interpretati dal periferico.
Il periferico risponde con le stesse variabili ma aggiungendo il valore desiderato.
I campi in arancione (campi evidenziati) sono i dati aggiunti dalla periferica nella risposta.
I caratteri in grassetto sono i comandi. Il rfpi.c manda i comandi in formato ASCII, quindi è
indispensabile inviare i comandi come mostrato nella tabella (maiuscole o minuscole). Per
analizzare i byte nel periferico, è possibile vedere i valori corrispondenti in una tabella ASCII come
segue.
IOTGEMINI – Introduzione all’architettura e protocolli
Pertanto il valore, che il periferico rimanda, deve essere convertito in ASCII. Se il valore
dell'ingresso che trasmette è un valore
invierà il carattere 'A'.
Introduzione all’architettura e protocolli Ultimo Aggiornamento 28/01/2019
Pertanto il valore, che il periferico rimanda, deve essere convertito in ASCII. Se il valore
trasmette è un valore analogico e questo valore in intero ha valore
Ultimo Aggiornamento 28/01/2019
23
Pertanto il valore, che il periferico rimanda, deve essere convertito in ASCII. Se il valore
analogico e questo valore in intero ha valore 65, la periferica