Mostrando postagens com marcador led. Mostrar todas as postagens
Mostrando postagens com marcador led. Mostrar todas as postagens

29 março 2016

Arduino com painel de Led RGB 8x8 e Anel de led RGB WS2812

Você já sabe como usar leds endereçáveis com o Arduino, certo ? Vimos isso no post Semárofo com Arduino e Led Endereçável WS2812B.

Vamos continuar esse assunto, mostrando como você pode ligar ao Arduino mais dois componentes: o Painel de Led RGB WS2812 e o Anel de Led RGB WS2812.

Neopixel led enderecavel WS2812


Ao contrário dos leds endereçáveis que vimos no post anterior, que precisavam ser conectados um a um, tanto o painel de led como o anel já tem todos os leds interligados, tornando mais fácil e rápida a adaptação ao seu projeto.

27 janeiro 2016

Semáforo com Arduino e Led Endereçável WS2812B RGB

Projetos de semáforo com Arduino são bastante comuns. A maioria usa leds convencionais para a montagem do projeto. Hoje eu vou mostrar um semáforo um pouco diferente, e que utiliza leds endereçáveis RGB WS2812B.

Semáforo com Arduino e Led Endereçável WS2812B


Mas o que são leds endereçáveis ?

08 janeiro 2015

Display OLED Arduino com controlador SSD1306

Você já deve ter ouvido falar em telas OLED. Elas são utilizadas principalmente em televisores, monitores de computador e telefones celulares, onde oferecem várias vantagens por serem mais finas, leves e flexíveis do que as tradicionais telas de LED, além de consumirem menos energia.

OLED Display Arduino SSD1306

Felizmente, no Arduino também podemos utilizar esse tipo de display. Antes de mostrar como fazer isso, vamos ver um pequeno resumo sobre a tecnologia OLED.

Como funciona a tecnologia OLED ?

OLED significa Organic Light-Emitting Diode, ou Diodo Emissor de Luz Orgânico. Consiste basicamente em uma camada de semicondutor orgânico, situado entre dois eletrodos, sendo que um deles geralmente é transparente.  Essa camada orgânica, ao ser estimulada por um campo eletromagnético, emite luz nas cores vermelho, verde e azul (o nosso conhecido RGB), que é a base de cores que os displays utilizam para gerar imagens.


Estrutura de uma tela OLED
Imagem: PCWorld


22 setembro 2014

Contador de visitantes usando led IR e fototransistor

O projeto do post de hoje foi usado no ano passado em um TCC, onde o aluno precisava criar um sistema que contasse o número de visitantes em uma sala, utilizando led infravermelho e fototransistor.

O sistema deveria contar o número de pessoas que entraram na sala, quantas saíram, calcular o número de pessoas na sala e, caso não houvesse ninguém, apagar a luz.

contador de visitantes ir fototransistor


Essas informações deveriam ser apresentadas em um display LCD 16x2, e com a utilização do Arduino a parte eletrônica ficou bem reduzida, facilitando a instalação do projeto em uma maquete.

No projeto, mostrado na foto acima, foram utilizados os seguintes componentes:

  • 1 led comum (para simular a luz da sala)
  • 2 leds IR 5mm
  • 2 fototransistores 5mm
  • 1 resistor de 220R para o led comum
  • 2 resistores de 220R para os leds IR
  • 2 resistores de 220R para o coletor do fototransistor
  • 2 resistores de 330R para o emissor do fototransistor
  • 1 display LCD 16x2 HD44780
  • 1 potenciômetro de 10 K

O esquema de ligação do display é o mesmo que eu utilizei na maioria dos projetos aqui no site (clique aqui para ver outros posts sobre display LCD aqui no Arduino e Cia). Na porta 7 ligamos o fototransistor que será responsável pela contagem de entrada da sala, e na porta 6 o responsável pela contagem de saída. O led que simula a luz da sala está ligado à porta 10 :


IR fototransistor


No circuito acima, cada fototransistor (em azul) tem a perna mais curta (o coletor) ligada ao positivo junto com um resistor de 220R, e a perna mais comprida (o emissor) ligada à porta do Arduino, com um resistor de 330R fazendo a função de pull-down. O potenciômetro ajusta o contraste do display.

O programa verifica o estado das portas 7 (sensor de entrada da sala) e 6 (sensor de saída da sala), que se encontram em nível alto enquanto estiverem recebendo iluminação dos leds IR (que estão sempre ligados). Quando a iluminação IR é interrompida por algum objeto, o estado da porta vai à nível baixo (0 / LOW), e o contador é então atualizado.

Na parte superior do display, mostramos a quantidade de pessoas na sala, e o total de visitantes. Na parte inferior do display, temos o contador de entrada e de saída, apenas para informação e acompanhamento.


  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
// Programa : Controle de visitantes
// Autor : Arduino e Cia

// Pino de ligacao do sensor IR de entrada
int pinoirent = 7;    
// Pino de ligacao do sensor IR de saida
int pinoirsaida = 6;  
// Variavel que registra o estado do sensor de entrada
int valorirent = 0;   
// Variavel que registra o estado do sensor de saida
int valorirsai = 0;   
// Variavel que registra a quantidade de visitantes que entraram
int content = 0;      
// Variavel que registra a quantidade de visitantes que sairam
int contsai = 0;      
// Variavel que registra a quantidade de pessoas na sala
int contsala = 0;     
// Variavel que registra a quantidade anterior de pessoas na sala
int contanterior = 0; 
// Pino de ligacao do led que representa a luz da sala
int pinoledsala = 10; 


// Configuracao do display LCD
#include <LiquidCrystal.h> 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 
 

void setup()
{
  Serial.begin(9600);            
  // Seta o pino do sensor de entrada como ENTRADA
  pinMode(pinoirent, INPUT);     
  // Seta o pino do sensor de saida como ENTRADA
  pinMode(pinoirsaida, INPUT);   
  // Seta o pino do Led indicador de presenca como SAIDA
  pinMode(pinoledsala, OUTPUT);  
  // Informacoes iniciais do display
  lcd.begin(16, 2);
  lcd.setCursor(0,0);            
  lcd.print("Sala:0 ");          
  lcd.setCursor(9,0);
  lcd.print("Tot: 0");
  lcd.setCursor(0,1);
  lcd.print("Ent: 0");
  lcd.setCursor(9,1);
  lcd.print("Sai: 0");
}

void loop()
{
  // Seta a variavel valorirent com o status do sensor de entrada
  valorirent = digitalRead(pinoirent);    
  // Seta a variavel valorirsai com o status do sensor de saida
  valorirsai = digitalRead(pinoirsaida);  

  // Mostra as informacoes dos sensores no serial monitor
  Serial.print("entrada : ");
  Serial.print(valorirent);
  Serial.print(" saida : ");
  Serial.println(valorirsai);

  // Verifica se o estado do sensor de entrada foi alterado
  if(valorirent!=1) 
  {
    // Incrementa o valor do contador de entrada em 1 unidade
    content=content+1; 
    // Verifica se a pessoa/objeto para em frente ao sensor
    while(digitalRead(pinoirent)!=1) 
      { 
        delay(100);  
        Serial.println("Sensor de entrada parado !");
      }
    // Atualiza no LCD o valor do contador de entrada
    lcd.setCursor(5,1); 
    lcd.print(content); 
    // Atualiza no LCD o valor total de visitantes
    lcd.setCursor(14,0); 
    lcd.print(content); 
  }

  // Verifica se o estado do sensor de saida foi alterado
  if(valorirsai!=1) 
  {
    // Incrementa o valor do contador de saida em 1 unidade
    contsai=contsai+1; 
    // Verifica se a pessoa/objeto para em frente ao sensor
    while(digitalRead(pinoirsaida)!=1)
      { 
       delay(100); 
       Serial.println("Sensor de saida parado !");
      }
    // Atualiza no LCD o valor do contador de saida
    lcd.setCursor(14,1);
    lcd.print(contsai);   
  }

  // Calcula o numero de visitantes na sala
  contsala=content-contsai; 
  // Verifica se o numero atual de visitantes na sala foi alterado.
  if (contsala != contanterior)
  {
    lcd.setCursor(5,0); 
    // Imprime 2 posicoes em branco, para limpar o cursor na 
    // coluna 5, linha 0
    lcd.print("  "); 
    lcd.setCursor(5,0);
    // Atualiza no LCD o numero de visitantes na sala
    lcd.print(contsala); 
    // Apos atualizar no LCD, coloca na varivel CONTANTERIOR 
    // o valor atual de visitantes na sala (CONTASALA} 
    contanterior = contsala; 

    // Verifica se o valor do contador de pessoas na sala 
    // e maior do que 0
    if (contsala > 0) 
    {
      //Caso positivo, acende a luz/led
      digitalWrite(pinoledsala,1); 
    }
      else
    { 
      //Caso negativo, apaga a luz/led
      digitalWrite(pinoledsala,0); 
    } 
  }
}

Também para fins de acompanhamento, os valores dos sensores são mostrados no serial monitor. Caso alguma pessoa ou objeto pare em frente ao sensor, essa informação também é mostrada :

Serial Monitor - Dados IR

O funcionamento desse projeto você confere no vídeo abaixo :



02 setembro 2014

Processing : mostre as informações do Arduino no seu computador

Hoje vamos ver como mostrar informações do Arduino na tela do computador utilizando o Processing, uma linguagem de programação de código aberto usada para escrever programas utilizando representação gráfica. Com ela você consegue criar imagens e animações e por esse motivo é uma linguagem muito utilizada por profissionais de design e ilustradores.

No Arduino, podemos utilizar o Processing para coletar as informações da placa e mostrá-las na tela do computador, como fiz ligando ao Arduino um botão tipo push-button e um led.

Tutorial Arduino Processing


A parte superior da tela temos o Estado Botão, onde um círculo mostra se o led está apagado (círculo em preto), ou aceso (círculo em vermelho). No meio da tela, um contador incrementado a cada acionamento do botão, e na parte inferior um gráfico que vai sendo atualizado conforme acionamos o circuito.

24 julho 2014

Detectando campos magnéticos com o Sensor Hall KY-003

Sensor de campo magnético hall é um sensor que usa o efeito hall para detectar a aproximação de um campo magnético do sensor, gerando em sua saída um valor analógico ou digital, dependendo do tipo de construção do módulo.

Sensor Hall KY-003 Arduino



Existem diversos tipos de sensor hall para utilização com Arduino. Alguns deles detectam a variação e intensidade do campo magnético e transferem essas informações ao pino de sinal de forma analógica, permitindo medir essa variação de forma confiável e precisa.

Outros trabalham apenas com a saída de forma digital, que é o caso do Sensor Hall KY-003 que eu testei. Aproxime um ímã do sensor e você terá o valor 0 no pino de saída. Na ausência de campo magnético, o valor se manterá estável em 1. 

Desta forma, o funcionamento é o mesmo de qualquer outro sensor ou botão que utilizamos com o Arduino : ligamos o pino de sinal do módulo sensor hall à uma porta digital, e tomamos uma ação de acordo com o estado 0 ou 1 dessa porta.

Esse tipo de sensor é ideal para configurações onde não há possibilidade ou necessidade de contato, como em um medidor de RPM de um motor ou um sistema de alarmes.

Esse módulo pode ser alimentado (pino central) com os próprios 5v do Arduino (tensão máxima suportada pelo módulo é de 24v DC). Conecte o pino da esquerda (-) ao GND e o pino da direita (S) à porta digital do seu Arduino. Um led no lado esquerdo da placa indica a presença de sinal no pino de saída:

Sensor Hall - Pinagem

Circuito Arduino e sensor hall KY-003


O programa que utilizei para testar esse circuito é o mesmo que já usei no artigo Ligando uma lâmpada com relé e push-button, com pequenas alterações quanto às portas. A cada acionamento do sensor hall, o estado do led é invertido e permanece assim até que o sensor seja novamente acionado :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// Programa : Teste de acionamento Sensor Hall KY-003
// Autor : Arduino e Cia

// define a porta para o acionamento do led
int pinoled = 6;      
// Porta ligada ao pino SINAL do sensor
int pinosinal = 4;    
// Armazena informações sobre a leitura do sensor
int leitura;          
// Armazena o estado do led (ligado/desligado)
int estadoled = 0;   

void setup()
{
  //Define o pino do led como saida
  pinMode(pinoled, OUTPUT); 

  //Define o pino do sensor hall como entrada
  pinMode(pinosinal, INPUT);      

}

void loop()
{
  leitura = digitalRead(pinosinal);
  if (leitura != 1)
  {
    while(digitalRead(pinosinal) != 1)
    {
      delay(100);
    }
    // Inverte o estado
    estadoled = !estadoled;
    digitalWrite(pinoled , estadoled);  
  } 
}


11 junho 2014

Ligando um sensor de chuva ao Arduino

Preparado para a época de chuvas ? Não ? Que tal uma ajudinha com o Arduino ?

Utilize um sensor de chuva como esse da foto abaixo, para que você consiga fechar uma janela  quando não estiver em casa ou acionar uma bomba para armazenar água da chuva.


sensor de chuva arduino


O sensor de chuva para Arduino é um componente com duas partes : a placa do sensor, formada por várias trilhas resistentes à oxidação, que vão detectar o nível de líquido que está atingindo a placa, e o módulo com chip comparador LM393, que é o responsável por ler as informações desse sensor e enviar os dados pelas pinos A0 (analógico), ou D0 (digital - valores 0 e 1).

Esse módulo também tem um potenciômetro para ajuste de sensibilidade, um led vermelho para indicação de LIGADO, e um led verde que indica a transmissão de dados :

Sensor de chuva Arduino - Pinos e Leds

Voltando aos exemplos que eu citei no início do post, você pode utilizar um motor ligado à saída digital para abrir (sem chuva - nível HIGH) ou fechar (com chuva - nível LOW) uma janela quando for detectada chuva, e com a saída analógica você pode abrir uma válvula ou acionar uma bomba dependendo da intensidade da chuva, lendo os valores de 0 à 1023 fornecidos por essa porta.

Teste o seu módulo com apenas 3 leds e 3 resistores, montando o circuito abaixo. O módulo pode ser alimentado com tensões de 3.3 à 5 volts :

Circuito Sensor de Chuva Arduino Uno
O programa de teste lê as informações do sensor e acende os leds de acordo com o nível de líquido detectado, testando os valores lidos em uma série de comandos IF (SE), que podem ser acrescentados ou alterados de acordo com o nível de precisão desejada :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// Programa : Teste sensor de chuva
// Autor : Arduino e Cia

int pino_d = 2; //Pino ligado ao D0 do sensor
int pino_a = A5; //Pino ligado ao A0 do sensor
int val_d = 0; //Armazena o valor lido do pino digital
int val_a = 0; //Armazena o valor lido do pino analogico

// Portas ligadas aos leds
int pino_led_verde = 5;
int pino_led_amarelo = 6;
int pino_led_vermelho = 7;

void setup()
{
  // Define os pinos do sensor como entrada
  pinMode(pino_d, INPUT);
  pinMode(pino_a, INPUT);

  // Define os pinos dos leds como saida
  pinMode(pino_led_verde, OUTPUT);
  pinMode(pino_led_amarelo, OUTPUT);
  pinMode(pino_led_vermelho, OUTPUT);
  Serial.begin(9600);
}

void loop()
{
  //Le e arnazena o valor do pino digital
  val_d = digitalRead(pino_d);
  //Le e armazena o valor do pino analogico
  val_a = analogRead(pino_a);
  //Envia as informacoes para o serial monitor
  Serial.print("Valor digital : ");
  Serial.print(val_d);
  Serial.print(" - Valor analogico : ");
  Serial.println(val_a);
 
  // Acende o led de acordo com a intensidade 
  if (val_a >900 && val_a <1024)
  {
    // Acende led verde - intensidade baixa
    digitalWrite(pino_led_verde, HIGH);
    digitalWrite(pino_led_amarelo, LOW);
    digitalWrite(pino_led_vermelho, LOW);
  }
  if (val_a >400 && val_a <900)
  {
    // Acende led amarelo - intensidade moderada
    digitalWrite(pino_led_verde, LOW);
    digitalWrite(pino_led_amarelo, HIGH);
    digitalWrite(pino_led_vermelho, LOW);
  }
  if (val_a > 0 && val_a <400)
  {
    // Acende led vermelho - intensidade alta
    digitalWrite(pino_led_verde, LOW);
    digitalWrite(pino_led_amarelo, LOW);
    digitalWrite(pino_led_vermelho, HIGH);
  }
  delay(1000);
}

Caso você queira testar apenas o sensor, sem montar todo o circuito, os valores também são exibidos no serial monitor :

Sensor de Chuva Arduino - Serial Monitor

O funcionamento do circuito teste você confere no vídeo abaixo :


04 junho 2014

Sensor de presença com módulo PIR DYP-ME003

Os sensores de presença mais comuns usam sensores PIR (Passive Infrared Sensor, ou Sensor Infravermelho Passivo) como detector de movimentos.

No Arduino, temos o módulo PIR DYP-ME003, que une numa mesma estrutura o sensor PIR e também os circuitos necessários para ajuste e controle do sinal de saída.
Modulo PIR DYP-ME003
O módulo contém o sensor PIR propriamente dito, composto internamente por duas faixas com material sensível ao infravermelho. Na parte externa, uma espécie de capa/tampa que na verdade é uma lente fresnel.

Quando há variação na detecção do sinal infravermelho entre essas duas faixas de material sensível, a saída é acionada por um determinado tempo. A lente fresnel tem a função de, vamos dizer assim, "ampliar" o campo de visão do sensor, condensando a luz em um único ponto.

Felizmente existem figuras para traduzir toda essa teoria e mostrar de uma forma mais clara como isso funciona.

Abaixo, o sensor PIR, a lente fresnel e as duas faixas de detecção, acionadas quando alguém passa em frente ao sensor :
sensor de presença com PIR
Imagem : electronicsgurukulam.blogspot.com



Nessa outra figura, uma representação de como funciona uma lente fresnel :

Lente fresnel e sensor PIR


Resumidamente, é assim que a coisa funciona. Uma explicação muito melhor e mais detalhada você encontra no datasheet do módulo, nesse link.

Vamos então para a parte boa, analisando o módulo e testando-o com um Arduino Uno. :-)

No lado esquerdo da imagem, o módulo sem a lente, com o sensor exposto. No lado direito, a parte inferior do módulo, com os 2 pinos de alimentação (4.5 à 20 volts ) e sinal, os potenciômetros para ajuste da sensibilidade e tempo de acionamento da saída, e também o jumper que controla o modo de operação do trigger (gatilho) :

Detalhe módulo PIR Arduino


Apenas preste atenção quando for ligar o seu módulo, pois alguns apresentam os pinos Vcc e GND invertidos. Na dúvida, consulte o datasheet do seu módulo ou verifique as indicações na placa.

Nesse módulo, praticamente não há necessidade de programação no Arduino, já que a saída é colocada em HIGH (ALTO), quando um objeto for detectado, e permanece assim pelo tempo que configurarmos no potenciômetro. Basta então definirmos o que será feito com as saídas do Arduino :

Circuito sensor de presença PIR Arduino Uno
No loop do programa, o valor lido da porta 3 (ligada ao pino de sinal do sensor), é constantemente checado, e caso ocorra movimentação em frente ao sensor, o led vermelho ligado à porta 5 é acionado. Caso contrário, é o led azul ligado à porta 6 que permanece acionado.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Programa : Sensor de presenca com modulo PIR
// Autor : Arduino e Cia

int pinoledverm = 5; //Pino ligado ao led vermelho
int pinoledazul = 6; //Pino ligado ao led azul
int pinopir = 3;  //Pino ligado ao sensor PIR
int acionamento;  //Variavel para guardar valor do sensor

void setup()
{
  pinMode(pinoledverm, OUTPUT); //Define pino como saida
  pinMode(pinoledazul, OUTPUT); //Define pino como saida
  pinMode(pinopir, INPUT);   //Define pino sensor como entrada

}

void loop()
{
 acionamento = digitalRead(pinopir); //Le o valor do sensor PIR
 if (acionamento == LOW)  //Sem movimento, mantem led azul ligado
 {
    digitalWrite(pinoledverm, LOW);
    digitalWrite(pinoledazul, HIGH);
 }
 else  //Caso seja detectado um movimento, aciona o led vermelho
 {
    digitalWrite(pinoledverm, HIGH);
    digitalWrite(pinoledazul, LOW);
 }
}

E o resultado desse experimento você confere no vídeo abaixo :



Se você planeja melhorar esse circuito e acionar um relé ou adicionar um buzzer, recomendo a leitura destes artigos aqui mesmo no Arduino e Cia :

Artigos relacionados à relés

Artigos relacionados à buzzer e sons no Arduino


28 setembro 2013

Controle de luz utilizando LDR

Algumas pessoas me escreveram perguntando sobre sensores de luz, e como poderia ser montado um dispositivo que acendesse uma lâmpada ao escurecer.

Esse é um circuito bem simples de montar, e que utiliza pouquíssimos componentes, entre eles, um componente barato e fácil de encontrar : o LDR (Light Dependent Resistor, ou Resistor Dependente de Luz), componente disponível no Kit Arduino Iniciante da loja FILIPEFLOP.


Arduino LDR

O LDR, como o próprio nome diz, é um resistor cuja resistência varia em função da luminosidade que incide sobre ele, devido ao material fotossensível que cobre o componente.

Ao iluminarmos um LDR, a sua resistência apresenta valores muito baixos. Ao cortarmos a iluminação, a resistência sobe. Observe isso na prática, nas fotos abaixo, onde eu aplico luz ao LDR (imagem da esquerda), e a resistência medida é baixa, e na imagem da direita, cubro parcialmente o LDR e ocorre o aumento da resistência :

Comparativo resistência LDR

Conhecendo os princípios básicos do componente, podemos montar um circuito onde, com incidência de luz, o led se apaga, e ao cobrirmos o LDR, o led se acende :

Circuito LDR Led - Arduino Uno
O programa para este circuito lê o valor da porta analógica (que deve estar na faixa de 0 a 1024), verificando se o valor é maior do que 800 (LDR encoberto) e consequentemente acendendo o led. Usei no meu circuito um resistor de 330 ohms para o led e de 10K para o LDR. Caso o seu circuito não funcione adequadamente, ajuste esses valores :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Programa : LDR - Sensor de Iluminação  
// Autor : Arduino e Cia  
   
int portaLed = 10; //Porta a ser utilizada para ligar o led  
int portaLDR = A5; //Porta analógica utilizada pelo LDR  
  
void setup()  
{  
  pinMode(portaLed, OUTPUT); //Define a porta do Led como saída  
}  
   
void loop()  
{  
  int estado = analogRead(portaLDR);  //Lê o valor fornecido pelo LDR  
    
  // Caso o valor lido na porta analógica seja maior do que 
  // 800, acende o LED  
  // Ajuste o valor abaixo de acordo com o seu circuito  
  if (estado > 800)    
  {  
    digitalWrite(portaLed, HIGH);  
  }  
  else  //Caso contrário, apaga o led  
  {  
    digitalWrite(portaLed, LOW);  
  }  
}  

E você lembra deste post sobre dimmer usando potenciômetro ? Pois bem, podemos utilizar o mesmo circuito, trocando o potenciometro pelo LDR, e obtendo o mesmo efeito, sem mexer no programa :

Circuito LDR Dimmer - Arduino Uno


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// Projeto : Controle de luminosidade de led com LDR  
// Autor : Arduino e Cia  
   
int pinoled = 10; //Pino ligado ao anodo do led  
int pinopot = 5;  //Pino ligado ao LDR  
int valorpot = 0; //Armazena valor lido do LDR, entre 0 e 1023  
float luminosidade = 0; //Valor de luminosidade do led  
   
void setup()  
{  
  Serial.begin(9600);    //Inicializa a serial  
  pinMode(pinoled, OUTPUT); //Define o pino do led como saída  
  pinMode(pinopot, INPUT);  //Define o pino do LDR como entrada  
}  
   
void loop()  
{  
  // Le o valor - analogico - do LDR  
  valorpot = analogRead(pinopot);  

  // Converte o valor lido do LDR
  luminosidade = map(valorpot, 0, 1023, 0, 255); 
  Serial.print("Valor lido do LDR : ");   

  // Mostra o valor lido do LDR no monitor serial  
  Serial.print(valorpot);  
  Serial.print(" = Luminosidade : ");  

  // Mostra o valor da luminosidade no monitor serial  
  Serial.println(luminosidade); 
  
  // Acende o led com luminosidade variável
  analogWrite(pinoled, luminosidade); 
 }  

Se necessário, ajuste os valores das resistências do led e do LDR, como no circuito anterior, e tenha agora um dimmer regulado por luz (ou pela falta dela).

27 julho 2013

Controlando 2 displays 7 segmentos com Max7219

No primeiro artigo sobre o display 7 segmentos, vimos como ligar um display diretamente no Arduino. No segundo artigo, ligamos o display à um CI controlador de displays, o Max7219, que por sua vez se comunica com o Arduino utilizando apenas 3 portas da placa.

Neste terceiro artigo, vou continuar utilizando o CI Max7219 e usá-lo para controlar 2 displays de 7 segmentos, gerando o resultado abaixo :



Observe no circuito abaixo que a ligação ao segundo display é a mesma, ou seja, os mesmos fios que usei para ligar o CI nos segmentos A,B,C, etc, serão utilizados para ligação aos segmentos A,B,C, etc do 2o. display.

Outra alteração no circuito é a ligação do pino D1 (pino 11 do Max7219) ao pino 8 (comum) do segundo display :

Circuito Max7219 e 2 displays 7 segmentos
Essas são as alterações no circuito, tirando uma eventual mudança na resistência, para controlar a corrente nos displays, e essa é a vantagem de usar um CI como o Max7219 : você controla até 8 displays de 7 segmentos, continua usando apenas uma resistência para controlar a corrente em todos os displays, e o resto do "serviço" é feito pelo programa do Arduino.

E falando em programa, vou utilizar praticamente o mesmo do artigo anterior, fazendo um contador de 0 a 99. A mudança no programa está na linha que envia os dados para o display, com o comando lc.setdigit, que tem a seguinte sintaxe :

lc.setDigit( numero_do_chip, display , valor , pontodecimal )

numero_do_chip = Podemos usar até 8 chips MAX7219 em cascata, e esse número determina para qual chip estamos enviando os dados. Para o primeiro chip, o valor deste parametro será 0, para o segundo chip, o valor será 1, e assim sucessivamente.

display = é o número do display com o qual estamos trabalhando. O valor 0 envia os dados para o primeiro display, o valor 1 envia para o segundo display, e assim sucessivamente

valor = é o valor a ser mostrado no display selecionado

pontodecimal = Recebe o valor "true" se quisermos ligar o ponto decimal do display selecionado, ou "false" se quisermos desligá-lo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// Programa : Controlando 2 displays 7 segmentos usando CI Max7219
// Alteracoes / comentarios  : Arduino e Cia
// Baseado no programa exemplo da biblioteca LedControl

#include "LedControl.h" 

// Pino 4 do Arduino ao pino 1 (DIN) do CI
// Pino 5 do Arduino ao pino 13 (CLK) do CI
// Pino 6 do Arduino ao pino 12 (LOAD) do CI
// Ultimo parametro se refere a qtde de MAX7219 utilizados no circuito
LedControl lc=LedControl(4,5,6,1); 

boolean pontodecimal; 

void setup() 
{ 
  // Inicializa o Max7219
  lc.shutdown(0,false); // Habilita o display 
  // Define o nivel de luminosidade (0 minimo, 15  maximo)
  lc.setIntensity(0,10); 
  lc.clearDisplay(0); // Apaga o display
  Serial.begin(9600); // Inicializa a serial
  pontodecimal = false;  //Define o ponto decimal como DESLIGADO
} 

void loop() 
{ 
  for(int i=0; i < 100 ; i++)  //Loop variando valor de i de 0 a 99
  { 
    //Mostra o valor de i/10 no display 1
    lc.setDigit(0,0,i/10,pontodecimal);  
    //Inverte o estado do ponto decimal
    pontodecimal = !pontodecimal;   
    //Mostra o valor de i%10 no display 2
    lc.setDigit(0,1,i%10,pontodecimal);  
    Serial.println(i);
    delay(1000);  //Aguarda 1 segundo e mostra o próximo valor
  } 
delay(1000);  //Aguarda 1 segundo e reinicia a contagem
}

22 julho 2013

Controlando display 7 segmentos com o Max7219

Continuando o assunto display 7 segmentos, abordado no meu post anterior, hoje vou controlar o display 7 segmentos usando o CI MAX7219, fabricado pela Maxim.

Arduino - CI Max7219 - Display 7 segmentos


O Max7219 é um CI driver display, isto é, um controlador feito especialmente para trabalhar com displays, tanto os de 7 segmentos, como as matrizes de led. Ele trabalha com displays de catodo comum e a comunicação com o Arduino utiliza apenas 3 portas da placa (veja que no exemplo do post anterior, eu usei 8 portas).

Além disso, com um único chip MAX7219 é possível controlar até 8 displays de 7 segmentos utilizando as mesmas 3 portas do Arduino. Outra vantagem é o uso de apenas um resistor para todos os segmentos, entre os pinos 19 e 18, conforme mostra o datasheet do CI :


A montagem do circuito requer atenção para não danificar o CI. Repare que o "chanfro" fica do lado esquerdo, logo o pino 1 fica à esquerda, abaixo do CI. Observe a pinagem do Max7219 :


Ligamos os pinos SEG A, SEG B,etc. , aos pinos do display, segmentos A, B, C, etc. Como neste exemplo temos apenas 1 display, vamos ligar o comum - pino 8 - ao pino DIG 0 do CI. Siga a tabela abaixo :




Para o programa exemplo, vamos utilizar a biblioteca LedControl, que você pode encontrar aqui, ou nesse link :

http://www.wayoda.org/arduino/downloads/LedControl.zip

Instalada a biblioteca, carregue o seguinte programa no Arduino :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// Programa : Contador display 7 segmentos usando CI Max7219
// Alteracoes / comentarios  : Arduino e Cia
// Baseado no programa exemplo da biblioteca LedControl

#include "LedControl.h" //Carrega a biblioteca LedControl

// Pino 4 do Arduino ao pino 1 (DIN) do CI
// Pino 5 do Arduino ao pino 13 (CLK) do CI
// Pino 6 do Arduino ao pino 12 (LOAD) do CI
// Ultimo parametro se refere a qtde de MAX7219 no circuito

LedControl lc=LedControl(4,5,6,1); 

boolean pontodecimal;  //Armazena o estado do ponto decimal (Lig/Desl)

void setup() 
{ 
  // Inicializa o Max7219
  lc.shutdown(0,false); // Habilita o display 
  // Define o nivel de luminosidade (0 minimo, 15  maximo)
  lc.setIntensity(0,10); 
  lc.clearDisplay(0); // Apaga o display
  Serial.begin(9600); // Inicializa a serial
  pontodecimal = true;  //Define o ponto decimal como LIGADO
} 

void loop() 
{ 
  for(int i=0; i < 10 ; i++)  //Loop variando valor de i de 0 a 9
  { 
    lc.setDigit(0,0,i,pontodecimal);  //Mostra o valor de i no display 
    Serial.println(i);
    pontodecimal = !pontodecimal; //Inverte o estado do ponto decimal
    delay(1000);  //Aguarda 1 segundo e mostra o próximo valor
  } 
delay(1000);  //Aguarda 1 segundo e reinicia a contagem
}

Este programa configura as portas a serem utilizadas com os pinos DIN, CLK e LOAD do CI, inicializa o display e mostra os valores de 0 a 9 por meio de um loop. Como costumo fazer, mostro também o valor no monitor serial, para fins de acompanhamento e análise caso ocorra algum problema na ligação do circuito.

No próximo artigo, vamos utilizar este circuito como base, e mostrar como utilizar esse CI para controlar 2 (ou mais) displays.

Atualizado : Controlando 2 displays de 7 segmentos com o Max7219

Até a próxima !



17 julho 2013

Display 7 segmentos

Hoje vou falar de outro display bastante comum utilizado nos projetos do Arduino : o display de 7 segmentos, como esse abaixo :

Display 7 segmentos FJ5101AH

O display de 7 segmentos, como o próprio nome diz, tem 7 partes, ou segmentos, que podem ser agrupados de modo a formar números e letras.

Display 7 segmentos - letras e numeros

Os segmentos são organizados de A a F :
Display 7 segmentos - Disposição dos segmentos
Imagem : Wikipedia
Assim, se você quiser mostrar o número 1, basta ativar os segmentos B e C. Para mostrar o número 3, os segmentos A, B, C, D e G, e assim por diante.

A ligação ao Arduino usa os pinos de 2 a 9, mais o GND,  na seguinte sequencia :

Pino 2 do Arduino ====> Pino segmento A
Pino 3 do Arduino ====> Pino segmento B
Pino 4 do Arduino ====> Pino segmento C
Pino 5 do Arduino ====> Pino segmento D
Pino 6 do Arduino ====> Pino segmento E
Pino 7 do Arduino ====> Pino segmento F
Pino 8 do Arduino ====> Pino segmento G
Pino 9 do Arduino ====> Pino segmento PONTO
Pino GND do Arduino => Pino 3 do display

Um ponto importante é a utilização dos resistores de 220 ohms para cada pino. Como o display trabalha com 2V, é necessário limitar a corrente, evitando queimar o componente :

Circuito Arduino Display 7 segmentosPara o modelo de display que estou utilizando (FJ5101AH, catodo comum), a disposição dos pinos é mostrada na próxima imagem. Se o seu display for de outro modelo, basta descobrir qual pino corresponde a cada segmento. Isso pode ser feito utilizando-se um multimetro ou até mesmo uma pilha, tomando o cuidado de respeitar a voltagem máxima que comentei acima : 2 volts.

Display catodo comum
Imagem : Parallax
Finalmente o programa, baseado no código desenvolvido pelo site hacktronics. Fiz algumas alterações no mesmo, para que o display mostre não só os números de 0 a 9, mas também as letras de A a F, em ordem crescente :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
// Programa : Contador crescente 0 a F
// Modificacoes e comentarios : Arduino e Cia
// Baseado no programa:
// Arduino 7 segment display example software
// http://www.hacktronics.com/Tutorials/arduino-and-7-segment-led.html
// License: http://www.opensource.org/licenses/mit-license.php (Go crazy)
// Define a ordem de ligação dos segmentos, dos digitos 0 a F
// Este padrão é para display de catodo comum
// Para display de anodo comum, modifique os valores de 0 para 1 e 
// de 1 para 0
// 1 = LED ligado, 0 = LED desligado, nessa ordem :
//                   Arduino pinos: 2,3,4,5,6,7,8

byte seven_seg_digits[16][7] = { { 1,1,1,1,1,1,0 },  // = Digito 0
                                 { 0,1,1,0,0,0,0 },  // = Digito 1
                                 { 1,1,0,1,1,0,1 },  // = Digito 2
                                 { 1,1,1,1,0,0,1 },  // = Digito 3
                                 { 0,1,1,0,0,1,1 },  // = Digito 4
                                 { 1,0,1,1,0,1,1 },  // = Digito 5
                                 { 1,0,1,1,1,1,1 },  // = Digito 6
                                 { 1,1,1,0,0,0,0 },  // = Digito 7
                                 { 1,1,1,1,1,1,1 },  // = Digito 8
                                 { 1,1,1,0,0,1,1 },  // = Digito 9
                                 { 1,1,1,0,1,1,1 },  // = Digito A
                                 { 0,0,1,1,1,1,1 },  // = Digito B
                                 { 1,0,0,1,1,1,0 },  // = Digito C
                                 { 0,1,1,1,1,0,1 },  // = Digito D
                                 { 1,0,0,1,1,1,1 },  // = Digito E
                                 { 1,0,0,0,1,1,1 }   // = Digito F
                                 };


void setup() 
{  
  pinMode(2, OUTPUT); //Pino 2 do Arduino ligado ao segmento A  
  pinMode(3, OUTPUT); //Pino 3 do Arduino ligado ao segmento B
  pinMode(4, OUTPUT); //Pino 4 do Arduino ligado ao segmento C
  pinMode(5, OUTPUT); //Pino 5 do Arduino ligado ao segmento D
  pinMode(6, OUTPUT); //Pino 6 do Arduino ligado ao segmento E
  pinMode(7, OUTPUT); //Pino 7 do Arduino ligado ao segmento F
  pinMode(8, OUTPUT); //Pino 8 do Arduino ligado ao segmento G
  pinMode(9, OUTPUT); //Pino 9 do Arduino ligado ao segmento PONTO
  writePonto(0);  // Inicia com o ponto desligado
}

void writePonto(byte dot)   //Funcao que aciona o ponto no display
{  
  digitalWrite(9, dot);
}

void sevenSegWrite(byte digit)  //Funcao que aciona o display
{
  byte pin = 2;

  //Percorre o array ligando os segmentos correspondentes ao digito
  for (byte segCount = 0; segCount < 7; ++segCount)  
  { 
    digitalWrite(pin, seven_seg_digits[digit][segCount]);
    ++pin;
  }
    writePonto(1);  //Liga o ponto
    delay(100);   //Aguarda 100 milisegundos
    writePonto(0);  //Desliga o ponto
}

void loop() 
{
  //Contador de 0 a 15, ligando os segmentos correspondentes
  //0 a 9 = liga os segmentos correspondentes aos numeros
  //10 a 15 = Forma as letras A,B,C,D,E,F
  for (byte count = 0; count < 16; count++)
  {
     delay(500);
     sevenSegWrite(count);
  }
  delay(4000);
}

Não encontrei o datasheet específico desse display FJ5101AH.Procurando modelos similares, encontrei as informações abaixo, que podem ser utilizadas como base :

Display 7 Segmentos - Pinagem e dimensões

Display 7 segmentos - Dados técnicos
No próximo artigo vou usar esse mesmo display de 7 segmentos com o Arduino, mas gerenciado por um circuito integrado específico para trabalhar com displays : o Max7219.

Atualizado : Controlando display 7 segmentos com o Max7219

Atualizado : Ligando 2 displays 7 segmentos ao Max7219

Até lá !


11 julho 2013

Dimmer - Usando portas analógicas para controlar a luminosidade de um led

Que tal um dimmer para entender como funciona a variação de "dados" na porta analógica ?

O nosso circuito usa um potenciômetro, ligado à entrada analógica 5, para controlar a luminosidade de um led ligado à porta 10. Conforme giramos o potenciômetro no sentido horário, a intensidade de iluminação do led vai se aproximando do ponto máximo.

Vamos usar o seguinte material....

  • 1 potenciometro de 10 K 
  • 1 led
  • 1 resistor de 330 ohms

...montando o seguinte circuito :

Circuito dimmer Arduino
O programa usa uma função chamada map (http://arduino.cc/en/Reference/Map), que converte o valor lido da entrada analógica (entre 0 e 1023), para um valor entre 0 e 255 (8 bits), que será utilizado para ajustar a luminosidade do led. A sintaxe dessa função é a seguinte :

map(valor, de_menor_valor, de_maior_valor, para_menor_valor, para_maior_valor)

No nosso caso então, temos :

luminosidade = map(valorpot, 0, 1023, 0, 255);

onde valorpot é o valor lido do potenciometro, entre 0 e 1023, que será convertido para um valor entre 0 e 255, que por sua vez será atribuído à variável luminosidade. Perceba que estamos utilizando a porta 10, digital, como uma porta analógica, usando a função analogWrite. Como o Arduino faz isso ?

Repare na foto abaixo que no Arduino os pinos 3, 5, 6, 9, 10 e 11 são PWM (Pulse Width Modulation - Modulação por Largura de Pulso), o que permite que eles sejam usados de forma analógica.

Detalhes portas PWM Arduino

O "truque" do PWM é ligar e desligar essa porta rapidamente, simulando uma voltagem entre 0 e 5 volts. O tempo que a porta permanece ligada ou desligada determina o valor da saída analógica, assim, se você quiser 50% da luminosidade, a porta ficaria 50% do tempo em modo ON (ligada), e 50% em modo OFF (desligada). Essa variação é feita de forma tão rápida que não é percebida pelo olho humano.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// Projeto : Controle de luminosidade de led com potenciometro
// Autor : Arduino e Cia

int pinoled = 10;  //Pino ligado ao anodo do led
int pinopot = 5;   //Pino ligado ao pino central do potenciometro
int valorpot = 0;  //Armazena valor lido do potenciometro, entre 0 e 1023

float luminosidade = 0; //Valor de luminosidade do led

void setup()
{
   Serial.begin(9600);        //Inicializa a serial
   pinMode(pinoled, OUTPUT);  //Define o pino do led como saída
   pinMode(pinopot, INPUT);   //Define o pino do potenciometro como entrada
}

void loop()
{
  // Le o valor - analogico - do pino do potenciometro
  valorpot = analogRead(pinopot);

  //Converte e atribui para a variavel "luminosidade" o
  // valor lido do potenciometro
  luminosidade = map(valorpot, 0, 1023, 0, 255);  

  Serial.print("Valor lido do potenciometro : "); 

  //Mostra o valor lido do potenciometro no monitor serial
  Serial.print(valorpot);   
  Serial.print(" = Luminosidade : ");

  //Mostra o valor da luminosidade no monitor serial
  Serial.println(luminosidade);  

  //Envia sinal analogico para a saída do led, com luminosidade variavel
  analogWrite(pinoled, luminosidade);  
}

Para facilitar a visualização de como as portas analógicas se comportam, o programa mostra no monitor serial não só o valor lido do potenciometro, como também o valor da luminosidade após a utilização da função map que expliquei anteriormente :

Dados dimmer Arduino monitor serial