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 Flavio Sergio Batista em 6 outubro 2015 às 19:04

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.

Comentário de André Araújo Kuhn Pereira em 6 outubro 2015 às 18:01

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.

Comentário de Flavio Sergio Batista em 6 outubro 2015 às 14:51

Boa tarde, posso usar o Dimmer Shield junto com shield ethernet arduino uno valeu.

Comentário de André Araújo Kuhn Pereira em 5 outubro 2015 às 13:24

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.

Comentário de Caio Cesar Venturini Augusto em 10 setembro 2015 às 23:41

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!!


Comentário de André Araújo Kuhn Pereira em 31 julho 2015 às 11:37

Obrigado Robson Eufrasio!

Espero que dê tudo certo!

Abraço.

Comentário de André Araújo Kuhn Pereira em 31 julho 2015 às 11:25

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.

Comentário de JORDY LUIZ CERMINARO SPACCA em 25 julho 2015 às 10:37

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.

Comentário de Robson Eufrasio Stirle em 20 julho 2015 às 12:53

obg, vou testar e posto o resultado nos comentários

Comentário de André Araújo Kuhn Pereira em 20 julho 2015 às 8:18

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.

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço