Archive for the ‘Display’ Category

Matriz de Leds 8×8 RGB Anôdo comum

29 OUT
2015

Author: Leonardo Dalla Porta

Neste tutorial você verá como conectar e utilizar o display do tipo Matriz de Leds RGB 8×8 Ânodo comum no seu arduino, de forma quanto complexo, porém, vale a pena todo o trabalho, além que você aprenderá muitas coisas!

Começando pela matriz de leds, ela tem 32 pinos: 8 anodos, catodos de 8 para o vermelho, verde e 8 para 8 de azul. Então, utilizamos um arduino para controlar todos os parametros de cor e posição dos leds acesos e apagados!

Saiba que com o Shift Register você pode controlar todos os 32 pinos da matriz de leds usando apenas um par de fios do arduino. Registradores são baratos, neste caso foi usado o circuito integrado 74HC595, que por sua vez controla todos os leds da matriz, ou seja, 64 leds!

 

Esquema

O esquema de ligação da matriz de leds e todos os componentes deve ficar igual da imagem a seguir, lembrando que os 3 fios azul, verde e amarelo são conectados ao Arduino, neste tutorial mostraremos como utiliza-lo com o Circuito integrado “74HC595” mas pode ser usado também com o “TLC5940”, porém você precisa ter habilidades para poder montar isso:

 

 

 

Código

O código, como é muito extenso, está disponibilizado neste link! O código consta com vários deslocamentos de Bits, ou seja, para você poder mudar de cor, você precisa modificar alguns parâmetros disponibilizados no código.

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Primeiros passos com o arduino Lilypad

13 OUT
2015

Author: Leonardo Dalla Porta

Este é um rápido tutorial para você começar costurar um circuito apenas para LEDs simples usando o Conselho Simples Arduino Lilypad. Você não vai aprender a criar o seu próprio programa Arduino, mas você vai ligar 9 LEDs para o conselho (um para cada pino exceto + e -), e você vai fazer upload de código fornecido para mudar a forma como as luzes se mover e piscar .

Você vai precisar de:

  • Fio condutor
  • LEDs LilyPad
  • LilyPad Arduino Board Simples
  • LilyPad FTDI
  • Cabo USB Mini
  • Bateria (Mesma de celular)
  • Tecido, vestuário, ou projeto
  • Arduino

Recomendado, mas não é necessário:

  • Bordados Hoop

 

Dê uma olhada em seu LilyPad que tem 11 conectores nele que podem ser costurados para qualquer número de dispositivos interessantes. Neste tutorial, nós apenas estamos indo para lidar com luzes, mas lembre-se que a placa Arduino é uma ferramenta muito versátil. Ele pode ser usado para direcionar a atividade de sensores, motores, campainhas, vibração motors- qualquer coisa que você pode comprar em uma placa de LilyPad, e muitas coisas que você não pode. Estamos usando 9 placas de luz LED, porque você tem nove blocos na placa além de + e – almofadas.

Vá em frente e passe a agulha com o fio condutora, e costurar de cima para baixo ao tecido onde você quer que pelo buraco na almofada rotulado ‘5’.

Costure longe deste ponto para onde você quer que seu primeiro LED para ir, em seguida, costurar para baixo o bloco positivo do LED

Amarrar e cortar o fio, reiniciar na próxima almofada que você gostaria de costurar para baixo. Acho que é mais fácil de passar para o outro lado do tabuleiro, de modo que ele está firmemente conectado em ambos os lados. Costure deste para onde você gostaria que o LED correspondente, e mais uma vez costurar para baixo o lado positivo do LED.

Repita esse processo para cada pad exceto os marcados + e -. Eu tenho o meu costurado em um padrão radial – você pode desviar-se este padrão, mas lembre-se para não cruzar qualquer dos fios. Desde fio condutor é não isolada, se as linhas de costura cruz, dois LEDs receberá o atual significou para apenas um.

Você tem duas almofadas de esquerda agora.

Costurar em direção a – pad, chamado ‘ground’ e costurar a partir dele para o “-” no LED mais próximo. Você não tem que amarrar e cortar essa linha de costura – continuá-lo para o próximo LED, e no próximo, a toda a volta para o LED de última, certificando-se de nunca cruzar um traço “+” com este – trace “” .

Quando você chegar ao último LED, vá em frente e dê um nó no fio e cortá-la. Deve agora ter todos os 9 LEDs ligados para almofadas individuais na placa Arduino sobre os seus lados positivos, e todos eles ligados de uma linha contíguos uns aos outros e para a almofada de terra.

Aqui está o que o circuito parece que da parte traseira – você pode ver que nenhum dos traços positivos estão em contacto uns com os outros, e todos os negativos são.

Você é feito agora com a porção de costura – o circuito está completo. Ligue a placa FTDI para os cabeçalhos na placa Arduino Lilypad e final mini-USB do seu cabo à placa FTDI assim:

E o fim do cabo USB em seu computador

Em seguida, você vai fazer o upload do programa. Se você não tiver instalado o Arduino no seu computador, no entanto, você precisará fazê-lo agora. Quando você abre Arduino, você vai ter uma tela como esta:

Verifique que você selecionou a placa correta

Agora é hora de fazer o upload do código que irá executar suas luzes!

Este é o código que você vai usar:

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
#define LED1 5
#define LED2 6
#define LED3 9
#define LED4 10
#define LED5 11
#define LED6 16
#define LED7 17
#define LED8 18
#define LED9 19
 
#define interval 11000
#define dead_time 1000
 
unsigned long PWM_counter = 0;
 
int offset = 0;
int step_size = 200;
unsigned long on_time = 0;
unsigned long cycle_start = 0;
char dir = 1;
 
int offset2 = 0;
int step_size2 = 200;
unsigned long on_time2 = 0;
unsigned long cycle_start2 = 0;
char dir2 = 1;
 
byte LED_tracker1 = 1;
byte LED_tracker2 = 1;
 
void setup() {
  Serial.begin(57600);
  pinMode(LED1, OUTPUT);      
  pinMode(LED2, OUTPUT); 
  pinMode(LED3, OUTPUT); 
  pinMode(LED4, OUTPUT); 
  pinMode(LED5, OUTPUT); 
  pinMode(LED6, OUTPUT); 
  pinMode(LED7, OUTPUT); 
  pinMode(LED8, OUTPUT); 
  pinMode(LED9, OUTPUT); 
  offset = random(2500,7500);
  offset2 = random(2500,7500);
}
 
void loop()
{
  PWM_counter = micros();
 
  if( (PWM_counter + offset - cycle_start) >= interval) {  // completed cycle, start over
    on_time += step_size*dir;
    cycle_start = PWM_counter;
    if (on_time >= (interval - dead_time) ) {
      dir *= -1;
      on_time = interval - dead_time;
    }
    else if (on_time <= 0) { on_time = 0; dir *= -1; LED_tracker1 = LED_tracker2; while (LED_tracker1 == LED_tracker2) LED_tracker1 = random(1,10); offset2 = random(0,4000); } } else if( (PWM_counter + offset - cycle_start) >= (dead_time + on_time) ) {  // time to switch LED off
    //digitalWrite(LED1, LOW);
    LED_off(LED_tracker1);
  }
  else if( (PWM_counter + offset - cycle_start) >= dead_time) {  // time to switch LED on
    //digitalWrite(LED1, HIGH);
    LED_on(LED_tracker1);
  }  
 
  if( (PWM_counter + offset2 - cycle_start2) >= interval) {  // completed cycle, start over
    on_time2 += step_size2*dir2;
    cycle_start2 = PWM_counter;
    if (on_time2 >= (interval - dead_time) ) {
      dir2 *= -1;
      on_time2 = interval - dead_time;
    }
    else if (on_time2 <= 0) { on_time2 = 0; dir2 *= -1; LED_tracker2 = LED_tracker1; while (LED_tracker2 == LED_tracker1) LED_tracker2 = random(1,10); offset2 = random(0,4000); } } else if( (PWM_counter + offset2 - cycle_start2) >= (dead_time + on_time2) ) {  // time to switch LED off
    //digitalWrite(LED1, LOW);
    LED_off(LED_tracker2);
  }
  else if( (PWM_counter + offset2 - cycle_start2) >= dead_time) {  // time to switch LED on
    //digitalWrite(LED1, HIGH);
    LED_on(LED_tracker2);
  }
}
 
void LED_on(byte LED)
{
  if (LED == 1) digitalWrite(LED1, HIGH);
  if (LED == 2) digitalWrite(LED2, HIGH);
  if (LED == 3) digitalWrite(LED3, HIGH);
  if (LED == 4) digitalWrite(LED4, HIGH);
  if (LED == 5) digitalWrite(LED5, HIGH);
  if (LED == 6) digitalWrite(LED6, HIGH);
  if (LED == 7) digitalWrite(LED7, HIGH);
  if (LED == 8) digitalWrite(LED8, HIGH);
  if (LED == 9) digitalWrite(LED9, HIGH);
}
 
void LED_off(byte LED)
{
  if (LED == 1) digitalWrite(LED1, LOW);
  if (LED == 2) digitalWrite(LED2, LOW);
  if (LED == 3) digitalWrite(LED3, LOW);
  if (LED == 4) digitalWrite(LED4, LOW);
  if (LED == 5) digitalWrite(LED5, LOW);
  if (LED == 6) digitalWrite(LED6, LOW);
  if (LED == 7) digitalWrite(LED7, LOW);
  if (LED == 8) digitalWrite(LED8, LOW);
  if (LED == 9) digitalWrite(LED9, LOW);
}

Recorte e cole esse código, em sua totalidade, para a janela esboço do Arduino, em seguida, clique no botão de upload.

E vejam o quadro preto na parte inferior.

Se você tem uma mensagem de erro vermelho, verifique a porta de comunicação. Você pode fazer isso abrindo-se este menu e desligar o cabo que liga o computador à placa FTDI da porta USB do computador. Olhe para a porta COM desaparece, em seguida, conecte o cabo USB de volta para o computador e selecione essa porta.

Exceto erros, você deve agora ter todos os nove luzes de participantes de forma rápida, desaparecendo efeito brilho. Vá em frente e retire a placa FTDI da placa Arduino, conecte a bateria e ligar o switch para verificá-la. Eu usei esse circuito para criar este vestido cocktail brilhando, mas você pode aplicar este circuito a qualquer coisa que você gostaria – sinta-se livre para usar a sua criatividade!

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Display TFT colorido 2,4 polegadas

09 OUT
2015

Author: Leonardo Dalla Porta


Se você estiver procurando por uma interface gráfica barato para sua Arduino, você está no lugar correto! Nosso Display TFT colorido de 2,4 polegadas tem uma tela de quatro fios de toque resistivo, ainda um slot de micro cartão SD é um conveniente. Para ajudá-lo a ir nós fornecemos alguns códigos de exemplo, que pode ser baixado aqui, neste tutorial

 

Especificações

  • Tamanho da tela: 2,4 polegadas
  • Resolução: 240 x 320
  • Cor LCD: 65k
  • Motorista LCD: ST7781
  • Interface: 8080 bits de dados 8 bits de controle com 4
  • Touchscreen: 4 Fios touchscreen resistiva

Conexões Arduino

Com este shield você nao precisa se preocupar com esta tabela a seguir, porém se for fazer uma “engenharia reversa” aqui está a ligação dos pinos:

Arduino Pin LCD Protetor Pin Uso
3.3V 3.3V Power
5V 5V Power
GND GND Power
A0 LCD_RD Controle LCD
A1 LCD_WR TOUCH_YP Controle LCD / Dados Toque
A2 LCD_RS TOUCH_XM Controle LCD / Dados Toque
A3 LCD_CS Controle LCD
A4 LCD_RST Redefinir LCD
D2 LCD_D2 Dados LCD
D3 LCD_D3 Dados LCD
D4 LCD_D4 Dados LCD
D5 LCD_D5 Dados LCD
D6 LCD_D6 / TOQUE XP Dados LCD / Dados Toque
D7 LCD_D7 / TOQUE YM Dados LCD / Dados Toque
D8 LCD_D0 Dados LCD
D9 LCD_D1 Dados LCD
D10 SD_CS SD Select
D11 SD_DI Dados SD
D12 SD_DO Dados SD
D13 SD_SCK Relógio SD

Tome cuidado para alinhar os pinos corretamente, e assegurar a parte inferior do shield não faz contato com a porta USB Arduino.

Softwares

Examinando os exemplos devem dar uma boa ideia de como usá-los, no entanto, estão sempre dispostos a responder a perguntas relevantes. A biblioteca original foi escrito para funcionar com uma variedade de diferentes controladores e shields. Enquanto isso é conveniente para o uso de placas de forma intercambiável, decidimos tira-lo de volta para apenas o que era necessário para este shield e o controlador de ST7781, ao invés de ampliá-lo para incluir mais um escudo. Isso deve fazer o menor consumo de memória, e o código um pouco mais rápido. Para utilizar o código de demonstração, baixar a biblioteca aqui, e extrair. Copie a pasta “SWTFT-Shield” a partir do arquivo extraído para a pasta Bibliotecas arduino. Você também vai precisar instalar o:

 

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Módulo Rádio Fm Stereo Philips Tea5767

18 SET
2015

Author: Leonardo Dalla Porta

 Se sua ideia é escutar alguma rádio utilizando o Arduino, este é o tutorial certo! Estes módulos TEA5767 são pequenos e usam o protocolo serial I2C e por isso são ideais para conectar a um Arduino.

Conectando ao Arduino

Aqui está a pinagem para o módulo. À esquerda temos a conexões SDA IC2 e SCL que vão aos pinos A5 e A4, respectivamente, sobre o Arduino Uno. O lado direito tem um ANT conexão (antena) para a esquerda e de áudio e ground. Conecte-se todas as conexões conforme a imagem a seguir. Se você quer ser capaz de controlar a afinação do seu rádio (você não tem que, você pode simplesmente definir a frequência no desenho), em seguida, usar uma protoboard para segurar uma potenciômetro (eu usei 10K linear). O potenciômetro deve ser conectado com o controle deslizante central para Arduino pino A0 e um extremo ao GND e outro para + 5V. Girando este potenciômetro ele vai mudar a frequência.

2

O Código

O código é muito simples, toda a ação real está na “setFrequency();” function. No ‘loop’ a leitura analógica e é convertido em a gama de frequências e então arredondado para uma casa decimal, para torná-lo mais fácil de ajustar. A saída do módulo requer amplificação. Um dock para iPod com aux-in irá funcionar bem e fiquei surpreendido com a qualidade do som.

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
#include 
 
unsigned char frequencyH = 0;
unsigned char frequencyL = 0;
 
unsigned int frequencyB;
double frequency = 0;
 
void setup()
{
  Wire.begin();
  frequency = 93.0; //starting frequency
  setFrequency();
  Serial.begin(9600);
}
 
void loop()
{
  int reading = analogRead(0);
  //frequency = map((float)reading, 0.0, 1024.0, 87.5, 108.0);
 
  frequency = ((double)reading * (108.0 - 87.5)) / 1024.0 + 87.5;
  frequency = ((int)(frequency * 10)) / 10.0;
 
  setFrequency();
  Serial.println(frequency);
}
 
void setFrequency()
{
  frequencyB = 4 * (frequency * 1000000 + 225000) / 32768;
  frequencyH = frequencyB >> 8;
  frequencyL = frequencyB & 0XFF;
  delay(100);
  Wire.beginTransmission(0x60);
  Wire.write(frequencyH);
  Wire.write(frequencyL);
  Wire.write(0xB0);
  Wire.write(0x10);
  Wire.write((byte)0x00);
  Wire.endTransmission();
  delay(100); 
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Display do Nokia 5110 no Arduino

16 SET
2015

Author: Leonardo Dalla Porta

 O display

O Módulo de LCD Nokia 5110 utiliza um controlador Philips PCD8544 LCD, foi projetado para telefones móveis, ou seja, celulares.

Operando em 3.3V

Muitos dispositivos que podem ser usados ​​com o Arduino exigem uma fonte de alimentação de 3.3V. Este também é o caso com o Nokia 5110. A melhor maneira de lidar com dispositivos de 3.3V é fazer um Arduino Pro, que pode ser executado em 3.3V.

Graças ao grampo interno do PCD8544 podemos usar um shifter nível muito simples. Quatro resistores limitadores de corrente de 10k pode fazer o trabalho. Quando uma linha de controle LCD é alta, a corrente através do resistor 10k é apenas 40uA, então isso é inofensivo. Note que não pode ler de volta do LCD com este circuito.

Operando em 5V

Porque VDD max = 7V, o controlador pode lidar com PCD8544 5V, mas o Nokia 5110 LCD funciona melhor em 3.3V. Os quatro resistores de 10k evitar estrias no visor LCD.

Ligar Nokia 5110 LCD ao Arduino com 3 fios

lcd Nokia

Ligar Nokia 5110 LCD ao Arduino com 3 fios

Note que o Arduino usa SPI, pinos 11 e 13 são utilizados para permitir que o hardware se comunique.

Código

“Limor Fried” do “Adafruit” criou uma biblioteca que pode ser baixado em  github. A biblioteca um pouco modificada você pode baixá-lo  aqui.
Também instalar a biblioteca Adafruit_GFX.

Impressão LCD com o operador de streaming <<

Com a biblioteca Streaming, podemos usar o operador de streaming << para impressão no console:

Serial << “Olá, \ n”;  em vez de  Serial.println (“Olá! \ N”);

Porque a classe pai PCD8544 é impressão também pode usar o operador de streaming << para impressão no LCD. Aqui está um exemplo:

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
#include 
#include 
#include 
#include 
#include 
 
byte PWMDACpin const = 9; // PWM DAC, apenas os pinos 9 e 10 são permitidos
const byte NokiaSCLKpin = 13; // Compatível com ISP hardware
const byte NokiaDNpin = 11; // Compatível com ISP hardware
const byte NokiaDCpin = 12;
const byte NokiaRESETpin = 10;
 
const caractere LCDcontrast = 55;
int i;
 
// ENSAIOS
#include "Stopwatch.h"
Cronómetro cronômetro (micros);
 
Adafruit_PCD8544 nokia (NokiaSCLKpin, NokiaDNpin, NokiaDCpin, 0, NokiaRESETpin);
Metro LCDinitTimer (2000);
 
void setup (void)
{Serial.begin (9600);
  nokia.begin ();
  nokia.setContrast (LCDcontrast);
  nokia.clearDisplay ();
  nokia &lt;&lt; "Olá, \ n"; // Sem usar F
  nokia &lt;&lt; F ("Save RAM com o Flash biblioteca \ n"); // Usar F para economizar espaço RAM
  nokia.display ();
  // findBestContrast (40, 60, 500);
  nokia.setContrast (LCDcontrast);
}
 
void loop (void)
{Stopwatch.start (); // Test
  nokia.clearDisplay ();
  nokia &lt;&lt; F ("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed não eiusmod tempor") &lt;&lt; i ++;
  nokia.display ();
  se (LCDinitTimer.check ()) nokia.begin (LCDcontrast); // Permitir desconectar e conectar o LCD durante a execução
  stopwatch.stop (); // Test
  Serial &lt;&lt; stopwatch.counter &lt;&lt; "" &lt;&lt; stopwatch.interval &lt;&lt; "" &lt;&lt; stopwatch.maxInterval (1) &lt;&lt; "\ n"; // Test
}
 
vazio findBestContrast (int contrastMin, int contrastMax, int _delay)
{For (int contraste = contrastMin; contraste &lt;= contrastMax; contraste ++)
  {Nokia.clearDisplay ();
    nokia.setContrast (contraste);
    Nokia &lt;&lt; F ("12345678901234");
    nokia &lt;&lt; F ("12345678901234 \ n"); // Bug: "\ n" depois de 14 personagens cria uma linha em branco
    nokia &lt;&lt; F ("bla bla bla bla bla bla \ n");
    Nokia &lt;&lt; contraste;   
    nokia.display ();
    atraso (_delay);
  }
}

 

O contraste deve ser definido separadamente para cada LCD. Com a função findBestContrast (), o valor de contraste correto pode ser determinado.

 

 Biblioteca PCD8544 com SPI hardware

O Adafruit_PCD8544 biblioteca usa a comunicação com o LCD por SPI software; Por conseguinte, a biblioteca é bastante lento. No meu exemplo, escrevendo a tela de LCD completo leva 31ms.

Snigelen criou uma biblioteca de hardware SPI PCD8544, consulte a mesma aqui.

Conferindo

  • Não use “\ n” após uma linha de 14 caracteres, isso cria uma linha em branco extra.
  • Não use endl, << endl; leva 60 bytes mais espaço do que o programa << “\ n”;
  • O drive LCD PCD8544 pode ser danificado se não for reinicializado corretamente.

MAX7219 e display 7 segmentos no arduino

11 SET
2015

Author: Leonardo Dalla Porta

Este circuitos integrado da Maxim são para a controle tanto de Leds individuais, de 64, ou até 8 dígitos de display de 7 segmentos. Este trabalha com a comunicação SPI como escravo que pode ser controlado a partir do Arduino usando apenas 3 dos pinos de saída digitais.

 

 

 

Ligações:

Aqui é um esquema básico para a conexão do MAX7219:

 

Não há ainda nenhum Led no esquema. Portanto logo abaixo mostramos as ligações no display de 7 segmentos:

 

Seg7Matrix

 

 

Além do MAX7219 e dos Leds você só precisa de três componentes externos: dois capacitores (C1; C2) e um resistor (RSet). Os capacitores estão lá para suprimir sinais de ruído introduzidas através das linhas de fornecimento de energia. Estes tipos de erros são realmente difíceis de aparecer. Ambos os capacitores devem ser colocados o mais próximo possível do V+ os e Gnd e pinos do MAX7219. O resistor RSet é responsável por estabelecer um limite máximo para a corrente que alimenta os Leds. O MAX72XX tem de ser alimentado com +5V. Para uma única matriz de LED é possível utilizar a +5V fornecimento do Arduino. Se você adicionar mais de uma matriz para o Arduino você provavelmente vai precisar de uma fonte de alimentação externa.

 

O Código:

Este código simplesmente para termos uma base é uma especie de “Hello Word!” Junto ao código temos a biblioteca, estão disponíveis neste link através do GitHub.

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Display 7 segmentos no Arduino

11 SET
2015

Author: Leonardo Dalla Porta

O display de sete segmentos é um dispositivo bastante simples. Na verdade são 8 LEDs (o ponto decimal é o oitavo). Ele pode ser disposto de modo que diferentes combinações podem ser usadas para fazer dígitos numéricos. A seguir iremos mostrar-lhe como ligar e utiliza-lo com um Arduino.

 

 

Você vai precisar de:

  • Display de 7 segmentos
  • Arduino
  • Protoboard
  • Jumpers

 

Montagem:

 

Para ter um brilho satisfatório e não queimar seu led, voce pode estar calculando o valor dos resistores. Conectando esses LEDs diretamente ao Arduino IO pinos acabará por queimar-los para fora! Conecte-se pinos de LED 3 e 8 para GND. Use um resistor entre cada uma das outras ligações para o seu Arduino.

Aqui estão os mapeamentos de pino do visor, note que ânodo exibe comuns terão revertido fiação:

 

seven_segment_led_pinsled-diagram-37seg-2

 

 

 

 

 

 

Use a sua protoboard para fazer as conexões entre o display e seu Arduino:

 

Pino Arduino  Pinos do Display
 2 7 (A)
 3 6 (B)
 4 4 (C)
 5 2 (D)
 6 1 (E)
 7 9 (F)
 8  10 (L)
 9 5 (DP)

 

 

 

Código

Este exemplo software Arduino faz a contagem regressiva de 9 a 0. Esta é uma versão agradável, compacto que utiliza um array de 2 dimensões para manter os padrões de bits de LED, e “para” loops para fazer as coisas.

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
// 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)
 
// Definir os padrões dígitos LED, 0-9
// Note que esses padrões são para catódicos monitores comuns
// Para ânodo exibe comuns, alterar as 1 do a 0 e 0 a 1 de
// 1 = LED, 0 = LED apagado , nesta ordem:
 
//                                    Arduino pin: 2,3,4,5,6,7,8
byte seven_seg_digits[10][7] = { { 1,1,1,1,1,1,0 },  // = 0
                                                           { 0,1,1,0,0,0,0 },  // = 1
                                                           { 1,1,0,1,1,0,1 },  // = 2
                                                           { 1,1,1,1,0,0,1 },  // = 3
                                                           { 0,1,1,0,0,1,1 },  // = 4
                                                           { 1,0,1,1,0,1,1 },  // = 5
                                                           { 1,0,1,1,1,1,1 },  // = 6
                                                           { 1,1,1,0,0,0,0 },  // = 7
                                                           { 1,1,1,1,1,1,1 },  // = 8
                                                           { 1,1,1,0,0,1,1 }   // = 9
                                                           };
 
void setup() {                
  pinMode(2, OUTPUT);   
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  writeDot(0);  // start with the "dot" off
}
 
void writeDot(byte dot) {
  digitalWrite(9, dot);
}
 
void sevenSegWrite(byte digit) {
  byte pin = 2;
  for (byte segCount = 0; segCount &lt; 7; ++segCount) { digitalWrite(pin, seven_seg_digits[digit][segCount]); ++pin; } } void loop() { for (byte count = 10; count &gt; 0; --count) {
   delay(1000);
   sevenSegWrite(count - 1); 
  }
  delay(4000);
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Ci Pcf8574 Expansor De Portas I/o 8 Bits I2c Para Arduino

01 SET
2015

Author: Leonardo Dalla Porta

Você que já criou projetos grandes, ou se está pensando que seu Arduino terá poucas portas para comunicar com seus dispositivos, provavelmente um expansor de portas é a melhor solução para seu caso! Já pensou transformar 2 portas de comunicação do Arduino em 8 portas I\O, além disso, podemos conectar 8 expansores pela mesma porta de comunicação, portanto, podemos ter com 8 Cis, cada um expandindo 8 portas (8*8=) 64 portas digitais!

Muitas vezes a eletrônica digital se limita por algum motivo, esse motivo geralmente se ocasiona pela falta de portas, como já mencionamos o expansor de portas aumenta esse numero, para cada Ci, 8 portas digitais, dessa forma podemos controlar muitas coisas utilizando somente dois pinos do arduino, sim, somente os pinos da comunicação I2C, desta forma tudo fica mais fácil, mas deixando a conversa de lado vamos a pratica!

Você vai precisar de:

  • -Um CI expansor de portas PCF8574

  • -Um Arduino

  • -Dois resistores de 2,2k

  • -Oito Resistores de 10k

  • -Um capacitor cerâmico de 100nF (Funciona sem… (Mas coloque))

  • -Jumpers!

  • -Protoboard

Montagem!

Para este CI Expansor de Portas, precisaremos de um pouco de conhecimento com eletrônica, além de ter os materiais mencionados acima, assim você poderá montar todo o circuito, lembrando que este CI trabalha com suas portas digitais de 0v e 5v, se for ligar leds ou relés lembre de limitar a corrente utilizando resistores, os resistores mencionados na imagem abaixo podem ser modificadas desde que tenham valores bem próximos, caso contrario seu Circuito integrado poderá se queimar. Este esquema foi desenvolvido no software: CadSoft Eagle 6.4.0, podendo não ser compatível com outras versões. Download do esquema para Eagle neste link.

1

 

Pinagens do CI:

PCF8574P

 

Código

Após montar o circuito, faça o download desta biblioteca deste código instale, e faça upload no Arduino e veja se todos os leds estão acendendo sequencialmente, se sim, o circuito está ok! Mas para entendermos um pouco do código:

Primeiramente, precisamos adicionar a biblioteca:

#include <PortExpander_I2C.h>
#include <Wire.h>

Após definimos, que o nosso ci está trabalhando na porta 0x21:

PortExpander_I2C pe(0x21);

Já dentro da Setup iniciamos o Expansor de portas:

pe.init();

No void loop, configuramos qual pinos queremos acender, no nosso caso efetuamos duas operações para acender um a cada loop:

for( int i = 0; i < 7; i++ )

{

pe.digitalWrite(i, HIGH);

delay(200);

pe.digitalWrite(i, LOW);

}

for( int i = 7; i > 0; i– )

{

pe.digitalWrite(i, HIGH);

delay(200);

pe.digitalWrite(i, LOW);

}

 

Qualquer duvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Autor: Leonardo D. Porta

Matriz De Leds 8×8 Com Max7219

12 MAIO
2015

Author: Leonardo Dalla Porta

 

Pra todos os lados podemos ver telas, display exibindo algum tipo de informações, é quase impossível passar um dia sem ver alguma tela, ai não ser que você viva no meio do mato, ai vamos dar uma exceção. É com este pensamento que apresentamos a vocês o Módulo Matriz de Leds 8×8 com Max7219, modelo com uma incrível praticidade.

Por que Matriz de Leds?

Quem nunca estudou em matemática “Matrizes e determinantes”? A ideia de matriz vem do fato de este display conter 64 leds posicionados e alinhados lado a lado fechando assim 8 e 8 leds de perímetro, completando assim um quadrado, esse sistema é muito utilizado em diversas áreas, por exemplo nas impressora matriciais (Derivada de matriz) temos um cabeçote e neste cabeçote temos um certo números de agulhas, assim para escrever uma letra ele sequencia as agulhas até formar a letra, por isso o alto nível de ruido dessas impressoras.

Os testes

Para testar esta Matriz led, desenvolvemos um código especifico com o alfabeto inteiro de “a” à “z”, para imprimi-los basta escrever o seguinte comando respectivo da letra desejada (Onde I a letra respectiva desejada).

lc.setRow(0, 0, I[0]);
lc.setRow(0, 1, I[1]);
lc.setRow(0, 2, I[2]);
lc.setRow(0, 3, I[3]);
lc.setRow(0, 4, I[4]);

Pode ser trabalhoso, mas foi a forma mais pratica que era possível.

  • A Biblioteca utilizada está disponível aqui

  • O código fonte está disponível aqui

Hardware

Como este Circuito integrado trabalha em SPI, trabalhamos apenas com 3 fios de comunicação o Din, CS, CLK, respectivamente ligados aos pinos digitais do Arduíno: 12, 10, 11. Ou como na imagem a seguir:

Untitled Sketch_bb

Espero que tenham entendido e compreendido, qualquer duvida deixe seu comentário, estaremos dispostos a responder…

Att. Leonardo Dalla Porta

Controlando um Lcd 16×2

24 MAIO
2014

Author: Nadiel Comércio

Hoje reuni algumas informações muito úteis e funcionais sobre este incrível display 16×2; vamos aprender como mostrar caracteres na tela.

Foi utilizado para este exemplo:

1x Arduino UNO

1x LCD 16×2

1x Potenciômetro 10KΩ

1x Protoboard

Alguns Jumpers Macho x Macho

 

Antes de começar, faça os downloads abaixo:

Pronto vamos a pinagem do LCD:  Lcd_0

pantalla-lcd-16x2-con-luz-trasera-arduino-atmel-pic-3109-MLM3986108728_032013-F

Na parte frontal do LCD você encontrará a numeração dos pinos, encontrando apenas o número 1(à esquerda) e o número 16(à direita), indicando que a contagem dos pinos vai de 1 a 16 da esquerda, para a direita.

Tenho percebido que alguns fabricantes deste lcd tem colocado invertido a numeração, onde mostra o pino 1 seria o 16, e onde mostra o 16 seria 0 1; e ainda existem algumas diferenças nas escritas na placa; alguns mostram VSS outros mostram GND, ou V0 por VEE… Mas isso não é importante, pois vai funcionar da mesma maneira o que temos que prestar atenção é na montagem conforme a tabela abaixo:

 

tabelaLCD

 

 

Datasheet do LCD: No Datasheet podemos encontrar informações sobre o LCD, e saber quais os pinos vamos utilizar para fazer a montagem do circuito do LCD com o Arduino!

Nesta nossa demonstração, não utilizaremos os pinos 7, 8, 9 e 10.

Após consultar o Datasheet, faça a  montagem do circuito conforme a figura abaixo:

 

 Montagem do Circuito: LCD + Arduino:

EfeitoscomLCD_bbObs: O potenciômetro de 10 K é utilizado para regular o contraste da tela, pode ser substituído por resistores;

 

 

// Código para Arduino

#include <LiquidCrystal.h> //Inclui a biblioteca do LCD

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Configura os pinos do Arduino para se comunicar com o LCD

int temp; //Inicia uma variável inteira(temp), para escrever no LCD a contagem do tempo

void setup()
{

lcd.begin(16, 2); //Inicia o LCD com dimensões 16×2(Colunas x Linhas)
lcd.setCursor(0, 0); //Posiciona o cursor na primeira coluna(0) e na primeira linha(0) do LCD
lcd.print(“Olá Mundo”); //Escreve no LCD “Olá Mundo!”
lcd.setCursor(0, 1); //Posiciona o cursor na primeira coluna(0) e na segunda linha(1) do LCD
lcd.print(“Meu Texto”); //Escreve no LCD “Meu Texto”

}

void loop()
{

lcd.setCursor(13, 1); //Posiciona o cursor na décima quarta coluna(13) e na segunda linha(1) do LCD
lcd.print(temp); //Escreve o valor atual da variável de contagem no LCD
delay(1000); //Aguarda 1 segundo
temp++; //Incrementa variável de contagem

if(temp == 600) //Se a variável temp chegar em 600(10 Minutos),…
{
temp = 0; //…zera a variável de contagem
}

}

 

Gostou?  Confira em nossa loja virtual, no Mercado Livre, NADIEL COMÉRCIO este produto e mais outros componentes eletrônicos.

 

 

 

 

 
WordPress主题
WordPress Themes