Comunicação entre Arduinos: I2C - Parte 2

Esse tutorial é a segunda parte do Tutorial Comunicação entre Arduinos: I2C - Parte 1. Se você ainda não viu, recomendamos que veja a Parte 1 do tutorial antes prosseguir.
Nessa segunda parte do tutorial a placa Slave estará conectada ao botão e, ao pressionar este botão, o estado do led conectado à placa Master será alterado. A placa Master trabalhará como o receptor e a placa slave como o emissor.

Para isso precisaremos de:

Confira na imagem ao lado como realizar as conexões de cada BlackBoard.

Agora que você já montou todo o circuito, é necessário programar cada placa com seu código. Neste momento, é importante que você verifique se está gravando a BlackBoard correta, por isso recomendamos que conecte e programe uma placa por vez. Desta forma você não irá se confundir com as portas COM.

Código para a BlackBoard Master (conectada ao LED):

/*
      RoboCore - Tutorial Comunicacao entre Arduinos: I2C - Parte 2
                                                           (Master)
                                                       (03/05/2015)

  Escrito por Marcelo Farias.

  Exemplo de como comunicar Arduinos utilizando o protocolo I2C.

  Altera o estado do LED conectado a placa Master quando o botao ligado
  a placa Slave for pressionado.

  Na placa Master foi utilizado um botao conectado ao pino 4, com o
  resistor de pullup interno da placa acionado e realizou-se um debounce
  em software. Na placa Slave foi utilizado um LED conectado ao pino 7.

  Referencias:
  Exemplo Debounce - https://www.arduino.cc/en/Tutorial/Debounce
  Tutorial Master Reader - https://www.arduino.cc/en/Tutorial/MasterReader
*/

#include "Wire.h"

#define ledPin 7 // numero do pino onde o LED esta conectado
  
// endereco do modulo slave que pode ser um valor de 0 a 255
#define slaveAdress 0x08

void setup() {
  // conecta ao barramento I2C com o endereço definido no myAdress (0x08)
  Wire.begin();

  pinMode(ledPin, OUTPUT);  // configura o pino do LED como saida
}

void loop() {
  // realiza uma requisicao de 1 byte de dados do modulo slave
  Wire.requestFrom(slaveAdress, 1);
  // verifica se existem dados para serem lidos no barramento I2C
  if (Wire.available()) {
    // le o byte recebido
    char received = Wire.read();

    // se o byte recebido for igual a 0, apaga o LED
    if (received == 0) {
      digitalWrite(ledPin, LOW);
    }

    // se o byte recebido for igual a 1 acende o LED
    if (received == 1) {
      digitalWrite(ledPin, HIGH);
    }
  }
}

Código para a BlackBoard Slave (conectada ao botão):

/*
      RoboCore - Tutorial Comunicacao entre Arduinos: I2C - Parte 2
                                                           (Master)
                                                       (03/05/2015)

  Escrito por Marcelo Farias.

  Exemplo de como comunicar Arduinos utilizando o protocolo I2C.

  Altera o estado do LED conectado a placa Master quando o botao ligado
  a placa Slave for pressionado.

  Na placa Master foi utilizado um botao conectado ao pino 4, com o
  resistor de pullup interno da placa acionado e realizou-se um debounce
  em software. Na placa Slave foi utilizado um LED conectado ao pino 7.

  Referencias:
  Exemplo Debounce - https://www.arduino.cc/en/Tutorial/Debounce
  Tutorial Master Reader - https://www.arduino.cc/en/Tutorial/MasterReader
*/

#include "Wire.h" // inclui a biblioteca Wire

#define buttonPin 4 // numero do pino onde o botao esta conectado
  
// endereco do modulo slave que pode ser um valor de 0 a 255
#define myAdress 0x08 

boolean buttonState;             // estado atual do botao
boolean lastButtonState = LOW;   // valor da ultima leitura do botao
boolean ledState = HIGH;         // estado atual do LED

// as variaveis a seguir sao do tipo long por conta que o tempo, medido 
// em milessegundos alcancara rapidamente um numero grande demais para 
// armazenar em uma variavel do tipo int

// tempo da ultima modificacao do estado do LED
unsigned long lastDebounceTime = 0;

// tempo de debounce; aumentar se o LED oscilar; espera-se que o LED acenda
// apenas se o botao for pressionado por mais de 50ms
unsigned long debounceDelay = 50;    

void setup() {
  Wire.begin(myAdress); // ingressa ao barramento I2C
  Wire.onRequest(requestEvent); // registra um evento para tratar requisicoes
  
  // configura o pino do botao como entrada com resistor de pullup interno
  pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
  // le o estado do botao e salva em uma variavel local
  int reading = digitalRead(buttonPin);

  // verifica se voce apenas apertou o botao (i.e. se a entrada foi de LOW 
  // to HIGH), e se ja esperou tempo suficiente para ignorar qualquer ruido

  // se a entrada foi alterada devido ao ruido ou botao ter sido pressionado:
  if (reading != lastButtonState) {
    // reseta o tempo do debounce
    lastDebounceTime = millis();
  }
  
  if ((millis() - lastDebounceTime) > debounceDelay) {
    // qualquer que seja a leitura atual, ela se manteve por um tempo maior
    // que o nosso debounce delay, então atualizemos o estado atual:

    // se o estado do botao foi alterado:
    if (reading != buttonState) {
      buttonState = reading;

      // apenas altera o estado do LED se o novo estado do botao e HIGH
      if (buttonState == HIGH) {
        ledState = !ledState;
      }
    }
  }
  // salva a leitura. No proximo laco este sera o ultimo 
  // estado do botao (lastButtonState)
  lastButtonState = reading;
}

// rotina para tratamento de requisicoes
// executada quando o mestre faz uma requisicao no barramento para
// o endereco desta placa, definido como 'myAdress'
void requestEvent(){
  // envia o estado que o led deve assumir
  Wire.write(ledState);
}

Agora basta alimentar ambas as placas que tudo deve funcionar perfeitamente. Aperte o botão da BlackBoard Slave e o LED conectado a placa Master deve acender. Se você apertar novamente o mesmo deve apagar. Agora você já sabe como enviar ou fazer requisições de mensagens utilizando o protocolo de comunicação I2C.

Comentários

Para fazer comentários é necessário estar logado. Efetuar login.

Você ainda nao é cadastrado? Cadastre-se agora!

fcarlosrodrigues
date

Enviado: 2019-07-04 11:29:58

Olá,
Também estou buscando conectar vários (10 a 15) arduinos entre si, pensei de usar o protocolo i2c, (porém seria necessário endereçar os escravos para solicitação de leitura e para distinguir as leituras dos sensores), teria um exmplo desse tipo de comunicação ?
Muito obrigado!
 Abraço!

Giovanni5

Enviado: 2019-07-04 11:54:59
fcarlosrodrigues

Infelizmente não temos ainda um exemplo pronto para uma comunicação I2C com mais escravos. Entretanto, esse tutorial é um ótimo exemplo para entender como realizar requisições e enviar informações entre mestre e escravos através deste protocolo.

vitinho
date

Enviado: 2019-04-05 12:36:34

Olá, consigo utilizar o protocolo I2C para que 4 SLAVES realizem a leitura de sensores analógicos diversos e as enviem para o MASTER? Irei precisar desenvolver isso para o meu TCC ...

Giovanni5

Enviado: 2019-04-05 16:10:23
vitinho

É possível realizar essa comunicação, porém seria necessário endereçar os escravos para solicitação de leitura e para distinguir as leituras dos sensores. Deste modo cada condição de leitura terá uma reação diferente sem a necessidade de mais mestres.

vitinho

Enviado: 2019-05-01 11:10:03
vitinho

obg pela ajuda!! tenho mais uma pergunta rsrs ja realizei a programação do sistema e estão se comunicando, porem percebi que os valores lidos pelo master estão entre um intervalo de 0  a 255, enquanto os escravos realizam a leitura normalmente, creio que seja uma limitação do protocolo I2c.

Giovanni5

Enviado: 2019-05-02 12:00:56
vitinho

O protocolo I2C possui diversas limitações, porém pode ser que essa diferença na leitura entre escravos e mestre seja causada  apenas um problema de código. Caso realmente não seja um problema de código, é necessário estudar qual limitação do protocolo está causando este distúrbio, para, se possível, encontrar uma solução.

vitinho

Enviado: 2019-05-06 19:52:45
vitinho

Você têm algum exemplo de como enviar dois dados de um arduino para o outro via o protocolo i2C.

Giovanni5

Enviado: 2019-05-07 09:49:57
vitinho

Infelizmente não temos nenhum tutorial pronto sobre como enviar mais de um dado entre placas da plataforma Arduino. Porém, se você já consegui enviar um dado de uma placa para outra, enviar mais de um dado, deve ser apenas uma questão de implementação do código.

rubensx
date

Enviado: 2017-09-06 22:21:51

Amigos, qual a distância de cabo que o i2C pode transferir informações sem perda? Na hipótese de ter dois arduinos um com um sensor e outro com um display e os dados sendo comunicados entre eles, poderiam ficar 2 metros longe um do outro? em testes apenas o sensor 2 metros longe (sensor i2c) a impedância do cabo parece interferir... Será que existe um amplificador de sinal i2c? obrigado

Francois

Enviado: 2017-09-08 13:54:07
rubensx

Depende da configuração. Por ser um sinal digital, a distância de transmissão é maior do que um sinal analógico. Porém, a impedância influencia no sinal de transmissão e pode tornar a mensagem incompreensível. Verifique as conexões, se o GND das duas placas estão conectados, senão você pode tentar usar um cabo blindado, resistores de pull-up (2k2, 4k7) e/ou um amplificador/buffer I2C.

tobisd
date

Enviado: 2017-06-28 09:45:44

para que serve o sck(Serial Clock)?
nao poderia haver apenas o SDA(Serial Data)?

MarceloFarias
date

Enviado: 2017-06-28 10:18:47
tobisd

O SCK é um clock responsável por garantir o sincronismo da comunicação. A cada pulso os dispositivos sabem que uma unidade de informação foi transferida, assim podem identificar o início e o fim de cada bit na comunicação.

tobisd
date

Enviado: 2017-06-18 19:31:24

Para que serve o clock sck, não poderia simplesmente ser enviado
O dado?

MarceloFarias
date

Enviado: 2017-06-19 15:11:09
tobisd

Não entendi sua pergunta.