Elétron Livre

Bússola Digital com sensor de temperatura e umidade utilizando o Program-Me da Globalcode.

2010-03-09T17:05:00.000-08:00

Neste post descrevo como é simples conectar sensores tipo bússola, temperatura e umidade ao Program-Me utilizando a interface I2C, e construir uma interessante bússola digital com display LCD gráfico.

O chip ATMEGA utilizado em todos os Arduinos possui uma interface muito interessante chamada I2C . Essa interface permite a conexão de diversos sensores, memórias EEPROM e inclusive outros Arduinos utilizando apenas dois fios além do terra (GND). Essa interface funciona como um barramento onde cada dispositivo tem um endereço e o dispositivo mestre, neste caso o ATMEGA, controla o acesso aos demais dispositivos denominados escravos.

Para aprender mais sobre esta interface recomendo os links abaixo:

http://www.arduino.cc/playground/Learning/I2C

http://www.nxp.com/acrobat_download2/literature/9398/39340011.pdf (especificação da interface)

Neste projeto utilizei dois sensores, um magnético que utiliza o chip HMC6352 da Honeywell e um sensor de temperatura e umidade que utiliza o chip SHT-15 da Sensirion, sendo que ambos são compatíveis com a interface I2C, apesar de que o SHT-15 não é endereçável por esta interface, porém pode conviver com os outros dispositivos no barramento I2C desde que isso seja gerenciado pelo software.

Para exibir as informações dos sensores foi utilizado um display LCD gráfico de 128x64 pixels em conjunto com a biblioteca KS0108.

O interessante da biblioteca KS0108, é que podemos transferir imagens para o display com apenas uma linha de comando.
Para isso a imagem .BMP deve ser convertida por um sketch de Processing chamado glcdBitmap, em um arquivo hexadecimal que será utilizado pela biblioteca para identificar quais são os pixels do display que devem ou não ser ativados.
Ai é só incluir o arquivo gerado no seu programa e utilizar quando necessário.

Existe um programa chamado FASTLCD que ajuda muito na construção das telas gráficas.
Na figura abaixo temos o layout da tela deste projeto sendo construída no FASTLCD.

Após construir a tela no FASTLCD devemos salvar o arquivo .BMP no diretório “..\hardware\libraries\ks0108\Processing\glcdBitmap\data” que fica dentro do diretório da IDE do Arduino.

Com o arquivo BMP salvo no diretório acima, abrimos na IDE de Processing o arquivo “..\hardware\libraries\ks0108\Processing\glcdBitmap\glcdBitmap.pde”

Então é só editar a linha abaixo colocando o nome do seu arquivo .BMP no lugar de “ArduinoIcon.bmp”

String sourceImage = "ArduinoIcon.bmp"; // mude esta linha para o nome do seu BMP

Ao executar este Processing, será gerado um arquivo nomedoseuBMP.h no diretório “..\hardware\libraries\ks0108\Processing\glcdBitmap” correspondente a imagem.

Então basta no inicio do seu programa incluir a figura com o comando do exemplo abaixo:

#include "Layout_bussola.h"

E depois para exibir a figura no display basta dar o seguinte comando:

GLCD.DrawBitmap(Layout_bussola, 0,0, BLACK); //desenha layout básico do display para bussola.

IMPORTANTE: Caso apresente falha na compilação do seu programa, será necessário copiar o arquivo .h do diretório “..\hardware\libraries\ks0108\Processing\glcdBitmap” para o diretório “..\hardware\libraries\ks0108”

O método GLCD.DrawBitmap permite especificar a partir de qual pixel será carregada a imagem, então para alterar as direções da bússola, criei 8 bitmaps diferentes (figuras abaixo) com resolução 64x64, ou seja, somente a metade direita do display e carrego elas a partir do pixel 64,0 conforme o valor recebido do sensor magnético HMC6352.

Com isso o trecho do programa que atualiza a indicação da bussola no display fica bem simples.

Na foto abaixo temos todo o conjunto montado em um protoboard e mais abaixo temos dois vídeos demonstrando o funcionamento do circuito.

Obs: As bússolas por padrão apontam sempre para o norte, porém neste projeto configurei de forma que seja indicado pela seta o rumo que estamos seguindo sendo que o NORTE fica fixo a frente. Para operar no modo padrão, bastaria criar as imagens com o norte acompanhando a ponta da seta e rotacionar no sentido oposto ao que esta sendo feito. É possível também conectar uma chave em uma das portas do Program-Me e com isso seria possível selecionar o modo de operação da bússola.

O próximo desafio é adaptar a biblioteca KS0108 para trabalhar com display serial, assim não ocuparemos tantas portas só para o display.

Ache outros vídeos como este em Globalcode Program-ME

Ache outros vídeos como este em Globalcode Program-ME

Mini Robô circular utilizando PROGRAM-ME

2010-02-22T19:15:00.000-08:00

Depois de ver alguns projetos de robôs do Vinicíus e de alguns colegas deste blog, resolvi montar um também para praticar os conceitos de robótica. Como não tenho um espaço ideal para produzir as partes mecânicas do robô, optei por utilizar um chassi já pronto.

Após algumas pesquisas pela internet, resolvi utilizar um chassi circular da Pololu (http://www.pololu.com/catalog/product/250), pois após imprimir o manual desse chassi, percebi que o Program-Me encaixaria perfeitamente nele, inclusive a furação parece até que foi feita para o Program-Me.
O diâmetro do chassi é aproximadamente o mesmo de um DVD deixando o robô bem compacto.

Nesse chassi montei também um kit de engrenagens e motores da TAMIYA (http://www.pololu.com/catalog/product/61) e como terceira roda utilizei um ball caster (http://www.pololu.com/catalog/product/66) também da TAMIYA.

Esse conjunto ficou muito bom e praticamente contempla toda a parte mecânica do robô.

Como os motores que vêm no kit TAMIYA funcionam com no máximo 6 volts e eu queria utilizar alimentação de 12 volts, substituí os dois motores por motores MABUCHI desses utilizados em carrinhos de autorama e o resultado foi muito bom.
Com apenas 30% de duty cycle no PWM já consigo uma velocidade muito boa no robô.

Para sensores de obstáculos utilizei dois sensores infravermelho da SHARP modelo GP2Y0A21YK (http://www.sparkfun.com/commerce/product_info.php?products_id=242) posicionados na parte frontal do robô e com inclinação de aproximadamente 30 graus para cada um dos lados. Dessa forma é possível detectar obstáculos, tanto na parte frontal como nas laterais da direção em que o robô se movimenta, não sendo necessário um servo para movimentar os sensores.
Esses sensores detectam obstáculos entre 10 e 80 cm sendo que conectei eles nos conectores JP6 e JP7 do PROGRAM-ME que estão associados às portas analógicas.

Após ver o post do Vinícius sobre a fita de leds RGB, tive a idéia de colocar uma ao redor do robô, como o chassi é circular imaginei que o acabamento ficaria muito bom e daria um visual interessante (vejam detalhe da fita na foto acima).

Para comandar a fita de leds permitindo várias combinações de cores, utilizei 3 dos 4 transistores existentes no PROGRAM-ME. Como apenas o transistor Q2 é normalmente associado à porta PWM, fiz um remapeamento dos jumpers do PROGRAM-ME de forma que mais 2 transistores ficassem associados às portas PWM (vejam detalhes na figura abaixo e na próxima foto).

Obs: os retângulos coloridos indicam os pontos que foram interconectados em JP8 e JP11.

Notem que além do remapeamento de TR1(transistor Q1) e TR3 (transistor Q3), foi também remapeado o primeiro led vermelho o qual utilizo para indicar um dos modos de operação do robô. Os leds AM3 e VD3 indicam os outros dois modos.

Abaixo temos uma foto que mostra como foi feito o remapeamento das portas utilizando os conjuntos de jumpers JP8 e JP11 do PROGRAM-ME.

A foto a seguir mostra o detalhe da conexão da fita RGB aos transistores do PROGRAM-ME.

Para interface entre o Program-Me e os motores , utilizei um Shield da SparkFun (http://www.sparkfun.com/commerce/product_info.php?products_id=9213) que contém duas pontes H que permitem um controle total de velocidade e direção, independente para cada um dos motores.
Esse shield utiliza as portas digitais 10 a 13 do Program-Me.

Como mencionei acima, o robô possui 3 modos de operação:

1- Autônomo : onde ele se desloca livremente detectando obstáculos e desviando automaticamente.
2- Joystick : onde controlamos seus movimentos através de um joystick .
3- Acelerômetro: os movimentos são controlados ao movimentar o controle remotos nos eixos X e Y.

Abaixo temos a foto do controle remoto que nada mais é que um arduino simples, equipado com um shield onde montei o rádio transmissor, um acelerômetro e um joystick.
Obs: O modo de operação é comutado ao pressionar a alavanca do Joystick

A interface entre o robô e o controle remoto é feita utilizando um rádio ASK de 433MHz que permite taxas de 2400bps a 19200bps (estou utilizando 9600bps).
Para enviar comandos entre o controle remoto acima e o robô, criei um protocolo simples onde cada comando é formado por 5 bytes ( um byte de flag de inicio, 3 bytes que formam o comando e um byte de finalização).

exemplo: {lfy}

onde “{“ é o flag de início, “l” indica que é um comando para o motor esquerdo, “f” indica que ele deverá gira para frente e “y” indica o dutycicle que deverá ser aplicado ao PWM associado a esse motor, sendo que varia de 0 a 100 (caracter ASCII correspondente).

Também implementei o comando para mudança do modo de operação e seu formato é :

 {mdx}

onde “md” significa solicitação de mudança de modo de operação e “x” indica um dos 3 modos (autônomo [1], joystick [2] e acelerômetro [3] .

Bem, é isso pessoal, abaixo temos um vídeo do robô em ação (modo autônomo) e algumas fotos mostrando algumas cores obtidas com fita RGB.
Ela muda de cor conforme são detectados os obstáculos ou quando o robô modifica a sua trajetória.

Ache outros vídeos como este em Globalcode Program-ME

[]s

José Luiz Sanchez Lorenzo

Yahoo! Open Hack Day 2010 no Brasil

2010-02-10T12:43:00.000-08:00

Oba!! Acontece no final de semana dos dias 20 e 21 de março a segunda edição do evento Yahoo! Open Hack Day no Brasil, realizado no excelente espaço de eventos do SENAC (o mesmo espaço do JustJava).

Tivemos uma experiência muito legal no evento do ano passado e acredito que este ano vai ser melhor ainda. Foi um evento bem diferente, um evento de codificação, onde as pessoas ou equipes criaram seus "hacks" durante o final de semana.
No domingo à tarde muita pressa para terminar os projetos para as apresentações. Muitos projetos, muito divertido e muito interessante. Votação e premiação seguidos de bate-papo sobre os projetos.

É um evento para quem gosta de codificar, ou de fazer coisas divertidas, diferentes.

A organização do evento foi impecável no ano passado, comida, espaço, limpeza, foi muito bom.

Veja a cobertura completa, fotos, nosso prêmio, equipe e muito mais!

Nosso time em 2008:

Instrutores : Eder Magalhães, Rafael Nunes, Vinicius Senger e eu;
Alunos: Gustavo Dantas Pereira, Pedro Germano, Eduardo Veríssimo, Alexandre Loiola e Katia Matto
Amigos e colaboradores: Ana Abrantes e Wagner Santos.
Obrigada pessoal, foi show! Que bom que vai ter mais um!

Nossos projetos concluídos em 2008:

SuperCrud com gerador para Flickr
Planning Poker para celular feito com Blueprint
Biblioteca de componentes JSF para renderizar aplicações Blueprint
Plugin Blueprint para NetBeans
      Muito trabalho para um final de semana né?
      Eu aindo lembro a sensação de terminar os projetos.
      Comemorar a conclusão.

Mas, chega de nostalgia, vamos ao que interessa, o planejamento para este ano!
Estamos "montando" uma equipe para colaborar durante o evento, trocar ideias, montar uma mesona... E todo o tipo de ajuda é bem vinda, design, ideias, eletrônica...
Já temos várias pessoas "confirmadas" pensando em coisas bacanas, e super animados. Tudo "discutido" pelo twitter:

Globalcoders, dev dream team.

Wagner Santos,
Eder Magalhães,
Rafael Nunes,
Jefferson Prestes,
João Horárcio,
Vinicius Senger,
Ana Abrantes,
Thiago Vespa,
Neto Marin,
Marcio Hiroyuki e
eu.

Como participar do time Globalcoders ?

Faça a sua inscrição no evento. O time não é formalizado durante a inscrição, portanto, se você quer participar do nosso time, inscreva-se, e comente aqui no Post.
Participe da comunidade no ning http://globalcoders.ning.com; que visa facilitar a discussão sobre os projetos, ideias e tecnologias envolvidas.

É isso ai, Yahoo! Open Hack Day, aqui vamos nós!

Participe, comente, divulgue!

[]s
Yara
http://twitter.com/yarasenger
http://blog.globalcode.com.br/search/label/Yara

Novo minicurso Introdução a Robótica com Arduino | Program-ME

2010-02-08T08:48:00.000-08:00

Esta semana temos mais novidade para a galera interessada em Eletrônica e Robótica :
"Novo minicurso Introdução a Robótica com Arduino | Program-ME", onde o Vinicius Senger vai apresentar diversos conceitos fundamentais para quem está iniciando no mundo da Robótica, e também vai mostrar alguns robôs e projetos desenvolvidos.

Se você já participa da comunidade do Program-ME ou já criou algum robô não deixe de trazer o seu "filhote" para passear e conversar com outros robôs.

Se tudo der certo ele vai repetir o Show de Dança do "Gavetão" com a música "Bug Novo" apresentada na abertura do The Developer's Conference 2009 em São Paulo, Florianópolis e Rio de Janeiro.

Particpe, colabore, divulgue!

[]s
Yara
http://twitter.com/yarasenger
http://blog.globalcode.com.br

Curso Eletrônica e Arduino para Instrutores

2010-02-04T08:53:00.000-08:00

Foi realizado recentemente na Globalcode um curso de homologação de instrutores (Unidade São Paulo e Alphaville) para a Academia do Programador, que utiliza o Program-ME / Arduino como instrumento didático, levando conceitos de computação física para os alunos.

Muitos instrutores já tinham experiência, e foi interessante relembrar os conceitos de eletrônica, que em geral, nós cientistas da computação não tínhamos tanto interesse na faculdade. Interessante ver a teoria na prática 10 anos depois, onde estamos bem mais Open4Education do que na época da universidade.

Rodamos alguns programinhas que tocam músicas no Program-ME, como "Brilha brilha estrelhinha", uma barulheira ótima.

Edson, Eder, Marcelo, Alexandre, Renato Bellia, Vinicius, Rodrigo, Felipe, Melissa e Rafael e eu que tirei a foto!

Obrigada a todos os insturtores que além de dedicar suas "noites" e sábados as aulas na Globalcode participaram desta turma no domingo!

[]s
Yara
http://twitter.com/yarasenger

Porque a Globalcode está entrando de cabeça no mundo da Robótica?

2010-01-27T13:51:00.000-08:00

Porque a Globalcode está entrando de cabeça no mundo da Robótica?

Recebi esta pergunta pelo Twitter, e também de algumas pessoas próximas. Achei difícil e volátil responder pelo Twitter, por isto estou postando aqui no Eletron Livre, o blog sobre Eletrônica, Automação e Robótica da Globalcode.

Não há apenas uma resposta, ou um motivo, são diversos fatores que nos levam a investir pessoalmente e corporativamente nas áreas de Eletrônica, Automação e Robótica.

Os mais atentos devem ter notado que estamos investindo em áreas distintas:

divulgação (eventos, blog, videos)
treinamento (direta e indiretamente)
criação e produção da placa de desenvolvimento Program-ME, que é o Arduino da Globalcode.

Considerações, razões e a nossa visão sobre Eletrônica, Automação e Robótica:

Entrar no mundo da Robótica não quer dizer abandonar ou reduzir os investimentos em Java, pelo contrário a Globalcode tem investido e vai continuar a investir cada vez mais em Java e outras tecnologias. Eu, particularmente, estou bastante otimista, como publiquei no post Muitas vagas, otimismo e sensação de reaquecimento da economia no blog colaborativo Globalcoders.
Sempre trabalhamos com paixão, e a Eletrônica e Robótica foram conquistando o Vinicius pouco a pouco e consequntemente contaminando e atraindo outras pessoas. Logo, foi natural seguirmos o ciclo Open4Education: Aprender, Praticar, Compartilhar.
Automação residencial e Robótica não são mais apenas o tema futurístico dos "Jetsons", é realidade e com certeza é um mercado promissor.
Analisando as comunidades de desenvolvimento internacionais na internet, e na MakerFair na Califórnia, percebemos uma forte tendência e motivação em relação ao Arduino, depois confirmada pela reportagem do Valor Economico / Wall Street Journal
Encontramos excelentes "gurus", o que tem facilitado muito a nossa jornada até agora. Acho que está claro para a grande maioria da comunidade que o Vinicius Senger tem liderado este projeto na Globalcode com coragem, ousadia e MUITA motivação, mas, ele não está sozinho, conta com um excelente time: Paulo Santos, Benedicto Franco Junior, Alberto Lemos (dr. Spock), José Luis Sanches e agora, toda a comunidade do Program-ME.
Robótica é um assunto popular entre os alunos de "algumas" engenharias, mas a cultura não é tão forte na comunidade de desenvolvedores e cursos de computação. Através do SunSpot e outras iniciativas do James Gosling a comunidade Java ficou um pouco mais antenada em Robótica e automação.
A motivação do Vinicius foi crescendo no contato com a comunidade Academica, nas intermináveis conversas sobre Física Quantica, Computação Quantica, Cristalografia, Física Básica, Raio-X com os físicos ao nosso redor: meu pai, avós, minha mãe e outros físicos amigos.
O universo de possibilidades de projetos ao redor do Arduino são infinitas: para aqueles que gostam de desafio e inovação é um prato cheio;

Como já comentei em outros posts nós somos investidores e nossa moeda é o nosso tempo. Investimos nossas horas: finais de semana ou noites em aprender novas tecnologias e APIs, escrever artigos, participar de fóruns e grupos de usuários.

Mas, como recomendam os analistas financeiros, em geral não devemos investir todas as fichas no mesmo produto (API ou tecnologia) e por isto temos que aprender as coisas novas sem esquecer (de acompanhar) as antigas. O Vinicius, o Spock e outras pessoas da comunidade tem investido parte do seu tempo nisto, como hobby e como especialização, e você, já sabe no que vai investir este ano ?

[]s
Yara
http://blog.globalcode.com.br
http://blog.globalcode.com.br/search/label/Yara
http://www.eletronlivre.com.br/search/label/Yara
http://twitter.com/yarasenger

Robótica na Campus Party

2010-01-26T04:56:00.000-08:00

Começou ontem a Campus Party, e os amigos Bruno Souza e Mauricio Leal estão participando ativamente da organização do evento, especialmente da área de Software Livre, que terá diversas palestras sobre Java, Robótica Livre e muito mais.

Vinicius Senger estará participando do evento com duas palestras:

Misturando Robotica e Desenvolvimento de Software, e tudo livre!
Terça-feira, 26 de janeiro das 20:00 as 21:00

Workshop Java
Quarta-feira, 27 de janeiro das 9:00 as 10:00

Além da participação nas palestras do evento ele também está planejando a montagem de um robô que deve nascer no meio da multidão de mais de 6000 pessoas que participam da Campus Party 2010. Para isto preparou uma chassi muito especial, e planeja recheá-lo durante o evento com trabalho colaborativo dos campuseiros e amigos do SouJava. O Robô vai utilizar a placa de desenvolvimento Program-ME, o Arduino da Globalcode. O Vinicius também vai "apresentar" alguns projetos de Robôs que usam SunSpot.

Eu estarei colaborando com a cobertura coletiva através do twitter do SouJava e da Globalcode, agregando as notícias mais interessantes para vocês, através dos diversos membros do SouJava que estão participando do Campus Party 2010 e atenta aos Twitteiros de plantão.

Acompanhe as palestras ao vivo na TV Campus Party : http://tv.campus-party.org/

[]s
Yara
http://twitter.com/yarasenger

Seleção de links interessantes "twitados" recentemente

2010-01-17T13:56:00.000-08:00

Alguns anos atrás a informação era muito mais escassa, e por isto muito mais valiosa. Hoje vivemos a era do excesso da informação, onde é difícil separar o joio do trigo, com isto aparecem os "agregadores" de blogs, que "selecionam" as melhores notícias de outros portais, facilitando a vida do leitor.

É interessante como através dos limitados 140 caracteres do Twitter aliado a uma boa seleção de pessoas para seguir recebo informações interessantes, conseguindo um resultado similar aos agregadores, só que "descentralizado". Quero dizer, não preciso seguir todas as pessoas e iniciativas, ao invés disto, as pessoas que eu sigo "re-tweetam" o consideram como as notícias mais importantes que elas receberam.

Mas, nem tudo é perfeito, a busca de tweets antigos não é muito legal, no Tweetdeck estão disponíveis apenas os tweets mais recentes de cada pessoa, e na aplicação Web tem que navegar por muitas páginas para localizar.

Desta forma resolvi separar algumas implementações curiosas relacionadas a tecnologia, eletrônica e robótica:

Agradeço as pessoas que me enviaram e produziram as informações interessantes!

PS: Se você está interessado em "Twittar" com Java veja o post da Ana Abrantes no blog colaborativo Globalcoders Postar no Twitter com programa escrito em Java.

Yara Senger
http://twitter.com/yarasenger

Lista para seguir todos os instrutores da Globalcode de uma vez:
http://twitter.com/globalcode/globalcode-team

Workshop interno de Soldagem de Arduino (Program-ME)

2010-01-12T12:29:00.000-08:00

Foi realizado na última sexta-feira um Worskhop de Soldagem do Program-ME, o Arduino da Globalcode.

Uma turma surprendente e divertida, com pessoas de diversas funções na Globalcode: Auxiliares administrativos, designers, vendas, infra-estrutura e até a gestora do departamente operacional, responsável pelo processo de produção do Program-ME.

Workshop foi uma experiência muito inovadora para mim pois nunca tive contato com esta tecnologia.
Paulo Santos (responsável pela Matrícula Delivery)

De workshop program-me 2010

Foto (esquerda para direita) André, Thayrine, Paulo, Rafaela, Mathias, Vinicius e Renato

Durante o Workshop foram produzidos 2 program-MEs completos, e claro, tinha que virar uma pequena corrida...
Não, era apenas uma brincadeira durante estas horas de puro aprendizado e descontrção.

De workshop program-me 2010

Parabéns aos que acertaram de primeira, e também aos que erraram forçando o Vinicius a ensinar como corrigir!

Parabéns também ao Vincius Senger pela não retenção de conhecimento e pela iniciativa de treinar a equipe interna da Globalcode.

Fita de Leds RGB 12v com Program-ME

2010-01-07T15:01:00.000-08:00

Estive hoje na Sta. Efigenia e acabei encontrando uma divertida fita com leds RGB SMD auto-colante que pode ser controlada pelo Program-ME.

Estou colocando o vídeo abaixo de como funciona a fita. Em breve vou disponibilizar o código-fonte, mas o principio é bastante simples, ligar 12v na fita, e cada cor em um transistor. Depois é só pirar no código... Com PWM fica mais legal ainda.

Curso de Eletrônica e Curso de Arduino da Globalcode

2009-12-18T05:10:00.000-08:00

Após finalizarmos a primeira turma do curso de eletrônica e Arduino da Globalcode, pudemos coletar muitos frutos como uma rica apostila desenvolvida por José Luiz Sanchez e também muitos feedbacks do alunos.

Como pudemos notar um enorme interesse em sala de aula por detalhes e aprofundamentos de fundamentos da eletrônica, resolvemos fazer uma expansão no tempo do curso, dividindo o treinamento em dois cursos distintos que podem ser adquiridos juntos, com preço especial, ou separado para por exemplo pessoas que já conhecem eletrônica e querem aprender Arduino.

Resumindo temos agora dois treinamentos de 8 horas:

- Eletrônica básica
- Arduino

Agora poderemos dedicar mais tempos para laboratórios práticos em ambos os treinamentos e temos certeza da efetividade de ambos.

Novidades eletrizantes para 2010!

Genius-ME é programado em DOJO na Globalcode

2009-12-15T06:22:00.000-08:00

Como programado, aconteceu na semana passada (10/12) o DOJO com Programe-ME e Arduino no auditório da Globalcode em São Paulo. A dinâmica realizada não poderia ter sido melhor! Todos os presentes puderam colocar a mão na massa (exceto as meninas, que apenas ficaram como ouvintes) e durante uma hora em meia em rodadas de 7 minutos cada um contribuiu com um pedaço do código para uma simulação/protótipo do brinquedo Genius (seguindo a onda, chamado aqui de Genius-ME).

Durante o evento tivemos acesso a um Genius original da Estrela e a sua versão mais nova chamada de Simon Trickster. Assim, os participantes puderam ter uma idéia muito mais clara do problema que deveria ser programado através do Program-ME e Genius-ME.

O vídeo a seguir mostra o Genius original em ação:

Veja também o Simon Trickster em ação aqui!

Ao final de uma hora e meia a platéia conseguiu desenvolver o programa a seguir:

int leds[] = {11,9,3,5};
int botoes[] = {12,10,4,6};
int bip = 13;

char state = 'S'; // S = Start, P = Play, B = Read button, ...

int sequencia[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int currentRound = 0;
int currentPosition = 0;
int tamanho = 8;
boolean fimJogo = true;

void setup() {
for (int i = 0; i < 4; i++) {
pinMode(leds[i], OUTPUT);
pinMode(botoes[i], INPUT);
} 
pinMode(bip, OUTPUT);
Serial.begin(9600);
}

void acendeluzesdarodada () {
for(int i = 0; i<= currentRound;i++) {
digitalWrite(leds[sequencia[i]],HIGH);
delay(1000);
digitalWrite(leds[sequencia[i]],LOW);
delay(500);
}
}

int leBotao() {
int timeout = 0;
Serial.println("teste");
int botao = -1;
while(botao == -1 && timeout <=30) {
for(int i = 0; i < 4; i++) {
if(digitalRead(botoes[i]) == HIGH) {
Serial.println(botoes[i]);
botao = i;
break;
}
delay(100);
timeout++;
}
}

digitalWrite(leds[botao], HIGH);
while (digitalRead(botoes[botao]) == HIGH);
digitalWrite(leds[botao], LOW);

return botao;
}

void beep() {
digitalWrite(bip, HIGH);
delay(1000);
digitalWrite(bip, LOW); 
}

void inicio() {
randomSeed(analogRead(0));
for(int i = 0; i < tamanho; i++) {
sequencia[i] = (int) random(0,4);
Serial.print("Posicao.: " + sequencia[i]);
}
}

void loop() {
if(state=='S') {
inicio();
fimJogo = false;
currentRound = 0;
state='P';
}

if (state=='P') {
acendeluzesdarodada();
state='B';
}

if(state=='B') {
for(int i = 0; i <= currentRound; i++) {
int botao = leBotao();
Serial.println(botao);
if (sequencia[i] != botao || botao==-1) {
state='S';
fimJogo=true;
beep();
break;  
}
}

if(!fimJogo) {
currentRound++;
state='P';
}

}

delay(3000);
}

Esta versão do programa funcionou e os desenvolvedores puderam experimentar a sensação de missão cumprida. Foi muito bom ver a empolgação durante o desenvolvimento do código, o medo de participar, a equipe externa dando pitacos no código, o piloto usando um computador miúdo e as observações finais da própria platéia sobre a dinâmica do DOJO. Agoram vejam o Genius-ME em ação com este código instalado no microcontrolador do Program-ME: Imaginem a situação de um desenvolvedor que não tem muita experiência ou nenhum conhecimento de programação em C e deve pegar um código deixado por outro desenvolvedor e continuar a manutenção ou evolução. Este desenvolvedor tem que entregar um código compilável, responder as perguntas do co-piloto (em pair programming), escrever o código, filtrar os pitacos externos, atender a pressão do prazo de uma rodada de 7 minutos e, além de tudo, ser observado por uma platéia de outros desenvolvedores, já que o código estava visível para todos via projetor ligado ao computador. Definitivamente, o DOJO com o Program-ME na Globalcode foi um sucesso e muito bom! Vale a pena conferir as próximas edições. By Spock http://blog.spock.com.br/
P.S.: Caso tenha participado deste DOJO e tenha fotos, please, publica na rede e manda o link para nós aqui via comentários.

DOJO com Program-ME e Arduino no LinguÁgil 2009

2009-12-09T08:37:00.000-08:00

Durante a participação no LinguÁgil 2009 em Salvador/BA este ano pela Globalcode, tivemos o imenso prazer de contribuir numa palestra prá lá de diferente. Para falar a verdade não é bem uma palestra mas um DOJO. O Dojo é uma reunião de desenvolvedores que foge ao estilo tradicional de palestras em que um palestrante apresenta um conteúdo para N pessoas. No Dojo todos podem participar (palestrar!).

Um Dojo funciona mais ou menos assim: Um moderador apresenta um problema de software/computação a ser desenvolvido pelos participantes (todos). Num computador ligado ao projetor, dois participantes da platéia assumem o desenvolvimento da solução para o problema apresentado. Um dos participantes assume o papel de piloto e tem o controle do teclado e mouse da máquina para realizar a codificação. O outro participante acompanha ao lado fazendo perguntas, discutindo soluções ou corrigindo o código realizado pelo piloto. Após uma rodada de alguns minutos (normalmente 5 a 7 minutos), o moderador interrompe o desenvolvimento para que o atual piloto saia da frente do compudador e o parcipante ao lado assuma o computador como o novo piloto. Daí, uma outra passoa da platéia assume o posto de co-piloto e começa uma nova rodada. Enquanto várias rodadas se desenrolam ao longo de uma hora ou uma hora e meia, a platéia pode ver o código em desenvolvimento e até fazer algumas observações e correções.

No Dojo realizado no LinguÁgil 2009 e moderado pelo Alexandre Gomes (@alegomes) foi apresentado como problema o desenvolvimento do algoritmo para simular através do Program-ME e Arduino o antigo brinquedo da Estrela chamado de Genius (ou Simon Trikster, como é conhecido atualmente). A simulação deveria gerar as seqüências de cores usando LEDs para um jogador interagir fisicamente com a aplicação através de botões coloridos para repetir a seqüencia aleatória apresentada. O algoritmo deveria então captar essas ações e identificar se a seqüência realizada pelo jogador está correta ou não. Para tornar o desenvolvimento mais emocionante, foram usadas a linguagens Ruby para controlar o Program-ME e C para controlar um Arduino. Eu, Dr. Spock (@drspockbr), comandei a mesa com o Arduino implementando com C e o Felipe Rodrigues (@felipero) comandou a mesa com o Program-ME implementando com Ruby. Após um hora e meia, os participantes conseguiram construir os seguintes códigos:

Versão para o Arduino implementado em "C"

int leds[] = {2,3,4,5};
int botoes[] = {8,9,10,11};
int bip = 13;

char state = 'S'; // S = Start, P = Play, B = Read button, ...

int sequencia[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int currentRound = 0;
int currentPosition = 0;

void setup() {
for(int i = 0; i < 3; i++) {
pinMode(leds[i], OUTPUT);
pinMode(botoes[i], INPUT);
} 
pinMode(bip, OUTPUT);
}

void loop() {
if (state == 'S') { // start
sort();
state = 'P';
}
if (state = 'P') { // play LEDS
playLeds();
state = 'B';
}
// implementar leitura de botoes e comparacao
if (state == 'B') {
botao = botaoPressionado();
for (int i = 0; i < 20; i++) {
if (sequencia[botao] != sequencia[i]) {
// errou! 
}
}

}
delay(5000);
if (++currentRound > 20) {
currentRound == 0;
state = 'S';
}
}

void apita() {
digitalWrite(bip, HIGH);
delay(1000);
digitalWrite(bip, LOW);
}

void sort() {
for(int j = 0; j < currentRound; j++) {
sequencia[j] = (int) random(0,4);
}
}

void playLeds() {
for(int j = 0; j < currentRound; j++) {
digitalWrite(leds[sequencia[j]], HIGH);
delay(1000);
digitalWrite(leds[sequencia[j]], LOW);
delay(1000);
}
}

int botaoPressionado() {
for(int j=0; i<4; i++) {
int estado = digitalRead(botoes[j]);
if (estado == HIGH) {
return j;
}
}
return -1;
}

Versão para o Program-ME implementado em "Ruby"

require 'arduino'

@cores = Array.new
@cores << green_led
@cores << blue_led
@cores << yellow_led
@cores << red_led

def gera_sequencia(quantidade)
@sequencia = []
quantidade.times do
@sequencia << @cores[rand * @cores.size]
end
@sequencia
end

def imprime_sequencia(sequencia)
sequencia.each do |cor|
turn_led_on(cor)
turn_led_off(cor)
end
end

qtd = 4
sequencia_inicial = gera_sequencia(qtd)
open_writing()
imprime_sequencia(sequencia_inicial)
done()
start_reading()
btn = []
qtd.times do
while b == nil do
b << read_button()
end

btn << b
puts "Botao '#{b}' pressionado"
end
done()

if btn == sequencia_inicial
puts "CERTO!"
end

#turn_led_on(green_led)
#turn_led_off(green_led)
#turn_led_on(blue_led)
#turn_led_off(blue_led)
#urn_led_on(yellow_led)
#turn_led_off(yellow_led)
#turn_led_on(red_led)
#turn_led_off(red_led)
done()

close_arduino()

O código fonte completo destas duas versões pode ser baixado do arquivo: dojo-linguagil.zip Estes programas não foram finalizados e não funcionaram completamente. Apesar de um dos objetivos era de chegar a uma solução que funcionasse, não era o principal objetivo. Após várias rodadas, todos os participantes puderam aprender um pouco sobre Program-ME, Arduino, Ruby, C, computação física, além de exercitar algumas práticas de desenvolvimento ágil como, por exemplo, Pair Programming. Um Dojo é uma forma divertida e irreverente de treinar programação onde todos podem participar com uma parte do código para resolver um problema proposto. Muito legal ver as pessoas tentando resolver o problema "ao vivo". Agora a Globalcode preparou a sua edição deste Dojo para o próximo dia 10 de dezembro em São Paulo. Mais detalhes e inscrição em: Dojo de programação com o Program-ME, o Arduino da Globalcode. By Spock http://blog.spock.com.br/

Arduino no Valor Econômico e Wall Street Journal

2009-12-04T03:06:00.000-08:00

Excelente artigo publicado no Wall Street Journal, e traduzido pelo Valor Econômico, retrata a plataforma Arduino de forma precisa, começando pelo título do artigo: "Taking an Open-Source Approach to Hardware".

A notícia no Wall Street Journal reforça a importância do Arduino e leva estas informações para os tomadores de decisão e para o mercado financeiro, consequentemente para os "ouvidos" dos investidores.

Ficamos sabendo da notícia através de um e-mail da minha irmã, Maria Carlota Senger, que trabalha com gestão de riscos em um banco de investimentos "Agora eu entendi o que você esta falando e fazendo com o Program-ME | Arduino".

Espera-se que sejam vendidos neste ano 60.000 peças de Arduino apenas da fábrica italiana. Somados aos 100 da Globalcode, são 60.100, risos.

Achei simplesmente fantástico por motivos claros, mas a finalização do artigo com a visão da personalidade criadora do Lilypad (uma versão de Arduíno para tecidos, roupas... usada por artistas) é uma das melhores definições sobre clonegem:

"I don't really care if someone can copy this thing, because a month from now I'm going to be making something different"

Esta visão é explicitamente de um "maker". Quantas pessoas empacam suas vidas com suas boas idéias sem nunca nem começar a desenvolve-las? Discutem se será open-source ou não sem fazer uma linha de código. Empreendedorismo onírico ou idéia platônica?

Viagens a parte, sei que o mundo real com Arduino esta ai, estampado no Wall Street Journal, e estamos felizes por ter bons mentores, que nos permitiram entrar no momento certo neste swell tecnológico.

-Vinicius

Mais um robô com Program-ME

2009-12-01T06:19:00.000-08:00

O forum do Program-ME está pegando fogo. São muitas dicas sobre compras, reuso e outras discussões. Alguns participantes extremamente ativos como Lex Blagus que além das dicas tem compartilhado excelentes fotos e o José Luiz, que além dos posts no Eletron Livre tem colaborado com informações técnicas extremamente consistentes, como a discussão sobre Dissipação de potência.

No meio de tudo isto, achei um robô criado com program-ME desenvolvido pelo Danilo Altheman

Parabéns Danilo e todos os que colaboraram!

Novo lote de Program-ME

2009-12-01T05:59:00.000-08:00

Pessoal,

Estamos recebendo na segunda-feira um novo lote de 20 Program-ME e respeitando a época natalina vamos manter a promoção: de R$ 199,00 por R$ 149,00. E ainda vem com o ATMega 328, o mais robusto da familia de Arduino antes do Mega.

Reserve sua unidade pelo email: contato@globalcode.com.br. As 30 primeiras unidades se esgotaram em 2 semanas portanto não perca tempo!

Vale lembrar que o Program-ME é um Arduino com diversos componentes on-board como leds, speaker, LDR, transistores de alta potência e entradas para 2 servo-motores.

A comunidade Program-ME não para de crescer, dúvidas, sugestões, comentários: http://program-me.ning.com.

Abraços,
Vinicius Senger

Vídeo-aulas de Program-ME

2009-11-26T11:47:00.000-08:00

Estamos disponibilizando oficialmente no site da Globalcode as primeiras vídeo-aulas sobre Program-ME. Este formato é muito simples de produzir e esperamos feed-backs para melhorar ele e profissionalizar ainda mais. Assim que tivermos mais feed-backs vamos produzir as próximas.

A primeira vídeo-aula está dividida em quatro partes e vai da introdução ao Arduino / Program-ME até o desenvolvimento do primeiro programa.

Os links são:

Parte 1: Introdução ao Arduino / Program-ME
Parte 2: Program-ME vs. Arduino (precisa fazer login no site)
Parte 3: Configurando Program-ME (precisa fazer login no site)
Parte 4: Desenvolvendo um primeiro aplicativo (precisa fazer login no site)

-Vinicius Senger

Controlando dispositivos via Web com o Program-Me

2009-11-23T17:11:00.000-08:00

Controlar dispositivos elétricos com o PROGRAM-ME é muito fácil, o principal cuidado que devemos tomar é com a capacidade máxima de corrente do chip ATMEGA que é de 40 mA (5V) .

Portanto para controlar dispositivos elétricos que necessitem de correntes superiores a 40mA , tensões superiores aos 12v disponíveis no Program-Me ou que trabalhem com corrente alternada (CA), será necessário associar alguns componentes entre os terminais dos PROGRAM-ME e o dispositivo a ser controlado.

Notem que um dos diferenciais do Program-Me, é já possuir on-board 4 transistores IRF510 que permitem controlar dispositivos externos sem qualquer hardware adicional, porém neste exemplo não iremos utilizar eles pois necessitamos de 5 interfaces.

Normalmente utilizamos um transitor na saída do Program-Me para dar um ganho na capacidade de corrente. Quando o dispositivo a ser controlado opera com corrente alternada (CA), ou necessita de uma corrente superior a suportada por transistores comuns, adicionamos além do transitor um relé.

Obs: Nos terminais da bobina do relé é necessário adicionar um diodo para proteger a junção do transistor, pois a bobina do relé gera uma tensão reversa ao ser desenergizada e que poderia danificar o transistor (vejam no diagrama elétrico da interface de relés os diodos D1 a D5) .

Com o circuito apresentado neste post, poderemos controlar até 5 dispositivos elétricos utilizando o PROGRAM-ME, sendo que o diferencial deste projeto é que vamos adicionar ao Program-Me um shield Wi-Fi (WiShield) que permitirá comandar os dispositivos remotamente de qualquer conexão internet.

O shield Wi-Fi utilizado é o da foto abaixo que é produzido pela AsyncLabs e custa por volta de US$ 50 nos Estados Unidos. Pode-se também utilizar um shield ethernet que pode ser encontrado aqui no Brasil por R$75 ,neste caso abrindo-se mão da conexão sem fios.

Seguem abaixo as características do Shield:

Wi-Fi Module Features:
• 802.11b Wi-Fi certified
- 1Mbps and 2Mbps throughput speeds
• Supports both infrastructure (BSS) and ad hoc (IBSS) wireless networks
• Ability to create secured and unsecured networks
- WEP (64-bit and 128-bit)
- WPA/WPA2 (TKIP and AES) PSK
• Low power usage
- Sleep mode: 250µA
- Transmit: 230mA
- Receive: 85mA

Pin Usage:
• SPI
- Slave select (SS): Arduino pin 10 (port B, pin 2)
- Clock (SCK): Arduino pin 13 (port B, pin 5)
- Master in, slave out (MISO): Arduino pin 12 (port B, pin 4)
- Master out, slave in (MOSI): Arduino pin 11 (port B, pin 3)
• Interrupt (Uses only one of the following, depending on jumper setting)
- INT0: Arduino pin 2 (port D, pin 2)
- DIG8: Arduino pin 8 (port B, pin 0)
• LED: Arduino pin 9 (port B, pin 1)
- To regain use of this pin, remove the LED jumper cap
• 5V power
• GND

Basicamente o projeto consiste em rodar um servidor Web no Program-Me, disponibilizando uma página simples onde podemos selecionar quais dos 5 dispositivos desejamos ligar ou desligar. O shield Wi-Fi permite a interface de rede entre o roteador wireless da rede local e o Program-Me.

O primeiro passo é acoplar o shield Wi-Fi ao Program-Me (figura abaixo) e depois carregar o sketch do servidorWeb, onde configuramos uma página Web simples que permitirá o controle de algumas saídas do Program-Me.

Neste caso utilizei como base o WiServer sketch apresentado no próprio site do fabricante do shield (http://asynclabs.com/wiki/index.php?title=AsyncLabsWiki), apenas adaptando a quantidade de dispositivos controlados para 5 dispositivos e modificando a formatação da página Web de forma a ficar compatível com o projeto que eu necessitava.

Montei então a placa para as interfaces dos 5 relés (figura abaixo), onde utilizei uma placa padrão que é facilmente encontrada nas lojas de componentes eletrônicos.

Na figura abaixo temos o diagrama elétrico da placa de interface de reles:

Conectei então essa interface em 5 portas de saída do Program-Me conforme figura abaixo:

Configurações:

No sketch é necessário atribuir um IP e uma máscara de rede para o Shield, sendo possível também utilizar segurança WEP (64-bit and 128-bit), WPA/WPA2 (TKIP and AES) PSK .

Abaixo temos o trecho do sketch onde são executadas as configurações de rede.


// Parametros de configuracao da rede wireless ----------------------------------------

unsigned char local_ip[] = { 192,168,10,200};   // Endereco IP do WiShield

unsigned char gateway_ip[] = { 192,168,10,1};   // Endereco do gateway ou roteador

unsigned char subnet_mask[] = { 255,255,255,0};   // mascara de rede local

const prog_char ssid[] PROGMEM = { "PROGRAM_ME"};      // SSID da rede (max 32 bytes)

unsigned char security_type = 0;   // 0 - open; 1 - WEP; 2 - WPA; 3 - WPA2



// WPA/WPA2 passphrase

const prog_char security_passphrase[] PROGMEM = { "12345678"};   // max 64 caracteres



// WEP 128-bit keys

// sample HEX keys

prog_uchar wep_keys[] PROGMEM = {

0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,   // Key 0

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // Key 1

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // Key 2

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00   // Key 3

};



// configuracao do wireless mode

// WIRELESS_MODE_INFRA - conexao com um AP

// WIRELESS_MODE_ADHOC - conexao direta com outro dispositivo WiFi (por exemplo com o PC)

unsigned char wireless_mode = WIRELESS_MODE_ADHOC;

unsigned char ssid_len;

unsigned char security_passphrase_len;





* O sketch completo deste projeto está disponível no final deste post.

Testando o dispositivo

Por volta de 15 segundos após ligar o conjunto, o shield Wi-Fi sintoniza a rede local e a página já fica disponível para acesso no endereço configurado para o shield. (neste caso 192.168.10.200)
Ao entrar no Browser com o endereço associado ao Shield é apresentada a seguinte tela:

Ao clicarmos com o mouse em cima do link de um dos relés, o Program-Me muda o estado da porta correspondente ao relé selecionado, ligando ou desligando o dispositivo que estiver conectado nos terminais desse relé.

A tela abaixo mostra o estado após selecionarmos o rele 1 na tela anterior.

Os comando podem ser executados facilmente de qualquer browser, inclusive de telefones celulares com Wi-Fi ou que tenham serviço de dados habilitado.

Vale lembrar que além do Servidor Web, podemos ter um cliente Web rodando em paralelo desde que o ATMEGA equipado seja um 328.
Esse tipo de configuração em paralelo permitirá por exemplo que a sua aplicação colete informações de um site de terceiros na internet e essas informações sejam utilizadas nas páginas hospedadas no PROGRAM-ME.
Outra implementação interessante que pode ser executada seria conectar sensores (temperatura, humidade, fumaça etc) e monitorar essas informações via Web com o Program-Me.

Bem pessoal é isso, espero que gostem do post e que ele sirva de inspiração para muitas idéias legais de aplicação.

José Luiz Sanchez Lorenzo

/*
* WebServer para controle via WEB de 5 dispositivos eletricos usando o Program-Me
*/
//carrega as bibliotecas necessarias para o funcionamento do WiServer
#include WiServer.h
#include string.h

#define WIRELESS_MODE_INFRA 1
#define WIRELESS_MODE_ADHOC 2

// configura as saidas do Program-Me que serao utilizadas para controlar os reles
#define ledPin1 14
#define ledPin2 15
#define ledPin3 16
#define ledPin4 17
#define ledPin5 18

// Parametros de configuracao da rede wireless ----------------------------------------
unsigned char local_ip[] = { 192,168,10,200}; // Endereco IP do WiShield
unsigned char gateway_ip[] = { 192,168,10,1}; // Endereco do gateway ou roteador
unsigned char subnet_mask[] = { 255,255,255,0}; // mascara de rede local
const prog_char ssid[] PROGMEM = { "PROGRAM_ME"}; // SSID da rede (max 32 bytes)
unsigned char security_type = 0; // 0 - open; 1 - WEP; 2 - WPA; 3 - WPA2

// WPA/WPA2 passphrase
const prog_char security_passphrase[] PROGMEM = { "12345678"}; // max 64 caracteres

// WEP 128-bit keys
// sample HEX keys
prog_uchar wep_keys[] PROGMEM = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, // Key 0
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Key 1
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Key 2
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Key 3
};

// configuracao do wireless mode
// WIRELESS_MODE_INFRA - conexao com um AP
// WIRELESS_MODE_ADHOC - conexao direta com outro dispositivo WiFi (por exemplo com o PC)
unsigned char wireless_mode = WIRELESS_MODE_ADHOC;
unsigned char ssid_len;
unsigned char security_passphrase_len;

boolean states[5]; //array que armazena os estados dos reles
char stateCounter; //variavel temporaria para indexar os reles
char tmpStrCat[64]; //variavel utilizada no processamento da pagina Web
char stateBuff[4]; //variavel utilizada no processamento de texto durante conversao de boleana para string (boolToString())
char numAsCharBuff[2];
char ledChange; //indica alteracao no estado dos reles

void boolToString (boolean test, char returnBuffer[4])
{
returnBuffer[0] = '\0';
if (test)
{
strcat(returnBuffer, "ON"); //retorna "ON" se o rele estiver ligado
}
else
{
strcat(returnBuffer, "OFF"); //retorna "OFF" se o rele estiver desligado
}
}

void printStates() //envia para a porta serial/USB o estado dos reles quando ocorrer alguma solicitacao de alteracao
{
for (stateCounter = 0 ; stateCounter < 5; stateCounter++)
{
boolToString(states[stateCounter], stateBuff);

Serial.print("Estado do Rele ");
Serial.print(stateCounter+1);
Serial.print(": ");
Serial.println(stateBuff);
}
}

void writeStates() //atualiza o estado das saidas do Program-Me acionando os reles
{
digitalWrite(ledPin1, states[0]);
digitalWrite(ledPin2, states[1]);
digitalWrite(ledPin3, states[2]);
digitalWrite(ledPin4, states[3]);
digitalWrite(ledPin5, states[4]);

}

// Esta é a funcao que gera a pagina Web
boolean sendPage(char* URL) {

Serial.println("Iniciada Impressao da pagina");

printStates();
writeStates();

//verifica qual link da pagina foi clicado e define qual rele deve-se alterar o estado
if (URL[1] == '?' && URL[2] == 'R' && URL[3] == 'E' && URL[4] == 'L')
{
ledChange = (int)(URL[5] - 49); //determina qual foi o link clicado na pagina.

for (stateCounter = 0 ; stateCounter < 5; stateCounter++)
{
if (ledChange == stateCounter)
{
states[stateCounter] = !states[stateCounter]; // inverte o estado do rele selecionado
Serial.print("Alterado estado do rele "); //informa na serial/USB que houve alteracao de estado
Serial.println(ledChange+1);
}
}

//retorna o usuario para a pagina principal
WiServer.print("");
return true;
}

if (strcmp(URL, "/") == false)
{
WiServer.print("Program-Me Server");
WiServer.print("Sistema de controle de dispositivos via WEB utilizando o PROGRAM-ME\n");
WiServer.print("
\n");
WiServer.print("Selecione o Rele que deseja alterar o status :\n");
WiServer.print("
\n");
for (stateCounter = 0; stateCounter < 5; stateCounter++) //for each led
{
numAsCharBuff[0] = (char)(stateCounter + 49); //soma 49 para obter o caracter ASCII comecando por 1
numAsCharBuff[1] = '\0'; //strcat espera uma string de caracteres e nao apenas um
//Essa string e um caracter + um string terminator.

tmpStrCat[0] = '\0'; //inicializa a string
strcat(tmpStrCat, " tmpStrCat[12] = (char)(stateCounter + 49); //adiciona o numero do Rele
tmpStrCat[13] = '\0'; //finaliza a string apropriadamente

strcat(tmpStrCat, ">Rele ");
strcat(tmpStrCat, numAsCharBuff);
strcat(tmpStrCat, ": ");

boolToString(states[stateCounter], stateBuff);
strcat(tmpStrCat, stateBuff);
strcat(tmpStrCat, " "); //nos temos agora algo similar a Rele 1: Off

WiServer.print(tmpStrCat);
WiServer.print("
\n");
}

WiServer.print(" ");
return true;
}
}

void setup() {
// Inicializa o WiServer e prepara ele para fornecer acesso a pagina
// Configura as portas do Program-Me selecionadas para os reles como saida
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);
pinMode(ledPin5, OUTPUT);

Serial.begin(9600); //configura a porta serial/USB para 9600bps
WiServer.init(sendPage);

//Inicializa o array que armazena o estado dos reles colocando os reles em OFF
states[0] = false;
states[1] = false;
states[2] = false;
states[3] = false;
states[4] = false;
}

void loop(){
// Run WiServer
WiServer.server_task();

delay(10);
}

Globalcode no mundo de Eletrônica & Robótica

2009-11-19T09:04:00.001-08:00

A Globalcode está a todo o vapor na área de Eletrônica e Robótica, estamos formando um time sensacional e finalizando diversos projetos nos quais investimos muita energia ao longo deste ano:

A produção do primeiro lote comercial do Program-ME, o Arduino da Globalcode, depois da realização do programa de testes;

Inicio da primeira turma da Academia do Programador, que utiliza o Program-ME como instrumento didático;
Lançamento da comunidade no Ning com diversos profissionais como fazendo coisas interessantes;
Lançamento do blog de eltrônica e robótica: Eletron Livre
Participação na Robotec Fair em Curitiba com dois Workshops : SunSpot e Arduino

Definição de convênio universitário devido ao interesse de Universidades usarem o Program-Me durante o curso para ensino de programação e eletrônica;
Apresentação de diversos robos e palestras nos eventos Java, veja a foto do show de Robos no The Developer's Conference 2009;

É neste clima que a Globalcode lançou ontem dois novos cursos na linha de Eletrônica e Robótica:

1) Eletrônica e computação física com Arduino - Módulo I - Básico

2) Robótica com Arduino

Comemoramos hoje a primeira matricula do curso "Robótica com Arduino", oferecendo uma bolsa para o curso "Eletrônica e computação física com Arduino" para o Aluno #1, que tem 25 anos de experiência programando diversas linguagens e fazendo suporte a infra estrutura.
Gerente de projetos e TI na R2 a 15 anos, trabalhando para diversos clientes internacionalmente. Guilherme Carneiro Poyares dos Reis, da R2 Tecnologia em informação, um grande amigo da Globalcode e do Vinicius Senger há mais de 10 anos.

Parabéns a todos os envolvidos pelas primeiras realizações!

Yara M. H. Senger

Academia do Programador - Turma 1

2009-11-18T10:16:00.000-08:00

Começamos nesta segunda-feira, 16 de novembro, a primeira turma da Academia do Programador. Depois de uma longa jornada trabalhando em materiais, códigos e o desenvolvimento da placa Program-ME temos o orgulho de contar com um treinamento como este que pode convencer mais e mais as pessoas a programarem e se profissionalizarem na área.

Lógica binária, hexadecimal, linguagens compiladas, linguagens interpretadas, de baixo nível, de alto nível e assim por diante...

Hoje tem mais: vamos começar a estudar ferramentas de desenvolvimento, desenvolver um Olá Mundo com Java e iniciar com o Program-ME.

Estamos muito satisfeitos e esperamos melhorar mais e mais este treinamento com o feed-back desta turma!

Conectando o Program-ME a um display LCD gráfico

2009-10-31T12:32:00.000-07:00

Pessoal,
Outro circuito legal que testei com o Program-Me, foi conectar ele a um display LCD gráfico de 128x64 pixels.
Utilizei a biblioteca (KS0108), que encontrei nos links do site oficial do Arduino.
Ela permite, utilizando processing, converter arquivos .bmp para arquivos que podem ser utilizados para exibir as imagens diretamente no display com uma única linha de comando.

Ex:
GLCD.DrawBitmap(logo_globalcode_128x64, 0,0, BLACK);

A linha acima exibe o logo da Globalcode a partir da coordenada 0,0 do display.
O display utilizado foi o ITM-12864 que custa 34 Reais na Sta Efigenia.

Vejam o resultado da exibição de algumas imagens nos videos abaixo.

http://www.youtube.com/watch?v=5a4Ju9MJVuk

http://www.youtube.com/watch?v=EO_mNM7WnS4

abraço a todos

José Luiz Sanchez Lorenzo

Conectando o Program-Me a uma matriz de Leds 8x8 e exibindo mensagens

2009-10-31T11:51:00.000-07:00

Vinicius,

Primeiramente gostaria de agradecer pela oportunidade de participar dos testes do Program-ME.
Infelizmente não tenho tido o tempo que gostaria para montar coisas com o Program-Me, mas nos últimos dias fiz um esforço durante as madrugadas e consegui fazer algumas coisinhas que gostaria de compartilhar com vocês.
A primeira coisa que fiz, foi conectar o Program-Me em uma matriz de Leds 8x8 e programar para mostrar mensagens de texto.
Ficou interessante quando mudei metade da matriz para a cor verde, pois as mensagens vão mudando de cor a partir do centro da matriz.
É possivel configurar qualquer tipo de caracter na resolução 8x8.
O circuito fica bem simples pois não é necessário nenhum circuito adicional além do Program-Me e da matriz.
Vocês poderão ver um vídeo do circuito em funcionamento no link abaixo.
http://www.youtube.com/watch?v=_c1oIj8YBrk

abraço a todos
José Luiz Sanchez Lorenzo

Program-ME's beta - Lista de participantes

2009-09-29T11:34:00.000-07:00

Agradecemos a comunidade que se interessou em participar deste programa de avaliação do Program-ME. Como produzimos um quantidade ainda pequena de Program-ME's a lista de participantes é pequena, ainda não podemos nem mesmo envolver todos instrutores da Globalcode.. Estamos produzindo um segundo lote e até o final de outubro.

Equipe Globalcode:

Julio Viegas;
Benedicto Franco Junior;
Dr. Spock (Campinas);
Jose Luis;
Elaine;
Felipe (Fratech);
Thiago Vespa (SJRP)
Rafael Nunes
Eder
Kleber Xavier
Neto Marin (Manaus)

Voluntários da Comunidade:

Fernando Luis
Aleksander Blagus
Leonardo Simberg
Luis Daniel Soares
Silveira Neto
Victor Hugo Jabur
Jiri Trnka

Estamos criando uma lista de discussão para suportar este processo! Nesta lista vamos anunciar como obter o Program-ME e também como reportar feed-backs.

Bem-vindo a todos e obrigado pela participação.

-Vinicius Senger

Resumo do resumo da raíz da eletrônica

2009-09-28T08:42:00.000-07:00

Segue aqui um resumo de alguns informações de baixo nível da eletrônica, isso pode até ser transformado em um mind mapping interessante, vou fazer um dia..

Cobre = 1 elétron na camada de valência
Silicio = 4 elétrons na camada de valência, material usado para construção de diodo, transistor, circuitos integrados,
Germanio também tem 4 elétrons na camada de valência, mas é muito sensível a temperatura portanto não mais usado em eletronica
Sólido de Silício = cristal de silício
Banda de condução = camada onde elétrons livre se movimentam
Semicondutor Tipo N = é um cristal de silício que recebeu atomos pentavalentes, ou seja, com 5 elétrons na camada de valência
5 na camada de valência: arsênio, antimônio, fósforo
Com semicondutor tipo n temos mais elétrons livres, pois cada átomo pentavalente dopado no silício vai disponibilizar 1 elétron livre a mais pois dos seus 5 da camada de valência apenas 4 serão usados para unir o átomo pentavalente, ex. fósforo,
Com semicondutor tipo p temos mais lacunas pois é injetado átomos trivalentes (alumínio, boro, gálio)
Força que vem do suprimento de energia, ex. bateria pilha, e faz que os elétrons se movimentem é chamada de força eletromotriz ou tensão e é medida em volts. Volt = Alexandre Volta, o criador da bateria com metal e ácido
A grandeza de uma corrente é medida em ampéres.
Resistencia é medida em ohms. Carbono é usado para resistor
Amperimetros mede corrente
Voltimetro mede tensão
Ohmimetros mede a resistencia
Biestável = pode representar um dos estados
Monoestável = um só estado
Astável = sem estado estável

1o mini-curso sobre Program-ME / Arduino

2009-09-26T06:59:00.001-07:00

Aconteceu na última quinta-feira o primeiro mini-curso sobre o Program-ME, o Arduino da Globalcode. Com um público variando de garotos de 13 anos a vice-presidente de multinacional, pudemos mostrar todo o potencial de desenvolvimento de hardwares, devices e robôs utilizando plataformas abertas, tanto no software quanto no hardware.

Pudemos conhecer novos membros da comunidade Globalcode onde alguns já tem muita experiência em eletrônica e ficaram extremamente motivados com o que viram. O material do mini-curso será disponibilizado no nosso site dentro do catálogo de mini-cursos e convidamos novamente todos para participarem dos seguintes projetos:

Movimento Elétron Livre: comunidade e blog que visa publicar e democratizar informações sobre eletrônica e robótica livre;
JavArduino.org: projeto para a criação de um compilador Java para Arduino.

Em breve estaremos lançandos novos treinamentos na área de eletrônica e robótica além de um evento voltado para isso.

Agradecemos a presença de todos e quem qusier encomendar um Program-Me pode entrar em contato com a Globalcode para colocar seu pedido na fila. Estamos fabricando as primeiras unidades, agora não-beta.

Fui, eletrificado.
-Vinicius