I2C Utilitários no Linux
Descrição
Hoje em dia, a maioria dos sistemas Linux está equipada com esses comandos. Se algum sistema não possui esses comandos, eles podem ser compilados para o próprio sistema. A compilação para o próprio sistema só pode ser feita se a instalação do compilador estiver disponível. Se o compilador não estiver disponível, eles precisam ser compilados cruzados. O código-fonte dessas ferramentas é de código aberto e as etapas de compilação são iguais às de outras ferramentas Linux.
Comandos amplamente utilizados disponíveis no pacote i2c-tools são: i2cdetect, i2cdump, i2cget, i2cset, i2ctransfer. Vamos discutir esses comandos em detalhes.
i2cdetect
Este comando é usado para detectar e listar todos os ônibus i2c disponíveis e conhecidos pelo Linux.
Pode haver vários controladores/ônibus I2C disponíveis no sistema e todos os ônibus podem ser listados com o comando i2cdetect. Exemplo de uso do i2cdetect é: i2cdetect -l
Este comando fornece a saída abaixo em um sistema:
[raiz] $ 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
[raiz] $
Na saída acima, podemos ver que, quando executarmos este comando com -l opção, ele está listando todos os ônibus i2c do sistema. Na saída que podemos ver, existem 4 ônibus disponíveis e conhecidos pelo Linux. 0, 1, 2 e 5 são o número de ônibus atribuídos pelo kernel Linux. Estes são os números necessários em outras operações de comando.
Mais informações sobre todos os escravos conectados ao barramento específico também podem ser consultados com este comando. Por exemplo, se queremos obter os detalhes no ônibus nº 0, podemos emitir comando como i2cget -y 0.
A saída do comando em nosso sistema é:
[raiz] $ 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: -- -- -- -- -- -- -- --
[raiz] $
Como podemos ver nos troncos acima, existem 4 escravos no ônibus 0. Endereço escravo daqueles dispositivos de escravos i2c no barramento 0 são 0x30, 0x36, 0x50, 0x52. Este endereço de escravo i2c também é necessário para comandos i2cget, i2cget, i2cdump.
i2cget
i2cget pode ser usado para ler o dispositivo escravo i2c. Qualquer endereço legível interno pode ser lido com o comando i2cget. O uso da amostra deste comando pode ser demonstrado com uma instância, digamos que queremos ler o deslocamento/endereço interno como 0x0 do dispositivo escravo I2C com endereço de escravo (0x50) no barramento nº 0. Os registros da operação do dispositivo são:
[raiz] $ i2cget -y 0 0x50 0
0x23
[raiz] $
Nos logs de saída. Podemos ver os dados no deslocamento 0 é 0x23. De maneira semelhante, esse comando pode ser usado para ler qualquer dispositivo escravo em qualquer barramento i2c ou em qualquer endereço interno do dispositivo escravo i2c.
i2cset
O comando i2cget pode ser usado para escrever os dados em qualquer endereço interno especificado do dispositivo escravo i2c. O endereço interno do dispositivo i2C deve ser gravável. Operação de gravação I2C pode ser protegida no nível do dispositivo ou qualquer endereço interno pode ser apenas de gravação. Com todas as permissões graváveis, o comando i2cset pode atualizar o dispositivo.
Exemplo de uso do comando, vamos dar um exemplo de gravação de um valor de dados 0x12 para dispositivo escravo RTC com endereço de escravo 0x68 no deslocamento 0x2. Demonstraremos a operação de gravação na seguinte sequência:
- Leia o dispositivo no deslocamento 0x2
- Escreva o 0x12 no deslocamento 0x2 do dispositivo escravo 0x68
- Leia o dispositivo no deslocamento 0x2 e verifique se os dados devem ser 0x12.
1.Leia o dispositivo no deslocamento 0x2.
[raiz] $ i2cget -y 1 0x68 0x2
0x14
[raiz] $
2.Escreva o 0x12 no deslocamento 0x2 do dispositivo escravo 0x68
[raiz] $ i2cset -y 1 0x68 0x2 0x12
[raiz] $
3.Leia o dispositivo no deslocamento 0x2 e verifique se os dados devem ser 0x12.
[raiz] $ i2cget -y 1 0x68 0x2
0x12
[raiz] $
Exemplo acima etapas/saída na caixa demonstra a operação de gravação no dispositivo escravo i2c. Etapas semelhantes podem ser seguidas para escrever quaisquer dados no dispositivo escravo i2c. Endereço escravo, dados ou número do barramento podem ser alterados de acordo com o sistema e necessidade.
i2cdump
O comando i2cdump pode ser usado para despejar dados de qualquer dispositivo de escravo i2C. Somente a entrada necessária para esta execução de comando é o número do barramento i2c, endereço de escravo. A gama de endereço também pode ser especificada com o comando. Vamos dar um exemplo de leitura de bytes de deslocamento 0x0 a 0xf i.e., Primeiros 16 bytes.
[raiz] $ i2cdump -y -r 0x0-0xf 1 0x68
Nenhum tamanho especificado (usando acesso de bytes de dados)
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)????!.. ?.
[raiz] $
O endereço do intervalo é opcional, se esse intervalo não for especificado por padrão, ele despeja o primeiro 0xFF bytes. eu.e., 256 bytes.
i2ctransfer
O comando i2ctransfer é muito útil e pode ser usado para ler ou escrever vários número de bytes no mesmo comando.
I2CTransfer Para ler 14 bytes de 0ffset 0x2, o comando será o seguinte:
[raiz] $ i2ctransfer -y 1 w1@0x68 2 r14
0x12 0x06 0x08 0x10 0x21 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x18 0x00
[raiz] $
I2CTransfer Para escrever 2 dados de bytes 0x10, 0x16 No deslocamento 0x1 e 0x2, o comando será o seguinte:
[raiz] $ i2ctransfer -y 1 w3@0x68 1 0x10 0x16
[raiz] $
Readback; Para confirmar os dados de gravação:
[raiz] $ i2ctransfer -y 1 w1@0x68 1 r2
0x10 0x16
[raiz] $
Os exemplos acima demonstraram o uso de I2CTransfer com uma instância. Com a ajuda desse uso, outros casos de uso podem ser facilmente executados. Qualquer dispositivo escravo e qualquer endereço interno podem ser lidos com a ajuda deste comando.
E se o dispositivo escravo for de 2 bytes endereçáveis?
Existem poucos dispositivos de escravos I2C, especificamente o dispositivo EEPROM, que são de 2 bytes-endereço. A transferência i2C fornece a maneira mais fácil de acessar o dispositivo nesse cenário. Se este dispositivo, queremos acessar com i2cget/i2cset, temos que considerar os 2 bytes abordando.
Eu tenho um dispositivo EEPROM comigo, que é 2 bytes endereçáveis. Vamos observar o i2cget/i2cset com a EEPROM e depois observaremos a I2CTransfer:
Vamos tentar ler byte do deslocamento 0. Vamos tentar com o mesmo comando que discutido na seção anterior do i2cget i.e., O comando será: i2cget -y 1 0x50 0
[raiz] $ i2cget -y 1 0x50 0
0xff
[raiz] $
Podemos ver que os dados retornados são 0xFF, portanto, esses não são os dados corretos.
Para ler com êxito do deslocamento 0, temos que escrever um endereço de 2 bytes com o comando i2cset. Esta é a maneira de ler os dados do dispositivo de 2 bytes. Exemplo de uso de uso:
[raiz] $ i2cset -y 1 0x50 0x0 0x0
[raiz] $ i2cget -y 1 0x50
0x45
[raiz] $
No comando i2cset, temos que escrever o endereço EEPROM interno de 2 bytes. Dois 0's após o endereço de escravo 0x50 são o endereço EEPROM interno como 0x0000.
Depois disso, se lermos os dados com o i2cget, obteremos os dados corretos. Podemos ver em nosso exemplo que é 0x45. Anteriormente, era 0xFF, que é um dados inválidos.
I2CTransfer no dispositivo de endereçamento de 2 bytes
i2ctransfer pode fornecer aos dados o mesmo comando. Considere o mesmo exemplo de caso de uso como I2CGet/i2Cset como acima.
[raiz] $ i2ctransfer -y 1 w2@0x50 0x0 0x0 r1
0x45
[raiz] $
Com este comando, podemos ler os dados no deslocamento 0000. Observe que devemos escrever endereço interno depois de dividir em 2 bytes.
Outro exemplo, lendo 16 bytes do deslocamento 0x0000:
[raiz] $ i2ctransfer -y 1 w2@0x50 0x0 0x0 r16
0x45 0x41 0x3d 0x41 0x41 0x42 0x42 0x43 0x43 0x44 0x44 0x44 0x45 0x45 0x30 0x0aa
[raiz] $
Mais um exemplo para ler 4 bytes do deslocamento 0x0004:
[raiz] $ i2ctransfer -y 1 w2@0x50 0x0 0x4 r4
0x41 0x42 0x42 0x43
[raiz] $
Este exemplo pode ser verificado com a operação de leitura anterior, onde lemos 16 bytes do deslocamento 0000. Agora, lemos o subconjunto. Se compararmos os resultados desta operação de leitura e verificarmos com o anterior, os resultados correspondem exatamente. Portanto, podemos concluir que esta leitura é bem -sucedida.
Conclusão
Discutimos o pacote de ferramentas i2C no Linux. Vários comandos estão disponíveis neste pacote i2c-tools. Alguns casos de uso especiais, como abordagem de 2 bytes, como usar comandos nesses cenários especiais. Muitos exemplo que vimos até agora. Confirmamos todos os comandos funcionando com o exemplo e demonstrações. I2cset, i2cget, i2cdump, i2cdetect e i2ctransfer são os comandos do pacote i2c -tools.