Publicidade:

quarta-feira, 25 de março de 2015

Arduino - Dimer para lâmpada com efeito fade in / fade out


No vídeo anterior mostrei como dimerizar mais de uma lâmpada com o Arduino. Nesse vídeo mostro como incluir efeitos de fade in / fade out, ao ligar e desligar a lâmpada.





Esse segundo vídeo, mostrado abaixo, é de um circuito feito a pedido de uma pessoa, com as mesmas funcionalidades mostradas no vídeo anterior, mas já numa PCB, contendo alguns botões e trimpots. Os Trimpots têm a função de regular o tempo de fading de cada uma das lâmpadas.




Imagens da PCB do segundo vídeo.






Código-Fonte (referente ao primeiro vídeo do post):

ATENÇÃO: Esse código está um pouco diferente do mostrado no vídeo. No vídeo é mostrado 2 lâmpadas sendo controladas por 2 Potenciômetros e uma lâmpada pelos dois botões, sendo o terceiro potenciômetro utilizado para controlar o tempo de fade-in / fade-out. O código abaixo foi alterado para que apenas 1 lâmpada fosse ser controlada pelo Potenciômetro e duas pelos Botões. Qualquer dúvida, deixe seus comentários direto no vídeo do Youtube, onde eu respondo mais rapidamente. Valeu.


/*
 Multiplos dimmers com TRIAC.

 exemplo de como dimerizar várias lâmpadas ao mesmo tempo com o Arduino.
 
 dentro da função init_dimmers_01, definir os pinos que serão utilizados
 pelos dimmers, 

 no exemplo abaixo está sendo utilizado para 3 dimmers, através dos pinos
 7, 8 e 9. testes com mais de 3 lampadas não funcionaram no arduino UNO.
 no arduino mega, possivelmente seja possível utilizar mais lampadas
 
 byte pinsDimmers[] = {7, 8, 9};  //mudar aqui para outros, mais ou menos lampadas.
 
 testado apenas com no máximo 3. 
 
 AVISO:
   não há qualquer garantia de funcionamento do uso desse código em qualquer aplicação. 
   o mesmo serve apenas como exemplo e quem deseja utilizá-lo para outros propósitos
   fica inteiramente responsável por qualquer problema ou erro que venha a ter.
 
 boa sorte. 
 

 Criado em 18/03/2015
 Por: 
   Fabiano A. Arndt 
   http://www.youtube.com/fabianoallex
   http://fabianoallex.blogspot.com.br
   fabianoallex@gmail.com

***********************************************************************************
*************************INICIO CLASSE DIMMERS*************************************
***********************************************************************************/

/*
definição do tipo de ponteiro para a funcao a ser recebida como parâmetro do construtor
da classe TriacDimmers que irá ser atachada na interrupção do pino de zero cross.
*/

#define ulong unsigned long
typedef void (*p_triac_dimmers)();  

class TriacDimmers {
  private:
    int  _quantidade;
    int  _pin_interrupt;
    int* _pins;
    int* _values;  
    int* _pos_sorted;

    void _sort() {
      for (int i=0; i<_quantidade; i++) { _pos_sorted[i] = i; }
      for (int i=0; i<_quantidade; i++) {
        for (int j=i+1; j<_quantidade; j++) {
          if (_values[_pos_sorted[i]] < _values[_pos_sorted[j]]) {
            int t = _pos_sorted[i];
            _pos_sorted[i] = _pos_sorted[j];
            _pos_sorted[j] = t;
          }
        }
      }
    }
    
  public:
    //o ultimo parâmetro do construtor, deve ser a função que sera atachada a interrupção
    TriacDimmers(int pin_interrupt, int quantidade, int pins[], p_triac_dimmers funcao_dimmer){  
      _quantidade = quantidade;
      _pins       = new int[_quantidade]; 
      _values     = new int[_quantidade];
      _pos_sorted = new int[_quantidade];
      
      for (int i=0; i<_quantidade; i++){ 
        _pins[i] = pins[i];
        pinMode(_pins[i], OUTPUT);
        _values[i] = 0;
      }
      pinMode(_pin_interrupt, INPUT);
      attachInterrupt(pin_interrupt==2 ? 0 : 1, funcao_dimmer, FALLING);
    }
    
    void set_value(int pos, int value) {
      if (_values[pos] != value){
        noInterrupts();
        _values[pos] = value; 
        _sort();
        interrupts();
      }
    }
    
    void dimmer(){
      int inc_delay=0;
      int p, t, t2;
      for (int i=0; i<_quantidade; i++) { 
        p  = _pos_sorted[i];
        t  = map(_values[p], 0, 100, 7200, 1 ); 
        t2 = t-inc_delay;
        
        if (t2 > 0) { delayMicroseconds(t2); }
        digitalWrite(_pins[p], HIGH);
        
        inc_delay += t2;
      }
      delayMicroseconds(10);
      for (int i=0; i<_quantidade; i++) { digitalWrite(_pins[i], LOW); } 

    }
    int get_quantidade() { return _quantidade; }
};

long fading(long ini, long fim, long time, long millis_ref){
  long t = millis()-millis_ref;
  if ( t>=time || ini==fim || time==0) { return fim; }
  long dif = fim-ini;
  return ini + (t * dif / time);
}

class TriacDimmersFade{
  private:
    TriacDimmers*  _td;
    int            _time_fade;
    long*          _millis_ref;
    boolean*       _is_fading;
    int*           _fade;
    int*           _fade_ref;
    
  public:
    TriacDimmersFade(TriacDimmers* td){
      _td = td;
      _millis_ref = new long[_td->get_quantidade()];
      _is_fading  = new boolean[_td->get_quantidade()];
      _fade       = new int[_td->get_quantidade()];
      _fade_ref   = new int[_td->get_quantidade()];
      
      for (int i=0; i<_td->get_quantidade(); i++){ 
        _millis_ref[i] = 0; 
        _is_fading[i] = false; 
        _fade[i] = 0; 
        _fade_ref[i] = 0; 
      }
    }
    
    void go_to(int pos, int value, int time_fade = 0){
      if (time_fade == 0) { time_fade = _time_fade; }
      _is_fading[pos] = true;
      
      if (_millis_ref[pos] == 0) { _millis_ref[pos] = millis(); }
      long f = fading(_fade_ref[pos], value, time_fade, _millis_ref[pos]);

      
      _fade[pos] = f;
      
      _td->set_value(pos, f); 
    }

    boolean is_fading(int pos){  return _is_fading[pos];  }
    
    void stop(int pos){
       _fade_ref[pos]   = _fade[pos]; 
       _millis_ref[pos] = 0; 
       _is_fading[pos]  = false;           
    }
};

/**********************************************************************************
*****************************FIM CLASSE DIMMERS************************************
***********************************************************************************/

/***********************************************************************************
*************************INICIO CLASSE DIGITAL BUTTONS******************************
***********************************************************************************/

class DigitalButtons {
  private:
    int*  _pinos;
    int  _quantidade;
    ulong _millis;               //armazena quando foi soltado o botao
    int   _ultimo_botao;         //armazena o ultimo botao pressionado
  public:
    DigitalButtons(int quantidade, int pinos[]) {
      _pinos        = new int[quantidade];
      _millis       = 0;
      _ultimo_botao = -1;
      _quantidade   = quantidade;
      
      for(byte i=0;i<quantidade;i++) { 
        pinMode(pinos[i], INPUT); 
        _pinos[i] = pinos[i];
      }
    }
  
    int get_button() {
      int idx = -1;
      for(byte i=0;i<_quantidade;i++) { 
        if ( digitalRead(_pinos[i]) ) { 
          idx     = i; 
          _millis = millis(); 
          break;
        }
      }
      if (idx >= 0) { _ultimo_botao = idx; }
      
      return _ultimo_botao;
    }

    ulong get_millis()          { return _millis;                     }
    ulong get_time_last_button(){ return millis() - get_millis();     }
    int   get_last_button()     { get_button(); return _ultimo_botao; }
};

/***********************************************************************************
*************************FIM CLASSE DIGITAL BUTTONS*********************************
***********************************************************************************/

/**********************************************************************************
*****************************INICIO DECLARAÇÕES DOS OBJETOS DIMMERS E BUTTONS******
***********************************************************************************/

/*cada ponteiro declarado para a classe TriacDimmers deve ter uma funcao correspondente 
a ser anexada (attachInterrupt). Essa função deve ser passada como parâmetro do construtor
da classe TriacDimmers. 

Caso outras instancias da classe TriacDimmers sejam criadas, 
devem ser criadas também, outras funções para serem passadas como parâmetros do construtor.*/

//ponteiro para o objeto que irá gerenciar os dimmers
TriacDimmers *triacDimmers_01;  
TriacDimmersFade *triacDimmersFade_01;

const int time_fade_min = 200;
const int time_fade_max = 5000;

//função a ser atachada na interrupção, passada como parametro no construtor de TriacDimmers
void triac_dimmers_01() { 
  triacDimmers_01->dimmer(); 
} 

//função acessória, apenas para facilitar a inicialização do objeto.
void init_dimmers_01(){
  int pinsDimmers[] = {7,8,9};  //configure aqui os pinos de saída para os triacs.
  int pinInterrupt  = 2;          //configure aqui o pino para detectar a interrupção.
  triacDimmers_01 = new TriacDimmers(
                           pinInterrupt, 
                           sizeof(pinsDimmers)/sizeof(int), 
                           pinsDimmers, 
                           triac_dimmers_01
                         ); 
                         
  triacDimmersFade_01 = new TriacDimmersFade(triacDimmers_01);  //Objeto que irá gerenciar o fadeon e fadeoff das lampadas
}

DigitalButtons *buttons_01;
DigitalButtons *buttons_02;

int button_01 = 0;
int button_02 = 0;

void init_buttons(){
  int pins_buttons_01[] = {4, 3};  //pinos para os botões da lampada 1
  buttons_01 = new DigitalButtons(sizeof(pins_buttons_01)/sizeof(int), pins_buttons_01);
  
  int pins_buttons_02[] = {6, 5}; //pinos para os botões da lampada 2
  buttons_02 = new DigitalButtons(sizeof(pins_buttons_02)/sizeof(int), pins_buttons_02);
}

void exec_lampada_pos_0(){
  if (!triacDimmersFade_01->is_fading(0)){
    button_01 = buttons_01->get_last_button()+1;
  }
  
  long m  = buttons_01->get_time_last_button();     //a quanto tempo foi pressionado o ultimo botao 
  
  int time_fade = map(analogRead(A0), 0, 1023, time_fade_min, time_fade_max );
  
  if (m>=0 && m<=(time_fade+100) && button_01>0 ) {
    if (button_01 == 1) { triacDimmersFade_01->go_to(0, 000, time_fade); }  //desliga
    if (button_01 == 2) { triacDimmersFade_01->go_to(0, 100, time_fade); }  //liga
  } else {
    triacDimmersFade_01->stop(0);
  }
}

void exec_lampada_pos_1(){ 
  if (!triacDimmersFade_01->is_fading(1)){
    button_02 = buttons_02->get_last_button()+1;
  }
  
  long m  = buttons_02->get_time_last_button();     //a quanto tempo foi pressionado o ultimo botao 
  
  int time_fade = map(analogRead(A1), 0, 1023, time_fade_min, time_fade_max ); 
  
  if (m>=0 && m<=(time_fade+100) && button_02>0 ) {
    if (button_02 == 1) { triacDimmersFade_01->go_to(1, 000, time_fade); }  //desliga
    if (button_02 == 2) { triacDimmersFade_01->go_to(1, 100, time_fade); }  //liga
  } else {
    triacDimmersFade_01->stop(1);
  }
}

void exec_lampada_pos_2(){ triacDimmers_01->set_value(2,map(analogRead(A2), 0, 1023, 0, 100 )); } //lampada controlado por potenciometro

/**********************************************************************************
*****************************FIM DECLARAÇÕES DOS OBJETOS DIMMERS E BUTTONS******
***********************************************************************************/

/**********************************************************************************
*****************************SETUP E LOOP******************************************
***********************************************************************************/

void setup() {
  Serial.begin(9600);
  init_dimmers_01();  //instancia o objeto que irá gerenciar os dimmers
  init_buttons();
}

void loop() {  
  exec_lampada_pos_0();
  exec_lampada_pos_1();
  exec_lampada_pos_2();
}

/**********************************************************************************
*****************************FIM SETUP E LOOP**************************************
***********************************************************************************/

segunda-feira, 23 de março de 2015

Arduino - Dimmer com mais de uma lâmpada - TIC226D, MOC3010, 4N25

Nesse vídeo mostro como dimerizar mais de uma lâmpada ao mesmo tempo, utilizando TRIAC TIC226D e MOC3010. Para a detecção do zero (Zero Cross) da Corrente AC, utilizo dois 4N25.





Para entender o funcionamento do circuito, vou recomendar que vejam dois vídeos do Jair Júnior que explica muito bem o funcionamento do circuito e dos componentes utilizados:





Código-Fonte:
/*
 Multiplos dimmers com TRIAC.

 exemplo de como dimerizar várias lâmpadas ao mesmo tempo com o Arduino.
 
 dentro da função init_dimmers_01, definir os pinos que serão utilizados
 pelos dimmers, 

 no exemplo abaixo está sendo utilizado para 3 dimmers, através dos pinos
 7, 8 e 9. testes com mais de 3 lampadas não funcionaram no arduino UNO.
 no arduino mega, possivelmente seja possível utilizar mais lampadas
 
 byte pinsDimmers[] = {7, 8, 9};  //mudar aqui para outros, mais ou menos lampadas.
 
 testado apenas com no máximo 3. 
 
 AVISO:
   não há qualquer garantia de funcionamento do uso desse código em qualquer aplicação. 
   o mesmo serve apenas como exemplo e quem deseja utilizá-lo para outros propósitos
   fica inteiramente responsável por qualquer problema ou erro que venha a ter.
 
 boa sorte. 
 

 Criado em 23/03/2015
 Por: 
   Fabiano A. Arndt 
   http://www.youtube.com/fabianoallex
   http://fabianoallex.blogspot.com.br
   fabianoallex@gmail.com

***********************************************************************************
*************************INICIO CLASSE DIMMERS*************************************
***********************************************************************************/

/*
definição do tipo de ponteiro para a funcao a ser recebida como parâmetro do construtor
da classe TriacDimmers que irá ser atachada na interrupção do pino de zero cross.
*/
typedef void (*p_triac_dimmers)();  

class TriacDimmers {
  private:
    int  _quantidade;
    int  _pin_interrupt;
    int* _pins;
    int* _values;  
    int* _pos_sorted;
    

    void _sort() {
      for (int i=0; i<_quantidade; i++) { _pos_sorted[i] = i; }
      for (int i=0; i<_quantidade; i++) {
        for (int j=i+1; j<_quantidade; j++) {
          if (_values[_pos_sorted[i]] < _values[_pos_sorted[j]]) {
            int t = _pos_sorted[i];
            _pos_sorted[i] = _pos_sorted[j];
            _pos_sorted[j] = t;
          }
        }
      }
    }
    
  public:
    //o ultimo parâmetro do construtor, deve ser a função que sera atachada a interrupção
    TriacDimmers(int pin_interrupt, int quantidade, int pins[], p_triac_dimmers funcao_dimmer){  
      _quantidade = quantidade;
      _pins       = new int[_quantidade]; 
      _values     = new int[_quantidade];
      _pos_sorted = new int[_quantidade];
      
      for (int i=0; i<_quantidade; i++){ 
        _pins[i] = pins[i];
        pinMode(_pins[i], OUTPUT);
        _values[i] = 0;
      }
      _sort();
      pinMode(_pin_interrupt, INPUT);
      attachInterrupt(pin_interrupt==2 ? 0 : 1, funcao_dimmer, FALLING);
    }
    
    void set_value(int pos, int value) {
      if (_values[pos] != value){
        noInterrupts();
        _values[pos] = value; 
        _sort();
        interrupts();
      }
    }
    
    void dimmer(){
      int inc_delay=0;
      int p, t, t2;
      for (int i=0; i<_quantidade; i++) { 
        p  = _pos_sorted[i];
        t  = map(_values[p], 0, 100, 7200, 1 ); 
        t2 = t-inc_delay;
        
        if (t2 > 0) { delayMicroseconds(t2); }
        digitalWrite(_pins[p], HIGH);
        
        inc_delay += t2;
        //if (inc_delay >= 7200) { break; }
      }
      
      delayMicroseconds(10);
      for (int i=0; i<_quantidade; i++) { digitalWrite(_pins[i], LOW); } 

    }
    int get_quantidade() { return _quantidade; }
};



/**********************************************************************************
*****************************FIM CLASSE DIMMERS************************************
***********************************************************************************/

/**********************************************************************************
*****************************INICIO DECLARAÇÕES DOS OBJETOS DIMMERS****************
***********************************************************************************/

/*cada ponteiro declarado para a classe TriacDimmers deve ter uma funcao correspondente 
a ser anexada (attachInterrupt). Essa função deve ser passada como parâmetro do construtor
da classe TriacDimmers. 

Caso outras instancias da classe TriacDimmers sejam criadas, 
devem ser criadas também, outras funções para serem passadas como parâmetros do construtor.*/

//ponteiro para o objeto que irá gerenciar os dimmers
TriacDimmers *triacDimmers_01;  

//função a ser atachada na interrupção, passada como parametro no construtor de TriacDimmers
void triac_dimmers_01() { 
  triacDimmers_01->dimmer(); 
} 

//função acessória, apenas para facilitar a inicialização do objeto.
void init_dimmers_01(){
  int pinsDimmers[] = {7,8,9};  //configure aqui os pinos de saída para os triacs.
  int pinInterrupt  = 2;          //configure aqui o pino para detectar a interrupção.
  triacDimmers_01 = new TriacDimmers(
                           pinInterrupt, 
                           sizeof(pinsDimmers)/sizeof(int), 
                           pinsDimmers, 
                           triac_dimmers_01
                         ); 
}

/**********************************************************************************
*****************************FIM DECLARAÇÕES DOS OBJETOS DIMMERS****************
***********************************************************************************/

/**********************************************************************************
*****************************SETUP E LOOP******************************************
***********************************************************************************/

void setup() {
  init_dimmers_01();  //instancia o objeto que irá gerenciar os dimmers
}

void loop() {  
  triacDimmers_01->set_value(0,map(analogRead(A0), 0, 1023, 0, 100 ) );
  triacDimmers_01->set_value(1,map(analogRead(A1), 0, 1023, 0, 100 ) );
  triacDimmers_01->set_value(2,map(analogRead(A2), 0, 1023, 0, 100 ) );
  
  delay(50);
}

/**********************************************************************************
*****************************FIM SETUP E LOOP**************************************
***********************************************************************************/

sexta-feira, 20 de março de 2015

Arduino - Autenticação HTTP com logoff

Esse vídeo é uma continuação do vídeo anterior, que mostra como fazer login no Ethernet Shield. Dessa vez, com a opção de fazer logoff.





ATENÇÃO - Correção da função de logoff para firefox e IE. (16/06/2015).


quando implementei a função de logoff, não fiz os testes adequadamente no Firefox e no IE e acabou que a função funcionou apenas para o Chrome. 

Fiz as devidas correções e agora está funcionando corretamente (pelo menos nos testes que fiz com Firefox e IE)

o código corrigido ficou assim:


void html_logoff(EthernetClient &client){
    client.print(F(
                 "HTTP/1.1 401 Authorization Required\n"  
                 "Content-Type: text/html\n"  
                 "Connnection: close\n\n"  
                 "<!DOCTYPE HTML>\n"  
                 "<html><head><title>Logoff</title>\n"  
                 "<script>document.execCommand('ClearAuthenticationCache', 'false');</script>"  //IE logoff
                 "<script>try {"                                                                //mozila logoff
                 "   var agt=navigator.userAgent.toLowerCase();"
                 "   if (agt.indexOf(\"msie\") != -1) { document.execCommand(\"ClearAuthenticationCache\"); }"
                 "   else {"
                 "     var xmlhttp = createXMLObject();"
                 "      xmlhttp.open(\"GET\",\"URL\",true,\"logout\",\"logout\");"
                 "     xmlhttp.send(\"\");"
                 "     xmlhttp.abort();"
                 "   }"
                 " } catch(e) {"
                 "   alert(\"erro ao fazer logoff\");"
                 " }"
                 "function createXMLObject() {"
                 "  try {if (window.XMLHttpRequest) {xmlhttp = new XMLHttpRequest();} else if (window.ActiveXObject) {xmlhttp=new ActiveXObject(\"Microsoft.XMLHTTP\");}} catch (e) {xmlhttp=false;}"
                 "  return xmlhttp;"
                 "}</script>"
                 "</head><body><h1>Voce nao esta mais conectado</h1></body></html>\n"));
}


Código completo Corrigido;

/*
 Web Server - HTTP Autentication
 Baseado na versão de exemplo do Arduino.
 
 ATENÇÃO: esse código é apenas para exemplo e não deve ser encarado como solução 
 completa para segurança de informações de qualquer aplicação.
 
 modified 25 feb 2015
 by Fabiano A. Arndt (fabianoallex)
*/
/*
 descrição Original:
 
 Web Server

 A simple web server that shows the value of the analog input pins.
 using an Arduino Wiznet Ethernet shield.

 Circuit:
 * Ethernet shield attached to pins 10, 11, 12, 13
 * Analog inputs attached to pins A0 through A5 (optional)

 created 18 Dec 2009
 by David A. Mellis
 
 modified 9 Apr 2012
 by Tom Igoe
 
*/

/**********************************************************************************
************************************BIBLIOTECAS************************************
**********************************************************************************/

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

/**********************************************************************************
********************************FIM BIBLIOTECAS************************************
**********************************************************************************/

/**********************************************************************************
*************************ROTINAS USUARIO E SENHA***********************************
***********************************************************************************/

boolean validar_usuario(char * linebuf) {
  /*
  nesse exemplo o usuario e senha estão definidos dentro do código fonte.
  mas o usuário e senha poderiam ser autenticados de diversas maneiras,
  lendo os dados de um servidor web, arquivo texto, etc, bastando apenas atribuir
  o valor lido para a variável usuario_senha. 
  */
  
  char usuario_senha[] = "admin:admin";
  int t = strlen(usuario_senha);
  
  int tamanhoEnc = (((t-1) / 3) + 1) * 4;   //tamanho da string codificada
  char out[tamanhoEnc];
  base64_encode(out, usuario_senha, t+1 );
  
  //---desconta é usado pra eliminar os caracteres '='
  int desconta = 0;
  if ((t%3) == 1) { desconta = 2; }
  if ((t%3) == 2) { desconta = 1; }
  
  char out2[tamanhoEnc-desconta];
  
  byte i;
  for (i=0; i<(tamanhoEnc-desconta);i++){ out2[i] = out[i]; }
  out2[i] = '\0';
  
  return ( strstr(linebuf, out2)>0 );
}

/**********************************************************************************
*************************FIM ROTINA USUARIO E SENHA********************************
***********************************************************************************/

/**********************************************************************************
***********************************PAGINAS HTML************************************
***********************************************************************************/
EthernetServer * server;

void iniciar_ethernet(){
  byte ip[4]      = {192,168,200,188};
  //byte gateway[4] = {192,168,200,254};
  //byte subnet[4]  = {255,255,255,0};
  byte mac[6]     = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
  int  porta      = 80;

  server = new EthernetServer(porta);

  //Ethernet.begin(mac, ip, gateway, subnet);         //caso necessario gateway utilizar essa linha
  Ethernet.begin(mac, ip);
  server->begin();
}

void html_logoff(EthernetClient &client){
    client.print(F(
                 "HTTP/1.1 401 Authorization Required\n"  
                 "Content-Type: text/html\n"  
                 "Connnection: close\n\n"  
                 "<!DOCTYPE HTML>\n"  
                 "<html><head><title>Logoff</title>\n"  
                 "<script>document.execCommand('ClearAuthenticationCache', 'false');</script>"  //IE logoff
                 "<script>try {"                                                                //mozila logoff
                 "   var agt=navigator.userAgent.toLowerCase();"
                 "   if (agt.indexOf(\"msie\") != -1) { document.execCommand(\"ClearAuthenticationCache\"); }"
                 "   else {"
                 "     var xmlhttp = createXMLObject();"
                 "      xmlhttp.open(\"GET\",\"URL\",true,\"logout\",\"logout\");"
                 "     xmlhttp.send(\"\");"
                 "     xmlhttp.abort();"
                 "   }"
                 " } catch(e) {"
                 "   alert(\"erro ao fazer logoff\");"
                 " }"
                 "function createXMLObject() {"
                 "  try {if (window.XMLHttpRequest) {xmlhttp = new XMLHttpRequest();} else if (window.ActiveXObject) {xmlhttp=new ActiveXObject(\"Microsoft.XMLHTTP\");}} catch (e) {xmlhttp=false;}"
                 "  return xmlhttp;"
                 "}</script>"
                 "</head><body><h1>Voce nao esta mais conectado</h1></body></html>\n"));
}
void html_autenticar(EthernetClient &client) {
  client.print(F("HTTP/1.1 401 Authorization Required\n"  
               "WWW-Authenticate: Basic realm=\"Area Restrita\"\n"  
               "Content-Type: text/html\n"  
               "Connnection: close\n\n"  
               "<!DOCTYPE HTML>\n"  
               "<html><head><title>Error</title>\n"  
               "</head><body><h1>401 Acesso nao autorizado</h1></body></html>\n"));
}

void html_autenticado(EthernetClient &client){
  client.println(F("HTTP/1.1 200 OK\n"
                   "Content-Type: text/html\n"
                   "Connection: keep-alive\n\n"
                   "<!DOCTYPE HTML>"
                   "<html>"));

  for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
    int sensorReading = analogRead(analogChannel);
    client.print(F("analog input "));
    client.print(analogChannel);
    client.print(F(" is "));
    client.print(sensorReading);
    client.println(F("<br>"));
  }
  client.println(F("<br><a href='/logoff'>Logoff</a></html>"));
}



void exec_ethernet(){
  EthernetClient client = server->available();
  if (client) {
    char linebuf[80];
    memset(linebuf, 0, sizeof(linebuf));
    
    int     charCount          = 0;
    boolean autenticado        = false;
    boolean currentLineIsBlank = true;
    boolean logoff             = false;
    
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        
        linebuf[charCount] = c;
        
        if (charCount<sizeof(linebuf)-1) { charCount++; }
        Serial.write(c);
        
        if (c == '\n' && currentLineIsBlank) {
          if (autenticado && !logoff ){
            html_autenticado(client);
          } else {
            logoff ? html_logoff(client) : html_autenticar(client);
          }
          break;
        }
        if (c == '\n') { 
          currentLineIsBlank = true;               
          
          if (strstr(linebuf, "GET /logoff"         )>0 ) { logoff = true; }
          if (strstr(linebuf, "Authorization: Basic")>0 ) { if ( validar_usuario(linebuf) )   {  autenticado = true;   } }  
          
          
          memset(linebuf, 0, sizeof(linebuf));
          charCount = 0;
        } else if (c != '\r') {
          currentLineIsBlank = false;    // you've gotten a character on the current line
        }
      }
    }
    
    delay(1);           // give the web browser time to receive the data
    client.stop();      // close the connection:
  }
}
/**********************************************************************************
**************************************** FIM PAGINAS HTML**************************
***********************************************************************************/


/**********************************************************************************
*************************BASE 64 CODE/DECODE DO USUARIO E SENHA********************
***********************************************************************************/

void a3_to_a4(unsigned char * a4, unsigned char * a3);
void a4_to_a3(unsigned char * a3, unsigned char * a4);
unsigned char b64_lookup(char c);

int base64_encode(char *output, char *input, int inputLen) {
  const char b64_alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  int i=0, j=0, encLen=0;
  unsigned char a3[3], a4[4];

  while(inputLen--) {
    a3[i++] = *(input++);
    if(i == 3) {
      a3_to_a4(a4, a3);
      for(i=0; i<4; i++) { output[encLen++] = b64_alphabet[a4[i]]; }
      i = 0;
    }
  }

  if (i) {
    for(j = i; j < 3; j++)     { a3[j] = '\0';                           }
    a3_to_a4(a4, a3);
    for(j = 0; j < i + 1; j++) { output[encLen++] = b64_alphabet[a4[j]]; }
    while((i++ < 3))           { output[encLen++] = '=';                 }
  }
  output[encLen] = '\0';
  return encLen;
}

/*
int base64_decode(char * output, char * input, int inputLen) {
  int i = 0, j = 0;
  int decLen = 0;
  unsigned char a3[3];
  unsigned char a4[4];
  while (inputLen--) {
    if (*input == '=') { break; }
    a4[i++] = *(input++);
    if (i == 4) {
      for (i = 0; i <4; i++)  { a4[i] = b64_lookup(a4[i]); }
      a4_to_a3(a3,a4);
      for (i = 0; i < 3; i++) { output[decLen++] = a3[i];  }
      i = 0;
    }
  }

  if (i) {
    for (j=i; j<4; j++)   { a4[j] = '\0';             }
    for (j=0; j<4; j++)   { a4[j] = b64_lookup(a4[j]);}
    a4_to_a3(a3,a4);
    for (j=0; j<i-1; j++) { output[decLen++] = a3[j]; }
  }
  output[decLen] = '\0';
  return decLen;
}
*/

//int base64_enc_len(int plainLen) {
//  int n = plainLen;
//  return (n + 2 - ((n + 2) % 3)) / 3 * 4;
//}

//int base64_dec_len(char * input, int inputLen) {
//  int i = 0;
//  int numEq = 0;
//  for(i = inputLen - 1; input[i] == '='; i--) { numEq++; }
//  return ((6 * inputLen) / 8) - numEq;
//}

void a3_to_a4(unsigned char * a4, unsigned char * a3) {
  a4[0] = (a3[0]  & 0xfc) >> 2;
  a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
  a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
  a4[3] = (a3[2] & 0x3f);
}

//void a4_to_a3(unsigned char * a3, unsigned char * a4) {
//  a3[0] = (a4[0] << 2) + ((a4[1] & 0x30) >> 4);
//  a3[1] = ((a4[1] & 0xf) << 4) + ((a4[2] & 0x3c) >> 2);
//  a3[2] = ((a4[2] & 0x3) << 6) + a4[3];
//}

unsigned char b64_lookup(char c) {
  if(c >='A' && c <='Z') return c - 'A';
  if(c >='a' && c <='z') return c - 71;
  if(c >='0' && c <='9') return c + 4;
  if(c == '+') return 62;
  if(c == '/') return 63;
  return -1;
}

/**********************************************************************************
*************************FIM BASE 64 CODE/DECODE DO USUARIO E SENHA****************
***********************************************************************************/



/**********************************************************************************
**************************************** VOID / LOOP ******************************
***********************************************************************************/

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

void loop() {
  exec_ethernet();
}

/**********************************************************************************
*************************************FIM VOID / LOOP*******************************
***********************************************************************************/