sexta-feira, 18 de dezembro de 2009

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!

terça-feira, 15 de dezembro de 2009

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).

Clique para ampliarDurante 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.

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/

sexta-feira, 4 de dezembro de 2009

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

terça-feira, 1 de dezembro de 2009

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

quinta-feira, 26 de novembro de 2009

Vídeo-aulas de Program-ME

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

segunda-feira, 23 de novembro de 2009

Controlando dispositivos via Web com o Program-Me

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);
}

quinta-feira, 19 de novembro de 2009

Globalcode no mundo de Eletrônica & Robótica

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

quarta-feira, 18 de novembro de 2009

Academia do Programador - Turma 1

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!

sábado, 31 de outubro de 2009

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

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

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

terça-feira, 29 de setembro de 2009

Program-ME's beta - Lista de participantes

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

segunda-feira, 28 de setembro de 2009

Resumo do resumo da raíz da eletrônica

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

sábado, 26 de setembro de 2009

1o mini-curso sobre Program-ME / Arduino

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:

  1. Movimento Elétron Livre: comunidade e blog que visa publicar e democratizar informações sobre eletrônica e robótica livre;
  2. 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

segunda-feira, 21 de setembro de 2009

A primeira ponte H agente nunca esquece....

Ponte H é um circuito integrado de grande valor para um robô pois podemos controlar motores invertendo corrente para poder andar para frente e traz. Eu comprei uma chamada L293E que é uma ponte H dupla, ou seja, podemos controlar com ela dois motores e também conseguimos usar o PWM do Arduino para controlar a potência dos motores.

Este circuito tem 20 pinos sendo que vou mostrar o que fizemos com 1 a 11 pois é o suficiente para um motor, depois para dois motores é só usar exatamente a mesma configuração mas só que da 12 a 20:

Pino 1 - Enable = ligamos na porta PWM 9 do Arduino
Pino 2 - Input A = ligamos na porta digital 4
Pino 3 - Output A= um diodo veio do terra para ele, do diodo para o positivo (ou negativo) do motor, do motor para outro diodo que foi ligado na corrente
Pino 4 - Sense - Aterramos ele pois não vamos precisar (pode-se usar o L293D que é mais em conta e não tem este recurso usado para driver chopper)
Pino 5 - GND
Pino 6 - GND
Pino 7 - Sense - Aterramos ele
Pino 8 - Output B = um diodo do terra veio para ele, do diodo para negativo (ou positivo) do motor, do motor para outro diodo que foi ligado na corrente.
Pino 9 - Input B = ligamos na porta digital 5
Pino 10 - Alimentação do motor (o L293E aceita até 36V)
Pino 11 - Alimentação do circuito integrado (também aceita até 36V e pede o mínimo de 5)

Nada muito avançado, mas nada muito básico.. De qualquer forma é um ótimo exercicio para você gastar seus diodos e nunca mais esquecer da direção da corrente deles.

Fiz tudo na protoboard conforme a foto a seguir:





Agora que tenho esse par de motores com redução de 100 RPMs e a ponte H funcionando vou trabalhar na mecânica pois o prazo para "máquina surpresa" do JustJava esta esgotando!!

Entre minhas aventuras com a ponte H, resolvi ontem final do dia soldar em uma placa com bornes e tudo bonitinho para ficar algo mais robusto e evitar mal contato, mas na medida que fui colocando os diodos e soldando tudo, percebi que iria faltar espaço... Ai vai vendo, fiz de um lado inteirinho para um motor e funcionou OK, falei com o Bene e mostrei por video para ele e na empolgação do elogio dele "não ficou ruim não!", fui fazer o outro lado. Exatamente a 1:00 da manhã fui ligar os dois motores e para não dizer que não deu nenhum sinal de fumaça, tudo que a engenhoca fazia era dar sinal de fumaça. Dormi decepcionado. Acordei e antes de escovar os dentes fui testar tudo no multimetro... Nada feito, tenho suspeitas de que alguma trilha cruzou... Plaquinha ruim + soldador cansado = fumaça.

Para minha agradável supresa, desoldei a ponte e liguei de volta na proto, bingo! O ponte porreta, isso é que é passar em prova de fogo!!!

É isso ai, se alguem tiver interesse o datasheet dela esta na net e fazer PWM é fácil depois da decodificação do nosso amigo e vulgo "engenheiro de verdade", Paulo Carlos.

E vamos nessa, para a marcenaria fazer a parte menos digital de todas: cortar madeiras e formas para encaixar o motor.

Fui. (motorizado, sem sinal de fumaça).