Home
› Tag Archives › Controle de Cargas
Módulo de relês 8 canais I2C
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; } }
Módulo de relês
O consumo de cada relê, de acordo com o datasheet, é de 71mA. Assim, o módulo de oito canais alcança 568mA com todos os relês ligados. Se você ligar apenas um de cada vez, pode operar o módulo sem problemas usando apenas a alimentação do arduino conectado a uma porta USB. Mas estranhos problemas podem acontecer se você tentar ligar vários relês ao mesmo tempo sem providenciar uma fonte adequada. Os problemas variam caso a caso, porque algumas portas USB são capazes de fornecer mais que 500mA e depende também do resto do consumo de seu projeto, mas o sinal mais comum de que você excedeu a capacidade de corrente é não ouvir mais os relês fecharem, ou ouvir apenas um som débil.
De uma forma ou de outra, mesmo que o consumo esteja dentro da capacidade do Arduino, é recomendável separar as fontes, porque o acionamento das bobinas provoca uma perturbação na alimentação que pode afetar de múltiplas maneiras o seu projeto.
Cada módulo de relês tem um header de três pinos para alimentação. A posição do header e do jumper nele depende do módulo, mas sempre são claramente rotulados:
- Módulo de 8 canais: header do lado direito da placa. Posição correta do jumper: para a direita;
- Módulo de 2 canais: header do lado esquerdo da placa. Posição correta do jumper: para a esquerda;
O jumper deve ser retirado para usar alimentação externa, mas nunca coloque na outra posição, pois isso deixa a alimentação (VCC e GND) em curto.
- Sem jumper: Alimentação para os relês (5V) deve ser conectada a GND e JD-VCC. Ou você pode deixar assim para testar o seu programa sem acionar as cargas. Os LEDs acenderão, mas os relês permanecerão desligados;
- Jumper entre JD-VCC e VCC: Relês alimentados pelo pino VCC do cabo principal (default);
- Jumper entre GND e VCC: nunca faça isso!
A placa opera por sinal negativo em cada uma das entradas IN. Embora isso possa parecer estranho ou até ilógico para alguns, é muito comum em aplicações industriais. Os sensores de proximidade refletivos e indutivos que vendo, por exemplo, são todos com saída negativa. Esses sensores são chamados de “NPN” no jargão da indústria local.
Este é o esquema aproximado de cada seção dos módulos:
Como o sinal de ativação é negativo (LOW), cuidados especiais precisam ser tomados no setup e utilização. Exemplo de código:
int Relay = 3; //relê ligado ao pino 3
void setup()
{
/*É necessário que seja feito nesta ordem, ou o rele vai dar
um "rebote" ao energizar e a cada reset do arduino*/
digitalWrite(Relay, HIGH); //Configura o default do pino como HIGH
pinMode(Relay, OUTPUT); //Configura o pino como saída
}
void loop()
{
digitalWrite(Relay, LOW); //Liga o relê
delay(2000);
digitalWrite(Relay, HIGH); //Desliga o relê
delay(2000);
}
Problemas comuns
Um ou mais relês não fazem barulho ou fazem um barulho muito mais baixo que o normal ao ligar
Verifique a fonte de alimentação. Ela não está fornecendo corrente suficiente.
O relê só liga quando eu mando desligar e vice-versa
O módulo opera com lógica negativa. Volte, releia o que foi explicado e estude o sketch de teste.
O arduino reseta quando mando ligar vários relês de uma vez, mesmo sem carga
Os relês já ligados desligam quando mando ligar vários relês de uma vez, mesmo sem carga
Você provavelmente está usando a mesma fonte que alimenta o Arduino para alimentar os relês e esta não aguenta o surto repentino de corrente. Alimente o módulo com uma fonte separada.
O arduino reseta quando mando ligar um relê com carga
Os relês já ligados desligam quando mando ligar um relê com carga
Em condições normais isso só ocorre se você está ligando uma carga que gera muito EMI, como um contactor. Você precisa providenciar filtros de EMI para sua carga. Esses filtros geralmente são compostos de um único capacitor ou de um conjunto resistor + capacitor em série (também chamado de filtro “snubber”).
Em anexo, cópia do datasheet do relê
Comentários