terça-feira, 3 de junho de 2014

Como instalar o Manjaro 0.8.9 em um netbook


Quem acompanha meu blog pode ter acompanhado a minha busca pela melhor distribuição Linux para um netbook velho que eu tinha aqui em casa.

Escolher um sistema operacional não é uma coisa muito simples, ainda mais se você tem necessidades específicas.

Eu queria um linux que rodasse bem no meu Asus EeePC Surf 2g. Ele só tem 512MB e veio com um sistema operacional customizado pela ASUS que não tem atualizações disponíveis há muitos anos.

Eu já tinha tentado instalar um Puppy Linux e outras distribuições, sem nenhum sucesso. Aí eu tentei o Arch Linux uma vez, mas não consegui colocar uma interface gráfica. Então tentei uma segunda vez, desta vez em um desktop, mas não fui muito mais longe. Por fim, larguei de mão do Arch Linux puro e instalei o Manjaro no meu netbook, mas não dei muita explicação. No meu post sobre o assunto, falei mais sobre os problemas que encontrei no caminho.

Pois bem, depois de passar mais um tempo com ele encostado, resolvi pegar de novo o netbook para mexer. Fui atualizá-lo e tive alguma dificuldade com o Openbox e problemas de permissões na hora de atualizar via console com o pacman. Achei que era uma boa oportunidade de começar do zero e registrar aqui o passo a passo completo.

Antes de tudo, você deve entrar lá na página do Manjaro e fazer o download da versão que você deseja instalar..

Desta vez escolhi a versão XFCE. Na verdade, da última vez eu acho que não tinha escolhido essa porque o pendrive que eu tinha disponível era de 1GB e o arquivo tinhas uns 70MB mais do que isso... Literalmente, foi por muito pouco que não consegui usá-la... Desta vez apelei e formatei um pendrive de 16GB, apesar de ter um menor em alguma gaveta... Se você tiver um de 2GB, acho que é o tamanho ideal. Se quiser usar um pendrive com mais que isso (como eu fiz), fique à vontade..

Lembre-se de que você vai precisar de duas mídias: um cartão SD de 6GB (ou mais) para instalar o sistema operacional que vai rodar no netbook e um pendrive de 2GB (ou mais) para servir de "disco de instalação". Você pode usar dois pendrives, mas não adianta ter dois cartões SD. O meu netbook só tem um leitor de cartão SD. Então, a não ser que você tenha um leitor de cartões USB, você precisa de um pendrive e um cartão.

Na minha tentativa anterior, eu tinha escolhido a versão Openbox e daquela vez o pendrive de 1GB serviu bem e o cartão de 4GB também. Aparentemente, a edição XFCE é mais "gulosa". Para essa, você vai precisar de um pendrive de 2GB e um cartão de 6GB.

Vamos começar pela preparação do pendrive de instalação. Toda vez que eu mencionar pendrive agora vai ser a mídia onde está a imagem de instalação, que prepararemos agora. Quando eu falar em cartão SD, estou falando da mídia em que o Manjaro ficará instalado em definitivo, que vai ficar morando dentro do netbook. Se você estiver usando mídias diferentes, tenha isso em mente.

Sugiro que a formatação do pendrive seja feita no modo FAT32, que é o padrão de fábrica, normalmente. Este padrão funciona bem em qualquer sistema operacional. É bom também dar um rótulo (label) para o pendrive, vai ajudar a identificá-lo durante a instalação.

Para gravar o disco de instalação no pendrive, você vai precisar do UNetbootin. O que o UNetbootin faz é gravar uma imagem ISO em um pendrive, o que corresponde a queimar um CD, como se dizia antigamente. Uma imagem ISO é um grande arquivo compactado que contém todo o conteúdo de um CD, DVD ou Blu-Ray. Ela guarda os arquivos e alguma configuração do CD original, então não adianta você simplesmente descompactá-la no pendrive, você precisa de um programa que transforme a partição do pendrive numa cópia exata da partição que deu origem a imagem. É isso que o UNetbootin faz.

Escolha com cuidado a letra do drive onde vai gravar a imagem, para evitar apagar alguma coisa.

A primeira vez em que rodei o UNetbootin deu errado, lógico. Fui dar o boot no netbook e ele dizia que a imagem estava inválida ("Invalid or corrupt kernel image"). Aí formatei o pendrive sem usar a opção rápida (levou uma meia hora) e gravei de novo. Aí, sim, deu errado de novo! Então deixei de ser teimoso e fui olhar se o arquivo tinha sido baixado direitinho. Como se faz isso? Conferindo o checksum. Checksum é uma análise de arquivos que gera um código a partir dos dados do arquivo. Dois arquivos idênticos devem gerar exatamente o mesmo código, como no processo de assinatura digital. A maioria dos sites que têm grandes arquivos para baixar disponibiliza o checksum para você conferir. No meu caso, usei o sha1sum.


Mesmo no Windows, eu gosto de usar terminal unix, então uso muito o Cygwin. É como o "cmd" do Windows, mas você usa "ls" ao invés de "dir", por exemplo. Ou seja, os comandos do Linux. Dentro do Cygwin você pode instalar pacotes, como no Linux. Não me lembro se o sha1sum já vem com ele ou instalei, mas rodei de lá. É só dar um "sha1sum arquivo.iso" que ele te mostra o checksum do arquivo. O comando demora um pouquinho para rodar (uns 2 minutos), não se preocupe.

O meu checksum deu bem diferente do que dizia o site do Manjaro, então meu arquivo estava obviamente corrompido. Por isso tive de baixar de novo e conferir. Na segunda vez deu certinho, como vocês podem ver na imagem. O sha1sum que obtive no Cygwin foi exatamente o mesmo do arquivo que baixei do site.

Hora de rodar o UNetbootin de novo. Gravei a imagem no pendrive com ele, ejetei o pendrive e o inseri no netbook. 

Para dar boot pelo pendrive, meu netbook (Asus Eee PC 2G Surf) exige que eu use a porta USB da esquerda. Depois de inserir o pendrive, você liga o netbook e fica apertando ESC várias vezes, até surgir a tela de escolher mídia.

 No meu netbook apareceram três opções de mídia:
  • HDD, que é drive SSD embutido no netbook;
  • USB DISK, que é o pendrive onde gravei a imagem de instalação com o UNetbootin; e
  • CardReader SD0, que é o cartão SD onde pretendemos instalar o sistema operacional.
 Escolha USB Drive e você vai ver a tela de boot do UNetbootin.


Nesta tela, a opção "default" não faz nada... É a opção "start" que dá o boot pela imagem que está no pendrive. Vai entender... O processo de inicialização mostra vários erros (não foi possível montar etc/sda e outros), mas ele inicializa mesmo assim. Levou um tempinho, mas o Manjaro XFCE iniciou...

Uma vez dentro do Manjaro, você será recebido com uma grande tela de boas vindas e terá a opção "Install Manjaro" disponível logo na primeira tela. Você poderá inclusive escolher o idioma em que quer fazer a instalação. E, sim, nosso "Português do Brasil" está entre as opções!




Ao iniciar a instalação, o Manjaro faz três verificações iniciais: se você tem 6GB disponíveis, se você está ligado à rede elétrica e se você está conectado à internet. De início, eu não estava conectado à internet, mas ao clicar no ícone de rede desconectada (dois cabos de rede com um x vermelho), pude escolher a minha rede Wi-Fi e me conectar, sem nem sair da tela de instalação. Depois você escolhe o fuso horário onde está e segue para a parte que exige atenção: Tipo de Instalação.

Eu continuo (anos depois) achando que o Linux que vem de fábrica nesses EeePC é bem feito e merece continuar nele. Além disso, o HD interno (SSD, na verdade) desse bicho só tem 2GB, então não adianta tentar instalar o Manjaro nele. Assim, nossa melhor opção é gerenciar as partições nós mesmos para escolhermos o nosso cartão SD como local de instalação.

Escolhi "Gerenciar as partições da instalação do Manjaro (avançado)".

O instalador vai abrir uma tela de particionamento muito parecida com o GParted e outros programas com a mesma finalidade. Escolha com cuidado o dispositivo que quer particionar. Se estiver usando mídias de diferentes tamanhos (como eu), fica fácil. Escolha a que tem o tamanho mais próximo do cartão SD. Meu cartão é de 8GB e o mais próximo disso é o 7.40GB que ele mostra. Se seu pendrive e cartão tiverem o mesmo tamanho, olhe o rótulo das partições montadas. Lembra que falei para formatar o pendrive com um nome fácil? É por isso.

O Manjaro pode te pedir para escolher um tipo de tabela de partições. Eu escolhi msdos (MBR).

Particione o cartão SD com um espaço inicial de, pelo menos, 3MB. Você pode fazer isso criando uma partição de 3MB inicialmente (de qualquer tipo). Depois você cria uma segunda partição primária com ponto de montagem "/" (root). Aí você apaga a primeira. Você só precisa de uma partição. Há muita discussão sobre a melhor forma de particionar um disco, mas estamos trabalhando com um cartãozinho SD, melhor deixar tudo junto misturado mesmo.

Eu usei o tipo "ext4". Também existem inúmeras possibilidades de escolha de filesystem, mas meu cartão vai morar dentro do netbook, então peguei o tipo que pareceu me dar maior performance, sem me preocupar com compatibilidade com outros sistemas operacionais. Se fosse me preocupar em compartilhar esse cartão com máquinas Windows ou MAC's, eu provavelmente ficaria com o fat32.

A minha partição ficou como na imagem abaixo, 4MB iniciais (acho que já tinha esse espaço lá) e o restante todo como ponto de montagem "/" (root). Esta tela eu já tirei de dentro do Manjaro instalado.


O Manjaro também pergunta onde ele deve instalar o gerenciador de inicialização (GRUB). Eu pedi para ele colocar no mesmo cartão SD. Isso quer dizer que eu vou ter que ficar sempre apertando ESC mil vezes para entrar no meu Manjaro, mas não me importo. Assim, se alguém for fuçar no netbook, vai cair no sistema operacional original (Xandros), enquanto eu e meus leitores saberemos que o Manjaro está ali escondido ; ).

Agora, o Manjaro vai perguntar "Quem é você?". Ele quer que você defina seu usuário. Aparece uma caixinha "Utilize a senha do usuário root". Não entendi bem. Deve ser algum problema de tradução... Eu marquei e defini a senha do root também. É melhor você escolher do que ele definir algo que todo mundo sabe, menos você. Deixei o Logon automático, para facilitar a vida. Se você tiver alguma preocupação de acesso indevido, peça para ele exigir senha no log in.

Depois de todas essas configurações, o Manjaro vai ficar um tempo trabalhando... Ao final, ele avisa: "Instalação finalizada! Deseja reiniciar o sistema?". Você pode dizer que sim e correr para o abraço, seu Linux está instalado!




O Manjaro já vem com o Firefox, LibreOffice e uma boa seleção de outros programas. Ainda não precisei instalar outras coisas, mas vi que ele tem uma opção "Adicionar / remover programas".

Depois de instalar, ele ficou acusando atualizações a fazer, mas a janela não cabia na tela para eu aceitar. Se isso acontecer com vocês, vocês podem segurar a tecla Alt e arrastar um ponto qualquer da janela. Não precisa pegar a janela por cima, não. Assim você consegue achar os botões abaixo.

Aqui, a atualização não funcionou de cara. Aparentemente, uma das coisas a atualizar era o gerenciador de janelas, então tive que ir para o terminal em modo texto. Os comandos a rodar eu peguei numa resposta ao fórum Manjaro Brasil. Apertei Ctrl+Alt+F1, fiz o login e rodei os seguintes comandos:


sudo pacman -Syy
sudo pacman -S manjaro-keyring
sudo pacman -Suu

sudo pacman -Suu

Demorou um bocado! Aparentemente tinha muita coisa para ser atualizada. Se a tela ficar preta, não se assuste, é só uma proteção de tela. Aperte "Ctrl" ou outra tecla "inofensiva", que ele volta.

O último comando eu rodei mais  de uma vez mesmo. Ele atualiza uma parte e depois atualiza o resto.

Estou há alguns dias com o sistema rodando e estou gostando. Ele demora um pouquinho para iniciar no meu netbook, mas depois fica espertinho. Minha ideia é ficar com ele por perto para usar principalmente o terminal. Às vezes dou uma desconfigurada no meu Ubuntu e é legal ter uma outra máquina para dar um "ssh" nele e ver o que está acontecendo.

Se você tem um netbook como o meu e expectativas muito altas, devo dizer logo: mesmo rodando o Manjaro o meu netbook não dá conta de ver vídeos do YouTube. Os vídeos até abrem e você consegue ouvir o áudio e tal, mas é só para alguma emergência audiovisual. Para dar uma navegadinha na internet ele serve bem.

Se quiserem saber sobre algum programa específico, por favor indiquem nos comentários. Eu escolho os temas do blog com base na popularidade dos posts existentes, então há boas chances de suas sugestões aparecerem numa próxima atualização.

Para ver outros posts similares, clique nas tags manjaro, linux ou netbook, abaixo.

Abs.,
Otávio

segunda-feira, 5 de maio de 2014

Como legendar seu vídeo no YouTube

Nos meus vídeos sobre a montagem do drone, eu resolvi colocar legendas em inglês, não sei se alguém percebeu. O YouTube diz que mais pessoas podem ver o seu vídeo se você colocar legendas e acho que é verdade...

Este blog e meu canal no YouTube não têm propósito comercial, então não faz tanta diferença quantas pessoas acessam. No entanto, os vídeos sobre o drone tem uma utilidade mais prática, achei que fazia sentido tentar alcançar mais pessoas.

E para que a legenda em inglês? Eu não tenho compromisso com gringo nenhum, mas eu mesmo já acessei vídeos de russos, franceses e alguma coisa que eu tinha certeza que era romeno. Eu tenho um amigo que diz: "a única língua que eu não falo é grego". Assim como para meu amigo, russo, francês e romeno são grego para mim, então tive que me virar pelas imagens. Não teria sido bom se esses vídeos tivessem legendas numa língua que eu pudesse entender? Seria ótimo! Então estou tentando quebrar o galho de pessoas de todas as línguas que estejam interessadas em montar um tricóptero e entendam a língua inglesa. Será que consigo?

Se você quiser colocar legendas no seu vídeo também, este post vai te ensinar a fazer.

Depois que você carrega o seu vídeo, o YouTube faz uma transcrição dele. O que é isso? É um texto contendo tudo aquilo que é dito. Ou melhor, tudo que o YouTube entendeu do que foi dito. Você pode acessar esse texto na aba "Legendas ocultas" do Gerenciador de Vídeos do YouTube. Você vai ver lá que já existe uma legenda no seu vídeo, marcado como "legendas automáticas".


O software que tenta entender o seu vídeo deve ser extremamente complexo e faz o que pode para entender o que você está dizendo, mas erra feio na maioria das vezes. Se você clicar no nome da legenda, vai ver uma tela para editá-la. Ali você vai ver inúmeras referências a futebol e números que o YouTube acha que ouviu. Ali mesmo você já pode ir tocando o vídeo e corrigindo, mas eu fiz de um jeito diferente.

Eu cliquei em "Ações" e marquei "Fazer o Download .srt". Isso vai te dar um arquivo que contém todo o texto que o YouTube entendeu já com as marcações de tempo.

Então ali você vai ver que entre os 16,6 e os 17,6 segundos do vídeo eu posso ter dito "quando o mundo" e mais tarde um pouco, que "o camisa 7 do ranking..." Pois é, nada a ver...

Mesmo assim, isso serve para alguma coisa. O arquivo .srt que o YouTube monta te poupa o trabalho de começar do zero. Se você for craque em legendar vídeos com outras ferramentas, isso pode não ser problema, mas me ajudou um bocado. Eu abri esse arquivo no Notepad++, meu editor de texto favorito, mas você pode usar o que tiver disponível.

Agora tem um primeiro trabalho, meio braçal, de corrigir, linha a linha, o que foi dito. Se você escreve um script para produzir seus vídeos, talvez você já tenha uma transcrição à mão. Eu, que gravo de improviso, precisei corrigir este texto para ele refletir o que eu realmente disse. Você pode até trapacear e escrever aí alguma coisa que não disse, mas que queria deixar mais claro no texto. Ou então resumir alguma frase em que você usou palavras demais durante a gravação. A ideia é transcrever o que foi dito, de uma forma ou de outra.

Depois que você acabar, você volta para o YouTube e faz o upload do arquivo. Ali você tem acesso ao editor para corrigir o que ainda estiver errado. Tem até uns atalhos para você alterar o tempo da legenda. Você tem que clicar na área da legenda, fora do texto e fora dos números. Exige um pouco de prática, mas se você conseguir selecionar uma legenda, pode usar as teclas de seta (para cima, para baixo, etc) para fazer ela aparecer antes ou durar mais, por exemplo.

E a gente não ia fazer legendas em inglês? Até aqui você só escreveu em português... É verdade. Tudo isso foi só para corrigir a transcrição. Mas não foi em vão! Fazendo isso, já temos um texto correto e revisado e com as marcações de tempo certinhas, prontas para usar em outras línguas.

Se estiver com preguiça, talvez você possa colocar o texto no Google Tradutor ou ferramenta que o valha. Eu gosto de escrever e estou fazendo isso para que as pessoas me entendam, então traduzi manualmente linha a linha. Se você traduzir o texto mantendo as marcações de tempo, é só fazer o upload de novo e indicar o idioma que utilizou.

Pronto! Agora seu vídeo já tem legendas em inglês. E de brinde você levou uma legenda em português corretíssima, revisada pelo autor!

Feito isso, a legenda automática (o YouTube te entendendo errado) não faz mais sentido algum, então você pode desativá-la.

Imagino que quem está lendo este post já saiba assistir vídeos com legenda, mas para facilitar, vou relembrar para você explicar para seus telespectadores: é só apertar aquele retangulozinho entre o relógio e a engrenagem no canto do vídeo.
Quando um vídeo tem legenda, aquele retângulo fica branco e você seleciona o idioma por ali.

Ainda tenho muitos vídeos para produzir, transcrever e traduzir, então vou ficando por aqui.

Um abraço!

sexta-feira, 2 de maio de 2014

Tricarneiro, o drone. Ep. 2 - Eletrônica Básica

No meu post anterior eu tinha falado que ia faltar uma coisinha ou outra para montar o meu tricóptero, o Tricarneiro. Pois bem, faltou mesmo.

O site da Hobby King indicava a seguinte especificação para o Electronic Speed Controller (ESC) que comprei:

Specs:
Current Draw: 12A Continuous
Voltage Range: 2-4s Lipoly
BEC: 0.5A Linear
Input Freq: 1KHz
Firmware: afro_nfet.hex
Discharge wire/plugs: 16AWG/Male 3.5mm
Motor wire/plugs: 16AWG/Female 3.5mm
Weight: 20.3g (Included wire, plug, heat shrink)
Size: 29.5 x 22.6 x 6mm

A sacanagem está na parte dos plugs. Reparem que eles falam em 3.5mm. Isso aí me quebrou as pernas... Os plugs que vieram com os ESC's são de 2mm. E o pior (melhor?) é que os conectores são muito bem feitos, o que tira qualquer ideia de arrancá-los fora para colocar outros.

Um amigo sugeriu tirar os plugs e conectar o ESC diretamente ao drone com solda mesmo, mas achei essa solução muito permanente. Além disso, iria diminuir um pouco as possibilidades didáticas da brincadeira.

Resultado: procurei na internet os tais conectores bullet de 2mm. Encontrei alguns fornecedores no MercadoLivre. O preço não era ruim: R$ 2,99 cada par (com um macho e uma fêmea). O problema é que eu tinha pressa. Comprei logo 10 pares e paguei uns R$ 40 reais de frete. Ou seja, 70 conto em uns pedacinhos de metal.

Outra coisa que tive que comprar adicional foram os anéis de borracha para prender as hélices aos motores. Eu não sabia o que era um prop saver (salva hélice) e acabei descobrindo. É um suporte para hélices que fica preso ao motor e que permite prender a hélice a ele por um anel de borracha. O motor que comprei, um Turnigy Park300, já vem com o prop saver, mas não com o anel. Tudo bem, foi barato. R$ 13,79 por 10 unidades. E fui buscar no fornecedor, então não paguei frete.

Comprei uns fios também. O site da SoldaFria tem uma tabela muito interessante indicando que tipo de fio você precisa conforme a corrente do seu circuito. Por aquela tabela, vi que um fio de 1mm de espessura (18AWG) aguenta uma corrente de 16A. Comprei 10m de cada cor, a R$ 2,40 cada. Com o frete, uns 60 reais de fio.

No vídeo, eu mostro como usar o rádio, incluindo como resolver o erro "Switch Error" do transmissor (um Turnigy 9x) e como energizar o receptor. Não vou fazer suspense. No transmissor você vira todas as alavancas para frente e o receptor você conecta a um ESC ligado à bateria.



Vocês vão reparar no vídeo que o motor não funciona na minha primeira tentativa. Acho que o ESC precisa ser "armado" para iniciar. Usualmente, colocar o acelerador no mínimo faz esse trabalho. Eu teria que estudar um pouco mais essa história para dizer com certeza. Se souberem, por favor comentem aqui.

No próximo post devo começar a montar a estrutura. Ainda tenho bastante trabalho pela frente, então continuem acompanhando.

Para ver todos os posts deste projeto, você pode clicar na tag "tricarneiro" logo abaixo.

Abraço!

terça-feira, 22 de abril de 2014

Tricarneiro, o drone. Ep. 1 - Compras

Comecei um projeto novo!

Estou montando um drone. É um tricóptero, um multirotor. Algo como um helicóptero com três  hélices, por assim dizer.

Montar um negócio desse exige muito estudo, então vou levar muito tempo até tirar ele do chão. Assim, pensei em ir compartilhando com vocês o aprendizado que eu for adquirindo ao longo da empreitada.

O primeiro desafio que encontrei foi escolher o que eu precisava comprar. Já existem drones completos à venda, prontos para voar (os RTF, ready-to-fly), mas na época em que comecei, não havia nenhum tricóptero desse modelo. Os mais comuns são os quadricópteros e eu queria um tri. Assisto muito os vídeos do canal Flite Test e em um vídeo deles fizeram uma comparação entre quads e tris e preferiram os tri para filmagens em função do tipo de movimento que fazem. Me convenceram!

Acabei escolhendo o quadro de tricóptero fornecido pela própria Flite Test, o Bat Bone. Um dos motivos foi contribuir para a continuidade do canal, que assisto muito. Outro motivo foi a facilidade de já ter ali na página do produto as recomendações de peças para o restante, que comprei na HobbyKing.

HobbyKing é um loja online muito boa para comprar equipamentos para aeromodelismo e afins. A minha lista completa de compras vai aqui embaixo, mas por enquanto vocês podem assistir o primeiro vídeo desta série, em que abro as caixas e mostro tudo o que chegou.


Os pacotes levaram uma eternidade para chegar... Pedi o primeiro (Flite Test, dos EUA) em 30 de novembro de 2013 e o segundo (HobbyKing, vindo das Ilhas Fiji) em 19 de janeiro de 2014. Os dois acabaram chegando juntos, no início de abril de 2014. Ou seja, uns 4 meses depois da compra...

O melhor de tudo (só que não) é que eles foram tributados. Tive que pagar os famosos 60% sobre o valor do produto + frete. Vejam aqui a fatura completa:

HobbyKing
ItemQtdePreço
Turnigy 9X 9Ch Transmitter w/ Module & 8ch Receiver (Mode 2) (v2 Firmware)*JIT-Item (this item takes 3-5 days to dispatch) 1  US$53.82  
JR Transmitter Neck Strap 1  US$3.22  
IMAX B6-AC Charger/Discharger 1-6 Cells (GENUINE) 1  US$39.99  
Nylon XT60 Connectors Male/Female (5 pairs) GENUINE 1  US$3.25  
3.5mm 3 wire Bullet-connector for motor (5pairs/bag) 1  US$4.71  
Hobbyking KK2.1 Multi-rotor LCD Flight Control Board With 6050MPU And Atmel 644PA 1  US$29.95  
Afro ESC 12Amp Multi-rotor Motor Speed Controller (SimonK Firmware) 3  US$9.99  
Turnigy Park300 Brushless Outrunner 1380kv 3  US$13.99  
Turnigy 2200mAh 3S 20C Lipo Pack 2  US$7.89  
Lipoly Charge Bag 23 x 30cm 2  US$2.10  
Peel-n-stick foam double sided tape 10x5inch 4mm thick 1  US$1.19  
Y Adapter For KK2.0 Super Bright LED and Buzzer 1  US$1.95  
Scorpion Lipoly Lock Strap 205mm (Small) x 3 1  US$5.28  
Linkage Stopper D1.8mm (10pcs) 1  US$2.95  
Afro ESC USB Programming Tool 1  US$7.21  
TGY-375DMG Metal gear Digital Servo w/ Heat Sink 2.3kg / .11sec / 11.5g 1  US$18.82  
8045 SF Props 2pc CW 2 pc CCW Rotation (Orange) 2  US$2.79  
8045 SF Props 2pc CW 2 pc CCW Rotation (Green) 2  US$2.79  
Total Itens  26  US$211.89  
Frete  1  US$61.25  
Total Hobby King      US$336.67  

FliteTest
ItemQtdePreço
Bat Bone Tri 370 Kit1  US$79.00  
Desconto1  -US$11.85  
Frete1  US$20.65  
Total Flite Test      US$87.80  

Receita Federal
OrigemValor do BemFreteCotação DólarValor TributávelImposto
Flite TestUS$ 79US$ 8R$ 2,283R$ 198,62R$ 119,17
Hobby KingUS$ 300  R$ 2,2603R$ 678,09R$ 406,85
Total Receita   R$ 526,02

O total geral em reais dá para tirar dessa última tabela, somando os valores tributáveis e o imposto. Deu R$ 1.402,73. Uh! Brincadeira cara!

Claro que ainda vai faltar uma coisinha ou outra, mas vou atualizando nos próximos posts...

Abraço!

ATUALIZAÇÃO (01/05/2014): Coloquei legendas em inglês no vídeo. Achei legal o processo, depois ensino vocês!

Para ver todos os posts deste projeto, você pode clicar na tag "tricarneiro" logo abaixo.

sexta-feira, 31 de janeiro de 2014

Olho de LCD com Arduino e Nokia 5110 - #sucesso

E... voilá!!


Consegui fazer o Olho de LCD usando um display Nokia 5110 e o Arduino!!!


De início eu havia pensado em gerar um arquivo bitmap (BMP) e convertê-lo depois em código usando uma ferramenta automatizada. Ou pelo menos foi o que eu escrevi que ia fazer no meu último post...

Acabei fazendo uma coisa bem diferente... Foi um trabalho mais braçal, mas deu certo.

Primeiro, marquei com uma canetinha vermelha as divisas das linhas do display, a cada 8 quadradinhos. O display recebe os dados a exibir na forma de bytes. Cada byte contém oito bits, então os dados chegam ao display na forma de linhas com oito bits de espessura. Foram essas linhas que marquei.

Para cada uma das 6 linhas, montei uma sequência de bytes. Para ficar bem claro no código, escrevi os bytes usando o sistema binário, assim:

0b00000000 //uma linha em branco
0b11111111 //uma linha preta

O "0b" no início diz ao Arduino que estou usando o sistema binário, ou seja, só zeros e uns.
Tive que escrever o correspondente de 0 ou 1 para cada quadradinho da grade que forma o display. Ou seja, 84 x 48 = 4032. Claro que usei um bocado de Ctrl + C, Ctrl + V e escrevi em linhas de 8 bits, então foram apenas 504 linhas de código para descrever o desenho... ;)
O código inteiro está aí embaixo, usem à vontade!


Se fizerem melhorias para ele olhar para os lados, piscar, etc, por favor compartilhem! Eu quero fazer isso também, mas se forem mais rápidos que eu, vai me poupar um bocado de trabalho!

Abraços!


//Olho de LCD - v1
//Controlador de Display LCD Nokia 5110 (84x48 pixels)
//em 31 de janeiro de 2014
//Mais informacoes: umcarneiro.blogspot.com
//Licenca: MIT (use como quiser!)

//Pinos utilizados no arduino
#define PIN_SCE   7  //pino 2 do display
#define PIN_RESET 6  //pino 1 do display
#define PIN_DC    5  //pino 3 do display
#define PIN_SDIN  4  //pino 4 do display
#define PIN_SCLK  3  //pino 5 do display

//Tamanho do LCD em pixels:
#define LCD_X     84
#define LCD_Y     48

byte linhaUm[84] = {
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //5
      0b00000000,
      0b00000001,
      0b00000010,
      0b00000100,
      0b00000100,  //10
      0b00001000,
      0b00001000,
      0b00010000,
      0b00100000,
      0b00100000,  //15
      0b00100000,
      0b01000000,
      0b01000000,
      0b01000000,
      0b01000000,  //20
      0b01000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //25
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //30
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //35
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //40
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //45
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //50
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //55
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,  //60
      0b10000000,
      0b10000000,
      0b10000000,
      0b10000000,
      0b01000000,  //65
      0b01000000,
      0b00100000,
      0b00100000,
      0b00010000,
      0b00010000,  //70
      0b00001000,
      0b00001000,
      0b00000100,
      0b00000010,
      0b00000010,  //75
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //80
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000
};

byte linhaDois[84] = {
      0b00000000,
      0b00000011,
      0b00001100,
      0b00110000,
      0b01000000,  //5
      0b10000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //10
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //15
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //20
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //25
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //30
      0b00000000,
      0b00000000,
      0b00000001,
      0b00000011,
      0b00000111,  //35
      0b00000111,
      0b00001111,
      0b00001111,
      0b00001110,
      0b00011110,  //40
      0b00011111,
      0b00011111,
      0b00011111,
      0b00011111,
      0b00011111,  //45
      0b00011111,
      0b00011111,
      0b00011111,
      0b00011111,
      0b00011111,  //50
      0b00011111,
      0b00011111,
      0b00011111,
      0b00011111,
      0b00011111,  //55
      0b00011111,
      0b00011111,
      0b00011111,
      0b00001111,
      0b00001111,  //60
      0b00001111,
      0b00001111,
      0b00001111,
      0b00001111,
      0b00000111,  //65
      0b00000111,
      0b00000011,
      0b00000001,
      0b00000000,
      0b00000000,  //70
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //75
      0b00000000,
      0b10000000,
      0b01000000,
      0b00100000,
      0b00010000,  //80
      0b00001000,
      0b00000110,
      0b00000001,
      0b00000000
};

byte linhaTres[84] = {
      0b11111111,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //5
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //10
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //15
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //20
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //25
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00001111,  //30
      0b00111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //35
      0b10001111,
      0b00000111,
      0b00000111,
      0b00000011,
      0b00000011,  //40
      0b00000011,
      0b00000111,
      0b00001111,
      0b11111111,
      0b11111111,  //45
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //50
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //55
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //60
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //65
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b00111111,  //70
      0b00001111,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //75
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //80
      0b00000000,
      0b00000000,
      0b10000000,
      0b01111111
};

byte linhaQuatro[84] = {
      0b11111000,
      0b00000110,
      0b00000001,
      0b00000000,
      0b00000000,  //5
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //10
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //15
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //20
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //25
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b11100000,  //30
      0b11111000,
      0b11111100,
      0b11111111,
      0b11111111,
      0b11111111,  //35
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //40
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //45
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //50
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //55
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,  //60
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111001,
      0b11111001,  //65
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111111,
      0b11111110,  //70
      0111111000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //75
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //80
      0b00000000,
      0b00000000,
      0b00001111,
      0b11110000
};

byte linhaCinco[84] = {
      0b00000000,
      0b00000000,
      0b00000000,
      0b11000000,
      0b00110000,  //5
      0b00001100,
      0b00000010,
      0b00000001,
      0b00000000,
      0b00000000,  //10
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //15
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //20
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //25
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //30
      0b00000000,
      0b00000000,
      0b00000000,
      0b10000000,
      0b11000000,  //35
      0b11000000,
      0b11100000,
      0b11100000,
      0b11110000,
      0b11110000,  //40
      0b11110000,
      0b11111000,
      0b11111000,
      0b11111000,
      0b11111000,  //45
      0b11111000,
      0b11111000,
      0b11111000,
      0b11111000,
      0b11111000,  //50
      0b11111000,
      0b11111000,
      0b11111000,
      0b11111000,
      0b11111000,  //55
      0b11111000,
      0b11111000,
      0b11111000,
      0b11111000,
      0b11111000,  //60
      0b11110000,
      0b11110000,
      0b11110000,
      0b11110000,
      0b11100000,  //65
      0b11100000,
      0b11000000,
      0b11000000,
      0b10000000,
      0b00000000,  //70      
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //75
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000011,
      0b00000100,  //80
      0b00011000,
      0b01100000,
      0b10000000,
      0b00000000
};

byte linhaSeis[84] = {
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000,  //5
      0b00000000,
      0b00000000,
      0b00000000,
      0b10000000,
      0b01000000,  //10
      0b00100000,
      0b00010000,
      0b00010000,
      0b00001000,
      0b00001000,  //15
      0b00001000,
      0b00000100,
      0b00000100,
      0b00000100,
      0b00000010,  //20
      0b00000010,
      0b00000010,
      0b00000010,
      0b00000010,
      0b00000001,  //25
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,  //30
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,  //35
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,  //40
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,  //45
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,  //50
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,  //55
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000001,  //60
      0b00000001,
      0b00000001,
      0b00000001,
      0b00000010,
      0b00000010,  //65
      0b00000010,
      0b00000010,
      0b00000010,
      0b00000010,
      0b00000100,  //70
      0b00000100,
      0b00000100,
      0b00001000,
      0b00010000,
      0b00100000,  //75
      0b00100000,
      0b01000000,
      0b10000000,
      0b00000000,
      0b00000000,  //80
      0b00000000,
      0b00000000,
      0b00000000,
      0b00000000
};

void setup(void)
{
  pinMode(PIN_SCE, OUTPUT);   // Inicializa os pinos...
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC, OUTPUT);
  pinMode(PIN_SDIN, OUTPUT);
  pinMode(PIN_SCLK, OUTPUT);
  digitalWrite(PIN_RESET, LOW); //RESET no controlador
  digitalWrite(PIN_RESET, HIGH);
  LcdWrite(LOW, 0x21 );  // Function set: PD=0 (On); V=0 (Horizontal); H=1 (Extended instruction set)
  LcdWrite(LOW, 0xBA );  // Define o LCD Vop (Contraste). //XXXXXXXXXXXXXXX
  LcdWrite(LOW, 0x04 );  // Define o coeficiente de temperatura (??)
  LcdWrite(LOW, 0x14 );  // LCD bias mode 1:48  (??)
  LcdWrite(LOW, 0x20 );  // Function set: PD=0 (On); V=0 (Horizontal); H=0 (Basic instruction set)
  LcdWrite(LOW, 0x0C );  // Display control = 10 (Normal)
  
  limpaTela();
  
  desenhaLinha(linhaSeis);
  desenhaLinha(linhaCinco);
  desenhaLinha(linhaQuatro);
  desenhaLinha(linhaTres);
  desenhaLinha(linhaDois);
  desenhaLinha(linhaUm);   
}
  
void limpaTela(void) {
  //Percorre todas as posicoes
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(HIGH, 0);
  }
}

void desenhaLinha(byte linha[]) {
  //Percorre as colunas
  for (int coluna = 0; coluna < LCD_X; coluna++)
  {
    LcdWrite(HIGH, linha[coluna]);
  }
}


//Cuida da burocracia: envia o comando ou dado seguindo o protocolo do chip
void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc); //define se vai mandar dado ou comando
  digitalWrite(PIN_SCE, LOW); //ativa o chip para receber dados
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data); //envia um bit de cada vez, comecando pela esquerda
  digitalWrite(PIN_SCE, HIGH); //desativa o envio de dados
}

void loop(void)
{  
  //nada
}


Você pode ver todas as etapas deste projeto usando este link, ou clicando no marcador "olho_de_lcd", abaixo.

segunda-feira, 27 de janeiro de 2014

Criando um bitmap para LCD Gráfico

Há algum tempo comecei um projeto para fazer um olho de brinquedo usando um LCD Gráfico Nokia 5110. A primeira tentativa falhou, mas depois entendi como o display funciona. Resta agora colocar o meu desenho nele.

Mas que desenho?

Pois bem, como é que você desenha algo para ficar bem em determinada resolução? Eu tive que testar imprimindo uma grade na resolução do display (84x48) para rabiscar em cima.

Claro que eu poderia criar uma imagem de 84 por 48 pixels e rabiscar no computador, mas de que jeito minha filha e nossa cachorrinha participariam do projeto?


Então, para permitir mais participação, criei a grade no computador e imprimi para desenhar. Minha primeira escolha de software seria o Inkscape, mas achei mais fácil fazer no Gimp.

A primeira coisa que descobri é que uma grade de 24 por 24 pixels permite você numerar os quadrados numa boa, então usei esse tamanho. Assim, minha imagem tinha que ter 24 vezes 84 de altura e 24 vezes 48 de largura, o que dá 1152 x 2016 pixels.

Com a imagem no tamanho certo, basta criar a grade. Vá em:
Filtros -> Renderizar -> Padrão -> Grade



Achou o caminho estranho? Pois é, eu também achei...

Nas opções da grade você só precisa alterar os campos  de "Espaçamento". O padrão é 16x16, mas eu usei 24x24, como mencionei acima.

Salvei um arquivo PNG e mandei imprimir a partir do visualizador de imagens. Não sei se dava para imprimir direto do Gimp. Estou tão acostumado a fazer desse jeito que nem tentei...

O resultado final está aí do lado. Talvez, se eu tivesse usado um scanner, daria para pegar a imagem direto e redimensionar para 48x84 e já jogar em um conversor de bitmap para bytes e partir para o abraço, mas...

Não tenho um scanner e o conversor de bitmaps indicado pela Sparkfun está fora do ar... Isso quer dizer que ainda terei mais algum trabalho com esse projeto e que teremos mais posts no blog sobre o assunto.

Nos vemos em breve!

Você pode ver todas as etapas deste projeto usando este link, ou clicando no marcador "olho_de_lcd", abaixo.

quinta-feira, 16 de janeiro de 2014

LCD Nokia 5110 com Arduino #sucesso

No meu post anterior eu falei que comprei um display LCD Nokia 5110 no MercadoLivre e, inicialmente não consegui fazê-lo funcionar... Depois eu atualizei o post dizendo que ele funcionou e fiquei de dar mais detalhes depois. Bom, aqui estão os detalhes!

Display Nokia 5110 sobre datasheet Philips PCD8544

Apesar de todo mundo se referir ao display como Nokia 5110, a parte importante para conhecer é o controlador que ele tem dentro, que na verdade é feito pela Philips! O controlador/driver é um Philips PCD8544.

O datasheet dele é bem extenso (32 páginas), mas você não precisa se preocupar, está numa linguagem bem acessível e tem até um exemplo de como desenhar uma palavra na tela, mostrando o que você deve enviar, bit a bit (página 22).


Para tentar entender o funcionamento do módulo, imprimi as páginas 14 e 22 e ainda montei uma "cola" para anotar o que cada byte representava em bits.


O problema que eu estava tendo com este módulo parecia estar na definição do contraste, então criei o código abaixo para vocês testarem o módulo de vocês. O que ele faz é desenhar uma barra que vai crescendo a medida que o contraste vai aumentando.

Este gif animado dá uma ideia do resultado. O contraste ideal é aquele em que a barra fica bem escura sobre um fundo claro. Se o fundo do seu LCD escurecer, é porque você passou da conta e deve diminuir um pouquinho.


//Controlador de Display LCD Nokia 5110 (84x48 pixels)
//em 13 de janeiro de 2014
//Mais informacoes: umcarneiro.blogspot.com
//Licenca: MIT (use como quiser!)

//Pinos utilizados no arduino
#define PIN_SCE   7  //pino 2 do display
#define PIN_RESET 6  //pino 1 do display
#define PIN_DC    5  //pino 3 do display
#define PIN_SDIN  4  //pino 4 do display
#define PIN_SCLK  3  //pino 5 do display

//Tamanho do LCD em pixels:
#define LCD_X     84
#define LCD_Y     48

//Estas variaveis restringem o menor e o maior contraste a ser testado
//Se sua tela estiver muito escura desde o inicio do teste, diminua este valor
const int MIN_CONTRAST = 175; //tem que ser maior que 128
//Se sua tela estiver muito clara no fim do teste, aumente este valor
const int MAX_CONTRAST = 200; //tem que ser menor que 255


void setup(void)
{
  pinMode(PIN_SCE, OUTPUT);   // Inicializa os pinos...
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC, OUTPUT);
  pinMode(PIN_SDIN, OUTPUT);
  pinMode(PIN_SCLK, OUTPUT);
  digitalWrite(PIN_RESET, LOW); //RESET no controlador
  digitalWrite(PIN_RESET, HIGH);
  LcdWrite(LOW, 0x21 );  // Function set: PD=0 (On); V=0 (Horizontal); H=1 (Extended instruction set)
  LcdWrite(LOW, 0xBA );  // Define o LCD Vop (Contraste). //XXXXXXXXXXXXXXX
  LcdWrite(LOW, 0x04 );  // Define o coeficiente de temperatura (??)
  LcdWrite(LOW, 0x14 );  // LCD bias mode 1:48  (??)
  LcdWrite(LOW, 0x20 );  // Function set: PD=0 (On); V=0 (Horizontal); H=0 (Basic instruction set)
  LcdWrite(LOW, 0x0C );  // Display control = 10 (Normal)
  
  //Clear - apaga todas as posicoes
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(HIGH, 0x00); //bit 0 em todo mundo!
  }

}

//Cuida da burocracia: envia o comando ou dado seguindo o protocolo do chip
void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc); //define se vai mandar dado ou comando
  digitalWrite(PIN_SCE, LOW); //ativa o chip para receber dados
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data); //envia um bit de cada vez, comecando pela esquerda
  digitalWrite(PIN_SCE, HIGH); //desativa o envio de dados
}

//desenha uma barra repetindo o byte informado
void desenhaBarra(int largura, byte caracter)  
{
  //Coloca o cursor no local correto
  LcdWrite( 0, 0x80 | 0);  // Coluna 0
  LcdWrite( 0, 0x40 | 2);  // Linha 2

  //barra horizontal
  for (int index = 0; index < largura; index++)
  {
    LcdWrite(HIGH, caracter);
  }
}

void loop(void)
{  
  //dentro dos limites que estabelecemos, define o contraste a mostrar
  for (int contrast = MIN_CONTRAST; contrast < MAX_CONTRAST; contrast++)
  {  
    LcdWrite(LOW, 0x21 );  // Function set: PD=0 (On); V=0 (Horizontal); H=1 (Extended instruction set)
    LcdWrite(LOW, contrast );  // Define o contraste (VOP)
    
    //define a largura da barra proporcional ao contraste
    int largura = map(contrast, MIN_CONTRAST, MAX_CONTRAST, 0, LCD_X); 

    LcdWrite(LOW, 0x20 );  // Function set: PD=0 (On); V=0 (Horizontal); H=0 (Basic instruction set)
    LcdWrite(LOW, 0x0C );  // Display control = 10
  
    //desenha a barra horizontal na largura que definimos
    desenhaBarra(largura, 0x7f);
    delay(350); //dah um tempo para podermos ver o resultado
  }
  
  //desenha uma barra invisivel da largura da tela
  desenhaBarra(LCD_X, 0x00); //ou seja, apaga a barra!
}


Juro que este foi o código mais simples que eu consegui fazer! Enchi de comentários para ver se conseguia torná-lo inteligível. Defini o contraste usando números decimais de propósito, para facilitar a leitura.  Tem um ótimo conversor de números entre binário, decimal e hexa nesta página. Eu usei um bocado para tentar entender o que estava acontecendo.

O circuito ficou assim:



Pino LCDResistorArduinoCor
1-RST10kPino 6Vermelho
2-CE10kPino 7Azul
3-DC10kPino 5Amarelo
4-DIN10kPino 4Verde
5-CLK10kPino 3Azul
6-VCC-3.3vVermelho
7-LIGHT330RGNDAzul
8-GND-GNDPreto

O código que eu tinha usado da outra vez usava, obrigatoriamente os pinos 11 e 13, mas este é mais simples e não tem essa exigência.

Repare também que o backlight (pino 7 do LCD) foi para o GND. Confesso que não entendi bem a lógica disso, já que o backlight se acende quando colocamos +3V direto no pino 7 e GND no pino 8.


O desenho do módulo de LCD no Fritzing eu fiz por conta própria. Se quiser o arquivo ou aprender a fazer você mesmo, leia este outro post.

Espero que vocês consigam colocar as suas telinhas para funcionar!

Quem sabe em um próximo post a minha já terá virado um olho de brinquedo?

Aguardem!

UPDATE: Desenhei o olho para colocar no LCD. Vejam neste outro post.

Você pode ver todas as etapas deste projeto usando este link, ou clicando no marcador "olho_de_lcd", abaixo.