quarta-feira, 9 de dezembro de 2009

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

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/

Um comentário:

  1. aMIGO PODE ME AJUDAR, PRECISO MONTAR O ARDUINO COMO ESTE PARA MINHA FACULDADE, TERIA COMO ME AJUDAR?

    ResponderExcluir