terça-feira, 28 de dezembro de 2010

Retrospectiva 2010

A iniciativa ElétronLivre da Globalcode nasceu, assim como todas as outras, da paixão pela tecnologia. Não foi uma iniciativa dirigida pelo retorno financeiro, mas sim pela empolgação do Vinicius Senger, Benedicto Franco Junior, Paulo Santos e José Luiz Lorenzo.

E os resultados foram surpreendentes, a produção foi riquissíma. Diversos robôs e projetos de automação residencial, participação em vários eventos, novos cursos, novos instrutores.

Diversas escolas de ensino fundamental já tem robótica no currículo utilizando a plataforma Lego, assim como as Universidades, principalmente nos cursos de engenharia. Mas existe um movimento internacional gigante de Hardware Open-Source principalmente para robótica amadora, hobistas, adolescentes e apaixonados. A missão da iniciativa ElétronLivre é a difusão destas tendências internacionais no mercado Brasileiro, e sem falsa modéstia acredito que alcançamos nossos objetivos em 2010, e aumentamos exponencialmente os objetivos para o ano que vem!


A iniciativa ElétronLivre termina 2010 muito mais madura e muito mais forte e sem dúvida merece uma retrospectiva a parte!

Retrospectiva ElétronLivre


Os 5 posts mais acessados do ElétronLivre Blog

É isso ai! 2011 tem muito mais!

Parabéns a todos os envolvidos e apaixonados por eltrônica, robótica e Arduino!

Yara Senger
http://twitter.com/yarasenger

    quinta-feira, 4 de novembro de 2010

    Dimmer futurístico & automação residencial open source

    Nossos projetos de eletrônica e open source hardware baseados em Arduino / Atmega não param!

    Antes de contar detalhes, vejam o resultado do projeto do dimmer futurístico neste pequeno vídeo do Youtube:



    Com o grande apoio do Paulo Carlos dos Santos, da empresa BR-o-BOT, desenvolvemos um dimmer digital que pode ser facilmente acoplado no Arduino ou qualquer outra placa controladora. O resultado é que você consegue controlar a intensidade de brilho de uma lâmpada incandescente.  Dependendo dos circutos que você colocar neste esquema, você pode controlar um ventilador, chuveiro, ou fazer um ferro de solda com controle de potência!

    Os desafios propostos neste desenvolvimento foram bem interessantes e pessoalmente foram verdadeiras aulas práticas de eletrônica e microcontroladores. 

    A primeira tentativa que fizemos utilizamos um isolador ótico simples e tentamos usar a PWM para controlar a potência, mas o resultado com a lâmpada não deu certo: ela ficava piscando. Então Paulo pesquisou e me passou uma solução mais trabalhosa mas que funcionaria.

    Neste novo esquema elétrico usamos dois isoladores óticos: 4N35 um MOC3021. O primeiro é utilizado para detectar a passagem da corrente alternada por zero e interromper o ATMega cada vez que isso acontecere, no caso do Brasil com 60hz, 120 vezes por segunda a corrente passa por 0. Neste momento é onde temporizamos  a abertura do TRIAC e simulamos o controle de potência. Veja o esquema elétrico:




    Segue o código-fonte para Arduino. Você pode mudar a intensidade alterando o valor da variável dim entre 1 e 120, sendo que 1 é o mais forte e 120 praticamente desligada. Este programa permite alteração desta variável por I2C ou por Serial:

    /*
    
    #include 
    int AC_pin = 3;
    volatile long dim = 60;
    
    void setup(){
    pinMode(AC_pin, OUTPUT);
    Serial.begin(9600);
    attachInterrupt(0, light, CHANGE);
    Wire.begin(66);
    Wire.onReceive(receiveEvent);
    }
    
    void receiveEvent(int howMany){
    char comando[16];
    int counter=0;
    while(1 < Wire.available())  {
    char c = Wire.receive();
    comando[counter++]=c;
    Serial.print(c);
    }  
    
    int x = Wire.receive();
    Serial.println(x);
    Serial.println("Evento");
    Serial.println(howMany);
    //value, fromLow, fromHigh, toLow, toHigh)  
    dim = map(comando[1], 48,57,10,120);
    } 
    
    
    void light(){
    if(dim<125) {
    long dimtime = (60*dim);  // eval the proper pause to fire the triac
    delayMicroseconds(dimtime);  // delay the dim time
    digitalWrite(AC_pin, HIGH);  // fire the Triac
    delayMicroseconds(1);  // pause briefly to ensure the triac turned on
    digitalWrite(AC_pin, LOW);   // turn off the Triac gate (triac will not turn off until next zero cross)
    }  else {
    digitalWrite(AC_pin, LOW);   // turn off the Triac gate (triac will not turn off until next zero cross)  
    }
    }
    
    void loop(){
    if (Serial.available() > 0) {
    byte inByte = Serial.read();
    dim = inByte;  }
    }
    
    
    


    E na etapa seguinte integramos este circuito com o ping da Parallax para ter o controle de intensidade "on the air". Bem, isso deixamos para um próximo post, por enquanto vai se divertindo com este circuito!

    Ah, em tempo, a lista de materiais para você comprar e montar:

    - 4 resistores de 47K (R1 a R4)
    - 1 resistor de 10k (R5) (se não tiver 1k e 10k não é eletrônica!)
    - 2 resistores 330 (R6 e R7)
    - TRIAC BTA16
    - 1 isolador 4N35
    - 1 isolador MOC3021

    Preço da lista: menos que R$ 10.

    Vinicius Senger
    http://twitter.com/vsenger
    http://twitter.com/eletronlivre
    http://loja.eletronlivre.com.br
    http://www.globalcode.com.br/instrutores/ViniciusSenger

    quinta-feira, 7 de outubro de 2010

    Controle de tomadas com a placa Tomad@

    Controle de tomadas é uma implementação fundamental para diversos projetos, principalmente aqueles relacionados a automação residencial. 

    Eu me lembro da primeira vez que o Paulo Carlos Santos e o Vinicius Senger controlando uma tomada com Arduino... é incrível. Vejam a empolgação de todos no vídeo do Casual Class de Robótica, onde apresentamos um hacking com Arduino controlando uma tomada.

    Para facilitar esta tarefa a br-o-bot e Elétron Livre criaram uma placa batizada como "Tomad@", que é vendida na Eletron Livre Loja e utilizada no Hacking Class - Controle de Tomadas via internet

    Vale a pena conferir a vídeo-documentação da placa Tomad@ publicada recentemente pelo Vinicius Senger.

     

    É isso ai pessoal, um vídeo vale por mais de 1000 palavras...
    []s
    Yara Senger

    quinta-feira, 30 de setembro de 2010

    Xacualiator Tabajara - resolvendo o seu problema

    Eu adoro desenvolvimento de sistemas e sites que melhoram a vida, ou os processos cotidianos das pessoas. Não somente os sistemas de grande abrangência como twitter, google, internet banking.  Adoro particularmente os que resolvem os nossos problemas "pessoais", como o GES - Global Education System que é o sistema utilizado pela Globalcode e também pelos parceiros nas Unidades Globalcode.

    O trabalho e a energia investidos neste projeto são muito gratificantes, porque ele melhora a vida dos usuários da nossa comunidade. É sempre muito bom ver o resultado, a otimização, a mudança no processo que a implantação, ou simplesmente a melhoria de um sistema pode causar.

    Na comunidade "geek-eletrônica-arduino" é mais interessante ainda observar as possibilidades de resolução ou melhoria dos nossos próprios processos. Tem vários exemplos do José Luiz, do Vinicius e de outros amigos que criaram uma soluções para o seu próprio problema. Isto é muito legal.

    Este projeto, batizado pelo Vinicius de Xacualiator Tabajara é um destes exemplos, de tecnologia utilizada para resolver o seu problema.

     

    Desde que fez a primeira placa caseira, através do processo de impressão da placa em Glossypaper, depois banho de Percloreto ele não parou mais. Acredito que já fez uma centena de placas, risos.

    Percebeu que mexendo o pote com a placa imersa no percloreto o processo era muito mais rápido, bastavam poucos minutos para a corrosão completa. Mas ficar mexendo o pote 10 minutos ? É simples, fácil, mas ninguém merece repetir isto 100 vezes. Exatamente pela simplicidade a automatização fica ainda mais atraente. Ele, não teve dúvidas, colocou o Arduino para mexer o pote e fez um vídeo da primeira versão.


    Adorei.

    Yara Senger
    http://twitter.com/yarasenger

    segunda-feira, 27 de setembro de 2010

    Arduino Hack Day no SINFORM em Ilhéus

    Aconteceu em Ilhéus entre 20 e 24 de Setembro o SINFORM 2010 (Semana da Informática da UESC). Fomos convidados a realizar o Arduino Hacking Day, por intermédio do Alexandre Gomes, que também participou do evento falando sobre Empreendedorismo. 

    Foram várias horas de atividades ministradas pelo Vinicius Senger:
    • Introdução a Arduíno
    • Controle de tomada com a placa tomada
    • Controle de motores e sensores 
    • Criação de placas caseiras.

    As fotos foram publicadas pelo Alexandre Gomes.


    Quando será o próximo ? 
    Em Brasília, dia 30 de Outubro na UNB, organizado pela Mecajun:


    Acompanhe mais notícias aqui no blog, nos perfis do twitter : @eletronlivre @vsenger @alegomes e no Boletim Globalcode.

    Yara Senger
    http://twitter.com/yarasenger


    segunda-feira, 16 de agosto de 2010

    Robô explorador 4x4 com PROGRAM-ME



    Depois de montar dois pequenos robôs com o PROGRAM-ME e executar diversas experiências com sensores, displays e motores, resolvi montar um robô agregando todos esses dispositivos de forma funcional permitindo assim um amplo aprendizado em robótica.

    A base deste robô é o PROGRAM-ME (Arduino turbinado da Globalcode) e um chassi 4x4 que comprei na forma de kit pronto para montar.


    Como os motores que vêm no kit operam entre 3 e 6 volts e eu pretendia alimentar o robô com células LIPO de 11.1 volts, substitui os 4 por motores de autorama modelo Mabuch Green de 12 volts x 24000 RPM.

    Na base do chassi além dos motores instalei uma placa que permite controlar os motores (2 a 2) utilizando apenas uma porta do Program_Me, um transmissor de vídeo de 2.4 GHz para transmitir as imagens captadas pela câmera e um relé para controlar a alimentação do transmissor e da câmera.



    Logo acima dos motores, na base inferior do chassi, instalei o Program-Me.
    Parece que o chassi foi feito para ele não acham ?



    Como a quantidade de dispositivos e sensores instalados neste robô é grande, o consumo da voltagem de 5 volts subiu bastante e portanto o regulador de voltagem 7805 tende a aquecer bastante. Para evitar o aquecimento excessivo desse regulador, tomei a decisão de remanejar ele para um pequeno dissipador na lateral do robô.



    Para que seja possível estabelecer comunicação wireless com o robô, acoplei ao Program-Me um módulo XBee utilizando um shield.



    O fato do Program-Me ter várias portas de conexão (SERVO 1, SERVO 2, POT 1, POT 2 e os bornes), facilitou bastante o trabalho de conexão dos sensores frontais, do display LCD e do Servo que controla a câmera, porém ainda faltavam pontos de conexão para os sensores traseiros, sensor PING, GPS, e portas I2C (sensores de temperatura/umidade, bússola e RTC).
    A solução foi utilizar a área de proto do shield XBee para implementar esses pontos de conexão. (foto abaixo)



    A próxima etapa seria dar ao robô a oportunidade de falar, para isso instalei um VOICE shield modificado com o chip TTS256-Text to Speech.
    Esse chip em conjunto com o Voice shield, permite ao robô pronunciar palavras em inglês bastando enviar a string de caracteres via serial.



    Na base superior instalei o servo que posiciona a câmera, o sensor de temperatura/umidade, a bússola, o GPS, os sensores de distância frontais e traseiros e o display LCD gráfico.

    A figura seguinte mostra a parte de baixo da base superior do robô, onde são fixados os sensores, o servo e os cabos de conexão de todos os sensores e dispositivos.



    Na foto abaixo temos a visão da base superior já com os sensores, GPS, RTC e o display gráfico instalados.
    A antena branca é a responsável pela transmissão do vídeo captado pela câmera do robô.



    A função do display gráfico é permitir a visualização das várias informações captadas pelos sensores do robô. A interface dele é serial a 115200 bps e utiliza apenas uma porta do PROGRAM-ME.


    As informações indicadas pelo display são as seguintes:

    superior esquerdo - Temperatura, umidade e ângulo de deslocamento.
    central - "bússola" que indica a direção de deslocamento do robô.
    superior direito - 3 barras verticais indicam as leituras dos sensores frontais (IR-esquerdo, PING e IR-direito)
    Os dois quadradinhos indicam obstáculos na parte traseira.
    A barrinha na horizontal indica o nível de luminosidade captado pelo sensor, sendo que o backlight do display é ligado automaticamente quando o nível de luminosidade é baixo.
    esquerdo inferior - latitude e longitude obtidas do GPS.
    direito inferior - Hora e Data que são obtidas do RTC.


    Na parte superior instalei também dois mini autofalantes desses utilizados em Notebooks que são responsáveis em reproduzir as falas do robô, e também uma micro câmera montada em um servo motor.






    Na traseira do robô instalei dois sensores IR que apenas detectam obstáculos. Eles não medem distância, mas o ponto de ativação pode ser ajustado entre 3 e 80 cm. Para alimentar o robô utilizei duas células de baterias LIPO de 1300mAh x 11,1 volts, que associadas em paralelo dão uma capacidade de 2600mAh x 11,1 volts



    Para a unidade de controle remoto, utilizei o Brasileirino (Arduíno básico da Globalcode), um shield XBee e um Nunchuck do WII da NINTENDO (este emprestado do vídeo game do Leo).



    O Nunchuck possui internamente um acelerômetro (que neste projeto controla os movimentos do robô), um mini joystick (controla a posição da câmera) e dois botões que controlam a alimentação do transmissor de vídeo/câmera e a buzina do robô (speaker do Program-Me).

    O melhor de tudo é que ele usa interface I2C o que facilita demais a comunicação com o Arduino usando apenas duas portas.

    A figura abaixo mostra a identificação dos sinais no conector do Nunchuck e a tabela mostra a formatação dos 6 bytes que devem ser lidos para obter as informações dos botões, do acelerômetro e do joystick.






    Segue abaixo o código que usei como referência para tratar os dados do Nunchuck:

    /*
    * wii_nunchuck_sevo -- Use a Wii Nunchuck to control a servo
    *
    * Tod E. Kurt, http://todbot.com/blog/
    *
    * The Wii Nunchuck reading code is taken from Windmeadow Labs
    * http://www.windmeadow.com/node/42
    */

    #include
    // comment out the below for Arduino 0011 and above, uncomment for older
    //#include
    //#include

    uint8_t outbuf[6]; // array to store arduino output
    int cnt = 0;
    int ledPin = 13;

    int servoPin = 7; // Control pin for servo motor
    int pulseWidth = 0; // Amount to pulse the servo
    long lastPulse = 0; // the time in millisecs of the last pulse
    int refreshTime = 20; // the time in millisecs needed in between pulses
    int minPulse = 700; // minimum pulse width

    #define pwbuffsize 4
    int pwbuff[pwbuffsize]; // buffer for smoothing pulseWidths
    int pwbuffpos = 0; // position in pwbuff

    void setup()
    {
    Serial.begin(19200);
    Wire.begin (); // join i2c bus with address 0x52
    nunchuck_init (); // send the initilization handshake
    pinMode(servoPin, OUTPUT); // Set servo pin as an output pin
    pulseWidth = minPulse; // Set the motor position to the minimum
    Serial.print ("Finished setup\n");
    }

    void nunchuck_init()
    {
    Wire.beginTransmission (0x52); // transmit to device 0x52
    Wire.send (0x40); // sends memory address
    Wire.send (0x00); // sends sent a zero.
    Wire.endTransmission (); // stop transmitting
    }

    void send_zero()
    {
    Wire.beginTransmission (0x52); // transmit to device 0x52
    Wire.send (0x00); // sends one byte
    Wire.endTransmission (); // stop transmitting
    }

    int t = 0; // when it gets to 25, read nunchuck
    void loop()
    {
    t++;
    if( t == 25 ) {
    t = 0;
    Wire.requestFrom (0x52, 6); // request data from nunchuck
    while (Wire.available ()) {
    // receive byte as an integer
    outbuf[cnt] = nunchuk_decode_byte (Wire.receive ());
    digitalWrite (ledPin, HIGH); // sets the LED on
    cnt++;
    }
    // If we recieved the 6 bytes, then go print them
    if (cnt >= 5) {
    printNunchuckData(); // uncomment this for debug
    // update servo pulseWidth
    float tilt = outbuf[4]; // z-axis, in this case ranges from ~75 - ~185
    tilt = (tilt - 70) * 1.5; // convert to degrees angle, approximately
    pulseWidth = (tilt * 9) + minPulse; // convert angle to microseconds
    pwbuff[pwbuffpos] = pulseWidth; // save for averaging
    if( ++pwbuffpos == pwbuffsize ) pwbuffpos = 0;

    pulseWidth=0; // reset so we can
    for( int p=0; p= refreshTime) {
    digitalWrite(servoPin, HIGH); // Turn the motor on
    delayMicroseconds(pulseWidth); // Length of the pulse sets the motor position
    digitalWrite(servoPin, LOW); // Turn the motor off
    lastPulse = millis(); // save the time of the last pulse
    }
    }

    // Print the input data we have recieved
    // accel data is 10 bits long
    // so we read 8 bits, then we have to add
    // on the last 2 bits. That is why I
    // multiply them by 2 * 2
    int i=0;
    void printNunchuckData()
    {
    int joy_x_axis = outbuf[0];
    int joy_y_axis = outbuf[1];
    int accel_x_axis = outbuf[2]; // * 2 * 2;
    int accel_y_axis = outbuf[3]; // * 2 * 2;
    int accel_z_axis = outbuf[4]; // * 2 * 2;

    int z_button = 0;
    int c_button = 0;

    // byte outbuf[5] contains bits for z and c buttons
    // it also contains the least significant bits for the accelerometer data
    // so we have to check each bit of byte outbuf[5]
    if ((outbuf[5] >> 0) & 1)
    z_button = 1;
    if ((outbuf[5] >> 1) & 1)
    c_button = 1;

    if ((outbuf[5] >> 2) & 1)
    accel_x_axis += 2;
    if ((outbuf[5] >> 3) & 1)
    accel_x_axis += 1;

    if ((outbuf[5] >> 4) & 1)
    accel_y_axis += 2;
    if ((outbuf[5] >> 5) & 1)
    accel_y_axis += 1;

    if ((outbuf[5] >> 6) & 1)
    accel_z_axis += 2;
    if ((outbuf[5] >> 7) & 1)
    accel_z_axis += 1;

    Serial.print ("seq");
    Serial.print ("\t");

    Serial.print ("joy_x");
    Serial.print ("\t");
    Serial.print ("joy_y");
    Serial.print ("\t");

    Serial.print ("X_axis");
    Serial.print ("\t");
    Serial.print ("Y_axis");
    Serial.print ("\t");
    Serial.print ("Z_axis");
    Serial.print ("\t");

    Serial.print ("Z_but");
    Serial.print (" ");
    Serial.println ("C_but");



    Serial.print (i,DEC);
    Serial.print ("\t");

    Serial.print (joy_x_axis, DEC);
    Serial.print ("\t");
    Serial.print (joy_y_axis, DEC);
    Serial.print ("\t");

    Serial.print (accel_x_axis, DEC);
    Serial.print ("\t");
    Serial.print (accel_y_axis, DEC);
    Serial.print ("\t");
    Serial.print (accel_z_axis, DEC);
    Serial.print ("\t");

    Serial.print (z_button, DEC);
    Serial.print ("\t");
    Serial.print (c_button, DEC);

    Serial.print ("\r\n");
    i++;
    delay (200);
    }

    // Encode data to format that most wiimote drivers except
    // only needed if you use one of the regular wiimote drivers
    char nunchuk_decode_byte (char x)
    {
    x = (x ^ 0x17) + 0x17;
    return x;
    }




    A distribuição de portas do PROGRAM-ME ficou da seguinte forma:




    Abaixo temos uma foto do conjunto finalizado, sendo que agora estou trabalhando nos últimos ajustes no código para corrigir pequenos bugs e melhorar o desempenho do robô. Assim que concluir disponibilizarei o código aqui para todos.



    Os participantes do TDC2010 poderão ver o robô ao vivo no evento no próximo Domingo.

    Segue abaixo uma pequena demo do robô.




    Como a voz robótica nem sempre é fácil de ser compreeendida, seguem abaixo as falas do robô pronunciadas no vídeo acima.

    "Robot activated"
    "Hello, this is an explorer robot from Globalcode"
    "I will be waiting for you on The Developers Conference 2010"
    "Temperature is about 21 Celsius Degrees"
    "Humidity is about 56 %"

    []s

    José Luiz
    http://twitter.com/jllorenzo

    segunda-feira, 26 de julho de 2010

    The Developer's Conference 2010

    A Globalcode está lançando a quarta edição do The Developer's Conference que neste ano ganhou uma forma fantástica que reflete o posicionamento da Globalcode diante as diversas áreas relacionadas a desenvolvimento de softwares.

    Vejamos os principais destaques desta edição:
    • 11 Conferências em 1: Arduino, Java, Web, Ruby, Agile, Testes, .NET, SOA & Cloud, Mobile, Spring e noSQL.
    • Mais de 60 palestras: palestras organizadas e coordenadas por um especialista da área.
    • 50 palestrantes: grandes nomes do mercado estarão presentes.
    • Apenas R$ 20 por trilha, ou seja, este valor para poder participar de 6 palestras é quase preço de café
    Temos o prazer de organizar a trilha de Arduino onde mostraremos de tudo um pouco:
    • Robótica com Arduino: diferentes robôs construídos por nós e membros da comunidade;
    • Automação residencial: de forma descomplicada vamos ensinar como controlar seus eletrônicos pelo computador e pela Internet;
    • Arte Tecnológica: música, obras e um mundo que mais une a razão com emoção e tecnologia;
    • Workshop: apresentaremos um workshop de como soldar e começar a criar seus próprios circuitos. Faremos ao vivo uma placa.
    Por apenas R$ 20,00 você poderá passar um domingo aprendendo e se divertindo com o mundo da computação física, Arduino, hacking, arte e open source hardware.


    quinta-feira, 22 de julho de 2010

    Agregando um REAL TIME CLOCK (RTC) ao Arduino.

















    Se você precisa registrar dados com infomações de data e hora em um projeto com Arduino, ou quer apenas ter essas informações disponíveis em um display por exemplo, este tutorial propõe uma solução com baixo custo e muito fácil de implementar.

    Utilizaremos como base o circuito integrado DS1307, que é um chip RTC completo e que por utilizar interface de comunicação I2C, permite uma fácil integração ao Arduino utilizando apenas duas portas (AN4 e AN5) que podem ser inclusive compartilhadas com outros dispositivos. O custo do circuito integrado DS1307 é de R$ 4,00.



    Na figura ao lado temos o diagrama de conexões entre um Microcontrolador e o DS1307.







    A figura abaixo mostra os blocos funcionais do RTC DS1307:




    As entradas X1 e X2 são os pontos onde conectamos um cristal oscilador de 32.768 kHz responsável pelo clock necessário para o funcionamento do chip.
    A partir desse clock é gerado um sinal com frequência de 1Hz responsável pelo incremento do relógio.

    No bloco Power Control temos as 3 conexões de alimentação, positivo (VCC), negativo (GND) e VBat que é o ponto onde deveremos conectar uma bateria de lítio de 3V tipo CR2032. Essa bateria será responsável por manter o relógio em funcionamento mesmo quando a alimentação do circuito for desligada.
    O consumo da bateria nesse modo é de menos de 500nA (nano Amper), o que dá uma autonomia muito grande a bateria. Para se ter uma idéia, uma bateria de Lítio de 48mAh dá uma autonomia de 10 anos.

    Os terminais SCL(serial clock input) e SDA(seria data input) são as conexões correspondentes a interface I2C, essa interface funciona como um barramento onde podemos conectar uma série de dispositivos , sendo que cada um terá um endereço e será gerenciado pelo Arduino.
    Mais detalhes sobre a interface I2C podem ser obtidos aqui :

    O terminal SQW/OUT é uma saída programável que pode ser utilizada para enviar 4 frequências distintas (1Hz, 4 Khz, 8 Khz e 32 Khz) de acordo com os valores programados nos bits 0 e 1 do registrador 07h.



    OUT: Controla o nível da saída SQW/OUT quando o bit4 (SQWE) for igual a 0.
    SQWE: Define se a saída SWQ/OUT será controlada pelo bit 7 ou por RS0 e RS1.
    RS0 e RS1: controlam qual é a freqüência do sinal na saída SWQ/OUT quando o bit SQWE for igual a 1.

    A tabela abaixo mostra de forma clara e resumida o funcionamento do registrador de controle do DS-1307:




    Ao lado temos a identificação de cada terminal do DS1307 em seu dois tipos de envolucros disponíveis.



    As voltagens de alimentação do DS1307 devem respeitar a tabela abaixo:



    No DS-1307 as informações são armazenadas em registradores que podem ser lidos ou modificados facilmente via interface I2C.

    A tabela abaixo mostra o formato desses registradores:

    Obs: os valores são armazenados em BCD e portanto devem ser convertidos para ASCII antes de serem enviados para a serial ou LCD.



    Os registradores de 00h a 07h são utilizados pelo RTC para armazenar as informações de data e hora, já os registradores 08h a 3Fh estão disponíveis para o usuário utilizar da forma que desejar. Vale lembrar que esses registros também são mantidos pela bateria de lítio na ocorrência de falha de alimentação.

    Deve-se ter cuidado ao ler e escrever a informação de Horas (registrador 02h) pois partes dos bits mais significativos (bits 5 e 6) são utilizados para selecionar/indicar o modo de operação 12/24h e AM/PM, sendo então necessário utilizarmos uma mascara em nosso programa para ler e escrever essas informações.

    Importante:
    O bit 7 (CH) do registrador 00h“segundos”, é como um “ON/OFF”do relógio, portanto ele deverá sempre ser colocado em 0, pois se for colocado em 1 o relógio vai ficar parado.


    Vamos ao código:

    Como a comunicação com o DS1307 é via I2C, precisamos incluir em nosso código a biblioteca “WIRE”com o comando abaixo:

    #include "Wire.h"

    O endereço lógico do DS1307 no barramento I2C é 0x68, e portanto definimos isso com a linha abaixo:

    #define DS1307_I2C_ADDRESS 0x68

    Abaixo temos um exemplo de trecho de código para efetuar a escrita nos registradores do DS1307, ou seja , ajustar o relógio:

    Wire.beginTransmission(DS1307_I2C_ADDRESS);
    Wire.send(0x00); //posiciona no primeiro registrador
    Wire.send(segundos);
    Wire.send(minutos);
    Wire.send(horas);
    Wire.send(diaDaSemana);
    Wire.send(diaDoMes);
    Wire.send(mes);
    Wire.send(ano);
    Wire.endTransmission();


    Obs: Inicialmente é necessário enviar um byte para posicionar no registro desejado, no exemplo acima "0x00" significa o primeiro registrador do RTC 00h) que corresponde a informação de segundos.
    A partir dai, a cada escrita efetuada o RTC automaticamente avança para o próximo registrador. O mesmo acontece com o processo de leitura.

    O trecho de código abaixo é um exemplo de como ler os dados dos registradores do DS1307.


    Wire.beginTransmission(DS1307_I2C_ADDRESS);
    Wire.send(0x00);//posiciona no primeiro registrador
    Wire.endTransmission();
    Wire.requestFrom(DS1307_I2C_ADDRESS, 7);//solicita leitura de 7 bytes na I2C
    segundos = (Wire.receive() & 0x7f);// Alguns registros necessitam mascara
    minutos = Wire.receive();
    horas = (Wire.receive() & 0x3f);// necessario alterar se utilizar 12 hour am/pm
    diaDaSemana = Wire.receive();
    diaDoMes = Wire.receive();
    mes = Wire.receive();
    ano = Wire.receive();


    Nas fotos abaixo, temos o circuito do RTC montado em uma protoshield e também a montagem final do shield sobre o Brasileirino (Arduino básico da Globalcode) .






    Bem pessoal, para finalizar temos abaixo um código demo completo que permite programar e ler o RTC DS1307 através do teclado do PC conectado ao Arduino.
    Basta carregar o código no arduino e abrir a janela de terminal monitor em 9600.



    /******************************************************************************
    Example program I2C-RTC interface with Arduino.

    SETUP: I2C-RTC => Arduino
    PIN1 => A5, PIN2 => A4, PIN3 => ground, PIN6 => +5V
    Note: The program is written for address 0xD0 (Arduino address 0x68).
    This program was tested using Arduino Nano
    Document: DS1340 datasheet
    Updated: September 4, 2008
    E-mail: support@gravitech.us
    Gravitech
    (C) Copyright 2008 All Rights Reserved
    *******************************************************************************/

    #include

    #define Binary 0
    #define Hex 1

    /*******************************************************************************
    Function Prototype
    *******************************************************************************/
    unsigned int SerialNumRead (byte);
    void SetTime();
    void DisplayTime();

    /*******************************************************************************
    Global variables
    *******************************************************************************/
    const int I2C_address = 0x68; // I2C write address
    byte Second; // Store second value
    byte Minute; // Store minute value
    byte Hour; // Store hour value
    byte Day; // Store day value
    byte Date; // Store date value
    byte Month; // Store month value
    byte Year; // Store year value

    /*******************************************************************************
    Setup
    *******************************************************************************/
    void setup()
    {
    Serial.begin(9600);
    Wire.begin(); // join i2c bus (address optional for master)
    delay(1000);
    }

    /*******************************************************************************
    Main Loop
    *******************************************************************************/
    void loop()
    {
    boolean Readtime; // Set/Read time flag
    unsigned int Incoming; // Incoming serial data

    // Display prompt
    Serial.println("What would you like to do?");
    Serial.println("(0) To set the current time.");
    Serial.println("(1) To display the current time.");
    Serial.print("Enter 0 or 1: ");

    Incoming = SerialNumRead (Binary); // Get input command
    Serial.println(Incoming, DEC); // Echo the value
    Serial.println();

    if (Incoming == 0) // Process input command
    SetTime();
    else if (Incoming == 1)
    DisplayTime();

    delay (1000);
    }

    /*******************************************************************************
    Read a input number from the Serial Monitor ASCII string
    Return: A binary number or hex number
    *******************************************************************************/
    unsigned int SerialNumRead (byte Type)
    {
    unsigned int Number = 0; // Serial receive number
    unsigned int digit = 1; // Digit
    byte i = 0, j, k=0, n; // Counter
    byte ReceiveBuf [5]; // for incoming serial data

    while (Serial.available() <= 0);

    while (Serial.available() > 0) // Get serial input
    {
    // read the incoming byte:
    ReceiveBuf[i] = Serial.read();
    i++;
    delay(10);
    }

    for (j=i; j>0; j--)
    {
    digit = 1;

    for (n=0; n < k; n++) // This act as pow() with base = 10
    {
    if (Type == Binary)
    digit = 10 * digit;
    else if (Type == Hex)
    digit = 16 * digit;
    }

    ReceiveBuf[j-1] = ReceiveBuf[j-1] - 0x30; // Change ASCII to BIN
    Number = Number + (ReceiveBuf[j-1] * digit); // Calcluate the number
    k++;
    }
    return (Number);
    }

    /*******************************************************************************
    Set time function
    *******************************************************************************/
    void SetTime()
    {
    Serial.print("Enter hours (00-23): ");
    Hour = (byte) SerialNumRead (Hex);
    Serial.println(Hour, HEX); // Echo the value
    Hour = Hour & 0x3F; // Disable century
    Serial.print("Enter minutes (00-59): ");
    Minute = (byte) SerialNumRead (Hex);
    Serial.println(Minute, HEX); // Echo the value
    Serial.print("Enter seconds (00-59): ");
    Second = (byte) SerialNumRead (Hex);
    Serial.println(Second, HEX); // Echo the value
    Second = Second & 0x7F; // Enable oscillator
    Serial.print("Enter day (01-07): ");
    Day = (byte) SerialNumRead (Hex);
    Serial.println(Day, HEX); // Echo the value
    Serial.print("Enter date (01-31): ");
    Date = (byte) SerialNumRead (Hex);
    Serial.println(Date, HEX); // Echo the value
    Serial.print("Enter month (01-12): ");
    Month = (byte) SerialNumRead (Hex);
    Serial.println(Month, HEX); // Echo the value
    Serial.print("Enter year (00-99): ");
    Year = (byte) SerialNumRead (Hex);
    Serial.println(Year, HEX); // Echo the value

    Wire.beginTransmission(I2C_address);
    Wire.send(0);
    Wire.send(Second);
    Wire.send(Minute);
    Wire.send(Hour);
    Wire.send(Day);
    Wire.send(Date);
    Wire.send(Month);
    Wire.send(Year);
    Wire.endTransmission();
    //I2COUT SDA, I2C_WR, [0,Second,Minute,Hour,Day,Date,Month,Year]
    Serial.println();
    Serial.println ("The current time has been successfully set!");
    }

    /*******************************************************************************
    Display time function
    *******************************************************************************/
    void DisplayTime()
    {
    char tempchar [7];
    byte i = 0;
    Wire.beginTransmission(I2C_address);
    Wire.send(0);
    Wire.endTransmission();

    Wire.requestFrom(I2C_address, 7);

    while(Wire.available()) // Checkf for data from slave
    {
    tempchar [i] = Wire.receive(); // receive a byte as character
    i++;
    }
    Second = tempchar [0];
    Minute = tempchar [1];
    Hour = tempchar [2];
    Day = tempchar [3];
    Date = tempchar [4];
    Month = tempchar [5];
    Year = tempchar [6];

    // Display time
    Serial.print("The current time is ");
    Serial.print(Month, HEX);
    Serial.print("/");
    Serial.print(Date, HEX);
    Serial.print("/20");
    if (Year<10)
    Serial.print("0");
    Serial.print(Year, HEX);
    Serial.print(" ");
    Serial.print(Hour, HEX);
    Serial.print(":");
    Serial.print(Minute, HEX);
    Serial.print(":");
    Serial.println(Second, HEX);
    }



    quinta-feira, 1 de julho de 2010

    Uso de Arduino e Program-me na exposição de arte e tecnologia no Itaú Cultural

    Recentemente conhecemos a artista Tania Fraga que já tem vários projetos de arte e tecnologia envolvendo robótica, eletrônica e programação. Por isto ela começou a fazer o curso de lógica de programação (primeiro módulo da Academia do Programador) e nós tivemos a grande oportunidade de conhecê-la e participar da exposição de arte e tecnologia no Itaú Cultural, ontem.
    De Exposicao ItauCultural - Com Program-me
    De Exposicao ItauCultural - Com Program-me

    Tania Fraga é autora do projeto Caracolomobile que se movimenta de acordo com os dados coletados por um capacete sensorial controlando também a música e luzes do ambiente.

    O Caracomobile, as luzes e a música são controlados por um programa em Java e foi necessário criar um bridge em Java para interagir com o driver do capacete em C. Incrível não?

    De Exposicao ItauCultural - Com Program-me

    O Vinicius Senger teve o prazer de participar um pouquinho do projeto e foi conhecer a obra, o hardware e o código antes da abertura da exposição, e num golpe de sorte e competência conseguiu identificar um bug e participar da história.

    Você consegue achar as duas placas Program-me escondidas uma acima e outra abaixo do cabo preto uma virada para cima, e a outra de ponta cabeça ?
    De Exposicao ItauCultural - Com Program-me
    Os cabos amarelos e vermelhos que bombeiam o ar que fazem o caracol abrir e fechar e uma placa Program-me verde de ponta cabeça do lado direito.

    De Exposicao ItauCultural - Com Program-me

    Diversos projetos brasileiros e internacionais estavam sendo apresentados e vários deles utilizam Arduino, reforçando a tendência apresentada no Wall Street Journal e Valor Econômico sobre a importância do Arduino, só que focando no mundo dos artistas.
    Algumas fotos dos projetos que utilizam Arduino:



    O Projeto Amoreiras (na foto abaixo) está do lado de fora do Itaú Cultural na Av. Paulista. As Amoreiras (que já tem amoras) reagem à poluição sonora da Av. Paulista balançando as folhas das árvores para se livrarem da poluição.



    De Exposicao ItauCultural - Com Program-me

    Além da exposição houve um cocktail bem interessante cheio de artistas-geeks.

    Este é sem dúvida nenhuma um dos casos de sucesso mais interessantes e concretos que utilizaram a placa de desenvolvimento Program-me um Arduino projetado e produzido pela Globalcode em parceria com a Br-o-bot.

    Sensacional, obrigada Tania Fraga e toda a equipe pela grande oportunidade.

    Yara Senger
    http://twitter.com/yarasenger
    http://twitter.com/eletronlivre
    http://blog.globalcode.com.br/search/label/Yara

    Novo lote de Program-me

    Chegou mais um lote de Program-mes, um projeto que estende o Arduino criado e produzido pela Globalcode em parceria com a Br-o-bot.

    As placas já estão disponíveis para venda na secretaria da Globalcode em São Paulo e na Loja Virtual Elétron Livre.


    Assista as video-aulas de Program-me / Arduino : http://www.globalcode.com.br/videos/program-me-aula1 e participe da comunidade http://program-me.ning.com/

    Parabéns Paulo Santos e Vinicius Senger pelo projeto de sucesso!

    Um abraço,

    Yara Senger
    http://twitter.com/yarasenger
    http://twitter.com/eletronlivre
    http://blog.globalcode.com.br/search/label/Yara

    segunda-feira, 21 de junho de 2010

    Robótica para todas as idades no Brasil

    A robótica no Brasil começa a criar agora suas raízes indo além do meio acadêmico, além dos materiais convencionais e fazendo que pessoas multi-disciplinares criem coisas fantásticas.

    Temos participado de vários eventos e tido a oportunidade de conhecer pessoas incríveis de todo o Brasil, que vem nos surpreendendo semanalmente. Materiais com memória de forma, mecanismos alternativos de comunicação sem fio e inúmeras plataformas eletrônicas vem surgindo com viabilidade para serem utilizadas até dentro de sua casa.

    Na nossa visão e missão queremos que cada vez mais o Brasil se coloque como um país produtos de tecnologias, além do software. Podemos criar hardware e invenções incríveis dentro da nossa casa, ou nosso escritório. Esta verdade pode ser comprovada na última semana, onde tivemos o prazer de poder participar de eventos relacionados a robótica no Brasil e vamos resumir nossas participações a seguir.

    I Torneio Juvenil de Robótica de São Paulo - IME / USP
    Este incrível evento aconteceu em um sábado chuvoso no agradável ambiente da cidade universitária, no prédio do IME. Organizado pelo Prof. Luis Rogério do Colégio Objetivo, o evento reuiniu uma quantidade incrível de jovens (300+) e robôs (50+). O prof. Luis Rogério, usuário da nossa placa Program-ME / Arduino, nos convidou e literalmente abriu as portas para nós apresentarmos uma oficina e também montarmos um stand onde fizemos diversas demonstrações.



    Com uma faixa etária de dar inveja (pudéra tivéssemos robótica no 1o grau!), os robôs competiram em diferentes categorias, sendo a mais disputada o sumo. Existe uma arena e o pessoal monta um robô e desenvolve uma programação com objetivo de tentar tirar o outro robô da arena. A competição aconteceu com as plataformas Lego NXT e Vex.



    Uma outra categoria que pessoalmente acabei me divertindo muito, foi a de dança, pois como alguns dos leitores deste blog sabem, ano passado desenvolvemos um número de dança de robôs com a famosa paródia do "Bug Novo". Mas ainda uma surpresa maior, alguns alunos dançam junto com os robôs como vocês podem ver na amostra deste vídeo:


    Tivemos a oportunidade de apresentar uma oficina da construção de robôs com Arduino e também assistir do Gogo-board, um interessante projeto de placa que utiliza PIC com USB embarcado no circuito e diferenciais inteligentes no sistema de regulagem de tensão.

    Simpósio de Educação Profissional e Tecnológica da Baixada Santista

    O evento na Praia Grande foi patrocinado pela Season, parceiro Globalcode na Baixada Santista e em São José dos Campos, e tivemos a oportunidade de apresentar uma versão em palestra do tema "Aprendendo a programar de forma divertida e eficiente". Com um público bastante híbrido com jovens (bem jovens) a professores, fizemos algumas colocações de dicas profissionais, escolha de carreira e logo fomos mostrando o mundo da programação com Java, Arduino, Program-ME's e demonstrações inspiradas na Copa do mundo.

    Muito legal é apresentar como funciona um computador falando desde eletrônica analógica, digital, transistores até o código propriamente dito. É um desafio maior ainda fazer isso em pouco mais de uma hora.
    Desenvolvemos ali na hora um exemplo de código bem simples com pisca LED, depois mostramos como acionar uma tomada, depois mostramos como acionar uma buzina que é incrivelmente barulhenta.

    Foi realmente divertido e todos puderam entender o funcionamento com bastante empolgação da plateia.


    Depois do término da palestra fomos conhecer a feira com uma exposição muito bacana mesmo, diversas engenhocas interessantes mostrando na prática toda a parte mecânica, eletrônica e software. Braços robóticos, acionamentos pneumáticos entre outros apresentados por estudantes foram bem legais.

    Agradecemos o pessoal da Season que trabalha com uma competência incrível e sempre apaixonados pela computação, o que representa o espírito de parceria com a Globalcode.

    Vinicius Senger
    http://twitter.com/vsenger
    http://program-me.ning.com
    http://loja.eletronlivre.com.br
    http://blog.globalcode.com.br/search/label/Vinicius%20Senger

    terça-feira, 8 de junho de 2010

    Controlando até 6 motores DC com um único Program-Me

    Durante as aulas da primeira turma do Curso de Robótica na Globalcode, os alunos mostraram vários projetos de robôs que eles construíram ou estavam construindo. Dentre esses projetos tivemos um com LEGO que apresentava a seguinte dificuldade:

    Controlar 5 motores DC de LEGO com o Program-Me utilizando a menor quantidade de portas possível.


    Os motores LEGO possuem um conector proprietário conforme figura ao lado, sendo que após algumas verificações concluimos que os terminais associados ao motor são os identificados como C1 e C2, ou seja, esses são os terminais que devem ser conectados na Ponte-H.




    Para conectar os motores de LEGO em uma ponte-H, é recomendado utilizar cabinhos de extensão da própria LEGO como adaptadores. Basta cortar esses cabinhos ao meio e você terá 2 adaptadores que evitarão a necessidade de danificar os cabos originais dos motores.


    O controle básico de cada motor DC exige uma ponte-H que necessita normalmente 3 portas (uma PWM para controle de velocidade e duas digitais para controlar a direção do motor), porém se utilizarmos 3 portas por motor já estaríamos gastando 15 portas do Program-Me o que não era interessante, pois sobrariam poucas portas para sensores e comunicação.

    Na figura abaixo temos um diagrama básico de um chip de ponte-H para dois motores, onde o lado esquerdo controla um motor e o lado direito controla outro motor.



    Funcionamento da Ponte-H

    Analisando apenas o lado esquerdo da figura acima temos o seguinte:

    As entradas IN1 e IN2 controlam a direção de rotação do motor, enquanto na entrada ENABLE1 aplicamos o sinal PWM que determinará a velocidade do motor.
    Quando o sinal aplicado na entrada IN1 é igual a "1" e o sinal aplicado na entrada IN2 é igual a "0"(zero) o motor gira para um lado, se o sinal aplicado na entrada IN1 é igual a "0" e o sinal aplicado na entrada IN2 é igual a "1" o motor gira no outro sentido. Se o sinal aplicado em ambas as entradas (IN1 e IN2) for igual a 0 ou 1, os terminais do motor serão curto circuitados criando o efeito de freio do motor.
    Como para este projeto o recurso de freio motor não é necessário ele foi descartado.
    As saídas OUT1 e OUT2 são os pontos onde conectamos os terminais do motor.

    Com o objetivo de utilizar menos portas do Program-Me, colocamos um transistor NPN que inverte o sinal aplicado na entrada IN1 e aplica na entrada IN2. Dessa forma conseguimos controlar a direção do motor utilizando apenas uma porta digital. Essa inversão poderia também ser executada por um circuito integrado de portas inversoras (por exemplo o SN7404), mas para simplificar as conexões na protoboard achei melhor utilizar os transistores.

    Na figura abaixo temos o diagrama de montagem da ponte-H para 6 motores com todas as conexões com o program-Me.



    Os transistores são todos BC548 e os resistores de 10K.




    Como a ponte H utilizada é a L293D, não é necessário montar diodos externamente.

    Com esse circuito deixamos todas as portas analógicas do Program-Me livres para conectar sensores e as portas digitais 0 e 1 disponíveis para comunicação com o módulo Xbee que permitirá o controle remoto do robô.