Log de Aprendizado: galileo

Mostrando postagens com marcador galileo. Mostrar todas as postagens

terça-feira, 12 de agosto de 2014

Projeto Web Service - Continuação

Faremos agora uma página mais complexa que a anterior, e alteraremos um pouco o código.

Primeiramente retire o cartão de memória da Galileo com ela desligada, e coloque a seguinte página html na raiz do cartão.

<!DOCTYPE html>
<html lang="pt-br">
  <head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">
    <link id="page_favicon" href="http://osx.wdfiles.com/local--files/icon:arduino-icon-small/arduino-icon-small.png" rel="icon" type="image/x-icon" />

    <title>Galileo na web!</title>

    <!-- Bootstrap core CSS -->
    <link href="http://getbootstrap.com/dist/css/bootstrap.min.css" rel="stylesheet">
    <!-- Bootstrap theme -->
    <link href="http://getbootstrap.com/dist/css/bootstrap-theme.min.css" rel="stylesheet">

    <!-- Custom styles for this template -->
    <link href="http://getbootstrap.com/examples/theme/theme.css" rel="stylesheet">

    <!-- Just for debugging purposes. Don't actually copy these 2 lines! -->
    <!--[if lt IE 9]><script src="../../assets/js/ie8-responsive-file-warning.js"></script><![endif]-->
    <script src="http://getbootstrap.com/assets/js/ie-emulation-modes-warning.js"></script>

    <!-- IE10 viewport hack for Surface/desktop Windows 8 bug -->
    <script src="http://getbootstrap.com/assets/js/ie10-viewport-bug-workaround.js"></script>

    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
      <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
      <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
    <![endif]-->
  </head>

  <body role="document">

    <!-- Fixed navbar -->
    <div class="navbar navbar-inverse navbar-fixed-top" role="navigation">
      <div class="container">
        <div class="navbar-header">
          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a class="navbar-brand" href="#">Galileo web</a>
        </div>
        <div class="navbar-collapse collapse">
          <ul class="nav navbar-nav">
            <li><a href="http://www.intel.com/content/www/us/en/embedded/products/galileo/galileo-overview.html" target="_blank">Galileo</a></li>
            <li><a href="arduino.cc" target="_blank">Arduino</a></li>
            <li><a href="http://www.intel.com.br/content/www/br/pt/homepage.html" target="_blank" >Intel</a></li>
            <li><a href="http://sistemas-producao.net/inovalab/" target="_blank">Inovalab</a></li>
            </li>
          </ul>
        </div><!--/.nav-collapse -->
      </div>
    </div>

    <div class="container theme-showcase" role="main">

      <!-- Main jumbotron for a primary marketing message or call to action -->
      <div class="jumbotron" align="center">
        <h1>Galileo na web!</h1>
        <p>Conheça o portal de projetos Inova Makers, e submeta seus projetos! </p>
        <p><center><a href="http://inovamakers.febrace.org.br/" class="btn btn-primary btn-lg" role="button">Veja mais</a></center></p>
      </div>


      <center>
      <div class="page-header">
        <h1>Acesso aos leds</h1>
      </div>
      <p>Clique em um botão e veja o efeito na placa! </p>
      <p>
        <button type="button" class="btn btn-lg btn-warning" onmousedown=location.href='?LED1;'>Led 1</button>
        <button type="button" class="btn btn-lg btn-success" onmousedown=location.href='?LED2;'>Led 2</button>
        <button type="button" class="btn btn-lg btn-primary" onmousedown=location.href='?LED3;'>Led 3</button>
        <button type="button" class="btn btn-lg btn-danger" onmousedown=location.href='?LED4;'>Led 13</button>
        
      </p>
      <center>
    </div> <!-- /container -->


    <!-- Bootstrap core JavaScript
    ================================================== -->
    <!-- Placed at the end of the document so the pages load faster -->
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
    <script src="../../dist/js/bootstrap.min.js"></script>
    <script src="../../assets/js/docs.min.js"></script>
  </body>
</html>

Nomeie o arquivo para index.htm, e recoloque o cartão na Galileo e ligue-a de acordo com o indicado anteriormente.

Abra a IDE e faça upload do código abaixo:

#include <SPI.h>
#include <Ethernet.h>
#include <SD.h>


// MAC address utilizado
byte mac[] = {0x6A, 0x11, 0x1l, 0x30, 0x12, 0x34};
EthernetServer server = EthernetServer(80); //servidor na porta 80

String readString; 

File webFile;

int led_state[4];


void setup()
{   
    int i;
    Serial.begin(9600);       
    
    pinMode(8, OUTPUT);
    pinMode(9, OUTPUT);
    pinMode(10, OUTPUT);
    pinMode(13, OUTPUT);
    
    for(i=0;i<4;i++)
      led_state[i] = 0;
    
    Ethernet.begin(mac);

    server.begin();
    
    Serial.println(Ethernet.localIP());

    initSDCard();
    
    // check for index.htm file
    if (!SD.exists("index.htm")) {
        Serial.println("ERRO - Nao foi possivel encontraro arquivo index.htm .");
        return;  // nao achou o arquivo
    }
    Serial.println("SUCESSO - Arquivo index.htm encontrado.");
}

void loop()
{
    EthernetClient client = server.available();  // verifica se tem cliente
    
    if (client) {  // se tiver cliente
        boolean currentLineIsBlank = true;
        while (client.connected()) {
            if (client.available()) {   // dados do cliente para ler
                char c = client.read(); // le um byte do cliente
                
                //read char by char HTTP request
                while (readString.length() < 100) {
                  char c = client.read();
                  //store characters to string 
                  readString += c; 
                  //Serial.print(c);
                  if(c == '\n' )
                    break;
                } 
                
                 //controle no led 1  (pino 2)
                if(readString.indexOf("LED1") >= 0 ){
                  if (led_state[0] == 0){
                    digitalWrite(8, HIGH);    
                    Serial.println("Led 1 On");
                    led_state[0] = 1;
                  }
                  else{
                    digitalWrite(8, LOW); 
                    Serial.println("Led 1 Off");
                    led_state[0] = 0;
                  }
                    readString = "";
                }
                
                //controle no led 2  (pino 3)
                if(readString.indexOf("LED2") >= 0 ){
                  if(led_state[1] == 0){
                    digitalWrite(9, HIGH);    
                    Serial.println("Led 2 On");
                    led_state[1] = 1;
                  }
                  else{
                    digitalWrite(9, LOW); 
                    Serial.println("Led 2 Off");
                    led_state[1] = 0;
                  }
                  readString = "";
                }
                
                //controle no led 3  (pino 4)
                if(readString.indexOf("LED3") >= 0 ){
                  if(led_state[2] == 0){
                    digitalWrite(10, HIGH);    
                    Serial.println("Led 3 On");
                    led_state[2] = 1;
                  }
                  else{
                    digitalWrite(10, LOW); 
                    Serial.println("Led 3 Off");
                    led_state[2] = 0;
                  }
                  readString = "";
                }
                
                //controle no led 13  (pino 13)
                if(readString.indexOf("LED4") >= 0 ){
                  if(led_state[3] == 0){
                    digitalWrite(13, HIGH);    
                    Serial.println("Led 13 On");
                    led_state[3] = 1;
                  }
                  else{
                    digitalWrite(13, LOW); 
                    Serial.println("Led 13 Off");
                    led_state[3] = 0;
                  }
                  readString = ""; 
                }

                
                if (c == '\n' && currentLineIsBlank) {
                  // http response header padrao
                  client.println("HTTP/1.1 200 OK");
                  client.println("Content-Type: text/html ; charset=utf-8");
                  client.println("Connection: close");
                  client.println();
                  // envia a web page
                  webFile = SD.open("index.htm");        // abre o arquivo da pagina
                  if (webFile) {
                      while(webFile.available()) {
                          client.write(webFile.read()); // envia a pagina pro cliente
                      }
                      webFile.close();
                  }
                  break;
                } 
                 
  
                if (c == '\n') {
                  currentLineIsBlank = true;
                }
                else if (c != '\r') {
                  currentLineIsBlank = false;
                }
            } 
        } 
        readString="";
        delay(1); // tempo para o browser receber os dados
        client.stop(); // fecha a conexão
               
    } 
}


void initSDCard()
{
    Serial.println("Inicializando SD card...");
    if (!SD.begin()) {
        Serial.println("ERRO - Inicializacao do SD card falhou!");
        return;    // init failed
    }
    Serial.println("SUCESSO - SD card inicializado.");
}

No final do upload, abra rapidamente o Serial Monitor para descobrir o ip atribuído à Galileo. Cole este endereço na barra de endereços do browser e aperte enter, a seguinte página deverá ser apresentada:

Nova interface web

quarta-feira, 6 de agosto de 2014

Controle de leds pela rede

Neste tutorial (adaptado daqui) teremos como resultado um servidor web que permitirá o acionamento de leds ligados à Galileo a partir de qualquer web browser cuja máquina esteja ligada na mesma rede que a placa.

Utilizaremos 3 leds coloridos e 3 resistores de 220Ω, que deverão ser ligados como na Figura 1 abaixo.

Figura 1. Ligação do circuito para o webservice

O código abaixo deverá ser colocado na Galileo, sempre lembrando-se dos procedimentos básicos: ligar a Galileo na energia antes de liga-la na USB do computador.

#include <Ethernet.h>
#include <SPI.h>

boolean reading = false;
String readString; 

// um http request termina com uma linha em branco
boolean currentLineIsBlank = true;
boolean sentHeader = false;


////////////////////////////////////////////////////////////////////////
//CONFIGURACAO
////////////////////////////////////////////////////////////////////////
  //byte ip[] = { 192, 168, 0, 199 };   //Para setup manual
  //byte gateway[] = { 192, 168, 0, 1 }; //Para setup manual
  //byte subnet[] = { 255, 255, 255, 0 }; //Para setup manual

  // Caso precise alterar o MAC address
  byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
  
  EthernetServer server = EthernetServer(80); //port 80
////////////////////////////////////////////////////////////////////////

void setup(){
  Serial.begin(9600);

  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(13, OUTPUT);

  Ethernet.begin(mac);

  server.begin();
  Serial.println(Ethernet.localIP());
  
}

void loop(){

  // escuta chegada de clientes e requests
  checkForClient();


}

void printPage(EthernetClient client){

  client.println("<!DOCTYPE html>");
    client.println("<h1>Galileo na web!</h1>");
    client.println("<p>Página web para acender os leds da Galileo.</p>");
    client.println("<p>Selecione o led que deseja acender:</p>");
    client.println("<input type=button value=LED1 onmousedown=location.href='/?LED1;'>");
    client.println("<input type=button value=LED2 onmousedown=location.href='/?LED2;'>");
    client.println("<input type=button value=LED3 onmousedown=location.href='/?LED3;'>");
    client.println("<input type=button value=LED13 onmousedown=location.href='/?LED4;'>");
    client.println("</body>");
    client.println("</html>");
    client.println();

}
void sendHeader(EthernetClient client, char *title)
{
  // envia o http response header padrao
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html ; charset=UTF-8");
  client.println ("Connection: close");
  client.println();
  client.print("<html><head><title>");
  client.print(title);
  client.println("</title><body>");
}

void checkForClient(){
  EthernetClient client = server.available();
  int pin = 0;
  if (client) {

    while (client.connected()) {
      if (client.available()) {
        char c = client.read();

        //read char by char HTTP request
        while (readString.length() < 100) {
          char c = client.read();
          //store characters to string 
          readString += c; 
          //Serial.print(c);
          if(c == '\n' )
            break;
        } 

      
                     
          if(!sentHeader) {
               sendHeader(client,"Web Page Galileo");
               printPage(client);
               sentHeader = true;  
           }
           
           
           //controle no led 1  (pino 2)
          if(readString.indexOf("LED1") >= 0 ){
            digitalWrite(2, HIGH);    
            Serial.println("Led 1 On");
            delay(3000);
            digitalWrite(2, LOW); 
            readString = "";
          }
          
          //controle no led 2  (pino 3)
          if(readString.indexOf("LED2") >= 0 ){
            digitalWrite(3, HIGH);    
            Serial.println("Led 2 On");
            delay(3000);
            digitalWrite(3, LOW); 
            readString = "";
          }
          
          //controle no led 3  (pino 4)
          if(readString.indexOf("LED3") >= 0 ){
            digitalWrite(4, HIGH);    
            Serial.println("Led 3 On");
            delay(3000);
            digitalWrite(4, LOW); 
            readString = "";
          }
          
          //controle no led 13  (pino 13)
          if(readString.indexOf("LED4") >= 0 ){
            digitalWrite(13, HIGH);    
            Serial.println("Led 13 On");
            delay(3000);
            digitalWrite(13, LOW);
            readString = ""; 
          }
          
          
        
        if (c == '\n' && currentLineIsBlank)  
          break;

        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
     
      }
      
    }
    
    readString="";
    sentHeader = false;
    delay(1); // tempo para o browser receber os dados
    client.stop(); // fecha a conexão
    
    digitalWrite(13, LOW); 
    
  } 

}

Abra o Serial Monitor assim que o upload for feito para que você possa saber em qual ip o a Galileo estará servindo a pagina de controle de leds.

De posse do ip apresentado, digite-o na barra de endereços do seu browser e aperte “Enter”. A seguinte janela será exibida :

Figura 2. Tela da página de controle de leds

Ainda com o Serial Monitor aberto verifique que ao pressionar um dos botões da interface o respectivo led é aceso na placa e também é mostrada uma mensagem no monitor que este led foi aceso.

Figura 3. Teste do webservice

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