I2C Utities en Linux
Descripción
En estos días, la mayoría de los sistemas de Linux están equipados con estos comandos. Si algún sistema no tiene estos comandos, estos pueden compilarse para el mismo sistema. La compilación para el sistema en sí solo se puede hacer si la instalación del compilador está disponible. Si el compilador no está disponible, entonces estos deben ser compilados. El código fuente de estas herramientas es de código abierto y los pasos de compilación son los mismos que de otras herramientas de Linux.
Los comandos ampliamente utilizados disponibles en el paquete I2C-Tools son: i2cdetect, i2cdump, i2cget, i2cset, i2ctransfer. Discutamos estos comandos en detalle.
i2cdetect
Este comando se usa para detectar y enumerar todos los autobuses I2C disponibles y conocidos por el Linux.
Puede haber múltiples controladores/autobuses I2C disponibles en el sistema y todos los buses se pueden enumerar con el comando i2cDetect. Ejemplo de uso del I2CDetect es: i2cdetect -l
Este comando proporciona la siguiente salida en un sistema:
[root] $ i2cdetect -l
I2C-1 I2C 0B234500.adaptador I2C-Bus I2C
I2C-2 I2C 0B234580.adaptador I2C-Bus I2C
I2C-0 I2C 0B234580.adaptador I2C-Bus I2C
I2C-5 I2C 0B234500.adaptador I2C-Bus I2C
[raíz] $
En la salida anterior, podemos ver que cuando ejecutamos este comando con -l opción está enumerando todos los buses I2C del sistema. En la salida podemos ver que hay 4 buses disponibles y conocidos por el Linux. 0, 1, 2 y 5 son el número de Busses asignado por el núcleo de Linux. Estos son los números necesarios en otras operaciones de comando.
También se puede consultar más información sobre todos los esclavos conectados al bus específico con este comando. Por ejemplo, si queremos obtener los detalles en el bus no 0, podemos emitir el comando como i2cget -y 0.
La salida del comando en nuestro sistema es:
[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: -- -- -- -- -- -- -- --
[raíz] $
Como podemos ver en los registros anteriores, hay 4 esclavos en el bus 0. La dirección de esclavos de esos dispositivos esclavos I2C en el bus 0 son 0x30, 0x36, 0x50, 0x52. Esta dirección de esclavo I2C también es necesaria para los comandos i2cget, i2cget, i2cdump.
i2cget
i2cget se puede usar para leer el dispositivo esclavo I2C. Cualquier dirección legible interna se puede leer con el comando i2cget. El uso de la muestra de este comando se puede demostrar con una instancia, digamos que queremos leer la dirección de compensación/interna como 0x0 del dispositivo esclavo I2C con dirección de esclavo (0x50) en el bus No 0. Los registros de la operación desde el dispositivo son:
[root] $ i2cget -y 0 0x50 0
0x23
[raíz] $
En los registros de salida. Podemos ver que los datos al desplazamiento 0 son 0x23. De manera similar, este comando se puede usar para leer cualquier dispositivo de esclavos en cualquier bus I2C o cualquier dirección interna del dispositivo de esclavo I2C.
i2cset
El comando i2cget se puede usar para escribir los datos en cualquier dirección interna especificada del dispositivo esclavo I2C. La dirección del dispositivo interno de I2C debe ser redactada. La operación de escritura I2C se puede proteger a nivel de dispositivo o cualquier dirección interna puede ser solo por escrito. Con todos los permisos de escritura, el comando i2cset puede actualizar el dispositivo.
Ejemplo de uso del comando, tomemos un ejemplo de escribir un valor de datos 0x12 al dispositivo esclavo RTC con la dirección esclava 0x68 al desplazamiento 0x2. Demostraremos la operación de escritura en la siguiente secuencia:
- Lea el dispositivo al desplazamiento 0x2
- Escriba el 0x12 al desplazamiento 0x2 del dispositivo esclavo 0x68
- Lea el dispositivo al desplazamiento 0x2 y verifique que los datos deben ser 0x12.
1.Lea el dispositivo al desplazamiento 0x2.
[raíz] $ i2cget -y 1 0x68 0x2
0x14
[raíz] $
2.Escriba el 0x12 al desplazamiento 0x2 del dispositivo esclavo 0x68
[raíz] $ i2cset -y 1 0x68 0x2 0x12
[raíz] $
3.Lea el dispositivo al desplazamiento 0x2 y verifique que los datos deben ser 0x12.
[raíz] $ i2cget -y 1 0x68 0x2
0x12
[raíz] $
Los pasos/salida de ejemplo de arriba en el cuadro demuestran la operación de escritura en el dispositivo esclavo I2C. Se pueden seguir pasos similares para escribir cualquier dato en el dispositivo de esclavo I2C. La dirección esclava, los datos o el número de bus se pueden cambiar según el sistema y la necesidad.
i2cdump
El comando i2cdump se puede usar para descargar datos de cualquier dispositivo de esclavo I2C. Solo la entrada necesaria para esta ejecución de comando es el número de bus I2C, dirección esclava. El rango de dirección también se puede especificar con el comando. Tomemos un ejemplo de lectura de bytes de desplazamiento 0x0 a 0xf I.mi., primeros 16 bytes.
[root] $ i2cdump -y -r 0x0-0xf 1 0x68
No hay tamaño especificado (usando el acceso a los datos de 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 00 18 00 x)????!… ?.
[raíz] $
La dirección de rango es opcional, si este rango no se especifica de forma predeterminada, se descarga primero 0xff bytes. i.mi., 256 bytes.
i2Ctransfer
El comando i2Ctransfer es muy útil y se puede usar para leer o escribir un número múltiple de bytes en el mismo comando.
i2Ctransfer para leer 14 bytes de 0ffset 0x2, el comando será el siguiente:
[root] $ i2ctransfer -y 1 w1@0x68 2 R14
0x12 0x06 0x08 0x10 0x21 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x18 0x00
[raíz] $
i2Ctransfer para escribir 2 datos bytes 0x10, 0x16 al desplazamiento 0x1 y 0x2, el comando será el siguiente:
[root] $ i2ctransfer -y 1 w3@0x68 1 0x10 0x16
[raíz] $
Lee atrás; Para confirmar los datos de escritura:
[root] $ i2ctransfer -y 1 w1@0x68 1 R2
0x10 0x16
[raíz] $
Los ejemplos anteriores demostraron el uso de i2Ctransfer con una instancia. Con la ayuda de este uso, se pueden realizar fácilmente otros casos de uso. Cualquier dispositivo de esclavos y cualquier dirección interna se puede leer con la ayuda de este comando.
¿Qué pasa si el dispositivo esclavo es de 2 bytes direccionable??
Hay pocos dispositivos de esclavos I2C, específicamente un dispositivo EEPROM que son 2 bytes adicionales. La transferencia I2C proporciona la forma más fácil de acceder al dispositivo en dicho escenario. Si este dispositivo, queremos acceder a I2CGG/I2CSET, tenemos que considerar los 2 bytes que se dirigen.
Tengo un dispositivo EEPROM conmigo que es de 2 bytes direccionable. Observemos el i2cget/i2cset con EEPROM y luego observaremos el i2ctransfer:
Intentaremos leer Byte de Offset 0. Lo intentaremos con el mismo comando que se discutió en la sección anterior de i2cget I.mi., El comando será: i2cget -y 1 0x50 0
[root] $ i2cget -y 1 0x50 0
0xff
[raíz] $
Podemos ver que los datos devueltos son 0xff, por lo tanto, estos no son los datos correctos.
Para leer con éxito de Offset 0, primero tenemos que escribir una dirección de 2 bytes con el comando i2cset. Esta es la forma de leer los datos del dispositivo de 2 bytes devastables. Ejemplo de uso del caso:
[root] $ i2cset -y 1 0x50 0x0 0x0
[raíz] $ i2cget -y 1 0x50
0x45
[raíz] $
En el comando i2cset tenemos que escribir la dirección EEPROM interna de 2 bytes. Dos 0 de la dirección esclava después de 0x50 son la dirección EEPROM interna como 0x0000.
Después de eso si leemos los datos con i2cget, obtendremos los datos correctos. Podemos ver en nuestro ejemplo es 0x45. Anteriormente era 0xff, que son datos inválidos.
i2Ctransfer en dispositivo de direccionamiento de 2 bytes
i2Ctransfer puede proporcionar los datos con el mismo comando. Considere el mismo caso de uso de ejemplo a partir de i2cget/i2cset como se indicó anteriormente.
[root] $ i2ctransfer -y 1 w2@0x50 0x0 0x0 r1
0x45
[raíz] $
Con este comando, podemos leer los datos en Offset 0000. Tenga en cuenta que debemos escribir la dirección interna después de dividir en 2 bytes.
Otro ejemplo, leer 16 bytes de 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
[raíz] $
Un ejemplo más para leer 4 bytes de Offset 0x0004:
[root] $ i2ctransfer -y 1 w2@0x50 0x0 0x4 r4
0x41 0x42 0x42 0x43
[raíz] $
Este ejemplo se puede verificar con la operación de lectura anterior donde hemos leído 16 bytes de Offset 0000. Ahora, hemos leído el subconjunto. Si comparamos los resultados de esta operación de lectura y verificamos con la anterior, los resultados coinciden exactamente. Por lo tanto, podemos concluir que esta lectura es exitosa.
Conclusión
Hemos discutido el paquete de herramientas I2C en Linux. Varios comandos están disponibles en este paquete I2C-Tools. Algunos casos de uso especial como 2-bytes se dirigen, cómo usar comandos en estos escenarios especiales. Muchos ejemplo que hemos visto hasta ahora. Confirmamos todos los comandos que funcionan con el ejemplo y las demostraciones. I2cset, i2cget, i2cdump, i2cdetect e i2ctransfer son los comandos del paquete I2C -Tools.