No tutorial anterior, discutimos os fundamentos do protocolo I2C. Na maioria dos dispositivos incorporados, UART ou I2C é usado para mensagens de console. Neste tutorial, discutiremos a comunicação serial no Raspberry Pi usando o protocolo I2C.
I2C em Raspberry Pi
Para comunicação serial através do protocolo I2C, o processador Broadcom do Raspberry Pi possui Broadcom Serial Controller (BSC). Este controlador BSC mestre de modo padrão é compatível com I2C da NXP Semiconductor e suporta uma taxa de transferência de dados de 400 kbps. O controlador BSC suporta endereçamento de 7 e 10 bits. Esta interface I2C é acessível nos pinos GPIO2 (pino nº 3 da placa) e GPIO3 (pino nº 5 da placa). GPIO2 é uma linha Serial Data (SDA) e GPIO3 é uma linha Serial Clock (SCL) do I2C1. Esses pinos I2C são puxados internamente até 3,3 V por meio de resistores de 1,8 kohms. É por isso que esses pinos não podem ser usados para E/S de uso geral onde o pull-up não é necessário.
Existe mais um periférico I2C BSC2 no Raspberry Pi identificado como I2C0. O mestre BSC2 é dedicado à interface HDMI e não pode ser acessado pelos usuários. Esta interface I2C está presente nos pinos 27 (ID_SD) e 28 (ID_SC) da placa. I2C0 permanece reservado para leitura de EEPROM de placas complementares do Raspberry Pi chamadas placas Hardware on The Top (HAT). I2C0 só pode se comunicar com HAT EEPROM no endereço 0x50 durante o tempo de inicialização.
É possível acessar I2C0 somente se a interface da câmera e a porta HDMI não estiverem em uso. Para usar I2C0, adicione as seguintes linhas ao boot/config.txt.
dtparam=i2c_vc=ligado
Os pinos I2C0 não são puxados internamente, portanto, se forem usados modificando o arquivo de configuração do Raspberry Pi, pull-ups externos (para 3,3V) devem ser usados nas linhas SDA e SCL. Ao usar I2C0, os pinos evitam usar o endereço HAT EEPROM.
Até o I2C1 está desabilitado no Raspberry Pi por padrão. Ele precisa ser habilitado na configuração do Raspberry Pi. Os controladores BSC do Raspberry Pi suportam I2C multimestre e multiescravo. Portanto, I2C1 é suficiente para conectar vários escravos I2C (máximo 112 escravos) e qualquer número de dispositivos mestres.
Habilitando I2C1 da GUI do Raspberry Pi
No Raspbian, navegue até Pi Start Menu -> Preferences -> Raspberry Pi Configuration.
Na janela pop-up, clique na guia ‘Interfaces’ e selecione o botão de opção ‘Ativar’ para I2C. Você também pode ativar ou desativar outras interfaces conforme necessário.
Para que as alterações tenham efeito, reinicie o Raspberry Pi. Após a reinicialização, GPIO3 e GPIO5 podem ser usados para conectar Raspberry Pi como mestre I2C com um barramento I2C ou a qualquer escravo I2C.
Habilitando I2C1 do Terminal
O suporte I2C para o núcleo ARM do Raspberry Pi e o kernel do Linux também pode ser habilitado no Terminal (Bash Shell no Raspberry Pi). Abra o Terminal e execute o seguinte comando:
sudo raspi-config
Na ferramenta de configuração do software Raspberry Pi, navegue até ‘Opções de interface’.
Em modelos Raspberry Pi mais antigos, navegue até ‘Opções avançadas’ e depois ‘I2C’.
Na janela pop-up, habilite a interface Arm I2C e selecione 'Sim' para carregar o Módulo Kernel I2C.
Agora reinicie o Raspberry Pi digitando o seguinte comando:
sudo reiniciar
Após a reinicialização, GPIO3 e GPIO5 podem ser usados para conectar Raspberry Pi como mestre I2C com um barramento I2C ou a qualquer escravo I2C.
Testando porta I2C
Depois de habilitar a porta do usuário I2C e reiniciar o Raspberry Pi, podemos testar se a porta está disponível como dispositivo Linux ou não. Na janela do Terminal, execute o seguinte comando:
ls /dev/
Ou
ls /dev/*i2c*
I2C1 deve aparecer como um dos dispositivos Linux disponíveis conforme imagem abaixo.
Observe que nas versões mais antigas do Raspberry Pi, a porta do usuário I2C é identificada como I2C0 em vez de I2C1. Em todos os modelos Raspberry Pi 256M, a porta do usuário I2C é 0 e, no restante, é 1.
Verificando escravos I2C no Raspberry Pi
Após habilitar a porta do usuário I2C, os escravos I2C conectados podem ser detectados usando i2c-tools. Em primeiro lugar, instale o i2c-tools executando o seguinte comando no Terminal Raspberry Pi:
sudo apt-get install -y i2c-tools
Agora execute o seguinte comando para verificar os escravos I2C conectados:
sudo i2cdetect -y 1
Como já mencionado que nas versões mais antigas do Raspberry Pi a porta do usuário I2C é 0, nas versões mais antigas altere o número da porta para 0 da seguinte forma:
sudo i2cdetect -y 0
O i2c-detect é uma ferramenta que verifica a porta do usuário I2C e retorna os endereços I2C dos dispositivos escravos conectados. A ferramenta retorna uma tabela de endereços de dispositivos escravos I2C conectados conforme mostrado na imagem abaixo:
Acessando dispositivos I2C usando a biblioteca SMBus
No Raspberry Pi, o barramento I2C pode ser acessado em um script Python usando a biblioteca SMBus. SMBus é um subconjunto da interface I2C. A biblioteca Python para SMBus pode ser usada para comunicação com dispositivos baseados em I2C. A biblioteca SMBus pode ser instalada no Raspberry Pi executando o seguinte comando:
sudo apt-get install python-smbus
Em um script Python, a biblioteca SMBus pode ser importada usando a seguinte instrução:
importar smbus
Após importar a biblioteca SMBus, um objeto da classe SMBus deve ser criado utilizando o método SMBus . O método SMBus usa o número da porta I2C como parâmetro e deve ser usado em uma instrução de atribuição para criar um objeto SMBus. Possui a seguinte sintaxe:
A seguir está um exemplo válido de criação de um objeto SMBus:
barramento i2c = smbus.SMBus(1)
Observe que nas versões mais antigas do Raspberry Pi, a porta do usuário I2C é 0, e em todas as versões do Raspberry Pi acima de 256M RPi, é 1. Para usar a biblioteca SMBus2 mais recente, ela pode ser instalada usando pip executando o seguinte comando:
pip instalar smbus2
Em um script Python, a biblioteca SMBus2 pode ser importada usando a seguinte instrução:
de smbus2 importar SMBus, i2c_msg
Um objeto da classe SMBus pode ser criado usando o método smbus2.SMBus da seguinte forma:
barramento i2c = smbus2.SMBus(1)
A biblioteca smBus2 possui duas classes – SMBus e i2c_msg. A classe SMBus oferece suporte aos seguintes métodos:
smbus.SMBus /smbus2.SMBus – Para criar um objeto SMBus em script Python.
aberto (ônibus) – Para abrir um determinado barramento i2c.
fechar – Para fechar a conexão I2C.
Os dados seriais de um escravo I2C podem ser lidos em bytes, palavras ou blocos de bytes. Em alguns dispositivos escravos I2C, o mestre precisa acessar dados seriais de registros específicos. Os seguintes métodos estão disponíveis na biblioteca SMBus2 para leitura de dados seriais I2C de dispositivos escravos:
read_byte(i2c_addr,força=Nenhum) – Para ler um único byte de um dispositivo.
read_byte_data(i2c_addr,registrar,force=Nenhum) – Para ler um único byte de um registro designado.
read_block_data(i2c_addr,registrar,force=Nenhum) – Para ler um bloco de até 32 bytes de um determinado registro.
read_i2c_block_data(i2c_addr,registro,comprimento,força=Nenhum) – Para ler um bloco de dados de bytes de um determinado registro.
read_word_data(i2c_addr,registrar,force=Nenhum) – Para ler uma única palavra (2 bytes) de um determinado registro.
Da mesma forma, os dados podem ser gravados em escravos I2C em bytes, palavras ou blocos de bytes. Em alguns dispositivos escravos I2C, os dados devem ser gravados em registros específicos. Os seguintes métodos estão disponíveis na biblioteca SMBus2 para gravar dados I2C seriais de dispositivos escravos:
write_byte(i2c_addr,valor,força=Nenhum) – Para escrever um único byte em um dispositivo.
write_byte_data(i2c_addr,registro,valor,força=Nenhum) – Para escrever um byte em um determinado registro.
write_block_data(i2c_addr,registro,dados,força=Nenhum) – Para escrever um bloco de dados de bytes em um determinado registro.
write_i2c_block_data(i2c_addr,registrar,dados,força=Nenhum) – Para escrever um bloco de dados de bytes em um determinado registro.
write_word_data(i2c_addr,registro,valor,força=Nenhum) – Para escrever um byte em um determinado registro.
write_quick(i2c_addr,força=Nenhum) – Para realizar transações rápidas. Lança IOError se não tiver êxito.
Os seguintes métodos estão disponíveis para gerenciar processos SMBus e combinar operações de leitura/gravação do barramento I2C:
process_call(i2c_addr,registro,valor,força=Nenhum) – Para executar uma chamada de processo SMBus, enviando um valor de 16 bits e recebendo uma resposta de 16 bits
block_process_call(i2c_addr,registro,dados,força=Nenhum) – Para enviar um bloco de dados de tamanho variável e receber outra resposta de tamanho variável.
i2c_rdwr(*i2c_msgs) – Para combinar uma série de operações de leitura e gravação i2c em uma única transação.
No próximo tutorial, discutiremos a interface do sensor acelerômetro ADXL345 com Raspberry Pi via porta I2C.
