quinta-feira, 24 de novembro de 2011

JHome no Community Keynote JavaOne São Francisco

Um dos momentos mais importantes da história da Eletron Livre aconteceu no dia 06 de Outubro de 2011. O projeto JHome, foi selecionado entre os vencedores do Duke's Choice Award 2011 a fazer uma demo no Community Keynote do JavaOne.

Depois de 10 anos de participação no JavaOne do Vinicius e 8 participações minhas aconteceu o que parecia impossível. Participar de um keynote. E não foi só isto, o Bruno Souza, fundador do SouJava também foi convidado e teve uma participação genial representando o SouJava e a comunidade Brasileira junto com outros líderes de JUGs!

O vídeo do Keynote está disponível na íntegra e muitas outras palestras podem ser assistidas no Parleys.com



O Keynote é muito organizado e planejado, e participamos do ensaio do Keynote na noite anterior onde tive o prazer de conhecer a principal responsável pelo JavaOne: Alvina O'Neal.

Pela primeira vez recebemos o Keynote Early Access Pass e pudemos entender um pouco mais sobre a realização de um keynote em um dos maiores eventos do mundo. Foi demais.

Nossos sinceros agradecimentos à Oracle e as pessoas envolvidas no Keynote Community: Sharat Chander, Arun Gupta e Bruno Souza!

Está chegando o JavaOne 2011 Latin America e nós vamos apresentar a palestra Experiências reais no Brasil: de sistemas financeiros a reator nuclear com Java! O Vinicius Senger vai apresentar o projeto JHome, com o qual recebemos o Duke's Choice Award no JavaOne em São Francisco!

Estaremos com um pequeno stand no pavilhão de exposição esperando você para aproveitarmos um dos melhores eventos para quem realmente gosta e trabalha com Java!

Você não vai ficar fora dessa, vai ? #ficaadica



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

segunda-feira, 24 de outubro de 2011

JHome: automação residencial com software e hardware livre

jHome é uma plataforma open-source para automação residencial baseada em Java EE 6 e Glassfish desenvolvida pela Globalcode através da iniciativa Elétron Livre.
Na verdade é uma consolidação de diversos projetos e demos realizadas pelos colaboradores da iniciativa Elétron Livre. Utilizando componentes JavaEE, como EJB, Servlet, WebService Endpoint e Timer Service, você pode controlar tomadas e muitos eletro-eletrônicos na sua casa. Desta forma você pode aprender Java EE de forma muito mais divertida.

Você pode injetar uma cafeteira no EJB usando CDI, brincou Vinicius Senger

Uma das coisas mais importantes que aprendemos com este projeto foi a confirmação da frase: : Quem não arrisca não petisca!
O Vinicius submeteu o projeto sem muita pretensão e o projeto foi selecionado! Depois de 10 anos participando ativamente da comunidade Java veio o primeiro prêmio da nossa história, um dos momentos mais sonhados por todo participante do JavaOne: um Duke's Choice Award.

Quer saber mais sobre o projeto ?
Visite o site jhome.globalcode.com.br

Quer saber mais sobre o prêmio?
Veja o post no Globalcoders

Assista a cerimônia de entrega do prêmio no JavaOne 2011:


Quer saber mais sobre o projeto JHome ?
Não perca a trilha #Arduino no #TDC2011 Goiânia, dias 29 e 30 de Outubro na Faculdade Cambury!

[]s
Yara Senger
twitter.com/yarasenger
blog.eletronlivre.com.br/search/label/Yara
www.globalcode.com.br/instrutores/YaraSenger

terça-feira, 4 de outubro de 2011

ElétronLivre + Globalcode no TechEd Brasil

Esta edição do TechEd Brasil foi muito especial para as pessoas que curtem Software e Hardware livre. A Microsoft abriu as portas para nos receber com a palestra Arduino + Java + .NET numa trilha focada em interoperabilidade.




O evento foi sensacional, mais de 3000 pessoas participando, com uma área de alimentação enorme para servir almoço para todos, infra-estrutura inpecável!  Muito networking!

Java + Arduino + .NET
Open Source Hardware é um tema que está ganhando cada vez mais visibilidade, desde a publicação no Wall Stret Journal, meio artistico, universidades e agora os principais eventos de tecnologia! Vinicius Senger apresentou este conceito e também as principais conceitos sobre  Arduino.

Apresentou também alguns projetos interessantes:
E para encerrar... cade o .NET ? Uma super arquitetura conceitual Java EE foi utilizada para criação de uma API para autoamção residêncial chamada JHome, que tem várias interfaces: JavaME, JavaFX e agora uma nova interface com .NET apresentada e discutida durante a palestra.

Mas, para aqueles que querem continuar escrevendo em .net, utilizando Visual Studio o Vinicius apresentou o .NET Microframework. E encerramos a palestra com várias perguntas e muita animação!

Esquenta TechEd Brasil na Globalcode
No dia 28 de agosto, véspera do maior evento da Microsoft na América Latina fizemos um encontro organizado pelo Vinicius Senger, Elemar Jr, Leandro Daniel, Emerson Gomes Brandão e Giovanni Bassi! Além da galera nota 10 da comunidade .NET recebemos também os amigos Felipe Oliveira (SoaExpert) e Alexandre Porcelli.(noSQL:br).

O clima esquentou mesmo, e teve muita discussão sobre a "morte ou não do silverlight", várias demos de WindowsPhone, uma prévia da apresentação de Java + Arduino + .NET, tudo isto com pizza e vinho.






Está sendo sensacional a interoperabilidade das comunidades: pessoal de Java conversando com a comunidade .NET, com a comunidade Python, Ruby, Arduino, etc, etc. Nada de cada um na sua panelinha. Developers são devolopers!

Agradeço aos amigos da comunidade .NET, em especial ao Giovanni Bassi que coordenou a primeira trilha .NET no The Developer's Conference 2011, bem como Fernando Figueira pela abertura e pelo espaço que tem nos ofercido, sem contar o apoio e participação no TDC!

É isso, ficamos super honrados e felizes com a participação no TechEd Brasil, esperamos que seja o primeiro de muitos! 

Quer saber mais sobre a comundiade .NET ? Sobre o Esquenta Tech Ed Brasil ? Sobre interoperabilidade de comunidades ? Você não pode perder o podcast produzido pelos amigos @elemarjr @leandronet e @vquaiato VOID PODCAST Vazio e sem retorno de valor !


Um abraço,
Yara Senger
twitter.com/globalcode
blog.globalcode.com.br/search/label/Yara
jhome.globalcode.com.br  

terça-feira, 27 de setembro de 2011

Projeto Automação Náutica com Arduino (Program-me)

Gostaria de compartilhar mais um projeto bacana desenvolvido pelo nosso Professor Pardal Vinicius Senger, uma forma de aprender e experimentar com as coisas da vida real.

Veleiro + Android + Arduino

Tudo começou com um piloto automático quebrado. O piloto automático de um veleiro é uma peça que controla a Cana de Leme mantendo o barco numa determinada direção da bussola, por exemplo  30 graus.

Com o piloto automático trabalhando (companheiro carinhosamente apelidado de Mané) o Capitão Senger consegue fazer outras coisas enquanto navegamos para uma determinada direção, e de tempos em tempos ajusta-se novamente a orientação do piloto automático. 

A bussola do piloto automático quebrou, e por isto o Capitão Senger (ou outro alguém) precisa ficar 100% do tempo mantendo a Cana de Leme na direção correta, caso contrário o barco fica girando ao redor do próprio eixo com influência do vento e do movimento das águas.

Essa foi a primeira motivação para começar o projeto com o Piloto Automático controlado pelo Program-me, o Arduino EletronLivre + Globalcode.

O  piloto automático tinha a seguinte interface: 
[-1 grau] [-10 graus] [ VISOR INDICANDO A DIREÇÃO] [+1 grau] [+10 graus]

Embora fosse totalmente possível reproduzir a interface original o Vinicius preferiu utilizar os mesmos conceitos de controle e comunicação com Bluetooth do Robô BR1 e o acelerômetro do Android foi escolhido como interface para indicação da direção do barco, ou seja, o capitão inclina o celular para direita ou para esquerda indicando a direção da navegação.

Vale a pena assistir ao vídeo que eu mesma editei para entender o funcionamento do projeto:



Em tempos de conectividade os antigos Diários de bordo já não são tão precisamente utilizados e há sempre a vontade de "logar" todos os passeios e viagens com o barco por isto um módulo de GPS foi adicionado ao projeto que cria a rota do barco no Google Earth.

Evidentemente este ainda é um projeto experimental, e sem dúvida um dia pode ser transformado num projeto real, mas o fruto mais importante já foi colhido: conhecimento prático!

E você, qual projeto vai tirar da gaveta?

Yara Senger

terça-feira, 13 de setembro de 2011

Electron Kernel: Arduino multi-modo e multi-tarefa

Lançamos hoje oficialmente o nosso framework Arduino para gerenciar nossos projetos mais complexos que trabalham com múltiplos modos de operação.

O Arduino apesar de simples, pode tomar uma proporção maior em projetos de média complexidade em diante, por isso criamos o Electron Kernel que é um gerenciador de modos, tarefas e eventos para Arduino.

Com ele você consegue programar múltiplos sketches que podem ser alternados via Serial, via botão / interrupção ou de formas customizadas, por exemplo, robôs que mudam de comportamento quando estão em um determinada inclinação.

Usando de conceitos de inversão de controle, principios de orientação a objetos com C++ e muito ponteiro de função, conseguimos abstrair as principais complexidades gerando uma biblioteca simples de usar e com alto poder.


Site em português
Site em inglês

quarta-feira, 27 de julho de 2011

Correio Braziliense - Correio Braziliense de hoje fala sobre o #openhardware e as perípécias de Vinicius Senger e Lucas Fragomeni

Open Hardware está ganhando cada vez mais espaço na mídia convencional , saindo das redes sociais, blogs e YouTube e ganhando as páginas de jornal e televisão enquanto o Arduino está saíndo das "Garagens" dos hobbistas e ganhando cada vez mais a confiança de grandes instituições, escolas e universidades.


Vale a pena conferir esta reportagem realizada com o Vinicius Senger (@vsenger) e Lucas Fragomeni (@lucasfragomeni) no Correio Braziliense.


Carolina Vicentin




Cada vez mais pessoas usam hardwares livres para desenvolver soluções tecnológicas ou melhorar produtos já existentes no mercado


http://www2.correiobraziliense.com.br/euestudante/noticias.php?id=21299



Parabéns!

Vale a pena conferir também a reportagem no Valor Econômico / Wall Street Journal!

Yara Senger
@ysenger

quarta-feira, 1 de junho de 2011

A Elétron Livre vem com tudo para o TDC 2011!

A Globalcode, nesta quinta edição do The Developer’s Conference, repetindo o formato inovador do ano passado - com várias trilhas de temas específicos, conta com o apoio e organização da Elétron Livre.

 The Developers Conference 2011, um evento organizado pela Globalcode

A coordenação da trilha de Arduino, que acontecerá no domingo, dia 10, está sob o comando do Vinicius Senger e do José Luiz Sanchez Lorenzo, ou seja, está imperdível!

Domingo geek = Tecnologia + Futuro + Hacking + Arte + Diversão


Vamos abordar palestras sobre o incrível mundo de invenções open source que unem hardware e software para solucionar problemas do mundo real, tornando a computação muito mais divertida.

Através de palestras, demonstrações e discussões, vamos mostrar parte do infinito mundo de possibilidades que temos acesso.

O evento acontecerá nos dias 6 a 10 de Julho, na Universidade Anhembi Morumbi. Vai ficar fora dessa?

Estão abertas as submissões para palestras na trilha Arduino e muitas outras! Participe! Call4Papers


[]s,
Graziela Tripodi
http://twitter.com/Grazi_UNX

Você já viu o novo site do Elétron Livre?

Empolgados com o lançamento das novas placas Program-ME resolvemos reestruturar todo site, veja só como ficou:

Direto na home você verá as últimas notícias dos produtos, das inovações, participações e parcerias.

A loja virtual também mudou:
Na página dos Program-MEs, por exemplo, você terá acesso à descrição detalhada das novas placas e download gratuito do manual e esquemático.

A compra e o pagamento continua vinculado ao PagSeguro, uma solução para pagamentos online que garante a segurança de quem compra, além da facilidade e ótimas formas de parcelamento.

O site foi desenvolvido utilizando a arquitetura Java EE 6, uma solução simples que demanda produtividade aliada à confiabilidade das tecnologias nativas como EJB, JMS e JSF. #2 Híbrido com OSGi.



Falando um pouco dos Program-MEs v2

As novas placas já vem com mais de 12 funções:
  • Sensor de luz
  • Sensor de temperatura
  • 4 Transistores: para ligar relés, motor de passo, motor DC, leds de alto brilho, etc.
  • Ponte H L293D: controle motores DC com inversão de polaridade (frente / ré) ou motor de passo bipolar
  • 2 entradas para servo-motor
  • Speaker;
  • Botão / chave tátil;
  • 2 entradas analógias
  • 2 entradas para interrupções
  • 1 entrada I2C
  • 1 entrada para bluetooth
  • 5 leds


Os componentes são exatamente os mesmos em ambos formatos e recomendamos a placa redonda para robôs e quadrada para projetos estacionados.

Esperamos que goste!!

[]s,
Graziela Tripodi
http://twitter.com/Grazi_UNX

quarta-feira, 11 de maio de 2011

Android Open Accessory Development Kit

A Google anunciou hoje no evento Google I/O algo que incrível para a plataforma Android em termos de hardware: um kit que permite o usuário desenvolver seu próprio acessório / dispositivo para seu telefone, e além de tudo utilizando a plataforma Arduino que é totalmente aberta e com forte participação da comunidade.

A placa é baseada no microcontrolador Atmega2560, ou seja, é semelhante a um Arduino Mega! Com isso podemos contar com os seguintes recursos:

  • 40 Portas digitais
  • 14 Portas digitais PWM
  • 16 portas analógicas
  • Clock 16 MHz
  • Flash Memory 256 KB
  • SRAM 8 KB
  • EEPROM 4 KB
  • USB Host baseado no shield da SparkFun com MAX3421EEHJ

    Desta forma encontramos na placa dois conectores USB:

    1. Conector para transferir programas do PC para o Arduino (via FT232RL)
    2. Conector para ligar o celular Android na placa (via MAX3421)
    O modelo de programação é o seguinte:

    1. Você desenvolve um aplicativo Arduino utilizando uma biblioteca de USB host da Google que vem no kit de desenvolvimento;
    2. Transfere o programa (sketch) para o Arduino.
    3. Você desenvolve um aplicativo para o Android e transfere da forma que preferir para o telefone
    4. Conecta o Arduino no telefone pela serial do MAX3421
    5. Boa!
    Além da placa com USB Host publicaram também um modelo de uma placa shield que embarca alguns componentes onboard para facilitar a vida de quem quer brincar sem protoboard (qualquer semelhança com Program-ME é mera coincidência!!):

    • 3 Leds RGB
    • 3 Entradas para servo-motor
    • 2 relés
    • Entrada para joystick (vou desvendar melhor esse CI!)
    • 1 microswitch
    • 3 leds 
    Pelo pouco que vi o shield fala com a placa por I2C, mas isso confirmo depois...
      Vejam aqui imagens do arquivo cad desta placa:



      Estamos muito felizes com isso porque nosso projeto Program-ME tem características semelhantes como uma development board e a ligação da nossa placa com o Android é até mais requintada pois é feita com Bluetooth, mas de qualquer forma isso nos mostra que estamos no caminho certo, tanto em investimentos no Arduino quanto tecnicamente nos nossos projetos de development board.

      Além disso, temos um exemplo claro do poder que o open-source de um lado pode ter com dinheiro e muito carisma, ou com carisma e muito dinheiro (Android) e como de outro lado pode ter algo academico que também toma proporções épicas apenas pelo efeito da comunidade (Arduino). E a soma dessas duas energias resultará em centenas de milhares de oportunidades de negócio, para todos nós!

      Podem esperar: seremos os primeiros no mundo a ter um curso disso, aguardem!

      quarta-feira, 30 de março de 2011

      Projeto Ubatubino na escola municipal Tancredo Neves

      O projeto Ubatubino é uma pequena parte de uma grande história que merece ser contada.

      Um dia, monitorando as atividades do GES, nosso sistema de gestão detectei uma solicitação de proposta da prefeitura municipal de Ubatuba, de um curso Introdução a Eletrônica de um professor que estava tendo o primeiro contato com a Globalcode.

      Recebemos o aceite da proposta e o curso foi ministrado algumas semanas depois pelo instrutor José Luiz. Ficamos sabendo um pouco mais sobre o projeto de construção de um Satélite na escola. Neste projeto seria necessário criar, soldar e programar as placas do satélite.

      O Vinicius, no auge da sua empolgação com a criação de placas caseiras (com o sucesso da placa Program-me e da Placa Tomada), ofereceu um segundo curso gratuitamente para ensiná-los a criar placas manualmente e apresentar o Arduino.

      Para este curso era necessário criar uma placa, mas qual placa?
      Criar 20 placas inúteis não parecia uma solução, criar placas tomada talvez...

      Foi então que o Vinicius teve a ideia de criar uma simplificação do Arduino, uma placa de baixo custo e baixa complexidade que os professores e crianças pudessem usar depois para outros projetos, valorizando ainda mais o investimento em peças e o conhecimento adquirido.

      Foi assim que nasceu o Ubatubino.

      Depois dos cursos, o Vinicius ajudou-os a montar um laboratório na escola, ajudando a desvendar os "segredos da Santa Efigênia", bem como ofereceu suporte quando os professores, criaram as placas, e acreditem: ensinaram várias turmas de quinto ano, isto mesmo... quase 120 alunos a imprimir, correr, corrigir, furar, soldar as placas Ubatubino!

      Veja as imagens na matéria realizada sobre o Projeto maior da escola, a construção de um Satélite!


      Este projeto tem tido uma excelente repercussão na mídia, principalmente depois do apoio recebido do meu avô Sérgio Mascarenhas, que abriu diversas portas com a publicação da história no Blog do Chico (que tem a história muito interessante dos primeiros passos do Professor Candido) , depois a publicação na Revista Fapesp, originando tantas solicitações da imprensa.

      Desta forma agradeço imensamente ao meu avô Sérgio Mascarenhas e também ao Vinicius Senger que vem dedicando dezenas de horas voluntariamente a este projeto, e claro, a toda equipe de professores da Escola Municipal Tancredo Neves, em Ubatuba.

      Quais os próximos passos com o Projeto Ubatubino ?
      A criação de um robô voador com balões de hélio! Veja o vídeo do protótipo:



      O céu não é mais o limite!

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

      quinta-feira, 24 de março de 2011

      Arduino Hack Day em São José do Rio Preto-SP

      Aconteceu na FATEC de São José do Rio Preto-SP entre 26 e 27 de Fevereiro de 2011 o Arduino Hacking Day, com o apoio da comunidade Java Noroeste e dos professores e técnicos da FATEC.



      No início de 2011, a lista do Java Noroeste foi bem movimentada com o assunto Arduino, que surpreendeu a muitos pela alta procura que proporcionou a 50 pessoas divididas em dois grupos passarem horas conversando e trocando ideias com o Vinicius Senger que com maestria e muita habilidade conduziu a todos numa viagem de possibilidades para futuros projetos.




      Enfatizamos todo o agradecimento a FATEC que proporcionou instalações para o Arduino Hacking Day fosse um sucesso e a DESTAQUE do nosso colega Thiago Vespa pela realização de mais este evento.
      Esperamos agora novas oportunidades para um novo Arduino Hacking Day, já que muitas pessoas não puderam fazer.
      Fica ai o registro e atenção para o próximo Arduino Hacking Day.

      segunda-feira, 14 de fevereiro de 2011

      Dimmer Digital Futurístico com Arduíno (Parte 2)



      Neste post falaremos sobre a teoria do funcionamento do dimmer digital com Arduino desenvolvido pelo Vinicius Senger e como implementar um controle de intensidade preciso utilizando um sensor de distância IR.

      A rede elétrica que temos disponível na maioria das residências no Brasil é senoidal com 127 volts, sendo que a freqüência de oscilação é de 60 Hz (sessenta ciclos por segundo). Isso significa que temos um ciclo a cada 16,66 ms.

      Para implementar o controle de luminosidade de uma lâmpada em AC, normalmente utilizamos um componente chamado TRIAC.

      TRIAC ou Triode for Alternating Current é um componente eletrônico equivalente a dois retificadores controlados de silício (SCR ou tiristores) ligados em antiparalelo e com os terminais de disparo “gate“ ligados juntos.
      Este tipo de ligação resulta em uma chave eletrônica bidirecional que pode conduzir a corrente elétrica nos dois sentidos. O TRIAC faz parte da família de tiristores.





      Um TRIAC pode ser disparado tanto por uma corrente positiva quanto negativa aplicada no terminal de disparo (gate). Uma vez disparado, o dispositivo continua a conduzir até que a corrente elétrica caia abaixo do valor de corte.
      Isto torna o TRIAC ideal para o controle de circuitos de corrente alternada, permitindo acionar grandes potências com circuitos acionados por correntes da ordem de miliamperes.

      Podemos controlar o início da condução do dispositivo, aplicando um pulso em um ponto pré-determinado do ciclo de corrente alternada, o que permite controlar a percentagem do ciclo que estará alimentando a carga (também chamado de controle de fase).

      Quando usado com cargas indutivas, como motores elétricos, é necessário que se assegure que o TRIAC seja desligado corretamente no final de cada semi-ciclo.
      Para circuitos de maior potência, podemos utilizar dois SCRs ligados em antiparalelo, o que garante que cada SCR estará controlando um semi-ciclo independente, não importando a natureza da carga.

      Para que seja possível disparar o TRIAC no momento correto, precisamos sincronizar esse disparo com a forma de onda da rede elétrica, para isso utilizamos um circuito detector de passagem por zero volts, no nosso projeto esse circuito é formado pelos componentes R1 a R4 , OK1 (4N35) e R5 (ver diagrama elétrico) .

      A cada passagem da onda por zero volts, é gerada uma interrupção (INT0) no ATMEGA, ou seja , temos uma interrupção a cada 8,33 ms. Devemos então gerar um pulso no gate do TRIAC dentro de um intervalo entre 150 microsegundos até 8 milisegundos após a interrupção, assim ele conduzirá corrente elétrica em parte do semi-ciclo atual, seja ele positivo ou negativo.
      Quanto mais antecipado for o disparo do TRIAC maior será a intensidade da lâmpada.

      obs: não devemos disparar o TRIAC exatamente após a interrupção, pois a tensão ainda estará baixa e não haverá corrente suficiente para manter o TRIAC conduzindo, por isso demos uma margem de 150 microsegundos.

      Neste projeto o circuito responsável pelo acionamento do TRIAC é formado pelos componentes OK2 (MOC3021), R7 e TRIAC-1.
      Lembrando que tanto OK1 como OK2 tem também as funções de isolar o circuito AC do circuito DC.

      Para controlarmos o instante de disparo do TRIAC, quando o ATMEGA recebe uma interrupção externa (INT0), iniciamos o TIMER1 com um valor em us (microsegundos) que é inversamente proporcional a ultima leitura válida do sensor de distância, sendo que transcorrido esse período será gerada uma interrupção indicando o momento do disparo do TRIAC.
      O momento do disparo definirá a intensidade luminosa da lâmpada.
      A implementação da interrupção utilizando o TIMER1 é feita utilizando a biblioteca TIMER1.

      Com a utilização do TIMER1 da forma descrita acima, liberamos o ATMEGA para executar outras funções durante o período entre a detecção de passagem por zero e o momento do disparo do TRIAC, ou seja , ganhamos até 8 ms por semi-ciclo. Esse tempo é aproveitado por exemplo para fazer a multiplexação dos displays de 7 segmentos que indicam a % da potência aplicada à lâmpada (método Loop), evitando assim a necessidade de mais componentes para controlar esses displays.

      A figura abaixo mostra as formas de onda da rede AC, da saída do detector de passagem pelo zero volts, do momento de disparo do gate do TRIAC e da forma de onda aplicada na lâmpada com 3 níveis diferentes de intensidade (100%, 50% e 10%).

      Vejam que quanto mais cedo for disparado o TRIAC, maior será a área do ciclo aplicado a lâmpada (em vermelho) , e consequentemente maior será a intensidade luminosa.



      Para definir o momento de leitura do sensor de distância, utilizamos a biblioteca MS_Timer2 de forma que seja gerada uma interrupção a cada 200ms. No tratamento dessa interrupção efetuamos a leitura do sensor de distância e definimos os dígitos de cada display 7 segmentos de acordo com a leitura efetuada.

      Como pode ser observado no código disponibilizado , o método loop( ) deste projeto, fica o tempo todo atualizando a informação nos displays de 7 segmentos, e todas as demais funções são tratadas a partir de interrupções externa (INT0 “zerocross detection”) e internas(Timer1 “disparo do TRIAC” / TIMER2 “leitura do sensor distância IR”).

      O resultado dessa implementação é um dimmer preciso e com indicação visual da potência aplicada na lâmpada.

      Nas figuras abaixo temos o diagrama elétrico completo e a arte final em formato de shield.





      Lista de Componentes:

      R1 a R4 : resistores de 47K
      R5 : resistor de 10K
      R6 e R7 : resistores de 330ohm
      OK1: fotoacoplador 4N35
      OK2: MOC3021
      TRIAC-1: BTA16
      Display de 7 segmentos com 3 digitos (anodo comum).
      Protoshield
      sensor de distância analógico (IR)

      O protótipo foi montado em uma protoshield que atendeu muito bem, possibilitando a montagem de todos os componentes com bastante facilidade. (foto abaixo)



      abaixo temos o código completo do dimmer:

      #include <TimerOne.h>   // inclui biblioteca Timer1
      #include <MsTimer2.h>   // Inclui biblioteca MsTimer2
      //define portas associadas ao display 7seg
      //int displaySeg[] = {a, b, c, d, e, f, g, pd};
      int displaySeg[] = {6, 1, 17, 15, 14, 5, 18, 12};
      //int displayPorts[] = {Anodo1, Anodo2, Anodo3};
      int displayPort[] = {7, 4, 3};
      
      // define padroes do display 7SEG, de 0 - 9 e apagado
      // 1 = segmento apagado, 0 = segmento aceso
      byte seven_seg_digits[11][8] =  {
      { 0,0,0,0,0,0,1,1 },  // = 0
      { 1,0,0,1,1,1,1,1 },  // = 1
      { 0,0,1,0,0,1,0,1 },  // = 2
      { 0,0,0,0,1,1,0,1 },  // = 3
      { 1,0,0,1,1,0,0,1 },  // = 4
      { 0,1,0,0,1,0,0,1 },  // = 5
      { 0,1,0,0,0,0,0,1 },  // = 6
      { 0,0,0,1,1,1,1,1 },  // = 7
      { 0,0,0,0,0,0,0,1 },  // = 8
      { 0,0,0,1,1,0,0,1 },   // = 9
      { 1,1,1,1,1,1,1,1 }   // = blank
      };
      
      int sensorDistancia = 2;  // porta associada ao sensor distancia IR
      int triacGatePin = 10 ;  // porta associada ao gate do TRIAC
      
      int distancia = 0 ;  // variavel para armazenar distancia
      int power= 0 ;  //inicializa variavel que controla potencia na lampada com 0 (lampada apagada)
      int centena = 10 ;  // armazena informacao a ser apresentada no display de centena (inicializa com 10 = apagado)
      int dezena = 10 ;  // armazena informacao a ser apresentada no display de dezena (inicializa com 10 = apagado)
      int unidade = 10 ;  // armazena informacao a ser apresentada no display de unidade (inicializa com 10 = apagado)
      
      void setup() {  
      //Serial.begin(9600);
      pinMode(triacGatePin, OUTPUT);
      for (int i=0 ; i<=3 ; i++) {  
      pinMode(displayPort[i], OUTPUT);  
      }
      for (int j=0 ; j<=7 ; j++) {  
      pinMode(displaySeg[j], OUTPUT);  
      }
      attachInterrupt(0, zeroCrossInterrupt, CHANGE);  //associa interrupcao INT0 com funcao "zeroCrossInterrupt"
      
      MsTimer2::set(200, leSensor); // inicializa Timer2 com 200 milisegundos (tempo entre leituras do sensor de dintancia)
      MsTimer2::start();  // start do timer2
      }
      
      void loop() {
      atualizaDisplay(unidade, dezena, centena);  // atualiza informacoes nos displays de 7 segmentos
      }
      
      void atualizaDisplay(int uni, int dez, int cen) {
      for (int k = 0; k < 8; ++k) {
      digitalWrite(displaySeg[k], seven_seg_digits[uni][k]);
      }
      digitalWrite(displayPort[2], HIGH);
      delay (1);
      digitalWrite(displayPort[2], LOW);
      
      for (int k = 0; k < 8; ++k) {
      digitalWrite(displaySeg[k], seven_seg_digits[dez][k]);
      }
      digitalWrite(displayPort[1], HIGH);
      delay (1);
      digitalWrite(displayPort[1], LOW);
      
      for (int k = 0; k < 8; ++k) {
      digitalWrite(displaySeg[k], seven_seg_digits[cen][k]);
      }
      digitalWrite(displayPort[0], HIGH);
      delay (1);
      digitalWrite(displayPort[0], LOW);
      
      }
      
      void zeroCrossInterrupt(){  // trata interrupcao INT0 
      if(power > 0) {
      long dimtime = int(map(power,0,100,8000,150));  // calcula o tempo de delay para o disparo do TRIAC
      Timer1.initialize (dimtime);  // inicializa o TIMER1 com o delay calculado
      Timer1.attachInterrupt(gateTRIAC);  //associa a funcao gateTRIAC com  Interrupcao do TIMER1
      Timer1.start();  // inicia contagem TIMER1
      }  else {
      digitalWrite(triacGatePin, LOW);   // mantem gate do TRIAC desativado.  
      Timer1.stop();
      }
      }
      
      void gateTRIAC () {  // trata interrupcao do TIMER1 gerando pulso no gate do TRIAC
      digitalWrite(triacGatePin, HIGH);  // dispara o Triac
      delayMicroseconds(15);  // aguarda 15 microsegundos para garantir disparo do TRIAC
      digitalWrite(triacGatePin, LOW);   // desabibilta gate do TRIAC 
      Timer1.stop();
      }
      
      void leSensor() {
      distancia = analogRead(sensorDistancia);  // le sensor de distancia
      //Serial.println(distancia);
      distancia = map(distancia,70,600,120,0);  // mapeia distancia lida para uma faixa de potencia entre 0 e 120
      if (distancia < 0) {
      distancia = 0;
      }
      
      if (distancia >=0 && distancia <= 100) {  // se distancia <= a 100 atualiza potencia
      power=distancia;
      }
      
      centena = int(power / 100);  // atualiza variaveis que contem informacoes dos displays
      dezena = int((power - (centena*100)) / 10);
      unidade = int(power - (centena*100)-(dezena*10));
      if (centena == 0 && dezena == 0){ 
      centena = 10;
      dezena = 10;
      }
      if (centena == 0){
      centena = 10;
      }
      }
      
      


      Segue um vídeo demonstrando o funcionamento do dimmer.

      segunda-feira, 24 de janeiro de 2011

      SIMONDUINO - game touchscreen com Arduino Brasileirino




      Neste post demonstrarei como utilizar uma tela touchscreen resistiva implementando o jogo SIMON (Genius da Estrela) no Arduino.

      Primeiro vamos ver como é o funcionamento da tela touchscreen resistiva.

      Basicamente essas telas são compostas de dois filmes resistivos "resistive Coating". Entre eles existem espaçadores "spacers" que evitam falsos toques. Existe também uma base de vidro "Bottom Glass" que dá resistência mecânica e mantém firme o resistive Coating da parte inferior.



      Esse tipo de tela possui 4 pontos de conexão, sendo dois deles associados aos extremos do resistive Coating (on top film) e os outros dois associados aos extremos do resistive Coating (on bottom glass).



      Ao pressionarmos um ponto da tela, o Resistive Coating superior entra em contato com o inferior criando uma resistência entre os pontos de conexão do resistive Coating superior e do resistive Coating inferior.

      Na prática o que temos é que a tela touchscreen resistiva se comporta como dois potênciometros, um associado ao eixo X e outro ao eixo Y.



      Obtendo as coordenadas do ponto pressionado




      Para obtermos a cordenada X, aplicamos (GND) em um dos terminais associados ao barramento lateral da tela e 5 volts no terminal associado ao outro barramento lateral da tela, então efetuamos uma leitura analógica no terminal associado ao barramento superior ou inferior da tela.

      A figura ao lado mostra como efetuar a leitura da cordenada X:














      Para obtermos a cordenada Y, aplicamos (GND) no terminal associado ao barramento inferior da tela e 5 volts no terminal associado ao barramento superior da tela, então efetuamos uma leitura analógica no terminal associado a qualquer um dos barramentos laterais da tela.

      A figura ao lado mostra como efetuar a leitura da cordenada Y:











      Com relação a calibragem da tela, foi necessário apenas ajustar no código o posicionamento na tela de acordo com os valores analógicos máximos e mínimos obtidos das cordenadas X e Y.

      As linhas principais do código para obter o ponto pressionado na tela ficaram da seguinte forma:

      int x=analogRead(yLow);
      x=map(x,90,850,0,127);

      onde valores mínimo e máximo de X (90 e 850) foram mapeados para os pixels do display (0 ~ 127)


      int y=analogRead(xLow);
      y=map(y,80,820,0,63);

      onde valores mínimo e máximo de Y (80 e 820) foram mapeados para os pixels do display (0 ~ 63)



      Bem agora que já sabemos o funcionamento básico do touchscreen resistivo, vamos ao projeto.

      Para implementar o SIMON touchscreen com Arduino, utilizei uma placa Brasileirino da Globalcode, um display LCD gráfico ITM-12864 (128x64 pixels), uma tela touchscreen resistiva de Nintendo DS e um Nintendo DS Touch Screen Connector Breakout (este para conexão do flat cable da tela touch).
      Obs: Recomendo a utilização do Nintendo DS Touch Screen Connector Breakout, pois a conexão da tela sem ele se torna muito delicada.



      A tela foi dividida em 4 quadrantes, onde cada um representa um botão do jogo. Vide foto abaixo:





      O display ITM-12864 é baseado no controlador KS0108 e portanto é compatível com a "KS0108 Graphics LCD library"

      Essa biblioteca facilita bastante a interface com o display LCD, visto que podemos carregar imagens bimap no display com apenas um comando.
      Mais detalhes sobre a utilização dessa biblioteca podem ser vistos no meu post sobre bússola digital ou na página oficial da biblioteca.
      Um detalhe importante na utilização dessa biblioteca é configurar corretamente o arquivo ks0108_Arduino.h.
      Nesse arquivo indicamos onde está conectado cada terminal do display no Arduino.

      Para este projeto o trecho inicial do arquivo ficou da seguinte forma:

      /*

      /*********************************************************/
      /* Configuration for assigning LCD bits to Arduino Pins */
      /*********************************************************/
      /* Arduino pins used for Commands
      * default assignment uses the first five analog pins
      */

      #define CSEL1 2 // CS1 Bit // swap pin assignments with CSEL2 if left/right image is reversed
      #define CSEL2 3 // CS2 Bit

      #define R_W 13 // R/W Bit
      #define D_I 12 // D/I Bit
      #define EN 19 // EN Bit
      //#define RES 19 // Reset Bit // uncomment this to contol LCD reset on this pin

      /* option: uncomment the next line if all command pins are on the same port for slight speed & code size improvement */
      #define LCD_CMD_PORT PORTB // Command Output Register for pins 14-19

      /* Arduino pins used for LCD Data
      * un-comment ONE of the following pin options that corresponds to the wiring of data bits 0-3
      */
      #define dataPins8to11 // bits 0-3 assigned to arduino pins 8-11, bits 4-7 assigned to arduino pins 4-7
      //#define dataPins14to17 //bits 0-3 assigned to arduino pins 14-17, bits 4-7 assigned to arduino pins 4-7. (note command pins must be changed)
      //#define dataPins0to3 // bits 0-3 assigned to arduino pins 0-3 , bits 4-7 assigned to arduino pins 4-7, this is marginally the fastest option but its only available on runtime board without hardware rs232.

      /* NOTE: all above options assume LCD data bits 4-7 are connected to arduino pins 4-7 */

      /*******************************************************/
      /* end of Arduino configuration */
      /*******************************************************/



      A maioria dos displays LCD necessitam de uma tensão negativa para acionamento do display, muitos deles possuem um circuito interno para gerar essa tensão. Como o ITM-12864 não possui esse circuito e afim de evitar a utilização de duas fontes de alimentação externas, montei no protoboard localizado em baixo do display, um conversor de +12volts para -9 volts utilizando um CI 555.

      Nas figuras abaixo temos o diagrama elétrico do conversor e a montagem dele no protoboard. Na protoboard foram adicionados também o speaker, o potenciômetro de controle de contraste do display e os resistores que ligam os terminais da tela touch ao terra.




      Nas imagens abaixo temos o detalhe da conexão do flat cable da tela touch utilizando a Nintendo DS touch Screen Connector Breakout. Também é possível ver a colagem da tela touch no display onde utilizei tiras de fita dupla face.





      Além de ser conectada nas portas analógicas 0 a 3, a tela touch necessita resistores para o terra (GND) conforme diagrama abaixo:
      Esses resistores foram montados na protoboard em baixo do display e eles tornam o processo de calibração da tela desnecessário.




      O programa deste projeto foi baseado no código apresentado pelo Spock em seu post sobre "DOJO de programação com Program-Me", sendo que aproveitei toda a parte funcional do código original e fiz apenas as adaptações necessárias para substituir os botões e Leds pela touchscreen e pelo display, além de implementar sons diferentes para cada botão.

      Segue abaixo o código final do projeto.



      #include <ks0108.h> // inclui biblioteca KS0108
      #include "bloco1_ON.h" // bitmap botao 1 ativado
      #include "bloco2_ON.h" // bitmap botao 2 ativado
      #include "bloco3_ON.h" // bitmap botao 3 ativado
      #include "bloco4_ON.h" // bitmap botao 4 ativado
      #include "blocos_OFF.h" // bitmap todos os botoes desativados
      #include "principal.h" // bitmap logo SIMONDUINO
      #include "logo_Globalcode.h" // bitmap logo Globalcode
      #include "level1.h" // bitmap nivel 1
      #include "level2.h" // bitmap nivel 2
      #include "level3.h" // bitmap nivel 3
      #include "level4.h" // bitmap nivel 4
      #include "gameOver.h" // bitmap game over
      #include "parabens.h" // parabens voce venceu

      #define xLow 15 //define porta associada ao xLow (X2)
      #define xHigh 17 //define porta associada ao xHigh (X1)
      #define yLow 16 //define porta associada ao yLow (Y2)
      #define yHigh 14 //define porta associada ao yHigh (Y1)

      int bip = 18;
      char state = 'S'; // S = Start, P = Play, B = Read button, ...
      int sequencia[] = {0,0,0,0,0,0,0,0,0};
      int currentRound = 0; // armazena round atual
      int level = 1; //define nivel 1 como inicial
      int tamanhoSequencia = 8; //define o tamnanho de cada sequencia
      boolean fimJogo = true; // indica fim de jogo

      void setup() {
      pinMode(bip, OUTPUT); // configura porta speaker como saida
      Serial.begin(9600);
      GLCD.Init(NON_INVERTED); // inicializa a biblioteca GLCD
      GLCD.ClearScreen(); // limpa tela do display
      GLCD.DrawBitmap(principal,0,0,BLACK); //desenha na tela o bitmap do SIMONDUINO
      delay(3000);
      GLCD.DrawBitmap(logo_Globalcode,0,0,BLACK); //desenha na tela o logo da Globalcode
      delay(3000);
      GLCD.DrawBitmap(level1,0,0,BLACK); //desenha na tela o bitmap do nivel 1
      delay(2000);
      }

      void loop() {
      if (state == 'S') {
      inicio(); //inicializa jogo
      fimJogo = false;
      currentRound = 0;
      state = 'P';
      }
      if (state == 'P') {
      acendeluzesdarodada(); //reproduz seguencia da rodada no display e no speaker
      state = 'B';
      }
      if (state == 'B') {
      for (int i = 0; i <= currentRound; i++){
      int botao = leBotao(); //chama funcao que le os botoes (touchscreen)
      if (sequencia[i] != botao || botao==-1) {
      state = 'S';
      fimJogo = true;
      GLCD.DrawBitmap(gameOver,0,0,BLACK); //desenha na tela o bitmap de gameover
      beep();
      delay(2000);
      GLCD.DrawBitmap(level1,0,0,BLACK); //draw the bitmap at the given x,y position
      level = 1;
      break;
      }
      }
      if (!fimJogo) {
      currentRound++;
      if (currentRound == tamanhoSequencia) { //verifica se round foi concluido
      level++ ;
      switch (level) { //caso concluido desenha bitmap do proximo nivel
      case 2:
      GLCD.DrawBitmap(level2,0,0,BLACK); //draw the bitmap at the given x,y position
      break;
      case 3:
      GLCD.DrawBitmap(level3,0,0,BLACK); //draw the bitmap at the given x,y position
      break;
      case 4:
      GLCD.DrawBitmap(level4,0,0,BLACK); //draw the bitmap at the given x,y position
      break;
      case 5:
      GLCD.DrawBitmap(parabens,0,0,BLACK); //draw the bitmap at the given x,y position
      delay(5000);
      GLCD.DrawBitmap(level1,0,0,BLACK); //desenha na tela o bitmap do nivel 1
      delay(2000);
      state = 'S';
      level = 1 ;
      break;
      }
      state = 'S';}else{
      state = 'P';
      }
      }
      }
      delay(2000);
      }

      void acendeluzesdarodada() {
      for (int i = 0; i <= currentRound;i++){
      alteraBotoes(sequencia[i]);
      ton(sequencia[i]);
      delay(500 - (level*50));
      noTone(bip);
      alteraBotoes(-1);
      delay(250 - (level*25));
      }
      }

      int leBotao() {
      int timeout = 0;
      int botao = -1;
      while (botao == -1 && timeout <= (35 - (level*5))) {
      botao = leScreen(); //le touchscreen
      if(botao != -1) {
      break;
      }
      delay(100);
      timeout++;
      }
      alteraBotoes (botao);
      while (leScreen( ) != -1){
      ton(botao);
      }
      noTone(bip);
      GLCD.DrawBitmap(blocos_OFF,0,0, BLACK); //desenha todos os botoes desativados
      return botao;
      }

      void beep() { // emite som de fim de jogo
      tone(bip,100);
      delay(2000);
      noTone(bip);
      }

      void ton(int freq) { //emite sond de cada botao
      tone(bip,freq*1000);
      }

      void inicio() {
      GLCD.ClearScreen();
      GLCD.DrawBitmap(blocos_OFF,0,0,BLACK); //desenha todos os botoes desativados
      randomSeed(analogRead(4)); // inicializa numeros randomicos
      for (int i = 0; i < tamanhoSequencia; i++) {
      sequencia[i] = (int) random(1, 5); // gera sequencia aleatoria do round
      }
      }

      int leScreen() {
      pinMode(xLow,OUTPUT); // prepara sinais da tela touch para leitura da coordenada X
      pinMode(xHigh,OUTPUT);
      digitalWrite(xLow,LOW);
      digitalWrite(xHigh,HIGH);
      digitalWrite(yLow,LOW);
      digitalWrite(yHigh,LOW);
      pinMode(yLow,INPUT);
      pinMode(yHigh,INPUT);
      delay(10);
      //xLow has analog port -14 !!
      int x=analogRead(yLow -14); // le coordenada X
      x=map(x,90,850,0,127); // ajusta coordenada X de acordo com resolucao do display

      pinMode(yLow,OUTPUT); // prepara sinais da tela touch para leitura da coordenada Y
      pinMode(yHigh,OUTPUT);
      digitalWrite(yLow,LOW);
      digitalWrite(yHigh,HIGH);
      digitalWrite(xLow,LOW);
      digitalWrite(xHigh,LOW);
      pinMode(xLow,INPUT);
      pinMode(xHigh,INPUT);
      delay(10);
      //xLow has analog port -14 !!
      int y=analogRead(xLow - 14); // le coordenada Y
      y=map(y,80,820,0,63); // ajusta coordenada Y de acordo com resolucao do display

      // Serial.print(x,DEC); //imprime cordenadas no serial monitor (descomentar para debug)
      // Serial.print(",");
      // Serial.println(y,DEC);

      delay(200);

      if ((x >= 0 && x < 64) && y > 32) { // verifica em qual quadrante da tela foi efetuado o toque de acordo com as coordenadas X e Y
      return 1;
      }
      if ((x >= 64 && x < 128) && y > 32) {
      return 2;
      }

      if ((x >= 0 && x < 64) && (y >= 0 && y < 32)) {
      return 3;
      }
      if ((x >= 64 && x < 128) && (y >= 0 && y < 32)) {
      return 4;
      }
      return -1;
      }

      void alteraBotoes (int botao) {
      switch (botao) {
      case 1:
      GLCD.DrawBitmap(bloco1_ON, 0, 0, BLACK); //desenha botao 1 ativado
      break;
      case 2:
      GLCD.DrawBitmap(bloco2_ON, 64, 0, BLACK); //desenha botao 2 ativado
      break;
      case 3:
      GLCD.DrawBitmap(bloco3_ON, 0, 32, BLACK); //desenha botao 3 ativado
      break;
      case 4:
      GLCD.DrawBitmap(bloco4_ON, 64, 32, BLACK); //desenha botao 4 ativado
      break;
      default:
      // se nenhum botao estiver pressionado, desenha botoes desativados
      GLCD.DrawBitmap(blocos_OFF, 0, 0, BLACK); //desenha botoes desativados
      }
      }



      Abaixo temos um video demonstrando o funcionamento do SIMONDUINO Touchscreen, sendo que apenas reduzi o tamanho das combinações de cada nível de 8 para 3 afim de encurtar o vídeo. A cada nível que se avança as sequências são apresentadas com maior velocidade e o jogador tem menos tempo para reproduzi-las.



      Custo dos componentes principais:

      Display LCD gráfico ITM-12864 R$ 50,00
      Tela touchscreen Nintendo DS US$ 9,95
      Breakout board para conexão da tela US$ 3,95


      Bem é isso pessoal, espero que gostem do projeto. Me diverti bastante fazendo ele.

      [ ]s

      José Luiz Sanchez Lorenzo
      Twitter: @jllorenzo