AUTOMALABS

Este é o mesmo módulo de oito canais que eu já oferecia (siga o link para maiores detalhes sobre o módulo), agora com o acréscimo de um cabo que faz a interface I2C, reduzindo de oito para dois os pontos de i/o necessários. Até oito módulos idênticos podem ser conectados em paralelo, dando um total de 64 relês, usando os mesmos dois fios.

Posso fornecer com endereços I2C de 0x20 a 0x27. Caso não seja especificado, será enviado com qualquer valor que eu tenha em estoque. O endereço é claramente marcado na interface.

Minha convenção de cores na fiação que conecta ao Arduino (a interface mostrada na foto não segue esse padrão):

• +5V: vermelho
• GND: preto
• SCL (CLOCK): Amarelo ou laranja – Arduino UNO: A5, Arduino Mega: 21;
• SDA (DATA): qualquer outra cor (geralmente branco) – Arduino UNO: A4, Arduino Mega: 20;

As saídas do conversor são do tipo latch. Assim não há rebote quando você escreve outro valor na interface. Porém é preciso tomar o cuidado de manter um registro em memória de que saídas estão ligadas, para evitar desligá-las acidentalmente ao ligar outro relê. Mas não é nada que um uso simples de operações bitwise como “AND”, “OR” e “XOR” não resolva.

Falando assim parece difícil, mas na verdade é bem fácil quando as rotinas estão prontas. Você consegue ligar um relê com um comando simples do tipo “LigarRele(7)” sem perturbar nenhuma das outras saídas. Exemplo a seguir:

//aqui você coloca o endereço que escrevi na interface
#define ADDRESS 0x23

//Nesta variavel ficará a representação em memória do estado das saídas
//Depois de manipular as saídas na variável jogamos a variável para a interface.
//Assim é evitada a modificação do estado das saídas erradas
byte Saidas = 0;

#include <Wire.h>

void setup()
{
Wire.begin();
//Por precaução, mas não é realmente necessário.
DesligaTudo();
}

void loop()
{

//Testa cada um dos relês, desligando os outros
for (int i=1;i<9;i++){
LigarReleUnico(i);
delay(200);
}
DesligaTudo();
delay(200);

//agora no caminho inverso
for (int i=8;i>0;i--){
LigarReleUnico(i);
delay(200);
}

DesligaTudo();
delay(200);

//Todos os relês serão ligados em sequencia até ficarem todos ligados ...
for (int i=1;i<9;i++){
LigarRele(i);
delay(500);
}

//... e serão desligados na mesma ordem
for (int i=1;i<9;i++){
DesligarRele(i);
delay(500);
}

}

void DesligaTudo()
{
Saidas=0;
sendI2Cneg(Saidas);
}

byte BitPosToDec(byte BitPos)
//Para entender esta função você precisa entender numeração binária
//e o funcionamento do operador SHIFT (<< e >>)
{
int bt=1; //isso "liga" o bit menos significativo do byte
bt = bt << BitPos-1;//move o bit ligado para a esquerda
return(bt);
}

void LigarRele(byte rele)
{
//Esta função liga um relê sem perturbar o estado dos outros
byte x=BitPosToDec(rele);
Saidas = Saidas | x;
sendI2Cneg(Saidas);
}

void DesligarRele(byte rele)
{ //Esta função desliga um relê sem perturbar o estado dos outros
byte x=BitPosToDec(rele);
 // Saidas = Saidas ^ x;
 Saidas = Saidas &(~x); //corrigido em 04/07/2017
sendI2Cneg(Saidas);
}

void LigarReleUnico(byte rele)
{
//Esta função vai desligar qualquer outro relê que já esteja ligado
sendI2Cneg(BitPosToDec(rele));
}

void sendI2Cneg(byte b)
/*Seria mais elegante chamar esta função de "AtualizarSaidas",
mas seria preciso fazer outras modificações que tornariam
o uso mais chato. Preferi deixar assim.
O "neg" vem do fato de que o módulo de relês opera
com lógica negativa e por isso todos os bits precisam ser invertidos
ao enviar. Uma única operação XOR se encarrega disso */
{
Wire.beginTransmission(ADDRESS);

//compatibilizando com o Arduino 1.x
#if (ARDUINO >= 100)
Wire.write(b ^ 255); // XOR
#else
Wire.send(b ^ 255); // XOR
#endif
Wire.endTransmission();

}

Forma alternativa da função BitPosToDec, que pode ser mais fácil de entender
byte BitPosToDec(byte BitPos)
{
switch (BitPos) {
case 1:
return(1);
break;
case 2:
return(2);
break;
case 3:
return(4);
break;
case 4:
return(8);
break;
case 5:
return(16);
break;
case 6:
return(32);
break;
case 7:
return(64);
break;
case 8:
return(128);
break;
}
}