2.3 Protocollo di comunicazione

(1)

2 STANDARD ISO18000 – 6B

ISO (Organizzazione Internazionale per la standardizzazione) e la IEC (Commissione Internazionale Elettrotecnica) formano il sistema qualificato per gli standard in tutto il mondo.

La ISO/IEC 18000 è divisa i 6 parti:

Parte 1. - Parametri Generici per la comunicazione in aria per le frequenze totalmente accettate

Parte 2. - Parametri per la comunicazione in aria sotto i 135 kHz

Parte 3. - Parametri per la comunicazione in aria a 13.56 MHz

Parte 4. - Parametri per la comunicazione in aria a 2.45 GHz

Parte 5. - Parametri per la comunicazione in aria a 5.8 GHz

Parte 6. - Parametri per la comunicazione in aria a 860-930 MHz La parte che sarà descritta in questo capitolo è quella relativa ai sistemi RFID nella banda di frequenze 860-930 MHz, e cioè la Parte 6, che a sua volta è divisa in altre due parti, in relazione a due tipi di tag diversi che rispondono a questo stesso protocollo: Tipo A, Tipo B.

2.1 Introduzione

Questo standard descrive un sistema RFID con tag passivo/semipassivo backscatter che supporta le seguenti caratteristiche:

Identificazione e comunicazione nel campo con tags multipli.

(2)

Selezione di un sottogruppo di tags per l’identificazione o con quali comunicare

Leggere da o scrivere a o riscrivere dati molte volte a tags singoli

Memoria accessibile in lettura e scrittura, con possibilità di protezione della memoria da utente

Controllo d’integrità dei dati (CRC)

Comunicazione lettore-tag con rivelazione di errori

Comunicazione tag-lettore con rivelazione di errori

In questo sistema RFID, il lettore alimenta e comunica con i tags che sono all’interno del suo raggio d’azione.

I tags ricevono i dati come chiave ON/OFF di modulazione d’ampiezza.

Durante il tempo di risposta del tag, il lettore mantiene costante il livello di potenza trasmessa, mentre il tag modula l’impedenza d’ingresso dell’antenna. Il lettore poi riceve i dati trasmessi dal tag come variazione in riflessione della sua stessa potenza trasmessa.

2.2 Specifiche dello STANDARD

Questo standard descrive le seguenti specifiche:

Le iterazioni fisiche tra lettore e tag

Il protocollo e le istruzioni

Gli schemi di arbitrato di collisione

Le specifiche sono relative a due tipi di tag: Tipo A e Tipo B. La descrizione del protocollo sarà concentrata sul secondo tipo, ossia quello B, in quanto sono le specifiche di progetto seguite per la realizzazione del hardware del tag, descritto nel Capitolo 3.

(3)

Parametri Tipo B Codifica in ricezione (lato tag) Manchester

Indice di Modulazione m 11% o 100%

Data rate Lettore-tag: 10 or 40 kbps (secondo le norme locali) Tag-lettore: 40kbps

Tipo di modulazione Modulazione di ampiezza backscatter doppio stato

Codifica di trasmissione (lato tag) FM0 (Bi-Phase) Procedura di anticollisione Albero Binario

Identificatore unico del tag (UID) Contenuto in memoria e accessibile tramite alcuni comandi

Lunghezza UID 64 bits

Rivelazione di errori Lettore-tag, tag-lettore: 16 bit CRC Dimensioni della memoria del tag 256 bytes

Tabella 2.1 Specifiche principali del tag

2.2.1 Livelli fisici e codifica dati

La trasmissione dei dati dal lettore al tag è effettuata tramite modulazione di ampiezza della portante (ASK). Il bit rate è 10kbps o 40kbps. La codifica dei dati è realizzata grazie alla generazione di pulsazioni, che producono una codifica Manchester come mostrano le figure 2.2, 2.3, tabella 2.2, tabella 2.3.

(4)

Figura 2.1 Modulazione 99%

Parametri Minimo Nominale Massimo M =(A-B)/(A+B) 90% 100% 100%

Ma 0 0.03 (A-B)

Mb 0 0.03 (A-B)

Tr 0 µs 1.8 µs 0.1 / fDatarate

Tf 0 µs 1.8 µs 0.1 / fDatarate

Tabella 2.2 Parametri per la modulazione 99%

Figura 2.2 Modulazione 11% (esempio a 40kbps)

(5)

Parametri Minimo Nominale Massimo

M =(A-B)/(A+B) 8% 11% 15%

Ma 0 0.05 (A-B)

Mb 0 0.05 (A-B)

Tr 0 µs 0.17/fDatarate

Tf 0 µs 0.17/fDatarate

Tabella 2.3Parametri per la modulazione 11%

La codifica Manchester è un tipo di codifica che effettua una transizione di livello, a metà periodo, per ogni bit trasmesso: l ’1’ha la prima metà del periodo del bit alta, la seconda bassa, mentre lo ‘0’ è come l’1’ ma invertito come mostra la figura 2.3 e 2.4.

Figura 2.3 Codifica Manchester

Figura 2.4 Modulazione del campo con codifica Manchester

(6)

La codifica Manchester fornisce un modo semplice per codificare sequenze binarie arbitrarie senza mai aver lunghi periodi di tempo privi di transizioni.

Il tag trasmette le informazioni al lettore modulando l’energia incidente e riflettendola nuovamente al lettore (tecnica backscatter). La modulazione avviene nel seguente modo: il tag cambia la proprietà di riflessione fra due stati, attraverso l’impedenza d’ingresso che vede ai terminali dell’antenna.

Lo stato “space” è la condizione normale in cui il tag è alimentato dal lettore ed è in grado di ricevere e decodificare i dati in ricezione. Lo stato

“mark” è la condizione alternativa creata dal tag cambiando l’impedenza d’ingresso dell’antenna.

Il bit rate dei dati trasmessi è di 40kbps. IL bit che viene inviato per prima è il bit MSB. La tecnica di codifica utilizzata è la FM0, nota anche come Spazio Bi-Fase come si vede in figura 2.5.

Figura 2.5. Codifica FM0 del byte ‘B1’

Data rate Trlb Tolleranza

40kbps 25 µs +/-15%

Tabella 2.3. Parametri di trasmissione

(7)

La codifica FM0 è un tipo di codifica che cambia livello per tutti i bit trasmessi, anche se sono tutti ‘1’ o tutti ‘0’ consecutivi, in più il livello ‘0’

cambia livello a metà del periodo compiendo una transizione dipendente dal bit precedentemente trasmesso. Ad esempio se trasmetto uno ‘0’, questo sarà alto-basso, o basso-alto, nel periodo, a seconda che il bit trasmesso prima era livello basso o livello alto rispettivamente.

2.3 Protocollo di comunicazione

Dalle specifiche si legge che le informazioni dal lettore al tag, vengono trasmesse serialmente secondo la codifica Manchester, ad un bit rate di 10kbps o 40kbps a seconda delle normative locali. I dati ricevuti vengono decodificati e divisi in una serie di campi, con lunghezza variabile multipla di 1 byte (8 bit) e che vanno a costituire l’intera trama.

Il protocollo di comunicazione definisce il meccanismo per lo scambio d’istruzioni e dati tra lettore e tag, in entrambe le direzioni di comunicazione. Per il tipo di modulazione utilizzata dal tag, e cioè backscatter, il lettore dopo aver trasmesso l’informazione, aspetta, mantenendo il campo costante (nessuna modulazione), che il tag risponda, per un periodo di tempo, stabilito dal protocollo. Questo campo si chiama campo WAIT .

E’ il lettore che inizia per primo il processo di comunicazione trasmettendo il comando. Il tag che si trova nella zona d’interrogazione, risponde al lettore (modulando) se e solo se ha decodificato correttamente il comando ricevuto.

(8)

Ogni comando ed ogni risposta sono contenuti in frame. Questi sono divisi in più campi, ognuno dei quali ha lunghezza diversa. I campi del comando sono descritti quanto segue:

Preambolo

Start Delimiter

Istruzione

Campo Parametri

Campo Dati

CRC

I campi della risposta sono invece:

Preambolo di ritorno

Campo Dati

CRC

Ogni campo dei due tipi di frame è composto da più bit. Il numero di bit trasmesso è multiplo di otto che corrisponde ad un byte, ed ogni campo può contenere più di 1 byte.

MSB LSB

bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0 Tabella 2.4 Rappresentazione di un byte

MSB LSB

Byte 7

Byte 6

Byte 5

Byte 4

Byte 3

Byte 2

Byte 1

Byte 0 Tabella 2.5 Rappresentazione di una word

(9)

L’ordine di trasmissione per ogni byte è dal bit più significativo (MSB) al bit meno significativo (LSB). L’ordine di trasmissione di una word (8bytes) è lo stesso del byte.

2.4 Formato del Comando

Abbiamo precedentemente accennato quali sono i campi del Comando che trasmette il lettore nel processo di comunicazione, figura 2.6.

Figura 2.5

2.4.1 Campo Preamble detect

Il campo preambolo detect consiste in un campo costante (no modulazione) che dura minimo 400μ . Questo tempo corrisponde a 16 bit, s per una velocità di comunicazione pari a 40kbps.

2.4.2 Campo Preambolo

Il preambolo è un campo di 9 bit ‘0’ della codifica Manchester, in formato NRZ: 010101010101010101

(10)

2.4.3 Campo Start Delimiter

Esistono quattro tipi di delimitatori:

 Delimiter – 1: 1100111010

 Delimiter – 2: 0101110011

 Delimiter – 3: 0011100101

 Delimiter – 4: 11011100101

Quelli usati sono il primo e l’ultimo, mentre il secondo ed il terzo sono RFU (riservati per uso futuro). L’unica differenza tra il Delimiter1 e il

Delimiter 2 è che il data rate in trasmissione è 4 volte più grande di quello in ricezione.

2.4.4 Campo DATI

Il campo dati è formato dalle informazioni vere e proprie che si vogliono trasmettere al Tag. Questo campo si divide in: ISTRUZIONI, PARAMETRI e DATI. Questi ultimi due sono dipendenti dal tipo d’ISTRUZIONE che si vuole trasmettere, e questa che determina le dimensione dei campi successi.

Parleremo nei prossimi paragrafi quali sono le istruzioni del protocollo di comunicazione.

2.4.5 Campo CRC

Il polinomio generatore utilizzato per il calcolo del CRC-16 è

5 1

12

16+ X +X +

X , che corrisponde allo standard CRC-CCITT. Il registro del tag a 16 bit sarà inizializzato al valore esadecimale “FFFF”. Il risultato

(11)

del calcolo CRC sarà “1D0F”, se il valore dal comando trasmesso è giusto altrimenti c’è un errore in trasmissione ed il dato sarà scartato.

2.5 Formato della risposta

La risposta del tag consiste nei campi seguenti:

Figura 2.6 Formato della risposta.

2.5.1 Cambo Quiet

Il tag non deve rispondere per 2 bytes (400μ a 40 kbps). La durata del s tempo di quiet, è determinata dal velocità di comunicazione della risposta del tag.

2.5.2 Campo Return Preamble

Il preambolo di ritorno è una serie di 16 bit come mostra figura 2.7, in formato NRZ corrispondono: 00000101010101010101000110110001

Figura 2.7 Preambolo di ritorno.

(12)

2.5.3 Campo DATI

I dati della risposta sono: codice UID, conferma di accesso in scrittura avvenuto con successo, dati memorizzati in memoria, errori di scrittura, etc.

2.5.4 Campo CRC

Anche questo campo, come quello nel formato del comando, deve avere un polinomio generatore CRC-16 pari a X¹⁶+X¹² +X⁵+1. Il registro sarà inizializzato a “FFFF”, calcolerà il valore del CRC del dato da trasmettere, invertito e trasmesso in coda al dato.

2.6 WAIT

Il campo WAIT viene usato per permettere al tag di rispondere. Quello che avviene è che il lettore, dopo aver trasmesso l’intero frame di comando, mantiene costante il campo generato, senza nessuna modulazione, per un tempo minimo di 15 ms.

Questo campo è utilizzato anche per un accesso in scrittura della memoria. Durante questo tempo, il tag scriverà un byte o più bytes (massimo 4) all’interno della memoria.

(13)

2.7 Il campo FLAGS

Il tag deve sostenere un campo a 8 flags, chiamato FLAGS, come mostra la tabella.

Bit Nome

FLAG1 (LSB) DE_SB (Data_Exchange Status Bit) FLAG2 WRITE_OK

FLAG3 BATTERY_POWERED FLAG4 BATTERY_OK FLAG5 0 (RFU)

FLAG6 0 (RFU) FLAG7 0 (RFU) FLAG8 (MSB) 0 (RFU)

Tabella 2.6

Il bit DE_SB viene settato quando il tag va nello stato DATA_EXCHANGE, e non lo cambia fino a quando non passa nello stato POWER_OFF. Se il tag riceve il comando INIZIALIZE, questo resetta immediatamente il bit DE_SB.

Il bit WRITE_OK verrà settato dopo una accesso in scrittura nella, memoria, eseguita con successo.

Il bit BATTERY_POWERED è settato se il tag è di tipo semi-passivo, e cioè ha una batteria. Se è si tipo passivo, il bit è resettato.

Il bit BATTERY_OK sarà settato quando la batteria ha sufficiente energia per alimentare il tag. Se il tag è passivo sarà 0.

(14)

2.8 Organizzazione e protezione della memoria

La memoria funzionale del tag deve essere organizzata in locazioni di un byte. Possono essere indirizzati fino a 256 locazioni da un byte, con una capacità massima di 2 Kbits. Questa struttura, prevede delle estensioni future della memoria. All’interno della memoria risiederà anche il seriale identificativo unico del tag (UID).

Ogni locazione deve avere un corrispondente bit di protezione. Questo bit sarà settato tramite il comando LOCK , il ché significa che il byte corrispondente non sarà più accessibile in scrittura. Lo stato di tutti i bit di chiusura potranno essere letti attraverso il comando QUERY_LOCK. Ci sono dei bit di chiusura settati nel tag dalla azienda produttrice che non possono essere resettati. Infatti in molti casi, i tag entrano in commercio già con il seriale UID impostato dalla azienda.

2.9 Stati del tag

Il tag ha 4 stati principali:

 POWER-OFF: il tag si trova nello stato POWER-OFF quando il lettore non riesce ad attivarlo (Per i tag assistiti da batteria, significa che il livello di eccitazione RF è insufficiente per la comunicazione).

 READY: il tag è nello stato READY quando il lettore gli fornisce energia.

 ID: il tag si trova nello stato ID quando il lettore cerca di identificarlo

(15)

 DATA_EXCHANGE: il tag si trova nello stato DATA_EXCHANGE quando è stato riconosciuto dal lettore ed è selezionato.

Figura 2.8 Diagramma a stati

Questo diagramma a stati mostra solo poche transizioni tra le tante possibile, tra gli stati del tag. La tabella seguente descrive tutte le transizioni possibili:

Stato corrente Istruzione Condizione Nuovo stato

POWER-OFF ANY COMMAND POWER OFF

POWER-OFF “Power up” READY

READY GROUP_SELECT_EQ ≠ READY READY GROUP_SELECT_NE = READY READY GROUP_SELECT_GT ≤ READY READY GROUP_SELECT_EQ_FLAGS flag not set READY READY GROUP_SELECT_NE_FLAGS flag set READY READY GROUP_SELECT_LT ≥ READY

READY GROUP_SELECT_EQ = ID

READY GROUP_SELECT_NE ≠ ID

READY GROUP_SELECT_GT > ID READY GROUP_SELECT_LT < ID READY GROUP_SELECT_EQ_FLAGS flag set ID READY GROUP_SELECT_NE_FLAGS flag not set ID

(16)

READY INITIALIZE READY

READY READ ID no match READY

READY READ ID match DATA_EXCHANGE READY READ_VERIFY ID no match or

not

WRITE_OK READY READY READ_VERIFY ID match and

WRITE_OK DATA_EXCHANGE READY READ_VERIFY_4BYTE ID no match or

not

WRITE_OK READY READY READ_VERIFY_4BYTE ID match and

WRITE_OK DATA_EXCHANGE READY WRITE ID no match READY

READY WRITE ID match DATA_EXCHANGE READY WRITE4BYTE ID no match READY

READY WRITE4BYTE ID match DATA_EXCHANGE READY QUERY_LOCK ID no match READY

READY QUERY_LOCK ID match DATA_EXCHANGE READY READ_FLAGS ID no match READY

READY READ_FLAGS ID match DATA_EXCHANGE READY READ_VARIABLE ID no match READY

READY READ_VARIABLE ID match DATA_EXCHANGE READY READ_PORT ID no match READY

READY READ_PORT ID match DATA_EXCHANGE READY READ_UNADDRESSED DATA_EXCHANGE

ID GROUP_UNSELECT_EQ ≠ ID

ID GROUP_UNSELECT_NE = ID

ID GROUP_UNSELECT_GT ≤ ID

ID GROUP_UNSELECT_LT ≥ ID

ID GROUP_UNSELECT_EQ_FLAGS flag not set ID ID GROUP_UNSELECT_NE_FLAGS flag set ID

ID GROUP_UNSELECT_EQ = READY

ID GROUP_UNSELECT_NE ≠ READY

ID GROUP_UNSELECT_GT > READY ID GROUP_UNSELECT_LT < READY ID GROUP_UNSELECT_EQ_FLAGS flag set READY ID GROUP_UNSELECT_NE_FLAGS flag not set READY ID MULTIPLE_UNSELECT ≠or not

WRITE_OK ID

ID MULTIPLE_UNSELECT = and

WRITE_OK READY

ID GROUP_SELECT_EQ ID

ID GROUP_SELECT_NE ID

ID GROUP_SELECT_GT ID

ID GROUP_SELECT_LT ID

ID GROUP_SELECT_EQ_FLAGS ID

ID GROUP_SELECT_NE_FLAGS ID

ID FAIL ID

ID SUCCESS ID

ID RESEND ID

ID INITIALIZE READY

ID READ ID no match ID

ID READ ID match DATA_EXCHANGE

ID DATA_READ ID no match ID

ID DATA_READ ID match DATA_EXCHANGE

(17)

ID READ_VERIFY ID no match or not

WRITE_OK ID ID READ_VERIFY ID match and

WRITE_OK DATA_EXCHANGE ID READ_VERIFY_4BYTE ID no match or

not

WRITE_OK ID ID READ_VERIFY_4BYTE ID match and

WRITE_OK DATA_EXCHANGE

ID WRITE ID no match ID

ID WRITE ID match DATA_EXCHANGE

ID WRITE4BYTE ID no match ID

ID WRITE4BYTE ID match DATA_EXCHANGE

ID WRITE_MULTIPLE ID

ID WRITE4BYTE_MULTIPLE ID

ID QUERY_LOCK ID no match ID

ID QUERY_LOCK ID match DATA_EXCHANGE

ID RESEND_O ID

ID READ_FLAGS ID no match ID

ID READ_FLAGS ID match DATA_EXCHANGE ID READ_VARIABLE ID no match ID

ID READ_VARIABLE ID match DATA_EXCHANGE

ID READ_PORT ID no match ID

ID READ_PORT ID match DATA_EXCHANGE

ID FAIL_O ID

ID SUCCESS_O ID

ID DATA_READ_O ID no match ID

ID DATA_READ_O ID match DATA_EXCHANGE

ID READ_UNADDRESSED DATA_EXCHANGE

DATA_EXCHANGE INITIALIZE READY

DATA_EXCHANGE READ DATA_EXCHANGE

DATA_EXCHANGE DATA_READ DATA_EXCHANGE DATA_EXCHANGE READ_VERIFY DATA_EXCHANGE DATA_EXCHANGE READ_VERIFY_4BYTE DATA_EXCHANGE

DATA_EXCHANGE WRITE DATA_EXCHANGE

DATA_EXCHANGE WRITE4BYTE DATA_EXCHANGE DATA_EXCHANGE WRITE4BYTE_MULTIPLE DATA_EXCHANGE DATA_EXCHANGE WRITE_MULTIPLE DATA_EXCHANGE

DATA_EXCHANGE LOCK DATA_EXCHANGE

DATA_EXCHANGE QUERY_LOCK DATA_EXCHANGE DATA_EXCHANGE READ_UNADDRESSED DATA_EXCHANGE DATA_EXCHANGE DATA_READ_O DATA_EXCHANGE DATA_EXCHANGE READ_FLAGS DATA_EXCHANGE DATA_EXCHANGE READ_VARIABLE DATA_EXCHANGE DATA_EXCHANGE READ_PORT DATA_EXCHANGE

(18)

2.10 Regole di anticollisione

Il lettore può usare i comandi GROUP_SELECT e GROUP_UNSELECT per decidere se scegliere tutti o un sottoinsieme di tag all’interno del campo, per attuare la procedura di anticollisione. Per l’arbitrio di collisione il tag deve prevedere due strutture hardware interne:

Un contatore a 8 bit COUNT

Un generatore casuale con due sole possibilità:’0’ o ‘1’.

Inizialmente, il gruppo di tag selezionati per l’arbitrio di collisione, passano nello stato ID, tramite i comandi GROUP_SELECT. Questi metteranno il valore del contatore COUNT a 0. Sottoinsiemi del gruppo possono essere de-selezionati tramite i comandi GROUP_UNSELECT, e riportati nello stato READY.

Dopo la selezione di tutti i tag o di un sottogruppo, inizia l’algoritmo con i seguenti passi:

1. Tutti i tag nello stato ID, con il contatore COUNT pari a 0, trasmetteranno la loro UID.

2. se più di un tag trasmette simultaneamente, il lettore riceverà un segnale indecifrabile, quindi automaticamente trasmetterà il comando FAIL.

3. Tutti i tag che ricevono il comando FAIL ed hanno il COUNT uguale a 0, incrementeranno il COUNT. Tutti i tag che hanno ricevuto il comando FAIL e con COUNT uguale a zero (cioè i tag che hanno appena trasmesso) genereranno un numero casuale:

quelli che genereranno 1 incrementano il COUNT e non trasmettono, quelli che genereranno 0 lasciano il COUNT a 0 e trasmettono nuovamente il loro UID.

Accade una delle seguenti 4 possibilità:

(19)

4. Se più tag ritrasmettono UID, il lettore rinvierà nuovamente il comando di FAIL ripetendo il passo 2(Possibilità 1)

5. Se tutti i tag generano un 1, nessuno trasmette. Il lettore a questo punto non riceve niente, ed trasmette il comando SUCCESS.

Tutti i contatori si decrementano e i tag con COUNT uguale a 0 trasmettono. Tipicamente si ritorna al passo 2 (Possibilità 2).

6. Se solo un tag trasmette e la UID è ricevuta correttamente, il lettore deve trasmettere il comando DATA_READ con la ID del tag appena ricevuta. Se questo comando viene ricevuto correttamente il tag cambierà stato passando allo stato DATA_EXCHANGE, e trasmetterà i sui dati. Quindi il lettore trasmetterà il comando SUCCESS, tutti i tag nello stato ID decrementeranno il COUNT.

7. Se un solo tag ha il COUNT a 0 e trasmette, vengono ripetuti i passi 5 e 6, altrimenti torniamo al passo 2.

8. Se un solo tag trasmette e l’UID viene ricevuto con un errore, il lettore trasmetterà il comando di RESEND. Se l’UID viene ricevuta correttamente, si ripete il passo 5. Se l’UID viene ricevuto di nuovo un numero variabile di volte (questo numero può essere impostato sul livello di trattamento di errori desiderato dal sistema) si suppone che più di un tag stia trasmettendo, e si ripete il passo 2.

2.11 Le ISTRUZIONI

Le istruzioni trasmesse nel frame trasmesso dal lettore, sono divisi in quattro gruppi funzionali:

(20)

Comandi di selezione

Comandi di identificazione

Comandi di trasferimento dati

Comandi multipli

Inoltre i comandi possono essere di 4 tipi:

Obbligatori

Opzionali

Custom

Riservati (esclusivi)

2.11.1 I tipi

Tutti i tag con lo stesso codice del fabbricante IC e lo stesso numero di versione IC, si comporteranno allo stesso modo.

2.11.1.1 Obbligatori

Le codifiche dei comandi Obbligatori vanno da ‘00’ a ‘0F’, ‘11’ a ‘13’,

‘15’ e ‘1D’ a ‘3F’. Tutti i tag devono rispettarli.

2.11.1.2 Opzionali

Le codifiche dei comandi Opzionali vanno da ‘17’ a ‘1C’ e da ‘40’ a

‘9F’. Tutti i tag possono supportarli facoltativamente. Se supportati, i

(21)

formati dei comandi e delle risposte devono uniformarsi alle definizioni date in questo standard. Se non supportati, rimarranno in silenzio.

2.11.1.3 Custom

Le codifiche vanno da ‘A0’ a ‘DF’.

Anche questi possono essere supportati dai tag facoltativamente, e servono per implementare funzioni speciali definite dal fabbricante. Gli unici campi che possono essere resi custom sono i campi PARAMETRI e i DATI.

Ogni comando custom contiene come suo primo parametro il codice IC del fabbricante. Questo permette di implementare i comandi senza rischiare di duplicare la codifica e quindi la presenza di un errore inevitabile.

Se il tag non supporta questi tipi di comandi, rimarrà in silenzio.

2.11.1.4 Riservati

Le codifiche del comando sono ’10, ’14, ’16, e da ‘E0’ a ‘FF’.

Questi comandi vengono usati dal fabbricante del IC e di tag per vari scopi quali test, programma d’informazione di sistema, etc. Questi non vengono specificati in questo standard. Il fabbricante IC può, se vuole, documentarli o no. E’ possibile che questi comandi siano resi inattivi dopo la fabbricazione del IC o del tag.

Seguono delle tabelle della descrizione dei codici e formati dei comandi, dimensione dei campi, risposte dei tag.

(22)

2.11.2 Codifica e formato

Le codifiche dei comandi e i formati sono mostrati nella tabella 2.7

Codifica Tipo Nome dell’istruzione Parametri

'00' Obbligatori GROUP_SELECT_EQ ADDRESS BYTE_MASK WORD_DATA '01' Obbligatori GROUP_SELECT_NE ADDRESS BYTE_MASK WORD_DATA '02' Obbligatori GROUP_SELECT_GT ADDRESS BYTE_MASK WORD_DATA '03' Obbligatori GROUP_SELECT_LT ADDRESS BYTE_MASK WORD_DATA '04' Obbligatori GROUP_UNSELECT_EQ ADDRESS BYTE_MASK WORD_DATA '05' Obbligatori GROUP_UNSELECT_NE ADDRESS BYTE_MASK WORD_DATA '06' Obbligatori GROUP_UNSELECT_GT ADDRESS BYTE_MASK WORD_DATA '07' Obbligatori GROUP_UNSELECT_LT ADDRESS BYTE_MASK WORD_DATA '08' Obbligatori FAIL none none none '09' Obbligatori SUCCESS none none none '0A' Obbligatori INITIALIZE none none none '0B' Raccomandato DATA_READ ID ADDRESS none '0C' Obbligatori READ ID ADDRESS none '0D' Raccomandato WRITE ID ADDRESS BYTE_DATA '0E' Raccomandato WRITE_MULTIPLE none ADDRESS BYTE_DATA '0F' Raccomandato LOCK ID ADDRESS none '10' Proprietary IC manufacturer dependant

'11' Raccomandato QUERY_LOCK ID ADDRESS none '12' Raccomandato READ_VERIFY ID ADDRESS none '13' Raccomandato MULTIPLE_UNSELECT ADDRESS BYTE_DATA none '14' Riservati IC manufacturer dependant

'15' Obbligatori RESEND none none none '16' Riservati IC manufacturer dependant

'17' Raccomandato GROUP_SELECT_EQ_FLAGS none BYTE_MASK BYTE_DATA '18' Raccomandato GROUP_SELECT_NE_FLAGS none BYTE_MASK BYTE_DATA '19' Raccomandato GROUP_UNSELECT_EQ_FLAGS none BYTE_MASK BYTE_DATA

(23)

'1A' Raccomandato GROUP_UNSELECT_NE_FLAGS none BYTE_MASK BYTE_DATA

'1B' Raccomandato WRITE4BYTE ID ADDRESS BYTE_

MASK 4BYTE _DATA

'1C' Raccomandato WRITE4BYTE_MULTIPLE ADDRESS BYTE_MASK 4BYTE_DATA '1D' Raccomandato READ_VERIFY_4BYTE ID ADDRESS none

‘1E’-

‘3F’ Obbligatori RFU

‘40’,

‘41’ Opzionali FAIL_O none none none

‘42’,

‘43’ Opzionali SUCCESS_O none none none

‘44’,

‘45’ Opzionali DATA_READ_O ID ADDRESS none

‘46’,

‘47’ Opzionali RESEND_O none none none

‘48’ –

‘4F’ Opzionali RFU

Tabella 2.7 Formato e codice del comando

Nella tabella 2.8 vengono mostrati i campi costituenti i frame sia di ricezione che di trasmissione, e le loro dimensioni.

Nome del Campo Dimensione

COMMAND 1 byte ADDRESS 1 byte BYTE_MASK 1 byte

ID 8 bytes

WORD_DATA 8 bytes BYTE_DATA 1 byte 4BYTE_DATA 4 bytes

LENGTH 1 byte

CRC-16 2 bytes

Tabella 2.8Campi e dimensioni dei campi

La tabella 2.9 mostra la codifica, la grandezza delle risposte del tag.

(24)

Codice della

risposta Nome della risposta Dimensione ACKNOWLEDGE 1 byte '00'

ACKNOWLEDGE_NOK 1byte

'01' ACKNOWLEDGE_OK 1byte 'FE' ERROR_NOK 1byte ERROR 1byte 'FF'

ERROR_OK 1byte n/a WORD_DATA 8 bytes

N/a VARIABLE DATA LENGTH bytes n/a BYTE_DATA 1byte

CRC-16 2 bytes ID 8 bytes

Tabella 2.9 Risposta del tag

2.11.3 Descrizione delle ISTRUZIONI

2.11.3.1 Istruzioni di selezione

Le istruzioni di selezione definiscono un sottoinsieme di tags all’interno del campo d’interrogazione da identificare o scrivere. Questi sono i tag usati per la procedura di anticollisione.

Ogni istruzione di selezione ‘sulla memoria’ ha tre argomenti (parametri e dati):

ADDRESS

BYTE_MASK

WORD_DATA

Il tag farà uno dei quattro confronti possibili:

1. EQ M D ≡ 2. NE M D ≠ 3. GT M > D

(25)

4. LT M < D M =

M0+M1* +M1*2⁸ 2¹⁶+M1*2²⁴+M1*2³²+M1*2⁴⁰+M1*2⁴⁸+M1*2 ⁵⁶ D =

D0+D1* +D1*2⁸ 2¹⁶+D1*2²⁴+D1*2³²+D1*2⁴⁰+D1*2⁴⁸+D1*2 ⁵⁶

Gli argomenti dei confronti sono:

M7 (MSB) M6 M5 M4 M3 M2 M1 M0 (LSB)

Contenuto memoria tag all’indirizzo

Contenuto memoria tag all’indirizzo ADDRESS+0 ADDRESS+1 ADDRESS+2 ADDRESS+3 ADDRESS+4 ADDRESS+5 ADDRESS+6 ADDRESS+7

Tabella 2.10 Composizione del BYTE_MASK

D7 (MSB) D6 D5 D4 D3 D2 D1 D0 (LSB)

Primo byte dopo l’istruzione

Ultimo byte dopo l’istruzione

Tabella 2.11 Composizione del WORD_DATA

L’argomento del BYTE_MASK definisce quali bytes considerare per il confronto.

BYTE_MASK Valore WORD_DATA

Bit 7 (MSB) 1 Considera D7 e M7 per il confronto

Bit 6 1 Considera D6 e M6 per il confronto

Bit 0 (LSB) 1 Considera D0e M0 per il confronto

(26)

Tabella 2.12 Maschera dei dati per le istruzioni GROUP_SELECT E GROUP_UNSELECT

Ogni istruzione di selezione ‘sui flags’ ha 2 argomenti (parametri e dati):

BYTE_MASK

BYTE_DATA

IL tag farà uno dei 2 confronti possibili:

1. EQ FLAGS≡D 2. NE FLAGS≠ D

Gli argomenti di confronto sono il contenuto del FLAGS, definito nel paragrafo 2.7, ed il valore del BYTE_DATA.

L’argomento del BYTE_MASK definisce quali bit considerare per il confronto.

BYTE_MASK ^Valore ^BYTE_DATA

Bit 7 (MSB) 1 Considera D7 e FLAG7 per il confronto

Bit 6 1 Considera D6 e FLAG 6 per il confronto

Bit 0 (LSB) 1 Considera D0 e FLAG 0 per il confronto

Tabella 2.13 Maschera dei dati per le istruzioni GROUP_SELECT E GROUP_UNSELECT

GROUP_SELECT_EQ

Codifica del comando =’00’

Alla ricezione dell’istruzione GROUP_SELECT_EQ, un tag che si trova nello stato READY, leggerà gli 8 bytes contenuti in memoria a partire

(27)

dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria è uguale ai dati trasmessi, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e passerà nello stato ID.

Sei il tag si trova nello stato ID imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e resterà nello stato ID.

In tutti gli altri casi il tag non trasmetterà nessuna risposta.

Se il valore del BYTE_MASK è 0, tutti i tag saranno selezionati.

GROUP_SELECT_NE

Alla ricezione dell’istruzione GROUP_SELECT_NE, un tag che si trova nello stato READY, leggerà gli 8 bytes contenuti in memoria a partire dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria non è uguale ai dati trasmessi, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e passerà nello stato ID.

Sei il tag si trova nello stato ID, imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e resterà nello stato ID.

GROUP_SELECT_GT

Alla ricezione dell’istruzione GROUP_SELECT_GT, un tag che si trova nello stato READY, leggerà gli 8 bytes contenuti in memoria a partire dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria è maggiore dei dati

(28)

trasmessi, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e passerà nello stato ID.

GROUP_SELECT_LT

Alla ricezione dell’istruzione GROUP_SELECT_LT, un tag che si trova nello stato READY, leggerà gli 8 bytes contenuti in memoria a partire dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria è minore dei dati trasmessi, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e passerà nello stato ID.

GROUP_UNSELECT_EQ

Alla ricezione dell’istruzione GROUP_UNSELECT_EQ, un tag che si trova nello stato ID, leggerà gli 8 bytes contenuti in memoria a partire dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria è uguale ai dati trasmessi, il tag passerà nello stato READY e non trasmetterà nessuna risposta. Nel caso in cui il confronto fallisce, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID e lo trasmetterà.

(29)

GROUP_UNSELECT_NE

Alla ricezione dell’istruzione GROUP_UNSELECT_NE, un tag che si trova nello stato ID, leggerà gli 8 bytes contenuti in memoria a partire dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria non è uguale ai dati trasmessi, il tag passerà nello stato READY e non trasmetterà nessuna risposta. Nel caso in cui il confronto fallisce, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID e lo trasmetterà.

GROUP_UNSELECT_GT

Alla ricezione dell’istruzione GROUP_UNSELECT_GT, un tag che si trova nello stato ID, leggerà gli 8 bytes contenuti in memoria a partire dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria è maggiore dei dati trasmessi, il tag passerà nello stato READY e non trasmetterà nessuna risposta. Nel caso in cui il confronto fallisce, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID e lo trasmetterà.

GROUP_UNSELECT_LT

Alla ricezione dell’istruzione GROUP_UNSELECT_EQ, un tag che si trova nello stato ID, leggerà gli 8 bytes contenuti in memoria a partire dall’indirizzo specificato e confronterà con il WORD_DATA trasmesso dal

(30)

lettore. Nel caso in cui il contenuto di memoria è minore dei dati trasmessi, il tag passerà nello stato READY e non trasmetterà nessuna risposta. Nel caso in cui il confronto fallisce, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID e lo trasmetterà.

MULTIPLE_UNSELECT

Alla ricezione dell’istruzione MULTIPLE_UNSELECT, un tag che si trova nello stato ID, leggerà 1 byte contenuto in memoria all’indirizzo specificato e confronterà con il BYTE_DATA trasmesso dal lettore. Nel caso in cui il contenuto di memoria è uguale al dato trasmesso ed il flag WRITE_OK è 1, il tag passerà nello stato READY e non trasmetterà nessuna risposta. Nel caso in cui il confronto fallisce, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID e lo trasmetterà.

Questo comando viene usato per deselezionare tutti i tag che hanno scritto correttamente, mentre quelli che non l’hanno fatto resteranno selezionati

GROUP_SELECT_EQ_FLAGS

Alla ricezione dell’istruzione GROUP_SELECT_EQ_FLAGS, un tag che si trova nello stato READY confronterà il contenuto del FLAGS con il BYTE_DATA trasmesso dal lettore. Nel caso il FLAGS è uguale al dato trasmesso, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e passerà nello stato ID.

(31)

Se il valore del BYTE_MASK è 0, tutti i tag saranno selezionati.

GROUP_SELECT_NE_FLAGS

Alla ricezione dell’istruzione GROUP_SELECT_NE_FLAGS, un tag che si trova nello stato READY confronterà il contenuto del FLAGS con il BYTE_DATA trasmesso dal lettore. Nel caso in cui il FLAGS non è uguale al dato trasmesso, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID, lo trasmetterà e passerà nello stato ID.

GROUP_UNSELECT_EQ_FLAGS

Alla ricezione dell’istruzione GROUP_UNSELECT_EQ_FLAGS, un tag che si trova nello stato ID, confronterà il contenuto del FLAGS con il BYTE_DATA trasmesso dal lettore. Nel caso il FLAGS è uguale al dato trasmesso, il tag passerà nello stato READY e non trasmetterà nessuna risposta. Nel caso in cui il confronto fallisce, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID e lo trasmetterà.

GROUP_UNSELECT_NE_FLAGS

Codifica del comando =’1A’

Alla ricezione dell’istruzione GROUP_UNSELECT_EQ_FLAGS, un tag che si trova nello stato ID, confronterà il contenuto del FLAGS con il

(32)

BYTE_DATA trasmesso dal lettore. Nel caso il FLAGS non è uguale al dato trasmesso, il tag passerà nello stato READY e non trasmetterà nessuna risposta. Nel caso in cui il confronto fallisce, il tag imposterà il valore del contatore interno COUNT a 0, leggerà il valore UID e lo trasmetterà.

2.11.3.2 Istruzioni di identificazione

Le istruzioni di identificazione vengono usati per eseguire la procedura di identificazione multipla.

FAIL

L’algoritmo di identificazione usa l’istruzione FAIL quando tag multipli cercano di identificarsi allo stesso tempo. Alcuni tags si fermano, altri ritrasmettono.

Un tag accetterà l’istruzione FAIL solo se si trova nello stato ID. Nel caso in cui il suo contatore interno COUNT non è 0 o il generatore random è 1, il COUNT incrementerà di 1, tranne se il COUNTER è ‘FF’.

Se il COUNT è 0, il tag leggerà il suo UID e lo trasmetterà nella risposta.

SUCCESS

SUCCESS inizializza l’identificazione del successivo set di tags. Viene usato in due casi:

(33)

Quando tutti i tags che ricevono l’istruzione FAIL si spengono e non trasmettono, SUCCESS forza questi stessi tags a trasmettere di nuovo.

Dopo un istruzione di DATA_READ che muove un tag identificato allo stato DATA_EXCHANGE, SUCCESS forza il prossimo sottoinsieme di tags selezionati ma non identificati a trasmettere.

Un tag accetterà un’istruzione di SUCCESS solo se si trova nello stato ID.

Nel caso in cui il suo contatore interno COUNTER non è uguale a 0, decrementerà di uno.

Se il risultato del valore del COUNT è 0, allora il tag leggerà il suo UID e lo trasmetterà nella risposta.

RESEND

L’algoritmo di identificazione usa l’istruzione RESEND quando un solo tag ha trasmesso ma il suo UID è stato ricevuto erroneamente. Il tag che ha trasmesso ritrasmette il suo UID.

Un tag accetterà l’istruzione RESEND solo se si trova nello stato ID. Se il valore del suo contatore interno COUNT è 0, allora il tag leggerà il suo UID e lo trasmetterà nella risposta.

INIZIALIZE

Codifica del comando =’0A’

Alla ricezione dell’istruzione INIZIALIZE un tag passerà nello stato READY e imposterà il valore del Data_Exchange_Status_Bit a 0.

(34)

FAIL_O

Codifica del comando =’40’ o ‘41’

L’algoritmo di identificazione usa l’istruzione FAIL_O quando tag multipli cercano di identificarsi allo stesso tempo. Alcuni tags si fermano, altri ritrasmettono.

Un tag accetterà l’istruzione FAIL solo se si trova nello stato ID. Nel caso in cui il suo contatore interno COUNT non è 0 o il generatore random è 1, il COUNT incrementerà di 1, tranne se il COUNTER è ‘FF’.

Se il COUNT è 0, il tag leggerà il valore della memoria all’indirizzo ’14’ e trasmetterà 32 bit (se l’istruzione è ‘40’) o 64 bit (se l’istruzione è ‘41’) nella risposta.

SUCCESS_O

Codifica del comando =’42’ or ‘43’

SUCCESS_O inizializza l’identificazione del successivo set di tags. Viene usato in due casi:

Quando tutti i tags che ricevono l’istruzione FAIL_O si spengono e non trasmettono, SUCCESS_O forza questi stessi tags a trasmettere di nuovo.

Dopo un istruzione di DATA_READ_O che muove un tag identificato allo stato DATA_EXCHANGE, SUCCESS_O forza il prossimo sottoinsieme di tags selezionati ma non identificati a trasmettere.

Un tag accetterà un’istruzione di SUCCESS_O solo se si trova nello stato ID. Nel caso in cui il suo contatore interno COUNTER non è uguale a 0, decrementerà di uno.

(35)

Se il risultato del valore del COUNT è 0, allora il tag leggerà il valore della memoria all’indirizzo ’14’ e trasmetterà 32 bit (se l’istruzione è ‘40’) o 64 bit (se l’istruzione è ‘41’) nella risposta.

RESEND_O

Codifica del comando =’46’ or ‘47’

L’algoritmo di identificazione usa l’istruzione RESEND_O quando un solo tag ha trasmesso ma il suo UID è stato ricevuto erroneamente. Il tag che ha trasmesso ritrasmette il suo UID.

Un tag accetterà l’istruzione RESEND solo se si trova nello stato ID. Se il valore del suo contatore interno COUNT è 0, allora il tag leggerà il valore della memoria all’indirizzo ’14’ e trasmetterà 32 bit (se l’istruzione è ‘40’) o 64 bit (se l’istruzione è ‘41’) nella risposta.

2.11.3.3 Istruzioni di trasferimento dati

Le istruzioni di trasferimento dati sono usati per leggere o scrivere dalla memoria.

READ

Codifica del comando =’0C’

Alla ricezione di un’istruzione READ, il tag confronterà l’ID trasmesso con il suo UID. Nel caso in cui l’ID sia uguale all’UID, il tag passerà da qualsiasi stato si trovi allo stato DATA_EXCHANGE, legge gli 8 byte contenuti in memoria iniziando dall’indirizzo specificato e li trasmetterà nella risposta. Nel caso in cui ID non è uguale all’UID o ogni altro tipo di errore il tag non risponde.

(36)

DATA_READ

Codifica del comando =’0B’

Alla ricezione di un’istruzione DATA_READ, il tag confronterà l’ID trasmesso con il suo UID solo se si trova nello stato ID o DATA_EXCHANGE. Nel caso in cui l’ID sia uguale all’UID, il tag passerà da qualsiasi stato si trovi tranne lo stato READY allo stato DATA_EXCHANGE, legge gli 8 byte contenuti in memoria iniziando dall’indirizzo specificato e li trasmetterà nella risposta. Nel caso in cui il tag si trovi nello stato READY o l'ID non è uguale all’UID o ogni altro tipo di errore il tag non risponde.

DATA_READ_O

Codifica del comando =’44’ o ‘45'

Alla ricezione di un’istruzione DATA_READ_O, il tag confronterà il dato trasmesso con il valore di memoria partendo dall’indirizzo ‘10’ solo se si trova nello stato ID o DATA_EXCHANGE. Nel caso in cui il codice d’istruzione usato sia ’44’ saranno confrontati 32 bits. Nel caso in cui il codice d’istruzione usato sia ’45’ saranno confrontati 64 bits. Nel caso in cui i confronti abbiano dato esito positivo il tag passerà da qualsiasi stato si trovi tranne lo stato READY allo stato DATA_EXCHANGE, legge gli 8 byte contenuti in memoria iniziando dall’indirizzo specificato e li trasmetterà nella risposta. Nel caso in cui il tag si trovi nello stato READY o l'ID non è uguale all’UID o ogni altro tipo di errore il tag non risponde.

READ_FLAGS

Codifica del comando =’50

(37)

Alla ricezione di un’istruzione READ_FLAGS, il tag passerà da qualsiasi stato in DATA_EXCHANGE, leggerà il valore del FLAGS e trasmetterà il suo contenuto nella risposta.

WRITE

Codifica del comando =’0D’

Alla ricezione di un’istruzione WRITE, il tag confronterà l’ID trasmesso con il suo UID. Nel caso in cui l’ID sia uguale all’UID, il tag passerà da qualsiasi stato si trovi allo stato DATA_EXCHANGE, legge le informazioni di protezione per la locazione di memoria specificata dall’indirizzo. Nel caso in cui la memoria è protetta, trasmetterà una risposta di ERROR.

Nel caso in cui la memoria è accessibile in scrittura, il tag trasmetterà una risposta di ACKNOWLEDGE e programmerà il dato nella locazione di memoria all’indirizzo specificato.

Nel caso in cui l’accesso in scrittura è stato effettuato con successo, il tag imposterà il valore del il bit WRITE_OK a 1. Altrimenti lo lascerà a 0.

WRITE4BYTE

Codifica del comando =’1B’

Alla ricezione di un’istruzione WRITE4BYTE, il tag confronterà l’ID trasmesso con il suo UID. Nel caso in cui l’ID sia uguale all’UID, il tag passerà da qualsiasi stato si trovi allo stato DATA_EXCHANGE, legge le informazioni di protezione per le quattro locazioni di memoria a partire dal primo indirizzo specificato. Nel caso in cui una delle locazioni di memoria è protetta, il tag trasmetterà una risposta di ERROR. Nel caso in cui tutti e quattro le locazioni di memoria sono accessibile in scrittura, il tag trasmetterà una risposta di ACKNOWLEDGE e programmerà il i dati nella locazione di memoria a partire dalla prima con indirizzo specificato.

(38)

LOCK

Codifica del comando =’0F’

Alla ricezione di un’istruzione LOCK, un tag che si trova nello stato DATA_EXCHANGE leggerà il suo UID e lo confronterà con il dato trasmesso dal lettore. Nel caso in cui l’UID sia uguale al dato, l’indirizzo sia all’interno dei valori permessi e la locazione di memoria sia chiudibile in protezione, il tag trasmetterà una risposta di ACKNOWLEDGE e programmerà il bit relativa alla locazione di memoria all’indirizzo specificato. Nel caso in cui l’indirizzo sia all’interno dei valori permessi e non sia possibile proteggere la locazione di memoria, allora il tag trasmetterà un ACKNOWLEDGE_NOK.

In tutti gli altri casi il tag non trasmetterà alcuna risposta.

2.11.3.4 Descrizione delle istruzioni di risposta

ACKNOWLEDGE

ACKNOWLEDGE indica una istruzione WRITE o LOCK eseguita con successo.

ERROR

ERROR indica un errore in scrittura (istruzione WRITE).

WORD_DATA

WORD_DATA è la risposta del tag alle istruzioni: GROUP_SELECT, GROUP_UNSELECT, FAIL, SUCCESS, RESEND, READ o DATA_READ.

(39)

BYTE_DATA

BYTE_DATA è la risposta del tag all’istruzioni READ_VERIFY.