IOTGEMINI – Introduzione all’architettura e protocolli ... · 2 – Architettura e protocolli...

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


Ultimo Aggiornamento 28/01/2019

1

IOTGEMINI


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


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


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.


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.


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


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


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


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


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.


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:


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


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”.


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.


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


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


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


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


18


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


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.


Nome Rete (TAG0) Commenti

Nome_della_rete // qui è sempre scritto il nome della rete

RFPI.C GUI 1 TAG


19

3.5 – FIFO RFPI PERIPHERAL


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


20


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.


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


trasmette è un valore analogico e questo valore in intero ha valore

Ultimo Aggiornamento 28/01/2019

23


analogico e questo valore in intero ha valore 65, la periferica

IOTGEMINI – Introduzione all’architettura e protocolli ... · 2 – Architettura e protocolli...

Documents

Transcript of IOTGEMINI – Introduzione all’architettura e protocolli ... · 2 – Architettura e protocolli...