O circuito que propomos é no sentido de se poder interfacear qualquer calculadora com qualquer microcontrolador, com destaque para o Arduino. Em calculadoras mais caras, elas podem ser equipadas com impressoras e bobinas de papel para que seus resultados sejam impressos, o que em determinadas aplicações o seu uso é indispensável (se utilizada uma calculadora com estas características no projeto, o Arduino teria também o controle desta impressora, o que abre várias possibilidades de uso).

Este circuito fica como intermediário entre a calculadora e o Arduino, recebendo dados serialmente a 2400 bps e utilizando apenas três pinos (+5V, Terra e RX). O seu funcionamento básico é por meio do controle do teclado da calculadora. Toda calculadora possui uma matriz para o seu teclado formado com linhas e colunas – ao se pressionar uma tecla, o contato entre uma determinada linha e coluna gera um sinal que informa qual a tecla pressionada ao circuito da calculadora.

Na calculadora que utilizamos como exemplo para este artigo, existem onze contatos para o controle das linhas e colunas (6 x 5 = 30 teclas no máximo), e oito digitos numéricos que podemos utilizar como saída de dados (informar voltagem, temperatura, etc. como fazemos com um Display LCD, e também com um Display 7 Segmentos). Além disso, podemos também utilizar o circuito de cálculo dela, controlando operações simples (soma, subtração, multiplicação e divisão) ou fazer o cálculo utilizando um programa no Arduino e somente enviando o resultado para o display da calculadora.

Para conseguirmos então poder controlar o teclado da calculadora, utilizamos o circuito integrado HEF4066 “Quadruple bilateral switches” (que funciona como quatro relês independentes), e por meio de um sinal de controle (positivo) enviado por um microcontrolador PIC16F628A (responsável pela lógica, controle e comunicação nesta interface), ele fecha os contatos para permitir o acionamento de determinado circuito. O HEF4066 como citado, possui quatro chaves (relês) cada um, e como precisamos de onze, iremos utilizar três iguais (4 x 3 = 12 chaves no máximo).

Para este artigo, a calculadora ficará com a sua fonte de alimentação original inalterada (ela utiliza +3V) e a alimentação do circuito proposto é independente da calculadora (mas pode ser adaptado para que tenham uma mesma fonte de alimentação). Ela possui também um circuito que emite um bip a cada tecla pressionada (uso de um pequeno transdutor piezoelétrico para emitir o som) e esta característica pode ser ligada ou desligada com o acionamento de uma tecla.

Como precisamos para acionar uma tecla qualquer, de uma linha e de uma coluna em determinado instante, somente esta linha e coluna devem estar conectadas. Então o circuito proposto neste artigo irá ativar as duas chaves respectivas (da linha e da coluna da tecla), simulando o pressionamento desta.

Uma curiosidade é que como o teclado da calculadora é controlado via circuito, ele pode ser digitado numa velocidade muito acima do que conseguiria ser feito por uma pessoa, e ainda ser livre de erros de digitação!

A seguir o passo a passo do circuito proposto da Placa de Interface.

Foto 01: (Embalagem da Calculadora) – clique na foto para ampliar:

Foto 02: Placa de Interface (Lado A) – clique na foto para ampliar:

Foto 03: Placa de Interface (Lado B) – clique na foto para ampliar:

Foto 04: Placa de Interface (Verso) – clique na foto para ampliar:

Foto 05: Conexão entre a Placa de Testes AVR, Placa de Interface e Calculadora – clique na foto para ampliar:

Foto 06: Conexão entre o Arduino Duemilanove, Placa de Interface e Calculadora – clique na foto para ampliar:

O Arquivo com o código fonte completo em C da CCS – CCS C Compiler do firmware para a Placa de Interface, incluindo o arquivo .hex já pronto para a gravação, pode ser baixado neste link. O artigo gravador de PIC, também mostra as etapas de como proceder a gravação.

O coração do circuito é um microcontrolador PIC16F628A, que pode ser programado na própria placa, utilizando o conector branco (5 pinos – ICSP) com o gravador de PIC, conforme mostra a foto abaixo:

Foto 07: Conexão ao gravador de PIC – clique na foto para ampliar:

Foto 08: Detalhe da conexão aos contatos do teclado da Calculadora (onze fios amarelos e pretos), conexão da alimentação da Calculadora (fios vermelho e preto: +3V e Terra respectivamente), conexão do disco piezoelétrico para o som (fios amarelo e laranja: centro e borda respectivamente) – clique na foto para ampliar:

Foto 09: Detalhe da conexão aos contatos do teclado da Calculadora (close) – clique na foto para ampliar:

Foto 10: Vista interna das conexões da Calculadora (1) – clique na foto para ampliar:

Foto 11: Vista interna das conexões da Calculadora (2) – clique na foto para ampliar:

Foto 12: Vista interna das conexões da Calculadora (3) – clique na foto para ampliar:

Neste projeto, o teclado original da calculadora foi removido, mas nada impede que seja mantido e que se tenha também a sua funcionalidade garantida, independentemente do circuito da Placa de Interface, que como veremos no seu diagrama esquemático (com poucos componentes utilizados), as chaves (relês) que controlam o teclado são isoladas do restante do circuito.

Falando do teclado, existe na calculadora um desenho com as conexões gravadas em um filme plástico, e também uma membrana de borracha com pontos de material condutor, que ao serem pressionados nos locais das teclas deste filme plástico, faz o contato desta, gerando o sinal referente a tecla escolhida para a calculadora.

Foto 13: Vista interna das conexões do filme plástico do teclado da Calculadora – clique na foto para ampliar:

Como podemos ver, ele também dá a dica de qual dupla de contatos entre os onze deve ser interligado para se obter o sinal da tecla que se quer pressionar para a calculadora. Observe a foto de número 01. Pode-se inclusive descobrir pelo método de tentativa e erro, já que não há perigo de se danificar a calculadora seja qual forem os contatos interligados.

aa

bb

O artigo da Robots Everywhere, é bem completo, sendo fornecido o diagrama para o circuito da plaquinha, bem como o código fonte em Java, para que qualquer um possa adaptar de acordo com o uso que se queira dar ao seu próprio projeto. Outros links são: o audioserial.apk e o audioserial.jar, respectivamente, um pacote para o Android e o executável em Java para o PC (para baixá-los, clique com o botão direito do mouse nos links, opção: “salvar como…”).

Para ilustrar este projeto, construimos a plaquinha de acordo com o diagrama fornecido, e testamos com um projeto nosso, o “Display Serial LCD“. Adaptamos também o código fonte fornecido (para o PC), conforme trecho abaixo (no arquivo Calculator.java):

void GenerateCommandString(String s)
{
if (s.length()<1)
return;
String s2 = s.replace(“\r”, “”);
s2 = s2.replace(“\n”, “”);
// s2 = “@@@@”+s2+”*\r\n”; // the @s are used to give time to …
s2 = ‘\f’+s2+’ ‘; // the @s are used to give time to …
//System.out.print(s2);
audioderp.AudioOut(audioderp.SerialDAC(s2.getBytes()));
}

Nesta simples adaptação, a cada envio dos dados, é enviado primeiro o caracter especial para limpar o Display Serial LCD –> ‘\f ‘. A edição do código fonte, a sua compilação e linkedição (geração do arquivo executável java “.jar”) foi feito com o uso da IDE do Eclipse (Eclipse IDE for Java Developers). O computador que for executar este código, já deve ter o runtime do Java (este link é para a versão no Windows) previamente instalado.

Segue o link para o arquivo java executável (.jar) já adaptado: AudioSerialAdaptado.zip. Descompactar, e dois cliques no arquivo: “AudioSerialAdaptado.jar” para executar.

Figura 01: Tela do programa: AudioSerialOutput Adaptado – clique na foto para ampliar:

Vamos a seguir, mostrar as fotos da plaquinha (Adaptador de Audio) que montamos:

Foto 01: (Lado A) – clique na foto para ampliar:

Foto 02: (Lado B) – clique na foto para ampliar:

Foto 03: (Verso) – clique na foto para ampliar:

Foto 04: Plaquinha conectada na fonte de alimentação (+5V), no computador via cabo de audio ligado na sua saída de som e no Display Serial LCD – clique na foto para ampliar:

Foto 05: Detalhe (1) da plaquinha conectada na fonte de alimentação (+5V), no computador via cabo de audio ligado na sua saída de som e no Display Serial LCD – clique na foto para ampliar:

Foto 06: Detalhe (2) da plaquinha conectada na fonte de alimentação (+5V), no computador via cabo de audio ligado na sua saída de som e no Display Serial LCD – clique na foto para ampliar:

Foto 07: Mensagem no Display Serial LCD indicando que ele está pronto para receber dados – clique na foto para ampliar:

No lugar do Display Serial LCD, é claro, pode ser utilizado a Placa de Testes AVR, ou o Arduino, conectando-se ao pino RX (receber dados da serial), não esquecendo de configurar a serial para 2400 bauds, e ativando algum pino na chegada de algum caracter (dado), programando assim o controle remoto!

Como vimos, este projeto é bem simples de ser montado, e para os leitores mais velhos que tiveram a oportunidade de trabalhar com os primeiros computadores pessoais (TK85, TK90, TK95, MSX, etc.), já devem ter se lembrado, que era via saída de audio de um gravador cassete, que os programas (softwares) da época eram descarregados (download) para a memória destes computadores antigos (as fitas cassete faziam o papel de armazenamento permanente, como disquetes, HDs, CD / DVD Roms e pen-drives). Vejam o site: cobit.xpg, para melhor ilustrar como era!

Como também fizemos umas poucas modificações do diagrama original, iremos também fornecer o diagrama completo modificado. O potenciômetro de 10K deve ser ajustado em relação ao sinal de audio, uma dica é iniciar o teste de recepção dos dados com ele na posição do negativo indo para o positivo da alimentação (+5V) –> aumentando a voltagem nos pinos (+) dos amplificadores operacionais gradativamente até o limiar, onde não recebe mais dados (retorne então, a uma posição em que fique mais claro o sinal de recepção) .

Figura 02: Diagrama completo modificado da plaquinha (Adaptador de Audio) – clique na foto para ampliar:

O amplificador operacional (LM324) também pode ser substituido por um outro com as mesmas características.

Aqui termina este artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post.

Procuramos utilizar então o menor número de pinos possível, e também conforme os objetivos nas nossas montagens:

1. Possibilitar a sua conectividade e comunicação com vários meios (serial, usb, rede, wireless, etc.) de maneira mais fácil;
2. Poder mostrar a sua saída dos dados em vários dispositivos (display serial lcd, display serial 7 segmentos, uma TV ou monitor, a console serial da IDE do Arduino no computador, etc.).
3. Coletar dados e informações, como: horário, temperatura, sensores diversos, etc.
4. Poder atuar como um controle de dispositivos: motores, lâmpadas, alarmes, etc.

Vamos então a mais este artigo, que esperamos leitor, torne mais claro como proceder para se ter o acesso a uma rede ethernet padrão, e poder conectar sem muito esforço qualquer microcontrolador com comunicação SPI (veremos isto com mais detalhes adiante).

Hoje em dia é muito fácil se adquirir produtos portáteis como: Notebooks, Netbooks, Tablets, Celulares, etc. que possuem circuitos para o acesso a redes, a mais comum Wi-Fi (wireless – sem fio – padrão 802.11b/g/n –> velocidades máximas de 11 Mbps, 54 Mbps e 300 Mbps), e também o Bluetooth. Nosso interesse neste caso, é com o Wi-Fi, que com um equipamento access point (Wireless Router) de baixo custo, que geralmente vem com 4 conectores RJ45 (Ethernet) para uma LAN (rede) local, permitindo a conexão de equipamentos com cabo (máximo de quatro) ou wireless (muitos, depende da capacidade do equipamento) entre si.

Tendo o acesso à rede, os microcontroladores podem então servir como elementos confiáveis na automação de tarefas diversas.

O circuito é baseado na especificação de um componente da Microchip, o ENC28J60 (Stand-Alone Ethernet Controller with SPI Interface), que permite o controle da interface de rede padrão Ethernet. Como características a serem destacadas, temos:

- IEEE 802.3 compatible Ethernet Controller;
- Integrated MAC and 10BASE-T PHY (10Mbps);
- Será configurado como half-duplex;

Figura 01: Diagrama da Pinagem do Enc28J60 – clique na figura para ampliar:

Figura 02: Diagrama de blocos do Enc28J60 – clique na figura para ampliar:

Informamos que o circuito trabalha tipicamente a +3,3V, possui um cristal externo de 25Mhz, e como podem ver na figura, possui os controles principais numa interface SPI.

Figura 03: Diagrama da interface típica do Enc28J60 – clique na figura para ampliar:

Figura 04: Diagrama de como adaptar a voltagem no Enc28J60 – clique na figura para ampliar:

Como este componente trabalha a +3,3V, a saída dele será de no máximo +3,3V, então ela deve ser ajustada a +5V, para que o microcontrolador que trabalhe a +5V possa entender o que o Enc28J60 está sinalizando. Ele também possui pinos de entrada que toleram os +5V, facilitando o seu interfaceamento.

Conforme a própria documentação, pode ser usado o 74HCT08 (quad AND gate), e o 74HC125 (quad 3-state buffer) ou qualquer outro chip CMOS 5V com TTL level input buffers, para prover o level shifting necessário.

Figura 05: Tabela da descrição dos pinos do Enc28J60 – clique na figura para ampliar:

Figura 06: Diagrama de conexão ao circuito do Enc28J60 – clique na figura para ampliar:

Esta figura acima é a mais importante, já que nosso circuito se baseia totalmente nela.

Figura 07: Diagrama de exemplo de conexão à rede Ethernet do Enc28J60 – clique na figura para ampliar:

A seguir, o circuito proposto – Placa de Rede Ethernet (com o Enc28J60):

Foto 08: (Lado A) – clique na foto para ampliar:

Foto 09: (Lado B) – clique na foto para ampliar:

Foto 10: (Verso) – clique na foto para ampliar:

Foto 11: (Lado C) – clique na foto para ampliar:

Foto 12: (Lado D) – clique na foto para ampliar:

Detalhe da Placa de Rede Ethernet (com o Enc28J60), conector de 8 vias que recebe os sinais dos pinos de controle da Placa de Teste AVR (ou da placa do Arduino). Os pinos são, da esquerda para a direita: (+5V -> fio vermelho), (INT -> fio laranja), (SO -> fio branco), (SI -> fio verde), (SCK -> fio azul), (CS -> fio marrom), (RESET -> fio cinza) e (Terra -> fio preto).

Existe também um conector P4 fêmea para se conectar uma fonte de alimentação (+5V), tornando a Placa de Rede Ethernet independente. (veremos isto em um próximo artigo).

Foto 12: Vista Geral da conexão da Placa de Teste AVR, e da placa do Enc28J60 com o Roteador Wireless (Access Point) – clique na foto para ampliar:

Foto 13: Detalhe da conexão dos fios da Placa de Teste AVR com a placa do Enc28J60 – clique na foto para ampliar:

Foto 14: Vista de cima da conexão dos fios da Placa de Teste AVR com a placa do Enc28J60 – clique na foto para ampliar:

Foto 15: Ligação dos fios na placa do Enc28J60 – clique na foto para ampliar:

Foto 16: Ligação dos fios na Placa de Teste AVR – clique na foto para ampliar:

Foto 17: Detalhe (1) do cabo de 8 vias para se conectar os pinos da Placa de Teste AVR aos pinos da Placa de Rede Ethernet. Os pinos são, da esquerda para a direita: (Terra -> preto), (RESET -> cinza), (CS -> marrom) , (SCK -> azul), (SI -> verde), (SO -> branco), (INT -> laranja) e (+5V -> vermelho)  – clique na foto para ampliar:

Foto 18: Detalhe (2) do cabo de 8 vias para conectar os pinos da Placa de Teste AVR aos pinos da Placa de Rede Ethernet – clique na foto para ampliar:

Para facilitar, segue uma tabela com as conexões necessárias: (link –> clique aqui!)

Foto 19: Leds indicadores do Access Point, o de número 1 aceso indica que existe um equipamento ligado e conectado ao soquete RJ45 correspondente – clique na foto para ampliar:

Vamos então a algumas observações:

Os componentes principais da Placa de Rede Ethernet que estamos propondo são todos baseados na própria especificação do manual do Enc28J60, conforme a foto a seguir:

Foto 20: Componentes principais – clique na foto para ampliar:

Estes componentes são difíceis de encontrar, o ideal é comprar pela internet, uma dica é o mercado livre, e também sites (lojas) on-line de componentes eletrônicos.

O Conector especial RJ45, que já vem com o circuito do transformador e LEDs embutidos, é o HanRun HR911105A (link1, link2) – Single Port RJ45 Connector with Magnetics Module and LED, mas existem outros tipos que também podem ser utilizados.

Figura 21: Diagrama do HR911105A – clique na figura para ampliar:

O outro é o próprio Enc28J60, e por último, o regulador de voltagem utilizado nesta montagem: LM1117 – 3.3, e que também pode ser substituído (o que precisa é garantir que, a partir de +5V se obtenha os +3,3V necessários para o funcionamento do Enc28J60).

Sobre o Ferrite citado na Figura 6, nesta montagem ele foi construído conforme mostram as fotos, com um pequeno bastão de ferrite com 12 voltas de fio rígido (mas também pode ser construído de outras maneiras – serve para diminuir uma provável interferência – ruído). Existe um site interessante, para o cálculo: EEweb.

Outra informação relevante é a necessidade de resistores confiáveis no seu valor (tolerância de 1%), principalmente o referente ao RBIAS (Figura 6) que é de 2,32K. Se não se possui este valor de resistor, pode se tentar uma combinação entre dois resistores que dê o valor mais aproximado possível (ex: 1,2k + 1,2k ou 2,2k + 120R, etc.). Se os resistores de 49,9R 1% também tiverem de ser substituídos por outros de maior tolerância, use um multímetro digital de boa qualidade para medir a sua resistência e encontar quatro com o valor mais próximo possível.

Uma vez concluída a montagem da nossa “Placa de Rede Ethernet”, é hora de se instalar o software de controle dela na Placa de Teste AVR ou na placa do Arduino. A “Placa de Rede Ethernet” é totalmente controlada pelos seus pinos SPI (CS, SI, SO e SCK), Bus Interface (INT) e System Control (RESET), não se instalando nenhum firmware nela. O software é baseado em um projeto livre “An AVR microcontroller based Ethernet device” da Tuxgraphics e também em um projeto da Nuelectronics “Ethernet Shield on Arduino”, onde se deve fazer o download dos arquivos para a IDE do Arduino aqui!

O arquivo é o “etherShield.zip”, que possui uma pasta “etherShield” que deve ser descompactada na pasta: \arduino-0023\libraries (faça o download da versão 0023 – clique aqui). A IDE do Arduino já está na versão 1.0 – saiu da versão 0023 que é a última versão “alpha” e está com várias melhorias! – se quiser conhecê-la, faça o download – clique aqui). Porém esta versão nova apresenta incompatibilidade com o código do “etherShield”. Depois disso, abrir o IDE do Arduino –> Arduino.exe –> File –> Examples –> etherShield –> etherShield_web_switch (por exemplo), editando os seguintes itens:

1. uint8_t myip[4] = {192,168,1,15}; // use este mesmo endereço fornecido pelo código fonte ou troque por um endereço IP livre na rede conforme a mascara da rede (ex.: se a sua rede for: 192.168.1.x e mascara: 255.255.255.0, onde x = de 1 à 254);
2. baseurl[]=”http://192.168.1.15/”; // edite de acordo com o IP escolhido;
3. uint16_t mywwwport = 80; // número da porta de escuta para o browser (Internet Explorer, Firefox, etc.) acessar (se 80 não precisa especificar no browser – valor de 1 à 254 (um byte));
4. uint8_t mymac[6] = {0×54,0×55,0×58,0×10,0×00,0×24}; // endereço MAC da placa de rede do Enc28J60 – edite e troque se necessário – na rede não pode haver dois MAC iguais;
5. #define LED_PIN  4 // Escolha qual o pino que irá acender o LED. No caso, o pino 4 digital da placa do Arduino é equivalente ao pino 6 do ATmega328;

Figura 22: Tela da IDE do Arduino, mostrando o programa etherShield_web_switch – clique na figura para ampliar:

Depois disso, faça o upload para a Placa de Testes AVR (ou para o Arduino) conforme explicado nos artigos anteriores.

Conecte tudo conforme a foto de número 12. Não esqueça de testar se o computador acessa o Access Point sem problemas (via cabo de rede ou via wireless), e se o LED com o resistor está incluído na Placa de Testes AVR ou no Arduino e conectado conforme foi definido no código fonte (catodo do LED ao número do pino definido e anodo via resistor ao positivo da alimentação +5V).

No browser (Firefox por exemplo), digite a seguinte url: http://192.168.1.15/, e veja as telas a seguir:

Figura 23: Tela do Firefox, mostrando o programa etherShield_web_switch funcionando (serve para ligar/desligar um LED – LED desligado!) – clique na figura para ampliar:

Figura 24: Tela do Firefox, mostrando o programa etherShield_web_switch funcionando (serve para ligar/desligar um LED – LED ligado!) – clique na figura para ampliar:

Foto 25: LED e seu resistor conectado a Placa de Testes AVR e ligado! – clique na foto para ampliar:

Parece muito trabalho para só acender um simples LED! Porém devemos pensar que com esta tecnologia podemos fazer muita coisa, como um controle remoto que pode ativar e desativar qualquer dispositivo no nosso ambiente via wireless (sem fio, no alcance que o Access Point permitir) ou cabo (RJ45), a partir de um computador desktop, notebook, netbook, tablet, etc., e até mesmo via Internet, configurando de modo adequado o seu roteador e fornecendo o IP público de acesso dele na url do browser remoto (ex: Firefox).

O dispositivo pode ser controlado por relês, o que permite uma grande potência em 110 ou 220V (motores, lâmpadas, eletro-eletrônicos, bombas d’agua, aquecedores, etc.). O controle também pode, para uma melhor segurança, ser ativado somente por uma senha fornecida, tornando o seu uso mais seguro e confiável. Na realidade, não há um limite do número de dispositivos que podem ser controlados, nem o tipo de controle que se quer (ex: controle gradual de temperatura, de iluminação, de velocidade de motores, etc.).

Tudo pode ser implementado acrescentando mais componentes/circuitos, podendo tambem informar remotamente que temperatura está fazendo, qual o nível de iluminação, etc. nos sensores instalados nos locais em que se quer monitorar.

Pode ser utilizado também para comandar uma câmera para tirar fotos no instante desejado, ou ligá-la para que esta filme ou fique tirando fotos, que podem, por meio de uma outra implementação, serem enviadas via Internet para um lugar especifico configurado.

Como uma dica, é fácil também garantir que fiquem a prova da falta de energia elétrica, tanto os circuitos da Placa de Teste AVR, da Placa de Rede Ethernet (com o Enc28J60), e o Access Point (Roteador Wireless). Como todos eles trabalham em uma voltagem baixa (Roteador no exemplo – TP-Link TL-WR340GD: +9V, Placa de Teste AVR: +5V, Placa de Rede Ethernet (com o Enc28J60): +5V e o Arduino que já tem regulador próprio, eles podem ser ligados em um circuito de fonte de alimentação (110/220V) com reguladores de voltagem para as saidas respectivas, que na falta de energia, acione então uma pequena bateria selada (12 V com pelo menos 4 AH) para continuar a alimentá-los nas suas voltagens corretas (através dos mesmos reguladores), e quando da volta da energia elétrica, a bateria fica carregando via circuito específico, até voltar a atingir o seu nível máximo de carga.

Vamos então dar continuidade ao artigo, explicando os pinos de controle que estão na Placa de Rede Ethernet (com o Enc28J60):

1. Os Pinos +5V (fio vermelho) e Terra (fio preto), fornecem a alimentação ao circuito. Esta alimentação sai da Placa de Testes AVR (ou do Arduino);
2. Os pinos de controle SPI (total de quatro), que são os responsáveis pela programação e comportamento na Placa de Rede Ethernet, são os seguintes (da Placa de Rede Ethernet (com o Enc28J60) para o Microcontrolador, mais a cor do fio):
   • SO (Serial Out)    –>  MISO (Master In Slave Out)   –> branco
   • SI (Serial In)        –>  MOSI (Master Out Slave In)   –> verde
   • SCK (Clock)          –>  SCK (Clock)                            –> azul
   • CS (Chip Select)   –>  SS (Slave Select)                   –> marrom
3. O pino de RESET (fio cinza) que é controlado pelo reset da Placa de Testes AVR (ou do Arduino), permite o reset simultâneo de ambos os circuitos (seu uso é opcional);
4. O pino de INT (fio laranja) da Placa de Rede Ethernet (Enc28J60), permite sinalizar para o microcontrolador um evento (pode conectar então no pino número 4 do ATmega328, que também responde pela INT0 – seu uso é opcional);

OBS: Observem a figura de número 2!

Podemos então utilizar somente 6 fios na maioria dos casos (o que não é muito).

Veremos a seguir, mais um exemplo de uso, desta vez para medir uma temperatura remotamente.

abrir o IDE do Arduino –> Arduino.exe –> File –> Examples –> etherShield –> etherShield_web_temperature, editando os seguintes itens:

1. uint8_t myip[4] = {192,168,1,15}; // use este mesmo endereço fornecido pelo código fonte ou troque por um endereço IP livre na rede conforme a mascara da rede (ex.: se a sua rede for: 192.168.1.x e mascara: 255.255.255.0, onde x = de 1 à 254);
2. baseurl[]=”http://192.168.1.15/”; // edite de acordo com o IP escolhido;
3. uint16_t mywwwport = 80; // número da porta de escuta para o browser (Internet Explorer, Firefox, etc.) acessar (se 80 não precisa especificar no browser – valor de 1 à 254 (um byte));
4. uint8_t mymac[6] = {0×54,0×55,0×58,0×10,0×00,0×24}; // endereço MAC da placa de rede do Enc28J60 – edite e troque se necessário – na rede não pode haver dois MAC iguais;
5. #define TEMP_PIN  3 // Escolha qual o pino que irá monitorar o DS18B20. No caso, o pino 3 digital da placa do Arduino é equivalente ao pino 5 do ATmega328;

Figura 26: Tela da IDE do Arduino, mostrando o programa etherShield_web_temperature – clique na figura para ampliar:

Figura 27: Tela do Firefox, mostrando o programa etherShield_web_temperature funcionando (obtem a temperatura do sensor DS18B20 remotamente!) – clique na figura para ampliar:

Foto 28: DS18B20 e seu resistor conectado a Placa de Testes AVR e monitorando! – clique na foto para ampliar:

Para concluir este artigo, iremos a seguir mostrar o diagrama completo do circuito da Placa de Rede Ethernet.

Figura 29: Diagrama da Placa de Rede Ethernet (com o Enc28J60) – clique na figura para ampliar:

Acreditamos que este projeto é uma boa introdução ao estudo dos microcontroladores em um ambiente de rede (talvez um dos mais simples para se montar e colocar para funcionar). Em um próximo artigo, iremos voltar a abordar o tema, com novos e interessantes circuitos. Esperamos que vocês leitores tenham gostado, e que aproveitem as dicas aqui fornecidas.

Aqui termina este artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post.

O display de 7 segmentos é muito utilizado para apresentar informações numéricas (e algumas alfanuméricas), em vários equipamentos, como relógios digitais, calculadoras, elevadores, decodificadores para a TV, DVD Players, multímetros, termômetros, etc. Com o Arduino (AVR), e também com outros controladores (PIC – por exemplo), é interessante poder se utilizar de poucos pinos para o controle de periféricos, pois numa montagem de teste, quanto mais fios conectados aos pinos de controle (Digital ou Analógico), mais complicado fica, além de impedir montagens mais complexas, por falta de pinos livres. Para ilustrar, o display de 7 segmentos utilizado neste artigo necessita de uma quantidade grande de pinos para o seu controle (14 pinos!), conforme figura abaixo:

Figura 01: Diagrama dos pinos do modelo do display utilizado: ParaLight A-394G – clique na figura para ampliar:

Foi escolhido este tipo de display, pois ele pode ser usado em um número grande de montagens, possui 4 dígitos com pontos (milhar, centena, dezena e unidade), dois pontos no meio (bom para mostrar as horas), um ponto acima (bom para mostrar a temperatura). Ele também, por motivo de economia de conexões internas, necessariamente tem de trabalhar multiplexado, para que possa mostrar os quatro dígitos com valores diferentes ao mesmo tempo (na realidade, um de cada vez em uma frequência muito alta para ser percebida). É claro que outros tipos de displays podem ser utilizados, e de vários tamanhos, dependendo do que se deseja como resultado final. (o tamanho do display utilizado neste artigo é pequeno, o que torna a montagem mais compacta).

Figura 02: Diagrama dos digitos do modelo do display utilizado: ParaLight A-394G – clique na figura para ampliar:

Vejamos então a seguir as fotos do circuito proposto:

Foto 01: (Lado A) – sem o display e o PIC, clique na foto para ampliar:

Foto 02: (Lado B) – sem o display e o PIC, clique na foto para ampliar:

Foto 03: (Lado A) – com o display e o PIC, clique na foto para ampliar:

Foto 04: (Lado B) – com o display e o PIC, clique na foto para ampliar:

Foto 05: (Verso) – com o display e o PIC, clique na foto para ampliar:

Foto 06: (Lado A) – Comparativo do tamanho do Display Serial de 7 Segmentos com uma moeda de 1 Real, clique na foto para ampliar:

Foto 07: Modelo do display utilizado: ParaLight A-394G – clique na foto para ampliar:

Agora, segue algumas explicações:

O Arquivo com o código fonte completo em C da CCS – CCS C Compiler do firmware para o Display Serial 7 Segmentos, incluindo o arquivo .hex já pronto para a gravação, pode ser baixado neste link. O artigo gravador de PIC, também mostra as etapas de como proceder a gravação.

O coração do circuito é um microcontrolador PIC16F628A, que pode ser programado na própria placa, utilizando o conector branco (5 pinos – ICSP) com o gravador de PIC, conforme mostra a foto abaixo:

Foto 08: Conexão ao gravador de PIC – clique na foto para ampliar:

Vamos então às fotos que explicam a sua utilização:

Foto 09: Display Serial 7 Segmentos conectado e funcionando no Arduino Duemilanove – clique na foto para ampliar:

Foto 10: Display Serial 7 Segmentos conectado e funcionando na Placa de Testes AVR – clique na foto para ampliar:

Foto 11: Detalhe do Display Serial 7 Segmentos funcionando – clique na foto para ampliar:

Foto 12: Conexões ao computador (Placa de Teste do AVR com o módulo USB, Display Serial 7 Segmentos, Gravador de PIC), e plaquinha com o DS1307, I²C Real-Time Clock – clique na foto para ampliar:

Foto 13: Conexões ao computador visto de cima (Placa de Teste do AVR com o módulo USB, Display Serial 7 Segmentos, Gravador de PIC), e plaquinha com o DS1307, I²C Real-Time Clock – clique na foto para ampliar:

Foto 14: (Lado A) Plaquinha com o DS1307 que será utilizada como um exemplo para o teste do Display Serial 7 Segmentos – clique na foto para ampliar:

Os pinos para a plaquinha com o DS1307 vistos da esquerda para a direita são: (Terra, SDA, SCL, SQW, e +5V) – o SQW não é utilizado neste exemplo.

Foto 15: (Verso) Plaquinha com o DS1307 que será utilizada como um exemplo para o teste do Display Serial 7 Segmentos – clique na foto para ampliar:

Uma característica acrescentada ao Display Serial 7 Segmentos é um botão, que ao ser pressionado e mantido assim até aparecer a opção que se quer, acende o LED vermelho miniatura, e a cada segundo pisca um dos seguintes pontos em sequência (3 opções): o ponto superior direito do display, os pontos do meio do display, e ambos os pontos. Isto seleciona qual irá piscar ao monitorar a chegada dos dados ao display, em uma velocidade de 2.400 bauds. Quando pisca ambos os pontos, significa que não haverá monitoração da chegada dos dados ao display. Se não utilizar esta característica, a programação padrão é o ponto superior direito que irá monitorar a chegada dos dados. Esta programação fica gravada na memória permanente do PIC (EEPROM de 128 bytes), o que significa que ao desligar e ligar o Display Serial 7 Segmentos esta informação se mantém.

Para o controle dos 4 dígitos, é utilizado 4 transistores BC337, que suportam bem a corrente consumida em cada dígito (máximo oito LEDs por dígito, incluindo o seu ponto).

Apresentamos também uma tabela (clique aqui) com os caracteres alfanuméricos que puderam ser desenhados (maiúsculos e minúsculos). Fica a critério de cada um modificar esta tabela no código fonte do display para atender a alguma necessidade de algum caractere especial a mais.

É interessante também estudar o código fonte do Display Serial 7 Segmentos, que está com um grande número de linhas de código, pois diferentemente do display LCD que possui um circuito dedicado ao seu controle, facilitando o seu uso (possibilitando um código de controle de utilização reduzido), o display 7 segmentos é somente um conjunto de LEDs dispostos de maneira a poder representar caracteres e números, um componente passivo, que precisa de um código de controle que detalhe tudo que se quer fazer com ele. Além disso, o código fonte do Display Serial 7 Segmentos está também com várias dicas de como se pode trabalhar com interrupções (em que o conceito básico se aplica a qualquer microcontrolador), com a criação e chamada à rotinas, e lógicas de controle e temporização.

Também está disponibilizado aqui -> neste link, o código fonte completo do programa para o teste das funções do display na IDE do arduino: “display7segpicarduino.pde”, que demonstra como é chamada cada função do Display Serial 7 Segmentos, e também a rotina para o funcionamento do teste do relógio digital com o DS1307.

As funções do Display Serial 7 Segmentos podem ser resumidas como a seguir:

1 – Mostrar um número de 0 à 9.999 com ponto ou sem (ou apagar);

2 – Mostrar um dígito numérico ou alfanumérico em qualquer posição (de 1 à 4) com ponto ou sem (ou apagar);

3 – Acender/apagar os dois pontos do meio do display, e o mesmo para o ponto superior direito;

4 – Ligar/desligar o pisca-pisca dos dois pontos do meio do display, e o mesmo para o ponto superior direito;

5 – Limpar o Display (apagar tudo);

6 – Rotina de Teste do display;

7 – Ligar/desligar/pausar o cronômetro do display, que vai de 1 à 9.999 segundos (precisão razoável em segundos – para uma melhor precisão teria de se utilizar um cristal externo de 4 Mhz para a contagem de tempo – neste projeto se utiliza o clock interno do PIC, rodando a 4Mhz);

A seguir será apresentado o diagrama esquemático do circuito do Display Serial 7 Segmentos (são poucos componentes utilizados, como podemos ver).

Figura 03: Diagrama do Display Serial 7 Segmentos – clique na figura para ampliar:

Como exemplo, utilizaremos o DS1307 para montar um relogio digital bem preciso, utilizando poucos pinos do Arduino/AVR, e tornando a montagem fácil de entender.

Como base deste exemplo, e após o download do arquivo fonte para a IDE do Arduino “display7segpicarduino.pde”, iremos utilizar a biblioteca RTClib (proceder o download na página do site, opção ZIP para facilitar, descompactar na pasta: “arduino-0023\libraries”, o nome da pasta é: adafruitRTClib862b4ec), clicar no arquivo executável: Arduino.exe –> File –> Examples –> adafruitRTClib862b4ec –> ds1307, para se observar o código fonte que foi tomado como base para este teste (arquivo display7segpicarduino.pde). Proceder ao upload do nosso arquivo de teste do Display Serial 7 Segmentos para a placa do Arduino (ou a Placa de Testes do AVR), e conectar conforme as fotos a seguir. Os pinos para o ATmega328 são: (pino 28 –> SCL, pino 27 –> SDA, pino 3 –> TXD), os pinos para o Arduino são: (Analog IN: pino 5 –> SCL, pino 4 –> SDA, Digital: pino 1 –> TX), e os pinos para o Display Serial 7 Segmentos da esquerda para a direita são: (+5V, NC – Não Conectado, RX, Terra).

Vamos então às fotos:

Foto 16: Montagem do circuito de teste do relógio digital (mostra horas e minutos) utilizando a Plaquinha com o DS1307 e a Placa de Testes AVR, como um exemplo para o Display Serial 7 Segmentos – clique na foto para ampliar:

Foto 17: Detalhe da conexão da Plaquinha com o DS1307 e a Placa de Testes AVR – clique na foto para ampliar:

Foto 18: Detalhe do Display Serial 7 Segmentos – clique na foto para ampliar:

Foto 19: Detalhe da conexão da Placa de Testes AVR com o Display Serial 7 Segmentos – clique na foto para ampliar:

Note que a plaquinha com o DS1307 não possui bateria para manter a configuração (ajuste) do tempo. Para o nosso teste, basta o exemplo gravado na Placa de Testes do AVR, pois ele ajusta as horas com o horário do computador que fez o upload a partir da IDE do Arduino!

Aqui termina este artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post.

Tudo isto já existe, e não é nem um pouco trabalhoso montar uma plaquinha com poucos componentes para compatibilizar o sinal gerado pelo microcontrolador para a TV utilizando a sua entrada monitor.

Vamos então à placa:

Foto 01: (Lado A) – clique na foto para ampliar:

Foto 02: (Lado B) – clique na foto para ampliar:

Foto 03: (Verso) – clique na foto para ampliar:

Foto 04: Com os conectores RCA – clique na foto para ampliar:

Foto 05: Conectada à Placa de Testes – clique na foto para ampliar:

Foto 06: Detalhe da conexão à Placa de Testes – clique na foto para ampliar:

Foto 07: Detalhe da conexão à Plaquinha – clique na foto para ampliar:

Foto 08: Programa de demonstração sendo executado na TV (close) – clique na foto para ampliar:

Foto 09: Programa de demonstração sendo executado na TV (vista geral) – clique na foto para ampliar:

Figura 10: Diagrama da Plaquinha TV – clique na figura para ampliar:

Vamos então começar as explicações de como funciona!

É baseado em um software, obtido neste link: arduino-tvout, onde se deve fazer o download do arquivo: TVoutBeta1.zip, descompactá-lo, e na pasta libraries da instalação do Arduino copiar as pastas: pollserial, TVout, e TVoutfonts. Feito isso, abrir a IDE do Arduino: arduino.exe, ir no menu: File –> Examples –> TVout –> DemoNTSC. Clique no icone (|>) para compilar, se tudo ok, proceder o upload [-->|] para a Placa de Testes, conforme explicado no artigo anterior “Monte uma placa de testes para o AVR da Atmel“, conectar conforme as fotos e visualizar a demonstração.

Há também um site que mostra como customizar um desenho/figura para ser mostrado na TV, usando um aplicativo feito para isto. O site é o “Tinkering with Electronics…“, e o programa é o “image2code“.

Não podemos também deixar de citar o excelente site do Rickard Gunee, com o seu PIC Game System, em que esta plaquinha também funciona para compatibilizar a saída do video do microcontrolador, pois o principal para a geração deste na TV são os dois resistores de 1 K e 470 ohms.

Figura 11: Diagrama das conexões – clique na figura para ampliar:

Conforme figura acima, os pinos do ATmega328 a serem conectados são:

Arduino:
SYNC      VIDEO    AUDIO
9             7           11

ATmega328:

SYNC                             VIDEO                           AUDIO
15 –> placa (pino 2)     13 –> placa (pino 3)     17 –> placa (pino 4)

Terra –> placa (pino 5)

Figuras 12: Comparando o Arduino X ATmega328 – clique nas figuras para ampliar:

Figura 13: Tabela comparativa Arduino X ATmega328 – clique na figura para ampliar:

Aqui termina este artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post.

Segue um link para um documento (artigo) que explica muito bem o seu funcionamento: How to use Intelligent LCDs, e também um link que mostra a quantidade de fios que precisam ser conectados, do Arduino ao LCD: Small Displays (16 x 2 LCD Display), bem como um link para o seu  datasheet: LCD HD44780.

Vejamos então a seguir as fotos do circuito proposto:

Foto 01: (Lado A) – clique na foto para ampliar:

Foto 02: (Lado B) – clique na foto para ampliar:

Foto 03: (Verso) – clique na foto para ampliar:

Agora, segue algumas explicações:

O coração do circuito é um microcontrolador PIC16F628A, que pode ser programado na própria placa, utilizando o conector branco (5 pinos – ICSP) com o gravador de PIC, conforme mostram as fotos abaixo:

Foto 04: Display LCD Serial com a conexão ao gravador de PICs – clique na foto para ampliar:

Foto 05: Display LCD Serial com a conexão ao gravador de PICs (detalhe) – clique na foto para ampliar:

O código fonte completo (escrito em C da CCS – CCS C Compiler), incluindo o arquivo .hex já pronto para a gravação, pode ser baixado neste link. O artigo gravador de PIC, também mostra as etapas de como proceder a gravação. À seguir também será apresentado o diagrama esquemático do circuito (são poucos componentes utilizados, como podemos ver).

Vamos então às fotos que explicam a sua utilização:

Foto 06: Display LCD Serial com a conexão ao Arduino – clique na foto para ampliar:

Foto 07: Display LCD Serial com a conexão ao Arduino (detalhe) – clique na foto para ampliar:

Como podemos ver, são somente três fios que precisam ser conectados à placa do Arduino para que este Display Serial LCD funcione: +5V, Terra, e o pino Digital 1 (TX). Muito menos dos pinos que seriam necessários em uma conexão direta ao LCD!

Ilustração usando o Fritzing –> (clique aqui!)

Também temos uma vantagem significativa, que é a facilidade de se reaproveitar vários códigos de exemplo do Arduino, com poucas modificações, que usam a interface serial para mostrar seus dados na console do computador (que é chamada pela IDE do Arduino). Isto se deve ao fato do Display Serial LCD utilizar o mesmo pino 1 (TX) para receber as mesmas informações que vão para o computador (PC) via alguma porta serial (ex: COM1). Sendo assim, se o Arduino estiver ligado ao PC e também ao Display Serial LCD, as mensagens aparecerão em ambos! (OBS: O Display Serial LCD foi configurado para trabalhar na velocidade de 2400 bauds – deve-se então, configurar esta mesma velocidade na console do Arduino, em que o padrão é 9600 bauds).

Conforme foi mostrado no artigo anterior “Monte uma placa de testes para o AVR da Atmel“, vamos também mostrar como utilizar o Display Serial LCD nela. Seguem as fotos de como proceder:

Foto 08: Display LCD Serial com a conexão à Placa de Testes para o AVR – clique na foto para ampliar:

Foto 09: Display LCD Serial com a conexão à Placa de Testes para o AVR (detalhe) – clique na foto para ampliar:

Como podemos ver, os três fios são ligados ao +5V, Terra, e ao pino 3 do microcontrolador ATmega328 (TXD). Para facilitar, vamos mostrar a tabela comparativa a seguir:

Figura 10: Tabela comparativa Arduino X ATmega328 – clique na figura para ampliar:

Continuando, a utilização dos pinos do Arduino X Placa de Testes (ATmega328) é muito fácil, mostraremos mais um exemplo a seguir:

Foto 11: DS18B20 sensor de temperatura com o resistor de 4,7K necessário para o seu funcionamento – clique na foto para ampliar:

Foto 12: DS18B20 conectado ao Arduino (+5V, Terra, e Sinal 1-Wire bus) – clique na foto para ampliar:

Foto 13: DS18B20 conectado à Placa de Testes AVR (+5V, Terra, e Sinal 1-Wire bus) – clique na foto para ampliar:

Foto 14: DS18B20 conectado à Placa de Testes AVR (+5V, Terra, e Sinal 1-Wire bus), e o Display LCD Serial também conectado (+5V, Terra, e ao pino 3 (TXD) – clique na foto para ampliar:

Nesta configuração, fácil de entender por utilizar poucos fios, podem ser executados os exemplos para o Arduino em relação à medição de temperatura, com as informações aparecendo no LCD. Uma biblioteca interessante é a Dallas Temperature Control Library, e também a OneWire Library, que podem ser utilizadas integradas na IDE do Arduino (descompactar na pasta: \arduino-0023\libraries\, e depois abrir o IDE do Arduino –> Arduino.exe –> File –> Examples –> DallasTemperature –> Simple (por exemplo), alterando o Serial.begin(9600) para Serial.Begin(2400) –> isto é necessário, e também tente diminuir o tamanho das mensagens para caber melhor no LCD –> teste primeiro no computador, para ver como sai as mensagens).

O funcionamento do Display Serial LCD em relação ao LED amarelo, é que este sinaliza todos os dados que são recebidos (caso seja interessante ligar/desligar o LED, pode se colocar um Jumper ou uma chave, ou então, alterar a programação via código fonte). Existe também no programa uma rotina de inicialização, teste e verificação do display, para saber se ele está funcionando adequadamente. Após esta rotina ser executada, o display fica aguardando a chegada dos dados serialmente na velocidade de 2400 bps.

O display também aceita 4 caracteres de controle, conforme a seguir:

\f   –> Limpa o display, posiciona o cursor na primeira linha a esquerda
Exemplo: Serial.print(“\f”);
\a  –> posiciona o cursor na primeira linha a esquerda
Exemplo: Serial.print(“\a”);
\n  –> Vai para o início da segunda linha
Exemplo: Serial.print(“\n”);
\b  –> Recua uma posição
Exemplo: Serial.print(“\b”);

Exemplo: Serial.print(“Hello world.”) –> obtem: Hello world.

O código fonte para o Arduino, como exemplo, está na biblioteca serial (clique aqui e aqui).

Bom, só falta então o diagrama:

Figura 15: Diagrama esquemático do Display LCD Serial – clique na figura para ampliar:

Como comparativo, e para mais dicas, siga este link –> Serial LCD tutorial!

Aqui termina este artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post.

Figura 01: Para a programação e configuração do módulo USB/serial, conecte a placa de testes utilizando o cabo especial de 6 vias ao módulo USB/serial conforme abaixo, não esquecendo de conectar a placa de teste a uma fonte de alimentação de +5V, e também de desligar o jumper verde e o dip-switch azul (todas as suas três chaves), e também conectar a placa de testes ao computador (COMx) utilizando o cabo serial: – clique na foto para ampliar:

Vamos então ao procedimento para configurar os fuses do microcontrolador ATmega8. Como já foi falado, esta configuração não precisa ser modificada para aceitar os firmwares cdc-232 (de 12Mhz e de 16 Mhz) e do moo-cdc. A informação sobre os fuses se encontra em um arquivo Readme.txt (que faz parte do arquivo cdc232.2011-06-24.zip), conforme trecho a seguir:

—————————————————————————————————————-

CDC-232

This is the Readme file to firmware-only CDC driver for Atmel AVR
microcontrollers. For more information please visit

http://www.recursion.jp/avrcdc/

SUMMARY
=======
The CDC-232 performs the CDC (Communication Device Class) connection over
low-speed USB. It provides the RS-232C interface through virtual COM
port. The AVR-CDC is originally developed by Osamu Tamura.
Akira Kitazawa has significantly contributed to improve this software.
SPECIFICATION
=============
AVR-CDC with USART (ATmega8/48/88/168)
speed:     600 – 38400bps
datasize: 5-8
parity:   none/even/odd
stopbit:  1/2
controls: DTR, RTS, CTS
Although the CDC protocol is supported by Windows 2000/XP/(Vista/7), Mac
OS 9.1/X, and Linux 2.4 or 2.6.31-, low-speed bulk transfer is not allowed
by the USB standard. Use CDC-232 at your own risk.
USAGE
=====
[Windows XP/2000/Vista/7]
Download “avrcdc_inf.zip” and read the instruction carefully.
Fuse bits ext H – L
ATmega8 — 8F – FF
USING AVR-CDC FOR FREE
======================
The AVR-CDC is published under an Open Source compliant license.
See the file “License.txt” for details.
Osamu Tamura @ Recursion Co., Ltd.

http://www.recursion.jp/avrcdc/

28 February 2010

—————————————————————————————————————-

Então, já temos nossa informação para os fuses. Vejamos a seguir:

Tela 02: na página: http://www.recursion.jp/avrcdc/download.html, fazer o download do arquivo: avrcdc_inf.zip (é o driver para o Windows 7, e funciona com o cdc-232 e com o moo-cdc): – clique na figura para ampliar:

Tela 03: na página: http://www.recursion.jp/avrcdc/download.html, fazer o download do arquivo: cdc232.2011-06-24.zip (contém o pacote do cdc-232): – clique na figura para ampliar:

Tela 04: Página: http://www.asio.pl/moo-cdc/, contém o firmware do moo-cdc: – clique na figura para ampliar:

Tela 05: Continuando, botão direito do mouse no link: moo-cdc-20100130-m8.hex –> opção save target as… – clique na figura para ampliar:

Tela 06: Continuando, fazer o download do arquivo: moo-cdc-20100130-m8.hex – clique na figura para ampliar:

Tela 07: Fazer o download do arquivo: cdcmega8cristal16mhz.zip – clique na figura para ampliar:

Tela 08: Arquivos já baixados (descompactar em alguma pasta os arquivos compactados) – clique na figura para ampliar:

Tela 09: Gravação dos fuses ( comando Avrdude –> avrdude -p m8 -c ponyser -P com2 -U lfuse:w:0xff:m -U hfuse:w:0x8f:m ) – clique na figura para ampliar:

Tela 10: Gravação do cdcmega8(cristal16mhz).hex ( comando Avrdude –> avrdude -p m8 -c ponyser -P com2 -U flash:w:cdcmega8(cristal16mhz).hex ) – clique na figura para ampliar:

Tela 11: Gravação do moo-cdc-20100130-m8.hex ( comando Avrdude –> avrdude -p m8 -c ponyser -P com2 -U flash:w:moo-cdc-20100130-m8.hex ) – clique na figura para ampliar:

Obrigatório é a gravação dos fuses (no caso do ATmega8 só existem o lfuse e o hfuse), e a escolha entre o cdcmega8(cristal16mhz).hex ou o moo-cdc-20100130-m8.hex como firmware para USB/serial. A instalação do driver no computador é idêntica a mostrada na quinta parte deste artigo, ou seja, do Cabo HL-340 (utilizando-se o arquivo avrcdc_inf.zip descompactado em uma pasta, por exemplo no Desktop –> “C:\Users\leo\Desktop\avrcdc_inf\xpvista7″ –> arquivos: lowcdc.inf e lowcdc.sys), e o teste de comunicação do módulo com o programa ASCIITable (incluindo o seu upload, somente com o firmware moo-cdc-20100130-m8.hex) idem.

Vamos inserir o módulo USB/serial na placa de teste. Siga a figura abaixo:

Figura 12: Para a utilização do módulo USB/serial, conectar a placa de testes, com o cabo USB conectado entre a placa de teste e o computador. Não esquecer de conectar a placa de teste a uma fonte de alimentação de +5V (ou o mais prático, aproveitar a voltagem da própria USB, mas se em algum programa, por exemplo, precisarmos de mais de 100mA de corrente (caso do uso de lâmpadas e/ou motores), é aconselhável realmente utilizar outra fonte de alimentação que a USB), e também de desligar o jumper verde e o dip-switch azul (todas as suas três chaves): – clique na foto para ampliar:

Este artigo sobre a placa de testes para o AVR da Atmel, em relação à sua funcionalidade, está praticamente concluído, porém é interessante saber como é possível gravar um programa do Arduino sem ser pelo bootloader, e ainda, criar um programa em C no AVR Studio 4 e executar na placa de testes, e também conhecer uma nova linguagem e conceito que precisa ser mais divulgada, que é a linguagem Processing, e além disso, porque não falar do Wiring?

Aqui termina a sexta parte deste artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post. clique aqui para ir para a sétima parte deste artigo.

Tela 01: Cabo HL-340 – clique na foto para ampliar:

Tela 02: Conectar o Cabo HL-340 em uma porta USB, após Clicar em Iniciar –> botão direito do mouse em Computador –> opção Properties: – clique na figura para ampliar:

Tela 03: Clicar em Device Manager e observar o reconhecimento do novo dispositivo USB2.0-Ser! – clique na figura para ampliar:

Tela 04: Executar o software HL-340.exe – clique na figura para ampliar:

Tela 05: Setup, clique em install: – clique na figura para ampliar:

Tela 06: Clique em: Install this driver software anyway: – clique na figura para ampliar:

Tela 07: Sucesso na instalação: – clique na figura para ampliar:

Tela 08: Device Manager –> dois cliques em: USB-SERIAL CH340 (COM3) –> Port Settings –> Advanced… (Verificando a nova porta serial criada com sucesso): – clique na figura para ampliar:

Vamos então, demonstrar a comunicação da placa de teste com o computador. Para isto, devemos inserir o módulo rs232 ou o módulo USB/serial na placa de teste. Vamos optar pelo módulo rs232  porque ainda não demonstramos o uso do outro módulo. Siga a figura abaixo:

Tela 09: Módulo rs232 conectado a placa de teste, com o cabo serial conectado entre a placa de teste e o computador. Não esquecer de conectar a placa de teste a uma fonte de alimentação de +5V, e também de desligar o jumper verde e o dip-switch azul (todas as suas três chaves): – clique na foto para ampliar:

Tela 10: Entrar na pasta da instalação do Arduino (arduino-0022) –> dois cliques no Arduino.exe –> Programa do Arduino carregado: – clique na figura para ampliar:

Tela 11: Selecionar: File –> Examples –> 4.Communication –>  ASCIITable – clique na figura para ampliar:

Tela 12: Código fonte do programa ASCIITable: – clique na figura para ampliar:

Tela 13: Conferindo se a placa (Board) é “Arduino Duemilanove or Nano w/ ATmega328″: – clique na figura para ampliar:

Tela 14: Conferindo se  a porta serial (Serial Port) é a mesma que está conectada à placa de teste: – clique na figura para ampliar:

Tela 15: Compilando o código fonte do programa ASCIITable (clique no ícone “(>)” ): – clique na figura para ampliar:

Tela 16: Término da compilação com sucesso do código fonte do programa ASCIITable: – clique na figura para ampliar:

Tela 17: Preparando para o Upload do binário do programa ASCIITable para a placa de teste(clique no ícone “(->|)” ): – clique na figura para ampliar:

Tela 18: Iniciando o Upload do binário do programa ASCIITable para a placa de testes (clique no botão Reset da placa de testes e solte no momento do upload para passar o controle ao bootloader do ATmega328, ele faz o resto! OBS: os LEDs vermelho e verde do módulo rs232 piscam, indicando que a comunicação do bootloader com a interface do computador está ocorrendo): – clique na figura para ampliar:

Tela 19: Termino do Upload do binário do programa ASCIITable para a placa de testes: – clique na figura para ampliar:

Tela 20: Abrindo a console para monitorar a porta serial (Clique no ícone do Serial Monitor): – clique na figura para ampliar:

Tela 21: Console para monitorar a porta serial: – clique na figura para ampliar:

Tela 22: Resetar a placa de testes, e verificar a saída de dados (tabela Ascii) gerada pelo programa (firmware) gravado no microcontrolador ATmega328, via porta serial (no exemplo, a COM2 a 9600 bauds), na Console do Arduino (OBS: o LED verde do módulo rs232 acende, indicando que uma transmissão da placa de testes para o computador está ocorrendo): – clique na figura para ampliar:

Tela 23: Final da saída de dados (tabela Ascii) gerada pelo programa (firmware) gravado no microcontrolador ATmega328, via porta serial, na Console do Arduino: – clique na figura para ampliar:

Em resumo, vimos nesta etapa nosso primeiro programa para a plataforma do Arduino, com o ciclo completo: código fonte do programa, compilação, upload para a placa de testes, e execução do programa, que neste exemplo, estabelece uma comunicação de dados com o computador via interface serial.

Aqui termina a quinta parte deste artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post. clique aqui para ir para a sexta parte deste artigo.

Para começar, vamos preparar o ATmega328 (que por exemplo, acabamos de adquirir no comércio e que está com a configuração de fábrica, ou seja, fuses padrões e nada gravado na memória flash de 32KBytes interna), gravando nele o bootloader padrão original do Arduino Duemilanove com o ATmega328 (o download do bootloader, junto com as configurações dos fuses, está disponível na 2ª parte deste artigo).

Tela 01: página da 2ª parte do projeto (fazer o download do bootloader) – clique na figura para ampliar:

Tela 02: nome do arquivo baixado: bootloaderdoarduinocomoblink.zip  – clique na figura para ampliar:

Tela 03: descompactar o arquivo zip para uma pasta:  – clique na figura para ampliar:

Tela 04: Arquivos – bootloader.arduino.duemilanove.blink.hex, testeefuse.hex, testehfuse.hex, e testelfuse.hex:  – clique na figura para ampliar:

Concluído esta etapa, vamos agora detalhar os passos necessários para a gravação no microcontrolador ATmega328. Iremos então, para facilitar, instalar um novo software que é o WinAVR, marcando a opção na instalação de configurar a variável PATH de ambiente do Windows 7 automaticamente, permitindo assim que executemos o Avrdude (que também já vem incluído na instalação do WinAVR, e numa versão mais nova: “AVRDUDE, Version 5.8cvs, 8 January 2010″) a partir de qualquer pasta do Windows.

Tela 05: Site para o download do WinAVR versão WinAVR-20100110-install.exe – faça o download:  – clique na figura para ampliar:

Tela 06: Arquivo WinAVR-20100110-install.exe clique duplo para instalar:  – clique na figura para ampliar:

Tela 07: Confirme – Yes:  – clique na figura para ampliar:

Tela 08: Selecione o idioma – Português do Brasil:  – clique na figura para ampliar:

Tela 09: Bem vindo ao assistente de instalação – avançar:  – clique na figura para ampliar:

Tela 10: Contrato de licença – concordo:  – clique na figura para ampliar:

Tela 11: Escolha do local da instalação – aceite o padrão:  – clique na figura para ampliar:

Tela 12: Escolha de componentes – não esqueça de marcar a opção “Add Directories to PATH”:  – clique na figura para ampliar:

Tela 13: Instalando…:  – clique na figura para ampliar:

Tela 14: Concluindo o assistente de instalação:  – clique na figura para ampliar:

Tela 15: WinAVR manual do usuário:  – clique na figura para ampliar:

Tela 16: Acesso ao WinAVR:  – clique na figura para ampliar:

Vamos voltar então à pasta onde se encontram os arquivos do bootloader do Arduino, e também no prompt de comando:

Tela 17: Arquivos:  – clique na figura para ampliar:

Agora chegou finalmente a hora de efetivamente gravarmos o bootloader no ATmega328, utilizando para isto o Avrdude que veio com o WinAVR:

Tela 18: Observar a variavel de ambiente PATH, onde foi incluido o caminho para a pasta bin do WinAVR:  – clique na figura para ampliar:

Agora, antes de executar os próximos comandos, temos de conectar em alguma interface serial do nosso computador (COMx) a placa principal de testes. Vide foto a seguir. (OBS: a placa pode ser alimentada com pilhas recarregáveis –> 4 x 1,2V = +4,8V. Para utilizar pilhas comuns, conectar 2 diodos em série –> +6V – 1,2V = +4,8V aproximadamente. Pode também ser conectada à uma porta USB livre do próprio computador = +5V ou então a uma fonte regulada de alimentação externa, que forneça +5V com pelo menos 300 mA de corrente e o plug P4 deve ter o positivo no centro –> selecione na chave qual a fonte de alimentação disponível (Externa ou USB). Também não podemos esquecer de conectar o jumper verde e o dip-switch azul com seus três interruptores).

Tela 19: Foto para referência:  – clique na foto para ampliar:

Tela 20: Comando executado (01): avrdude -F -p m328p -c ponyser -P com2 -U flash:w:bootloader.arduino.duemilanove.blink.hex – clique na figura para ampliar:

Tela 21: Comando sendo executado (continuação 02): – clique na figura para ampliar:

Tela 22: Comando finalizado (continuação 03): – clique na figura para ampliar:

Vamos fazer alguns comentários. Note que o comando Avrdude especifica o parâmetro -F, que significa ignorar a diferença da assinatura do dispositivo (Atmega328 x ATmega328P) conforme a seguir: Device signature = 0x1e9514 (ATMEGA328) –> Expected signature for (ATMEGA328P) is 1E950F (se você leitor adquirir o ATmega328P não precisa utillizar o parâmetro -F). Notamos também que ele apaga toda a memória do microcontrolador, para garantir que não haverá nenhuma sujeira na memória flash. Os outros parâmetros são: p m328p (especifica o microcontrolador utilizado), -c ponyser (especifica que tipo de gravador estamos utilizando), -P com2 (especifica que porta serial estamos utilizando – no caso estamos utilizando a COM2), -U flash:w:bootloader.arduino.duemilanove.blink.hex (o flash especifica que é na memória flash que iremos atuar, o w de write – gravar, e a seguir o nome do arquivo .hex que será gravado).

Interessante também é que o LED vermelho da placa de testes fica aceso e oscilando, pelo motivo de estar conectado ao pino 19 do ATmega328 (que corresponde ao Digital 13 na placa do Arduino), que é também o SCK (clock) da gravação ICSP.

A seguir, iremos gravar os fuses no ATmega328. Os fuses configuram como o microcontrolador trabalha, independentemente do programa que ele roda. Por exemplo, se ele usa clock interno (com algumas opções fixas de velocidade) ou se usa clock externo (ditado por exemplo, pelo cristal que é utilizado: nesta placa de teste e no Arduino Duemilanove foi utilizado um cristal de 16Mhz). Existem várias outras opções e detalhes para os fuses, um site interessante para calcular os fuses é o: http://www.engbedded.com/fusecalc/.

Tela 23: Comando executado: avrdude -F -p m328p -c ponyser -P com2 -U efuse:w:testeefuse.hex – clique na figura para ampliar:

Tela 24: Comando executado: avrdude -F -p m328p -c ponyser -P com2 -U hfuse:w:testehfuse.hex – clique na figura para ampliar:

Tela 25: Comando executado: avrdude -F -p m328p -c ponyser -P com2 -U lfuse:w:testelfuse.hex – clique na figura para ampliar:

Como vimos, existe para o ATmega328, três tipos de fuses a serem configurados, a saber: lfuse (low), hfuse (high), e efuse (extend), composto cada fuse por um único byte (8bits) que representa valores de configuração de acordo com cada tipo de microcontrolador (olhar o manual específico de cada um para saber o que significa cada bit). Também há uma outra maneira de configurá-los, por meio dos parâmetros: -U lfuse:w:0xzz:m -U hfuse:w:0xzz:m -U efuse:w:0xzz:m (onde zz é o byte de configuração na representação hexadecimal, de 00 à FF, ou seja de 0 à 255 decimal).

Concluído estes comandos, Parabéns, você já possui um clone funcional do Arduíno Duemilanove!!! (OBS: como este bootloader já vem com o programa Blink carregado, é fácil comprovar se tudo ocorreu bem, após o reset da placa de testes, ao pressionar o botão de reset ou desligá-la e ligá-la de novo, o LED vermelho irá ficar piscando de um em um segundo).

Aqui termina a quarta parte deste artigo. Caso tenham alguma dúvida, segue um e-mail para contato:  micro@dimensaobynet.com.br
Até o próximo post. clique aqui para ir para a quinta parte deste artigo.