Embed Size (px)
Citation preview
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIAS DA COMPUTAÇÃO – BACHARELADO
PROTÓTIPO DE UM GAME EMBARCADO EM
PLATAFORMA ARM DOTADO DE ACELERÔMETRO
ROBSON VITOR REZINI
BLUMENAU 2008
2008/2-23
ROBSON VITOR REZINI
PROTÓTIPO DE UM GAME EMBARCADO EM
PLATAFORMA ARM DOTADO DE ACELERÔMETRO
Trabalho de Conclusão de Curso submetido à Universidade Regional de Blumenau para a obtenção dos créditos na disciplina Trabalho de Conclusão de Curso II do curso de Ciências da Computação — Bacharelado.
Prof. Miguel Alexandre Wisintainer, Mestre – Orientador
BLUMENAU 2008
2008/2-23
PROTÓTIPO DE UM GAME EMBARCADO EM
PLATAFORMA ARM DOTADO DE ACELERÔMETRO
Por
ROBSON VITOR REZINI
Trabalho aprovado para obtenção dos créditos na disciplina de Trabalho de Conclusão de Curso II, pela banca examinadora formada por:
______________________________________________________ Presidente: Prof. Miguel Alexandre Wisintainer, Mestre – Orientador, FURB
______________________________________________________ Membro: Prof. Antônio Carlos Tavares, Mestre, FURB
______________________________________________________ Membro: Prof. Mauro Marcelo Mattos, Doutor, FURB
Blumenau, 11 de fevereiro de 2009
Em memória de Alaíde Maria Rezini.
AGRADECIMENTOS
A toda minha família, que sempre me apoiou e lutou em todos os momentos ao meu
lado, para que conseguisse concretizar meus estudos, a quem muito devo por ter chegado
aqui, fica meu eterno sentimento de amor e gratidão.
Ao meu pai Vitor, que sempre me ensinou a ser uma pessoa honesta, digna e de
caráter, um exemplo em minha vida.
A minha inesquecível mãe Alaíde, que esteve sempre junto comigo, me apoiando em
todos os momentos de minha vida. Sua presença em minha vida jamais será esquecida.
Aos meus tios Sebastião e Valdete, que ajudaram muito, incentivando e contribuindo
para que conseguisse realizar o sonho de se formar.
Aos meus amigos e colegas, que estiveram presentes nessa caminhada, sempre ao meu
lado, enfrentando junto a mim as dificuldades e provações de um curso superior, fica o meu
obrigado pelo companheirismo e amizade.
Ao meu orientador e demais professores da FURB que me ensinaram, além de todas as
disciplinas, a ser um profissional ético e competente.
Ás demais pessoas que contribuíram direta ou indiretamente para o meu sucesso.
Imaginação é mais importante do que inteligência.
Albert Einstein
RESUMO
Este trabalho apresenta o desenvolvimento de um protótipo de game embarcado em plataforma Acorn RISC Machine (ARM) dotado de acelerômetro. São abordadas informações sobre o dispositivo acelerômetro utilizado e sua função para com o protótipo, informações sobre o processador ARM e seu kit de desenvolvimento, suas principais características e limites, informações sobre a Integrated Development Enviroment (IDE) e a linguagem computacional utilizada. É desenvolvido o protótipo do game baseado no game clássico Tetris, levando em consideração seus limites e a utilização do acelerômetro para a detecção dos movimentos, que serão utilizados pra controlar os movimentos das peças do game, sem o auxilio de qualquer outro botão.
Palavras-chave: Acelerômetro. Software embarcado. Microcontrolador ARM.
ABSTRACT
This work presents the development of a prototype board game on the platform Acorn RISC Machine (ARM) with the accelerometer. They discussed details on the accelerometer used and its function to the prototype, information on the ARM processor and development of their kit, their main characteristics and limits, information on the Integrated Development Environment (IDE) and the computer language used. It developed the prototype of the game based on the classic Tetris game, taking into account its limits and uses the accelerometer to detect movements, which will be used for controlling the movements of parts of the game without the aid of any other button.
Key-words: Accelerometer. Software Board. ARM Microcontroller.
LISTA DE ILUSTRAÇÕES
Figura 1 – Placa eletrônica com acelerômetro LIS3LV02DL .................................................. 19
Figura 2 – Comparação do Acelerômetro com uma moeda. .................................................... 19
Figura 3 – Sensores do acelerômetro vistos em microscópio eletrônico. ................................. 20
Figura 4 – Arquitetura interna do acelerômetro. ...................................................................... 20
Figura 5 – Kit STM3210B-PRIMER ....................................................................................... 21
Figura 6 – Nintendo Wii ........................................................................................................... 22
Figura 7 – Wii Remote ............................................................................................................. 23
Figura 8 – iPhone ...................................................................................................................... 24
Figura 9 – iPhone e a ação de seu acelerômetro ....................................................................... 25
Figura 10 – Nokia N95 ............................................................................................................. 26
Figura 11 – Exemplo de aplicativo que utiliza o acelerômetro no N95 ................................... 26
Figura 12 – Casos de Uso ......................................................................................................... 28
Figura 13 – Diagrama de seqüência de movimento das peças do protótipo............................. 29
Figura 14 – Diagrama de estados do game ............................................................................... 30
Figura 15 – Fluxograma do game ............................................................................................. 31
Figura 16 – IDE Ride7 ............................................................................................................. 33
Quadro 1 – Exemplo de código fonte implementado para a linguagem C++. ......................... 34
Figura 17 – Kit STM3210B-PRIMER ..................................................................................... 35
Figura 18 – Tela inicial do kit STM3210B-PRIMER com o Pointer ...................................... 36
Figura 19 – Menu inicial do kit STM3210B-PRIMER ............................................................ 37
Figura 20 – Página inicial do fórum do kit STM3210B-PRIMER ........................................... 38
Figura 21 – Primeira versão do game Tetris............................................................................. 39
Figura 22 – Tela do Tetris para PC de 1987 com sua sete peças ............................................. 39
Quadro 2 – Organização da API Circle-os ............................................................................... 40
Quadro 3 – Trecho do código fonte que capta as informações do acelerômetro...................... 41
Quadro 4 – Trecho do código fonte que traduz as informações do acelerômetro .................... 42
Quadro 5 – Trecho do código fonte que implementa a pausa do game com o Double Shock . 43
Quadro 6 – Trecho do código fonte que cria as estruturas representando as peças do game ... 44
Quadro 7 – Trecho do código fonte que representa a estrutura do tabuleiro ........................... 44
Quadro 8 – Trecho do código fonte com o protótipo das funções do game ............................. 45
Quadro 9 – Exemplo de uma função com sua estrutura de comentário ................................... 45
Figura 23 – Tela do aplicativo STM32 Manager ..................................................................... 46
Quadro 10 – Trecho de código fonte do STM32 Manager que chama o utilitário
Circle_Mgr.exe ...................................................................................................... 47
Figura 24 – Tela inicial do game .............................................................................................. 48
Figura 25 – Peça sendo movimentada no game. ...................................................................... 49
Figura 26 – Peça sendo movimentada no game. ...................................................................... 49
Figura 27 – Peças do game Tetris e suas possíveis posições tomadas no decorrer do jogo ..... 50
Figura 28 – Movimentação do kit ............................................................................................ 51
Figura 29 – Game pausado pelo jogador. ................................................................................. 52
Figura 30 – Tela de game over do game .................................................................................. 53
Figura 31 – Parte da página do fórum do fabricante do kit, onde mostra a quantidade de
projetos e usuários ................................................................................................. 54
Figura 32 – Página do protótipo do game no fórum do fabricante com suas 481 visitas e 59
downloads .............................................................................................................. 55
Figura 33 – Página do fórum do fabricante que mostra o protótipo desenvolvido como projeto
da semana............................................................................................................... 55
Figura 34 – Trecho da página que mostra o protótipo desenvolvido como o mais popular do
fórum...................................................................................................................... 56
LISTA DE SIGLAS
API – Application Programming Interface
ARM - Acorn RISC Machine
BCPL - Basic Combined Programming Language
CPU - Central Processing Unit
DVD - Digital Vídeo Disc
GNU – General Public License
GPS - Global Positioning System
HD - Hard Disc
IDE - Integrated Development Environment
LCD - Liquid Crystal Display
MEMS - Micro Electro Mechanical Systems
MP3 - MPEG-1 Audio Layer 3
OO - Orientação a Objetos
PC - Personal Computer
RISC - Reduced Instruction Set Computer
RTTTL - Ring Tone Text Transfer Language
TCC - Trabalho de Conclusão de Curso
UML – Unified Modeling Language
USB - Universal Serial Bus
LISTA DE SÍMBOLOS
% - por cento
$ - cifrão
+ - mais (soma)
SUMÁRIO
1 INTRODUÇÃO .................................................................................................................. 13
1.1 ESCOPO E PROBLEMA.................................................................................................. 14
1.2 OBJETIVOS DO TRABALHO ........................................................................................ 15
1.3 ESTRUTURA DO TRABALHO ...................................................................................... 16
2 FUNDAMENTAÇÃO TEÓRICA .................................................................................... 17
2.1 MICROCONTROLADOR ARM ...................................................................................... 17
2.2 ACELERÔMETRO ........................................................................................................... 18
2.3 O KIT STM3210B-PRIMER ............................................................................................ 21
2.4 TRABALHOS CORRELATOS ........................................................................................ 22
2.4.1 Nintendo Wii ................................................................................................................... 22
2.4.2 iPhone .............................................................................................................................. 23
2.4.3 Nokia N95 ....................................................................................................................... 25
3 DESENVOLVIMENTO DO PROTÓTIPO .................................................................... 27
3.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO ....................... 27
3.2 ESPECIFICAÇÃO ............................................................................................................ 28
3.2.1 Casos de Uso ................................................................................................................... 28
3.2.2 Diagrama de Seqüência ................................................................................................... 29
3.2.3 Diagrama de Estados ....................................................................................................... 29
3.2.4 Fluxograma ..................................................................................................................... 30
3.3 IMPLEMENTAÇÃO ........................................................................................................ 32
3.3.1 Técnicas e ferramentas utilizadas.................................................................................... 32
3.3.1.1 IDE ................................................................................................................................ 32
3.3.1.2 Linguagem de programação ......................................................................................... 33
3.3.1.3 O kit de desenvolvimento STM3210B-PRIMER ......................................................... 35
3.3.1.4 Desenvolvimento do Jogo ............................................................................................. 37
3.3.2 Operacionalidade da implementação .............................................................................. 47
3.4 RESULTADOS E DISCUSSÃO ...................................................................................... 53
4 CONCLUSÕES .................................................................................................................. 58
4.1 EXTENSÕES .................................................................................................................... 59
REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................. 60
13
1 INTRODUÇÃO
Já é de conhecimento comum a todos que a indústria de jogos tem crescido muito nos
últimos anos, atingindo a todas as faixas etárias, movimentando altos valores financeiros e
gerando muita lucratividade para os seus investidores. Motivados por esta lucratividade e pelo
seu alto crescimento, as empresas investem pesado nessa indústria emergente, injetando
recursos em pesquisas de novas tecnologias de software e hardware para desenvolverem seus
jogos, buscando sempre estreitar ainda mais a distância entre a realidade e o mundo virtual
dos jogos, aumentando a qualidade na interação entre o jogador e o jogo.
Após uma pesquisa, a DFC Intelligence [a DFC Intelligence é uma empresa de pesquisa e consultoria de mercado focada na área de jogos] concluiu que haverá um crescimento significativo na indústria de jogos eletrônicos nos próximos anos. Até 2011, a indústria mundial que valia US$ 29 bilhões até 2005, passará a valer aproximadamente US$ 44 bilhões. (PORTAL TERRA, 2006).
Buscando atrair ainda mais jogadores e aumentar a competitividade de seus produtos,
as empresas desenvolveram recentemente novos hardwares e componentes eletrônicos
visando uma participação mais efetiva do jogador, algo que vai além de um simples controle
de videogame, algo que faça o jogador realmente sentir sua participação efetiva no jogo.
Esses dispositivos novos, que captam movimentos e agem aos estímulos do jogador, são os
acelerômetros. A utilização destes componentes na área de entretenimento é muito atual, e
existem poucos estudos e pesquisas divulgadas sobre este componente e sobre a sua aplicação
nos jogos. Sua utilização pode ser extensa. Com a captura dos movimentos é possível utilizá-
lo para navegação em menus, controle de objetos do mundo virtual como bola, jogador e
peças entre outros, e até outras aplicações que podem ir além do mundo dos jogos, como
detecção de terremotos, detecção de impacto em discos rígidos e outros dispositivos comuns
do cotidiano.
Os acelerômetros já estão presentes em alguns celulares e consoles1 de videogames de
última geração, como o smartphone Nokia N95, o console Nintendo Wii e o celular iPhone da
Apple. O iPhone possui um acelerômetro que detecta quando o usuário movimentou o
equipamento de modo retrato para paisagem, ajustando automaticamente o conteúdo e a
visualização da tela (APPLE INC, 2008a).
O Nintendo Wii possui o Wii Remote, um joystick diferente de todos já utilizados nos
demais consoles. Ele possui um acelerômetro que capta os movimentos dos jogadores em
1 Console é o termo utilizado para designar o aparelho que processa os jogos, o próprio videogame.
14
qualquer direção com grande sensibilidade, aumentando a interação entre o jogador e o jogo
(LIPPE; FREITAS, 2007). Com o intuito de alterar drasticamente a forma de se jogar, o
Nintendo Wii possui acelerômetros de três dimensões fabricados pela STMicroeletronics, que
detectam movimentos e inclinações da mão do jogador, convertendo-os em ações imediatas
no jogo (STMICROELETRONICS, 2006a).
Tentando contribuir para a popularização e conhecimento do acelerômetro, surge a
idéia de prototipar um game utilizando-o como principal meio de interface entre o jogador e o
game, mostrando assim suas funcionalidades e seus benefícios, não só ao mundo dos jogos,
mas também a outras aplicações que necessitam de uma solução na qual o mesmo se encaixe.
Optou-se por desenvolver o game utilizando um kit de desenvolvimento eletrônico de
plataforma Acorn RISC Machine (ARM), especificamente o kit STM3210B-PRIMER da
STMicroeletronics. A escolha deste kit para o desenvolvimento deve-se ao seu custo baixo,
sua versatilidade e seus recursos, tais como o microcontolador ARM, o acelerômetro, a
interface Universal Serial Bus (USB) 2.0, o Liquid Crystal Display (LCD) colorido e as
bibliotecas gráficas desenvolvidas em C e C++, linguagens essas que são largamente
utilizadas no desenvolvimento de jogos pelo mundo todo.
1.1 ESCOPO E PROBLEMA
Como são altos os recursos investidos, deve-se incentivar as pesquisas acadêmicas
nestas tecnologias, para atrair uma parte destes recursos diretamente ao meio acadêmico,
visando o desenvolvimento do conhecimento.
Este trabalho abrange outra área que também é emergente, a área de aplicações
embarcadas, pequenos aplicativos e softwares embarcados em microcontroladores ARM, que
proporcionam economia em aplicações diversas por terem baixo consumo de corrente e
menor custo, sendo utilizados em diversos segmentos, tanto industriais como acadêmicos.
Considerando o objeto deste trabalho, o uso do acelerômetro, observa-se que o mesmo
não é difundido em meio acadêmico, se trata de um novo recurso da área de eletrônica, ainda
pouco explorado nas instituições de ensino e um recurso que, pelas suas características, tem
um potencial de uso quase ilimitado, dependendo unicamente da criatividade do
desenvolvedor na sua utilização.
Para o desenvolvimento deste trabalho será necessário o conhecimento em
15
microcontroladores da arquitetura ARM, pouco divulgados no Curso de Ciência da
Computação, sendo somente citado de modo geral em algumas disciplinas da área de
eletrônica em alguns Trabalhos de Conclusão de Curso (TCCs). Será necessário também o
conhecimento nas linguagens de programação C, C++, Assembly e algoritmos clássicos de
Computação Gráfica, tais como o algoritmo de colisão, de rotação e translação muito usados
no desenvolvimento de jogos.
Foi utilizado o kit STM3210B-PRIMER da STMicroleletronics, um kit de
desenvolvimento baseado no processador STM32 ARM Cortex – M3, que possui um LCD de
interface gráfica colorida, conexão USB, buzzer, acelerômetro e utiliza programas
desenvolvidos em C/C++, itens que beneficiam o desenvolvimento de jogos. Essa escolha
também se deve a própria STMicroeletronics desenvolver os acelerômetros do console da
Nintendo, o Wii, demonstrando desta forma que seus produtos são precisos e de boa
qualidade.
1.2 OBJETIVOS DO TRABALHO
O objetivo deste trabalho é desenvolver um protótipo de game em plataforma ARM
que utilize o componente eletrônico acelerômetro como principal interface de interação entre
o jogador e o game.
Os objetivos específicos do trabalho são:
a) identificar um game que possua características compatíveis com o dispositivo
STM3210B-PRIMER;
b) adequar o roteiro e as regras do game selecionado para compatibilizá-lo com as
limitações do dispositivo STM3210B-PRIMER;
c) portar o game selecionado para a plataforma ARM do dispositivo STM3210B-
PRIMER;
d) traduzir a informação do acelerômetro em informação útil ao game selecionado;
e) utilizar o acelerômetro como única forma de navegação no game, permitindo
somente utilizar um botão para funções que independem de movimento, como
confirmações de mensagens e seleções de menus e objetos.
16
1.3 ESTRUTURA DO TRABALHO
Este trabalho está organizado em quatro capítulos distintos. No capítulo 2 é descrita
toda a fundamentação teórica utilizada como referência durante a elaboração e
desenvolvimento do trabalho, apresentando alguns conceitos sobre os microcontroladores da
plataforma ARM, descrevendo-os e citando a sua história, alguns conceitos sobre o
acelerômetro, sua funcionalidade e sua arquitetura interna, informações sobre o kit de
desenvolvimento STM3210B-PRIMER, escolhido para o desenvolvimento do protótipo, suas
características, suas limitações, seu uso e suas funcionalidades e por fim são apresentados
neste capítulo alguns trabalhos correlatos existentes em mercado atualmente. No capítulo 3 é
detalhado todo o desenvolvimento do trabalho, desde sua concepção até seu término,
descrevendo seus requisitos, mostrando sua estrutura e especificação, apresentando casos de
uso e diagramas de exemplo, técnicas e ferramentas utilizadas para o seu desenvolvimento,
exemplos de códigos fonte e telas do protótipo, por fim são discutidos os resultados
alcançados e os problemas enfrentados durante o desenvolvimento. No quarto é último
capítulo são apresentadas as conclusões obtidas no trabalho e algumas idéias de trabalhos que
possam ser desenvolvidos no futuro utilizando o mesmo assunto deste trabalho como base.
17
2 FUNDAMENTAÇÃO TEÓRICA
Neste capítulo são apresentados os conceitos mais importantes relacionados ao
trabalho, que servirão como base para o desenvolvimento do mesmo. São descritas as
principais características de um microcontrolador ARM, do kit STM3210B-PRIMER e do
acelerômetro. Na última seção são apresentados alguns trabalhos correlatos.
2.1 MICROCONTROLADOR ARM
Os microcontroladores ARM são um marco na indústria de semicondutores. Nunca uma arquitetura foi tão rapidamente difundida e maciçamente fabricada como a arquitetura ARM.
Parte deste sucesso se deve às suas características atraentes que incluem um design simples, alta velocidade, grande diversidade de modelos e fabricantes e quantidade de software disponível, entre outras.
Não é por acaso que esses microcontroladores estão presentes na maioria dos equipamentos portáteis vendidos atualmente, incluindo telefones celulares, computadores de mão (PDAs), MP3 players, videogames etc. (PEREIRA, 2007, p. 17).
Pereira (2007, p. 17) ainda define um microcontrolador como sendo uma Central
Processing Unit (CPU) baseada na arquitetura Reduced Instruction Set Computer (RISC) de
32 bits.
Sobre sua origem Pereira (2007, p. 17) conta que tiveram sua origem na década de 80
como um resultado bem sucedido de um projeto de autoria da Acorn Computer Group. Como
na época existiam tão somente microcontroladores de 8 bits fabricados pela Acorn e suas
concorrentes, a Acorn decidiu investir no desenvolvimento de novos microcontroladores,
mais rápidos, de programação simples e construção barata. Após pesquisas e análises decidiu-
se desenvolver um novo microprocessador, baseado em uma arquitetura de 32 bits. Em 1985
surgiram os primeiros exemplares do novo microprocessador, o ARM1, logo após sua versão
comercial o ARM2. As primeiras versões destes microprocessadores (ARM2 e ARM3) foram
utilizadas nos primeiros computadores RISC pessoais fabricados pela Acorn (Archimedes
300, 400 e 500). Em 1990 a Acorn se reuniu a outras empresas e criou a Joint Venture ARM
Limited, lançando com ele a primeira versão embedded comercial da CPU ARM, o ARM6,
juntamente com o primeiro processador da ARM, o ARM610. Os principais conceitos por trás
18
desta arquitetura são a simplicidade, baixo custo, pequeno consumo e modularidade, sendo
projetadas para serem simples, baratas e integradas aos mais diferentes periféricos, atendendo
a diversos perfis de aplicação.
No caso do microcontrolador ARM STM32F103B6, a STMicroeletronics (2008b, p. 1)
descreve suas características como, um microcontrolador ARM baseado na família Cortex-M3
de 32 bits, com 72MHZ de freqüência máxima, com até 128 Kbytes de memória flash, nove
interfaces de comunicação diferentes, uma delas sendo USB 2.0 e sete timers internos.
A família ARM CORTEX utiliza a sétima geração da arquitetura ARM e permite atingir níveis de performance [desempenho] muito superiores aos das versões anteriores. [...] CORTEX-M3 – versão extremamente simplificada de família CORTEX e focada em aplicações de baixo custo. A família CORTEX-M3 é considerada a menor CPU ARM fabricada atualmente (em torno de 33.000 portas lógicas, incluindo o sistema de interrupção). [...] A família CORTEX-M3 deve, no futuro, substituir os ARM7. (PEREIRA, 2007, p. 21).
De modo geral, os microcontroladores ARM, são processadores de pequeno porte e
baixo custo, que possuem em um único chip o processador, os registradores, a memória, as
interfaces e os barramentos necessários para o seu funcionamento.
2.2 ACELERÔMETRO
A detecção de movimento em dispositivos é possível graças ao acelerômetro, um
dispositivo eletro-mecânico com tamanho e custos reduzidos. Basicamente, ele é um
dispositivo composto geralmente por duas superfícies de cerâmica polarizada, que submetidas
a uma pressão, tensão ou compressão, geram uma carga elétrica em suas faces, que é
proporcional à força aplicada, a qual pode ser precisamente calculada utilizando a segunda lei
de Newton, que diz que força é igual à massa vezes à aceleração (COELHO, 2007).
STMicroeletronics é uma fabricante deste tipo de dispositivo, inclusive do
LIS3LV02DL, representado na Figura 1. A STMicroeletronics (2008a, p. 11) descreve o
LIS3LV02DL como sendo um acelerômetro de três eixos, 3D, de alto desempenho e baixo
consumo de energia.
19
Fonte: STMicroeletronics (2007b).
Figura 1 – Placa eletrônica com acelerômetro LIS3LV02DL
Em geral os acelerômetros são pequenos (ver Figura 2), muito sensíveis e de baixo
custo, ideais para pequenas aplicações e dispositivos como celulares.
Fonte: Morimoto (2008).
Figura 2 – Comparação do Acelerômetro com uma moeda.
No caso do LIS3LV02DL, a STMicroeletronics (2008a, p. 19) descreve seu sensor
como sendo produto de um processo proprietário, uma tecnologia microscópica, conhecida
como Micro Electro Mechanical Systems (MEMS), onde os mesmo possuem pequenas
estruturas de silício (ver Figura 3) que são imersas em um substrato presentes em vários
pontos do acelerômetro chamados âncoras, essas estruturas são livres de movimentos,
movendo-se para qualquer direção, de acordo com a movimentação do acelerômetro. Quando
uma aceleração for aplicada aos sensores, as estruturas se deslocam no substrato, causando
um desequilíbrio elétrico entre as hastes, esse desequilíbrio é medido aplicando-o como um
pulso elétrico em um capacitor preso a estrutura, e depois se lê a carga do mesmo, essa carga
é muito baixa, mas mesmo assim possui limites para não danificar os componentes. Existe
20
ainda um amplificador de sinais, responsável por amplificar os sinais elétricos.
A sensibilidade do acelerômetro abrange acelerações dentro da escala de 1g a 6g (g
denota o valor de gravidade) em uma largura de banda de 650Hz para todos os eixos.
Fonte: Morimoto (2008).
Figura 3 – Sensores do acelerômetro vistos em microscópio eletrônico.
Segundo a STMicroeletronics (2008a, p. 19), o acelerômetro LIS3LV02DL possui
ainda três interface digitais, uma para cada sensor, responsáveis por traduzir os sinais de baixa
freqüência que são captados pelos sensores em sinais digitais que são disponibilizados em
portas do circuito já configuradas de fábrica. Elas são responsáveis também por filtrar o sinal
recebido dos sensores, afim de não ter ruídos externos aos sensores que possam prejudicar na
medição e leitura do sinal. O próprio acelerômetro possui ainda outra porta de comunicação
responsável por dar um sinal de quando há novos dados nos sensores do mesmo. A Figura 4
representa a arquitetura interna do acelerômetro.
Fonte: STMicroeletronics (2006b).
Figura 4 – Arquitetura interna do acelerômetro.
A STMicroeletronics (2008a, p. 20), cita que o acelerômetro LIS3LV02DL vem
calibrado de fábrica, com valores baseados em gravidade zero, que são armazenados numa
estrutura não volátil, tendo assim sempre o seu valor inicial correto, não necessitando aos
21
usuários calibrar o dispositivo sempre que ele for religado.
2.3 O KIT STM3210B-PRIMER
O STM3210B-PRIMER é um kit de desenvolvimento inovador e de baixo custo,
concebido para fornecer divertimento e introdução às características dos microcontroladores
ARM Cortex – M3 (RAISONANCE, 2007).
Este kit de desenvolvimento é muito útil para pessoas que queiram iniciar o estudo dos
acelerômetros, já que possui vários itens que auxiliam no desenvolvimento de aplicações e
uma interface para comunicação com outros dispositivos.
STMicroeletronics (2007a) descreve seu kit, representado pela Figura 5, como sendo
um pacote de desenvolvimento inovador e divertido que fornece ferramentas de introdução
aos microcontroladores ARM Cortex – M3, possuindo comunicação USB com o computador
e ferramentas de edição de códigos da Raisonance2 baseados em C++.
Fonte: STMicroeletronics (2007a). Figura 5 – Kit STM3210B-PRIMER
O kit possui um acelerômetro digital de três eixos LIS3LV02DL da
STMicroeletronics, uma porta para comunicação com computador, depuração de código e
carregamento da aplicação, LCD colorido de 128x128 pixels, um botão para comandos de
menu, bateria interna e um microcontrolador ARM STM32F103B6. Com estes itens
combinados em um só equipamento, fica melhor o desenvolvimento de aplicações, evitando
problemas como incompatibilidade de hardwares e softwares entre os fabricantes, que só
atrapalham e desaceleram o desenvolvimento das aplicações.
2 Raisonance é uma empresa que fabrica kits de desenvolvimento para a área de eletrônica.
22
2.4 TRABALHOS CORRELATOS
O uso do acelerômetro é muito atual, por isso ainda é pouco divulgado, refletindo em
um baixo número de aplicações e dispositivos que o utilizam. Mesmo assim, essas poucas
tecnologias e dispositivos existentes exploram bem o seu uso, sendo geralmente famosas em
seu meio de atuação, possuindo características novas e intrigantes que atraem o público
consumidor. Nas próximas seções, estão descritos três dispositivos que possuem o
acelerômetro.
2.4.1 Nintendo Wii
O Nintendo Wii (ver Figura 6) é um console de videogame de última geração que
possui uma característica diferente dos consoles de outros fabricantes. O seu controle, o Wii
Remote, representado na Figura 7, possui uma tecnologia de detecção de movimentos nova,
que aumenta a interatividade com o jogo, os acelerômetros.
Fonte: Nintendo of America Inc (2008a).
Figura 6 – Nintendo Wii
Para realmente entender como ele revoluciona a maneira de jogar, deve-se
experimentá-lo. Ele é simples e de fácil uso devido aos acelerômetros. Sua facilidade de uso e
interatividade permite uma única experiência para todos os usuários (NINTENDO OF
23
AMERICA INC, 2008a).
O dispositivo do console que possui o acelerômetro, o Wii Remote, abriu as portas
para pessoas de todas as idades, e com diferentes habilidades, jogarem. O Wii Remote mistura
a familiaridade de um controle remoto com a última tecnologia em sensores de movimento.
Os desenvolvedores de games sempre criam novas funcionalidades para o Wii Remote. Ele
pode tornar-se uma raquete em seu braço ao jogar tênis ou um volante em jogos de corridas,
sendo as possibilidades infinitas (NINTENDO OF AMERICA INC, 2008b).
Fonte: Nintendo of America Inc (2008b).
Figura 7 – Wii Remote
Observando as afirmações que a Nintendo faz sobre o Nintendo Wii, pode-se perceber
como o acelerômetro está mudando a maneira de se jogar, provando que sua utilização futura
será muito grande e de sucesso no mercado de entretenimento.
2.4.2 iPhone
O iPhone, representado na Figura 8, é um novo e revolucionário celular que permite
fazer uma chamada com um simples toque em sua tela, ou através de seu livro de endereços
digital, ou de uma lista de favoritos, possuindo também sincronismo com computadores tanto
na plataforma Personal Computer (PC) quanto na plataforma Macintosh (APPLE INC,
2008b).
Mas o iPhone não é somente isso, ele é um misto de MPEG-1 Audio Layer 3 (MP3)
player com celular, visualizador de vídeo e navegador para a internet, e o que mais
24
impressiona nele é que possui um botão de acesso a um menu principal, no resto, todo o
controle do telefone, inclusive a discagem de números, é feita pela sua tela, que é sensível ao
toque. Outro dispositivo presente nele é o acelerômetro. No caso do iPhone, o acelerômetro é
utilizado para verificar em que posição o celular está, em posição de retrato ou em posição de
paisagem. Quando o acelerômetro detecta a mudança da posição da tela, ele gera uma
interrupção e faz o iPhone ajustar instantaneamente a tela de acordo com a nova posição, a
Figura 9 ilustra esta mudança. O acelerômetro pode ainda ser utilizado por outras aplicações
desenvolvidas especificamente para o iPhone.
Fonte: Apple Inc (2008b).
Figura 8 – iPhone
No iPhone o acelerômetro ainda é um dispositivo que não chama muito a atenção, pois
o celular possui muitos outros itens que despertam mais a atenção dos usuários, mas aos
poucos vão sendo desenvolvidas novas aplicações e o uso deste dispositivo pode tornar-se
mais presente no aparelho.
25
Fonte: Morimoto (2008).
Figura 9 – iPhone e a ação de seu acelerômetro
2.4.3 Nokia N95
O N95 é um computador portátil, com funções de celular, câmera de 5 Megapixels,
lentes Carl Zeiss3, que podem capturar fotos e vídeos de alta definição com qualidade de
Digital Vídeo Disc (DVD) (RIOLINO, 2006).
O Nokia N95, representado na Figura 10, é muito mais que isto, ele é um smartphone
com funcionalidades muito parecidas com o iPhone. Além da câmera digital ele possui tela de
2,6 polegadas, sistema operacional Symbian 60, um chip dedicado para gráficos 3D, Global
Positioning System (GPS) integrado, MP3 player, celular e um acelerômetro dentre outros
dispositivos.
3 Carl Zeiss é uma empresa que fabrica lentes ópticas para dispositivos de captura de imagens.
26
Fonte: Riolino (2006).
Figura 10 – Nokia N95
No N95, o uso do acelerômetro se faz mais fácil, pois a fabricante Nokia, liberou
várias funções, bibliotecas e até Integrated Development Environment (IDE) para
desenvolvimento de aplicações. Já existem vários aplicativos que utilizam o acelerômetro do
N95. O próprio smartphone possui um sistema aclopado à função de MP3 player, que
monitora o acelerômetro, caso o usuário agitar o celular, o MP3 player troca de música no
mesmo instante. Existem ainda vários aplicativos que utilizam o acelerômetro do N95, a
Figura 11 mostra um deles, o Inclinômetro.
Fonte: Reinert (2007).
Figura 11 – Exemplo de aplicativo que utiliza o acelerômetro no N95
Assim como no iPhone, no N95, o uso do acelerômetro ainda é muito pouco
divulgado, mas se mostra uma forte tendência para aumentar a interação com o smartphone.
27
3 DESENVOLVIMENTO DO PROTÓTIPO
Este capítulo apresenta o desenvolvimento do protótipo do game, sua utilização, testes
realizados e os resultados alcançados.
Serão detalhadas também as técnicas utilizadas, as ferramentas de desenvolvimento
adotadas, as dificuldades encontradas durante o processo de desenvolvimento, tanto com o
hardware escolhido como com a linguagem e o ambiente de desenvolvimento e suas
limitações.
O jogo escolhido para demonstrar as funcionalidades do acelerômetro foi o Tetris no
seu estilo clássico, o qual será comentado no decorrer desta seção.
3.1 REQUISITOS PRINCIPAIS DO PROBLEMA A SER TRABALHADO
O protótipo proposto deverá possuir os seguintes Requisitos Funcionais (RF) e
Requisitos Não Funcionais (RNF):
a) movimentar os personagens e/ou peças do game de acordo com os movimentos
que o usuário faz com o kit/hardaware (RF);
b) captar os movimentos do usuário através de um acelerômetro (RF);
c) emitir mensagens ao usuário no LCD, comunicando os eventos ocorridos no game
(RF);
d) mostrar pontuação do game (RF);
e) possuir interface gráfica (RNF);
f) ser visualizado através do LCD colorido presente no kit (RNF);
g) ser concebido no kit STM3210B-PRIMER da STMicroeletronics (RNF);
h) ser implementado para microcontrolador ARM (RNF);
i) ser implementado utilizando as ferramentas de desenvolvimento da Raisonance,
presentes no kit STM3210B-PRIMER (RNF).
28
3.2 ESPECIFICAÇÃO
Para especificação do protótipo de game a ser desenvolvido foi adotado o padrão
Unified Modeling Language (UML). Foi utilizado também um fluxograma para representar
todas as ações tomadas pelo protótipo de modo geral.
A ferramenta escolhida para desenvolvimento dos diagramas foi a Enterprise Architect
na sua versão 6.5. Para fazer o fluxograma foi utilizada a ferramenta Microsoft Office Visio
2007 que dá total suporte apoio ao desenvolvimento de fluxogramas em geral.
3.2.1 Casos de Uso
A Figura 12 mostra os casos de uso básicos relacionados ao contexto do jogo.
Figura 12 – Casos de Uso
29
3.2.2 Diagrama de Seqüência
O Diagrama de Seqüência mostrado na Figura 13 representa uma seqüência de
acontecimentos relevantes a movimentação das peças do game, ou seja, no momento em que
um movimento é feito pelo jogador. Este diagrama representa a parte principal do código do
protótipo, pois neste momento é que são tratados os eventos do acelerômetro.
Figura 13 – Diagrama de seqüência de movimento das peças do protótipo
3.2.3 Diagrama de Estados
O diagrama de estados ilustrado na Figura 14 é o que melhor representa os estados do
protótipo, pois o mesmo baseia-se em seqüências de acontecimentos disparados pelo jogador,
como ligar ou desligar o game e movimentar as peças. Ele apresenta todos os estados do
game, desde seu início, com a inicialização do kit e a seleção do game, até o fim, com a saída
do game através do único botão presente no kit.
30
Figura 14 – Diagrama de estados do game
3.2.4 Fluxograma
O fluxograma representado na Figura 15 fornece uma visão geral da estrutura do jogo.
Como pode ser notado, o protótipo funciona como um loop infinito, onde o game só termina
quando o usuário decidir sair do mesmo, pressionando o botão do kit.
31
Figura 15 – Fluxograma do game
32
3.3 IMPLEMENTAÇÃO
A seguir são mostradas as técnicas e ferramentas utilizadas para o desenvolvimento do
protótipo do game e a operacionalidade da implementação.
3.3.1 Técnicas e ferramentas utilizadas
Nesta seção são apresentadas de forma detalhadas as técnicas e ferramentas utilizadas
para o desenvolvimento do protótipo.
3.3.1.1 IDE
O protótipo do game proposto foi desenvolvido utilizando o IDE Ride7 na sua versão
7.01 (ilustrado na Figura 16). Ele é fabricado pela empresa Raisonance, mesma fabricante do
kit de desenvolvimento utilizado (hardware). Juntamente com o Ride7, foi utilizado o
RKitARM For Ride7 na sua versão 1.03. Essas duas ferramentas fazem parte de um pacote de
software desenvolvido para prover ferramentas de desenvolvimento para processadores ARM
da família STM32. Esse pacote possui, além do Ride7 e do RKitARM, um compilador C/C++
baseado em General Public License (GNU), um debugger e um RLINK, que gerencia a
conexão do IDE com o hardware da fabricante via USB.
33
Fonte: Raisonance (2008a).
Figura 16 – IDE Ride7
Esta é a única IDE voltada à família STM32 de microcontroladores ARM a prover
todas as ferramentas necessárias para o desenvolvimento do game e por utilizar a linguagem
de programação C/C++. Outro motivo que levou a escolha dessa IDE, foi que a mesma é
desenvolvida pela da mesma fabricante do kit de desenvolvimento (hardware), com isso
diminui-se a chance de ocorrerem inconsistências e incompatibilidades entre a IDE e o kit de
desenvolvimento (hardware).
3.3.1.2 Linguagem de programação
A linguagem de programação utilizada para o desenvolvimento do protótipo foi a
C/C++. Essa linguagem foi escolhida pelos seguintes motivos:
a) ser bastante difundida no meio acadêmico e científico;
b) ser de fácil entendimento e abordagem;
c) ser suportada pela IDE e pelo kit escolhidos para o desenvolvimento;
d) possuir padrões e notações de escrita e documentação já prontas.
O Quadro 1 ilustra um exemplo de código fonte feito para a linguagem C++.
34
/******************************************************************************* * Function Name : SetColor * Description : Get the color according the parameters * * Input : u8 type * Return : u32 color *******************************************************************************/ u32 SetColor(u8 type) { //Each type had a color, default is white //1- .... //2- :: //3- ':. //4- .:' //5- .:. //6- ..: //7- :.. switch(type) { case 1: return RED; case 2: return WHITE; case 3: return ORANGE; case 4: return GREEN; case 5: return BLUE; case 6: return YELLOW; case 7: return MAGENTA; default: return WHITE; } }
Quadro 1 – Exemplo de código fonte implementado para a linguagem C++.
A linguagem C foi criada em 1972, por Dennis M. Ritchie e Brian W. Kernighan, baseando-se na linguagem B, proveniente na antiga Basic Combined Programming
Language (BCPL). B foi renomeado com a primeira letra de BCPL e a linguagem C, com a segunda.
C tornou-se rapidamente popular, pois une leveza, poder e velocidade em códigos bem legíveis e de fácil interpretação, sem a necessidade de entender instruções complexas como os códigos escritos em linguagem Assembly. C/C++ é utilizada no desenvolvimento de mais de 90% dos jogos profissionais, de Tetris a jogos que utilizam avançados motores como Doom II, da Idsoftware.
A linguagem C++ foi introduzida por Bjarne Stroustrup, em meados de 1983, com novos e poderosos elementos e novas propostas para a programação, que contribuem para o reuso, manutenção e adição ao código. C++ possui extensas bibliotecas-padrão que utilizam em grande quantidade as características da linguagem em relação a C.
Códigos escritos em C/C++ são de fácil leitura, pois a linguagem permite separar seu código em partes e arquivos para que seja mais bem estruturado. Com C++, o programador cria bons hábitos na programação, sabendo organizar seu código de maneira legível e tornando-o mais veloz. (SANTEE, 2005, p.21).
35
3.3.1.3 O kit de desenvolvimento STM3210B-PRIMER
Já descrito nas seções anteriores, o kit STM3210B-PRIMER foi escolhido por fornecer
toda a estrutura necessária de hardware para se implementar o protótipo do game. A Figura 17
ilustra o kit. Contando com o acelerômetro, display LCD, microprocessador ARM, timer e um
sistema operacional próprio (Circle-Os), ele se destaca e contribui muito para o
desenvolvimento do protótipo, não se fazendo necessárias a construção e soldagem dos
componentes eletrônicos utilizados, uma vez que os mesmos já fazem parte do kit.
Fonte: Raisonance (2008a).
Figura 17 – Kit STM3210B-PRIMER
Ao se ligar o kit de desenvolvimento a primeira tela apresentada é a tela inicial do seu
firmware, onde fica visível o dispositivo Pointer, que é um ponto na tela que se locomove de
acordo com os movimentos do usuário, conforme mostra Figura 18, essa funcionalidade já
vem de fabrica e é toda tratada pelo próprio firmware.
36
Figura 18 – Tela inicial do kit STM3210B-PRIMER com o Pointer
Nessa mesma tela inicial, ao se pressionar o botão, são mostrados os menus do
Firmware. Através deles pode-se acessar as funcionalidades e configurações do kit, tais como
configuração do relógio interno, informações sobre o kit, configuração de velocidade de
processamento (clock), desligamento do kit, intensidade da luminosidade do LCD, um
pequeno aplicativo de teste do kit e um menu (mostrado na Figura 19) contendo todas as
aplicações carregadas para a memória do mesmo.
O kit ainda traz de fábrica dois jogos instalados, o jogo BreakOut e o jogo Maze. O
jogo BreakOut é um jogo clássico desenvolvido para várias plataformas de jogos diferentes, o
jogo consiste em rebater uma bola, utilizando uma barra que fica na base da tela do jogo, na
direção de pequenos tijolos que ficam no alto da tela do jogo, afim de quebrá-los todos até
não restar nenhum. Já o jogo Maze é mais conhecido como Pac-Man, é um jogo bastante
popular onde o objetivo é movimentar um boneco pelo labirinto do jogo, comendo todas as
pastilhas encontradas no caminho até não sobrar nenhuma, evitando os quatro fantasmas
existentes que tentam aniquilar o boneco.
37
Figura 19 – Menu inicial do kit STM3210B-PRIMER
3.3.1.4 Desenvolvimento do Jogo
Como o principal objetivo deste trabalho foi desenvolver um protótipo de game que
utilize o acelerômetro, foi desenvolvido um game de Tetris para o kit de desenvolvimento
escolhido. Este game diferenciou-se dos demais por utilizar o acelerômetro sem modificar as
regras básicas e clássicas do game Tetris. Este game baseia-se em encaixar na base da tela as
peças de diferentes formatos que surgem uma de cada vez no alto da tela, de forma a
preencher totalmente as linhas horizontais, não deixando nenhum espaço livre entre as peças.
Quando uma linha é preenchida, a mesma desaparece da tela e o jogador soma pontos. O
game termina quando as linhas incompletas se empilham até o topo da tela.
O fabricante do kit possui um fórum e um site específicos para o desenvolvimento e
discussão de aplicações, jogos e utilitários que são feitos para a plataforma do kit. A Figura 20
ilustra a página inicial do fórum.
38
Fonte: Raisonance (2008b).
Figura 20 – Página inicial do fórum do kit STM3210B-PRIMER
Neste fórum os desenvolvedores podem postar suas aplicações e discutir com os
demais participantes sobre suas idéias e problemas com o kit de desenvolvimento. Para poder
postar um projeto neste fórum, deve-se seguir algumas regras do mesmo, para que não
existam projetos copiados, duplicados e projetos que desrespeitem alguma regra de direitos
autorais.
Foi feito uma busca neste site por jogos conhecidos que ainda não haviam sido
implementados para a plataforma do kit, sendo observado que o game Tetris ainda não tinha
sido desenvolvido e postado neste fórum. Surgiu então à idéia de desenvolvê-lo utilizando-o
como protótipo do game. Além disso, o game Tetris foi escolhido por ser um game bastante
conhecido e fácil de jogar. Este game fez muito sucesso nas décadas de 80 e 90 e ainda hoje é
desenvolvido em várias plataformas de videogames e dispositivos de jogos.
Segundo Fahey, o game Tetris surgiu em 1985 (ver Figura 21) e foi criado pelo russo
Alexey Pajitnov, que se inspirou num antigo jogo grego do tipo puzzle, que envolvia um
enigma onde deveriam ser encaixadas doze peças de cinco quadrados, os Pentaminos. Pensou
em criar um game com essas peças, os Pentaminos, onde os mesmos caiam de um tabuleiro
retangular e deveriam ser encaixados na sua base, um em cima do outro, mas percebeu que a
estrutura dos Pentaminos era muito complexa para ser arranjada no tabuleiro do game fazendo
39
o mesmo ficar muito complexo de se jogar. Sendo assim resolveu utilizar sete peças
compostas de quatro quadrados, os Tetraminos, vindo daí o nome do game, Tetris.
Fonte: Fahey (2007).
Figura 21 – Primeira versão do game Tetris
O game Tetris se popularizou muito rapidamente recebendo inúmeras versões em
variadas plataformas de computadores e chips. Em 1987, finalmente o Tetris foi liberado para
a plataforma PC, contribuindo ainda mais para a sua popularização. A Figura 22 ilustra sua
versão para PC de 1987.
Fonte: Fahey (2007).
Figura 22 – Tela do Tetris para PC de 1987 com sua sete peças
Com o game a ser prototipado escolhido, passou-se para a etapa seguinte, a formulação
do game com características compatíveis com o kit. Neste estágio do trabalho verificou-se
uma barreira quanto a IDE de desenvolvimento, pois a mesma não fornece uma estrutura boa
para se trabalhar com Orientação a Objetos, tornando mais dificultoso o desenvolvimento do
trabalho, requerendo mais tempo hábil para o mesmo. Com isso adotou-se a idéia de se
trabalhar com mesma estrutura de programação já utilizada em anos atrás para o
desenvolvimento do game Tetris, a clássica forma estruturada de programação em C. Isto veio
a contribuir com o trabalho, pois o padrão que a fabricante do kit sugere seguir no
desenvolvimento dos projetos segue a forma estruturada de C.
40
No decorrer do desenvolvimento da aplicação, estudou-se a documentação do kit de
desenvolvimento e sua Application Programming Interface (API) de funcionamento. Essa
API é como um mini Sistema Operacional, um firmware, ela possui muitas funções gráficas e
funções de manejo dos componentes do kit (O LCD, o acelerômetro, o botão e os leds). O
Quadro 2 mostra a organização da API.
ARQUIVO FUNCIONALIDADE button.c Inicialização e gerenciamento do botão buzzer.c Funções dedicadas ao buzzer, com suporte a sons
no formato RTTTL circle_api.h Biblioteca de controle geral do kit de
desenvolvimento draw.c Utilitários de desenho lcd.c Driver LCD para ST7637 led.c Gerenciamento dos leds mems.c Inicialização e gerenciamento do acelerômetro menu.c Gerenciador geral dos menus e caixas de diálogo menu_app.c Funções gerais para lidar com o menu da aplicação menu_settings.c Gestão de um menu, que permite configurar o
STM32-PRIMER, o kit pointer.c Diversos utilitários para gerenciamento dos
ponteiros rtc.c Gestão e utilitários do relógio interno Util.c Funções úteis pata o kit, como conversão de inteiro
para string Quadro 2 – Organização da API Circle-os
A biblioteca desta API que foi a mais importante para o desenvolvimento do trabalho
foi a Mems.c que fornece informações sobre o acelerômetro através da função
MEMS_GetInfo( ). Essa informação é guardada em uma estrutura da própria biblioteca
chamada tMEMS_Info que pode ser acessada em qualquer momento na aplicação, desde que
declarada, conforme código fonte do Quadro 3.
41
//Information of the MEMS tMEMS_Info* pMEMS_info; s16 Initial_MEMS_X, Initial_MEMS_Y; /******************************************************************************* * Function Name : Application_Ini * Description : Initialization function of Circle_App. This function will * be called only once by CircleOS. * Input : None * Return : MENU_CONTINUE_COMMAND *******************************************************************************/ enum MENU_code Application_Ini ( void ) { POINTER_SetMode(POINTER_OFF); if(strcmp(UTIL_GetVersion(), NEEDEDVERSION) < 0) { return MsgVersion(); } Initial_MEMS_X = 0; Initial_MEMS_Y = 0; MEMS_GetInfo()->DoubleClick = 0; //Prevents Arbitary change on startup (DoubleShock) pMEMS_info = (MEMS_GetInfo()); //Get the info about the MEMS LCD_SetScreenOrientation ( V12 ) ; //Fix the orientation to match with the MEMS information VariableInit(); //Initializa the Variables DesignInit(); //Initialize the LCD Design return MENU_CONTINUE_COMMAND; //Return Continue }
Quadro 3 – Trecho do código fonte que capta as informações do acelerômetro
A partir dessa informação pode-se começar a trabalhar com o acelerômetro, traduzindo
as variáveis e seus valores para um significado usual no protótipo. Para esta parte foi feita a
codificação representada no Quadro 4, que traduz as informações do acelerômetro.
42
//Get information from the accelerometer Current_MEMS_X = pMEMS_info -> OutX_F4 >> 2; Current_MEMS_Y = pMEMS_info -> OutY_F4 >> 2; deltaX = Current_MEMS_X - Initial_MEMS_X; deltaY = Current_MEMS_Y - Initial_MEMS_Y; //Check the direction of movement // | // x___|___ // | // | // y if(abs(deltaX)>abs(deltaY))//more X than Y { if(Current_MEMS_X>0) Direction=2; // | // ___|_O_ // | O // | if(Current_MEMS_X<0) Direction=4; // | // _O_|___ // O | // | } if(abs(deltaX)<abs(deltaY))//more Y than X { if(Current_MEMS_Y>0) Direction=3; // O|O // ___|___ // | // | if(Current_MEMS_Y<0) Direction=1; // | // ___|___ // | // O|O }
Quadro 4 – Trecho do código fonte que traduz as informações do acelerômetro
A primeira parte do código acima utiliza duas variáveis de locomoção do acelerômetro,
a OutX_F4 e a OutY_F4, que trazem a posição dos acelerômetros nos eixos x e y,
respectivamente, no momento em que são atribuídos. Com estes valores, é possível calcular
quanto foi a movimentação de x e y em relação a posição inicial de x e y, obtendo assim um
valor delta (representado pelas variáveis deltaX e deltaY). Como no protótipo
implementado interessava somente saber para qual direção o jogador moveu o kit (para cima,
ou para baixo, ou para o lado esquerdo ou direito) a fim de mover as peças do game, resolveu-
se calcular qual a direção que obteve maior deslocamento. Assim sendo calculou-se se x ou y
obteve maior movimentação, determinando-se assim se a movimentação foi horizontal (eixo
x) ou vertical (eixo y). Após isso bastou verificar se os valores eram negativos ou positivos
para designar se o movimento foi para o lado esquerdo ou direito, no caso da movimentação
horizontal, ou foi para cima ou para baixo, no caso da movimentação vertical. Esse trecho do
código de checagem de direção e movimentação foi a parte mais importante do trabalho, pois
com isso pode-se saber qual foi a intenção do jogador e quais as medidas deveme ser tomadas
para mover ou alterar o status do game.
43
Outra parte do código que se utilizou do acelerômetro para prototipar uma função foi a
funcionalidade da pausa de game (representada no Quadro 5) que é importante, pois um
jogador, motivado por algum fator externo do game, pode querer parar sua execução por um
tempo indeterminado a fim de continuar sua execução do mesmo ponto após esse tempo.
Como o kit de desenvolvimento possui somente um botão, e este já tinha a funcionalidade, de
fábrica, de sair da aplicação para a tela principal do Sistema Operacional do kit (funcionando
como um botão de saída da aplicação), foi necessário implementar outra maneira de captar o
comando de pausa do usuário. Depois de pesquisar as documentações da API do kit,
descobriu-se que uma versão mais atual da API, a 2.0, trazia algumas funcionalidades novas
diferentes da versão embarcada no produto, a 1.5. Decidiu-se então atualizar as APIs do kit
para esta versão nova, que trazia consigo a funcionalidade descrita pelo fabricante como
Double Shock, onde o acelerômetro do kit detecta se o mesmo recebeu um duplo clique, ou
duplo choque que emula um duplo clique, e grava uma variável com esta informação, a
variável DoubleClick que fica na estrutura de informações do acelerômetro. Decidiu-se então
utilizar esta função para pausar o game, dando um Double Shock no kit o game é pausado,
dando outro Double Shock, o game é retornado a sua execução. O quadro abaixo ilustra essa
implementação.
if (pMEMS_info -> DoubleClick)//Check the double shock { pMEMS_info -> DoubleClick = 0;//Re-arm the double shock if(system_pause == 0) { //paused system_pause = 1; LED_Set( LED_RED, LED_BLINKING_LF ); //Display Pause msg DRAW_SetTextColor(WHITE); DisplayPause(); } else { //no paused system_pause = 0; LED_Set( LED_RED, LED_OFF ); //Erase pause msg DRAW_SetTextColor(BLACK); DisplayPause(); } }
Quadro 5 – Trecho do código fonte que implementa a pausa do game com o Double Shock
No primeiro momento desta rotina o programa verifica se houve algum Double Shock,
em caso afirmativo, ele atribui zero a variável, para checar novamente mais tarde. A variável
system_pause é uma flag que verifica se o game está pausado (valor igual à 1) ou se o game
está rodando (valor igual à 0) dependendo da situação o programa pausa o game ou continua a
sua execução.
44
Para representar as peças do game, foram criadas duas estruturas básicas, uma
representando um quadrado da peça de Tetris, def_Square, e outra representando a peça do
Tetris em si, def_Piece. Para controlar as peças que estavam em jogo, a peça que iria entrar
em jogo e o desenho destas, foram criadas três variáveis do tipo def_Piece. O Quadro 6
mostra esta implementação.
/* Data types -------------------------------------------------*/ //Square of a piece struct def_Square { u8 xPos,yPos; }; //The piece struct def_Piece{ struct def_Square squares[4]; //four squares for each piece u8 type; //type of piece 1..7 u16 color; //color of piece u8 position; //position of piece 1..4 }; //Control Piece struct def_Piece currentPiece; struct def_Piece nextPiece; struct def_Piece designPiece;
Quadro 6 – Trecho do código fonte que cria as estruturas representando as peças do game
O tabuleiro do game foi representado por uma estrutura matriz, onde os seus valores
representam o tipo de peça que está na posição selecionada, ou se nenhuma peça existe na
posição selecionada, a estrutura está exemplificada no Quadro 7.
unsigned char board [18][31]; // Board of the game //values //0 - not completed //1 – completed
Quadro 7 – Trecho do código fonte que representa a estrutura do tabuleiro
Com estas estruturas de controle representadas, segue-se para o desenvolvimento das
funcionalidades do game, como movimentação e rotação da peça, desenho do LCD,
mensagens na tela informando a situação do game, representação e cálculo de pontos e vidas
no game, música inicial do game, validação dos movimentos das peças, tratamento de
colisões, tratamento de limites de tela, exclusão de linhas completas e sorteio de peças
aleatórias que surgem no game. Estas funções estão representadas no Quadro 8.
45
/* Private functions ---------------------------------------------------------*/ enum MENU_code MsgVersion(void); //Version Dialog static void DesignInit(void); //Init screen static void VariableInit(void); //Init variable for //application u8 ValidMov (u8, u8, u8); //Validation of move u8 ValidLin(u8); //Verify completed //lines u8 CheckDead(); //Check Dead u32 SetColor(u8); //Get the color void Move (u8); //The moving //function void DownLin(u8); //Down a line void Sort(void); //Sorts a new piece void CalcPiece(u8,u8,u8,u8,u8); //Calculate the //piece void RoundPiece(void); //Rotate the piece void Reestart(); //Reestart the game void CheckScoreLevel(u8); //Add the value to //score and check the level. void EmptyBoard(); //Reestart the board //and the verificator void PaintLifes(u8); //Paint the BMP life void DisplayPause(); //Display Paused void DisplayScore(void); //Display Score void DisplayLevel(void); //Display Level void DisplayCompLines(void); //Display the Number of //Completed lines void DisplayInformation(u8,u8,char[6],u8,u32); //Display a information //at right of the board void DrawScreenLimit(); //Draw the limits of //the screen void DrawPiecesFromBoard(); //Draw the board's //pieces void DrawPiece(struct def_Piece, u8, u32); //Draw a piece
Quadro 8 – Trecho do código fonte com o protótipo das funções do game
Por sugestão do fabricante da IDE, para cada função criada, foi necessário criar, antes
do corpo da mesma, uma estrutura que organizava a IDE no controle destas funções. Esta
estrutura é um comentário que descreve brevemente a função, suas entradas e suas saídas. O
Quadro 9 exemplifica uma destas funções com a sua estrutura de comentário.
/*********************************************************************** * Function Name : DisplayCompLines * Description : Display the Number of Completed lines * * Input : None * Return : None ***********************************************************************/ void DisplayCompLines(void) { //Int to text UTIL_uint2str( TextBuffer, Lines, 3, 1); //set the color to green DRAW_SetTextColor(LIGHT_GRAY); //Draw the Score points DRAW_DisplayString(LINES_NMB_X_POS,LINES_NMB_Y_POS, TextBuffer,LINES_NMB_LEN); }
Quadro 9 – Exemplo de uma função com sua estrutura de comentário
Trabalhar com estas estruturas tornou o trabalho mais organizado e mais claro,
resultando também na aceitação, no fórum do fabricante, do protótipo implementado, como
projeto.
46
Depois de implementado e feitos os testes via debug pela IDE, apareceu a necessidade
de instalar o aplicativo no kit, a fim de validar o mesmo sem a necessidade de um debug. A
primeira etapa realizada para testar a aplicação, foi instalar a mesma no kit. Esse processo é
todo feito por linhas de comando ou aplicativos de lotes disponibilizados pelo fabricante do
kit. Para conseguir fazer isto torna-se necessário a instalação de alguns drivers e aplicativos
que acompanham o kit, no computador utilizado para fazer o desenvolvimento.
Este processo é muito demorado, alguns passos são confusos e complicados de serem
executados, observando isso, resolveu-se implementar um aplicativo que ficasse responsável
por gravar, excluir e listar todos os aplicativos instalados no kit, permitindo assim um maior
maleabilidade do kit ao desenvolvedor evitando um esforço desnecessário do mesmo para
escrever as aplicações e apagá-las, assim nasceu o STM32 Manager, criado para esta função.
A Figura 23 ilustra o STM32 Manager.
Figura 23 – Tela do aplicativo STM32 Manager
O STM32 Manager foi criado utilizando a linguagem de programação C++. Ele cria
menus para o usuário selecionar uma exclusão única de um aplicativo, exclusão total dos
aplicativos, listagem dos aplicativos e carregamento de aplicativos para o kit. De acordo com
a escolha feita pelo usuário, o programa chama o utilitário Circle_Mgr.exe, que é
disponibilizado pelo fabricante juntamente com o kit, passando os parâmetros de acordo com
a escolha. A partir destes parâmetros, o utilitário executa a ação. O Quadro 10 mostra um
trecho de seu código fonte.
47
void shell(char s[20]){ ShellExecute(NULL, NULL, "C:\\Program Files\\Raisonance\\Ride\\bin\\Circle_Mgr.exe", s, NULL, SW_SHOWNORMAL); } void eraseApp(){ char str[20] = ""; char str1[20] = "L E"; char str2[20] = ""; char str3[20] = " L S W"; printf("\n\n Enter the name of the application: "); scanf("%s",&str2); strcat (str, str1); strcat(str,str2); strcat(str,str3); shell(str); }
Quadro 10 – Trecho de código fonte do STM32 Manager que chama o utilitário Circle_Mgr.exe
3.3.2 Operacionalidade da implementação
Ao se ligar o kit de desenvolvimento, o primeiro aplicativo que aparece ao usuário é
uma tela inicial do firmware do mesmo, onde há o Pointer. Pressionando o botão do kit, o
usuário poderá visualizar todos os menus do kit de desenvolvimento. Nesses menus ele
poderá selecionar o protótipo do game e iniciar o mesmo.
Ao se iniciar o protótipo, a primeira tela que aparece ao usuário é a tela do próprio
game (ver Figura 24), sem que haja a necessidade do mesmo iniciar alguma seleção de menu.
Nesta tela uma música (desenvolvida em formato Ring Tone Text Transfer Language
(RTTTL) compatível com o kit) começa a tocar no buzzer do kit. Após tocar toda a música o
game tem início.
48
Figura 24 – Tela inicial do game
No início do game, o aplicativo inicializa os pontos do jogador com o valor de zero,
suas vidas com o valor de cinco, o número de linhas completadas com o valor de zero, o nível
do game com o valor de um, mostra qual será a peça seguinte a cair na tela e apresenta uma
peça no alto do tabuleiro que começa a cair em direção à base do mesmo.
Conforme já foi explicado, o objetivo do game é encaixar na base do jogo, todas as
peças que aparecem no alto do tabuleiro, de forma a não sobrarem espaços vazio e
incompletos, a fim de se completar as linhas, para que assim essas desapareçam e sejam
somados os pontos.
Cada vez que uma peça é encaixada na base do tabuleiro, ou em cima de outra peça,
ela é travada naquela posição e a peça que se encontrava no campo da próxima peça (Next) é
inserida no alto do tabuleiro e uma nova peça é sorteada aparecendo no campo Next. Esse
sorteio é feito somando-se a um acumulador os números que representam a hora, os minutos e
os segundos do momento da chamada da função, esse acumulador é dividido por sete, onde o
resto dessa divisão é um número de zero a seis que representam as sete peças do game. Cada
linha completada equivale a uma pontuação, dependendo do nível do game em que se está.
Quando uma linha for completada, o protótipo soma pontos e acresce o número de linhas
completadas. Assim que se chega a uma determinada pontuação o game passa para o nível
seguinte, tornando mais difícil o jogo, pois cada nível aumenta a velocidade de queda das
peças no tabuleiro. As Figuras 25 e 26 exemplificam o encaixe e surgimento das peças no
game.
49
Figura 25 – Peça sendo movimentada no game.
Figura 26 – Peça sendo movimentada no game.
Para movimentar uma das sete peças do game (representadas na Figura 27) durante sua
queda no tabuleiro, deve-se pender o kit para os lados esquerdo e direito, fazendo assim a
peça se mover para os mesmo lados, como mostra a Figura 28. Pendendo o kit para frente, a
peça do game é rotacionada para o sentido horário. Dependendo da peça ela pode ter até
quatro posições de rotação, conforme descrito na Figura 27. Para poder pausar o game o
jogador deve dar duas batidinhas no kit, emulando um clique duplo, ativando assim o
dispositivo Double Shock do acelerômetro, pausando o game. Após refazer o procedimento o
50
game é reiniciado. A Figura 29 mostra o game pausado.
Fonte: Fahey (2007).
Figura 27 – Peças do game Tetris e suas possíveis posições tomadas no decorrer do jogo
51
Figura 28 – Movimentação do kit
52
Figura 29 – Game pausado pelo jogador.
Cada vez que as peças já encaixadas no tabuleiro alcançarem o alto do mesmo, o
jogador perde uma vida, o game apaga todas as peças do tabuleiro e inicia um novo tabuleiro
completamente vazio.
Quando um jogador perder todas as suas vidas o jogo acaba, aparecendo a tela de game
over (ver Figura 30) onde é informada ao jogador a maior pontuação feita no game (o
recorde) que fica salvo em um registrador mapeado na memória do kit, sendo modificada toda
vez que um jogador consegue superá-lo. É informado o fim do jogo e exibida uma mensagem
pedindo para que o jogador clique no botão do kit para sair do game. O jogador também pode
sair do game a qualquer momento, clicando no botão do kit.
53
Figura 30 – Tela de game over do game
3.4 RESULTADOS E DISCUSSÃO
Para demonstrar e testar na prática o funcionamento do protótipo resolveu-se submeter
o mesmo à avaliação dos técnicos, que não é reportada ao desenvolvedor, e dos usuários do
fórum do fabricante do kit, com isso tem-se uma validação real do protótipo, visando uma
qualidade boa de código, funcionamento e jogabilidade, provando que o uso do acelerômetro
no desenvolvimento do game foi justificado e que o mesmo ocorreu de maneira a não
prejudicar a jogabilidade, trazendo mais benefícios e desafios ao jogador.
O fórum do fabricante, localizado no endereço http://www.stm32circle.com, possui
uma base com trinta e seis projetos postados e quatro mil setecentos e oitenta e três usuários
54
registrados (ver Figura 31), todos estes projetos postados são revisados e testados pela equipe
de manutenção do mesmo, assegurando que somente projetos com boa qualidade e
provenientes de idéias novas sejam postados, a fim de proteger direitos autorais,
equipamentos dos usuários e manter um nível de conhecimento razoável.
Fonte: Raisonance (2008b)
Figura 31 – Parte da página do fórum do fabricante do kit, onde mostra a quantidade de projetos e usuários
O protóripo foi submetido ao fórum do fabricante em 3 de outubro de 2008. O projeto r
passou pela avaliação dos programadores do fabricante, e o mesmo apareceu como destaque
na página inicial do fórum (ver Figura 33), apresentando a todos o game como projeto
destaque. Nessa situação, começaram a aparecer inúmeros downloads do mesmo, e visitas à
página de documentação e download do protótipo (ver Figura 32). Após duas semanas
presente no fórum, o protótipo de game Tetris desenvolvido já tinha a melhor avaliação de
seus jogadores, ou seja, foi o projeto melhor avaliado, liderando a lista de projetos mais
populares do fórum (ver Figura 34).
55
Fonte: Raisonance (2008c). Figura 32 – Página do protótipo do game no fórum do fabricante com suas 481 visitas e 59 downloads
Fonte: Raisonance (2008b)
Figura 33 – Página do fórum do fabricante que mostra o protótipo desenvolvido como projeto da semana
56
Fonte: Raisonance (2008b)
Figura 34 – Trecho da página que mostra o protótipo desenvolvido como o mais popular do fórum
Existiram alguns obstáculos que tiveram que ser superados para se obter sucesso no
desenvolvimento deste trabalho. O primeiro deles foi a falta de dispositivos que continham o
acelerômetro para desenvolvimento de aplicações. No Brasil, ainda é difícil encontrar
dispositivos e placas eletrônicas de desenvolvimento com o acelerômetro. Os poucos que
existiam tinham um custo muito elevado, como o celular Nokia N95 e o Iphone da Apple.
Como desenvolver uma placa com circuito que utilizasse o acelerômetro tomaria muito tempo
hábil, resolveu-se adquirir um kit de desenvolvimento, o kit STM3210B-PRIMER. Ele foi
importado dos Estados Unidos. Com o kit de desenvolvimento em mãos, passou-se para o
estudo do mesmo, e constatou-se a falta de documentação sobre o kit e os dispositivos
embarcados no mesmo. Passou-se então a utilizar a página do fabricante como referência,
buscando aplicações e documentos referentes às funcionalidades e bibliotecas do kit.
Estudando-se este material e algumas aplicações prontas do site, conseguiu-se entender o
57
funcionamento e as bibliotecas do kit.
Existiram também alguns problemas referentes a IDE Ride7. O maior deles
relacionado a um erro de estouro de memória, indicando que o código fonte do protótipo
excedia a quantidade de bytes que o kit suportava. Após muitas buscas nos fóruns do
fabricante e cerca de dois dias depois conseguiu-se achar a solução para o problema, que
envolveu a alteração de uma configuração interna da IDE, fazendo com que a mesma
aceitasse aplicações com código fonte de tamanho maior que 8 Kilobytes. Contudo quando
este valor era atingido, não era mais possível ser feito o debug da aplicação. Com isso alguns
testes só poderam feitos com a aplicação rodando diretamente no kit de desenvolvimento.
Outro problema encontrado foi à falta de apoio da IDE à programação Orientada a
Objetos, ficando todo o controle a ser feito pelo programador, como isto requeria maior tempo
hábil, decidiu-se seguir o modelo de programação padrão do fabricante, um C++ estruturado
com funções. Talvez a falta de um apoio à Orientação a Objetos se deve à simplicidade dos
aplicativos implementados para o kit, pequenos jogos e aplicativos que não necessitam de
uma definição orientada a objetos, com a linguagem estrutural dando apoio suficiente ao
desenvolvimento dos mesmos.
Outro problema enfrentado também foi a falta de funções cruciais para o protótipo que
não estavam presentes na versão 1.5 do firmware. Com a alteração de versão para a 1.7 este
problema foi solucionado.
58
4 CONCLUSÕES
Foi visto que a indústria de jogos está sendo impulsionada por grandes investimentos,
alimentando o desenvolvimento de tecnologias novas, tanto de hardware quanto de software.
Dentro destas novas tecnologias, surgiu o acelerômetro que trouxe um novo modo de
interação entre o jogador e o jogo. Como se trata de uma tecnologia nova decidiu-se
prototipar um game utilizando-o como interface de comunicação entre o jogo e o jogador,
capturando os movimentos do jogador e manipulando assim os objetos do jogo.
Observa-se que devido aos limites do kit utilizado, não foi possível desenvolver um
game muito complexo, pois se trata de um protótipo cujo escopo é explorar e demonstrar o
uso do acelerômetro como dispositivo de controle e captação de movimentos e não a
tecnologia dos algoritmos gráficos e bibliotecas envolvidas.
Verifica-se ainda que já existem aplicações comerciais que utilizam o acelerômetro, no
entanto as empresas que as possuem não divulgam as tecnologias e métodos empregadas,
deixando assim, uma lacuna de conhecimento sobre estes itens. A área acadêmica necessita
desenvolver este conhecimento e divulgá-lo para os interessados no assunto para não perder
este avanço tecnológico.
Pode-se concluir que se conseguiu chegar aos objetivos propostos, desenvolvendo um
game em plataforma ARM que utiliza o acelerômetro como interface de captação de
movimento, provando que seu uso contribui ainda mais para a jogabilidade do game. Conclui-
se também que o acelerômetro se trata de um dispositivo multiuso com infinitas aplicações,
atuando em várias áreas da informática, como entretenimento, segurança, portabilidade e
outras. Como o seu uso é abrangente espera-se que surjam cada vez mais aplicações e
tecnologias que o utilizem.
O meio acadêmico tem muito conhecimento a desenvolver acerca do mesmo,
conseguindo assim atrair investimentos acadêmicos criando tecnologias novas. O
desenvolvimento deste game demonstrou que até pequenas aplicações e jogos podem fazer
uso do mesmo atraindo mais usuários e jogadores. A publicação do jogo no fórum do
fabricante caracterizou isso, uma vez que o game obteve sucesso e popularidade muito
rapidamente.
59
4.1 EXTENSÕES
Como este trabalho priorizou fazer um estudo introdutório do acelerômetro para provar
que seu uso em jogos e aplicações é justificável, desenvolvendo um protótipo que o utilize,
não foi desenvolvido nenhuma aplicação muito complexa, mas isso não quer dizer que não
seja possível, como foi mostrado já existem videogames de última geração contando com este
recurso.
Para dar continuidade a este trabalho, sugere-se o desenvolvimento de uma função para
descer mais rapidamente as peças do jogo Tetris, a fim de deixar o jogo mais dinâmico. Para a
captação do movimento, sugere-se utilizar a movimentação do kit para baixo.
Outra extensão a ser trabalhada seria o uso do eixo Z no jogo, implementando uma
versão 3D do Tetris que poderia utilizar o acelerômetro para checar a profundidade do
movimento.
No final do ano de 2008, a Raisonance lançou a versão 2 do kit utilizado no
desenvolvimento deste trabalho, implementar o jogo Tetris para esta versão (versão 2) seria
um grande desafio, pois os recursos presentes nessa nova versão são maiores, beneficiando o
desenvolvimento de novas funções e o aprimoramento das funções já presentes no protótipo.
60
REFERÊNCIAS BIBLIOGRÁFICAS
APPLE INC. Accelerometer. [S.l.], 2008a. Disponível em: <http://www.apple.com/iphone/features/index.html#accelerometer>. Acesso em: 31 mar. 2008.
______. Revolutionary phone. [S.l.], 2008b. Disponível em: <http://www.apple.com/iphone/features/index.html#phone>. Acesso em: 31 mar. 2008.
COELHO, Guilherme. Acelerômetros: o truque da detecção dos movimentos na nova geração de celulares. [S.l.], 2007. Disponível em: <http://webinsider.uol.com.br/index.php/2007/11/29/acelerometros/>. Acesso em: 25 mar. 2008.
FAHEY, Colin. Tetris. [S.l.], 2007. Disponível em: <http://www.colinfahey.com/tetris/tetris_pt.html>. Acesso em: 03 out. 2008.
LIPPE, Pedro H. L.; FREITAS, Luiz E. FAQ wii: tudo sobre o novo console. [S.l.], [2007?]. Disponível em: <http://www.wii-brasil.com/index.php?sec=lerartigo&id=52>. Acesso em: 31 mar. 2008.
MORIMOTO, Carlos. Smartphones: acelerômetros. [S.l.], 2008. Disponível em: <http://www.gdhpress.com.br/blog/smartphones-acelerometros/>. Acesso em: 10 out. 2008.
NINTENDO OF AMERICA INC. What is Wii? Washington, 2008a. Disponível em: <http://www.nintendo.com/wii/what>. Acesso em: 31 mar. 2008.
______. Wii controllers. Washington, 2008b. Disponível em: <http://www.nintendo.com/wii/what/controllers>. Acesso em: 31 mar. 2008.
PEREIRA, Fábio. Tecnologia ARM: microcontroladores de 32 bits. São Paulo: Érica, 2007.
PORTAL TERRA. Indústria mundial de games valerá US$ 44 bilhões. [S.l.], 2006. Disponível em: <http://games.terra.com.br/interna/0,,OI1162241-EI1702,00.html>. Acesso em: 25 mar. 2008.
RAISONANCE. RIDE toolset for STM32. [S.l.], 2008a. Disponível em: <http://www.stm32circle.com/resources/stm32primer.php>. Acesso em: 05 out. 2008.
______. STM32-primer: fun, easy introduction kit for STM32 microcontrollers. [S.l.], 2007. Disponível em: <http://elmicro.com/files/raisonance/stm32-primer-manual.pdf>. Acesso em: 01 abr. 2008.
61
RAISONANCE. Tetris Game 1.0. [S.l.], 2008c. Disponível em: <http://www.stm32circle.com/projects/project.php?id=50>. Acesso em: 01 out. 2008.
______. The STM32 Primer Community. [S.l.], 2008b. Disponível em: <http://www.stm32circle.com/hom/index.php>. Acesso em: 01 abr. 2008.
REINERT, Thomas A. Bewegungssensoren n2: inclinometer for Nokia N95. [S.l.], 2007. Disponível em: <http://www.symbian60.mobi/2007/11/05/bewegungssensoren-n2-inclinometer-for-nokia-n95/>. Acesso em: 10 out. 2008.
RIOLINO, Rael B. Novo Nokia N95 com câmera de 5 megapixels. [S.l.], 2006. Disponível em: <http://www.antenando.com.br/tecnologia/arquivo/novo-nokia-n95-com-camera-de-5-megapixels>. Acesso em: 31 mar. 2008.
SANTEE, André. Programação de jogos com C++ e Directx. São Paulo: Novatec, 2005.
STMICROELETRONICS. LIS3LV02DL: MEMS inertial sensor 3-axis - ±2g/±6g digital output low voltage linear accelerometer. [S.l.], 2008a. Disponível em: <http://www.st.com/stonline/products/literature/ds/12094/lis3lv02dl.pdf>. Acesso em: 26 mar. 2008.
______. STM32 primer. [S.l.], 2007a. Disponível em: <http://www.st.com/mcu/contentid-105-110-STM3210B_PRIMER.html>. Acesso em: 01 abr. 2008.
______. STM32F103x6 STM32F103x8 STM32F103xB: performance line, ARM-based 32-bit MCU with flash, USB, CAN, seven 16-bit timers, two ADCs and nine communication interfaces. [S.l.], 2008b. Disponível em: <http://www.st.com/stonline/products/literature/ds/13587.pdf >. Acesso em: 26 mar. 2008.
______. STMicroeletronics drives gaming revolution with Nintendo’s Wii: MEMS technology puts players into the action. Geneva, 2006a. Disponível em: <http://www.st.com/stonline/stappl/cms/press/news/year2006/t2031.htm>. Acesso em: 26 mar. 2008.
______. Three-axis digital accelermeter in LGA: high performance, low-power and cost effective. [S.l.], 2006b. Disponível em: <http://eu.st.com/stonline/products/promlit/pdf/flmemlis0906.pdf>. Acesso em: 10 out. 2008.
______. UM0395 User guide: LIS3LV02DL adapter board. [S.l.], 2007b. Disponível em: <http://www.stmicroelectronics.com/stonline/products/literature/um/13221.pdf>. Acesso em: 13 abr. 2008.
