UNIVERSIDADE ANHEMBI MORUMBI
ANDERSON DA SILVA BISCONSIN
DIEGO LEITE DE SOUSA
GABRIEL TREVISAN
RAFAEL PEGORARO SOARES
DESENVOLVENDO O JOGO PONG COM ARDUINO
São Paulo
2011
ANDERSON DA SILVA BISCONSIN
DIEGO LEITE DE SOUSA
GABRIEL TREVISAN
RAFAEL PEGORARO SOARES
DESENVOLVENDO O JOGO PONG COM ARDUINO
Trabalho de Conclusão de Curso apresentado como exigência parcial para a obtenção de título de Graduação do
Curso de Ciência da Computação da Universidade
Anhembi Morumbi
Orientador: Prof. Msc. Emerson S. Paduan
São Paulo
2011
ANDERSON DA SILVA BISCONSIN
DIEGO LEITE DE SOUSA
GABRIEL TREVISAN
RAFAEL PEGORARO SOARES
DESENVOLVENDO O JOGO PONG COM ARDUINO
Trabalho de Conclusão de Curso apresentado como exigência parcial para a obtenção de título de Graduação do
Curso de Ciência da Computação da Universidade
Anhembi Morumbi
Aprovado em:
PROF. EMERSON DOS SANTOS PADUAN
Universidade Anhembi Morumbi
PROF.: REGIANE APARECIDA MARUCCI
Universidade Anhembi Morumbi
PROF.: EDSON LUIZ RECCHIA
Universidade Anhembi Morumbi
RESUMO
O Arduino é uma plataforma de prototipação eletrônica que possui diversas
versões e com módulos disponíveis para uso em diversas aplicações, ele é um
projeto que disponibiliza todas as suas documentações técnicas e diagramas
esquemáticos para uso livre sobre uma licença Open Hardware, que permite o uso
livre desses recursos contanto que os resultados sejam igualmente livres.
Ele possue uma linguagem de programação própria, que é uma modificação
da linguagem C baseada no projeto Wiring e com ambiente de desenvolvimento
escrito em Java baseado no projeto Processing, ambos projetos Open-source, ou
seja, de código aberto. O Arduino possibilita o desenvolvimento de aplicações
complexas de forma simples, facilitando o aprendizado e o desenvolvimento por
qualquer pessoa.
Para demonstrar estas características este trabalho tem o objetivo de recriar o
jogo Pong integrando a uma interface de controle fisica com as paletas de jogo.
Apresentando as características, recursos e possibilidades existentes no Arduino
desenvolvendo o jogo Pong.
Palavras-chave: Linguagem C. Eletrônica. Desenvolvimento para Arduino.
ABSTRACT
The Arduino is an electronics prototyping platform that has many versions and
modules available for use in many applications, it is a project that provides all
technical documentation and schematics for free use on an Open Hardware License,
which allows free use these resources as long as the results are equally free.
He possesses an own programming language, which is a modification of the C
language based on Wiring design and development environment written in Javabased on Processing project, both open-source project, or open source. The Arduino
allows for the development of complex applications in a simple, facilitating learning
and development by anyone.
To demonstrate these features our work aims to recreate the game Pong with
a game controller that integrates physically palettes of the game control.
Demonstrating its features, possibilities and resources developing the game Pong
with Arduino.
Key words: Language C. Electronics. Development for Arduino.
LISTA DE FIGURAS
Figura 1 - Tela do Jogo Pong .............................................................................13
Figura 2 - Tela do Jogo Tennis no Odyssey.......................................................14
Figura 3 - Protótipo Pong de 1972 .....................................................................15
Figura 4 - Arcade Pong de 1973.........................................................................15
Figura 5 - Diagrama de Blocos ..........................................................................20
Figura 6 - PWM, Ciclo de Trabalho. .................................................................21
Figura 7 – Dotklok ..............................................................................................22
Figura 8 - Wifi Robot ..........................................................................................22
Figura 9 - Arduino gamepack..............................................................................23
Figura 10 - Arduino Uno .....................................................................................24
Figura 11 - Arduino Duemilanove.......................................................................24
Figura 12 - Arduino Nano....................................................................................25
Figura 13 - Arduino Mega ..................................................................................27
Figura 14 - Arduino BT (Bluetooth) ....................................................................28
Figura 15 - Arduino LilyPad ...............................................................................28
Figura 16 - Arduino Fio ......................................................................................29
Figura 17 - Arduino Mini .....................................................................................29
Figura 18 - Arduino Pro ......................................................................................30
Figura 19 - Arduino Pro Mini...............................................................................31
Figura 20 - Arduino Mini USB Adapter ...............................................................31
Figura 21 - Uso simultâneo de Shields...............................................................32
Figura 22 - Arduino Ethernet Shield ..................................................................33
Figura 23 - Arduino Input Shield ........................................................................33
Figura 24 – Freeduino ........................................................................................34
Figura 25 – Seeeduino ......................................................................................34
Figura 26 – Severino ..........................................................................................35
Figura 27 - Brasuino BS1 ..................................................................................35
Figura 28 - IDE Processing.................................................................................36
Figura 29 - IDE Arduino .....................................................................................37
Figura 30 - Barra de Ferramentas......................................................................38
Figura 31 - Seleção de Placas Arduino..............................................................40
Figura 32 - AVR Studio.......................................................................................40
Figura 33 - Seleção de Bibliotecas.....................................................................45
Figura 34 - Ping Pong com Matriz de LEDs.......................................................47
Figura 35 - Relação, Arduino e Protótipo...........................................................48
Figura 36 - Campo de jogo ................................................................................48
Figura 37 - Componentes do Arduino Mega ......................................................50
Figura 38 - Matriz de LED 8x8 60mm ................................................................50
Figura 39 - Potenciômetro .................................................................................51
Figura 40 - Display de 7 Segmentos .................................................................51
Figura 41 - Buzzer .............................................................................................52
Figura 42 - Motor 4,5V........................................................................................52
Figura 43 - Shield Motor ....................................................................................53
Figura 44 - Chip da Shield Motor (L298N) .........................................................53
Figura 45 – Protoboard ......................................................................................54
Figura 46 – Ligações internas da Protoboard ...................................................54
Figura 47 – Fonte de Alimentação Universal .....................................................55
Figura 48 – Diagrama para ligação de uma Matriz de LEDs 8x8 .....................56
Figura 49 – Ligação do Potenciômetro ao Arduino ...........................................57
Figura 50 – Primeiro protótipo do Projeto ..........................................................58
Figura 51 – Pinos de um Display de 7 Segmentos ...........................................58
Figura 52 – Sequências de bits para exibição de numerais no Display ............59
Figura 53 – Ligação do Buzzer ao Arduino .......................................................59
Figura 54 – Diagrama de ligação da Shield Motor no Arduino ..........................61
Figura 55 – Tela Inicial .......................................................................................61
Figura 56 – Visão do Jogo .................................................................................62
Figura 57 - Telas de fim de jogo ........................................................................62
Figura 58 - Diagrama das ligações dos componentes no Arduino ....................63
Figura 59 – Projeto final .....................................................................................64
Figura 60 – Falha lógica ....................................................................................65
LISTA DE TABELAS
Tabela 1 - CRITÉRIOS OPEN HARDWARE......................................................17
Tabela 2 - TABELA COMPARATIVA DE TIPOS DE ARDUINO..........................32
Tabela 3 - BARRA DE MENUS...........................................................................40
Tabela 4 - TABELA DE VARIÁVEIS....................................................................43
SUMÁRIO
1 INTRODUÇÃO ................................................................................................11
1.1 OBJETIVO ....................................................................................................11
1.2 JUSTIFICATIVA ............................................................................................11
1.3 ABRANGÊNCIA ...........................................................................................11
1.4 ESTRUTURA DO TRABALHO ....................................................................12
2 O JOGO PONG ..............................................................................................13
3 OPEN HARDWARE ........................................................................................16
3.1 DENIFIÇÃO DOS CRITERIOS DO OPEN HARDWARE ............................16
3.1.1 DOCUMENTAÇÃO....................................................................................16
3.1.2 ESCOPO ...................................................................................................16
3.1.3 SOFTWARE NECESSÁRIO. ....................................................................17
3.1.4 PRODUTOS DERIVADOS. ......................................................................17
3.1.5 LIVRE REDISTRIBUIÇÃO ........................................................................17
3.1.6 ATRIBUIÇÃO ............................................................................................17
3.1.7 NÃO DISCRIMINAÇÃO DE PESSOAS OU GRUPOS ............................18
3.1.8 NÃO DISCRIMINAÇÃO DE CAMPOS DE UTILIZAÇÃO .........................18
3.1.9 DISTRIBUIÇÃO DA LICENÇA ..................................................................18
3.1.10 A LICENÇA NÃO DEVE SER ESPECÍFICA DE UM PRODUTO ...........18
3.1.11 NÃO RESTRINGIR OUTROS SOFTWARES OU HARDWARES ..........18
3.1.12 A LICENÇA DEVE SER TECNOLOGICAMENTE NEUTRA ..................18
4 ARDUINO .......................................................................................................19
4.1 APLICAÇÕES ..............................................................................................20
4.1.1 DOTKLOK..................................................................................................21
4.1.2 WIFI ROBOT..............................................................................................22
4.1.3 ARDUINO GAMEPACK ............................................................................23
4.2 TIPOS DE ARDUINO ...................................................................................23
4.2.1 UNO ..........................................................................................................23
4.2.2 DUEMILANOVE ........................................................................................24
4.2.3 UNO SMD .................................................................................................25
4.2.4 NANO ........................................................................................................25
4.2.5 DIECIMILA ................................................................................................26
4.2.6 MEGA ........................................................................................................26
4.2.7 MEGA 2560 ...............................................................................................27
4.2.8 BT (BLUETOOTH) ....................................................................................27
4.2.9 LILYPAD ....................................................................................................28
4.2.10 FIO ..........................................................................................................28
4.2.11 MINI .........................................................................................................29
4.2.12 PRO ........................................................................................................30
4.2.13 PRO MINI ................................................................................................30
4.2.14 MINI USB ADAPTER ..............................................................................31
4.2.15 COMPARATIVO ENTRE OS MODELOS................................................32
4.3 SHIELDS ......................................................................................................32
4.4 HARDWARES BASEADOS NO ARDUINO..................................................33
4.4.1 FREEDUINO..............................................................................................34
4.4.2 SEEEDUINO..............................................................................................34
4.4.3 SEVERINO................................................................................................35
4.4.4 BRASUINO BS1........................................................................................35
4.5 ARDUINO ALPHA (IDE) ..............................................................................36
4.5.1 CARACTERÍSTICAS DA FERRAMENTA (IDE)........................................38
4.5.2 INSTALAÇÃO ...........................................................................................41
4.5.3 UTILIZAÇÃO .............................................................................................42
4.5.4 LINGUAGENS...........................................................................................42
4.5.4.1 VARIAVEIS .............................................................................................42
4.5.4.2 FUNÇÕES .............................................................................................44
4.5.4.3 BIBLIOTECAS........................................................................................44
4.5.4.3.1 BIBLIOTECAS STANDARD.................................................................45
4.5.4.3.2 BIBLIOTECAS CONTRIBUTED..........................................................45
5 TRABALHO RELACIONADO.........................................................................46
6 MODELAGEM DO PROJETO........................................................................48
6.1 HARDWARES UTILIZADOS .......................................................................49
6.1.1 RAZÃO PARA USO DO MEGA ................................................................49
6.1.2 MATRIZ DE LED .......................................................................................49
6.1.3 POTENCIÔMETRO ..................................................................................50
6.1.4 DISPLAY CÁTODO DE SETE SEGMENTOS ..........................................50
6.1.5 BUZZER ....................................................................................................50
6.1.6 MOTOR .....................................................................................................51
6.1.7 SHIELD MOTOR DUAL H-BRIDGE .........................................................51
6.1.8 PROTOBOARD ........................................................................................52
6.1.9 FONTE DE ALIMENTAÇÃO .....................................................................53
6.2 DESENVOLVIMENTO .................................................................................54
6.2.1 FUNCIONAMENTO DO JOGO PONG .....................................................54
6.2.2 LIGANDO UMA MATRIZ DE LEDS AO ARDUINO ..................................55
6.2.3 LIGANDO UM POTENCIÔMETRO AO ARDUINO ..................................55
6.2.4 PRIMEIRO PROTÓTIPO ..........................................................................56
6.2.5 LIGANDO UM DISPLAY CÁTODO AO ARDUINO ...................................57
6.2.6 LIGANDO UM BUZZER AO ARDUINO ....................................................58
6.2.7 LIGANDO A SHIELD E UM MOTOR NO ARDUINO.................................59
6.2.8 TELAS DO JOGO .....................................................................................60
6.2.9 INTELIGÊNCIA ARTIFICIAL .....................................................................61
6.3 MONTAGEM ................................................................................................62
6.3 TESTES .......................................................................................................62
7 DIFICULDADE ENCONTRADAS...................................................................64
8 CONCLUSÃO E TRABALHOS FUTUROS....................................................64
9 TRABALHOS FUTUROS................................................................................64
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................65
APENDICE A – CÓDIGO FONTE .....................................................................71
APENDICE B – IMAGENS DO PROCESSO DE MONTAGEM .......................81
APENDICE C – COMPARAÇÃO ENTRE MODELOS .....................................81
11
1
INTRODUÇÃO
A cada ano que passa a tecnologia avança mais, e observa-se que no
mercado de Jogos e Hardwares existem grandes empresas investindo em novas
tecnologias para novos projetos (MICROSOFT, 2011; ESTADAO, 2011; VEJA,
2011). Com o objetivo de oferecer aos seus usuários maior liberdade, realismo e
interação através de novas tecnologias de captura de movimento, tornando tudo
mais próximo da realidade. Pode-se facilmente notar esses avanços observando os
jogos atuais que, com o uso da criatividade e das novas tecnologias, permitem uma
maior interação e realismo proporcionando maior liberdade de movimento. Neste
projeto foi utilizado o hardware Arduino para recriar o jogo Pong em uma interface
mais amigável, tornando o funcionamento do jogo mais interativo e realista.
1.1
OBJETIVO
Este projeto tem por objetivo desenvolver o jogo Pong utilizando o hardware
Arduino e com ele desenvolver uma nova interface de controle para este jogo, com o
objetivo de tornar o jogo mais intuitivo.
1.2
JUSTIFICATIVA
O intuito deste projeto é cobrir temas como robótica, games e eletrônica,
áreas não abordadas ou pouco discutidas pelo curso. Esse trabalho tem como
objetivo o desenvolvimento de um jogo eletrônico utilizando a placa Arduino, tendo
em vista proporcionar um aprendizado não adquirido até o momento. E tem como
motivação a criação de um trabalho divertido que incentiva o aprendizado, servindo
de referência futura para a área.
1.3
ABRANGÊNCIA
O projeto abrange o desenvolvimento do jogo eletrônico Pong sem opção
multi-jogador utilizando o open hardware Arduino como base. Será construído um
hardware que possibilitará a interação do jogador, que controlará uma das barras
12
laterais que representam as raquetes no jogo, enquanto a máquina controlará a
barra lateral oposta no jogo, os movimentos da bolinha e terá inteligência para
validar as jogadas. As barras laterais serão físicas, sendo uma delas dotada de um
controlador, enquanto a bolinha será representada virtualmente. Haverá contagem
dos pontos obtidos por cada jogador e será possível a visualização desta contagem.
A cada colisão da bolinha com uma barra lateral, um falante será acionado, emitindo
um som para representar a colisão.
1.4
ESTRUTURA DO TRABALHO
Além do capítulo introdutório, o trabalho está estruturado em 7 capítulos.
No capítulo 2 é apresentada a história do jogo Pong e curiosidades acerca do
jogo.
É abordado no capítulo 3 o significado de Open Hardware, elencando as
principais exigências do conceito no que diz respeito à documentação e licença de
distribuição.
No capítulo 4 é apresentado o Arduino, open hardware que será utilizado no
projeto, descrevendo os modelos existentes e a linguagem de programação utilizada
pelo projeto.
No capítulo 5 são abordadas a IDE e a linguagem do Arduino.
O capítulo 6 contempla o desenvolvimento e a montagem do projeto,
descrevendo os hardwares utilizados e o funcionamento da inteligência artificial.
Já no capítulo 7 são apresentadas as conclusões da monografia e sugestões
de trabalhos futuros.
13
2
O JOGO PONG
A história do jogo Pong, e também a história dos videogames, teve origem em
1951, quando Ralph Baer, um jovem engenheiro, foi encarregado de construir o
melhor aparelho de televisão do mundo. A idéia de Ralph era possibilitar que as
pessoas interagissem com o aparelho de TV, jogando. Essa idéia não foi bem aceita
pelo engenheiro chefe Sam Lackoff, e o conceito de vídeo games de Raplh Baer não
pode ser implementado. Somente em 1966, Raplh retomou a sua idéia de 1951 e
começou a construir protótipos, cerca de sete, do que viria a ser o primeiro vídeo
game da história. Em 1968, Ralph construiu seu último protótipo, a Brown Box,
(PONGSTORY, 2011).
Em 1971, Ralph Baer licencia seu projeto Brown Box para ser produzido
exclusivamente pela Magnavox e auxilia a empresa na produção de uma versão do
seu protótipo, que seria lançado no ano seguinte com o nome Odyssey, (BAER,
2011).
O jogo Pong (Figura 1) foi criado em 1972 pelo engenheiro elétrico e cientista
da computação Al Alcorn, com ajuda de Nolan Bushnell, que fundou a empresa Atari
juntamente com Ted Dabney no mesmo ano, (CLASSICGAMING, 2011; NONUBA,
2009).
Figura 1 - Tela do jogo Pong. Fonte: (OLD COMPUTERS, 2011).
Pong foi o primeiro produto da Atari e funcionava de forma semelhante a uma
partida de tênis, onde os jogadores rebatiam uma bola de um lado para outro, e era
controlado por botões rotativos, parecidos com um controlador de volume de
aparelho de som. Apesar de ser o primeiro jogo lucrativo da história, a idéia de Pong
14
não era original, pois Nolan Bushnell havia visitado uma feira e visto o jogo Tennis
(Figura 2) do videogame Odyssey e pediu que Alcorn criasse um jogo baseado nele,
a título de exercício, dado que Alcorn não tinha experiência com jogos eletrônicos.
Bushnell ficou tão surpreso com a qualidade do jogo feito por Alcorn, que decidiu
investir no jogo, (CLASSICGAMING, 2011; NONUBA, 2009).
Figura 2 - Tela do Jogo Tennis no Odyssey.
Fonte: (VIDEOGAME CONSOLELIBRARY, 2011).
No mesmo ano, Nolan Bushnell e Al Alcorn criaram um protótipo do jogo, que
possibilitava jogar contra a própria máquina ou contra um amigo mediante
pagamento, e colocaram em um bar na Califórnia, chamado "Andy Capps Tavern".
Após duas semanas da instalação do jogo, Alcorn foi informado pelo gerente do bar
que o jogo havia quebrado e que ele adoraria que o jogo fosse concertado. Quando
Alcorn verificou a máquina, encontrou um problema pouco comum. O motivo da
máquina ter parado de funcionar era a quantidade de moedas que havia dentro dela.
Em poucos meses outras empresas lançaram imitações do Pong, até que a
Magnavox, empresa responsável pelo vídeo game Odyssey, processou a Atari por
infringir as patentes de Ralph Baer, criador do videogame, em 700 mil dólares,
ocasionando
a
primeira
batalha
judicial
sobre
videogames
da
história,
(CLASSICGAMING, 2011; NONUBA, 2009).
Em 1973, foram construídas de 8 a 10 mil unidades da máquina com o jogo
Pong, conforme mostrado nas figuras 3 e 4, tornando-o um sucesso sem
precedentes. No mesmo ano, Ted Dabney vendeu metade da sua parte nas ações
da Atari para Nolan Bushnell, que criou uma nova empresa para concorrer com a
Atari, a Kee Games, (CLASSICGAMING, 2011; NONUBA, 2009).
15
Figura 3 - Protótipo Pong de 1972. Fonte: (VIDEOGAMETRADER, 2011).
A partir de 1974, diversas empresas, como Atari, Magnavox e Coleco,
começaram a trabalhar em versões caseiras do jogo Pong, aproveitando o sucesso
do Arcade. Elas criaram diversas variações do jogo nos anos seguintes, até que em
1977 Pong perdeu a sua popularidade com a chegada dos videogames baseados
em cartuchos, cujos jogos não se limitavam a variações de Pong
(CLASSICGAMING, 2011; NONUBA, 2009).
Figura 4 – Arcade Pong de 1973. Fonte: (VIDEOGAME CONSOLELIBRARY, 2011).
16
3
OPEN HARDWARE
Open Hardware é um hardware de especificação aberta, ou seja, todas as
informações necessárias para compreensão e reconstrução devem estar acessíveis
e seus arquivos abertos e lidos por qualquer programa de código aberto, isto é, sem
o auxílio de qualquer ferramenta comercial. Isso significa dizer que todo o seu
design está à disposição de todo o público, para que esse possa estudá-lo, modificálo, fazer a sua distribuição, produção e até a venda do mesmo (OPEN HARDWARE
ORG, 2011).
3.1
DENIFIÇÃO DOS CRITERIOS DO OPEN HARDWARE.
Os critérios proporcionam às pessoas a liberdade de controlar a tecnologia e
partilhar de seus conhecimentos, além de incentivar o comércio através da livre
troca de projetos. Vale salientar que não se pode fazer o uso de um open hardware
em
quaisquer
projetos
proprietários,
com
especificação
fechada
(OPEN
HARDWARE ORG, 2011).
No dia 10 de fevereiro de 2011 foi lançada uma definição de open hardware,
nela está escrita que para sua distribuição 12 critérios devem ser cumpridos (OPEN
HARDWARE ORG, 2011).
Os critérios são:
3.1.1 DOCUMENTAÇÃO.
Ele deve ser distribuído com documentação, isso deve incluir os arquivos de
design e também permitir a modificação e distribuição desses arquivos. Caso o
produto físico não venha acompanhando da documentação, deve obtê-la,
preferencialmente via download na Internet, (OPEN HARDWARE ORG, 2011).
3.1.2 ESCOPO.
Sua documentação deve especificar de forma clara quais as partes de seu
design são distribuídas sob licença, (OPEN HARDWARE ORG, 2011).
17
3.1.3 SOFTWARE NECESSÁRIO.
Caso haja a necessidade de usar um software para o hardware operar
corretamente, sua licença deve requisitar que uma das condições a seguir seja
cumprida:
a) Sua interface deve ser devidamente documentada e de maneira
descomplicada, possibilitando a criação de um software open source para que o
dispositivo possa funcionar corretamente.
b) Distribuição de uma licença open source para o software necessário.
Tornando o software alterável por qualquer pessoa, (OPEN HARDWARE
ORG, 2011).
3.1.4 PRODUTOS DERIVADOS.
Deve-se permitir a modificação e criação de produtos derivados do hardware
original. Também se deve permitir a distribuição, manufatura e venda dos produtos
derivados, contanto que os mesmos sejam distribuídos sob os mesmos termos da
licença original, (OPEN HARDWARE ORG, 2011).
3.1.5 LIVRE REDISTRIBUIÇÃO
A licença não pode fazer a cobrança de direitos autorais ou de qualquer outra
taxa para a venda ou redistribuição, (OPEN HARDWARE ORG, 2011).
3.1.6 ATRIBUIÇÃO
A licença pode fazer a requisição de nota de direitos autorais aos seus
produtos derivados, (OPEN HARDWARE ORG, 2011).
18
3.1.7 NÃO DISCRIMINAÇÃO DE PESSOAS OU GRUPOS
Não pode ser feita qualquer discriminação contra uma pessoa, ou grupo de
pessoas, (OPEN HARDWARE ORG, 2011).
3.1.8 NÃO DISCRIMINAÇÃO DE CAMPOS DE UTILIZAÇÃO
Não se deve restringir o uso do produto em nenhum campo de utilização,
(OPEN HARDWARE ORG, 2011).
3.1.9 DISTRIBUIÇÃO DA LICENÇA
Todos que tiverem produtos redistribuídos devem possuir os mesmos direitos
garantidos pela licença original, sem necessidade de nenhuma outra licença
adicional, (OPEN HARDWARE ORG, 2011).
3.1.10 A LICENÇA NÃO DEVE SER ESPECÍFICA DE UM PRODUTO
Não se deve permitir que produtos licenciados sejam partes de um produto
particular, ou seja, caso uma parte seja extraída de um produto, que esteja dentro
dos termos da licença, todas as partes devem ter os mesmos direitos garantidos do
produto original, (OPEN HARDWARE ORG, 2011).
3.1.11 A LICENÇA NÃO DEVE RESTRINGIR OUTROS SOFTWARES OU
HARDWARES
Não se deve fazer nenhuma restrição a outros itens que sejam agregados ao
produto mas não derivados do mesmo, (OPEN HARDWARE ORG, 2011).
3.1.12 A LICENÇA DEVE SER TECNOLOGICAMENTE NEUTRA
Não se pode aplicar nenhuma parte da licença a uma tecnologia em particular,
componente, material ou ao estilo da interface, (OPEN HARDWARE ORG, 2011).
19
4
ARDUINO
O conceito Arduino surgiu na Itália em 2005 com o objetivo de criar um
dispositivo para controlar projetos / protótipos construídos de uma forma que exija
menos despesas do que outros sistemas disponíveis no mercado (DA FONSECA;
BEPPU, 2010).
O Arduino é uma plataforma de computação física (são sistemas digitais
ligados a sensores e atuadores, que permitem construir sistemas que percebam a
realidade e respondam com ações físicas), baseada em uma simples placa de
Entrada / Saída microcontrolada e desenvolvida sobre uma biblioteca que simplifica
a escrita da programação em C (DA FONSECA; BEPPU, 2010).
Um microcontrolador, também denominado MCU é um computador em um
chip, que contém processador, memória e periféricos de entrada / saída, e que pode
ser
programado
com
funções
específicas,
em
contraste
com
outros
microprocessadores de propósitos gerais (como os utilizados nos PCs). Eles são
acoplados no Arduino para que o Arduino possa controlar suas funções ou ações
através de programação.
O Arduino é capaz de interpretar variáveis no ambiente e transformá-las em
sinal elétrico correspondente, através de sensores ligados aos seus terminais de
entrada, e atuar no controle ou acionamento de algum outro elemento eletroeletrônico conectado ao terminal de saída.
Ou seja, é uma ferramenta de controle de entrada e saída de dados, que
pode ser acionada por um sensor, por exemplo, um resistor dependente da luz –
LDR, e que logo após passar por uma etapa de processamento, o microcontrolador
poderá acionar um atuador, por exemplo, um motor.
É como um computador, tendo como periféricos de entrada o mouse e o
teclado, e de saída impressoras, motores de passo e caixas de som, só que fazendo
interface com circuitos elétricos, podendo receber ou enviar informações / tensões
através deles.
20
Para melhor entendimento, na figura 5 é possível identificar os elementos
principais do circuito através de um diagrama em blocos (DA FONSECA; BEPPU,
2010).
Figura 5 – Diagrama de Blocos. Fonte: (DA FONSECA; BEPPU, 2010).
O Arduino é baseado em um microcontrolador ATmega, e dessa forma é
logicamente programável, ou seja, é possível a criação de programas (Sketchs),
utilizando uma linguagem própria baseada em C, que quando implementados fazem
com que o hardware execute certas ações (DA FONSECA; BEPPU, 2010).
O grande diferencial desta ferramenta é que ela é desenvolvida e
aperfeiçoada por uma comunidade que divulga os seus projetos e códigos fonte de
aplicações, pois a concepção dela é open source (código fonte aberto). Ele foi
projetado com a finalidade de ser de fácil entendimento, programação e aplicação,
além de ser multiplataforma, ou seja, pode-se configurá-lo em ambiente Windows,
GNU / Linux e Mac OS (DA FONSECA; BEPPU, 2010).
Assim sendo, pode ser perfeitamente utilizado como ferramenta educacional
sem se preocupar com o fato do usuário não ter um conhecimento específico de
eletrônica. Entretanto, pelo fato de ter o seu esquema e software de programação
open source, chamou a atenção de todos os envolvidos na área, que começaram a
aperfeiçoar e a criar aplicações mais complexas (DA FONSECA; BEPPU, 2010).
4.1
APLICAÇÕES
O Arduino pode ser usado para desenvolver artefatos interativos stand-alone,
aplicação que não está conectada a um computador, ou conectados a um
computador através de bibliotecas para comunicação com programas como Adobe
Flash, Processing, Max/MSP, Pure Data ou Super Collider e outros demais.
21
Suas aplicações são diversas e abrangem tanto usos industriais quanto
domésticos.
Em indústrias, ele pode ser usado para controlar elevadores de carga,
esteiras rolantes, guinchos e demais máquinas através do PWM (Pulse-Width
Modulation - Modulação por Largura de Pulso).
Conforme pode ser visto na figura 6, o PWM é uma tecnologia que permite
controlar o período cíclico de alimentação ou frequência de operação do dispositivo.
Aumentando ou diminuindo o percentual energético enviado para o dispositivo
conectado ao Arduino é possível alterar a sua frequência de operação, (DA
FONSECA; BEPPU, 2010).
Figura 6 – PWM, Ciclo de Trabalho. Fonte: (DA FONSECA; BEPPU, 2010).
Já em aplicações domésticas, ele pode ser usado para controle de
iluminação, portões, cortinas elétricas, dentre outros equipamentos domésticos que
podem prover um gerenciamento de sua energia elétrica e da água de sua
residência (DA FONSECA; BEPPU, 2010).
Alguns exemplos de aplicações com o Arduino são apresentados a seguir.
22
4.1.1 DOTKLOK
O Dotklok (Figura 7) é um relógio digital feito com Arduino que exibe diversas
animações enquanto mostra as horas. Essas animações variam entre números e
padrões abstratos, figuras geométricas, código Morse, faces de um relógio analógico
e algumas inspiradas em jogos de vídeo clássicos como Pong, Tetris, Pacman e
Space Invaders.
O Dotklok possui um modo de animações aleatórias opcional, onde a
animação é alterada todo dia à meia-noite, (TECHNOETC, 2011).
Figura 7 – Dotklok. Fonte: (TECHNOETC, 2011).
4.1.2 WIFI ROBOT
O Wifi Robot (Figura 8) é um carro controlado remotamente pela internet ou
com um laptop sem fio de até 500m de distância. Ele possui uma webcam e utiliza
um roteador Linksys WRT54GL para o recebimento dos comandos. Seu código fonte
é aberto e foi distribuído sob os termos da GNU GPL v2, então qualquer pessoa
pode utilizá-lo livremente, (JBPROJECTS, 2011).
Figura 8 – Wifi Robot. Fonte: (JBPROJECTS, 2011).
23
4.1.3 ARDUINO GAMEPACK
O GamePack (Figura 9), é um projeto de um videogame portátil, baseado no
Nintendo Game Boy utilizando a tecnologia do Arduino. Ele possui uma tela de LED,
um joystick pequeno, dois botões de controle e uma bateria de lítio. Atualmente, o
GamePack está disponível em forma de kit para que pessoas possam construir a
sua versão. O seu sistema só executa alguns códigos de demonstração rudimentar,
mas a esperança é que futuramente ele rode jogos mais avançados, ou talvez um
emulador de Nintendo, (TECHNABOB, 2011).
Figura 9 – Arduino gamepack. Fonte: (TECHNABOB, 2011).
4.2
TIPOS DE ARDUINO
Atualmente, existem 13 tipos de Arduino, nesta seção são detalhadas suas
especificações e características. Também serão apresentadas as
Shields,
componentes externos que podem ser usados para se estender as funcionalidades
do Arduino.
4.2.1 UNO
O modelo Uno, mostrado na figura 10, é baseado no microcontrolador
ATmega328. Diferentemente de outros modelos, ele não faz uso do chip FTDI
(usado para converter o sinal USB para conexão UART), que foi substituído pelo
microcontrolador ATmega8U2, programado para converter USB para serial.
24
Este modelo marca a versão 1.0 do Arduino e pode ser alimentado através
da entrada USB, com um adaptador AC-DC ou uma bateria, (ARDUINO, 2011).
Figura 10 – Arduino Uno. Fonte: (ARDUINO, 2011).
4.2.4 DUEMILANOVE
O modelo Duemilanove (2009 em italiano), mostrado na figura 11, é baseado
no microcontrolador ATmega368 e ATmega168 nas versões anteriores. Esse
modelo de Arduino pode trabalhar com voltagens entre 6 e 20 volts. Entretanto, com
voltagens inferiores a 7 volts, a voltagem dos pinos não alcança os 5 volts,
apresentando instabilidade no funcionamento. O problema ocorre também com
voltagens superiores a 12, o regulador de voltagem pode superaquecer e queimar a
placa. Devido a estes problemas, as voltagens recomendadas estão entre 7 e 12
volts (ARDUINO, 2011).
Figura 11 – Arduino Duemilanove. Fonte: (ARDUINO, 2011).
25
4.2.2 UNO SMD
O modelo Uno SMD é uma versão do Arduino Uno que usa o
microcontrolador ATmega328P montado na superfície da placa, ao invés de
montada por furos. Esta versão foi feita em resposta a um escassez na oferta do
ATmega328P para montagem por furos (ARDUINO, 2011).
4.2.3 NANO
O modelo Nano, mostrado na figura 12, possui uma placa muito pequena, 0.7"
x 1.7", baseada nos microcontroladores ATmega168 ou ATmega328, dependendo
da versão. Sua funcionalidade se assemelha ao modelo Duemilanove, porém com
um pacote diferente. Ele possui uma entrada USB mini-B, que pode ser utilizada
como fonte de alimentação com voltagem entre 6 e 20 volts, ou por outra fonte de
alimentação de 5 volts (ARDUINO, 2011). O modelo com microcontrolador
ATmega168 possui 16 KB de memória flash, enquanto o modelo com
microcontrolador ATmega328 possui 32 KB. Outras diferenças entre os modelos são
o tamanho da EEPROM, 512 bytes para o modelo ATmega168 e 1 KB para o
modelo ATmega328 e da SRAM, 1 KB e 2 KB, respectivamente. Diferente dos
demais modelos de Arduino, as versões do modelo Nano não possuem o botão
Reset impresso, elas foram projetadas para serem reiniciadas via software.
Outra facilidade é o envio de código para a placa, feito através do botão
Upload no software do Arduino (ARDUINO, 2011).
Figura 12 – Arduino Nano. Fonte: (ARDUINO, 2011).
26
4.2.5 DIECIMILA
O modelo Diecimila representa a marca de 10.000 placas fabricadas e é
baseado no microcontrolador ATmega168. Ele tem basicamente as mesmas
características do Arduino Duemilanove, mas com a praticidade de que este
seleciona automaticamente a fonte de energia vindo ou da entrada USB ou da Fonte
de energia externa, enquanto o Duemilanove tem um jumper que pode ser colocado
conforme se queira utilizar (ARDUINO, 2011).
4.2.6 MEGA
O modelo Mega, mostrado na figura 13, é baseado no microcontrolador
ATmeg1280 e é o modelo que possui a maior quantidade de pinos, 54 ao todo, dos
quais 14 podem ser utilizados para saída PWM, que podem ser utilizados tanto para
entrada quanto para saída de dados.
Possui também 16 entradas analógicas, 4 portas seriais UARTS, um cristal
oscilador de 16 MHz, conexão USB, uma entrada para energia, um conector ICSP e
um botão Reset.
O Mega é compatível com a maioria das Shields projetados para os modelos
Arduino Duemilanove e Diecimila.
Além de possuir um botão Reset, este modelo foi desenhado para reiniciar
automaticamente quando conectado ao computador, permitindo o upload de novos
códigos sem a necessidade de pressionar fisicamente o botão Reset.
Existe uma trilha, identificada como "RESET-EN", que pode ser cortada para
desabilitar o auto reset e os terminais de cada lado da trilha podem ser soldadas
novamente para reativá-lo. Também é possível desativar o auto reset ligando um
resistor de 110 Ohms num pino de 5 volts e no pino Reset.
Outra característica deste modelo é a presença de um poli fusível reajustável
que protege a entrada USB contra curtos e sobre-tensões. O poli fusível quebra
27
automaticamente, caso uma corrente superior a 500 mA for aplicada a entrada USB
(ARDUINO, 2011).
Figura 13 – Arduino Mega. Fonte: (ARDUINO, 2011).
4.2.7 MEGA 2560
O modelo Mega 2560 é uma versão atualizada do modelo Mega e é baseada
no microcontrolador ATmega2560. Está versão conta também com 256 KB de
memória flash, dos quais 8 KB são reservados para o gerenciador de boot. Assim
como o modelo Uno, esta versão do modelo Mega não faz uso do chip FTDI, que foi
substituído pelo microcontrolador ATmega8U2, programado para converter USB
para serial. O Mega 2560 também é compatível com a maioria das Shields
projetados para os modelos Arduino Uno, Duemilanove e Diecimila (ARDUINO,
2011).
4.2.8 BT (BLUETOOTH)
O modelo BT, mostrado na figura 14, é baseado no microcontrolador
ATmega168 e no módulo Bluetooth Bluegiga WT11. Este modelo suporta
comunicação serial sem fio, bluetooth, mas não é compatível com fones de ouvido
ou outros dispositivos de áudio que disponham dessa tecnologia. O módulo
Bluetooth WT11 foi especialmente configurado para o uso no Arduino BT. Ele possui
um nome de identificação e exige uma senha numérica para iniciar qualquer
comunicação.
28
O gerenciador de boot se comunica utilizando o protocolo STK500, mas
também pode ser ignorado e o microcontrolador programado através do ICSP (InCircuit Serial Programming), (ARDUINO, 2011).
Figura 14 – Arduino BT (Bluetooth). Fonte: (ARDUINO, 2011).
4.2.9 LILYPAD
O modelo LilyPad, mostrado na figura 15, possui duas versões baseadas nos
microcontroladores ATmega168V, para a versão de baixa potência, e ATmega328V.
Este modelo foi desenvolvido e projetado por Leah Buechley e Eletrônica SparkFun
para computação vestível e pode ser costurado em tecidos e ligado a fontes de
alimentação, sensores e atuadores com fio condutor. Apesar de ter sido projetado
para computação vestível, não é recomendado lavá-lo. Entretanto caso isso seja
necessário é recomendado lavá-lo à mão com detergente neutro e deixar escorrer.
Também é fundamental que a placa esteja desligada da fonte de alimentação
(ARDUINO, 2011).
Figura 15 – Arduino LilyPad. Fonte: (ARDUINO, 2011).
29
4.2.10 FIO
O modelo Fio, mostrado na figura 16, é baseado no microcontrolador
ATmega328P. Este modelo foi projetado por Shigeru Kobayashi e SparkFun
Electronics, e desenvolvido pela SparkFun Electronics para aplicações sem fio. Ele
possui conexões para bateria de lítio, com um circuito para carga via USB
disponível, e uma conexão para XBee na parte inferior. Sendo destinado para
aplicações sem fio, neste modelo o usuário pode carregar programas (Sketchs) com
um cabo FTDI (cabo com conector Uart e USB) ou uma placa SparkFun. Além disso,
usando um adaptador específico é possível carregar programas (Sketchs) sem o uso
de cabos. A placa vem sem conexões pré-montadas, permitindo o uso de vários
tipos de conectores ou solda direta dos fios, (ARDUINO, 2011).
Figura 16 – Arduino Fio. Fonte: (ARDUINO, 2011).
4.2.11 MINI
O modelo Mini, mostrado na figura 17, possui uma placa um pouco maior que
a do modelo Nano e é baseado no microcontrolador ATmega168. Este modelo é
destinado ao uso em protoboards, onde o espaço é bastante escasso. É possível
programar o Arduino Mini utilizando um adaptador USB Mini, outros dispositivos
USB semelhantes ou um adaptador serial RS232 para TTL, (ARDUINO, 2011).
Figura 17 – Arduino Mini. Fonte: (ARDUINO, 2011).
30
4.2.12 PRO
O modelo Pro, mostrado na figura 18, possui duas versões, baseadas nos
microcontroladores ATmega168 e ATmega328. Este modelo não possui conexões
pré-montadas e como foi projetado para a instalação de componentes de forma
semi-permanente possibilita o uso de vários tipos de conectores ou solda direta de
fios. Sua pinagem é compatível com a maioria das Shields para Arduino. A versão
com microcontrolador ATmega168 possui 16 KB de memória flash enquanto o
ATmega328 32 KB, nas duas versões 2 KB são utilizados pelo gerenciador de boot.
O Arduino Pro não exige que o botão Reset seja pressionado antes de um
upload de código, ele foi projetado para permitir upload enquanto está conectado ao
computador. Um pino é conectado a linha de Reset do microcontrolador utilizando
um capacitor de 100 nanofarad e também à linha de controle de fluxo do hardware
que converte USB para serial. Este recurso é utilizado para que a reinicialização
funcione de forma automática e reduz o tempo de carregamento do gerenciador de
boot (ARDUINO, 2011).
Figura 18 – Arduino Pro. Fonte: (ARDUINO, 2011).
4.2.13 PRO MINI
O modelo Pro Mini, mostrado na figura 19, é baseado no microcontrolador
ATmega168 e foi projetado e fabricado pela SparkFun Electronics. Assim como
ocorre no modelo Pro ele não possui conexões pré-montadas e como foi projetado
para a instalação de componentes de forma semi-permanente, possibilita o uso de
vários tipos de conectores ou solda direta de fios.
31
Sua pinagem é compatível com o modelo Arduino Mini. Existem duas versões
do modelo Mini Pro, uma que opera a 3.3 volts e freqüência de 8 MHz, e outra que
opera a 5 volts e 16 MHz de freqüência, (ARDUINO, 2011).
Figura 19 – Arduino Pro Mini. Fonte: (ARDUINO, 2011).
4.2.14 ADAPTADORES E CONECTORES (MINI USB ADAPTER)
O Modelo Mini USB Adapter, mostrado na figura 20, é a placa que converte
uma conexão USB em TX e RX (entrada e saída) de 5 volts, permitindo
comunicação direta entre o Arduino Mini, ou outros microcontroladores, e o
computador. Esta placa é baseada no chip FT232RL da FTDI (ARDUINO, 2011).
Figura 20 – Arduino Mini USB Adapter. Fonte: (ARDUINO, 2011).
A.
CHIP FTDI E CABO FTDI
O chip FTDI FT232R é uma interface USB para serial UART com saída
opcional geradora de clock, entre 6MHz e 48MHz, e pode ser utilizado para acionar
um microcontrolador a outro dispositivo usado em conjunto (FTFICHIP ICS). O cabo
FTDI é um conversor USB para Serial UART nível TTL que permite uma interface de
dispositivos TTL para USB (FTDICHIP CABLES, 2011).
32
4.3
SHIELDS
As Shields são placas que simplificam e diminuem o custo da inclusão de
novas tecnologias nos projetos desenvolvidos com Arduino. Elas podem ser
conectadas diretamente ao Arduino aumentando seus recursos (ARDUINO
SHIELDS, 2011). Através da modularidade disponível nas Shields, o Arduino pode
trabalhar com muitas delas simultaneamente, conforme ilustrado na figura 21, caso
sejam compatíveis e suas especificações estejam de acordo com os recursos
disponíveis, (SHIELDLIST, 2011).
Figura 21 – Uso simultâneo de Shields. Fonte: (SHIELDLIST, 2011).
Para cada tecnologia existe pelo menos um modelo de Shield, Arduino
Ethernet Shield (Figura 22), usado para conexão com a Internet e o Arduino Input
Shield (Figura 23), utilizado para a construção de um joystick. Apesar da diversidade
de Shields, nem todos os modelos são compatíveis com todos os modelos de
Arduino.
Visando centralizar e reunir o máximo de informações sobre os modelos de
Shield e de sua compatibilidade com os modelos do Arduino, foi criado um banco de
dados originado no fórum de discussões oficial no site do Arduino.
Esse banco de dados enumera a maioria dos modelos de Shield disponíveis,
juntamente com a indicação dos pinos que ele utiliza, tornando mais fácil a análise
de compatibilidade (SHIELDLIST, 2011).
Existem diversos fabricantes de Shields compatíveis com Arduino, e cada
fabricante pode, ou não, distribuir a especificação do seu hardware, para isso
33
utilizam algumas das várias licenças de distribuição disponíveis, como GPL v2, GPL
v3, Creative Commons e BSD (SHIELDLIST, 2011).
Figura 22 - Arduino Ethernet Shield.
Fonte: (ARDUINO SHIELDS, 2011; HACKDAY, 2008).
Figura 23 - Arduino Input Shield. Fonte: (DFROBOT WIKI, 2010).
4.4
HARDWARES BASEADOS NO ARDUINO
Devido ao fato do Arduino ser um hardware de especificação aberta, pode-se
encontrar alguns projetos baseados em sua tecnologia e totalmente compatíveis
com ele.
Alguns exemplos são o Freeduino, Seeeduino e os modelos brasileiros
Severino e Brasuino.
4.4.1 FREEDUINO
Inicialmente, o Freeduino era um projeto colaborativo para a publicação de
arquivos de código aberto compatíveis com o Arduino. Os arquivos resultantes
34
desse projeto permitem aos usuários criar placas 100% funcionais. Com o passar do
tempo ele passou a ser um hardware independente, mas totalmente compatível com
o Arduino.
O Freeduino vem com uma licença totalmente livre e sem restrições quanto
ao uso de seu nome, ou seja, o usuário não precisa se preocupar com uma violação
de marca. A figura 24 mostra o Freeduino na sua versão 2.1, (FREEDUINO ORG
2011).
Figura 24 – Freeduino. Fonte: (FREEDUINO ORG, 2011).
4.4.2 SEEEDUINO
O Seeeduino é uma placa totalmente compatível com o Arduino, assim como
seus programas (Sketchs). Ele foi produzido pela empresa SeeedStudio e é
baseado no layout das placas Arduino Diecimila, Duemilanove e UNO, ou seja, as
posições dos pinos são as mesmas.
Na versão 2.21 ATmega 168P e ATmega 328P o seu hardware sofreu
algumas mudanças para melhorar a flexibilidade e a experiência do usuário.
A figura 25 mostra a placa Seeeduino versão 2.21 ATmega 168P,
(SEEEDSTUDIO, 2011).
Figura 25 – Seeeduino. Fonte: (SEEEDSTUDIO, 2011).
35
4.4.3 SEVERINO
O Severino é um microcontrolador projetado pelo brasileiro Adilson Akashi e
foi baseado no Arduino Diecimila ATmega8. Atualmente ele está na sua terceira
versão, (ARDUINO SEVERINO, 2011). Ele foi batizado dessa maneira pela tradição
italiana do nome Arduino e pelo fato do nome ser bem brasileiro. O projeto é
totalmente compatível com Shields, e possui 3 jumpers de fio, função auto reset e
um jumper para desligá-la (ARDUINO TUTORIAL, 2011).
A figura 26 mostra o Severino versão 3.
Figura 26 – Severino. Fonte: (ARDUINO TUTORIAL, 2011).
4.4.4 BRASUINO BS1
A Holoscópio é uma empresa que atua na área de consultoria e
desenvolvimento de soluções tecnológicas livres, e foi a responsável pelo
desenvolvimento do Brasuino BS1. O Brasuino utiliza um microcontrolador AVR
ATmega328 em 16MHz, com 32KB de memória Flash, 2KB de memória RAM e 1
KB de memória EEPROM. Utiliza um microcontrolador secundário ATmega8U2 que
pode ser usado para criar dispositivos USB diversos. Ele é compatível com o Shields
do Arduino Uno e o software Arduino (HOLOCÓPIO, 2011).
A figura 27 mostra o Brasuino BS1.
Figura 27 – Brasuino BS1. Fonte: (HOLOSCOPIO, 2011)
36
4.5
ARDUINO ALPHA (IDE)
O ambiente de desenvolvimento do Arduino é uma IDE (Integrated
Development Environment ou Ambiente Integrado de Desenvolvimento) que pode
ser usada para escrever, editar, compilar (transformar os códigos em linguagem que
o microcontrolador irá processar) e para enviar o programa compilado ao Arduino
através de interface USB, usando o botão Upload (MARGOLIS, 2011).
Essa ferramenta de desenvolvimento foi criada em Java baseado na IDE
usada pela linguagem Processing, uma linguagem de programação e ambiente de
desenvolvimento.
Criados com o intuito de proporcionar um ambiente e linguagem de fácil
entendimento para manipulação e criação de imagens, animações e interações para
uso em recursos multimídia por artistas, designers, hobbistas ou qualquer outra
pessoa (PROCESSING, 2011).
Pode-se notar na figura 28 o ambiente de desenvolvimento do Processing,
que é bem limpo e objetivo.
Figura 28 - IDE Processing. Fonte: (PROCESSING, 2011).
O resultado foi uma IDE simples e objetiva semelhante à IDE do Processing.
Na figura 29, pode-se notar a interface da Arduino IDE.
37
Essas características ajudam pessoas com pouco ou nenhuma experiência
em desenvolvimento a criar suas aplicações rapidamente.
Barra de Ferramentas
Abas
Editor de textos
Área de Mensagem
Console
Figura 29 - IDE Arduino. Fonte: (O Autor, 2011).
4.5.1 CARACTERÍSTICAS DA FERRAMENTA (IDE)
O ambiente de desenvolvimento do Arduino é um Editor AVR (uma família de
micro-controladores da fabricante ATmel), que é um ambiente de desenvolvimento
para a Linguagem C para chips Atmel, que possui uma Área de Codificação, uma
Área de Mensagens, Console, Abas, Barra de Ferramentas e uma Barra de Menus
onde estão disponíveis outras opções. Sendo este um software gratuito e Open
Source.
Os programas do Arduino são escritos usando-se a IDE (Ambiente de
Desenvolvimento Integrado), Arduino Alfa. Através dela são realizadas todas as
implementações e modificações nos programas que serão executados no
microcontrolador.
38
A Área de Mensagens mostra notificações para as ações executadas como
Salvar, Exportar (Upload) e exibição de erros. O Console exibe as respostas do
Arduino, como os programas de console Java, e através dele também é possível a
visualização das mensagens de erro completas, além de outras informações.
A Barra de Ferramentas (Figura 30), permite Abrir, Criar, Salvar, Verificar e
realizar o Upload dos programas criados. Além de permitir abrir o Monitor Serial.
Figura 30 - Barra de Ferramentas. Fonte: (O Autor, 2011).
Verify/Compile (Verificar/Compilar) – Verifica o código à procura de erros.
Stop (Parar) – Para o Monitor Serial, ou retira o foco de outros botões.
New (Novo) – Cria um novo programa (Sketch).
Open (Abrir) – Abre um Menu com os Programas no Sketch book. Ele
abre o mesmo na janela atual.
Save (Salvar) – Salva o programa.
Upload to I/O Board (Enviar) – Compila e envia o programa para a placa
do Arduino usando a porta de comunicação atual.
Serial Monitor (Monitor Serial) – Abre o Monitor Serial.
Mas como se trata de um ambiente de desenvolvimento Alfa ainda podem
ocorrer mudanças em seu desenvolvimento até a versão final, incluindo novas
funcionalidades ou resultando na exclusão de outras.
Outra opção interessante é a possibilidade de usar o modo Verbose
ampliando as funções disponíveis pelos botões, segurando-se a Tecla SHIFT e
passando o mouse pelos itens da barra de ferramentas é possível abrir programas
em novas janelas, Abrir uma nova janela de projeto ou até depurar o envio do
programa.
39
Outras opções podem ser encontradas na Barra de Menus nos menus File,
Edit, Sketch, Tools, Help. Algumas das principais opções disponíveis na IDE podem
ser vistas na tabela 1:
Tabela 1 – Barra de Menus.
Copia o código para a
Copy for Discourse
clipboard, área de
transferência, com a formatação necessária para a
postagem em Fóruns.
Copia o código para a clipboard com uma
Edit
Sketc
Copy as HTML
formatação em HTML, perfeito para uso em
Verify/Compile
páginas da web.
Procura erros no programa.
Adiciona bibliotecas ao programa
Import Library
Show Sketch Folder
h
Add File...
Auto Format
Board
Serial Port
usando
o
#include.
Abre o diretório do programa.
Adiciona um arquivo ao seu projeto. Ele irá
aparecer em uma nova aba.
Formata o código do programa.
Aqui é possível selecionar o modelo de placa
Arduino usada no programa.
Neste menu é possível selecionar os dispositivos
seriais que estão conectados ao computador, seja
o Arduino ou qualquer outra placa AVR.
Esse menu permite gravar um bootloader no
Tools
microcontrolador do Arduino. Normalmente usado
Burn Bootloader
em
placas
bootloader.
ATmega
É
que
importante
não
possuem
selecionar
a
um
placa
Arduino correta no menu Board antes de se criar o
bootloader.
Fonte: (ENVIRONMENT, 2011).
Na figura 31, pode ser visualizada uma das opções da Barra de Menu
expandida. Neste menu é possível selecionar o Arduino que será usado no
desenvolvimento de sua aplicação.
40
Figura 31: Seleção de Placas Arduino. Fonte: (O Autor, 2011).
Outros ambientes de desenvolvimento como Editores AVR também podem
ser usados, como é o caso do AVR Studio da própria Atmel, mostrado na figura 32.
Figura 32 - AVR Studio. Fonte: (USING-AVR, 2011).
4.5.2 INSTALAÇÃO
A instalação do ambiente de desenvolvimento exige do usuário apenas um
conhecimento básico de operação do sistema e como instalar drivers para novos
41
dispositivos, é recomendo se possuir acesso de administrador da maquina onde o
ambiente será instalado para se evitar problemas na hora de instalar algum recurso.
Para começar o desenvolvimento de programas no Arduino é necessário
realizar o download da IDE no site oficial (http://www.arduino.cc) na sessão
download.
Utilizando um cabo de dados que conecte o Arduino ao computador, ligue a
fonte de energia do Arduino e verifique se o LED verde acende.
Aguarde a instalação do driver (essa instalação irá falhar devido à falta do
driver no Windows), após a falha entre no Gerenciador de dispositivos e localize em
portas “Arduino UNO (COMxx)”, clique com o botão direito e escolha a opção para
Atualizar o driver que se encontra na pasta Drivers dentro do diretório da IDE
Arduino.
Siga as etapas seguintes e após a instalação do driver, o Arduino estará
pronto para o uso. Ele funciona como um pen-drive, por isso, é necessário conectálo ao computador somente para realizar o upload do novo programa.
No site do Arduino estão disponíveis tutoriais de instalação para os sistemas
MacOS e Linux, além de tutoriais específicos para cada versão do Arduino
(GETSTART, 2011).
4.5.3 UTILIZAÇÃO
A utilização da IDE é muito simples: como exemplo, abra o arquivo de Blink
em File > Examples > Basics > Blink. Escolha a versão do Arduino que será usada
em Tools > Boards.
Após ter conectado o Arduino ao computador, selecione a porta onde ele está
instalado em Tools > Serial Port. Após desenvolver seu programa, o processo de
upload é efetuado simplesmente clicando no botão Upload to I/O Board
(GETSTART, 2011).
4.5.4 LINGUAGENS
O Arduino é programado usando-se uma linguagem de programação baseada
no projeto Wiring (ARDUINO, 2011). Wiring é uma iniciativa que tem por objetivo
42
ilustrar conceitos de programação de eletrônicos e controle de mecanismos,
necessários para o entendimento das interações físicas entre hardware e software
(WIRING, 2011).
A linguagem de programação usada no Arduino Alfa trata-se de uma
modificação da linguagem C, que permite a qualquer usuário com conhecimento em
C desenvolver aplicações para o Arduino.
No Arduino os programas são chamados sketches e são criados através de
sua IDE ou qualquer Editor AVR. As definições de variáveis, funções e bibliotecas,
são feitas da mesma forma que em qualquer linguagem derivada de C.
A seguir, são demonstradas as definições e sintaxes de declaração de
variáveis, funções e inclusão de bibliotecas (ARDUINO FAQ, 2011).
4.5.4.1
VARIÁVEIS
São locais na memória onde são armazenadas informações. Possui um Nome
usado para referenciá-la, um Tipo que identifica como a informação está/será
armazenada e um Valor que se trata de seu conteúdo.
A sintaxe para a declaração de variáveis é a seguinte:
Tipo Nome = Valor;
Na tabela 2 são mostradas as variáveis disponíveis na linguagem, suas
características, memória consumida e valores aceitos. Por usar uma linguagem
baseada na linguagem C suas variáveis possuem características semelhantes.
Tabela 2 – Tabela de Variáveis.
Tipos
int
Características
Representa numero inteiros positivos e
negativos.
Memória
usada
2 Bytes
Valores possíveis
-32768 a 32767
43
unsigned
int
long
Unsigned
long
float
double
boolean
char
byte
string
void
Representa somente valores positivos.
Usado para representar valores muito
grandes com o uso de sinal.
Usado para armazenar números
inteiros muito grandes. Sem sinal.
Representa valores de precisão que
usem ponto flutuante.
Ao contrario de C, em Arduino o
double é apenas outra referência ao
tipo Float.
Representa valores booleanos como 0
e 1 ou verdadeiro e falso.
Usado para representar um único
caractere, representa valores entre
-128 até 127.
Semelhante ao char é usado para
valores sem sinal. De 0 a 255.
Representa arrays de caracteres
(char), usado para guardar textos.
Usado em funções para determinar
que nenhum valor será retornado.
Fonte: (MARGOLIS, Michael, 2011).
2 Bytes
4 Bytes
4 Bytes
4 Bytes
0 a 65535
-2147483648 a
2147483647
0 à 4294967295
3.4028235E+38 a
-3.4028235E+38
4 Bytes
-
1 Bytes
false (0) ou true (1)
1 Bytes
-128 a 127
1 Bytes
0 a 255
Não se
Aplica.
Não se
Aplica.
Não se aplica.
Não se aplica.
Nem sempre o Valor precisar ser declarado ao se iniciar a variável, também é
possível se atribuir outros valores à variável usando-se o operador de atribuição (=)
durante a execução do programa. Conforme mostrado na tabela 2, é possível o uso
de diversos tipos de variáveis (ARDUINO REFERENCES, 2011).
4.5.4.2
FUNÇÕES
Uma função é um seguimento de código que pode ser usado diversas vezes
no decorrer do programa. Nela são definidas as tarefas que serão executadas
sempre que esta for chamada. Seu uso possibilita vantagens, como a organização e
a simplificação do código, redução de erros, redução do tamanho do código e
simplifica o reuso de determinado recurso.
A declaração de uma função segue a seguinte sintaxe:
44
Tipo NomeDaFuncao(Valor){
x = Valor++;
}
Como uma variável, a função também necessita de declaração de tipos, pois
isso
define
o
tipo
de
informação
resultante
do
seu
processamento.
O
NomeDaFuncao será usado para chamar a função quando a for necessário. Na
declaração são delimitados os valores que serão passados como parâmetros para a
função durante sua chamada, e que serão usados durante sua execução, sendo
necessário seu uso em conjunto com o nome da função quando declarado. Segue a
sintaxe de chamada da função (ARDUINO REFERENCES, 2011):
NomeDaFuncao(Valor);
4.5.4.3
BIBLIOTECAS
Biblioteca é um arquivo com diversas funções, ou declarações, que possuem
ações semelhantes ou que trabalham sobre o mesmo objetivo. Um exemplo seria
uma biblioteca de comunicação que possui funções de comunicação ou que
contribuem com esse tipo de função. A declaração de uma função é bem simples:
#include “NomeBiblioteca”
Ou
#include <NomeBiblioteca>
A biblioteca é anexada ao código através do comando #include. Após sua
declaração, todas as funções e comandos desta biblioteca poderão ser usados no
código do programa da mesma forma que as funções no arquivo do programa.
O NomeBiblioteca entre < e >, é usado para definir bibliotecas nativas,
enquanto NomeBiblioteca entre as aspas duplas, é usado para definir bibliotecas
exclusivas do projeto atual. As declarações seguem o mesmo formato usado na
linguagem C, o que torna muito mais fácil seu entendimento, principalmente para
quem já possui algum conhecimento da linguagem C.
45
O Arduino possui um conjunto de bibliotecas que permitem ampliar o conjunto
de funcionalidades disponíveis. Para usá-las, basta ir até o menu Sketch > Import
Library e selecionar a biblioteca desejada conforme mostrado na figura 33.
Figura 33: Seleção de Bibliotecas. Fonte: (O Autor, 2011).
4.5.4.3.1
BIBLIOTECAS STANDARD
Essas são as bibliotecas que estão presentes na IDE do Arduino, nelas estão
funções básicas que podem ser usadas no desenvolvimento de aplicações exemplo
encontradas no site do Arduino, para desenvolvimento de Shields Standard ou para
desenvolvimento de novas aplicações.
•
EEPROM – Para leitura e escrita para armazenamento físico.
•
Ethernet – Para utilizar funções de conexão de rede da Ethernet
Shield.
•
Firmata – Para comunicação entre o computador e o Arduino usando
interface serial.
•
LiquidCrystal – Para o controle de telas de cristal líquido.
•
SD – Para leitura e escrita em cartões SD.
•
Servo – Para controle de motores do tipo Servo.
•
SPI – Para comunicação usando a interface serial Bus.
46
•
SoftwareSerial – Para comunicação serial usando os pinos digitais.
•
Stepper – Para controlar motores de paso.
•
Wire – Para comunicação de dados com dispositivos I2C / TWI.
•
Matrix – Biblioteca básica de manipulação de matriz de LED.
•
Sprite – Biblioteca básica de manipulação de imagens para animações
com uma matriz de LED.
4.5.4.3.2
BIBLIOTECAS CONTRIBUTED
Além das bibliotecas Standard, existem outras denominadas Contributed
(Contribuição), que devem ser instaladas no subdiretório Libraries do diretório do
IDE Arduino. As bibliotecas Contributed estão divididas entre as categorias de:
Comunicação, Sensores, Displays e LED, Geradores de freqüência e áudio, Motores
e PWM, Timing e Utilidades. Todas elas disponibilizadas para download gratuito
(ARDUINO LIBRARIES, 2011).
Uma das diferenças entre a linguagem Arduino e C é a existência de duas
estruturas predefinidas setup() e loop(), que são usadas em quase todos os
programas. A estrutura setup() é executada apenas uma única vez, quando o
programa é iniciado. Ela normalmente é usada para configurar recursos que serão
utilizados. A estrutura loop() é executada continuamente durante a execução do
programa. Essa estrutura é usada para executar as tarefas. Essas duas estruturas
são
usadas
para
simplificar
o
desenvolvimento
no
Arduino
(ARDUINO
REFERENCES, 2011). No site do Arduino estão disponíveis muitos tutoriais que
ensinam como trabalhar com os principais recursos do Arduino, o que ajuda na
aprendizagem.
5
TRABALHO RELACIONADO
O projeto encontrado no Blog de Bruno Soares foi a referência mais sólida e
objetiva encontrada, pois em relação as referências encontras no fórum do Arduino
essa foi a única que especificava características da matriz e que possuía um vídeo
(disponibilizado em seu blog).
Sua versão do jogo Pong foi desenvolvida para suportar dois jogadores onde
cada jogador controla uma das barras (raquetes). Porém seu código não implementa
47
nenhuma inteligência artificial, pontuador ou mesmo um motor. Como pode ser
observado na figura 34.
Figura 34 – Ping Pong com Matriz de LEDs. Fonte: (SOARES, 2009).
O projeto do Bruno Soares se iniciou com o intuito de testar uma Matriz de
LED 8x8 que ele havia obtido. Para iniciar o desenvolvimento ele inicialmente
desenvolveu um protótipo em Flash com o uso do Action Script 3.0 (linguagem de
programação do Abobe Flash). Após a prototipagem em Flash ele iniciou o
desenvolvimento no Arduino utilizando como referência para ligar os LED um código
encontrado em “Arduino Playground (DirectDriveLEDMatrix)”, mas, devido a
diferenças entre sua matriz e a explicada no código algumas alterações foram
necessárias no método doubleBuffer (responsável por ascender os LEDs da matriz),
pois as linhas cátodo do código exemplo eram as colunas cátodo da matriz
(nomenclatura usada para designar o contato positivo), o resultado foi o jogo pong
para dois jogadores com código disponível em seu blog, (SOARES, 2009).
6
MODELAGEM DO PROJETO
Neste trabalho foi realizado o desenvolvimento do jogo eletrônico Pong para
interação de 1 (um) jogador humano contra a CPU.
O hardware foi construído utilizando como base controladora o Arduino Mega,
com microcontrolador ATmega1280, que deverá controlar todos os recursos
eletrônicos, e seu funcionamento ocorrerá como exemplificado na figura 35.
48
Figura 35 - Relação, Arduino e Prototipo. Fonte: (O Autor, 2011).
A bola do jogo será desenhada em uma matriz de LEDs, denominada “campo
de jogo”, enquanto as barras verticais que servem de "raquetes" para o jogo serão
físicas.
Uma das barras verticais será controlada pelo jogador humano e outra pelo
Arduino através de um motor. Foram utilizados sensores para detecção da posição
Y das barras verticais e com esta informação, em conjunto com a informação do eixo
XY da bola, o hardware controlador irá verificar se houve, ou não, colisão entre a
bola e a barra vertical.
Caso haja colisão, a velocidade da bola será incrementada e um falante será
acionado fazendo assim o som do impacto da bola, como no jogo virtual.
Caso não haja colisão e a bola ultrapasse a marca que delimita o "campo de
jogo", conforme mostrado na figura 36, será computado um ponto. A pontuação é
exibida pelos displays de sete segmentos localizados acima do "campo de jogo".
49
Figura 36 - Campo de jogo. Fonte: (O Autor, 2011).
6.1
HARDWARES UTILIZADOS
Para
o
desenvolvimento
desse
projeto,
foram
utilizados
diversos
componentes que serão descritos a seguir:
6.1.1 RAZÃO PARA USO DO MEGA
O Arduino Mega foi escolhido para este projeto por se tratar do modelo mais
completo. Por possuir maior numero de portas entre as demais versões ele fornecia
uma vida útil maior, alem de permitir a implementação de projetos mais sofisticados.
Sua memória interna é a maior entre todos os Arduinos, ele possui uma entrada
USB, entrada para fonte de energia, um botão de reset e de não necessitar da
gravação do bootloader.
Na figura 37, é possível se observar os componentes do Arduino Mega.
50
Figura 37 – Componentes do Arduino Mega. Fonte: (ARDUINO, 2011).
Uma comparação mais detalhada pode ser observada na tabela disponível no
Apêndice C.
6.1.2 MATRIZ DE LED
Para o campo de jogo foi utilizada uma Matriz de LED 8x8 de 60mm x 60mm
RGB, mostrada na figura 38, usada para o campo de jogo.
Figura 38 – Matriz de LED 8x8 60mm. Fonte: (ITEADSTUDUIO, 2011).
6.1.3 POTENCIÔMETRO
51
Um potenciômetro, também conhecido como resistor variável, é um
dispositivo elétrico que pode ter a sua resistência elétrica alterada mecanicamente.
(UFRGS, 2011). Para esse projeto foram utilizados dois potenciômetros de 16mm,
servindo como sensores para indexar a posição das raquetes. A figura 39 mostra um
potenciômetro (comum).
Figura 39 – Potenciômetro. Fonte: (MULTI COMERCIAL, 2011).
6.1.4 DISPLAY CATODO DE SETE SEGMENTOS
Esse display é responsável por mostrar o placar do jogo, com segmentos de
cor vermelha para o CPU e de cor verde para o jogador. A figura 40 mostra um
exemplo desse display.
Figura 40 – Display de 7 Segmentos. Fonte: (ELETRODEX, 2011).
6.1.5 BUZZER
O Buzzer é um dispositivo utilizado para emitir os sons do jogo, a cada colisão
da bola, pontos marcados ou fim de jogo. A figura 41 mostra um buzzer como o
utilizado no projeto. O som do buzzer varia de acordo com a frequência e o tempo
52
de duração que são passados para ele, e para cada evento do jogo foram utilizadas
frequências e durações diferentes.
Figura 41 – Buzzer. Fonte: (DIGI-KEY CORPORATION, 2011).
6.1.6 MOTOR
Um motor de 4,5 V retirado de uma impressora foi utilizado, como visto na
figura 42. Ele é controlado pela Shield Dual H-Bridge.
Figura 42 – Motor 4,5V. Fonte: (MITSUMI, 2011).
6.1.7 SHIELD MOTOR DUAL H-BRIDGE
Essa Shield é responsável por controlar o motor de acordo com as
informações que são passadas pelo Arduino. Ela é capaz de controlar até dois
motores simultaneamente.
Sua aparência pode ser vista na figura 43.
53
Figura 43 – Shield Motor. Fonte: (DFROBOT, 2011).
A Shield possui um chip, que pode ser visto na figura 44, que tem como
principal função ativar ou desativar o motor.
Figura 44 – Chip da Shield Motor (L298N). Fonte: (ROBOKITS, 2011).
6.1.8 PROTOBOARD
A Protoboard, também conhecida como breadboard ou matriz de contato,
permite a construção de protótipos de circuitos complexos sem a necessidade de
solda. Na superfície de uma protoboard existe uma base de plástico com diversos
orifícios onde são conectados os componentes, enquanto na parte inferior existem
contatos metálicos que interligam eletricamente os componentes inseridos na placa.
Geralmente, elas suportam correntes entre 1 A e 3 A (ARDUINO PIAUI, 2010).
A figura 45 ilustra uma protoboard básica, com duas fileiras horizontais, sendo
uma na parte superior e uma na parte inferior, elas são utilizadas para alimentação e
todos os orifícios são ligados horizontalmente, em geral possuem um rótulo
indicando a fileira positiva e a negativa.
54
Figura 45 – Protoboard. Fonte: (ELETRONICA DIDATICA, 2011).
Existem também duas fileiras de orifícios verticais que são ligados na mesma
orientação, de A a E e de F a J, em todas as fileiras, conforme a imagem 46
demonstra como são as ligações internas da protoboard (ARDUINO PIAUI, 2010).
Figura 46 – Ligações internas da Protoboard.
Fonte: (ELETRONICA DIDATICA, 2011).
6.1.9 FONTE DE ALIMENTAÇÃO
Com muitos componentes eletrônicos ligados ao mesmo tempo, o consumo
de energia aumentou, tornando a bateria de 9 Volts comum e a alimentação pelo
cabo USB insuficientes.
Portanto, para suprir esta necessidade, foi utilizada uma fonte universal,
mostrada na figura 47, com a possibilidade de alteração da voltagem, entre 1.5 volts
até 12 volts.
55
Figura 47 – Fonte de Alimentação Universal. Fonte: (GSM INFORMATICA, 2011).
6.2
DESENVOLVIMENTO
Nesta seção são mostrados os passos seguidos na adaptação do jogo base
ao projeto, da implementação das novas funcionalidades e de sua montagem.
6.2.1 FUNCIONAMENTO DO JOGO PONG
O funcionamento do jogo é simples, o jogador e a Inteligência Artificial devem
impedir que a bola toque seu respectivo lado, o que pontua o oponente. Para isso o
jogador ou a CPU devem mover as barras laterais (raquetes) para interceptar a
bolinha, rebatendo a mesma para a outra extremidade da matriz. A cada ponto
marcado o contador aumenta em um ponto, o contador que alcançar três pontos
primeiro vence terminando a rodada. Exibindo uma animação de vitória caso os 3
pontos sejam alcançados pelo jogador ou de derrota caso a CPU alcance os 3
pontos.
Após o fim da rodada o jogo é iniciado novamente exibindo uma animação do
nome Pong exibido letra por letra. Essa animação também é exibida quando o jogo é
ligado.
6.2.2 LIGANDO UMA MATRIZ DE LEDS AO ARDUINO
56
Para ligar a Matriz de LEDs ao Arduino, foi utilizado, além do datasheet que
acompanha a matriz, o diagrama da figura 46. Nele é possível visualizar de forma
menos técnica as referências de linhas e colunas com cada pino da Matriz.
Figura 48 – Diagrama para ligação de uma Matriz de LEDs 8x8.
Fonte: (OOMLOUT, 2009).
A matriz utilizada possibilita a exibição de mais de uma cor por LED, porém
para este projeto só seria necessária a exibição de uma única cor e por esse motivo
nem todos os pinos da matriz estão ligados ao Arduino.
6.2.3 LIGANDO UM POTENCIÔMETRO AO ARDUINO
No potenciômetro, as conexões das extremidades são referentes a
alimentação, e devem ser ligadas nas fileiras negativas e positivas da protoboard, ou
às entradas GND e 5V do Arduino, respectivamente.
A conexão central do potenciômetro serve para a comunicação e deve ser
ligada à uma entrada analógica do Arduino.
Existem diversos modelos de potenciômetros disponíveis no mercado, porém
o modelo escolhido ofereceu uma vantagem técnica pois pode ser utilizado junto de
engrenagens.
Na figura 49 é possível se observar as ligações do potenciômetro.
57
Figura 49 – Ligação do Potenciômetro ao Arduino. Fonte: (ARDUINO, 2011).
Para que o Arduino possa ler o valor do potenciômetro deve ser utilizada a
função analogRead() e informando como parâmetro o pino ligado à conexão
central do potenciômetro, conforme trecho de código a seguir, (ARDUINO, 2011):
int potPin = 2; // Pino conectado ao potenciômetro
int val = 0;
void setup() {
}
void loop() {
var
=
analogRead(potPin);
//
ler
o
valor
do
potenciômetro
Serial.println(var); // Exibe no console valor lido do
potenciômetro
}
6.2.4 PRIMEIRO PROTÓTIPO
Para a implementação do primeiro protótipo do projeto, mostrado na figura 50,
foram implementadas adaptações ao código-fonte disponibilizado pelo Bruno Soares
para que funcionasse com os pinos do Arduino utilizados na ligação da Matriz de
LEDs e dos potenciômetros.
Sua alimentação de dava através do cabo UART conectado na USB do
computador.
58
Figura 50 – Primeiro protótipo do Projeto. Fonte: (O Autor, 2011).
Com o protótipo funcional, foram iniciadas pesquisas sobre o funcionamento
de um Display de sete segmentos, para exibição da pontuação no jogo, de um
Buzzer, para a sonorização, do controle de um Motor DC utilizando uma Shield, e
para a movimentação da raquete da CPU utilizando uma inteligência artificial.
6.2.5 LIGANDO UM DISPLAY CÁTODO AO ARDUINO
Figura 51 – Pinos de um Display de 7 Segmentos. Fonte: (TECNOMELQUE, 2011).
No diagrama da figura 49 são mostrados os pinos existentes em um Display
Cátodo. Os pinos são ligados ao Arduino em ordem alfabética, onde os pinos de A a
G são referentes aos segmentos, e devem ser ligados às entradas digitais do
Arduino, e o pino K a alimentação. Caso o display utilizado seja Cátodo, os dois
pinos K existentes no display devem ser ligados à fileira negativa da protoboard ou
às entradas GND do Arduino, caso seja Anodo, os pinos K devem ser ligados à
fileira positiva da protoboard ou à entrada 5V do Arduino (TECNOMELQUE, 2011).
59
Para que sejam exibidos numerais de 0 a 9 no Display Cátodo, uma
seqüência de bits deve ser enviada ao Display Cátodo para informar quais
segmentos deverão ser acesos ou apagados, conforme a figura 52.
Figura 52 – Sequências de bits para exibição de numerais no Display.
Fonte: (TECNOMELQUE, 2011).
6.2.6 LIGANDO UM BUZZER AO ARDUINO
Para possibilitar o uso de efeitos sonoros no projeto, foi utilizado um Buzzer,
descrito na seção 6.1.5. A ligação do Buzzer é bem simples, bastando ligar a
conexão negativa do Buzzer à fileira negativa da protoboard, ou a entrada GND do
Arduino, e a conexão positiva à uma entrada digital do Arduino, como pode ser
observado na figura 53.
Figura 53 – Ligação do Buzzer ao Arduino. Fonte: (SUHANKO, 2011).
60
Para que seja emitido qualquer som através do Buzzer, deve-se utilizar a
função tone(), informando como parâmetros o pino ligado à conexão positiva do
Buzzer, a frequência do som e a duração, conforme demonstrado no trecho de
código a seguir, (SUHANKO, 2011):
int buzzPin = 2, // Pino conectado ao positivo do buzzer
void setup(){
pinMode(buzzPin,OUTPUT); // Declara o pino buzzPin como
saída
}
void loop(){
tone(buzzPin,3100,800); // Toca tom com frequência 3100
por 800 milissegundos
delay(1000); // Delay em milissegundos
}
6.2.7 LIGANDO A SHIELD E UM MOTOR NO ARDUINO
Para ligar a shield de controle e um motor ao Arduino, foi utilizado o diagrama
da figura 54. Nele é possível visualizar uma descrição detalhada de cada uma das
conexões da shield Motor Dual H-bridge. Para controle do motor são utilizadas as
funções analogWrite() e digitalWrite().
A função analogWrite() recebe como parâmetro o pino referente a porta E
(E1 ou E2) da Shield, e a velocidade que se deseja para a movimentação do motor,
enquanto que a função digitalWrite() recebe como parâmetros o pino referente
a porta M (M1 ou M2) as Shields, e o sentido da rotação, HIGH ou LOW (DFROBOT
WIKI, 2011).
Com estas duas funções é possível mover o motor no sentido e velocidade
desejados. O motor é ligado à shield através das conexões positiva e negativas,
cada lado da shield possui duas conexões.
Para movimentar o motor no sentido correto foi necessário um teste em
conjunto com as engrenagens, isso facilitou a calibração.
61
Figura 54 – Diagrama de ligação da Shield Motor no Arduino.
Fonte: (DFROBOT WIKI, 2011).
6.2.8 TELAS DO JOGO
Por se tratar de um jogo simples, ele possui poucas telas, quatro no total. A
primeira delas é a tela de apresentação, mostrada na figura 55, onde é escrito o
termo “PONG!”, uma letra por vez, devido à limitação da matriz de LED.
Figura 55 – Tela Inicial. Fonte: (O Autor, 2011).
A figura 56 mostra a visão do jogo. Nela, a matriz de LED reproduz a bola e
as barras verticais são feitas de Lego e presas à barras de ferro. Existem também
dois displays de sete segmentos, onde são exibidos os pontos.
62
Figura 56 – Visão do Jogo. Fonte: (O Autor, 2011).
As duas últimas telas são: a tela de vitória e de derrota. Caso o jogador
humano ganhe, um rosto feliz é apresentado, caso contrário um rosto triste aparece.
Ambas as telas são mostradas na figura 57.
Figura 57 – Telas de fim de jogo. Fonte: (O Autor, 2011).
6.2.9 INTELIGÊNCIA ARTIFICIAL
O algoritmo da inteligência artificial é bem simples, ele apenas se aproxima da
bola uma casa por vez, de acordo com a posição dela no eixo Y da matriz. Isso
significa que, se a bola estiver acima da raquete da CPU ela decrementa sua
posição em um, caso esteja abaixo sua posição é incrementada em um e caso seja
igual ela não se move. Ela também não se moverá quando a bola estiver indo em
direção ao campo de defesa do jogador, a partir da posição 5 do eixo X da matriz.
63
Sua lógica é semelhante ao Robocode, onde o movimento da bolinha na tela é
acompanhado e uma ação é tomada para cada ação realizada pela bolinha.
Fazendo com que a maquina se movimente em paralelo.
O problema com essa abordagem, é que ela torna a CPU invencível, algo
inaceitável em um jogo. Para variar o nível de dificuldade do jogo foi implementado
um atraso na movimentação da CPU que influencia em sua velocidade, e a cada gol
marcado pelo jogador ele diminui esse atraso e se torna mais rápido fazendo com
que o jogo fique mais difícil. Porém uma rotina faz com que a CPU tenha uma
movimentação restringida quando o delay esta configurado para 1, tornando ela
mais lenta para buscar bolas mais rápidas quando a dificuldade esta alta.
6.3
MONTAGEM
O diagrama da figura 58 demonstra a ligação de cada componente à
protoboard e ao Arduino adotado neste projeto:
Figura 58 – Diagrama das ligações dos componentes no Arduino.
Fonte: (O Autor, 2011).
64
A protoboard e os demais componentes foram colocados dentro de uma caixa
de madeira, onde foram afixadas três barras de ferro retiradas de uma impressora.
Essas barras servem de trilhos para os carros onde ficam os cartuchos da
impressora. Esses carros também retirados da impressora, e neles foram presas
peças de Lego, que representam as raquetes do jogo.
Duas barras de ferro foram usadas para o lado do jogador, uma para prender
o carro e outra para a sua sustentação. Uma engrenagem retirada de um drive de
CD-ROM foi colada a um dos carros da impressora, para movimentar o
potenciômetro quando o carro for movido.
A terceira barra é usada no lado da CPU como apoio para o carro, enquanto
uma correia, também retirada da impressora, é usada para mover o carro, que fica
preso a ela, e girar o potenciômetro através de uma engrenagem. Um motor afixado
na caixa e ligado à Shield Dual H-Bridge, que por sua vez é ligada ao Arduino, move
a correia, que é sustentada por roldanas. Esse segundo potenciômetro é usado
apenas para saber a posição do carro, que é acessada no início do jogo. A figura 59
mostra o projeto final.
Figura 59 – Projeto final. Fonte: (O Autor, 2011).
Nos apêndices A e B podem ser encontrados o código fonte do projeto e várias
fotos das etapas do processo de montagem.
65
6.4
TESTES
Durante a etapa de testes foi encontrado um problema relacionado ao
funcionamento do jogo Pong em uma Matrix de numero Par (8x8) com raquetes com
numero Par de LED. Foi identificado que devido a esta paridade caso a raquete seja
colocada em uma posição central o jogo ficaria em Loop até a derrota da CPU ou
em alguns casos pode continuar por tempo indeterminado. Isso ocorre pois ao bater
na laterais a bolinha sempre percorre a mesma distancia para todos os casos. Para
solucionar esse problema seria necessárias uma matriz impar ou barras (raquetes)
de numero impar.
Na figura 60 é possível se observar o problema em questão.
Figura 60 – Falha lógica. Fonte: (O Autor, 2011).
Mas como o jogador costuma alternar a posição da aste essa situação foi
considerada aceitável, pois isso só ocorre se o lado especifico da aste tocar na
bolinha. Pois permitia ao jogador ter uma vantagem imperceptível durante a partida
contra a CPU.
66
7
DIFICULDADE ENCONTRADAS
Durante o desenvolvimento do projeto, um dos maiores problemas
enfrentados foi referente a compra dos equipamentos, pois parte dos hardwares que
foram utilizados no projeto foi adquirida no exterior e o tempo para entrega somado
ao atraso gerado pela greve dos correios atrapalharam o cumprimento do
cronograma. Outro problema enfrentado, foi durante a pesquisa sobre o
funcionamento de alguns equipamentos, como por exemplo, a shield para motor. A
documentação que acompanhava a shield estava no idioma coreano e após
pesquisas utilizando o modelo da shield, foi encontrada documentação em inglês.
No início do projeto, também foram enfrentados problemas relacionados aos
pinos do Arduino Mega 1280, pois os exemplos disponíveis na internet, em sua
maioria, foram desenvolvidos utilizando os modelos Uno e Duelimanove, que
possuem pinagem diferente do modelo utilizado no projeto. Estudadas as
equivalências dos pinos desses modelos com o Arduino Mega 1280, foram feitas
adaptações dos códigos de exemplo e o desenvolvimento se tornou mais simples.
No desenvolvimento da jogabilidade da CPU, foram enfrentadas dificuldades
em relação a sincronização das partes mecânica e eletrônica do jogo. A ideia de que
as raquetes do jogo fossem físicas demandou o uso de engrenagens para girar os
potenciômetros, e dado o alto custo dessas engrenagens, elas foram adaptadas de
uma impressora multifuncional.
Para a movimentação das raquetes do jogo, também foram utilizadas,
inicialmente, peças de um drive de CD-ROM. A idéia acabou sendo descartada por
limitar o espaço de movimentação da raquete e as peças do driver também foram
substituídas pelas peças da multifuncional.
67
8
CONCLUSÃO E TRABALHOS FUTUROS
No desenvolvimento deste projeto foi constatado que a linguagem usada pelo
Arduino é basicamente C, e que ela não permite orientação a objeto sendo sua
lógica estruturada. O funcionamento do Arduino em conjunto com a Shield de motor
foi melhor entendido e está intimamente ligado a amperagem disponível na fonte de
energia. Foi possível também a compreender o funcionamento de um circuito
elétrico fechado, devido a simplicidade e facilidade de desenvolvimento em Arduino.
Com a utilização de peças e partes de equipamentos quebrados e
inutilizados, foi possível a montagem dos mecanismos usados para mover e fixar os
componentes de jogo na caixa.
O estudo dos diagramas retirados de sites dos fabricantes, todos disponíveis
gratuitamente, de cada componente tornou possível o entendimento de seu
funcionamento e o uso para a construção do jogo Pong.
9
TRABALHOS FUTUROS
68
Para os trabalhos futuros referentes a este projeto estão previstas melhorias
na estrutura do hardware e das peças usadas no jogo, a impressão de uma placa de
circuito impresso (PCB), a implementação de um botão de Liga / Desliga e de um
melhor acabamento.
É esperado o desenvolvimento de novos trabalhos, como robôs autônomos e
utensílios para casas inteligentes com o uso de Shields.
Tendo como base os conhecimentos adquiridos com este projeto, como a
criação equipamentos autônomos ou controlados por computador.
REFERÊNCIA BIBLIOGRÁFICAS
69
ARDUINO SEVERINO. Arduino Single-Sided Serial Board, 2011. Disponível em:
<http://www.arduino.cc/en/Main/ArduinoBoardSerialSingleSided3> Acessado em 30
de agosto de 2011.
ARDUINO. Entrada analógica, 2011. Disponível em:
<http://www.arduino.cc/playground/Portugues/LearningAnalogInput> Acessado em
17 de setembro de 2011.
ARDUINO FAQ. Frequently Asked Questions Arduino, 2011. Disponível em:
<http://www.arduino.cc/en/Main/FAQ> Acessado em 26 de abril de 2011.
ARDUINO LIBRARIES. Writing a Library for Arduino, 2011. Disponível em:
<http://www.arduino.cc/en/Hacking/LibraryTutorial> Acessado em 1 de maio de
2011.
ARDUINO REFERENCES. Language Reference, 2011. Disponível em:
<http://www.arduino.cc/en/Reference/> Acessado em 29 de abril de 2011.
ARDUINO HARDWARE. Hardware, 2011. Disponível em:
<http://www.arduino.cc/en/Main/Hardware> Acessado em 27 de abril de 2011.
ARDUINO PIAUI. Conectando um LED externo ao Arduino, 2010. Disponível em:
<http://www.arduinopi.net/2010/12/conectando-um-led-externo-ao-arduino.html>
Acessado em 17 de setembro 2011.
ARDUINO SHIELDS. Shields, 2011. Disponível em:
<http://www.arduino.cc/en/Main/Arduinoshields> Acessado em 4 de maio de 2011.
ARDUINO TUTORIAL. Arduino Severino USB/Serial DIY, 2011. Disponível
em:<http://arduinotutorial.blogspot.com/> Acessado em 27 de junho de 2011.
BAER, Ralph. Video Game History, 2011. Disponível em:
<http://www.ralphbaer.com/> Acessado em 15 de agosto de 2011.
70
CLASSICGAMING. História do Jogo Pong, 2011. Disponível em:
<http://www.classicgaming.com.br/cgi-bin/vgh/03.asp?IDConsole=4> Acessado em
06 de abril de 2011.
DFROBOT WIKI. Arduino Input Shield, 2011 Disponível em:
<http://www.dfrobot.com/wiki/index.php?
title=Arduino_Input_Shield_(SKU:_DFR0008)> Acessado em 10 de maio de 2011.
DA FONSECA, Erika Guimarães Pereira; BEPPU, Mathyan Motta. Apostila Arduino Universidade Federal Fluminense - Centro Tecnológico e Engenharia, Niterói, 2010.
Disponível em:
<http://www.telecom.uff.br/pet/petws/downloads/tutoriais/arduino/Tut_Arduino.pdf>
Acessado em 29 de abril de 2011.
DIGI-KEY CORPORATION. Buzzer, 2011. Disponível em:
<http://kr.digikey.com/1/5/index15.html> Acessado em: 30 de outubro de 2011.
DFROBOT. 2A Dual Motor Controller, 2011. Disponível em:
<http://www.dfrobot.com/index.php?route=product/product&path=51&product_id=66>
Acessado em: 30 de outubro de 2011.
ELETRODEX. Display 7 Segmentos + PT 2,3" Vermelho, 2011. Disponível em:
<http://eletrodex.com.br/Produto-7-Segmentos--Matriz-Display-7-Segmentos--PT-23Vermelho-versao-396-955.aspx> Acessado em: 30 de outubro de 2011.
ELETRONICA DIDATICA. PROTOBOARD, 2011. Disponível em:
<http://eletronicadidatica.com.br/equipamentos/protoboard/protoboard.htm>
Acessado em 11 de novembro de 2011.
ENVIRONMENT. Arduino Development Environment, 2011. Disponível em:
<http://www.arduino.cc/en/Guide/Environment/> Acessado em 7 de maio de 2011.
71
ESTADAO. Nintendo mostra Wii com controle em forma de tablet, 2011. Disponível
em: <http://www.estadao.com.br/noticias/impresso,nintendo-mostra-wii-comcontrole-em-forma-de-tablet,729405,0.htm> Acessado em 30 de agosto de 2011.
FREEDOMDEFINED. OSHW, 2011. Disponível em:
<http://freedomdefined.org/OSHW> Acessado em 30 de abril de 2011.
FREEDUINO ORG. About Freeduino, 2011. Disponível em:
<http://www.freeduino.org/about.html> Acessado em 27 de junho de 2011.
FTDICHIP CABLES. USB TTL Serial Cables, 2011. Disponível em:
<http://www.ftdichip.com/Products/Cables/USBTTLSerial.htm> Acessado em 3 de
maio de 2011.
FTDICHIP ICS. FT232R - USB UART IC, 2011. Disponível em:
<http://www.ftdichip.com/Products/ICs/FT232R.htm> Acessado em 3 de maio de
2011.
GETSTART. Getting Started w/ Arduino on Windows, 2011. Disponível em:
<http://www.arduino.cc/en/Guide/Windows/> Acessado em 2 de maio de 2011.
GSM INFORMATICA. Fonte Universal Bivolt VAC 1000MA ST1462P – Smart, 2011.
<http://www.gsmi.com.br/index.php?local=7&id=120&pid=423> Acessado em 14 de
novembro de 2011.
HACKDAY. Oficial Arduino Ethernet Shield, 2011. Disponível em:
<http://hackaday.com/2008/11/06/official-arduino-ethernet-shield/> Acessado em 10
de maio de 2011.
HOLOSCOPIO. Brasuino Holoscópio, 2011. Disponível em:
<http://brasuino.holoscopio.com/> Acessado em 28 de junho de 2011.
72
ITEADSTUDUIO. 60mm square 8x8 LED Matrix - super bright RGB, 2011.
Disponível em: <http://iteadstudio.com/store/index.php?
main_page=product_info&products_id=189> Acessado em: 30 de outubro de 2011.
JBPROJECTS. Wifi Robot, 2008. Disponível em:
<http://www.jbprojects.net/projects/wifirobot/> Acessado em 25 de Agosto de 2011.
MARGOLIS, Michael – Livro Arduino Cookbook, O’Reilly Media, Inc., 1005
Gravenstein Highway North, Sebastopol, (46 p). Editora O’REILLY, 2011.
MICROSOFT. Microsoft anuncia grandes lançamentos para Xbox 360 durante a E3
e surpreende indústria de games, 2011. Disponível em:
<http://www.microsoft.com/latam/presspass/brasil/2009/junho/e3.mspx> Acessado
em 30 de agosto de 2011.
MITSUMI. M36N-1 Series DC Mini-Motors, 2011. Disponível em:
<http://www.mitsumi.co.jp/latest/Catalog/compo/motorav/m36n1series_e.html>
Acessado em: 11 de novembro de 2011.
MULTI COMERCIAL. Potenciômetro 16mm com eixo Estriado, 2011. Disponível em:
<http://loja.multcomercial.com.br/ecommerce_site/produto_6473_4689_Potenciometr
o-16mm-com-eixo-Estriado> Acessado em: 30 de outubro de 2011.
NONUBA. Momento Old School: A história de Pong, 2009. Disponível em:
<http://www.nonuba.com.br/exclusivos/curiosidades/934-momento-old-school-ahistoria-de-Pong> Acessado em 07 de abril de 2011.
OLD COMPUTERS. Pong, 2011. Disponível em:
<http://www.old-computers.com/museum/software_detail.asp?id=315> Acessado em
08 de abril de 2011.
OPEN HARDWARE ORG. Open Hardware Definition 1.0 Released, 2011 Disponível
em: <http://www.openhardwaresummit.org/2011/02/10/Open-Hardware-definition-10-released/> Acessado em 30 de abril de 2011.
73
OOMLOUT. LED Displays, 2009. Disponível em: <http://oomlout.com/8X8M/8X8MGuide.pdf> Acessado em 17 de setembro 2011.
PROCESSING. Processing, 2011. Disponível em: <http://www.processing.org/>
Acessado em 6 de maio de 2011.
PONGSTORY. Welcome to PONG-Story - The Site of the First Video Game, 2011.
Disponível em: <http://www.pong-story.com/intro.htm> Acessado em 15 de agosto
de 2011.
ROBOKITS. L298 Motor Driver, 2011. Disponível em:
<http://robokits.co.in/shop/index.php?
main_page=product_info&cPath=14_17&products_id=80> Acessado em: 30 de
outubro de 2011.
SEEEDSTUDIO. Seeeduino v2.21, 2011 Disponível em:
<http://garden.seeedstudio.com/index.php?title=Seeeduino_v2.21#Schematic>
Acessado em 27 de junho de 2011.
SHIELDLIST. Sparkfun Joystick Shield, 2011. Disponível em:
<http://shieldlist.org/sparkfun/joystick> Acessado em 10 de maio de 2011.
SHIELDLIST. Arduino Shield List, 2011. Disponível em: <http://www.shieldlist.org/>
Acessado em 10 de maio de 2011.
SOARES, Bruno. Ping Pong com Matriz de LEDs 8×8, 2009. Disponível em:
<http://blog.bsoares.com.br/arduino/ping-pong-with-8x8-led-matrix-on-arduino>
Acessado em 17 de setembro de 2011.
SUHANKO, Djames. Eletrônica digital com Arduino – Buzzer, parte 1, 2011.
Disponível em: <http://suhanko.com/2011/06/26/eletronica-digital-com-arduinobuzzer-parte-1/> Acessado em 19 de setembro de 2011.
TECHNOETC. DOTKLOK, 2011. Disponível em: <http://www.technoetc.net/dotklok/>
Acessado em 25 de Agosto de 2011.
74
TECNOMELQUE. Arduino dimmer com display de sete segmentos, 2011. Disponível
em: <http://tecnomelque.blogspot.com/2011/01/arduino-dimmer-com-display-desete.html> Acessado em 19 de setembro de 2011.
TECHNABOB. Arduino Gamepack: Make Your Own Open Source Gameboy
, 2011. Disponível em:
<http://technabob.com/blog/2008/10/27/arduino-gamepack-make-your-own-opensource-gameboy/> Acessado em 25 de Agosto de 2011.
USING-AVR, Using AVR Studio 5, 2011. Disponível em:
<http://maxembedded.wordpress.com/2011/06/12/using-avr-studio-5/> Acessado em
31 de agosto de 2011.
WIRING, About Wiring, 2011. Disponível em: <http://www.wiring.org.co/> Acessado
em 25 de abril de 2011.
UFRGS, Instituto de Física UFRGS, 2011, Disponível em:
<http://www.if.ufrgs.br/mpef/mef004/20061/Cesar/SENSORES-Potenciometro.html>
Acessado em 2 de novembro de 2011
VEJA. Sony lança sensor de movimento para Playstation 3, 2011. Disponível em:
<http://veja.abril.com.br/noticia/vida-digital/sony-lanca-sensor-de-movimento-paraplaystation-3> Acessado em 30 de agosto de 2011.
VIDEOGAMECONSOLELIBRARY, Magnavox Odyssey, 2011. Disponível em:
<http://www.videogameconsolelibrary.com/pg70-odyssey.htm> Acessado em 06 de
abril de 2011.
VIDEOGAMETRADER, The story behind Pong and Andy Capp’s Tavern, 2011.
Disponível em:<http://www.videogametrader.com/2009/03/31/the-story-behind-Pongand-andy-capps-tavern/> Acessado em 07 de abril de 2011.
71
APENDICE A – CÓDIGO FONTE
/**
* Pong com
*
* @author
*
*
*
*
* @version
*/
Arduino
Rafael Pegoraro Soares
Diego Leite de Souza
Anderson Bisconsin
Gabriel Trevisan
1.6b
#include "TimerOne.h"
// Pinos de controle das barras do jogo
#define PIN_LEFT 5
#define PIN_RIGHT 4
// Pino de conbtrole do buzzer
#define PIN_BUZZER 36
// Pinos de ligacao do Motor
#define PIN_DM 2
#define PIN_AE 3
// Forca do motor
#define MOTOR_POWER 215
unsigned int left = 0;
unsigned int right = 0;
unsigned int motor_pot = 0; //variavel pro potenciometro do motor
int angle = 0;
// Pinos ligados ao display de 7 segmentos
int pts_right[7] = {34, 32, 30, 28, 26, 24, 22};
int pts_left[7] = {35, 33, 31, 29, 27, 25, 23};
// Pinos onde estao ligadas linha e colunas da matriz de LEDs
byte rows[8] = {4, 5, 6, 7, 8, 9, 18, 19};
byte cols[8] = {10, 11, 12, 13, 14, 15, 16, 17};
// Referencias a tela do jogo (Matriz de LEDs)
byte screen[8] = {0, 0, 0, 0, 0, 0, 0, 0};
volatile byte screenRow = 0;
volatile byte screenCol = 0;
// Cada byte abaixo corresponde a um numero no display. Desprezando o
primeiro 0 cada bit corresponde a um segmento (a,b,c,d,e,f,g)
respectivamente.
// Bit 1 significa segmento correspondente aceso. Bit 0 significa
segmento correspondente apagado
//
0
1
2
3
4
5
6
7
8
9
byte
numero[10] = {B01111110, B00110000, B01101101, B01111001,
B00110011, B01011011, B01011111, B01110000, B01111111, B01111011};
int _angle; // Angulo da direcao da bolinha
int _px; // Posicao X
int _py; // Posicao Y
72
int _w = 8; // Largura do campo de jogo (7 com a barra e 8 sem)
int _h = 7; // Altura do campo de jogo
int _wall[] = {3, 3}; // Dimensoes das barras (raquetes)
int _count = 0; // Temporizacao para reducao da velocidade da bolinha
no jogo
int _speed = 3; // Velocidade da bolinha
int _countPoints = 0; // Quanto maior o valor mais rapida fica a
bolinha
int _delay = 0; // Tempo de atraso para o CPU
int _maxPoints = 3; // Pontucao maxima do jogo
int _level = _maxPoints; // Quanto maior o numero mais facil se for 0
fica invencivel
int _playerPts = 0, _cpuPts = 0;
void setup() {
Timer1.initialize(100);
// Seta os 16 pinos usados pela matriz de leds
for(int i = 0; i<8; i++){
pinMode(rows[i], OUTPUT);
pinMode(cols[i], OUTPUT);
}
// Seta os 14 pinos utilizados pelos displays catodo
for(int i = 0; i<7; i++)
{
pinMode (pts_right[i], OUTPUT);
pinMode (pts_left[i], OUTPUT);
}
// Seta pino utilizado pelo buzzer
pinMode(PIN_BUZZER,OUTPUT);
// Seta pino do motor
pinMode(PIN_DM, OUTPUT);
Timer1.attachInterrupt(doubleBuffer);
Serial.begin(9600);
}
_delay = 0;
_level = _maxPoints;
_playerPts = 0;
_cpuPts = 0;
updateScore();
entry();
motor_pot = analogRead(PIN_LEFT); // Posicao inicial do motor
motor_pot = constrain(map(motor_pot, 223, 800, 0, 6), 0, 6);
left = motor_pot; // Recebe valor do potenciometro
reset();
// Escreve na matriz de LEDs
void doubleBuffer() {
digitalWrite(rows[screenRow], LOW);
digitalWrite(cols[screenCol], HIGH);
screenCol++;
if (screenCol >= 8) {
screenCol = 0;
screenRow++;
if (screenRow >= 8) {
screenRow = 0;
73
}
}
}
if((screen[screenRow] >> screenCol) & B1 == B1) {
digitalWrite(rows[screenRow], HIGH);
digitalWrite(cols[screenCol], LOW);
} else {
digitalWrite(rows[screenRow], LOW);
digitalWrite(cols[screenCol], HIGH);
}
// Escreve pontuacao no display catodo 7 segmentos
void pts_write(int num, int sete_seg[7])
{
byte aux;
aux = numero[num];
for(int i= 7; i >= 0; i --) // O laco despreza o bit mais
significativo
{
if(bitRead(aux,i )==1) // Le bit a bit
{
digitalWrite(sete_seg[i] , HIGH);
}
else
{
digitalWrite(sete_seg[i] , LOW);
}
}
}
// Liga um led na matriz
void on(byte row, byte column) {
screen[column-1] |= (B1 << (row - 1));
}
// Apaga um led na matriz
void off(byte row, byte column) {
screen[column-1] &= ~(B1 << (row - 1));
}
// Calcula as barras (raquetes) do jogo
void calcWall()
{
left = AIwall();
//left = analogRead(PIN_LEFT); // Usado somente para multiplayer
motor_pot = analogRead(PIN_LEFT);
right = analogRead(PIN_RIGHT);
//left = constrain(map(left, 223, 800, 0, 6), 0, 6); // Usado
somente para multiplayer
right = constrain(map(right, 223, 800, 0, 6), 0, 6);
motor_pot = constrain(map(motor_pot, 223, 800, 0, 6), 0, 6);
clearWall();
// Para exibir a barra (raquete) do9 lado CPU
//on(1, left + 1);
//on(1, left + 2);
// Para exibir a barra (raquete) do9 lado jogador
//on(8, right + 1);
74
//on(8, right + 2);
_wall[0] = left;
_wall[1] = right;
show();
}
// Apaga as barras (raquetes) do jogo
void clearWall()
{
for (int i = 0; i < 8; i++)
screen[i] &= B01111110;
}
// Limpa a tela do jogo
void clearGame()
{
for (int i = 0; i < 8; i++)
screen[i] &= B10000001;
}
void loop() {
if (_playerPts == _maxPoints)
{
clearGame();
happyFace();
setup();
}
else if (_cpuPts == _maxPoints)
{
clearGame();
sadFace();
setup();
}
}
calcWall();
enterFrameHandler();
delay(50);
// Motor
void runMotor(char direcao)
{
if (direcao == 'C') // Para cima
{
digitalWrite(PIN_DM, LOW); // LOW gira o motor pra um lado e
HIGH pro outro
analogWrite(PIN_AE, MOTOR_POWER); // Seta a potencia do motor
}
if (direcao == 'B') // Para caixo
{
digitalWrite(PIN_DM, HIGH); // LOW gira o motor pra um lado e
HIGH pro outro
analogWrite(PIN_AE, MOTOR_POWER); // Seta a potencia do motor
}
if (direcao == 'P') // Parar
{
analogWrite(PIN_AE, 0); // Zera a potencia do motor
}
}
75
// Campo de jogo
void enterFrameHandler()
{
if (_count++ < _speed)
return;
}
_count = 0;
checkCollision();
calcAngleIncrement();
show();
// Seta angulo de retorno da bolinha apos colisao
void retorted(int angle)
{
//Serial.println(angle);
_angle = angle;
}
if (++_countPoints % 5 == 0 && _speed > 1)
_speed--;
void resetAnim()
{
for (int i = 0; i < 8; i++)
{
screen[i] = B11111111;
delay(25);
}
for (int i = 0; i < 8; i++)
{
screen[i] = B00000000;
delay(25);
}
}
void reset()
{
resetAnim();
_px = random(3, 5);
_py = random(3, 5);
_angle = random(0, 2) == 0 ? 0 : 180;
_speed = 5;
_countPoints = 0;
}
show();
delay(500);
void show()
{
clearGame();
on(_px + 1, _py + 1);
}
// Verifica se houve colisao da bolinha
void checkCollision()
{
76
if (_px == _w - 1)
// Colisao com player
{
if (_angle == 315 || _angle == 0 || _angle == 45)
{
if (_py == _wall[1] || _py == _wall[1] + 1)
{
play_sound(2);
}
if (_angle == 0 &&
retorted(225);
else if (_angle ==
retorted(135);
else if (_angle ==
retorted(135);
else if (_angle ==
retorted(180);
else if (_angle ==
retorted(180);
else if (_angle ==
retorted(225);
_py == _wall[1])
0 && _py == _wall[1] + 1)
45 && _py == _wall[1])
45 && _py == _wall[1] + 1)
315 && _py == _wall[1])
315 && _py == _wall[1] + 1)
}
}
else if (_px == 0)
// Colisao com CPU
{
if (_angle == 225 || _angle == 180 || _angle == 135)
{
if (_py == _wall[0] || _py == _wall[0] + 1)
{
play_sound(2);
if (_angle == 180 && _py == _wall[0])
retorted(315);
else if (_angle == 180 && _py == _wall[0] + 1)
retorted(45);
else if (_angle == 135 && _py == _wall[0])
retorted(45);
else if (_angle == 135 && _py == _wall[0] + 1)
retorted(0);
else if (_angle == 225 && _py == _wall[0])
retorted(0);
else if (_angle == 225 && _py == _wall[0] + 1)
retorted(315);
}
}
}
if (_px == _w) // Bolinha passou pelo player
{
_delay = 0;
_cpuPts++;
play_sound(4);
updateScore();
reset();
}
else if (_px == -1) // Bolinha passou pelo CPU
{
_delay = 0;
_playerPts++;
play_sound(3);
updateScore();
77
_level--;
reset();
}
else if (_py == _h) // Colisao com lateral
{
if (_angle == 45)
{
play_sound(1);
_angle = 315;
}
else if (_angle == 135)
{
play_sound(1);
_angle = 225;
}
}
else if (_py == 0) // Colisao com lateral
{
if (_angle == 225)
{
play_sound(1);
_angle = 135;
}
else if (_angle == 315)
{
play_sound(1);
_angle = 45;
}
}
}
// Movimentacao da bolinha
void calcAngleIncrement()
{
if (_angle == 0 || _angle == 360)
{
_px += 1;
}
else if (_angle == 45)
{
_px += 1;
_py += 1;
}
else if (_angle == 135)
{
_px -= 1;
_py += 1;
}
else if (_angle == 180)
{
_px -= 1;
}
else if (_angle == 225)
{
_px -= 1;
_py -= 1;
}
else if (_angle == 315)
{
_px += 1;
_py -= 1;
78
}
}
// Inteligencia do CPU
int AIwall()
{
runMotor('P'); // Para o motor
int result = left;
if (_px < 4) // Se a posicao do eixo X for menor que 4, anda (px
distancia)
{
if (_delay == 0) // Quando delay for 0
{
if (left == _py) // Se estiver na mesma posicao da bola nao se
move (py = altura)
result = _py;
else if (left < _py) // Se for menor, move para baixo
{
result = left +1;
runMotor('B'); // Move para baixo
}
else // Se for maior, move para cima
{
result = left -1;
runMotor('C'); // Move para cima
}
_delay ++; // Incrementa o delay
}
else if (_delay == _level) // Se o delay for igual ao level, zera
ele para andar
_delay = 0;
else // Senao, incrementa o delay
_delay++;
}
if (result == 7) // Condicao para nao ultrapassar o tamanho da
matriz
result --;
}
return result;
// Atualizacao do placar
void updateScore()
{
pts_write(_playerPts, pts_right);
pts_write(_cpuPts, pts_left);
}
// Sons executados durante o jogo
void play_sound(int soundType)
{
// Colisao com laterais
if (soundType == 1)
{
tone(PIN_BUZZER,180,100);
}
// Colisao com players
else if (soundType == 2)
{
tone(PIN_BUZZER,500,100);
79
}
// Ponto para o player
else if (soundType == 3)
{
tone(PIN_BUZZER,1600,100);
}
// Ponto para CPU
else if (soundType == 4)
{
tone(PIN_BUZZER,100,100);
}
}
// Som executado quando o player vence
void winnerSound()
{
tone(PIN_BUZZER,1300,200);
delay(200);
tone(PIN_BUZZER,1050,200);
delay(200);
tone(PIN_BUZZER,1200,200);
delay(200);
tone(PIN_BUZZER,800,200);
}
// Som executado quando o player perde
void loserSound()
{
tone(PIN_BUZZER,1500,200);
tone(PIN_BUZZER,100,200);
delay(200);
tone(PIN_BUZZER,300,200);
delay(200);
tone(PIN_BUZZER,150,200);
}
// Animacao inicial do jogo
void entry()
{
allOFF();
delay(1000);
// P
on(2, 2); on(2, 3); on(2,
on(2, 6); on(2, 7); on(3,
on(4, 2); on(4, 5); on(5,
on(6, 2); on(6, 5); on(7,
delay(500);
allOFF();
// O
on(2, 3); on(2, 4); on(2,
on(3, 2); on(3, 7); on(4,
on(5, 2); on(5, 7); on(6,
on(7, 3); on(7, 4); on(7,
delay(500);
allOFF();
// N
on(2, 2); on(2, 3); on(2,
on(2, 6); on(2, 7); on(3,
on(5, 5); on(6, 6); on(7,
on(7, 4); on(7, 5); on(7,
delay(500);
4);
2);
2);
3);
on(2,
on(3,
on(5,
on(7,
5);
5);
5);
4);
5);
2);
2);
5);
on(2,
on(4,
on(6,
on(7,
6);
7);
7);
6);
4);
3);
2);
6);
on(2,
on(4,
on(7,
on(7,
5);
4);
3);
7);
80
allOFF();
// G
on(2, 3); on(2,
on(3, 2); on(3,
on(5, 2); on(5,
on(6, 7); on(7,
delay(400);
allOFF();
// Exclamation
on(4, 2); on(4,
on(5, 2); on(5,
delay(800);
allOFF();
4);
7);
7);
5);
on(2,
on(4,
on(6,
on(7,
5); on(2, 6);
2); on(4, 7);
2); on(6, 5);
6);
3); on(4, 4); on(4, 6); on(4, 7);
3); on(5, 4); on(5, 6); on(5, 7);
}
// Apaga todos os leds da matriz
void allOFF() {
for (int col = 0; col < 8; col++)
{
for (int row = 0; row < 8; row++)
{
screen[col] &= ~(B1<<(row));
}
}
}
// Liga todos os leds da matriz
void allON() {
for (int col = 0; col < 8; col++)
{
for (int row = 0; row < 8; row++)
{
screen[col] |= (B1<<(row));
}
}
}
void happyFace()
{
winnerSound();
on(1, 1);
on(1, 2);
on(2, 1);
on(2, 2);
on(7, 1);
on(7, 2);
on(8, 1);
on(8, 2);
on(1, 1);
on(1, 2);
on(4, 4);
on(4, 5);
on(5, 4);
on(5, 5);
on(2, 7);
on(7, 7);
on(3, 8);
on(4, 8);
on(5, 8);
on(6, 8);
delay(5000);
81
}
void sadFace()
{
loserSound();
on(1, 1);
on(1, 2);
on(2, 1);
on(2, 2);
on(7, 1);
on(7, 2);
on(8, 1);
on(8, 2);
on(1, 1);
on(1, 2);
on(4, 4);
on(4, 5);
on(5, 4);
on(5, 5);
on(2, 8);
on(7, 8);
on(3, 7);
on(4, 7);
on(5, 7);
on(6, 7);
delay(5000);
}
81
APENDICE B – IMAGENS DO PROCESSO DE MONTAGEM
A seguir serão mostrados todos os passos necessários para a
construção do projeto.
Foi desmontada uma impressora multifuncional da HP (Figura 1) para o
reaproveitamento de algumas peças.
Figura 1 – Impressora Multifuncional da HP.
O carro onde são encaixados os cartuchos de tinta, as engrenagens e
peças de fixação do mecanismo de impressão, exibidos na figura 2, foram
removidos.
Figura 2 – Impressora aberta e engrenagens do mecanismo de impressão.
82
O motor, responsável pela movimentação da cabeça de impressão, e o
trilho que o sustenta também foram retirados da impressora, conforme exibido
na figura 3. O motor foi testado no Arduino para verificar o seu funcionamento
em conjunto com a Shield de controle com o chip L298n.
Figura 3 – Motor e barras de sustentação do mecanismo de impressão.
Com o motor funcionando, foram feitos diversos furos na caixa que
abrigaria o jogo, apresentada na figura 4.
Figura 4 – Caixa que abriga o jogo.
83
Todos os furos foram feitos levando em consideração a posição
necessária para o funcionamento correto dos mecanismos que seriam
colocados dentro dela. As figuras 5 e 6, exibem o lado da CPU e a forma como
foram afixadas o motor, uma peça de metal e as roldanas. Todas removidas da
impressora.
Figura 5 – Motor e roldana afixados na caixa.
Figura 6 – Disposição das penas da impressora na caixa.
84
As barras de ferro, que sustentavam o mecanismo de impressão, foram
serradas as meio e inseridas na caixa através de furos, conforme demonstrado
na figura 7.
Figura 7 – Furações necessárias para a afixação das peças.
No lado da CPU, um potenciômetro foi fixado na caixa com o uso de
uma peça de metal retirada da impressora e moldada para esta finalidade,
conforme mostra a figura 8.
Figura 8 – Potenciômetro fixado à uma peça de metal retirada da impressora.
85
No lado do jogador também foi fixado um potenciômetro à caixa, porém
usando uma peça retirada de um drive de CD-ROM, conforme mostra a figura
9.
Figura 9 – Potenciômetro fixado à uma peça de metal retirada da impressora.
Em ambos os lados, foi afixada uma engrenagem ao potenciômetro possibilitando a rotação deste por outra peça. Também foi adaptada uma peça do
carro de impressão para que esta movesse o potenciômetro através de um
conjunto de roldanas e engrenagens. Na figura 10, é exibida a peça final resultante da colagem de um pedaço da gaveta de um drive de CD-ROM à uma
parte do mecanismo de impressão.
Figura 10 – Pedaço da gaveta de um drive de CD-ROM colada à uma peça do
mecanismo de impressão.
86
A peça, retirada do drive de CD-ROM e da impressora, adaptada foi colocada
em seu respectivo suporte, no lado do jogador, conforme mostrado na figura
11.
Figura 11 – Peça adaptada de um drive de CD-ROM e de uma impressora
afixada ao suporte.
O lado da CPU também foi montado e afixado ao suporte feito com as barras
de ferro do mecanismo de impressão, conforme mostrado na figura 12.
Figura 12 – Peças do lado da CPU afixadas ao suporte.
87
Depois de afixar todas as partes mecânicas à caixa, foi colocada a parte
eletrônica, montada em uma protoboard e ligada à uma Shield e ao Arduino,
conforme mostra a figura 12.
Figura 12 – Visão do lado do jogador.
Também foram ligados os potenciômetros à protoboard, deixando os
carros de ambos os lados, CPU e jogador, ligados ao sistema. Peças de Lego
foram utilizadas para representar as raquetes do jogo, conforme mostra a figura
13.
Figura 13 – Peças de Lego usadas para representar as raquetes do jogo.
88
Na figura 14, é possível visualizar o mecanismo de controle construído
para o lado da CPU a partir de peças removidas de uma impressora multifuncional.
Figura 14 – Visão do mecanismo de jogo do lado da CPU.
Na figura 15, é exibido o mecanismo de controle do lado do jogador,
construído a partir de peças removidas de uma impressora multifuncional e de
um drive de CD-ROM.
Figura 15 – Visão do mecanismo de jogo do lado do jogador.
89
Com todas as partes, mecânica e eletrônica, posicionadas dentro da caixa, conforme exibido na figura 16, o projeto sofreu testes e uma série de ajustes para o melhor funcionamento. Todo o conjunto foi alimentado utilizando
uma fonte genérica com possibilidade de alteração de voltagem, ligada em 9
volts.
Figura 16 – Projeto em sua versão final.
90
APENDICE C – COMPARAÇÃO ENTRE MODELOS