Utilità i2C in Linux
Descrizione
In questi giorni, la maggior parte dei sistemi Linux è dotata di questi comandi. Se un sistema non ha questi comandi, questi possono essere compilati per il sistema stesso. La compilazione per il sistema stesso può essere eseguita solo se la struttura del compilatore è disponibile. Se il compilatore non è disponibile, questi devono essere compilati incrociati. Il codice sorgente di questi strumenti è open source e le fasi di compilazione sono uguali di altri strumenti Linux.
I comandi ampiamente usati disponibili nel pacchetto i2c-tools sono: i2cdetect, i2cdump, i2cget, i2cset, i2ctransfer. Discutiamo in dettaglio questi comandi.
i2cdetect
Questo comando viene utilizzato per rilevare ed elencare tutti i bus i2c disponibili e noti a Linux.
Possono esserci più controller/bus i2C disponibili nel sistema e tutti i bus possono essere elencati con il comando i2cdetect. Esempio di utilizzo di I2CDetect è: i2cdetect -l
Questo comando fornisce l'output seguente su un sistema:
[root] $ i2cdetect -l
I2C-1 I2C 0B234500.adattatore i2c-bus i2c
I2C-2 I2C 0B234580.adattatore i2c-bus i2c
I2C-0 I2C 0B234580.adattatore i2c-bus i2c
I2C-5 I2C 0B234500.adattatore i2c-bus i2c
[root] $
Nell'output sopra possiamo vedere che quando eseguiamo questo comando con -l è elencando tutti i bus i2c del sistema. Nell'output possiamo vedere che ci sono 4 autobus disponibili e noti a Linux. 0, 1, 2 e 5 sono il numero dei bus assegnati dal kernel Linux. Questi sono i numeri necessari in altre operazioni di comando.
Ulteriori informazioni su tutti gli schiavi collegati al bus specifico possono anche essere informate con questo comando. Ad esempio, se vogliamo ottenere i dettagli sul bus n. 0, possiamo emettere il comando come i2cget -y 0.
L'output del comando sul nostro sistema è:
[root] $ i2cdetect -y 0
0 1 2 3 4 5 6 7 8 9 A B C D E F
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: 30 - - - - - 36 -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: 50 - 52 -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
[root] $
Come possiamo vedere nei registri sopra, ci sono 4 schiavi sul bus 0. Indirizzo slave di quei dispositivi slave i2c sul bus 0 sono 0x30, 0x36, 0x50, 0x52. Questo indirizzo slave i2c è necessario anche per i comandi i2cget, i2cget, i2cdump.
i2cget
i2Cget può essere usato per leggere il dispositivo slave i2c. Qualsiasi indirizzo leggibile interno può essere letto con il comando i2cget. L'utilizzo del campione di questo comando può essere dimostrato con un'istanza, diciamo che vogliamo leggere l'indirizzo offset/interno come 0x0 del dispositivo slave I2C con indirizzo slave (0x50) sul bus n. I registri dell'operazione dal dispositivo sono:
[root] $ i2cget -y 0 0x50 0
0x23
[root] $
Nei registri di output. Possiamo vedere i dati all'offset 0 è 0x23. Allo stesso modo, questo comando può essere utilizzato per leggere qualsiasi dispositivo slave su qualsiasi bus i2c o qualsiasi indirizzo interno del dispositivo slave i2c.
i2cset
Il comando i2CGET può essere utilizzato per scrivere i dati su qualsiasi indirizzo interno specificato del dispositivo slave i2c. L'indirizzo del dispositivo interno I2C dovrebbe essere scrittabile. L'operazione di scrittura I2C può essere protetta a livello di dispositivo o qualsiasi indirizzo interno può essere solo scritto. Con tutte le autorizzazioni scrivibili, il comando i2cset può aggiornare il dispositivo.
Esempio di utilizzo del comando, prendiamo un esempio di scrittura di un valore di dati 0x12 a RTC Slave Device con indirizzo slave 0x68 all'offset 0x2. Dimostreremo l'operazione di scrittura nella seguente sequenza:
- Leggi il dispositivo all'offset 0x2
- Scrivi il 0x12 all'offset 0x2 del dispositivo slave 0x68
- Leggi il dispositivo all'offset 0x2 e verificare che i dati dovrebbero essere 0x12.
1.Leggi il dispositivo all'offset 0x2.
[root] $ i2cget -y 1 0x68 0x2
0x14
[root] $
2.Scrivi il 0x12 all'offset 0x2 del dispositivo slave 0x68
[root] $ i2cset -y 1 0x68 0x2 0x12
[root] $
3.Leggi il dispositivo all'offset 0x2 e verificare che i dati dovrebbero essere 0x12.
[root] $ i2cget -y 1 0x68 0x2
0x12
[root] $
Passaggi/output di esempio sopra nella casella Dimostra l'operazione di scrittura sul dispositivo slave i2c. Passaggi simili possono essere seguiti per scrivere qualsiasi dati sul dispositivo slave i2c. L'indirizzo degli slave, i dati o il numero del bus possono essere modificati secondo il sistema e necessità.
i2cdump
Il comando i2cdump può essere utilizzato per scaricare i dati da qualsiasi dispositivo slave i2c. Solo l'input necessario per questa esecuzione del comando è il numero del bus i2c, l'indirizzo slave. L'intervallo di indirizzo può anche essere specificato con il comando. Facciamo un esempio di lettura di byte da offset 0x0 a 0xf i.e., Primi 16 byte.
[root] $ i2cdump -y -r 0x0-0xf 1 0x68
Nessuna dimensione specificata (utilizzando l'accesso ai dati byte)
0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
00: 58 29 12 06 08 10 21 00 00 00 00 00 00 18 00 x)????!.. ?.
[root] $
L'indirizzo dell'intervallo è facoltativo, se questo intervallo non è specificato per impostazione predefinita, scarica i primi byte 0xFF. io.e., 256 byte.
i2ctransfer
Il comando i2ctransfer è molto utile e può essere utilizzato per leggere o scrivere diversi byte nello stesso comando.
i2Ctransfer per leggere 14 byte da 0FFSET 0x2, il comando sarà il seguente:
[root] $ i2ctransfer -y 1 w1@0x68 2 r14
0x12 0x06 0x08 0x10 0x21 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x18 0x00
[root] $
i2ctransfer a scrivere 2 byte dati 0x10, 0x16 all'offset 0x1 e 0x2, il comando sarà il seguente:
[root] $ i2ctransfer -y 1 w3@0x68 1 0x10 0x16
[root] $
Rileggi; Per confermare i dati di scrittura:
[root] $ i2ctransfer -y 1 w1@0x68 1 r2
0x10 0x16
[root] $
Esempi sopra hanno dimostrato l'uso di i2Ctransfer con un'istanza. Con l'aiuto di questi utilizzo, un altro casi d'uso può essere facilmente eseguito. Qualsiasi dispositivo slave e qualsiasi indirizzo interno possono essere letti con l'aiuto di questo comando.
Cosa succede se il dispositivo slave è indirizzabile a 2 byte?
Ci sono pochi dispositivi slave i2c, in particolare dispositivo EEPROM che sono 2 byte. Il trasferimento I2C fornisce il modo più semplice per accedere al dispositivo in tale scenario. Se questo dispositivo, vogliamo accederci con i2cget/i2cset dobbiamo considerare l'indirizzo 2 byte.
Ho un dispositivo EEPROM con me che è indirizzabile a 2 byte. Osserviamo l'i2Cget/i2cset con eeprom e poi osserveremo i2ctransfer:
Cercheremo di leggere il byte dall'offset 0. Proveremo con lo stesso comando discusso nella sezione precedente di i2cget i.e., Il comando sarà: i2cget -y 1 0x50 0
[root] $ i2cget -y 1 0x50 0
0xff
[root] $
Possiamo vedere i dati restituiti è 0xFF, quindi questi non sono i dati corretti.
Per leggere correttamente da Offset 0, dobbiamo prima scrivere l'indirizzo a 2 byte con il comando i2cset. Questo è il modo di leggere i dati da 2 dispositivi per il byte. Esempio di utilizzo:
[root] $ i2cset -y 1 0x50 0x0 0x0
[root] $ i2cget -y 1 0x50
0x45
[root] $
Nel comando i2cset dobbiamo scrivere l'indirizzo EEPROM interno a 2 byte. Due 0's dopo l'indirizzo slave 0x50 sono l'indirizzo EEPROM interno come 0x0000.
Successivamente se leggiamo i dati con i2Cget, otterremo i dati corretti. Possiamo vedere nel nostro esempio è 0x45. In precedenza era 0xFF, che è un dati non validi.
i2Ctransfer nel dispositivo di indirizzamento a 2 byte
i2ctransfer può fornire ai dati lo stesso comando. Considera lo stesso caso d'uso di esempio a partire da i2cget/i2cset come sopra.
[root] $ i2ctransfer -y 1 w2@0x50 0x0 0x0 r1
0x45
[root] $
Con questo comando, possiamo leggere i dati all'offset 0000. Si noti che dobbiamo scrivere l'indirizzo interno dopo esserci divisi in 2 byte.
Un altro esempio, leggendo 16 byte da offset 0x0000:
[root] $ i2ctransfer -y 1 w2@0x50 0x0 0x0 r16
0x45 0x41 0x3d 0x41 0x41 0x42 0x42 0x43 0x43 0x44 0x44 0x44 0x45 0x45 0x30 0x0a
[root] $
Un altro esempio per leggere 4 byte dall'offset 0x0004:
[root] $ i2ctransfer -y 1 w2@0x50 0x0 0x4 r4
0x41 0x42 0x42 0x43
[root] $
Questo esempio può essere verificato con la precedente operazione di lettura in cui abbiamo letto 16 byte dall'offset 0000. Ora abbiamo letto il sottoinsieme. Se confrontiamo i risultati di questa operazione di lettura e verifichiamo con quello precedente, i risultati corrispondono esattamente. Quindi, possiamo concludere che questa lettura ha successo.
Conclusione
Abbiamo discusso del pacchetto di strumenti I2C in Linux. Vari comandi sono disponibili in questo pacchetto i2c-tools. Alcuni casi di utilizzo speciali come l'indirizzamento a 2 bytes, come utilizzare i comandi in questi scenari speciali. Molti esempi che abbiamo visto finora. Abbiamo confermato tutti i comandi che funzionano con l'esempio e le dimostrazioni. I2cset, i2cget, i2cdump, i2cdetect e i2ctransfer sono i comandi del pacchetto i2c -tools.