I2C Visão geral no Linux

Neste artigo, exploraremos a introdução básica no I2C e a implementação do I2C no Linux. Vamos explorar o subsistema i2C no kernel Linux e alguns exemplos para a comunicação I2C Master e Slave.

Descrição

I2C significa Inter -Integrated Circuit, é um protocolo a bordo para usado para comunicação entre dois ICs. É um serial, dois protocolo de arame. Isso segue o modo escravo mestre. O I2C Master sempre inicia a comunicação e o relógio para comunicação também são fornecidos pelo I2C Master. Em duas linhas, pode haver vários dispositivos conectados. Em um único mestre e muitas configurações de escravo, todo escravo será distinguido com endereço de escravo exclusivo.

Exemplo de configuração de mestre único e múltiplos escravos:

No diagrama de blocos acima, podemos ver que há um mestre único e 3 escravos com endereços, conforme mencionado na caixa de cada escravo.

Protocolo I2C

A sequência de mensagens gerais i2C usada na comunicação entre mestre e escravo é mostrada abaixo:

Iniciar -> Endereço + R/W BYTE -> ACK -> Data Byte1 -> ACK -> Data Byte2 -> ACK -> Data Byte3 -> ACK -> Stop

Começar: Condição gerada pelo mestre para indicar que deseja se comunicar com o escravo.

Endereço + r/w byte: Endereço de escravo de 7 bits e 1 bit para indicar se a operação é lida ou escrita.

ACK: O reconhecimento é sempre enviado para todas as transferências de bytes. Isso é enviado pelo dispositivo receptor.

Parar: Depois que a transferência estiver concluída, o controlador/mestre enviará a condição de parada para concluir a transferência.

No Linux, os drivers I2C são organizados em três camadas lógicas:

1. driver de mestre/adaptador
2. Camada i2c-core
3. Driver de escravo/cliente

I2C Drivers de mestre/adaptador

Estes estão localizados na árvore de origem do kernel no caminho: drivers/ i2c/ ônibus/. Para cada mestre ou controlador I2C, deve haver um motorista presente neste caminho. Este é o motorista que se registra na camada i2c-core e controla/gerencia os busos i2c. Este é o motorista que se comunica com os dispositivos de escravos i2c sobre os ônibus I2C presentes na plataforma.

I2C-CORE DRIVERS

Esta é a lógica comum do núcleo i2c comum do Linux. Isso é comum e independente de qualquer mestre ou escravo específico do i2C. Esta é a implementação principal do subsistema I2C no Linux.

I2C Slave/Client Driver

Este é o driver de chip de escravo necessário para cada dispositivo de escravo. Qualquer dispositivo de escravo I2C deve ter driver ou implementação presente nesta categoria. Isso é necessário para que qualquer dispositivo escravo se registre no subsistema Linux i2C.

Habilitando os drivers I2C no kernel Linux

A implementação relacionada ao núcleo do I2C será ativada com sinalizadores de configuração do Kernel Core I2C. O driver mestre i2C também será ativado com o controlador I2C da placa específico. Da mesma forma, haverá um sinalizador de configuração deve ser ativado para o driver de escravos i2c.

Todas as configurações necessárias podem ser ativadas de duas maneiras. Um como motorista embutido ou como um módulo de kernel. Os módulos de kernel nos fornecem a vantagem de carregá -lo como tempo de execução sem alterar ou compilar o kernel Linux.

A abordagem do módulo só pode ser usada se o acesso ao dispositivo não faz parte do caminho da inicialização. Se os dados de qualquer dispositivo forem necessários para o sistema inicializar, esses motoristas precisam ser incorporados. Esses motoristas não podem ser compilados como módulos carregados dinamicamente em tempo de execução.

Instanciando os dispositivos i2c

No Linux, diferentes maneiras estão presentes para instanciar os dispositivos i2c. Dois métodos amplamente utilizados são: estático e dinâmico

Estático: Nos sistemas de braço, a árvore de dispositivos pode ser usada para criar uma instância do dispositivo I2C.

O nó de dispositivo específico pode ser adicionado na árvore do dispositivo. Exemplo, a declaração de árvore de dispositivos para o dispositivo I2C é:

i2c0: i2c@60000000
EEPROM@50
compatível = "atmel, eeprom-at";
reg = <0x50>;
;
rtc@60
Compatible = "RTC, RTC-MAXIM";
reg = <0x60>;
;
;

O exemplo acima cria uma instância de 2 dispositivos de escravos i2c. Um é o dispositivo EEPROM e outro é o dispositivo RTC. Após o surgimento do sistema, essas entradas podem ser encontradas em/sys/barramento/i2c/dispositivos/i2c-0/. Ambos serão criados dentro do diretório I2C-0, porque estes são colocados dentro do nó i2c 0.

Dinâmico: A instância de tempo de execução do dispositivo I2C pode ser criada através de arquivos SYSFS.

Existem dois arquivos Sysfs presentes para cada barramento i2c. new_device e delete_device, ambos os arquivos são somente de gravação e o endereço de escravo I2C pode ser escrito nesses arquivos para criar a instância do dispositivo e excluir a instância do dispositivo.
Para criar um dispositivo I2C equivalente aos dispositivos definidos na árvore de dispositivos como exemplo anterior.

Crie a instância da EEPROM com o endereço de escravo 0x50:

# eco eeprom 0x50>/sys/bus/i2c/dispositivos/i2c-0/new_device

Exclusão da instância do dispositivo EEPROM:

# eco 0x50>/sys/barramento/i2c/dispositivos/i2c-0/delete_device

Em seguida, a investigação do dispositivo com driver também pode ser feita a partir de arquivos SYSFS: existem dois arquivos somente de gravação vinculados e desbotados, associados a cada driver. Exportar ID do dispositivo para os arquivos de ligação e desbloquear os resultados para a ligação e o deslocamento do driver com o dispositivo. Por exemplo, o driver rtc-ds1307 tem os arquivos abaixo nos sysfs, conforme discutido anteriormente.

[raiz] $ ls/sys/barramento/i2c/drivers/rtc-ds1307/
vincular uevent desbloquear
[raiz] $

Vamos ter um pouco mais de discussão sobre os arquivos SYSFS do subsistema I2C:

I2c sysfs está presente no local:/sys/barramento/i2c/

Instantâneo do I2C SYSFS:

Como podemos ver, existem dois diretórios: dispositivos e drivers

Os dispositivos conterão todas as instâncias de dispositivo presentes e conhecidas pelo kernel Linux. Em nossa prancha, temos abaixo dos dispositivos I2C dentro do diretório dos dispositivos:

Os motoristas conterão todos os drivers I2C presentes e conhecidos pelo kernel Linux. Em nossa prancha, temos abaixo dos motoristas I2C dentro do diretório dos motoristas:

Para vincular e desbaste dos dispositivos com drivers, existem dois arquivos somente de gravação presentes em todos os driver. Para a vinculação de qualquer dispositivo com o driver, pode ser feito ecoando o ID do dispositivo ao arquivo de ligação e o desligamento pode ser feito ecoando o ID do dispositivo para o arquivo desbotado.

Ligação do dispositivo I2C com driver i2C

[raiz] $ echo 1-0068>/sys/bus/i2c/drivers/rtc-ds1307/bind
[592061.085104] RTC-DS1307 1-0068: Registrado como RTC0
[raiz] $

A confirmação da ligação bem -sucedida pode ser feita verificando o link suave criado após a operação de ligação. Um novo link suave do dispositivo pode ser visto na instância do log abaixo depois de executar o comando mencionado na seção de ligação:

[raiz] $ ls/sys/barramento/i2c/drivers/rtc-ds1307/
1-0068 Bind Uevent desbloquear
[raiz] $

Desparecer do dispositivo I2C com o driver i2C

[raiz] $ echo 1-0068>/sys/barramento/i2c/drivers/rtc-ds1307/não

A confirmação do desbaste bem -sucedido pode ser feita verificando o nó do dispositivo de link suave criado anteriormente dentro do diretório dos drivers será removido. Se verificarmos o conteúdo do diretório dos drivers, devemos ver o instantâneo dos logs como abaixo:

[raiz] $ LS/SYS/BUS/I2C/DRIVERS/RTC-DS1307
vincular uevent desbloquear
[raiz] $

Aplicativos i2C ou casos de uso em relação ao Linux

1. Dispositivo EEPROM Para armazenar pequenos dados, a memória é de poucos KBs.
2. Dispositivo RTC, usado para manter os dados em tempo real. O dispositivo é usado para manter o controle do tempo, mesmo quando o sistema principal está desligado.
3. Muitos dispositivos de sensores HW, como sensores térmicos, sensores de corrente e sensores de tensão, vêm como dispositivos I2C.
4. Fiários de controle de fãs também vêm como dispositivos i2c.

I2c-tools

Aplicativos de espaço do usuário no ambiente Linux são usados ​​para acessar dispositivos escravos i2c. I2cdetect, i2cget, i2cset, i2cdump e i2ctransfer são os comandos disponíveis quando i2c-tools são instalados em qualquer plataforma Linux. Todos os casos de uso dos dispositivos discutidos nas seções de aplicativos i2C podem ser acessados ​​através dessas ferramentas.

Não há necessidade de driver de dispositivo de escravo I2C, ao tentar acessar o dispositivo escravo com i2c-tools. Essas ferramentas podem nos permitir acessar os dispositivos em formato bruto. Mais detalhes sobre esses utilitários estão disponíveis em outro artigo.

Conclusão

Discutimos o subsistema I2C no Linux. I2C Framework com visão geral da organização de código lógico foi fornecido. Também discutimos arquivos i2c sysfs. Discutimos a sequência de mensagens de comunicação i2C. Passamos pela criação da instância do dispositivo de ambas as maneiras, eu.e., estático e dinamicamente. Também exploramos os drivers Bind/Unbind com dispositivos. Algumas das aplicações em tempo real da i2C.