Curso de Eletrônica e Curso de Arduino da Globalcode

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

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

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

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

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

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