27 julho 2013

Ligando 2 displays 7 segmentos ao 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

02 julho 2013

Como trocar as cores da IDE do Arduino ?

Confesso que nunca fui muito fã das cores da IDE do Arduino, principalmente a cor de fundo, branca, que acaba cansando facilmente os olhos depois de algum tempo em frente ao computador. Um fundo preto seria o ideal para programação, na minha opinião.

Existem alguns temas interessantes disponíveis para download, mas acabei encontrando um esquema relativamente simples para alterar as cores da IDE. Abaixo, a minha IDE original, do jeito que foi baixada :

cores IDE Arduino
 ... e como ela ficou....

IDE Arduino - Alterada
E como eu altero isso ? alterando o arquivo theme.txt que está na pasta lib da IDE do Arduino. No meu caso, o caminho é esse :

D:\Arduino\arduino-1.0.5\lib\theme

Antes de mais nada, faça uma cópia desse arquivo, caso algo dê errado.

Evite abrir o arquivo no bloco de notas do Windows, já que ele vai aparecer sem formatação e você terá dificuldade em encontrar o que precisa. 

Ao invés disso, utilize o Wordpad (ou outro editor equivalente, de sua preferência) para abrir o theme.txt, e você verá uma tela como essa :


Procure  a seguinte entrada, que muda a cor do texto para branco, e a cor de fundo para preto :

# EDITOR - DETAILS

# foreground and background colors
editor.fgcolor = #000000
editor.bgcolor = #ffffff

Troque apenas os valores 000000 por ffffff (vai mudar a cor do texto para branco, e o de fffff por 000000 (que vai mudar a cor do fundo para preto). Ficará assim :

# EDITOR - DETAILS

# foreground and background colors
editor.fgcolor = #ffffff
editor.bgcolor = #000000


O cursor piscante tem uma cor escura, por isso precisamos mexer nesse parâmetro também. O procedimento é o mesmo, procurando o seguinte texto :

# caret blinking and caret color
editor.caret.color = #333300

Troque o 333300 por ffffff, e o seu texto ficará assim :

# caret blinking and caret color
editor.caret.color = #ffffff

Salve o arquivo theme.txt, feche a IDE do Arduino e abra novamente, para que as alterações sejam carregadas.

O valor 000000 corresponde à cor preta, e o ffffff à cor branca, mas e se você quiser outras cores, onde encontrar os códigos ? Basta usar uma tabela, parecida com esta da figura abaixo, que você encontra, completa, nesse link :

Arduino IDE - Tabela de cores

O theme.txt também permite que você altere a cor das abas da IDE, cor do texto selecionado, fonte do texto, linha de status e muitos outros parâmetros. Faça um backup do seu arquivo e "brinque" à vontade !