Como usar e testar o LCD 18x2 no arduíno

Olá, amantes de robótica!
Neste post irei mostrar como ligar o LCD no Arduíno e como testá-lo.

 


Vamos ao material que precisamos:


Qtd Itens:
1 - Arduino UNO ou qualquer outra versão;
1 - LCD 18x2;
1 - Potenciômetro;
1 - Protoboard;
16 - Jumpers (Fios).


Não sabe onde comprar as peças, confira esse post: onde comprar arduino e componentes



Vamos à montagem:

Basta fazer as mesmas conexões da imagem abaixo:

(clique na imagem pra ampliá-la)
O potenciômetro é necessário para controlar o brilho da tela, para deixar a letra legível.


Veja as fotos do projeto:






O mais importante, o código fonte:

Não sabe programar? Então acesse: Como programar em Arduíno, fazer robôs e projetos diversos


Atenção:

Para o código fonte funcionar é necessário baixar as bibliotecas: Baixar Library.
 /*   
  >>>>> Criando Robô Com Arduino <<<<<   
  ##### Robôs, Projetos e Tutoriais! #####  
  .:: Site principal: http://www.CriandoRoboComArduino.com/     
  .:: Site secundário: http://www.TestCriandoRoboComArduino.com/  
  ========== IMPORTANTE ==========   
  O código está livre para usar, citar, alterar e compartilhar,  
  desde que mantenha o site como referência.   
  Obrigado.  
  --------------------------------------------------------------------------------------------------  
  Projeto: Como usar e testar o LCD 18x2 no arduíno    
  ---------------------------------------------------------------------------------------------------  
 */   
  // Inclusão de bibliotecas.   
  #include <LiquidCrystal.h> // incluir biblioteca de manipulação do monitor LCD 16x2   
  //Variáveis para uso da função do lcd   
  LiquidCrystal lcd(9, 11, 5, 4, 3, 2); // ligando o display no arduino   
  int pinoPotenciometro = 0;    // controle do brilho do lcd   
  long valorPotenciometro = 0;   // controle do brilho do lcd   
  // Executado na inicialização do Arduino   
  void setup(){   
  lcd.begin(16, 2); // inicia o lcd   
  Serial.begin(9600); // inicializa a comunicação serial para o display LCD   
  }   
  // Loop pincipal do Arduino   
  void loop(){   
  valorPotenciometro = analogRead(pinoPotenciometro); // controle do brilho do LCD   
  lcd.clear();// limpa o que está escrito no LCD   
  lcd.setCursor(0,0); // aqui ele escreverá na primeira posição da primeira linha    
  lcd.print("Linha de cima"); //escrevendo no LCD   
  delay(1000); //espera para poder trocar a escrita   
  lcd.clear();// limpa o que está escrito no LCD   
  lcd.setCursor(0,1); // aqui ele escreverá na primeira posição da segunda linha    
  lcd.print("linha de baixo"); //escrevendo no LCD   
  delay(1000); //espera para poder trocar a escrita   
  lcd.clear();// limpa o que esta escrito no LCD   
  lcd.setCursor(0,0); // aqui ele escreverá na primeira posição da primeira linha    
  lcd.print("www.CriandoRobo"); //escrevendo no LCD   
  lcd.setCursor(0,1); // aqui ele escreverá na primeira posição da segunda linha    
  lcd.print("comArduino.com"); //escrevendo no LCD   
  delay(3000); //espera para poder trocar a escrita   
  }   
 /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::  
   >>>>> Acesse os sites: <<<<<  
   .:: Robôs, Projetos e Tutoriais  
     http://www.CriandoRoboComArduino.com/     
   .:: Testes dos robôs, noticias sobre robótica e muito mais  
     http://www.TestCriandoRoboComArduino.com/  
   >>>>> Inscreva-se nos canais no Youtube: <<<<<  
   .:: Vídeos dos robôs, projetos e tutoriais  
     Criando Robô Com Arduino  
     https://www.youtube.com/CriandoRoboComArduin  
   .:: Mostrando os testes dos robôs e projetos  
     Test Criando Robô Com Arduino  
     https://www.youtube.com/TestCriandoRoboComAr  
   :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/  


Este projeto foi desenvolvido por: Leonardo Campbell
Fonte:http://www.criandorobocomarduino.com/2013/09/como-usar-e-testar-o-lcd-18x2-no-arduino.html



Esta com alguma duvida? Qualquer coisa entre em contato.

Leia Mais ►

Como usar e testar o sensor de distância ultrassônico HC-SR04 no arduino

Olá, amantes de robótica!
Neste post, ensinarei usar o sensor ultrasonic hc-sr04 no arduino.

 



Vamos ao material que precisamos:


Qtd Itens:
1 - Arduino UNO ou qualquer outra versão;
1 - Protoboard;
1 - Sensor ultrasonic HC-SR04;
4 - Jumpers (Fios).

Não sabe onde comprar as peças, confira esse post: onde comprar arduino e componentes


Vamos à montagem:


Basta fazer as mesmas conexões da imagem abaixo:


(clique na imagem pra ampliá-la)

Veja as fotos do projeto:













O mais importante, o código fonte:

Não sabe programar? Então acesse: Como programar em Arduíno, fazer robôs e projetos diversos


Se você é iniciante veja:Como enviar (upload) o programa pronto para a placa do arduino uno, mega entre outros


Atenção:

Para o código fonte funcionar é necessário baixar as bibliotecas: Baixar Library.


 /*   
  >>>>> Criando Robô Com Arduino <<<<<   
  ##### Robôs, Projetos e Tutoriais! #####  
  .:: Site principal: http://www.CriandoRoboComArduino.com/     
  .:: Site secundário: http://www.TestCriandoRoboComArduino.com/  
  ========== IMPORTANTE ==========   
  O código está livre para usar, citar, alterar e compartilhar,  
  desde que mantenha o site como referência.   
  Obrigado.  
  --------------------------------------------------------------------------------------------------  
  Projeto: Como usar e testar o sensor de distância ultrassônico HC-SR04 no arduino   
  ---------------------------------------------------------------------------------------------------  
 */   
  // Inclusão de bibliotecas.   
  #include <Ultrasonic.h>   // inclui biblioteca de manipulação de servos motores.   
  #define echoPin 8 //Pino 13 recebe o pulso do echo   
  #define trigPin 12 //Pino 12 envia o pulso para gerar o echo   
  Ultrasonic ultrasonic(12,8);   
  // Executado na inicialização do Arduino   
  void setup(){   
  Serial.begin(9600); // inicializa a comunicação serial para Debug ou para mostrar dados em um display LCD   
  pinMode(trigPin, OUTPUT);  // define o pino triger como saída.   
  pinMode(echoPin, INPUT);  // define o pino echo como entrada.   
  }   
  // Loop pincipal do Arduino   
  void loop(){   
  Serial.print( ultrasonic.Ranging(CM) ); //exibido no computador qual a medição do sensor. Essa função faz todo os cálculos e fornece as respostas   
  Serial.println( "cm" );// imprime o centímetro no final   
  delay(1000); //espere 1 segundo pra calcular novamente   
  }   
 /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::  
   
   :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/  

Este projeto foi desenvolvido por:Leonardo Campbell
fonte: http://www.criandorobocomarduino.com/2013/09/como-usar-e-testar-o-sensor-de.html


Pronto, qualquer duvida é só deixar nos comentários ou entrar em Contato.




Leia Mais ►

Arduíno Uno R3




O Arduino Uno é uma placa de microcontrolador baseado no ATmega328 ( datasheet ). Dispõe de 14 pinos digitais de entrada / saída (dos quais 6 podem ser usados ​​como saídas PWM), 6 entradas
analógicas, um ressonador cerâmico 16MHz, uma conexão USB, um fone de poder, um cabeçalho ICSP, e um botão de reset. Ele contém tudo o necessário para apoiar o microcontrolador; basta conectá-lo a um computador com um cabo USB ou ligá-lo com um adaptador AC-to-DC ou bateria para começar.


O Uno difere de todas as placas anteriores em que não utilizar o chip controlador USB-to-serial FTDI. Em vez disso, ele apresenta o Atmega16U2 (Atmega8U2 até a versão R2) programado como um conversor USB para serial.
Revisão 2 do conselho Uno tem um resistor puxando a linha 8U2 HWB a solo, tornando-o mais fácil de colocar em modo DFU .
Revisão 3 do conselho de administração tem os seguintes novos recursos:
1,0 pinagem: SDA adicionado e pinos SCL que estão perto ao pino AREF e outros dois novos pinos colocados perto do pino de RESET o IOREF permitir que as protecções para se adaptar à voltagem fornecida a partir da placa. No futuro, escudos será compatível tanto com a placa que usa o AVR, que opera com 5V e com o Arduino Due que opera com 3.3V. O segundo é um pino não está conectado, que é reservada para efeitos futuros.
Circuito de reset mais forte.
Atmega 16U2 substituir o 8U2.


"Uno", uma em italiano e é nomeado para marcar o lançamento do Arduino 1.0. O Uno e versão 1.0 serão as versões de referência do Arduino, movendo-se para a frente. O Uno é o mais recente de uma série de placas Arduino USB, e o modelo de referência para a plataforma Arduino; para uma comparação com as versões anteriores, consulte o índice de placas Arduino .
Resumo



Microcontrolador

ATmega328


Tensão de funcionamento

5V


Tensão de entrada (recomendado)

7-12V


Tensão de entrada (limites)

6-20V


Digital pinos I / O

14 (dos quais 6 oferecem saída PWM)


Analog pinos de entrada

6


Corrente DC por I / O Pin

40 mA


Corrente DC 3.3V para Pin

50 mA


Memória Flash

32 KB (ATmega328), dos quais 0,5 KB utilizado pelo bootloader


SRAM

2 KB (ATmega328)


EEPROM

1 KB (ATmega328)


Velocidade do relógio

16 MHz


Comprimento

68,6 milímetros


Largura

53,4 milímetros


Peso

25 g

Schematic & Design de referência


Arquivos Eagle: arduino-uno-Rev3-reference-design.zip (NOTA: trabalha com Eagle 6.0 e mais recentes)


Diagrama: arduino-uno-Rev3-schematic.pdf


Nota: O projeto de referência Arduino pode usar um Atmega8, 168, ou 328, os modelos atuais usam um ATmega328, mas um Atmega8 é mostrado no esquema para referência. A configuração de pinos é idêntica em todos os três processadores.
Poder


O Arduino Uno pode ser alimentado através da conexão USB ou com uma fonte de alimentação externa. A fonte de alimentação é selecionada automaticamente.


(Não-USB) externa de energia pode vir com um adaptador AC-to-DC (parede-verruga) ou bateria. O adaptador pode ser conectado, conectando um plug 2,1 milímetros de centro-positivo em tomada de poder do conselho. Leads de uma bateria podem ser inseridos nas pin headers Gnd e Vin do conector de alimentação.


A placa pode operar com uma fonte externa de 6 a 20 volts. Se fornecido com menos de 7V, no entanto, o pino 5V pode fornecer menos de cinco volts e do conselho pode ser instável. Se usar mais do que 12V, o regulador de voltagem pode superaquecer e danificar a placa. O intervalo recomendado é de 7 a 12 volts.


Os pinos de energia são os seguintes:
VIN. A tensão de entrada para a placa Arduino quando ele está usando uma fonte de alimentação externa (por oposição aos 5 volts a partir da conexão USB ou outra fonte de alimentação regulada). Você pode fornecer tensão através deste pino, ou, se o fornecimento de tensão através da tomada de energia, acessá-lo através deste pino.
5V. Este pino produz um 5V regulado pelo regulador na placa. A placa pode ser alimentado com energia a partir da tomada de energia DC (7 - 12V), o conector USB (5V), ou o pino VIN do conselho (7-12V). Fornecimento de tensão através dos 5V ou 3.3V pinos ignora o regulador, e pode danificar a placa. Nós não aconselho isso.
3V3. A alimentação de 3,3 volt gerado pelo regulador de bordo. Sorteio máxima atual é 50 mA.
GND. Pinos de terra.
IOREF. Este pino na placa Arduino fornece a referência de tensão com que o microcontrolador opera. Um escudo configurado corretamente pode ler a tensão pin IOREF e selecione a fonte de alimentação adequada ou habilitar tradutores de tensão nas saídas para o trabalho com a 5V ou 3.3V.
Memória


O ATmega328 tem 32 KB (com 0,5 KB utilizado para o bootloader). Ele também tem 2 KB de SRAM e 1 KB de EEPROM (que pode ser lido e escrito com a biblioteca EEPROM ).
Entrada e Saída


Cada um dos 14 pinos digitais do Uno pode ser usado como uma entrada ou uma saída, usando pinMode () , digitalWrite () , e digitalRead () funções. Eles operam a 5 volts. Cada pino pode fornecer ou receber um máximo de 40 mA e tem um resistor pull-up interno (desconectado por padrão) de 20-50 kOhms. Além disso, alguns pinos têm funções especializadas:
Serial: 0 (RX) e 1 (TX) Utilizado para receber (RX) e transmitir dados seriais (TX) TTL.. Estes pinos são ligados aos pinos correspondentes do USB-TTL chip de série ATmega8U2.
Interrupções externas: 2 e 3. Estes pinos podem ser configurados para disparar uma interrupção por um valor baixo, uma borda de subida ou queda, ou uma mudança de valor. Veja o attachInterrupt () função para obter detalhes.
PWM: 3, 5, 6, 9, 10, e 11. Fornecer saída PWM de 8 bits com a analogWrite () função.
SPI:. 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK) Estes pinos suporte à comunicação SPI usando a biblioteca SPI .
LED: 13. Há um built-in LED conectado ao pino digital 13. Quando o pino é de alto valor, o LED está ligado, quando o pino é baixo, ele está fora.


O Uno tem 6 entradas analógicas, marcado A0 a A5, cada qual com 10 bits de resolução (ie 1024 valores diferentes). Por padrão elas medem de 5 volts, porém, é possível mudar a extremidade superior de sua faixa usando o pino AREF e doanalogReference function (). Além disso, alguns pinos têm funções especializadas:
TWI:. Pin A4 ou SDA e A5 ou pino SCL comunicação TWI Apoio usando a biblioteca Wire .


Há um par de outros pinos na placa:
AREF. Tensão de referência para as entradas analógicas. Usado com analogReference ().
Repor. Trazer esta linha LOW para resetar o microcontrolador. Normalmente usado para adicionar um botão de reset para shields que bloqueiam o que há na placa.


Veja também o mapeamento entre os pinos do Arduino e portos ATMega328 . O mapeamento para a Atmega8, 168, e 328 são idênticos.
Comunicação


O Arduino Uno tem uma série de facilidades para se comunicar com um computador, outro Arduino ou outros microcontroladores. O ATmega328 fornece UART TTL (5V) de comunicação serial, que está disponível nos pinos digitais 0 (RX) e 1 (TX). Um ATmega16U2 nos canais de tabuleiro esta comunicação serial através de USB e aparece como uma porta COM virtual para o software no computador. O "firmware 16U2 usa os drivers USB padrão COM, e nenhum driver externo é necessário. No entanto, no Windows, um arquivo .inf é necessária . O software Arduino inclui um monitor serial que permite que dados simples de texto sejam enviadas de e para a placa Arduino. Os LEDs RX e TX da placa pisca quando os dados estão sendo transmitidos via o chip e USB de conexão USB para serial para o computador (mas não para comunicação serial nos pinos 0 e 1).


A biblioteca SoftwareSerial permite comunicação serial em qualquer um dos pinos digitais do Uno.


O ATmega328 também suporta I2C (TWI) e comunicação SPI. O software Arduino inclui uma biblioteca Wire para simplificar o uso do bus I2C; veja a documentação para mais detalhes. Para a comunicação SPI, use a biblioteca SPI .
Programação


O Arduino Uno pode ser programado com o software Arduino ( faça o download ). Selecione "Arduino Uno a partir do menu Ferramentas> Board (de acordo com o microcontrolador em seu board). Para mais detalhes, consulte a referênciae tutoriais .


Os ATmega328 no Arduino Uno vem preburned com um bootloader que permite o envio de novos códigos sem o uso de um programador de hardware externo. Ele se comunica usando o protocolo original STK500 ( referência , arquivos de cabeçalho C ).


Você também pode ignorar o bootloader e programar o microcontrolador através do (Programação In-Circuit Serial) ICSP cabeçalho usando Arduino ISP ou similar; veja estas instruções para obter detalhes.


O ATmega16U2 (ou 8U2 no rev1 e placas REV 2) código fonte do firmware está disponível. O ATmega16U2 / 8U2 é carregada com um carregador de inicialização DFU, que pode ser activado por:
Em placas Rev1: Conectando o jumper de solda na parte de trás do cartão (próximo o mapa de Itália) e, em seguida, redefinir o 8U2.
Em placas Rev2 ou posteriores: existe um resistor que puxar a linha 8U2 / 16U2 HWB para a terra, tornando-a mais fácil de colocar em modo DFU.


Você pode então usar o software da Atmel FLIP (Windows) ou o programador DFU (Mac OS X e Linux) para carregar um novo firmware. Ou você pode usar o cabeçalho ISP com um programador externo (substituindo o bootloader DFU). Vejaeste tutorial usuário contribuiu para mais informações.
(Software) Reset Automático


Em vez de exigir uma imprensa física do botão de reset antes de um upload, o Arduino Uno foi concebido de uma forma que permite que ele seja reposto por software rodando em um computador conectado. Uma das linhas de controlo de fluxo de hardware (DTR) do ATmega8U2 / 16U2 está ligado à linha de reset dos ATmega328 através de um condensador 100 nanofarad. Quando esta linha é (rebaixada), a linha de reset decai por tempo suficiente para resetar o chip. O software Arduino usa esse recurso para permitir que você faça o upload de código, simplesmente pressionando o botão de upload no ambiente Arduino. Isto significa que o carregador de inicialização pode ter um tempo de espera mais curtos, como a redução de DTR pode ser bem coordenado com o início do carregamento.


Essa configuração tem outras implicações. Quando o Uno está conectado a um computador rodando Mac OS X ou Linux, ele redefine a cada vez que uma conexão é feita com o software (via USB). Para o seguinte meio segundo ou assim, o bootloader está em execução no Uno. Enquanto ele está programado para ignorar dados mal formados (ou seja, qualquer coisa além de um upload de novo código), ele irá interceptar os primeiros bytes de dados enviados para a bordo, após uma conexão é aberta. Se um programa rodando na placa recebe configuração de uma só vez ou outros dados quando se inicia pela primeira vez, certifique-se de que o software com o qual ele se comunica espera um segundo após a abertura da conexão e antes de enviar esses dados.


O Uno contém um traço que pode ser cortado para desativar o auto-reset. As almofadas de cada lado do traço podem ser soldados juntos para reativá-lo. Está identificada como "RESET-PT". Você também pode ser capaz de desativar o auto-reset, ligando um resistor 110 de 5V para a linha de reposição; veja este tópico do fórum para mais detalhes.
USB Proteção de Sobrecorrente


O Arduino Uno tem uma POLYFUSE reajustável que protege portas USB do seu computador a partir de shorts e sobrecorrente. Embora a maioria dos computadores fornecem sua própria proteção interna, o fusível fornece uma camada extra de proteção. Se houver mais de 500 mA é aplicada à porta USB, o fusível romper automaticamente a ligação até que a sobrecarga ou curto é removido.
Características Físicas


O comprimento máximo e largura do PCB Uno são de 2,7 e 2,1 polegadas, respectivamente, com a tomada de conector USB e poder que se estende para além do ex-dimensão. Quatro orifícios dos parafusos permitem que a placa ser ligado a uma superfície ou caso. Note-se que a distância entre os pinos digitais 7 e 8 é de 160 mil (0,16 "), e não um múltiplo do espaçamento de 100 mil os outros pinos.

Fonte: http://arduino.cc/en/Main/arduinoBoardUno
Leia Mais ►

Arduíno Nano




O Arduino Nano é um pequeno, completo e amigável-placa de ensaio de tabuleiro baseado no ATmega328 (Arduino Nano 3.x)
ou ATmega168 (Arduino Nano 2.x). Ela tem mais ou menos a mesma funcionalidade da Arduino Duemilanove, mas numa embalagem diferente. Falta-lhe apenas uma tomada de energia DC, e funciona com um cabo USB Mini-B, em vez de um padrão. O Nano foi projetado e está sendo produzido por Gravitech.
Schematic and Design


Arduino Nano 3.0 (ATmega328): esquemáticos , arquivos de Águia .


Arduino Nano 2.3 (ATmega168): Manual (pdf), arquivos de Águia . Nota: uma vez que a versão gratuita do Águia não processa mais de 2 camadas, e esta versão do Nano é de 4 camadas, é publicado aqui unrouted, assim os usuários podem abrir e usá-lo na versão gratuita do Águia.
Especificações:



Microcontrolador

Atmel ATmega168 ou ATmega328


Tensão operacional (nível lógico)

5 V


Tensão de entrada (recomendado)

7-12 V


Tensão de entrada (limites)

6-20 V


Digital pinos I / O

14 (dos quais 6 oferecem saída PWM)


Analog pinos de entrada

8


Corrente DC por I / O Pin

40 mA


Memória Flash

16 KB (ATmega168) ou 32 KB (ATmega328), dos quais 2 KB utilizado pelo bootloader


SRAM

1 KB (ATmega168) ou 2 KB (ATmega328)


EEPROM

512 bytes (ATmega168) ou 1 KB (ATmega328)


Velocidade do relógio

16 MHz


Dimensões

0,73 "x 1,70"

Potência:


O Arduino Nano pode ser alimentado através da ligação USB Mini-B, 6-20V regulamentada fonte de alimentação externa (pino 30), ou 5V regulamentada fonte de alimentação externa (pino 27). A fonte de energia é automaticamente selecionado para a fonte de tensão mais elevada.


O chip FTDI FT232RL sobre o Nano só é alimentado se a placa está sendo alimentado por USB. Como resultado, quando em execução no (não-USB) de energia externa, a saída de 3.3V (que é fornecida pelo chip FTDI) não está disponível e osLEDs RX e TX piscará se pinos digitais 0 ou 1 são elevados.
Memória


O ATmega168 tem 16 KB de memória flash para armazenamento de código (dos quais 2 KB é usado para o bootloader); oATmega328 tem 32 KB, (também com 2 KB utilizado para o bootloader). O ATmega168 tem 1 KB de SRAM e 512 bytes de EEPROM (que podem ser lidos e escritos com a biblioteca EEPROM ); o ATmega328 tem 2 KB de SRAM e 1 KB de EEPROM.
Entrada e Saída


Cada um dos 14 pinos digitais do nano pode ser usado como uma entrada ou uma saída, usando pinMode () , digitalWrite () , e digitalRead () funções. Eles operam a 5 volts. Cada pino pode fornecer ou receber um máximo de 40 mA e tem um resistor pull-up interno (desconectado por padrão) de 20-50 kOhms. Além disso, alguns pinos têm funções especializadas:
Serial: 0 (RX) e 1 (TX) Utilizado para receber (RX) e transmitir dados seriais (TX) TTL.. Estes pinos são ligados aos pinos correspondentes do USB-a-chip de TTL Serial FTDI.
Interrupções externas: 2 e 3. Estes pinos podem ser configurados para disparar uma interrupção por um valor baixo, uma borda de subida ou queda, ou uma mudança de valor. Veja o attachInterrupt () função para obter detalhes.
PWM: 3, 5, 6, 9, 10, e 11. Fornecer saída PWM de 8 bits com a analogWrite () função.
SPI:. 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK) Estes pinos suporte à comunicação SPI, que, embora fornecido pelo hardware subjacente, não está incluída na linguagem Arduino.
LED: 13. Há um built-in LED conectado ao pino digital 13. Quando o pino é de alto valor, o LED está ligado, quando o pino é baixo, ele está fora.


O Nano tem 8 entradas analógicas, cada uma das quais com 10 bits de resolução (ie 1024 valores diferentes). Por padrão elas medem de 5 volts, porém, é possível mudar a extremidade superior de sua faixa usando o analogReference ()função. Pins analógicos 6 e 7 não pode ser usado como pinos digitais. Além disso, alguns pinos têm funções especializadas:
I 2 C: 4 (SDA) e 5 (SCL) I 2 C (TWI) Suporte de Comunicação usando o. biblioteca Wire (documentação no site do Wiring).


Há um par de outros pinos na placa:
AREF. Tensão de referência para as entradas analógicas. Usado com analogReference ().
Repor. Trazer esta linha LOW para resetar o microcontrolador. Normalmente usado para adicionar um botão de reset para shields que bloqueiam o que há na placa.


Veja também o mapeamento entre os pinos do Arduino e portos ATmega168 .
Comunicação


O Arduino Nano tem uma série de facilidades para se comunicar com um computador, outro Arduino ou outros microcontroladores. Os ATmega168 e ATmega328 fornecer UART TTL (5V) de comunicação serial, que está disponível nos pinos digitais 0 (RX) e 1 (TX). Um FT232RL FTDI nos canais de tabuleiro esta comunicação serial através de USB e osdrivers de FTDI (incluído com o software Arduino) fornecer uma porta COM virtual para o software no computador. O software Arduino inclui um monitor serial que permite que dados simples de texto sejam enviadas de e para a placa Arduino. Os LEDs RX e TX da placa pisca quando os dados estão sendo transmitidos via o chip e conexão USB FTDI para o computador (mas não para comunicação serial nos pinos 0 e 1).


A biblioteca SoftwareSerial permite comunicação serial em qualquer um dos pinos digitais do Nano.


O ATmega168 e ATmega328 também apoiar I2C (TWI) e comunicação SPI. O software Arduino inclui uma biblioteca Wire para simplificar o uso do bus I2C; veja a documentação para mais detalhes. Para usar a comunicação SPI, consulte oATmega168 ou ATmega328 folha de dados.
Programação


O Arduino Nano pode ser programado com o software Arduino ( faça o download ). Selecione "Arduino Diecimila, Duemilanove, ou Nano w / ATmega168" ou "Arduino Duemilanove ou Nano w / ATmega328" a partir do menuFerramentas> Board (de acordo com o microcontrolador em sua placa). Para mais detalhes, consulte a referência etutoriais .


Os ATmega168 ou ATmega328 no Arduino Nano vem preburned com um bootloader que permite o envio de novos códigos sem o uso de um programador de hardware externo. Ele se comunica usando o protocolo original STK500 (referência , arquivos de cabeçalho C ).


Você também pode ignorar o bootloader e programar o microcontrolador através do (Programação In-Circuit Serial) ICSP cabeçalho usando Arduino ISP ou similar; veja estas instruções para obter detalhes.
(Software) Reset Automático


Ao invés de necessitar de uma imprensa física do botão de reset antes de um upload, o Arduino Nano foi projetado de uma maneira que permite que ele seja reposto por software rodando em um computador conectado. Uma das linhas de controlo de fluxo de hardware (DTR) FT232RL está ligado à linha de reset dos ATmega168 ATmega328 ou através de um condensador 100 nanofarad. Quando esta linha é (rebaixada), a linha de reset decai por tempo suficiente para resetar o chip. O software Arduino usa esse recurso para permitir que você faça o upload de código, simplesmente pressionando o botão de upload no ambiente Arduino. Isto significa que o carregador de inicialização pode ter um tempo de espera mais curtos, como a redução de DTR pode ser bem coordenado com o início do carregamento.


Essa configuração tem outras implicações. Quando o Nano é conectado a um computador rodando Mac OS X ou Linux, ele redefine a cada vez que uma conexão é feita com o software (via USB). Para o seguinte meio segundo ou assim, o bootloader está em execução no Nano. Enquanto ele está programado para ignorar dados mal formados (ou seja, qualquer coisa além de um upload de novo código), ele irá interceptar os primeiros bytes de dados enviados para a bordo, após uma conexão é aberta. Se um programa rodando na placa recebe configuração de uma só vez ou outros dados quando se inicia pela primeira vez, certifique-se de que o software com o qual ele se comunica espera um segundo após a abertura da conexão e antes de enviar esses dados.

Fonte: http://arduino.cc/en/Main/arduinoBoardNano
Leia Mais ►

Como programar em Arduíno, fazer robôs e projetos diversos

Olá, amantes de robótica!



1º: APRENDA A LÓGICA DE PROGRAMAÇÃO "JOGANDO"





     Primeiro passo para aprender a programar em arduino é saber a lógica de programação. Existem jogos que, de forma involuntária, faz com que você a desenvolva. O site www.Code.org, que é e site é patrocinado pela Microsoft, Facebook, entre outros, no site tudo, é gratuito e lhe ajuda adquirir essa lógica, jogando. Acesse e faça todas as lições para depois programar em arduino. Acesse: www.code.org


2º: APRENDA A PROGRAMAÇÃO DO ARDUINO:






Depois de aprender a lógica de programação é hora de aprender a sintaxe do arduino, ou seja como se chama os comandos e suas funções. 

Aprenda também no site do arduinoacesse:

Arduino.cc

Porém o idioma do site é só em inglês.

Pessoal, com essas dicas, você conseguirá programar sozinho, ou pegar códigos livres e alterá-los sem ter dor de cabeça.


Fonte:http://www.criandorobocomarduino.com/2014/09/como-programar-em-arduino-fazer-robos-e.html
Leia Mais ►

Como instalar o Arduíno no windows?

Olá, amantes de robótica!
Aqui explicarei como instalar o Arduíno no windows 8 (no Xp, vista e 7 é praticamente a mesma coisa).




Vamos à instalação:
1) Entre no site do Arduíno e baixe o programa: arduino v1.0.5 para windows.

2) Extraia os arquivos (clique com o botão direito em cima dele e clique em "extrair aqui") em uma pasta de sua preferência:


3) Após extrair os arquivos, conecte o cabo USB ao Arduíno e no seu computador.

4) Clique em cima do "Meu computador" e em seguida em "Propriedades":


5) Clique em "Gerenciador de Dispositivos":


6) Após clicar, irá aparecer um dispositivo desconhecido, igual na imagem:


7) Clique duas vezes nele e vá na aba "Driver" e clique em "Atualizar Driver":


8) Clique em "procurar software de driver no computador":


9) Clique em "Procurar", após vá na pasta onde você extraiu o Arduíno, clique na pasta do "arduino-1.0.5", clique em "drive" e depois em "OK":


10) Após clique em "Avançar" e depois clique em "instalar":


11) Pronto seu Arduíno esta instalado. Observe em qual porta ele está, por exemplo, o meu está na porta "COM5" e o seu pode estar em outra.


12) Agora vá na pasta do arduino-1.0.5 e clique com o botão direito no executável do "arduino" e vá em "enviar" e clique "área de trabalho".

13) Agora abra o programa e clique em "ferramentas" -> "placas" selecione a placa que você esta usando, no meu caso é o "uno".


14) Clique novamente em "ferramentas" -> "porta serial" e selecione a porta que foi instalada sua placa, no meu caso é a porta "COM5".


Pronto, qualquer duvida é só deixar nos comentários ou entrar em Contato.
Leia Mais ►

Onde comprar Arduino e componentes?


Olá, amantes de robótica!

Neste pagina mostrarei alguns sites onde é possível comprar Arduínos e componentes.



Não estamos ganhando comissão para divulgar nenhum site e não nós responsabilizamos por nada, ou seja, tenha cuidado ao comprar!
Site de venda oficial do Arduíno: 



Sites de distribuidores oficiais do Arduíno no Brasil: 



Sites de vendas do arduino no Brasil: 


Mercado livre: Lojas no Mercado livre (já comprei muitas coisas nesse site. Contudo, antes de comprar, verifique a qualificação do vendedor, veja quantos produtos ele já vendeu, olhe a opinião dos compradores e leia comentários antes de fechar o negocio). 


Fonte:http://www.criandorobocomarduino.com/2013/08/onde-comprar-arduino-e-componentes.html


Veja Também:


A Salamandra robótica franco-suíça;

Como fazer um controle remoto de TV com arduino.



Leia Mais ►

Arduino mega 2560 R3



O Arduino mega 2560 é uma placa de microcontrolador baseado no ATmega2560 ( folha de dados ). Ele tem 54 pinos digitais de entrada / saída
(dos quais 15 podem ser usados ​​como saídas PWM),

16 entradas analógicas, 4 UARTs (portas seriais de hardware), um oscilador de cristal de 16 MHz, uma conexão USB, um fone de poder, um cabeçalho ICSP, e um botão de reset. Ele contém tudo o necessário para apoiar o microcontrolador; basta conectá-lo a um computador com um cabo USB ou ligá-lo com um adaptador AC-to-DC ou bateria para começar. O mega é compatível com a maioria dos protetores projetados para o Arduino Duemilanove ou Diecimila.


O mega 2560 é uma atualização para o Arduino Mega , que substitui.


O Mega2560 difere de todas as placas anteriores em que não utilizar o chip controlador USB-to-serial FTDI. Em vez disso, ele apresenta o ATmega16U2 (ATmega8U2 nas placas de revisão 1 e revisão 2) programado como um conversor USB para serial.
Revisão 2 do conselho Mega2560 tem um resistor puxando a linha 8U2 HWB a solo, tornando-o mais fácil de colocar emmodo DFU .
Revisão 3 do conselho de administração tem os seguintes novos recursos:
1,0 pinagem: SDA adicionado e pinos SCL que estão perto ao pino AREF e outros dois novos pinos colocados perto do pino de RESET o IOREF permitir que as protecções para se adaptar à voltagem fornecida a partir da placa. No futuro, escudos será compatível tanto com a placa que usar o AVR, que operam com 5V e com o Arduino Due que operam com 3.3V. O segundo é um pino não está conectado, que é reservada para efeitos futuros.
Circuito de reset mais forte.
Atmega 16U2 substituir o 8U2.
Schematic, Reference Design & Pin Mapping


EAGLE arquivos: arduino-mega2560_R3-reference-design.zip


Diagrama: arduino-mega2560_R3-schematic.pdf


Mapping Pin: PinMap2560 página
Resumo



Microcontrolador

ATmega2560


Tensão de funcionamento

5V


Tensão de entrada (recomendado)

7-12V


Tensão de entrada (limites)

6-20V


Digital pinos I / O

54 (dos quais 15 são uma saída PWM)


Analog pinos de entrada

16


Corrente DC por I / O Pin

40 mA


Corrente DC 3.3V para Pin

50 mA


Memória Flash

256 KB, dos quais 8 KB usados ​​pelo bootloader


SRAM

8 KB


EEPROM

4 KB


Velocidade do relógio

16 MHz

Poder


O Arduino Mega pode ser alimentado através da conexão USB ou com uma fonte de alimentação externa. A fonte de alimentação é selecionada automaticamente.


(Não-USB) externa de energia pode vir com um adaptador AC-to-DC (parede-verruga) ou bateria. O adaptador pode ser conectado, conectando um plug 2,1 milímetros de centro-positivo em tomada de poder do conselho. Leads de uma bateria podem ser inseridos nas pin headers Gnd e Vin do conector de alimentação.


A placa pode operar com uma fonte externa de 6 a 20 volts. Se fornecido com menos de 7V, no entanto, o pino 5V pode fornecer menos de cinco volts e do conselho pode ser instável. Se usar mais do que 12V, o regulador de voltagem pode superaquecer e danificar a placa. O intervalo recomendado é de 7 a 12 volts.


Os pinos de energia são os seguintes:
VIN. A tensão de entrada para a placa Arduino quando ele está usando uma fonte de alimentação externa (por oposição aos 5 volts a partir da conexão USB ou outra fonte de alimentação regulada). Você pode fornecer tensão através deste pino, ou, se o fornecimento de tensão através da tomada de energia, acessá-lo através deste pino.
5V. Este pino produz um 5V regulado pelo regulador na placa. A placa pode ser alimentado com energia a partir da tomada de energia DC (7 - 12V), o conector USB (5V), ou o pino VIN do conselho (7-12V). Fornecimento de tensão através dos 5V ou 3.3V pinos ignora o regulador, e pode danificar a placa. Nós não aconselho isso.
3V3. A alimentação de 3,3 volt gerado pelo regulador de bordo. Sorteio máxima atual é 50 mA.
GND. Pinos de terra.
IOREF. Este pino na placa Arduino fornece a referência de tensão com que o microcontrolador opera. Um escudo configurado corretamente pode ler a tensão pin IOREF e selecione a fonte de alimentação adequada ou habilitar tradutores de tensão nas saídas para o trabalho com a 5V ou 3.3V.
Memória


O ATmega2560 tem 256 KB de memória flash para armazenamento de código (dos quais 8 KB é usado para o bootloader), 8 KB de SRAM e 4 KB de EEPROM (que pode ser lido e escrito com a biblioteca EEPROM ).
Entrada e Saída


Cada um dos 54 pinos digitais do mega pode ser usado como uma entrada ou uma saída, usando pinMode () ,digitalWrite () , e digitalRead () funções. Eles operam a 5 volts. Cada pino pode fornecer ou receber um máximo de 40 mA e tem um resistor pull-up interno (desconectado por padrão) de 20-50 kOhms. Além disso, alguns pinos têm funções especializadas:
Serial: 0 (RX) e 1 (TX); Serial 1: 19 (RX) e 18 (TX); Serial 2: 17 (RX) e 16 (TX); Serial 3: 15 (RX) e 14 (TX) Utilizado para receber (RX) e transmitir dados seriais (TX) TTL.. Pinos 0 e 1 também são ligados aos pinos correspondentes do USB-TTL chip de série ATmega16U2.
Interrupções externas:. 2 (interrompem 0), 3 (interrompem 1), 18 (interromper 5), 19 (interromper 4), 20 (interromper 3), e 21 (interrupção 2) Estes pinos podem ser configurados para disparar uma interrupção por um valor baixo, uma borda de subida ou queda, ou uma mudança de valor. Veja o attachInterrupt () função para obter detalhes.
PWM: 2 a 13 e 44 a 46. Assegurar a saída PWM de 8-bit com o analogWrite () função.
SPI:. 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS) Estes pinos suporte à comunicação SPI usando a biblioteca SPI . Os pinos SPI também são divididos no cabeçalho ICSP, que é fisicamente compatível com o Uno, Duemilanove e Diecimila.
LED: 13. Há um built-in LED conectado ao pino digital 13. Quando o pino é de alto valor, o LED está ligado, quando o pino é baixo, ele está fora.
TWI: 20 (SDA) e 21 (SCL) comunicação TWI Suporte usando o. biblioteca Wire . Note-se que estes pinos não estão no mesmo local que os pinos de TWI no Duemilanove ou Diecimila.


O Mega2560 tem 16 entradas analógicas, cada uma das quais com 10 bits de resolução (ie 1024 valores diferentes). Por padrão elas medem de 5 volts, porém, é possível mudar a extremidade superior de sua faixa usando o pino AREF e função analogReference ().


Há um par de outros pinos na placa:
AREF. Tensão de referência para as entradas analógicas. Usado com analogReference ().
Repor. Trazer esta linha LOW para resetar o microcontrolador. Normalmente usado para adicionar um botão de reset para shields que bloqueiam o que há na placa.
Comunicação


O Arduino Mega2560 tem uma série de facilidades para se comunicar com um computador, outro Arduino ou outros microcontroladores. O ATmega2560 fornece quatro UARTs hardware para TTL (5V) de comunicação serial. UmATmega16U2 (ATmega 8U2 sobre a revisão 1 e revisão 2 placas) sobre os canais de bordo de uma dessas mais de USB e fornece uma porta COM virtual para o software no computador (máquinas Windows vai precisar de um arquivo .inf, mas as máquinas OSX e Linux vai reconhecer o conselho como uma porta COM automaticamente. O software Arduino inclui um monitor serial que permite que dados simples de texto sejam enviados de e para o conselho. Os LEDs RX e TX da placa pisca quando os dados são transmitidos através da ATmega8U2 / ATmega16U2 chip e conexão USB para o computador (mas não para comunicação serial nos pinos 0 e 1).


A biblioteca SoftwareSerial permite comunicação serial em qualquer um dos pinos digitais do Mega2560.


O ATmega2560 também suporta comunicação TWI e SPI. O software Arduino inclui uma biblioteca Wire para simplificar o uso do bus TWI; veja a documentação para mais detalhes. Para a comunicação SPI, use a biblioteca SPI .
Programação


O Arduino Mega pode ser programado com o software Arduino ( faça o download ). Para mais detalhes, consulte areferência e tutoriais .


Os ATmega2560 no Arduino Mega vem preburned com um bootloader que permite o envio de novos códigos sem o uso de um programador de hardware externo. Ele se comunica usando o protocolo original STK500 ( referência , arquivos de cabeçalho C ).


Você também pode ignorar o bootloader e programar o microcontrolador através do (Programação In-Circuit Serial) ICSP cabeçalho usando Arduino ISP ou similar; veja estas instruções para obter detalhes.


O ATmega16U2 (ou 8U2 no rev1 e placas REV 2) código fonte do firmware está disponível no repositório do Arduino . OATmega16U2 / 8U2 é carregada com um carregador de inicialização DFU, que pode ser activado por:
Em placas Rev1: Conectando o jumper de solda na parte de trás do cartão (próximo o mapa de Itália) e, em seguida, redefinir o 8U2.
Em placas Rev2 ou posteriores: existe um resistor que puxar a linha 8U2 / 16U2 HWB para a terra, tornando-a mais fácil de colocar em modo DFU. Você pode então usar o software da Atmel FLIP (Windows) ou o programador DFU (Mac OS X e Linux) para carregar um novo firmware. Ou você pode usar o cabeçalho ISP com um programador externo (substituindo o bootloader DFU). Veja este tutorial usuário contribuiu para mais informações.
(Software) Reset Automático


Ao invés de necessitar de uma imprensa física do botão de reset antes de um upload, o Arduino Mega2560 foi concebido de uma forma que permite que ele seja reposto por software rodando em um computador conectado. Uma das linhas de controlo de fluxo de hardware (DTR) do ATmega8U2 está ligado à linha de reset dos ATmega2560 através de um condensador 100 nanofarad. Quando esta linha é (rebaixada), a linha de reset decai por tempo suficiente para resetar o chip. O software Arduino usa esse recurso para permitir que você faça o upload de código, simplesmente pressionando o botão de upload no ambiente Arduino. Isto significa que o carregador de inicialização pode ter um tempo de espera mais curtos, como a redução de DTR pode ser bem coordenado com o início do carregamento.


Essa configuração tem outras implicações. Quando o Mega2560 está conectado a um computador rodando Mac OS X ou Linux, ele redefine a cada vez que uma conexão é feita com o software (via USB). Para o seguinte meio segundo ou assim, o bootloader está em execução no Mega2560. Enquanto ele está programado para ignorar dados mal formados (ou seja, qualquer coisa além de um upload de novo código), ele irá interceptar os primeiros bytes de dados enviados para a bordo, após uma conexão é aberta. Se um programa rodando na placa recebe configuração de uma só vez ou outros dados quando se inicia pela primeira vez, certifique-se de que o software com o qual ele se comunica espera um segundo após a abertura da conexão e antes de enviar esses dados.


O Mega2560 contém um traço que pode ser cortado para desativar o auto-reset. As almofadas de cada lado do traço podem ser soldados juntos para reativá-lo. Está identificada como "RESET-PT". Você também pode ser capaz de desativar o auto-reset, ligando um resistor 110 de 5V para a linha de reposição; veja este tópico do fórum para mais detalhes.
USB Proteção de Sobrecorrente


O Arduino Mega2560 tem um POLYFUSE reajustável que protege portas USB do seu computador a partir de shorts e sobrecorrente. Embora a maioria dos computadores fornecem sua própria proteção interna, o fusível fornece uma camada extra de proteção. Se houver mais de 500 mA é aplicada à porta USB, o fusível romper automaticamente a ligação até que a sobrecarga ou curto é removido.
Características físicas e protetor Compatibility


O comprimento máximo e largura do PCB Mega2560 são 4 e 2,1 polegadas, respectivamente, com a tomada de conector USB e poder que se estende para além do ex-dimensão. Três orifícios de parafuso permitem que a placa ser ligado a uma superfície ou caso. Note-se que a distância entre os pinos digitais 7 e 8 é de 160 mil (0,16 "), e não um múltiplo do espaçamento de 100 mil os outros pinos.


O Mega2560 é projetado para ser compatível com a maioria dos protetores projetados para o Uno, Diecimila ou Duemilanove. Pinos digitais 0 a 13 (e da AREF adjacente e GND), entradas analógicas 0-5, o cabeçalho do poder, e cabeçalho ICSP estão todos em locais equivalentes. Além disso, o UART principal (porta serial) está localizado nos mesmos pinos (0 e 1), como são interrupções externas 0 e 1 (pinos 2 e 3, respectivamente). SPI está disponível através do cabeçalho ICSP em ambos os Mega2560 e Duemilanove / Diecimila. Por favor, note que eu 2 C não está localizado nos mesmos pinos no mega (20 e 21) como o Duemilanove / Diecimila (entradas analógicas 4 e 5).


Fonte:http://arduino.cc/en/Main/arduinoBoardMega2560
Leia Mais ►

SIMONDUINO - game touchscreen com Arduino Brasileirino


Neste post demonstrarei como utilizar uma tela touchscreen resistiva implementando o jogo SIMON (Genius da Estrela) no Arduino.


Primeiro vamos ver como é o funcionamento da tela touchscreen resistiva.

Basicamente essas telas são compostas de dois filmes resistivos "resistive Coating". Entre eles existem espaçadores "spacers" que evitam falsos toques. Existe também uma base de vidro "Bottom Glass" que dá resistência mecânica e mantém firme o resistive Coating da parte inferior.





Neste post demonstrarei como utilizar uma tela touchscreen resistiva implementando o jogo SIMON (Genius da Estrela) no Arduino.


Primeiro vamos ver como é o funcionamento da tela touchscreen resistiva.

Basicamente essas telas são compostas de dois filmes resistivos "resistive Coating". Entre eles existem espaçadores "spacers" que evitam falsos toques. Existe também uma base de vidro "Bottom Glass" que dá resistência mecânica e mantém firme o resistive Coating da parte inferior.





Esse tipo de tela possui 4 pontos de conexão, sendo dois deles associados aos extremos do resistive Coating (on top film) e os outros dois associados aos extremos do resistive Coating (on bottom glass).




Ao pressionarmos um ponto da tela, o Resistive Coating superior entra em contato com o inferior criando uma resistência entre os pontos de conexão do resistive Coating superior e do resistive Coating inferior.


Na prática o que temos é que a tela touchscreen resistiva se comporta como dois potênciometros, um associado ao eixo X e outro ao eixo Y.




Obtendo as coordenadas do ponto pressionado




Para obtermos a cordenada X, aplicamos (GND) em um dos terminais associados ao barramento lateral da tela e 5 volts no terminal associado ao outro barramento lateral da tela, então efetuamos uma leitura analógica no terminal associado ao barramento superior ou inferior da tela.


A figura ao lado mostra como efetuar a leitura da cordenada X:



Para obtermos a cordenada Y, aplicamos (GND) no terminal associado ao barramento inferior da tela e 5 volts no terminal associado ao barramento superior da tela, então efetuamos uma leitura analógica no terminal associado a qualquer um dos barramentos laterais da tela.


A figura ao lado mostra como efetuar a leitura da cordenada Y:

Com relação a calibragem da tela, foi necessário apenas ajustar no código o posicionamento na tela de acordo com os valores analógicos máximos e mínimos obtidos das cordenadas X e Y.

As linhas principais do código para obter o ponto pressionado na tela ficaram da seguinte forma:

int x=analogRead(yLow);
x=map(x,90,850,0,127);

onde valores mínimo e máximo de X (90 e 850) foram mapeados para os pixels do display (0 ~ 127)


int y=analogRead(xLow);
y=map(y,80,820,0,63);

onde valores mínimo e máximo de Y (80 e 820) foram mapeados para os pixels do display (0 ~ 63)

Bem agora que já sabemos o funcionamento básico do touchscreen resistivo, vamos ao projeto.


Para implementar o SIMON touchscreen com Arduino, utilizei uma placa Brasileirino da Globalcode, um display LCD gráfico ITM-12864 (128x64 pixels), uma tela touchscreen resistiva de Nintendo DS e um Nintendo DS Touch Screen Connector Breakout (este para conexão do flat cable da tela touch).

Obs: Recomendo a utilização do Nintendo DS Touch Screen Connector Breakout, pois a conexão da tela sem ele se torna muito delicada.



A tela foi dividida em 4 quadrantes, onde cada um representa um botão do jogo. Vide foto abaixo:



O display ITM-12864 é baseado no controlador KS0108 e portanto é compatível com a "KS0108 Graphics LCD library"

Essa biblioteca facilita bastante a interface com o display LCD, visto que podemos carregar imagens bimap no display com apenas um comando.

Mais detalhes sobre a utilização dessa biblioteca podem ser vistos no meu post sobre bússola digital ou na página oficial da biblioteca.

Um detalhe importante na utilização dessa biblioteca é configurar corretamente o arquivo ks0108_Arduino.h.

Nesse arquivo indicamos onde está conectado cada terminal do display no Arduino.

Para este projeto o trecho inicial do arquivo ficou da seguinte forma:

/* /*********************************************************/ /* Configuration for assigning LCD bits to Arduino Pins */ /*********************************************************/ /* Arduino pins used for Commands * default assignment uses the first five analog pins */ #define CSEL1 2 // CS1 Bit // swap pin assignments with CSEL2 if left/right image is reversed #define CSEL2 3 // CS2 Bit #define R_W 13 // R/W Bit #define D_I 12 // D/I Bit #define EN 19 // EN Bit //#define RES 19 // Reset Bit // uncomment this to contol LCD reset on this pin /* option: uncomment the next line if all command pins are on the same port for slight speed & code size improvement */ #define LCD_CMD_PORT PORTB // Command Output Register for pins 14-19 /* Arduino pins used for LCD Data * un-comment ONE of the following pin options that corresponds to the wiring of data bits 0-3 */ #define dataPins8to11 // bits 0-3 assigned to arduino pins 8-11, bits 4-7 assigned to arduino pins 4-7 //#define dataPins14to17 //bits 0-3 assigned to arduino pins 14-17, bits 4-7 assigned to arduino pins 4-7. (note command pins must be changed) //#define dataPins0to3 // bits 0-3 assigned to arduino pins 0-3 , bits 4-7 assigned to arduino pins 4-7, this is marginally the fastest option but its only available on runtime board without hardware rs232. /* NOTE: all above options assume LCD data bits 4-7 are connected to arduino pins 4-7 */ /*******************************************************/ /* end of Arduino configuration */ /*******************************************************/

A maioria dos displays LCD necessitam de uma tensão negativa para acionamento do display, muitos deles possuem um circuito interno para gerar essa tensão. Como o ITM-12864 não possui esse circuito e afim de evitar a utilização de duas fontes de alimentação externas, montei no protoboard localizado em baixo do display, um conversor de +12volts para -9 volts utilizando um CI 555.

Nas figuras abaixo temos o diagrama elétrico do conversor e a montagem dele no protoboard. Na protoboard foram adicionados também o speaker, o potenciômetro de controle de contraste do display e os resistores que ligam os terminais da tela touch ao terra.




Nas imagens abaixo temos o detalhe da conexão do flat cable da tela touch utilizando a Nintendo DS touch Screen Connector Breakout. Também é possível ver a colagem da tela touch no display onde utilizei tiras de fita dupla face.








Além de ser conectada nas portas analógicas 0 a 3, a tela touch necessita resistores para o terra (GND) conforme diagrama abaixo:

Esses resistores foram montados na protoboard em baixo do display e eles tornam o processo de calibração da tela desnecessário.




O programa deste projeto foi baseado no código apresentado pelo Spock em seu post sobre "DOJO de programação com Program-Me", sendo que aproveitei toda a parte funcional do código original e fiz apenas as adaptações necessárias para substituir os botões e Leds pela touchscreen e pelo display, além de implementar sons diferentes para cada botão.

Segue abaixo o código final do projeto.

#include <ks0108.h> // inclui biblioteca KS0108 #include "bloco1_ON.h" // bitmap botao 1 ativado #include "bloco2_ON.h" // bitmap botao 2 ativado #include "bloco3_ON.h" // bitmap botao 3 ativado #include "bloco4_ON.h" // bitmap botao 4 ativado #include "blocos_OFF.h" // bitmap todos os botoes desativados #include "principal.h" // bitmap logo SIMONDUINO #include "logo_Globalcode.h" // bitmap logo Globalcode #include "level1.h" // bitmap nivel 1 #include "level2.h" // bitmap nivel 2 #include "level3.h" // bitmap nivel 3 #include "level4.h" // bitmap nivel 4 #include "gameOver.h" // bitmap game over #include "parabens.h" // parabens voce venceu #define xLow 15 //define porta associada ao xLow (X2) #define xHigh 17 //define porta associada ao xHigh (X1) #define yLow 16 //define porta associada ao yLow (Y2) #define yHigh 14 //define porta associada ao yHigh (Y1) int bip = 18; char state = 'S'; // S = Start, P = Play, B = Read button, ... int sequencia[] = {0,0,0,0,0,0,0,0,0}; int currentRound = 0; // armazena round atual int level = 1; //define nivel 1 como inicial int tamanhoSequencia = 8; //define o tamnanho de cada sequencia boolean fimJogo = true; // indica fim de jogo void setup() { pinMode(bip, OUTPUT); // configura porta speaker como saida Serial.begin(9600); GLCD.Init(NON_INVERTED); // inicializa a biblioteca GLCD GLCD.ClearScreen(); // limpa tela do display GLCD.DrawBitmap(principal,0,0,BLACK); //desenha na tela o bitmap do SIMONDUINO delay(3000); GLCD.DrawBitmap(logo_Globalcode,0,0,BLACK); //desenha na tela o logo da Globalcode delay(3000); GLCD.DrawBitmap(level1,0,0,BLACK); //desenha na tela o bitmap do nivel 1 delay(2000); } void loop() { if (state == 'S') { inicio(); //inicializa jogo fimJogo = false; currentRound = 0; state = 'P'; } if (state == 'P') { acendeluzesdarodada(); //reproduz seguencia da rodada no display e no speaker state = 'B'; } if (state == 'B') { for (int i = 0; i <= currentRound; i++){ int botao = leBotao(); //chama funcao que le os botoes (touchscreen) if (sequencia[i] != botao || botao==-1) { state = 'S'; fimJogo = true; GLCD.DrawBitmap(gameOver,0,0,BLACK); //desenha na tela o bitmap de gameover beep(); delay(2000); GLCD.DrawBitmap(level1,0,0,BLACK); //draw the bitmap at the given x,y position level = 1; break; } } if (!fimJogo) { currentRound++; if (currentRound == tamanhoSequencia) { //verifica se round foi concluido level++ ; switch (level) { //caso concluido desenha bitmap do proximo nivel case 2: GLCD.DrawBitmap(level2,0,0,BLACK); //draw the bitmap at the given x,y position break; case 3: GLCD.DrawBitmap(level3,0,0,BLACK); //draw the bitmap at the given x,y position break; case 4: GLCD.DrawBitmap(level4,0,0,BLACK); //draw the bitmap at the given x,y position break; case 5: GLCD.DrawBitmap(parabens,0,0,BLACK); //draw the bitmap at the given x,y position delay(5000); GLCD.DrawBitmap(level1,0,0,BLACK); //desenha na tela o bitmap do nivel 1 delay(2000); state = 'S'; level = 1 ; break; } state = 'S';}else{ state = 'P'; } } } delay(2000); } void acendeluzesdarodada() { for (int i = 0; i <= currentRound;i++){ alteraBotoes(sequencia[i]); ton(sequencia[i]); delay(500 - (level*50)); noTone(bip); alteraBotoes(-1); delay(250 - (level*25)); } } int leBotao() { int timeout = 0; int botao = -1; while (botao == -1 && timeout <= (35 - (level*5))) { botao = leScreen(); //le touchscreen if(botao != -1) { break; } delay(100); timeout++; } alteraBotoes (botao); while (leScreen( ) != -1){ ton(botao); } noTone(bip); GLCD.DrawBitmap(blocos_OFF,0,0, BLACK); //desenha todos os botoes desativados return botao; } void beep() { // emite som de fim de jogo tone(bip,100); delay(2000); noTone(bip); } void ton(int freq) { //emite sond de cada botao tone(bip,freq*1000); } void inicio() { GLCD.ClearScreen(); GLCD.DrawBitmap(blocos_OFF,0,0,BLACK); //desenha todos os botoes desativados randomSeed(analogRead(4)); // inicializa numeros randomicos for (int i = 0; i < tamanhoSequencia; i++) { sequencia[i] = (int) random(1, 5); // gera sequencia aleatoria do round } } int leScreen() { pinMode(xLow,OUTPUT); // prepara sinais da tela touch para leitura da coordenada X pinMode(xHigh,OUTPUT); digitalWrite(xLow,LOW); digitalWrite(xHigh,HIGH); digitalWrite(yLow,LOW); digitalWrite(yHigh,LOW); pinMode(yLow,INPUT); pinMode(yHigh,INPUT); delay(10); //xLow has analog port -14 !! int x=analogRead(yLow -14); // le coordenada X x=map(x,90,850,0,127); // ajusta coordenada X de acordo com resolucao do display pinMode(yLow,OUTPUT); // prepara sinais da tela touch para leitura da coordenada Y pinMode(yHigh,OUTPUT); digitalWrite(yLow,LOW); digitalWrite(yHigh,HIGH); digitalWrite(xLow,LOW); digitalWrite(xHigh,LOW); pinMode(xLow,INPUT); pinMode(xHigh,INPUT); delay(10); //xLow has analog port -14 !! int y=analogRead(xLow - 14); // le coordenada Y y=map(y,80,820,0,63); // ajusta coordenada Y de acordo com resolucao do display // Serial.print(x,DEC); //imprime cordenadas no serial monitor (descomentar para debug) // Serial.print(","); // Serial.println(y,DEC); delay(200); if ((x >= 0 && x < 64) && y > 32) { // verifica em qual quadrante da tela foi efetuado o toque de acordo com as coordenadas X e Y return 1; } if ((x >= 64 && x < 128) && y > 32) { return 2; } if ((x >= 0 && x < 64) && (y >= 0 && y < 32)) { return 3; } if ((x >= 64 && x < 128) && (y >= 0 && y < 32)) { return 4; } return -1; } void alteraBotoes (int botao) { switch (botao) { case 1: GLCD.DrawBitmap(bloco1_ON, 0, 0, BLACK); //desenha botao 1 ativado break; case 2: GLCD.DrawBitmap(bloco2_ON, 64, 0, BLACK); //desenha botao 2 ativado break; case 3: GLCD.DrawBitmap(bloco3_ON, 0, 32, BLACK); //desenha botao 3 ativado break; case 4: GLCD.DrawBitmap(bloco4_ON, 64, 32, BLACK); //desenha botao 4 ativado break; default: // se nenhum botao estiver pressionado, desenha botoes desativados GLCD.DrawBitmap(blocos_OFF, 0, 0, BLACK); //desenha botoes desativados } }

Abaixo temos um video demonstrando o funcionamento do SIMONDUINO Touchscreen, sendo que apenas reduzi o tamanho das combinações de cada nível de 8 para 3 afim de encurtar o vídeo. A cada nível que se avança as sequências são apresentadas com maior velocidade e o jogador tem menos tempo para reproduzi-las.

Fonte: http://blog.eletronlivre.com.br/2011/01/simonduino-game-touchscreen-com-arduino.html
Leia Mais ►

Copyright © Mechatronics & Robotics |
Design by Mechatronicrobotics | Tecnologia do Blogger
    YouTube Google + Facebook