Mostrando postagens com marcador desenvolvimento. Mostrar todas as postagens
Mostrando postagens com marcador desenvolvimento. Mostrar todas as postagens

segunda-feira, 7 de julho de 2014

Verificador de emails não lidos

No site de aprendizado da Sparkfun está disponível um tutorial de como fazer um verificador de emails não lidos utilizando a placa Galileo.

No tutorial, é utilizado um display de 7 segmentos para apresentar o número de emails não lidos e pode-se também escolher fazer a conexão na rede via wi-fi ou via cabo.

Alterei algumas partes do código original para que eu pudesse utilizar um display lcd ao invés de um display de 7 segmentos para, quem sabe, futuramente incrementar as funcionalidades deste código.

Os componentes necessários para este tutorial são:


  • 1x Placa Intel® Galileo
  • 1x Display LCD 16x2
  • 1x potenciômetro
  • 1x Cabo de rede
  • 1x Cartão µSD
O diagrama da montagem com o LCD está apresentado na imagem a seguir:

Sugestão de ligação do display LCD

A montagem acima é da seguinte forma:

  • Conectores DB4-DB7 do display ligados nos pinos A2-A5 da Galileo
  • Conector RS do display ligado no pino A0 da Galileo
  • Conector E (Enable) do display ligado no pino A1 da Galileo
  • Conector V0 do display ligado no conector central do potenciômetro
  • Conector VSS e conector R/W do display ligados em um conector não-central do potenciômetro curto-circuitado com Gnd da Galileo
  • Conector VDD ligado ao conector restante do potenciômetro curto-circuitado com o pino de 5V da Galileo
Com esta ligação será possível apresentar no display a contagem de emails não lidos e qualquer mensagem que queiramos apresentar. O potenciômetro tem a função de controlar o 'alfa' do display.

Para realizar o tutorial é necessário que a Galileo esteja com o firmware atualizado e com o sistema linux instalado no cartão µSD, de acordo com os passos 3 e 4 destas recomendações.

Inclua o seguinte código em um arquivo python na raiz do cartão µSD que tem o linux instalado com o nome de pyMailCheck.py:


# pyMailCheck.py - Loga no seu gmail e imprime o numero de emails nao lidos.
# Coloque este arquivo na raiz do cartao SD da Galileo.
 
import imaplib  # Usado para conectar em um servidor IMAP4.
obj = imaplib.IMAP4_SSL('imap.gmail.com', '993')  # Conecta em um servidor IMAP4 com SSL, porta 993
obj.login('my_email_address@gmail.com','myPassword')  # Identifica o usuário e senha do cliente
obj.select()  # Seleciona o 'INBOX'  (parametro default)
# Procura na caixa de email o charset no (None), criterio:"UnSeen" (nao visto). Retornara uma tupla, pega a segunda parte,
# divide cada string em uma lista e retorna o tamanho desta lista:
print len(obj.search(None,'UnSeen')[1][0].split())

Altere o código acima colocando suas informações de e-mail e insira o cartão SD no slot da Galileo, ligue-a na fonte de energia e em seguida ao computador para fazer upload do código a seguir:


/* Galileo Email Checker
   by: Jim Lindblom
       SparkFun Electronics
   date: January 7, 2013
   license: Beerware. Please use, reuse, and modify this code.
   If you find it useful, you can buy me a beer when we meet.
   
   This code connects a Galileo to Ethernet. Then runs a Python script
   - https://gist.github.com/jimblom/8292444#file-pymailcheck-py -
   that lives on the Galileo's SD card to check how many unread
   emails you have. That number is displayed on an OpenSegment
   Shield - https://www.sparkfun.com/products/11846 - which is
   controlled over SPI.
   
   Editado para funcionar com uma shield LCD por Rodrigo Monteiro
*/
/////////////////////////////
// Inclusao de bibliotecas //
////////////////////////////

//Biblioteca do LCD
#include <LiquidCrystal.h>

#include <SD.h> // Biblioteca SD para ler o arquivo temporario
                // onde o script em python armazena o contador de emails nao lidos.
#include <Ethernet.h> // Biblioteca Ethernet 



// Inicializa a biblioteca com o numero dos pinos de interface
LiquidCrystal lcd(A0, A1, A2,A3, A4, A5);

////////////////////////////
// Definicoes de Ethernet //
///////////////////////////
byte mac[] = {0x6A, 0x11, 0x1l, 0x30, 0x12, 0x34};

///////////////////////////
// Definicoes de pinagem //
//////////////////////////
const int STAT_LED = 13; // The Galileo's status LED on pin 13

/////////////////////////////////////////////
// Variaveis globais de checagem de emails //
/////////////////////////////////////////////
const int emailUpdateRate = 10000; // Taxa de update em ms (10 s)
long emailLastMillis = 0; // Armazena o ultimo instante de checagem de email
int emailCount = 0; // Armazena a ultima contagem de email

// setup() inicializa o lcd, o SD card, e o Ethernet
// Se bem sucedido, o led de status se ligara.
void setup() 
{
  pinMode(STAT_LED, OUTPUT);
  digitalWrite(STAT_LED, LOW);

  Serial.begin(9600); // Monitor Serial para debug
 
  
  // Declara o numero de linhas e colunas do LCD: 
  lcd.begin(16, 2);
  lcd.print("Emails nao lidos");
  lcd.setCursor(1, 1);

  
  initSDCard();  // Inicializa a classe SD
  
  if (initEthernet() == 1) // Se a Ethernet conectar, acende o LED de status
    digitalWrite(STAT_LED, HIGH);
  else
  { // Se a conexao Ethernet falhar, imprima erro, loop infinito
    //SPIWriteString("----", 4);
    
    lcd.print("Erro de rede");
    lcd.setCursor(1, 1);
    
    while (1)
      ;
  }
}

// loop() checa pelo contador de emails nao lidos a cada emailUpdateRate
// mili segundos. Se o contador mudou, atualiza o display.
void loop() 
{
  // Apenas cheque o email se passou emailUpdateRate ms 
  if (millis() > emailLastMillis + emailUpdateRate)
  {
    emailLastMillis = millis(); // atualiza emailLastMillis
    
    // Obtem o contador de emails nao lidos e armazena em uma variavel temporaria
    int tempCount = getEmailCount(); 
    Serial.print("Voce tem ");
    Serial.print(tempCount);
    Serial.println(" emails nao lidos.");
    if (tempCount != emailCount) // Se e um valor diferente, atualize
    { // Faca isso para evitar piscar o mesmo numero
      emailCount = tempCount; // atualize a variavel emailCount
      lcd.print(emailCount); // imprima o contador de nao lidos
      lcd.setCursor(1, 14);
    }
  }
  
  // Bit de protecao no caso de overrun de millis:
  if (millis() < emailLastMillis)
    emailLastMillis = 0;
}


// getEmailCount executa o script pyMail.py , e le a saida.
// Ira retornar o valor impresso pelo script python.
int getEmailCount()
{
  int digits = 0;
  int temp[10];
  int emailCnt = 0;

  // Envia uma chamada de sistema para executar o script python e rotear a 
  // saida desse script para um arquivo.
  system("python /media/realroot/pyMailCheck.py > /media/realroot/emails");

  File emailsFile = SD.open("emails"); // Abre email para leitura

  // le dos emails ate que se atinja o final ou uma nova linha
  while ((emailsFile.peek() != '\n') && (emailsFile.available()))
    temp[digits++] = emailsFile.read() - 48; // Converte de ASCII para um numero
    
  emailsFile.close(); // fecha o arquivo de email
  system("rm /media/realroot/emails"); // remove o arquivo de emails
  

  // Transforma um numero individual em um inteiro de digito simples
  for (int i=0; i<digits; i++)
    emailCnt += temp[i] * pow(10, digits - 1 - i);
  
  return emailCnt;
}


// initSDCard() inicia a classe SD
void initSDCard()
{
  SD.begin();
}

uint8_t initEthernet()
{
  if (Ethernet.begin(mac) == 0)
    return 0;
  else
    return 1;
}

Ligue o cabo de rede na porta ethernet da placa Galileo e em um roteador com internet e após alguns segundos pode-se verificar a contagem de emails não lidos:

Verificador funcionando

sexta-feira, 9 de agosto de 2013

Configurações 3D utilizando Blender

    O objetivo do post é expôr a minha solução para sobrepor duas cenas diferentes em uma aplicação 3D no Blender. Neste caso a camada inferior é um vídeo já em 3d (lado a lado) e a camada superior é um game que deveria ser adaptado em 3D, para que houvesse um casamento entre os efeitos.

Imagem 1: Vídeo 3D lado a lado e game sobreposto

    Após alguns testes com a aplicação direta do plugin do desenvolvedor noeol, sendo este código sendo usado juntamente com o controle add overlay scene do blender obtive um certo sucesso com a cena do game ficando 3d juntamente com o video. No entando, neste game o cursor colorido atira o projétil para "dentro" da tela, e este efeito estava completamente errado na aplicação que fiz.


Imagem 2: Controles para sobrepor a cena 'game' na cena principal
    A solução do problema foi alcançada com a aplicação de viewports, que dividem a cena verticalmente (ou horizontalmente) de modo que cada câmera que filma o game seja exibida em exatamente metade da tela.

Imagem 3: Blocos lógicos para o viewport


    Para o vídeo usado o viewport foi aplicado com uma divisão vertical, e deste modo, o efeito 3D do game foi alcaçado pois cada visão do game foi colocada em cima da metade do vídeo, de modo que quando uma tv compatível fizer a composição das imagens o game também ficará em 3D.



Imagem 4: Cursores duplicados, compatíveis com o vídeo
 
    O código utilizado para configurar os viewports foi obtido aqui, referente a este vídeo.

sexta-feira, 26 de abril de 2013

Blender + pyserial

Algumas considerações sobre utilizar o Blender + pyserial : 

    Utilizando um arduino UNO a porta serial  utilizada no Ubunto está em /dev/ttyACM0, e para se poder escrever nesta porta temos que executar o seguinte comando:

        
     sudo adduser user dialout

    Este comando adiciona o usuário "user" ao grupo dialout, para se poder escrever na serial.
   
    Em seguida deve-se reiniciar a sessão para a alteração ter efeito.

    O script de comunicação serial a linha deve ficar assim:


           G.SerialPort = serial.Serial('/dev/ttyACM0',9600)

sexta-feira, 12 de abril de 2013

Engine selecionada : Blender


    Apesar do Blender não ter sido um dos programas que inicialmente planejei testar acabei por usar ele pois descobri que seu engine é muito eficiente nos aspectos que desejo implementar, além de ser também muito intuitivo.

 
    Digo que o Blender Game Engine é eficiente não somente pelo fato de incorporar elementos que outras engines possuem, mas por incorporar o python com linguagem de scripting ele amplia as possibilidades de aplicação com o uso de módulos incluídos no python.

Tudo isso foi conseguido com uma instalação muito fácil, e com uma interface muito user-friendly. (Instalei a versão 2.66)
 
    Do post anterior, eu gostaria de uma engine que:

    1. Tivesse possibilidade de tocar video
    2. Possibilitasse uma layer com animaçao (game) sobre o uma layer com um video
    3. Colher posição atual do video
    4. Conseguir enviar comandos para porta serial


    Todos esses requisitos foram alcançados pelo Blender, que juntamente com o python, facilitou a o desenvolvimento do teste que descreverei a seguir.

   A técnica para tocar video é criar uma textura a partir do vídeo desejado que é dinamicamente atualizada a cada frame pelo blender. Desta forma o video é executado, porém sem som.

   O som deve ser tocado em paralelo, sincronizado com o video. Abaixo estão algumas imagens do projeto e o código-fonte está anexo e os controles relacionados para se tocar o video.

   Neste projeto também existe um mini-game que roda em cima(literalmente) do video. Para este teste, segui o tutorial deste video do youtube.
 
O código para o video foi adaptado do código neste site, cujos créditos (aparentemente) vão para Dalai Felinto.

Sensores e controladores do minigame


Sensores e controladores do video e envio de sinais
 
    Um ponto crucial deste teste foia  integração com um hardware externo, comunicando-se por uma porta serial.
    Para isso utilizei o módulo pyserial, que permite uma comunicação descomplicada com a porta serial.

    Inicialmente tive problemas para a instalação deste módulo, uma vez que apesar de ele funcionar com o python 3.3 (python que vem com o Blender 2.66) ele é escrito para um python anterior.

    Para contornar esse problema, instalei o pip para windows deste link e segui o tutorial de instalação do pyserial para o pip, e deu tudo certo.

    Só como observação: você deve ter a versão do python 3.3 instalada no seu sistema para poder gerar o pacote do pyscript que você depois colocará na pasta do python para ser utilizada dentro do  Blender.

    Finalmente, utilizei um arduino mega para poder fazer os testes com a comunicação serial. O código para o arduino pode ser baixado aqui. O arquino em teste foi testado com uma shield com leds e reles.
 

Baixe aqui o arquivo .blend para testar o projeto.


quinta-feira, 28 de março de 2013

Pesquisa de Engine de games

O objetivo da pesquisa é encontrar uma engine que cumpra os seguintes requisitos:
  1. Ter um player de video
  2. Possibilitar uma layer com animaçao sobre o uma layer com um video
  3. Colher posição atual do video
  4. Conseguir enviar comandos para porta serial
Tudo isso de uma forma simples que possa ser reproduzido em outros computadores por qualquer pessoa(sem a necessidade de muitos conhecimentos técnicos).

Neste post descrevo brevemente as experiências que adquiri com cada engine que testei.