[Tutorial] Aprendendo a Mexer com o Sun SPOTS

---------------------------------------------------------------------------------------------------------------------------------

Post originalmente publicado no meu blog pessoal. Estou republicando a primeira parte aqui porque o restante da série será postada neste blog.

Ontem eu traduzi esse post para o inglês como pode ser visto aqui.

A segunda parte do tutorial, falando sobre acelerômetros, pode ser lida aqui.

-------------------------------------------------------------------------------------------------------------------------------

To see a translation of this blog post in English, click here

-------------------------------------------------------------------------------------------------------------------------------

Eu sempre preferi a parte de software do que a de hardware - eu me lembro de realmente FUGIR das aulas sobre hardware no meu curso técnico, e sempre que tenho algum problema com hardware eu costumo pedir socorro ao meu namorado. Além dele entender mais disso do que eu, ele tem o mesmo efeito do Gizmo nesta tirinha do Recruta Zero:

Recruta Zero - The Gizmo Effect

Além disso, eu sempre preferi a praticidade da programação: é muito mais fácil aprender a programar do que aprender a mexer com hardware, já que tudo o que você precisa está ao alcance dos seus dedos: existem milhões de tutoriais de programação na rede, e não é muito difícil baixar IDEs e testar seus recém-feitos programas.

Mexer com hardware, por outro lado, envolve coisas misteriosas como comprar placas, ter de aprender a mexer com Assembly (ou com C, na melhor das hipóteses), montar redes místicas e torcer para nada queimar… e eu nem mencionei em tentar colocar periféricos extras e mais interessantes do que… LEDs.

Atualmente, existem algumas alternativas para quem quer mexer com um hardware mais interessante e de maneira não tão complicada - uma que eu posso mencionar que eu já usei é o kit de Lego Mindstorms - você pode criar bonecos em legos, colocar sensores de luz, de pressão, colocar motores, e programar tudo isso a partir de uma programação em blocos simples (mas limitada) provida pela kit, ou programar em C e passar o programa através de infravermelho para o robô feito de Lego.

Bom, o resultado do meu grupo quando nós tivemos de fazer um projeto com isso na faculdade foi esse:

Lego Mindstorms - AGV

Lindo, né? Trata-se de um pequeno veículo para levar e trazer peças em um chão de fábrica. Nada funcionou como a gente esperava na hora que a gente precisava, mas tudo bem…

O problema desse tipo de solução é que eles ainda são muito caros - especialmente aqui no Brasil. Um kit do Mindstorms mais recentes (e mais bacana) custa cerca de 1000 reais aqui no Brasil. Não é exatamente algo que você pense "ah, ok, vou comprar um para ver como é…". Mas é o tipo de coisa que eu gostaria de dar para um filho, se ele se interessasse e eu tivesse condições. Ein, meu filho será filho de dois engenheiros nerds, vocês tem ALGUMA dúvida de que ele será criado como uma criança tr00 nerd?

Devaneios maternais de lado, outra solução é o Bug Labs, que oferece um kit básico e "apetrechos" extras para você fazer coisas mais interessantes, como uma câmera de 2MP, GPS, uma base para você conectar apetrechos via USB, sensor de movimento, acelerômetro… o problema, novamente, é o preço: 250 dólares pela base, e de 50 a 80 dólares pelos módulos extras. Mas ele traz uma SDK para ajudar no desenvolvimento, e é open-source.

A outra opção que eu conheço e sobre a qual eu vou falar é a solução da Sun, o Sun SPOTS. Basicamente, são pequenos hardwares que você pode programar em Java, já que ele roda uma máquina virtual. Conta com acelerômetros, sensores de luz, botões analógicos e digitais, etc.

Nota rápida: Ao procurar por Sun Spots no Google, encontrei uma notícia com essa headline: "Sun goes longer than normal without producing sunspots" e cliquei, já preocupada em estar interessada em uma tecnologia que poderia estar dando sinais de cansaço.

Bom, não era bem esse o caso, como você pode conferir olhando a matéria

Nisso que dá uma empresa chamada Sun criar uma tecnologia chamada Sun SPOTS…

Como existem muitos gamers que lêem esse blog, eu acho que uma boa motivação seria mostrar esse vídeo do Sun Sposts sendo usado para criar um controle diferente para jogar Counter Strike:

 Legal, ein? Novamente, os preços são um problema: 750 dólares pela base e seus apetrechos. Existe um desconto promocional para estudantes americanos, para 300 dólares. Há algum tempo, porém, eles estavam dando kits para estudantes que apresentassem propostas interessantes de uso - um amigo meu conseguiu um kit assim. Atualmente essa promoção não está mais valendo, mas mesmo assim eu tenho chances de conseguir um kit (o que é um assunto para outro post).

Para isso, claro, eu preciso fazer uma proposta interessante de uso do Sun SPOTS. E para poder fazer isso, eu preciso conhecê-lo melhor, para saber do que esse danado é capaz.

E eu posso fazer isso não apenas lendo o site, mas efetivamente programando e testando no Sun Spots! Não em um de verdade, claro, mas em um emulador fornecido pela Sun.

Como eu adoro criar tutoriais, eu vou tentar relatar o que eu estiver aprendendo por aqui. Se alguém tiver MUITO interesse, entre em contato com uma proposta de uso. Eu não posso fazer muita coisa para conseguir kits, mas eu posso mostrar sua proposta para alguém que possa. :p

Instalando o Emulador

Primeiramente, você deve ter o Sun Java JRE. Se você já programa em Java, você já tem o que é necessário, então não se preocupe. Instruções mais específicas podem ser encontradas aqui, de acordo com o sistema operacional que você usa.

Tendo os runtimes necessários, tudo o que você precisa fazer é ir na página do Sun Spot Manager e baixar o aplicativo.

SunSpot Manager - Install Now

Execute-o com o Sun Java WebStart (seu sistema provavelmente irá conhecer a extensão e mandar abrir com esse programa, de qualquer maneira), leia aquilo tudo (eu tenho certeza de que você vai fazer isso…), desça a barra de rolagem até o final, clique em próximo, próximo… se quiser, crie um atalho para o Sun Spot Manager no seu desktop, facilita quando você quiser acessá-lo depois.

Ele vai verificar se você tem o Netbeans. Se você ainda não tiver, instale-o quando sugerido, assim como o Ant. Isso facilita bastante  na hora de desenvolver, acredite.

Além disso, não há muito segredo na hora de instalar - ele irá verificar os requisitos do seu sistema, sugerir instalar alguma coisa que não encontre… se você ler pelo menos o mínimo (sabe, aquelas mensagens que costumam aparecer com pontos de exclamação do lado), você não deve encontrar problemas aqui. Mas se encontrar algum, poste nos comentários que eu tento ajudar, claro.

Se você fez tudo certo, dê um duplo clique no atalho que está na sua área de trabalho e ele irá abrir o Sun SPOT Manager na aba de tutoriais. A parte que mais nos interessa é o Solarium:

Sun SPOT Manager - Solarium

É aqui que nós temos acesso ao emulador do Sun SPOT - clicar no pequeno botão escrito "Solarium" no canto inferior direito irá abrir o espaço do emulador (e também da onde você visualiza os Sun SPOTs reais que você tiver conectado ao seu PC).

Sun SPOT Solarium - Emulador

Ao ir no menu "emulator" e selecionar a opção "new virtual spot", você irá ver a imagem de um pequeno spot na sua tela:

Sun SPOT - virtual spot

Pronto, esse é o emulador. Ao clicar com o botão direito sobre o Virtual SPOT você vai ver a opção "deploy MIDlet bundle", que é onde você irá selecionar o programa que você fez para testar no SPOT… o que nos leva, claro, ao passo seguinte: como fazer um programa para o SPOT?

Desenvolvendo para Sun SPOT no NetBeans

Se você instalou o Netbeans junto do Sun SPOT Manager, você já deve ter os plugins necessários. Mas como esse não é o caso de muitas pessoas, vamos ver como instalar os  plugins necessários. Em primeiro lugar, você deve fazer o download do plugin que irá adicionar um novo Update Center ao NetBeans.

Para instalar esse plugin, abra o Netbeans e vá no menu "Ferramentas" -> Plug-ins.

Netbeans - Instalar Novo Plugin

Na aba "baixados", selecione "adicionar plug-ins" e escolha o plugin que você acabou de baixar. Depois de instalá-lo, vá em plug-ins disponíveis e recarregue o catálogo. Instale os plugins da categoria SunSPOT que irão surgir:

netbeans - sunspot plugin

Depois disso, crie um novo projeto na categoria "Java", do tipo Sun SPOT Application:

Netbeans - Novo Projeto de Sun SPOT

Você vai ver que ele já cria uma classe padrão, a StartApplication.java, que tem todos os "imports" e inicializações necessárias para fazer seu Spot funcionar - na realidade, este já é um programa que você pode testar no seu emulador. Não que ele seja muito úteil - ele se resume a ficar piscando um led enquanto você não abertar um botão.

O código para isso se encontra no método startApp():

Sun SPOT - Example Code

A primeira linha usa um método para recuperar o Switch 1, o primeiro led é colocado em um cor ligeiramente vermelha na segunda linha e então inicia-se um laço que é executado enquanto o Switch 1 estiver "aberto" (um switch fecha um circuito quando está pressionado, por isso a expressão "open", já que quando ele não está pressionado ele deixa um circuito aberto): Liga o led, espera um um quarto de segundo, desliga o led, espera um segundo e reinicia o processo.

Quando o switch é pressionado, o programa sai do laço e o notifyDestroyed serve para dizer que o programa foi encerrado (o que chama o destroyApp, que não faz nada além de se certificar de que todos os leds estão apagados neste caso).

Para construir o programa e testá-lo, você deve construi-lo, clicando com o botão direito sobre o projeto e selecionando "construir". Isso irá gerar um jar na pasta "suite" do seu projeto.

Agora, só falta a parte mais divertida: finalmente testar seu projeto "Hello, world!".

Testando o Projeto no Emulador

Lembram-se de que eu falei lá em cima que iríamos testar o aplicativo no Solarium? Volte para o Solarium, onde você criou o Virtual Spot, clique com o botão direito sobre ele,  em "deploy MIDlet bundle" e então selecione o jar que você criou.

Para testar, clique com o botão direito sobre o SPOT, "Run MIDlet" -> "StartApplication". Pronto, você terá seu super-bacanérrimo… SPOT que pisca o LED!

Se você clicar novamente com o botão direito e então em "Display Sensor Output" -> Internal frame, você irá ver também os valores dos sensores (que você também pode alterar através dessa interface), como abaixo:

Sun SPOT - emulador rodando exemplo

E aqui nós terminamos a primeira parte do tutorial. Espero que na próxima parte nós já estejamos fazendo coisas mais interessantes do que piscar LEDs, não? ;)

De qualquer maneira, se você se interessou, não fique me esperando: existem muitos tutoriais que vem com o próprio Sun SPOT Manager, no site oficial…

-----------------------------------------------------------------------------------------------------------------------------

Caso você queira continuar acompanhando o tutorial, a segunda parte, falando sobre acelerômetros, pode ser lida aqui.

-----------------------------------------------------------------------------------------------------------------------------

Comments:

Post a Comment:
  • HTML Syntax: NOT allowed
About

Blog com tutoriais relacionados a desenvolvimento de software, especialmente Java, e que conta com as experiências de desenvolvimento de uma menina maluquinha, digo, eu.

Search

Archives
« Abril 2014
SegTerQuaQuiSexSábDom
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    
       
Today