medigaco_wp

Utilizando um display de cristal líquido LCD com o arduino.

Utilizando um display de cristal líquido LCD com o arduino.

Teoria sobre LCD displays de cristal líquido.

 

Os LCD são formados por um material que se denomina cristal líquido. As moléculas desse material são distribuídas entre duas lâminas transparentes polarizadas. Essa polarização é orientada de maneira diferente nas duas lâminas, de forma que estas formem eixos polarizadores perpendiculares, como se formassem um ângulo de 90º. As moléculas de cristal líquido são capazes de orientar a luz.
A base da iluminação de um LCD é a luz fornecida por uma lâmpada CCFL ou um conjunto de LEDS. Nos displays monocromáticos, cada ponto da tela corresponde a um ponto da imagem.
Um pixel é a menor unidade de uma imagem, o número de pixels no display determina a resolução do LCD. 

 

LCD monocromático, Chinmayananda Das  – Monitor and Control of Greenhouse Environment
Os LCDs são amplamente usados em conjunto com micro controladores para mostrar a informação visualmente, os LCDs possuem uma tabela de caracteres ASCII e símbolos matemáticos em sua memória.
Display com back light azul – 20 colunas e 4 linhas
Caracteres padrões contidos na memória do LCD – (Data Sheet MGD2004D-FL-YBS)

Sinais Enviados para o LCD

O display requer três sinais de controle que devem ser enviados pelo micro controlador.
Enable (E) – Este sinal permite acessar o display através das instruções R/W e RS.
Quando enable tem nível lógico baixo o display ignora os sinais vindos de R/W e RS, quando enable tem nível lógico alto o display checa os estados desses dois controladores, e responde de acordo.
Read/Write (R/W) Ler e Escrever- Determina a direção em que os dados fluem entre o LCD e o micro controlador, quando R/W tem nível lógico baixo os dados enviados pelo micro controlador são escritos no LCD, quando R/W tem nível lógico alto os dados são lidos do LCD.
Register select (RS) Seletor de Registros – De acordo com os dados nesse controlador o display interpreta o tipo de dado que está sendo enviado pelo micro controlador.
Quando RS tem nível baixo uma instrução está sendo escrita no display, quando o nível é alto um caractere ou mais está sendo escrito.
E = 0 Acesso ao LCD desabilitado
  = 1 Acesso ao LCD habilitado
R/W = 0 Escrevendo dados no LCD
  = 1Lendo dados do LCD
RS= 0 Uma instrução foi enviada ao LCD
    = 1 Um caractere foi enviado ao LCD
Escrevendo dados no LCD
Enviar dados para o display requer alguns passos:
1) Setar o bit R/W bit como 0 (zero).
2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).
3) Enviar dados para as linhas de dado.
4) Setar o bit E como 1 (um).
5) Setar o bit E como 0 (zero).
Lendo dados
1) Setar o bit R/W como 1 (um)
2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).
3) Ler dados das linhas de dados
4) Setar o bit E como 1 (um).
5) Setar o bit E como 0 (zero).
 
Pinagem do LCD
Display  20×4 dimensões e pinagem (Data Sheet MGD2004D-FL-YBS – 26 de junho de 2006)
 

 

Display CD 20×4 – descrição dos pinos. (Data Sheet MGD2004D-FL-YBS – 26 de junho de 2006)
Inicialização do LCD
Antes de usar o display para nosso objetivo, ele deve ser inicializado via reset interno ou pelo envio de um conjunto de instruções. Como nosso projeto foi concebido com a idéia de conectar o display a um micro controlador, escolhemos a inicialização por instruções.
Inicializar um display LCD com instruções é um processo simples, abaixo temos um fluxograma que indica todos os passos.
Fluxograma de inicialização por instruções do Display LCD (Ajay Bhargav – http://www.8051projects.net/)
De acordo com o fluxograma podemos observar que o display LCD é inicializado conforme a seguinte seqüência
1)    Enviar o comando 0x30 – Usando a interface de 8 bits
2)    Esperar 20ms
3)    Enviar o comando 0x30 – Usando a interface de 8 bits
4)    Esperar 20ms
5)    Enviar o comando 0x30 – Usando a interface de 8 bits
6)    Esperar 20ms
7)    Enviar o conjunto de instruções.
8)    Enviar o comando 0x01 para limpar a tela
Definir o modo de incremento.


Interface com o Arduino
Prossiga montando seu circuito de acordo com o esquema abaixo.
LCD 16×2 ou 20×4 possuem físicamente os mesmos pinos, o que muda durante seu uso são as instruções enviadas aos mesmos e é claro o limite de linhas e colunas.
O potênciometro é utilizado para ajustar o contraste dos caracteres no display, o regule conforme seu próprio critério, as setas >> indicam para que pinos do arduino os pinos do LCD devem ser ligados, não se esqueça de verificar se o datasheet do seu LCD é compatível com o meu esquemático.
O código
 Código fonte: (em itálico)
 #include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
/*
Pino 12 = RS
Pino 11 = EN
Pino 05 = D4
Pino 04 = D5
Pino 03 = D6
Pino 02 = D7
*/
void setup()
{
//lcd.begin(cols, rows)
lcd.begin(20, 4); // Tipo de LCD usado no meu caso de 20 colunas por 4 linhas
lcd.setCursor(0, 0); // O Cursor iniciara na coluna zero linha 0
lcd.print(”    Central AVR!”);
lcd.setCursor(0, 1); // O Cursor iniciara na coluna zero linha 1
}
void loop()
{
//lcd.setCursor(col, row)
lcd.setCursor(0, 2); // O Cursor iniciara na coluna zero linha 1
lcd.print(millis()/1000); // Função para contar em segundos
lcd.print(”  segundos”);  // Exibe e atualiza o tempo desde a entrada no loop
}
O código acima é escrito em linguagem C, e faz uso de bibliotecas integradas do arduino como por exemplo a função LiquidCrystal lcd(); que seta os pinos do lcd que serão conectados ao arduino. 
Na pasta de instalação do arduino subpasta reference podemos consultar uma explicação básica em inglês de todas as funções padrões, vou pegar a referência LiquidCrystal função LiquidCrystal() para exemplificar.
LiquidCrystal()

 

Description

 

Creates a variable of type LiquidCrystal. The display can be controlled using 4 or 8 data lines. If the former, omit the pin numbers for d0 to d3 and leave those lines unconnected. The RW pin can be tied to ground instead of connected to a pin on the Arduino; if so, omit it from this function’s parameters.

 

Syntax

 

LiquidCrystal(rs, enable, d4, d5, d6, d7)
LiquidCrystal(rs, rw, enable, d4, d5, d6, d7)
LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
LiquidCrystal(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)

 

Parameters

 

rs: the number of the Arduino pin that is connected to the RS pin on the LCD
rw: the number of the Arduino pin that is connected to the RW pin on the LCD (optional)
enable: the number of the Arduino pin that is connected to the enable pin on the LCD
d0, d1, d2, d3, d4, d5, d6, d7: the numbers of the Arduino pins that are connected to the corresponding data pins on the LCD. d0, d1, d2, and d3 are optional; if omitted, the LCD will be controlled using only the four data lines (d4, d5, d6, d7).
 Neste procedimento foi utilizado um display de LCD de 20×4 com comunicação a 4 fios, portanto foi utilizada a função LiquidCrystal(rs, enable, d4, d5, d6, d7); Com os devidos valores substituídos pelos pinos do arduino.
LiquidCrystal(rs, enable, d4, d5, d6, d7);
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 
Sendo:
 Pino 12 = RS
Pino 11 = ENABLE
Pino 05 = D4
Pino 04 = D5
Pino 03 = D6
Pino 02 = D7
O resultado final pode ser visto no vídeo abaixo

Posted by medigaco_wp in Arduino, 5 comments
PRIMEIRO PROJETO COM O ARDUINO, PISCA LED.

PRIMEIRO PROJETO COM O ARDUINO, PISCA LED.

INICIANDO COM O ARDUINO, FAZENDO UM LED PISCAR

A plataforma arduino vem se mostrando a de mais fácil aprendizado e a de maior poder, procurando pela internet podemos encontrar um miríade de projetos e instruções básicas, para não fugir do padrão começarei da forma mais básica possível é o que é mais básico do que fazer um led piscar?

Observe a imagem abaixo e monte o circuito exatamente como apresentado.

Não se esqueça que o lado chanfrado do LED é o negativo e portanto deve ser ligado ao GND (terra) e o lado positivo deve ser ligado a um resistor para limitar a corrente algo em torno de 10mA a 20mA  procure não ultrapassar o último limite. Para calcular a corrente utilize a lei de OHM.

Código fonte: (em itálico)

#define LED 13

void setup()
{
pinMode(LED, OUTPUT); //seta o pino como output
}

void loop()
{
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite (LED, LOW);
delay(1000);
}

O código acima é escrito em linguagem C, e faz uso de bibliotecas integradas do arduino como por exemplo a função pinMode que seta o tipo de função do pino a ser usado, como um LED é um elemento de saída ele é setado como OUTPUT.
Na pasta de instalação do arduino subpasta reference podemos consultar uma explicação básica em inglês de todas as funções padrões, vou pegar a função digitalWrite para exemplificar.

digitalWrite()

Description

Write a HIGH or a LOW value to a digital pin.
If the pin has been configured as an OUTPUT with pinMode(), its voltage will be set to the corresponding value: 5V (or 3.3V on 3.3V boards) for HIGH, 0V (ground) for LOW.
If the pin is configured as an INPUT, writing a HIGH value with digitalWrite() will enable an internal 20K pullup resistor (see the tutorial on digital pins). Writing LOW will disable the pullup. The pullup resistor is enough to light an LED dimly, so if LEDs appear to work, but very dimly, this is a likely cause. The remedy is to set the pin to an output with the pinMode() function.
NOTE: Digital pin 13 is harder to use as a digital input than the other digital pins because it has an LED and resistor attached to it that’s soldered to the board on most boards. If you enable its internal 20k pull-up resistor, it will hang at around 1.7 V instead of the expected 5V because the onboard LED and series resistor pull the voltage level down, meaning it always returns LOW. If you must use pin 13 as a digital input, use an external pull down resistor.

Syntax

digitalWrite(pin, value)

Parameters

pin: the pin number
value: HIGH or LOW

digitalWrite()

Escreve ALTO(HIGH) ou BAIXO(LOW) a um pino previamente definido digitalWrite(pin, value) 

Neste exemplo:
digitalWrite(LED, HIGH) fara com que o LED se acenda
Para criarmos um efeito de pisca acendemos o LED aguardamos um tempo delay(1000) e o apagamos, para apagar usaremos digitalWrite(LED, LOW).

PARTE 2: Usando um botão para ligar um LED.

Novamente monte o circuito de acordo com o apresentado abaixo (resistor do botão de 10K ohms):

Código fonte: (em itálico)

#define LED 13 // Define LED como o pino 13
#define BOTAO 7 // Define BOTAO como o pino 7

int var = 0; // Var é a variável que armazenará o estado do botao(pressionado ou não)

void setup()
{
pinMode(LED, OUTPUT); // Define o LED como saída
pinMode(BOTAO, INPUT); // Define a chave como entrada
}

void loop()
{
var = digitalRead(BOTAO); // Lê o estado do botão pressionado = 1 solta = 0

if (var==HIGH) { // Se 1 ou Alto ou 5 Volts
digitalWrite(LED, HIGH); // O LED acende
}
else{ // Senão
digitalWrite(LED,LOW); // O LED fica apagado
}
}

Neste exemplo foi adicionado um mecânismo de entrada de dados digitais o BOTAO ou CHAVE,
como o botão é usado para informar um estado ele deve ser declarado como INPUT.
pinMode(BOTAO, INPUT); // Define a chave como entrada
Não basta somente declarar o botão como uma entrada é necessário também ler o estado desse botão
que pode ser Alto ou Baixo / High ou Low. Para lermos o estado do botão usamos a função digitalRead(BOTAO).
var = digitalRead(BOTAO); // Lê o estado do botão pressionado = 1(HIGH) solto = 0 (LOW)

Como funciona a chave ou botão? 
Isso é muito simples, quando a chave está aberta a tensão fica entre seus terminais portanto no pino 7 do arduino ( o fio que vai par ao pino 7 é o mesmo que está ligado ao voltimetro na figura) teremos 0 Volts, agora quando fechamos a chave a tensão de 5 Volts fica entre os pinos do resistor portanto nível alto no pino 7.
Para melhor entendimento veja a imagem abaixo:



Resultado final

Caso ainda não esteja familiarizado com a linguagem C recomendo procurar algumas apostilas pela internet ou consultar o seguinte livro  “Teach Yourself C++ in 21 Days” em inglês.
No site www.4shared.com pode-se encontrar muita coisa mesmo, sempre vale a pena olhar nele até mesmo antes do google.

 

Posted by medigaco_wp in Arduino, 2 comments
Arduino Instalando e configurando

Arduino Instalando e configurando

O arduino é uma das plataformas mais versáteis de se utilizar, com preço acessível, uma incrível documentação e com diversos fóruns pelo mundo a fora não há como se arrepender ao embarcar nesta jornada de aprendizado.

Arduino é uma plataforma “open source” baseada em uma placa simples com INPUTS E OUTPUTS (Entradas e Saídas) vulgo I/O. A placa pode ser comprada em diversos locais, sendo a versão oficial encontrada em www.arduino.cc que alias é o site ofícial do Arduino.

Algumas das vantagens do arduino:

Funciona em várias plataformas como Windows, Linux e Mac OS.
É programável pela porta USB, ao contrário de vários outros dispositivos que ainda utilizam a já ultrapassada porta serial (COM).
O hardware é barato, custando por volta de R$70,00 ( no mercadolivre).
A comunidade é muito atuante, então existem diversas pessoas dispostas a te ajudar.

Instalando o Arduino:

O primeiro passo é baixar o software no site oficial http://arduino.cc/en/Main/Software escolha a versão para o seu sistema operacional, no meu caso Windows (XP).
Após baixar o arquivo compactado extraia-o de preferência em um lugar de fácil como C:.
Ligue seu arduino a porta usb do seu micro e espere o aviso do Windows que um novo hardware foi encontrado, e indique o seguinte caminho para a instalação do driver D:AVRARDUINOArduinoarduino-0022drivers

Depois de instalado vá ao seu gerenciador de dispositivo e veja em qual porta de comunicação seu Arduino foi instalado.

Pronto agora podemos abrir o compilador do Arduino (arduino.exe), se você instalou em C: ele estará nesse endereço C:ARDUINOArduinoarduino-0022arduino.exe
Precisamos configurar a porta que vimos no gerenciador de dipositivo no compilador para isso iremos em

Tools >Serial Port



Depois selecione o modelo do seu Arduino em Tools>Board ( no meu caso uso um UNO).
Pronto já terminamos todas as configurações necessárias agora vamos fazer um programinha simples para piscar um LED apenas para testar se tudo deu certo.
Copie e cole este código (em itálico) no seu compilador ou preferencialmente o digite:

#define LED 13

void setup()
{
pinMode(LED, OUTPUT); //seta o pino como output
}

void loop()
{
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite (LED, LOW);
delay(1000);
}

Este código apenas fara o LED que já existe na placa do Arduino (indicado pela letra L) piscar alternadamente a cada 1 segundo.
Para confirmar se o código funciona vá em Sketch >Verify Compile se ocorrer algum erro, procure por erros de digitação ou cole o código.
Para enviar o código para o seu Arduino vá em File>Upload to I/O Board
Se nenhum erro ocorrer o LED começará a piscar alternadamente a cada 1 segundo.

Qualquer dúvida utilizem os comentários.

Posted by medigaco_wp in Arduino, 1 comment
USANDO O ECLIPSE COMO IDE PARA O WINAVR

USANDO O ECLIPSE COMO IDE PARA O WINAVR

Por que usar o Eclipse como IDE para o WINAVR?
Eclipse é uma IDE muito moderna, com muitas funções. E sendo uma IDE de código aberto ela é muito suportada e documentada por muita gente e muitas outras características como o plugin que usaremos existem para estender ainda mais sua funcionalidade.
Outra grande vantagem é escapar do incomodo makefiles, usando o Eclipse sua aplicação é automaticamente criada e até gravada no microcontrolador com o auxílio do AVRdude.
Para usarmos o ECLIPSE utilizaremos um plugin que nos permite utilizar o AVR-GCC como compilador. Mais informações sobre o plugin podem ser achadas na página do desenvolvedor Thomas Holland.
 
Instalando o WinAVR, Eclipse e o plugin.
Faça download dos seguintes softwares:
ECLIPSE
PLUGIN PARA UTILIZAR O WINAVR-GCC COMO COMPILADOR PARA O ECLIPSE
WINAVR
JAVA
O primeiro passo é instalar o WinAVR no diretório padrão c:winavrxxxxx o procedimento é de sempre clique em avançar/ok até a conclusão da instalação.
Agora instalaremos o ECLIPSE, ele não vem com um setup é só extrair em qualquer local. Por preferências pessoais eu instalei na pasta C:
O plugin também não requer nenhuma atenção especial, somente extraia ele na pasta do ECLIPSE  que no meu caso é C:eclipse-cpp-helios-win32eclipse
A maioria dos computadores já possui a run time do JAVA instalada, se você não tiver ou caso não saiba que tem é só executar o executável na pasta do Eclipse, caso uma mensagem de erro aparecer instale o JAVA e novamente tente abrir o ECLIPSE o procedimento para instalar o JAVA é o de sempre clique em avançar/ok até a conclusão da instalação.
Agora poderemos começar a trabalhar com nossa nova IDE, vá na pasta do ECLIPSE e execute o programa eclipse.exe.
Assim que o programa carregar clique me  File > New e então selecione C Project.
Selecione AVR Cross Target Application, no lado direito você verá o AVR-GCC como Toolchain, em Project name  coloque pisca e clique em next para mudar para a próxima janela.

 

Na nova janela só desmarque a opção de DEBUG e clique em finish.
Mudanças posteriores serão feitas em Project > Properties.
A janela de trabalho será está:
Nosso próximo passo e criar um arquivo.c para darmos inícios ao trabalho, clique com o botão direito em pisca e vá em New > File e digite como nome pisca.c
Clique agora no menu superior Project > Properties
E faça as seguintes alterações:
Selecione C/C+++  Build na lista a esquerda
A sua direita mude a configuração para Release como mostrado na figura abaixo

 

No menu a esquerda clique em AVR > Target Hardware e escolha o micro que você deseja trabalhar e seu clock. No meu caso será um ATmega16 a 1Mhz.
Agora no mesmo menu a esquerda clique em AVR > AVRDude clique em edit e selecione o seu programador ou o protocolo que ele segue, novamente no meu caso será o STK500, conforme imagem abaixo:

 

 

Clique em OK e OK novamente para sair das configurações.
Cole o seguinte código no editor:
#include <avr/io.h>
#include <avr/delay.h> // Header da função delay
void main (void)
{
DDRB=0xFF; // Data Direction Register porta D setada como output
                while(1) // O bloco do while se repetira eternamente enquanto for verdadeiro
                {
                               for (signed int i=1; i<=128; i*=2) // Inicia uma contagem e executa as declarações do bloco enquanto verdadeiro
                               {
                                               PORTB=i;
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                               }
                               for (signed int i=1; i<=128; i*=2) // Inicia uma contagem e executa as declarações do bloco enquanto verdadeiro
                               {
                                               PORTB=~i; // ~ comlementa os bits da porta. Exemplo i=0011   ~i=1100
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                                               _delay_loop_2(5000);
                               }
                }
}
Salve tudo clicando no ícone Save All e depois vá em Project > Build Configurations > Set Active > Release e finalmente  compile clicando no ícone Build All. Aparecerá 3 Warnings, as desconsidere.
Agora você tem duas opções ou grava no microcontrolador utilizando direto o AVRDude pelo eclipse ou use o AVR Studio ou outro programa similar. Para gravar direto com o AVRDude clique no ícone
 
Resultado final no meu Kit STK500
Video YouTube:

 

Posted by medigaco_wp in Arduino, 0 comments