Tutorial: Controlando a luminosidade de uma lâmpada incandescente com Dimmer Shield


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 Dimmer Shield

1xArduíno UNO Rev.3

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://labdegaragem.com/profiles/blogs/tutorial-acionando-lampada-com-mini-relay-shield-e-interruptor-pa

http://www.newtoncbraga.com.br/index.php/como-funciona/619-dimmers-e-controles-de-potencia-art071

Exibições: 31782

Comentar

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)

Comentário de Robson Eufrasio Stirle em 14 julho 2015 às 3:24

Estou utilizando o RF 433 Mhz.

O circuito é esse que esta na imagem, ficou faltando o Dimmer Shield, que é o Dimmer que comprei aqui no site. O meu problema é o seguinte, tenho uma central com um Arduino Mega com um Ethernet Shield com um emissor RF 433 Mhz, que recebe informações através de um aplicativo android, e envia essas informações através dos RF 433 para os demais arduinos, para que eles possam acionar reles, acionar aparelhos como tv, ar condicionado entre outros.

Quando utilizo o arduino que possui o receptor RF 433 ele recebe as informações normalmente e executa os comandos enviados, como por exemplo, acionar uma lâmpada, ai quando coloco o dimmer shield na placa arduino também continua funcionando, mas quando ligo o dimmer shield na rede elétrica 110/220 V ai o receptor RF 433 não recebe nenhum dado, e assim não aciona nem os reles e nem controla a luminosidade desejada através do Dimmer Shield, já tentei de tudo, mas ate agora não tive sucesso.

Segue o código que estou utilizando no arduino com o rf 433 e o Dimmer Shield

#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 = 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);
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

}

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()
{
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 integer
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)
{
temp = 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)
{
temp = 100; // dimeriza em 100%
Serial.println(" - Dimmer em 100% !");

}


}

//------------------------------------------------------------------------------------------
// 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);
}

}
}

Comentário de André Araújo Kuhn Pereira em 14 julho 2015 às 2:26

Boa noite Robson Eufrasio Stirle!

Você está usando o módulo RFID ou RF 433 MHz?

É possível postar a foto do circuito com o arduino?

E também o código?

Att.

André Kuhn.

Comentário de André Araújo Kuhn Pereira em 14 julho 2015 às 2:07

Boa noite Lucas Murilo Guedes! Na utilização do LDR para controlar o Dimmer Shield, você terá que fazer uma programação que fique lendo a entrada analógica, e nesta entrada estará o circuito Medidor de Luminosidade. A Figura 1 mostra este circuito conectada na entrada analógica A0.

A leitura analógica irá variar de 0 a 1024, utilizando a função:

    analogRead(A0);

Declara uma variável do tipo inteira chamada luminosidade para armazenar o valor da entrada analógica.

    luminosidade = analogRead(A0);

Utilizando o código do meu primeiro tutorial, a variável inteira chamada "power" varia de 0 a 300. Quanto mais próximo de 0 a luz da lâmpada ficará mais fraca, e quanto mais próxima de 300 ficará mais forte a luminosidade.

Será necessário utilizar uma função chamada "map", para remapear o valor inteiro "luminosidade" (que varia de 0 a 1023) para valores de 0 a 300 (a variável "power").

    power = map(luminosidade, 0, 1023, 0, 300); 

E os códigos para controlar a luminosidade pelos botões, retire-os.

Qualquer dúvida poste aqui!

Espero que tenha ajudado.

Eu ainda não fiz teste utilizando um LDR e Dimmer Shield. Quando tiver tempo, eu faço e posto um tutorial.

Link do primeiro tutorial: http://labdegaragem.com/profiles/blogs/tutorial-dimmer-shield


Att.
André Kuhn.
Comentário de Robson Eufrasio Stirle em 11 julho 2015 às 15:00

como faço pra utilizar esse dimmer junto com RFID 433 ?

quando ligo o dimmer separado ele funciona, mas quando coloco o RFID ele nao emite nem recebe dados.

Comentário de Lucas Murilo Guedes em 27 junho 2015 às 17:16

Ola, como eu faria para adicionar um LDR para o controle dessa lampada junto com dimmer?

Comentário de André Araújo Kuhn Pereira em 15 junho 2015 às 22:04

Boa noite Rafael Schiavon!

 

Pelas pesquisas que fiz, mostra que é necessário colocar um resistor pull-up ou pull-down, sobre o sinal de saída do sensor. No Dimmer Shield, os botões utiliza resistores do tipo pull-down, ou seja, quando o botão é pressionado, o pino digital 4 ou 5, fica em nível alto.

Então, se colocar o sinal do sensor no pino digital 4 ou 5 (PORTA_DIGITAL_4 ou PORTA_DIGITAL_5), ele irá funcionar com o resistor pull-down. Não sendo necessário inserir o resistor. Então na programação do arduino, para verificar se o sensor PIR detectou presença, terá que utilizar o seguinte código.

            if(digitalRead(4) == HIGH);    ou        if(digitalRead(5) == HIGH);

A imagem retirada do site http://br-arduino.org/ mostra a utilização do sensor PIR em pull-down:

Imagem modificada

Lembrando que, caso o botão seja pressionado com o circuito PIR conectado, o arduino irá detectar "presença", ou seja, o pino 4 ou 5 ficará em nível alto.

Para mais detalhes segue os links:

 

Explicação dos resistores pull-down e pull-up

http://arduinomais.blogspot.com.br/2014/05/resistor-pull-up-e-pull-...

 

Segue o link mais adequado ao seu projeto, sobre a utilização do sensor PIR com o resistor pull-down http://br-arduino.org/2014/12/sensor-de-presenca-no-arduino-uma-pro...

 

Utilização do sensor PIR em pull-up

http://labdegaragem.com/profiles/blogs/tutorial-como-utilizar-o-sen...

 

Att.

André Kuhn.

Comentário de Rafael Schiavon Guido em 6 junho 2015 às 0:54

Prezados  tenho de entregar um projeto como um trabalho para a faculdade bem parecido com esse, porém preciso inserir um sensor PIR que acionará a lampada em rampa e vai desligar também em uma rampa de descida, minha dúvida é com base nesse projeto ai se alterando as entradas que nesse vem dos botões da placa pelos da leitura do sensor o sistema funcionaria?

Comentário de André Araújo Kuhn Pereira em 26 abril 2015 às 17:04

O mais conhecido módulo RTC é com o chip DS1307. Tem no site labdegaragem.org, segue o link: Relógio de Tempo Real - RTC (http://www.labdegaragem.org/loja/relogio-de-tempo-real-grove.html). Esse chip suporta comunicação I2C. A figura abaixo mostra a conexão do módulo com o arduino. 

As conexões são: sda do módulo, na entrada analógica 4 (A4); scl do módulo, na entrada analógica 5 (A5). A utilização deste chip é melhor porque utiliza apenas dois pinos (A4 e A5) do arduino.

Att.

André Kuhn.

Comentário de Raphael Louis Grangeon em 24 abril 2015 às 21:41

Olá Andre,

recomenda algum modulo RTC ?

Comentário de André Araújo Kuhn Pereira em 21 abril 2015 às 13:55

Raphael Louis, é possível fazer o seu projeto com o Dimmer Shield sim, mas sugiro utilizar um módulo RTC (Real Time Clock), ou seja, um relógio de tempo real. É necessário esse módulo porque o Arduino com Dimmer Shield, controla a intensidade da lâmpada utilizando o delay (atraso) do microcontrolador, o que comprometeria o objetivo do seu projeto. Com o módulo RTC, pode verificar a hora a qualquer momento e comparar o horário que quer, para controlar a potência dissipada da lâmpada. Desculpe a demora de responder, neste post não aparece a atualização no meu e-mail.

Att.

André Kuhn.

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço