I2C com Raspberry Pi

I2C com Raspberry Pi

Esse artigo tende a ser genérico tanto quanto possível, porque o foco é falar sobre o barramento I2C com Raspberry Pi e discorrer sobre sua utilização.

Brevemente introduzindo o assunto, I²C ou IIC significa Inter-Integrated Circuito, tratando-se de um barramento multi-mestre desenvolvido pela Philips para interconexão de dispositivos de baixa velocidade onboard. Claro, diversos sensores tem sido implementados em circuitos independentes, bastando fornecer-lhes alimentação do circuito em comum e interconexão com o barramento I²C. Com isso, a conexão entre um Raspberry ou um Arduino com qualquer dispositivo I²C deve possuir 4 fios.

Dispositivos que se utilizam de I²C podem por vezes ser úteis para reduzir o número de GPIOs necessários para uma conexão, como ----essa interface I²C para displays de 16x2---. Mas esse barramento é mais comum do que se pode imaginar; sensores como o MPU6050, alguns displays OLED, RTC (Real Time Clock), sensores de pressão etc.

Como vocês podem ver, já escrevi bastante coisa utilizando I²C, mas como tudo utiliza biblioteca, não vimos claramente a interface com o barramento, que pode conter diversos dispositivos atrelados e a consulta feita pelo respectivo endereço. Alguns desses dispositivos são facilmente endereçaveis.

No Arduino e no Raspberry, os pinos relacionados ao barramento I²C estão marcados como SCL para clock e SDA para barramento de dados. Apesar de ser utilizado em computadores X86/X86_64 (para medir temperatura da CPU por exemplo), seu uso é muito mais comum em sistemas embarcados, com velocidades entre 1Mbps e 3.4Mbps.

Inicialmente seu modo de operação é Mestre consultando slaves, que acaba por se parecer em muito com uma comunicação RS485 exclusivamente nesse aspecto. Para que a comunicação ocorra, o mestre envia o bit inicial com os 7bits do escravo-alvo, que em caso de existir, responde 1bit para se anunciar ao mestre. Nesse ponto, é muito similar a um 'ping', também somente nesse aspecto de consulta. A partir desse ponto a comunicação e seguida conforme desejado, recebendo ou enviando. Com o bit 0 o mestre diz que deseja escrever e com o bit 1 o mestre diz ue deseja ler do escravo.

Apenas para ficar claro, o bit inicial é dado de uma baixa para alta no canal de dados (SDA) enquanto o clock (SCL) está em alta, assim como o último bit, e nos demais modos a transição de SDA é feita com o SCL em baixa. Para o master escrever, ele envia os dados e recebe um bit do escravo certificando a comunicação. Cada leitura também é respondida com um bit certificador.

Como em quase todos os casos existem bibliotecas para interagir com os dispositivos I²C, o hobista mal se dá ao trabalho de fazer parsing na mensagem, mas isso dificulta o entendimento da comunicação com multiplos dispositivos conectados ao barramento, por isso decidi fazer esse artigo para mostrar alguns dos recursos do Raspberry para a manipulação de I²C, inclusive sua habilitação no sistema.

MPU6050

Esse acelerômetro com giroscópio é um sensor bastante conhecido e utilizado. Já escrevi um artigo sobre ele nesse link. No Arduino normalmente é utilizada a biblioteca Wire.h, mas conforme o datasheet do MPU6050MPU-6050_DataSheet_V3%204.pdf, ambos os barramentos estão disponíveis; SPI e I²C. O I²C tem dois canais, sendo o slave (utilizando SDA e SCL) para receber comandos externos e o canal master (nos AUX_*) para fazer consulta a outro dispositivo I²C, como um magnetômetro.

No datasheet estão especificados os 2 endereços I²C, mas depois veremos um scan do barramento à procura de dispositivos, sem necessidade de mais esforço.

PCF8574

Esse CI é um expansor de I/O I²C endereçável e de fácil manipulação. Basicamente ele tem 8bits de I/O, disponibilizando assim 8 portas de escrita/leitura e 1 pino para interrupções - ótimo para o caso de tratamento de eventos.

Uma característica interessante é que o I²C permite live connection, ou seja, novos dispositivos podem ser conectados e desconectados do barramento sem a necessidade de desligamento do Raspberry Pi. Como vou entrar em detalhes da configuração desse expansor em um próximo artigo onde interligarei 3 deles e mostrarei detalhes de configuração, decidi antecipar nesse artigo a configuração do RPi para suportar a utilização do barramento. Sigamos.

Configurar o I²C no Raspberry

Os passos são simples, porém diversos. Seguindo-os conforme descrito você deverá obter um suporte habilitado a contento.

1 - raspi-config

Como root (sudo su) execute o comando 'raspi-config' no seu Raspbian e no menu que se abre vá em 'Advanced' e habilite o suporte a I²C. Quando concluido, você poderá ser questionado sobre um reboot. Faça-o. Porém isso não foi o suficiente para mim e outros passos foram necessários.

2 - /etc/modules

Edite o arquivo /etc/modules e se não estiver lá, insira as duas linhas a seguir:

#i2c
i2c-bcm2835 
#disponibilizar o barramento em /dev
i2c-dev

O segundo módulo é necessário porque ele oferece uma interface com o barramento I²C através de um arquivo descritor em /dev, normalmente sendo algo como i2c-N. Vou mostrar isso em detalhes no próximo artigo.

3 - Garanta que não haja barreiras pela frente

Edite o arquivo /etc/modprobe.d/raspi-blacklist.conf e verifique se há quaisquer linhas relacionadas ao I²C. Se ocorrer, adicione uma cerquilha (sustenido, jogo-da-velha,bequadro,cerquinha ou como você quiser chamar) ao início da linha e salve o arquivo.

4 - Garanta que ambas as linhas estejam contidas no arquivo

Edite o arquivo /boot/config.txt e procure por estas linhas. Se não houver alguma, inclua:

dtparam=i2c_arm=on
#apos i2c eh UM, nao L
dtparam=i2c1=on 

5 - reboot

E calma, não acabou.

6 - Instalar pacotes

sudo su
apt-get install python-smbus i2c-tools

7 - Faça o teste

Se você já tiver algum dispositivo I²C conectado, já deverá estar apto a encontrá-lo. Se estiver utilizando o RPi 1, a porta será 0, senão, a porta será 1:

i2cdetect -y 1

Como eu estava com 2 dispositivos conectados no momento desse comando, o retorno foi esse:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f 00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: 20 -- -- -- 24 -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: -- -- -- -- -- -- -- --

Os endereços são exibidos em hexadecimal pelo comando supracitado (no meu caso, os endereços são o 0x20 e 0x24). No próximo artigo vou mostrar a manipulação desse expansor de I/O I²C utilizando Python no RPi, com o código bonitinho para explicar a leitura e escrita em binário, decimal e hexadecimal. Prometo que o próximo post será tão breve quanto possível e já o tenho quase pronto!

Inscreva-se no nosso canal Manual do Maker Brasil no YouTube.

Próximo post a caminho!