Panoramica i2C in Linux
Descrizione
I2C sta per il circuito integrato, è un protocollo a bordo per l'uso per la comunicazione tra due ICS. È un protocollo seriale a due fili. Questo segue la modalità Slave Master. I2C Master avvia sempre la comunicazione e l'orologio per la comunicazione è anche fornito da I2C Master. Su due righe possono esserci più dispositivi collegati. Su una configurazione master singola e molti slave, ogni slave si distinguerà con un indirizzo slave unico.
Esempio di configurazione del singolo master e più schiavi:
Nel diagramma a blocchi sopra, possiamo vedere che esiste un singolo master e 3 schiavi con indirizzi come menzionato nella scatola di ogni schiavo.
Protocollo I2C
La sequenza di messaggi General I2C utilizzata nella comunicazione tra master e slave è mostrata di seguito:
Start -> Indirizzo + Byte R/W -> ACK -> Data Byte1 -> ACK -> Data Byte2 -> ACK -> Data Byte3 -> ACK -> STOP
Inizio: Condizione generata dal master per indicare che vuole comunicare con lo schiavo.
Indirizzo + byte r/w: Indirizzo slave a 7 bit e 1 bit per indicare se l'operazione viene letta o scritta.
Ack: Il riconoscimento viene sempre inviato per ogni trasferimento di byte. Questo viene inviato dal dispositivo di ricezione.
Fermare: Una volta completato il trasferimento, il controller/master invierà la condizione di arresto per completare il trasferimento.
In Linux, i driver I2C sono organizzati in tre strati logici:
- driver master/adattatore
- Strato i2c-core
- driver di schiavi/client
Driver Master/Adapter I2C
Questi si trovano nell'albero della sorgente del kernel sul sentiero: conducenti/ i2c/ buss/. Per ogni master o controller i2c, dovrebbe esserci un driver presente in questo percorso. Questo è il driver che si registra nel livello i2c-core e controlla/gestisce i bus i2c. Questo è il conducente che comunica con i dispositivi Slave I2C su autobus I2C presenti sulla piattaforma.
Driver i2c-core
Questa è la comune logica del core I2C di Linux. Questo è comune e indipendente da qualsiasi specifico maestro I2C o schiavo. Questa è l'implementazione principale del sottosistema I2C in Linux.
Driver slave/client i2c
Questo è il driver chip slave necessario per ogni dispositivo slave. Qualsiasi dispositivo slave i2c dovrebbe avere driver o implementazione presente in questa categoria. Questo è necessario per qualsiasi dispositivo slave per registrarsi al sottosistema Linux I2C.
Abilitare i driver I2C nel kernel Linux
L'implementazione correlata al core I2C sarà abilitata con flag di configurazione del kernel core i2c. Il driver master i2c sarà anche abilitato con il controller della scheda specifica I2C. Allo stesso modo, ci sarà un flag di configurazione dovrebbe essere abilitato per i2c slave driver.
Tutte le configurazioni richieste possono essere abilitate in due modi. Uno come driver integrato o come modulo del kernel. I moduli del kernel ci forniscono il vantaggio di caricarlo come runtime senza cambiare o compilare il kernel Linux.
L'approccio del modulo può essere utilizzato solo se l'accesso al dispositivo non fa parte del percorso di avvio. Se sono necessari dati di un dispositivo per l'avvio del sistema, questi driver devono essere integrati. Tali driver non possono essere compilati come moduli caricati dinamicamente in fase di esecuzione.
Istanziando i dispositivi I2C
In Linux, sono presenti diversi modi per istanziare i dispositivi I2C. Due metodi ampiamente usati sono: statico e dinamico
Statico: sui sistemi ARM, l'albero del dispositivo può essere utilizzato per creare un'istanza del dispositivo I2C.
Il nodo del dispositivo specifico può essere aggiunto nell'albero del dispositivo. Esempio, la dichiarazione dell'albero del dispositivo per il dispositivo I2C è:
i2c0: i2c@60000000
eeprom@50
compatibile = "Atmel, eeprom-at";
reg = <0x50>;
;
rtc@60
compatibile = "rtc, rtc-maxim";
reg = <0x60>;
;
;
L'esempio sopra crea un'istanza di 2 dispositivi slave i2c. Uno è il dispositivo EEPROM e un altro è il dispositivo RTC. Dopo l'arrivo del sistema, queste voci possono essere trovate in/sys/bus/i2c/dispositivi/i2c-0/. Entrambi saranno creati all'interno della directory I2C-0 perché sono posizionati all'interno del nodo I2C 0.
Dinamico: L'istanza di runtime del dispositivo I2C può essere creata tramite i file SYSFS.
Ci sono due file sysfs presenti per ogni bus i2c. new_device e delete_device, entrambi i file sono solo scritti e l'indirizzo slave I2C può essere scritto su questi file per creare istanza del dispositivo ed eliminare l'istanza del dispositivo.
Per creare un dispositivo I2C equivalente ai dispositivi definiti nell'albero dei dispositivi all'esempio precedente.
Crea istanza EEPROM con indirizzo slave 0x50:
# echo eeprom 0x50>/sys/bus/i2c/dispositivi/i2c-0/new_device
Eliminazione dell'istanza del dispositivo EEPROM:
# echo 0x50>/sys/bus/i2c/dispositivi/i2c-0/delete_device
Successivamente, il sondaggio del dispositivo con driver può anche essere eseguito dai file SYSFS: ci sono due file di solo scrittura che si legano e si uniscono, associati a ogni driver. Esportazione dell'ID del dispositivo in file BIND e INCLID risulta nel collegamento e al dibattito del driver con il dispositivo. Ad esempio, il driver RTC-DS1307 ha i file seguenti nei SYSF come discusso in precedenza.
[root] $ ls/sys/bus/i2c/driver/rtc-ds1307/
Lega Uevent Unlend
[root] $
Facciamo un po 'più di discussione sui file SYSFS del sottosistema I2C:
I2C SYSFS è presente nella posizione:/sys/bus/i2c/
Snapshot dei Sysf i2C:
Come possiamo vedere, ci sono due directory: dispositivi e driver
I dispositivi conterranno tutte le istanze del dispositivo presenti e note al kernel Linux. Nella nostra scheda, abbiamo dei dispositivi I2C sotto la directory dei dispositivi:
I conducenti conterranno tutti i driver I2C presenti e noti al kernel Linux. Nella nostra scheda, abbiamo sotto i driver I2C all'interno della directory dei conducenti:
Per bind e slessamento dei dispositivi con driver, ci sono due file di soli scritti presenti all'interno di ogni driver. Per il collegamento di qualsiasi dispositivo con il driver può essere eseguito facendo eco all'ID del dispositivo al file BIND e l'allimzo.
Binding del dispositivo I2C con driver I2C
[root] $ echo 1-0068>/sys/bus/i2c/driver/rtc-ds1307/bind
[592061.085104] RTC-DS1307 1-0068: registrato come RTC0
[root] $
La conferma del vincolo efficace può essere eseguita controllando il collegamento soft creato dopo l'operazione di bind. Un nuovo collegamento soft di dispositivo può essere visualizzato nell'istanza del registro seguente dopo l'esecuzione del comando menzionato nella sezione Binding:
[root] $ ls/sys/bus/i2c/driver/rtc-ds1307/
1-0068 BIND UEVENT INSIDID
[root] $
Smalto del dispositivo I2C con il driver i2C
[root] $ echo 1-0068>/sys/bus/i2c/driver/rtc-dds1307/ixind
La conferma dell'indintinging riuscito può essere eseguita controllando il nodo del dispositivo di collegamento soft creato in precedenza all'interno della directory dei driver verrà rimossa. Se controlliamo il contenuto della directory dei driver, dovremmo vedere l'istantanea dei registri come di seguito:
[radice] $ ls/sys/bus/i2c/driver/rtc-ds1307
Lega Uevent Unlend
[root] $
Applicazioni i2c o casi d'uso rispetto a Linux
- Dispositivo EEPROM per archiviare piccoli dati, la memoria è di pochi KB.
- Dispositivo RTC, utilizzato per mantenere i dati in tempo reale. Il dispositivo viene utilizzato per mantenere la traccia del tempo anche quando il sistema principale è spento.
- Molti dispositivi per sensori HW come sensori termici, sensori di corrente e sensori di tensione sono disponibili come dispositivi I2C.
- I chip di controllo della ventola arriva anche come dispositivi i2c.
TOOLS I2C
Le applicazioni di spazio utente in ambiente Linux vengono utilizzate per accedere ai dispositivi slave i2c. I2cdetect, i2cget, i2cset, i2cdump e i2ctransfer sono i comandi disponibili quando i tool i2c sono installati su qualsiasi piattaforma Linux. Tutti i casi d'uso dei dispositivi discussi nelle sezioni delle applicazioni I2C sono accessibili tramite questi strumenti.
Non è necessario il driver del dispositivo slave i2c, quando si tenta di accedere al dispositivo slave con i2c-tools. Questi strumenti possono consentirci di accedere ai dispositivi in formato grezzo. Maggiori dettagli su queste utility sono disponibili in un altro articolo.
Conclusione
Abbiamo discusso del sottosistema I2C in Linux. È stato fornito il framework I2C con panoramica dell'organizzazione del codice logico. Abbiamo anche discusso dei file I2C SYSFS. Abbiamo discusso della sequenza dei messaggi di comunicazione I2C. Abbiamo esaminato la creazione dell'istanza del dispositivo in entrambi i modi, io.e., statico e dinamicamente. Abbiamo anche esplorato i conducenti di bind/Unbind con dispositivi. Alcune delle applicazioni I2C in tempo reale.