ATENÇÃO: este projeto utiliza conexão direta à rede elétrica, e não fazer as conexões de forma adequada causa riscos de CHOQUE ELÉTRICO e INCÊNDIO. Só execute este projeto caso você já tenha experiência prévia com instalações elétricas.
Olá garagista no tutorial de hoje mostraremos como utilizar o Dimmer Shield para controlar a luminosidade de uma lâmpada incandescente pelo monitor serial Arduíno e por tac switchs presentes na placa através do Arduíno UNO Rev.3( Lembrando que a carga máxima é de até 4 A) .
Material utilizados
1x Plug de Tomada
1x Lâmpada
1x Metro de cabo AC
1. Dimmer Shield
Figura 1- Dimmer Shield
Características:
O Dimmer Shield é um shield para Arduíno que pode acionar de forma proporcional cargas como lâmpadas e motores, ou seja, você pode variar a intensidade do brilho de uma lâmpada incandescente, velocidade de um ventilador de mesa e controlar dispositivos que operam diretamente com 110V ou 220V com no máximo 4 A.
VAC: 110/220VAC 4 A
LOAD: Lâmpada Incandescente, Motor de ventilador de mesa e etc.
Pinos Utilizados:
D2 - Interrupção (Passagem por Zero)
D3 - Chaveamento do Triac
D4 e D5 - Chaves tácteis para uso geral
2. Dimmer
Dimmers (controles de brilho) e Controles de potência nada mais são do que circuitos que, intercalados com cargas na rede de energia elétrica, permitem controlar a sua potência.
Figura 2 - Esquema de ligação de um Dimmer
Ligados em série com lâmpadas incandescentes, eles permitem controlar seu brilho. Ligados em série com aparelhos que usam motores universais, eles possibilitam o controle da velocidade e em série com elementos de aquecimento a sua temperatura. Infelizmente, esses controles só podem ser usados com cargas resistivas (elementos de aquecimento e lâmpadas) ou formadas por um único enrolamento indutivo (motores universais e transformadores). Nunca devemos usar esses controles com lâmpadas eletrônicas, fluorescentes ou equipamentos eletrônicos em geral, pois eles podem causar a sua queima.O TRIAC é o elemento principal capaz de conduzir a corrente principal da carga. O controle da potência é feito, variando-se o ponto de disparo do triac em cada semiciclo da alimentação de corrente alternada.
Figrura 3 - Passagem pelo ponto zero
Figura 1- Ângulos de disparo
Com uma constante de tempo baixa o TRIAC dispara no início do semiciclo e a potência aplicada à carga é maior. Com uma constante de tempo alta , o disparo ocorre no final do semiciclo e apenas uma pequena parte da potência disponível é aplicada à carga.
Entre os dois extremos o controle pode ser ajustado para aplicar à carga qualquer potência entre 0 e aproximadamente 95% da potência máxima.
3. Sketch
//Desenvolvido por Marco Silva
//Email: Marco.silva@labdegaragem.com
//Lab de Garagem
int AC_LOAD = 3;// Dará o pulso no Triac pin
int dimming = 125;// Dimming level (0-128) 0 = ON, 128 = OFF
unsigned long time;//Contará o tempo
unsigned long timeout;//Estouro
int brilho[3];//Recebe os valores da serial
int i=0;//Quantidade de caracteres recebida pela serial
int flag=0;//Indica que foi recebida informação pela serial
char temp;//Armazena dados recebidos pela serial
int x,y;//Variaveis auxiliares
void setup()
{
Serial.begin(9600);//Inicia a serial com baud rate
pinMode(AC_LOAD, OUTPUT);// Disparo do Triac pino 3
attachInterrupt(0, zero_crosss_int, RISING);// Interrupção detecta a passagem por 0, quando passa de nível baixo para auto
pinMode(4, INPUT);// Configura o pino 4 como entrada
pinMode(5, INPUT);// Configura o pino 5 como entrada
}
void zero_crosss_int() // Função que detecta a passagem por 0
{
// Calculo do ângulo de disparo :: 60Hz-> 8.33ms (1/2 Cycle)
// (8333us - 8.33us) / 128 = 65 (Approx)
int dimtime = (65*dimming); // 65 equivale a 1 de 128
delayMicroseconds(dimtime); // Off cycle
digitalWrite(AC_LOAD, HIGH); // disparando o Triac
delayMicroseconds(8.33); // Aguarda o tempo de disparo
digitalWrite(AC_LOAD, LOW); // finaliza o pulso do Triac
}
void loop()
{
//------------------------------------------------------------------------------------------
// Retorna o tempo em milisegundos desde que o Arduíno começou a rodar,
time = millis()%2;//Divide por 2 e salva o resto
if(time==1||time==0)//Compara se o resto é igual a 0 ou 1 e sempre vai ser
{
timeout++;// Cronômetro
if (timeout>500)// Compara se houve estouro do tempo
{
i=0;// Zera o quantidades de caracteres recebidos
flag=0;// Zera o aviso de que foi recebido algum dado na serial
}
}
//-------------------------------------------------------------------------------------------
//Aumenta a intensidade
if(digitalRead(4)==1 && dimming >10)// Compara se o botão foi pressionado e se o dimming é maior que 10 seu limite máximo
{
dimming= dimming -5;// Aumenta a intensidade de 5 em 5
y=dimming/1.25;//Converte em %
y=(y-100)*(-1);//O dimming é inversamente proporcional à porcentagem
Serial.print(y);
Serial.println("%");
Serial.print("Resolucao: ");
Serial.println(dimming);
delay(100);// Aguarda um tempo até o próximo acionamento
}
//Diminui a intensidade
if(digitalRead(5)==1&& dimming<125)
{
dimming= dimming +5;
y=dimming/1.25;
y=(y-100)*(-1);
Serial.print(y);
Serial.println("%");
Serial.print("Resolucao: ");
Serial.println(dimming);
delay(100);
}
//--------------------------------------------------------------------------------------------
if (Serial.available()>0)// Verifica se houve recepção
{
flag=1;//Sinaliza que houve recepção
timeout=0;// Zera o o tempo de reset
//------------------------------------------------------------------------------------------
temp = Serial.read();// Armazena o que foi recebido pela serial
brilho[i]=temp-48;// Decrementa 48 na tabela ascii para converter de decimal para char
i++;// Contabiliza um recebimento
}
//---------------------------------------------------------------------------
if (timeout>200&&flag==1)// Compara se houve estouro do timeout(se ficou um tempo sem recepção) e se houve recepção
{
flag=0;// Sera aviso de recepção
// Verifica a quantidade de informação recebida
switch(i)
{
case 1:
x=brilho[0];//Unidade
break;
case 2:
x=brilho[0]*10 + brilho[1];//Dezena e unidade
break;
case 3:
x=brilho[0]*100 + brilho[1]*10 + brilho[2];//Centena, Dezena, Unidade
break;
}
// Envia para serial informações em % e resolução de disparo
Serial.print(x);
Serial.println("%");
delay(30);
if(x>100||x<0)// Proteção para se foi inserido um valor mair que 100%
{
Serial.println("Excedeu o limite");
}
else// Se estiver tudo OK
{
x=100-x;// Inversamente proporcional a %
dimming=x*1.25;// Resolução diminuida de 128 para 125 para garantir um tempo bom de resposta
if(dimming<8)
{
dimming=8;// O dimming será sempre maior que 10 para garantir um tempo bom de resposta
}
//Envia para a serial o valor da resolução
Serial.print("Resolucao: ");
Serial.println(dimming);
}
}
}
Referências:
http://www.labdegaragem.org/loja/48-ldg/dimmer-shield.html
http://labdegaragem.com/profiles/blogs/tutorial-dimmer-shield
http://www.newtoncbraga.com.br/index.php/como-funciona/619-dimmers-e-controles-de-potencia-art071
Comentar
Boa noite André
muito bom vai me ajudar muito. só tenho mas uma divida!
Consigo usar Dimmer shield junto com a IRemote pois para enviar comandos IRemote uso pino 3
e para disparar seu triac usa o pino 3 também?
valeu e obrigado por tirar minhas duvidas.
meu projeto uso 1 Arduino uno, 1 Shield Ethernet, 2 ReleyBoard, 2 Sensores, Pino 3 IRemote.
queria implementar o dimmer.
Boa tarde Flávio Sérgio!
Pode utilizar o Ethernet Shield sim!
Estou preparando um tutorial para controlar a luminosidade da lâmpada com Dimmer Shield através do Ethernet Shield e do módulo ESP8266 (WiFi)!
Só falta melhorar o código do aplicativo para Android! Depois posto um tutorial e um vídeo!
Segue a imagem do programa em desenvolvimento para Android:
Att.
André Kuhn.
Boa tarde, posso usar o Dimmer Shield junto com shield ethernet arduino uno valeu.
Boa tarde Caio Cesar!
Acredito que o erro é por não zerar a variável "valor_recebido_RF" (código receptor) e "Valor_CharMsg"(código emissor), ou seja, ficando dessa forma no código do receptor: "valor_recebido_RF = 0;", e do emissor: "itoa(0, Valor_CharMsg, 10);".
No código explicitei a alteração dessa forma: "//----------------------------------- Alteração que fiz"
Segue o código onde fiz uma pequena alteração do que você fez.
//----------------------------------------------------------------------------------------------------------
//Código do Emissor:
#include <VirtualWire.h>
//Define pinos Led e Botao
const int ledPin = 13;
const int pino_botao1 = A0;
const int pino_botao2 = A1;
int valor_botao1;
int valor_botao2;
char Valor_CharMsg[4];
//Armazena estado led = ligar/desligar
int estado1 = 0;
int estado2 = 0;
void setup()
{
Serial.begin(9600);
pinMode(ledPin,OUTPUT);
pinMode(pino_botao1,INPUT);
pinMode(pino_botao2,INPUT);
//Pino ligado ao pino DATA do transmissor RF
vw_set_tx_pin(4);
//Velocidade de comunicacao (bits por segundo)
vw_setup(1200);
Serial.println("Trasmissao modulo RF ‐ Acione o botao...");
}
void loop()
{
//Verifica o estado do push‐button
valor_botao1 = digitalRead(pino_botao1);
valor_botao2 = digitalRead(pino_botao2);
//itoa(valor_botao,Valor_CharMsg,10);
//Caso o botao seja pressionado, envia dados
if (valor_botao1 == 0)
{
//Altera o estado do led
estado1 = 8;
//Converte valor para envio
itoa(estado1,Valor_CharMsg,10);
//Liga o led da porta 13 para indicar envio dos dados
digitalWrite(13, true);
//Envio dos dados
vw_send((uint8_t *)Valor_CharMsg, strlen(Valor_CharMsg));
//Aguarda envio dos dados
vw_wait_tx();
//Desliga o led da porta 13 ao final da transmissao
digitalWrite(13, false);
Serial.print("Valor enviado: ");
Serial.println(Valor_CharMsg);
delay(500);
}
if (valor_botao2 == 0)
{
//Altera o estado do led
estado2 = 9;
//Converte valor para envio
itoa(estado2,Valor_CharMsg,10);
//Liga o led da porta 13 para indicar envio dos dados
digitalWrite(13, true);
//Envio dos dados
vw_send((uint8_t *)Valor_CharMsg, strlen(Valor_CharMsg));
//Aguarda envio dos dados
vw_wait_tx();
//Desliga o led da porta 13 ao final da transmissao
digitalWrite(13, false);
Serial.print("Valor enviado: ");
Serial.println(Valor_CharMsg);
delay(500);
}
//------------------------------------------------ Alteração que fiz.
//Converte valor da variável Valor_CharMsg para zero
itoa(0, Valor_CharMsg, 10);
//------------------------------------------------ Alteração que fiz.
}
//----------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------
//Código Receptor:
#include <VirtualWire.h>
//------------------------------------------------------------------------
int valor_recebido_RF; // original int
char recebido_RF_char[4];
char Valor_CharMsg[4];
//------------------------------------------------------------------------
//------------------------------------------------------------------------
int AC_LOAD = 3;// Dará o pulso no Triac pin
int dimming = 0;// Dimming level (0-100) 0 = ON, 100 = OFF
int brilho[3];//Recebe os valores da serial
int i=0;//Quantidade de caracteres recebida pela serial
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void setup()
{
Serial.begin(9600);
//pinMode(ledPin, OUTPUT);
//Pino ligado ao pino DATA do receptor RF
vw_set_rx_pin(7);
//Velocidade de comunicacao (bits por segundo)
vw_setup(1200);
//Inicia a recepcao
vw_rx_start();
Serial.println("Recepcao modulo RF - Aguardando...");
pinMode(AC_LOAD, OUTPUT);// Disparo do Triac pino 3
attachInterrupt(0, zero_crosss_int, RISING);// Interrupção detecta a passagem por 0, quando passa de nível baixo para auto
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
// Função que detecta a passagem por 0
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void loop()
{
//-------------------------------------------------------------------------------------------
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
for (i = 0; i < buflen; i++)
{
//Armazena os caracteres recebidos
recebido_RF_char[i] = char(buf[i]);
}
recebido_RF_char[buflen] = '\0';
//Serial.println("Aguardando valor");
//Converte o valor recebido para inteiro
valor_recebido_RF = atoi(recebido_RF_char);
//Serial.print("Recebido: ");
//Serial.print(valor_recebido_RF);
// realiza as acoes conforme desejado
}
//Aumenta a intensidade
if(valor_recebido_RF == 8 && dimming < 100)// Compara se o botão foi pressionado e se o dimming é maior que 10 seu limite máximo
{
dimming += 10; //Faz a soma do power anterior com 10 (incremento de 10)
//Serial.println("Resolucao: ");
//Serial.print(dimming);
//Serial.println("%");
delay(200);// Aguarda um tempo até o próximo acionamento
//------------------------------------------------ Alteração que fiz
valor_recebido_RF =0;
//------------------------------------------------ Alteração que fiz
}
//Serial.print("Hue");
//-------------------------------------------------------------------------------------------
//Diminui a intensidade
if(valor_recebido_RF == 9 && dimming > 0)
{
dimming -= 10; //Faz a soma do power anterior com 10 (incremento de 10)
//Serial.println("Resolucao: ");
//Serial.print(dimming);
//Serial.println("%");
delay(200);// Aguarda um tempo até o próximo acionamento
//------------------------------------------------ Alteração que fiz
valor_recebido_RF =0;
//------------------------------------------------ Alteração que fiz
}
}
//----------------------------------------------------------------------------------------------------------------------
//Controle do Dimmer Shield
void zero_crosss_int()
{
// Calculo do ângulo de disparo :: 60Hz-> 8.33ms (1/2 Cycle)
// (8333us - 8.33us) / 100 = 83 (Approx), o dimming vai variar de 0 a 100
int dimtime = (83*(100-dimming)); //O powertime é o tempo que o TRIAC permanescerá desligado quando é detectado o ponto 0 da senóide
//e varia de 0 a 8300 microsegundos
//Se o powertime for menor ou igual a 300 microsegundos, dar o comando de ligar a lâmpada (carga) - potência total fornecida
if(dimtime <= 300)
{
//Liga o pulso do sinal ao TRIAC para que ele passe a conduzir, coloca o pino digital "load" em nível alto
digitalWrite(AC_LOAD, HIGH);
}
//Se o powertime for menor ou igual a 8000 microsegundos, dar o comando de desligar a lâmpada (carga) - potência zero fornecida
else if(dimtime >= 8000)
{
//Desliga o pulso do sinal ao TRIAC para que ele não conduza, coloca o pino digital "load" em nível baixo
digitalWrite(AC_LOAD, LOW);
}
//Se o powertime estiver entre 300 microsegundos a 8000 microsegundos
else if((dimtime > 300) && (dimtime < 8000))
{
//Mantém o circuito desligado por powertime microssegundos (espera powertime microssegundos)
delayMicroseconds(dimtime);
//Envia sinal ao TRIAC para que ele passe a conduzir, coloca o pino digital "load" em nível alto
digitalWrite(AC_LOAD, HIGH);
//Espera 8,33 microssegundos para que o TRIAC perceba o pulso
delayMicroseconds(8.33);
//Desliga o pulso do TRIAC, coloca o pino digital "load" em nível baixo
digitalWrite(AC_LOAD, LOW);
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------
Atenciosamente.
André Kuhn.
Boa noite,
Estou tentando fazer o controle do dimmer shield através de comunicação sem fio, porém, parece estar havendo algum conflito de processamento, alguém poderia me ajudar?
Código do Emissor:
#include <VirtualWire.h>
//Define pinos Led e Botao
const int ledPin = 13;
const int pino_botao1 = A0;
const int pino_botao2 = A1;
int valor_botao1;
int valor_botao2;
char Valor_CharMsg[4];
//Armazena estado led = ligar/desligar
int estado1 = 0;
int estado2 = 0;
void setup()
{
Serial.begin(9600);
pinMode(ledPin,OUTPUT);
pinMode(pino_botao1,INPUT);
pinMode(pino_botao2,INPUT);
//Pino ligado ao pino DATA do transmissor RF
vw_set_tx_pin(4);
//Velocidade de comunicacao (bits por segundo)
vw_setup(1200);
Serial.println("Trasmissao modulo RF ‐ Acione o botao...");
}
void loop()
{
//Verifica o estado do push‐button
valor_botao1 = digitalRead(pino_botao1);
valor_botao2 = digitalRead(pino_botao2);
//itoa(valor_botao,Valor_CharMsg,10);
//Caso o botao seja pressionado, envia dados
if (valor_botao1 == 0)
{
//Altera o estado do led
estado1 = 8;
//Converte valor para envio
itoa(estado1,Valor_CharMsg,10);
//Liga o led da porta 13 para indicar envio dos dados
digitalWrite(13, true);
//Envio dos dados
vw_send((uint8_t *)Valor_CharMsg, strlen(Valor_CharMsg));
//Aguarda envio dos dados
vw_wait_tx();
//Desliga o led da porta 13 ao final da transmissao
digitalWrite(13, false);
Serial.print("Valor enviado: ");
Serial.println(Valor_CharMsg);
delay(500);
}
if (valor_botao2 == 0)
{
//Altera o estado do led
estado2 = 9;
//Converte valor para envio
itoa(estado2,Valor_CharMsg,10);
//Liga o led da porta 13 para indicar envio dos dados
digitalWrite(13, true);
//Envio dos dados
vw_send((uint8_t *)Valor_CharMsg, strlen(Valor_CharMsg));
//Aguarda envio dos dados
vw_wait_tx();
//Desliga o led da porta 13 ao final da transmissao
digitalWrite(13, false);
Serial.print("Valor enviado: ");
Serial.println(Valor_CharMsg);
delay(500);
}
}
Código Recepto:
#include <VirtualWire.h>
//------------------------------------------------------------------------
int valor_recebido_RF; // original int
char recebido_RF_char[4];
char Valor_CharMsg[4];
//------------------------------------------------------------------------
//------------------------------------------------------------------------
int AC_LOAD = 3;// Dará o pulso no Triac pin
int dimming = 0;// Dimming level (0-100) 0 = ON, 100 = OFF
int brilho[3];//Recebe os valores da serial
int i=0;//Quantidade de caracteres recebida pela serial
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void setup()
{
Serial.begin(9600);
//pinMode(ledPin, OUTPUT);
//Pino ligado ao pino DATA do receptor RF
vw_set_rx_pin(7);
//Velocidade de comunicacao (bits por segundo)
vw_setup(1200);
//Inicia a recepcao
vw_rx_start();
Serial.println("Recepcao modulo RF - Aguardando...");
pinMode(AC_LOAD, OUTPUT);// Disparo do Triac pino 3
attachInterrupt(0, zero_crosss_int, RISING);// Interrupção detecta a passagem por 0, quando passa de nível baixo para auto
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
// Função que detecta a passagem por 0
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void loop()
{
//-------------------------------------------------------------------------------------------
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
for (i = 0; i < buflen; i++)
{
//Armazena os caracteres recebidos
recebido_RF_char[i] = char(buf[i]);
}
recebido_RF_char[buflen] = '\0';
//Serial.println("Aguardando valor");
//Converte o valor recebido para inteiro
valor_recebido_RF = atoi(recebido_RF_char);
//Serial.print("Recebido: ");
//Serial.print(valor_recebido_RF);
// realiza as acoes conforme desejado
}
//Aumenta a intensidade
if(valor_recebido_RF == 8 && dimming < 100)// Compara se o botão foi pressionado e se o dimming é maior que 10 seu limite máximo
{
dimming += 10; //Faz a soma do power anterior com 10 (incremento de 10)
//Serial.println("Resolucao: ");
//Serial.print(dimming);
//Serial.println("%");
delay(200);// Aguarda um tempo até o próximo acionamento
}
//Serial.print("Hue");
//-------------------------------------------------------------------------------------------
//Diminui a intensidade
if(valor_recebido_RF == 9 && dimming > 0)
{
dimming -= 10; //Faz a soma do power anterior com 10 (incremento de 10)
//Serial.println("Resolucao: ");
//Serial.print(dimming);
//Serial.println("%");
delay(200);// Aguarda um tempo até o próximo acionamento
//flag = 1;
//valor_recebido_RF =0;
}
}
void zero_crosss_int()
{
// Calculo do ângulo de disparo :: 60Hz-> 8.33ms (1/2 Cycle)
// (8333us - 8.33us) / 100 = 83 (Approx), o dimming vai variar de 0 a 100
int dimtime = (83*(100-dimming)); //O powertime é o tempo que o TRIAC permanescerá desligado quando é detectado o ponto 0 da senóide
//e varia de 0 a 8300 microsegundos
//Se o powertime for menor ou igual a 300 microsegundos, dar o comando de ligar a lâmpada (carga) - potência total fornecida
if(dimtime <= 300)
{
//Liga o pulso do sinal ao TRIAC para que ele passe a conduzir, coloca o pino digital "load" em nível alto
digitalWrite(AC_LOAD, HIGH);
}
//Se o powertime for menor ou igual a 8000 microsegundos, dar o comando de desligar a lâmpada (carga) - potência zero fornecida
else if(dimtime >= 8000)
{
//Desliga o pulso do sinal ao TRIAC para que ele não conduza, coloca o pino digital "load" em nível baixo
digitalWrite(AC_LOAD, LOW);
}
//Se o powertime estiver entre 300 microsegundos a 8000 microsegundos
else if((dimtime > 300) && (dimtime < 8000))
{
//Mantém o circuito desligado por powertime microssegundos (espera powertime microssegundos)
delayMicroseconds(dimtime);
//Envia sinal ao TRIAC para que ele passe a conduzir, coloca o pino digital "load" em nível alto
digitalWrite(AC_LOAD, HIGH);
//Espera 8,33 microssegundos para que o TRIAC perceba o pulso
delayMicroseconds(8.33);
//Desliga o pulso do TRIAC, coloca o pino digital "load" em nível baixo
digitalWrite(AC_LOAD, LOW);
}
}
Tenho uma protoboad com 2 botões conectados nas entradas analógicas A0 e A1 do meu arduino mega, quando aperto o botão A0, ele envia "8" para o arduino2 que ao reconhece-ló, deveria aumentar a luminosidade, a mesma analogia é válida para o botão A1 (envia "9" e o arduino2 reconhece e deveria diminuir a luminosidade).
Quando mando o comando da luminosidade pela primeira vez, tudo ocorre perfeitamente, porém, quando tento enviar outro comando (apertar pela segunda vez o botão), o arduino2 não consegue mais entrar na rotina de leitura de dados.
Alguém tem alguma ideia de solucionar esse problema?
Obrigado!!
Obrigado Robson Eufrasio!
Espero que dê tudo certo!
Abraço.
Bom dia Jordy Luiz!
Qual lâmpada está utilizando? Qual o código que utilizou? Tem que verificar como está a rede de energia! Verificar se o neutro está realmente em 0 volts. Em rede bifásica (duas fases na tomada), não funcionará corretamente.
Atenciosamente.
Bom dia!! Assim que eu carrego o código no Arduino a lâmpada começa a piscar. Quanto o controle da luminosidade ele funcionou corretamente. O único problema é que a lâmpada pisca mesmo em baixa luminosidade.
obg, vou testar e posto o resultado nos comentários
Bom dia Robson!
Desculpa a demora de responder!
Segue abaixo o código com algumas modificações que fiz!
Tem trecho do código que não entendi o que deseja fazer. Destaquei em comentário.
As modificações principais foi colocar a variável "dimming" variar de 0 a 100. Com isso, eliminei os cálculos matemáticos para converter em porcentagem. Melhorando o tempo no processamento, acredito que isso seja o problema do módulo RF 433 MHz não receber o dados corretamente.
Sugiro que faça os códigos e os testes, passo a passo, por exemplo, tentar controlar a lâmpada utilizando somente o módulo RF 433 Mhz. Feito teste e funcionando normalmente, implementa a comunicação serial.
E assim por diante.
Segue o código:
#include <VirtualWire.h>
//------------------------------------------------------------------------
//Define pino led
int ledPin = 13; // original 5
int valor_recebido_RF; // original int
char recebido_RF_char[4];
char Valor_CharMsg[4];
//------------------------------------------------------------------------
//------------------------------------------------------------------------
int AC_LOAD = 3;// Dará o pulso no Triac pin
int dimming = 50;// Dimming level (0-100) 0 = ON, 100 = OFF
unsigned long time;//Contará o tempo
unsigned long timeout;//Estouro
int brilho[3];//Recebe os valores da serial
int i=0;//Quantidade de caracteres recebida pela serial
int flag=0;//Indica que foi recebida informação pela serial
char temp;//Armazena dados recebidos pela serial
int x,y;//Variaveis auxiliares
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void setup()
{
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
//Pino ligado ao pino DATA do receptor RF
vw_set_rx_pin(7);
//Velocidade de comunicacao (bits por segundo)
vw_setup(1200);
//Inicia a recepcao
vw_rx_start();
Serial.println("Recepcao modulo RF - Aguardando...");
pinMode(AC_LOAD, OUTPUT);// Disparo do Triac pino 3
attachInterrupt(0, zero_crosss_int, RISING);// Interrupção detecta a passagem por 0, quando passa de nível baixo para auto
pinMode(4, INPUT);// Configura o pino 4 como entrada
pinMode(5, INPUT);// Configura o pino 5 como entrada
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
// Função que detecta a passagem por 0
void zero_crosss_int()
{
// Calculo do ângulo de disparo :: 60Hz-> 8.33ms (1/2 Cycle)
// (8333us - 8.33us) / 100 = 83 (Approx), o dimming vai variar de 0 a 100
int dimtime = (83*(100-dimming)); //O powertime é o tempo que o TRIAC permanescerá desligado quando é detectado o ponto 0 da senóide
//e varia de 0 a 8300 microsegundos
//Se o powertime for menor ou igual a 300 microsegundos, dar o comando de ligar a lâmpada (carga) - potência total fornecida
if(dimtime <= 300)
{
//Liga o pulso do sinal ao TRIAC para que ele passe a conduzir, coloca o pino digital "load" em nível alto
digitalWrite(AC_LOAD, HIGH);
}
//Se o powertime for menor ou igual a 8000 microsegundos, dar o comando de desligar a lâmpada (carga) - potência zero fornecida
else if(dimtime >= 8000)
{
//Desliga o pulso do sinal ao TRIAC para que ele não conduza, coloca o pino digital "load" em nível baixo
digitalWrite(AC_LOAD, LOW);
}
//Se o powertime estiver entre 300 microsegundos a 8000 microsegundos
else if((dimtime > 300) && (dimtime < 8000))
{
//Mantém o circuito desligado por powertime microssegundos (espera powertime microssegundos)
delayMicroseconds(dimtime);
//Envia sinal ao TRIAC para que ele passe a conduzir, coloca o pino digital "load" em nível alto
digitalWrite(AC_LOAD, HIGH);
//Espera 8,33 microssegundos para que o TRIAC perceba o pulso
delayMicroseconds(8.33);
//Desliga o pulso do TRIAC, coloca o pino digital "load" em nível baixo
digitalWrite(AC_LOAD, LOW);
}
}
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void loop()
{
//-------------------------------------------------------------------------------------------
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
for (i = 0; i < buflen; i++)
{
//Armazena os caracteres recebidos
recebido_RF_char[i] = char(buf[i]);
}
recebido_RF_char[buflen] = '\0';
//Converte o valor recebido para inteiro
valor_recebido_RF = atoi(recebido_RF_char);
//Mostra no serial monitor o valor recebido
Serial.print("Recebido: ");
Serial.print(valor_recebido_RF);
// realiza as acoes conforme desejado
if (valor_recebido_RF == 1)
{
digitalWrite(ledPin, HIGH);
Serial.println(" - Led aceso !");
}
else if (valor_recebido_RF == 0)
{
digitalWrite(ledPin, LOW);
Serial.println(" - Led apagado !");
}
// recebe o comando que se for igual a 50 atribui a variavel temp
//o valor desejado para dimerizar a lampada atraves do Dimmer Shield
else if (valor_recebido_RF == 50)
{
dimming = 50; // dimeriza em 50%
Serial.println(" - Dimmer em 50% !");
}
// recebe o comando que se for igual a 100 atribui a variavel temp
//o valor desejado para dimerizar a lampada atraves do Dimmer Shield
else if (valor_recebido_RF == 100)
{
dimming = 100; // dimeriza em 100%
Serial.println(" - Dimmer em 100% !");
}
}
//-------------------------------------------------------------------------------------------
//Não entendi essa parte do código**********************************************************
//------------------------------------------------------------------------------------------
// Retorna o tempo em milisegundos desde que o Arduíno começou a rodar,
time = millis()%2;//Divide por 2 e salva o resto
if(time==1||time==0)//Compara se o resto é igual a 0 ou 1 e sempre vai ser
{
timeout++;// Cronômetro
// Compara se houve estouro do tempo
if (timeout > 500)
{
i=0;// Zera o quantidades de caracteres recebidos
flag=0;// Zera o aviso de que foi recebido algum dado na serial
}
}
//-------------------------------------------------------------------------------------------
//Não entendi essa parte do código***********************************************************
//-------------------------------------------------------------------------------------------
//Aumenta a intensidade
if(digitalRead(4) == HIGH)// Compara se o botão foi pressionado e se o dimming é maior que 10 seu limite máximo
{
//Se power (porcentagem) for menor que 100, executa
if(dimming < 100)
{
dimming += 10; //Faz a soma do power anterior com 10 (incremento de 10)
}
Serial.println("Resolucao: ");
Serial.print(dimming);
Serial.println("%");
delay(100);// Aguarda um tempo até o próximo acionamento
}
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
//Diminui a intensidade
if(digitalRead(5) == HIGH)
{
//Se power (porcentagem) for menor que 100, executa
if(dimming > 0)
{
dimming -= 10; //Faz a soma do power anterior com 10 (incremento de 10)
}
Serial.println("Resolucao: ");
Serial.print(dimming);
Serial.println("%");
delay(100);// Aguarda um tempo até o próximo acionamento
}
//-------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
if (Serial.available() > 0)// Verifica se houve recepção
{
flag=1;//Sinaliza que houve recepção
timeout=0;// Zera o o tempo de reset
//------------------------------------------------------------------------------------------
temp = Serial.read();// Armazena o que foi recebido pela serial
brilho[i] = temp - 48;// Decrementa 48 na tabela ascii para converter de decimal para char
i++;// Contabiliza um recebimento
}
//-------------------------------------------------------------------------------------------
//Não entendi essa parte do código***********************************************************
//---------------------------------------------------------------------------
if (timeout > 200 && flag == 1)// Compara se houve estouro do timeout(se ficou um tempo sem recepção) e se houve recepção
{
flag=0;// Sera aviso de recepção
// Verifica a quantidade de informação recebida
switch(i)
{
case 1:
x = brilho[0];//Unidade
break;
case 2:
x=brilho[0] * 10 + brilho[1];//Dezena e unidade
break;
case 3:
x=brilho[0] * 100 + brilho[1] * 10 + brilho[2];//Centena, Dezena, Unidade
break;
}
// Envia para serial informações em % e resolução de disparo
Serial.print(x);
Serial.println("%");
delay(30);
if(x > 100 || x < 0)// Proteção para se foi inserido um valor mair que 100%
{
Serial.println("Excedeu o limite");
}
else// Se estiver tudo OK
{
//Fiz modificações aqui**********************
dimming = x;
Serial.print("Resolucao: ");
Serial.println(dimming);
}
}
//---------------------------------------------------------------------------
//Não entendi essa parte do código***********************************************************
}
Att.
André Kuhn.
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por
Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!
Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)