domingo, 20 de março de 2011

Automação residencial com celular usando Arduino Mega

Já pensou em controlar sua casa por celular ou telefone fixo com um sistema criado por você mesmo? Sim é possível! Nesse post vamos fazer um sistema de automação residencial com celular usando o Arduino Mega e alguns componentes. Nesse exemplo iremos controlar a lâmpada de um quarto.

Por se tratar de um projeto educacional não utilizarei recursos de prototipagem, embora esse projeto possa ser remodelado para fins comerciais :-)

Com o projeto apresentado você terá base para construir um sistema multifuncional, ou seja, você pode controlar as luzes dos cômodos, portão automático, alarme, bomba d'água e, até simular sua presença caso não haja ninguém em casa, afastando os "malas" que procuram casas vazias para praticarem furtos.

O projeto se divide em três partes:

Decodificador DTMF (MT8870DE): Reponsável por decodficar as teclas do telefone remoto e convertê-las em saída digital para o Arduino;

Sistema de controle (Arduino Mega): Responsável por receber as saídas digitais do decodificador DTMF, tratá-las e acionar o relé correspondente ao dispositivo que queremos ligar/ desligar;

Os atuadores (Relés): Ficarão conectados ao Arduino, onde serão ativados conforme tecla de ativação remota (celular);

Materiais utilizados

Como dito anteriormente, por se tratar de um projeto educacional, iremos fazer de uma forma mais didática utilizando um protobord e alguns componentes eletrônicos, encontrado facilmente em lojas de eletrônica. O Protoboard é uma placa padrão com matrizes de contatos utilizado para quem é iniciante na área de circuitos, são bastante utilizados nas escolas técnicas e faculdades de tecnologia. Abaixo a lista de materiais utilizados:

Figura1: Lista de componentes

1 x Protoboard
1 x MT8870DE (Decodificador de DTMF)
1 x Cristal de 3.58MHZ
2 x Capacitores cerâmicos de 100nF
2 x Resistores de 100K
1 x Resistor de 300K
1 x Plug (mono) de 3,5mm
1 x Adaptador de 3,5mm - 2,5mm - caso seu celular já tenha entrada 3,5mm, não precisa comprar!


Para o atuador (relé que controlará o dispositivo), decidi utilizar o módulo Electronic brick -5V Relay module da Seeed, por dispensar o uso de prototipação e soldagem da placa. Uma observação: cada módulo controlará um dispositivo, no nosso exemplo iremos controlar uma lâmpada, se você quiser controlar mais dispositivos deverá adquirir mais módulos!
Electronic brick -5V Relay module(http://www.seeedstudio.com)

O módulo acima possui um conector de 3 vias com encaixe, se você tem familiaridade com o ferro de solda poderá soldar os fios diretamente na placa, caso contrário, é interessante adquirir o conector abaixo, também vendido na Seeed.

Electronic brick- fully buckled 3 wire cable(http://www.seeedstudio.com) 


Outros: Fios para conexões, Alicate para corte, ferro de solda (para soldar o plug 3,5mm-opcional)
O custo dos materiais acima fica em torno de R$50,00, fora o Arduino Mega e um celular simples.

Funcionamento

O DTMF (Tons Duplos de Múltiplas Frequências) é um sistema criado no laborátório da Bell (Bell Labs) que passou a ser utilizados nos telefones de teclado, seu funcionamento baseia-se no envio de duas freqências, uma baixa e outra alta, utilizando o sistema de sinalização MFSK - Multi-Frequency Shift Keying. O intuito da criação do protocolo DTMF era de permitir a discagem DDD, que usa enlaces sem fio como os de micro-ondas e satélite. O CI utilizado no nosso projeto é o CM8870DE (figura2), encontrado facilmente em lojas de eletrônica. Similares também podem ser utilizados! Vide Datasheet http://www.datasheetcatalog.org/datasheets2/22/220193_1.pdf

Figura2: Decodificados de tons DTMF MT8870DE


O CI mais alguns componentes ficarão montados no protoboard e conectado a um celular na entrada de fones, ele ficará responsável por fazer a ponte entre o usuário e a casa a ser controlada, o decodificador tem a função de "ouvir" o que foi digitado e repassar (decodificar) o número em formato digital para o Arduino Mega, que trata a informação binária e aciona o atuador (Relé) correspondente fazendo com que uma luz seja ligada, por exemplo.

Veja atentamente o vídeo abaixo, em tela cheia, e repare na decodificação binária das teclas do celular na saída do CI (MT8870DE).

Video1: Decodificação DTMF em fomato binário

Note que a cada tecla digitada é sinalizada sua recepção no pino STD. Este pino é extremamente importante, pois informará ao Arduino o momento de fazer a leitura dos bits correspondentes das teclas.

Na tabela abaixo estão as equivalências das teclas, bem como as saídas dos pinos Q3, Q2, Q1 e Q0 do Decodificador DTMF.

Tecla do telefone
Saída
digital do Decodificador DTMF
Valor equivalente
Decimal
Q3
Q2
Q1
Q0
1
0
0
0
1
1
2
0
0
1
0
2
3
0
0
1
1
3
4
0
1
0
0
4
5
0
1
0
1
5
6
0
1
1
0
6
7
0
1
1
1
7
8
1
0
0
0
8
9
1
0
0
1
9
0
1
0
1
0
10
*
1
0
1
1
11
#
1
1
0
0
12
Tabela1 - Saídas binárias do decodificador DTMF.


Mais detalhes sobre o DTMF: http://pt.wikipedia.org/wiki/DTMF

Por quê o Arduino Mega?

Muitos devem estar se perguntando: se o exemplo só serve para acender uma lâmpada, por quê utilizar o Arduino Mega?
Para esse projeto, especificamente, o Arduino Mega tem uma vantagem em relação aos outros: NÚMERO DE PORTAS! São 54 portas que podemos utilizar no projeto, dos quais 4 portas são utilizados para o circuito decodificador DTMF, sobrando, portanto, 50! Ou seja, podemos controlar 50 dispositivos em uma casa!


Figura3: Arduino Mega


Características do Arduino Mega:


» Microcontrolador: ATmega1280
» Voltagem de operação: 5V
» Voltagem de entrada(recomendada): 7-12V
» Limites de voltagem de entrada: 6-20V
» Pinos de I/O digitais: 54 (dos quais 14 podem ser de saída PWM)
» Pinos de entrada analógica: 16
» Corrente DC por pino de I/O: 40 mA
» Memória Flash: 128KB dos quais 4 KB são utilizados no bootloader
» Memória SRAM: 8KB
» Memória EEPROM: 4KB
» Velocidade de Clock: 16 MHz


http://arduino.cc/en/Main/ArduinoBoardMega

Ligações e esquemático do circuito de decodificação


O Esquemático abaixo serve tanto para guiar na montagem do circuito no protoboard, como para quem pretende montar numa placa de fibra de vidro ou fenolite. 

Figura4 - Ligações ao Arduino Mega


Montando o decodificador no protoboard


De acordo com o esquemático acima, montamos o circuito de decodificação DTMF no ptotoboard, monte com atenção e confira todas as ligaçoes! Observe que o pino 1 do CI é marcado por um chanfro e uma bola em baixo relevo, contamos os pinos a partir da esquerda (1) para a direita (9)e, no fim, continuando por cima com o pino 10 da direita para a esquerda (16) conforme Figura2.



Figura2 - Montagem do circuito de decodificação.

Os fios devem ser conectados no Arduino Mega conforme segue abaixo:

5V .............................. Ao pino 5V do Arduino Mega   
GND............................ Ao pino GND do Arduino Mega   
STD ........................... Ao pino 3 do Arduino Mega            
Q3 .............................. Ao pino 4 do Arduino Mega    
Q2 .............................. Ao pino 5 do Arduino Mega   
Q1 .............................. Ao pino 6 do Arduino Mega   
Q0 .............................. Ao pino 7 do Arduino Mega   

Para a conexão com o plug (que será conectado ao celular) recomendo a soldagem no terminal, caso não seja possível, descasque o fio e enrrole nos terminais tendo cuidado para não dar curto nos fios (Figura3). Na maioria dos celulares a conexão dos fones são com plugues de 2,5mm, nesse caso adquira um adaptador para a conversão (Figura4).

Figura3: Ligação no plug 3,5mm


Figura4: Adaptador 3,5mm-2,5mm



Firmware


/* ---------------------------------------------
 * DTMF HOME CONTROL V1.0 Rev0.0
 * Controle de dispositivos através de telefone
 * Arduino-ce
 * Comunidade Cearense de Hardware Livre
 * http://groups.google.com/group/arduino-ce?hl=pt-br
 * http://arduino-ce.blogspot.com
 * março de 2011
 ---------------------------------------------*/

#define RELE1 2 // Conectado ao fio branco do módulo Relé(Figura4)

#define pinBit01  7 // Q0
#define pinBit02  6 // Q1
#define pinBit03  5 // Q2
#define pinBit04  4 // Q3
#define pinBitStd 3 // STD

int tecla = 0;

int bit01 = 0;   
int bit02 = 0; 
int bit03 = 0; 
int bit04 = 0; 
int bitStd= 0; 

int RELE1_STATE = LOW; // Estado do Relé LOW (Desligado)

void setup() { 
  Serial.begin(9600); // Iniciamos a Serial com Baudrate 9600
  pinMode(RELE1, OUTPUT); // Definimos o pino do Relé como Saída
  Serial.println("Aguardando tecla de comando..."); // Exibimos a mensagem no terminal...
}

void loop(){ 

  bitStd = digitalRead(pinBitStd); //Lê o estado do pino STD e armazena em 'bitStd' 

  if (bitStd == HIGH) {//Se estiver em nível alto fará as leituras 
                       //dos bits dos pinos Q3, Q2, Q1 e Q0

    bit01 = digitalRead(pinBit01);   
    bit02 = digitalRead(pinBit02); 
    bit03 = digitalRead(pinBit03); 
    bit04 = digitalRead(pinBit04); 

    tecla = (bit04 * 8) + (bit03 * 4) + (bit02 * 2) + (bit01 * 1);//Conversão binária para 
                                                                  //decimal (ver Vídeo1)

    Serial.print("Recebido: "); // Exibe a mensagem

    switch (tecla){ // Seleciona a tecla pressionada

    case 1: // Tecla 1
      Serial.println("1");     
      /* COMANDO PARA RELE1 */
      RELE1_STATE = !RELE1_STATE; // Guarda o estado INVERTIDO do Relé.     
      break;

    case 2: // Tecla 2
      Serial.println("2");               
      break;

    case 3: // Tecla 3
      Serial.println("3");
      break;

    case 4: // Tecla 4
      Serial.println("4");
      break;

    case 5: // Tecla 5
      Serial.println("5");
      break;

    case 6: // Tecla 6
      Serial.println("6");
      break;

    case 7: // Tecla 7
      Serial.println("7");
      break;

    case 8: // Tecla 8
      Serial.println("8");
      break;

    case 9: // Tecla 9
      Serial.println("9");
      break;

    case 10: // Tecla 0
      Serial.println("0");
      break;

    case 11: // Tecla *
      Serial.println("*");
      break;

    case 12: // Tecla #
      Serial.println("#");
      break; 
    }

    digitalWrite(RELE1, RELE1_STATE);//Liga ou desliga o Relé1 conforme o estado (HIGH/ LOW)

    // Zeram-se todas as variáveis 
    tecla = 0;
    bit01 = 0;   
    bit02 = 0; 
    bit03 = 0; 
    bit04 = 0; 
    bitStd= 0; 
    delay (500); // Aguarda 500 milissegundos
  } // Sai do switch// Volta pro loop...


Testando o protótipo


Utilizei uma lâmpada fluorescente comum ligado em 220V na bancada. O computador com a IDE do Arduino foi utilizado para monitorar o recebimento das teclas do telefone numa ligação local.





Vídeo2: Acendendo uma lâmpada via telefone





Prova e uso

Vídeo3: Acendendo a luz do quarto. OBS: Não reparar na bagunça! :P





Links relacionados

Bento XVI pode controlar iluminação LED do Cristo Redentor pelo celularhttp://super.abril.com.br/blogs/planeta/bento-xvi-pode-controlar-iluminacao-led-do-cristo-redentor-pelo-celular/

Celulares e tablets se transformam em controle universal em casa “high-tech” -  http://www.mobilepedia.com.br/noticias/celulares-e-tablets-se-transformam-em-controle-universal-em-casa-%E2%80%9Chigh-tech%E2%80%9D

Algumas considerações:

- Com alterações no firmware o projeto pode ser alterado para até 50 módulos de controle, devendo-se levar em conta a alimentação do conjunto, ou seja, para mais de 3 módulos de relés uma fonte deverá ser utilizada, escolha de preferência 12V x 5A.

- Caso já tenha experiência com eletrônica, poderá montar tanto o circuito do módulo DTMF quanto os módulos de controles de relés em placas de fibra de vidro e montar o conjunto em uma caixa hermética!

- Por ter uma gande potência ao controlar um arcondicionado, utilize um contactor em conjunto com o relé, ou seja, o relé liga o contactor, que liga o arcondicionado!


NUNCA MEXA NA REDE ELÉTRICA SEM O DEVIDO CONHECIMENTO, FAÇA COM O AUXÍLIO DE UM PROFISSIONAL DA ÁREA DE ELETRICIDADE!


Por enquanto é só, até o próximo tutorial!


Licença Creative Commons
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Brasil License.

domingo, 27 de fevereiro de 2011

Arduino-ce no II Pylestras

O Evento contou com bastante gente, fiquei muito feliz com a receptividade e o interesse das pessoas no Arduino! Para quem não pode ir, segue os slides da palestra:








Fotos do evento...













terça-feira, 25 de janeiro de 2011

Monitor de Temperatura via TCP/IP

A diferença desse tutorial para o anterior é o meio por onde iremos monitorar temperaturas.Com esse projeto (WebTemp) você poderá monitorar, por exemplo, uma estufa de plantas, uma câmara frigorífica ou mesmo sua adega ;-) tudo remotamente pela Rede Local ou através da Internet usando computador ou celular via Wifi! Para tanto, utilizaremos um Shield, que é uma placa auxiliar "espetada" no Arduino  que tem uma determinada funcionalidade, você pode comprá-lo como também criar o seu próprio shield. Existem shields praticamente pra tudo, nesse link (http://shieldlist.org/)  você confere a lista de shields disponíveis por fabricante, bem como os pinos que eles ocupam no Arduino! Para esse projeto iremos utilizar um dos shields que eu mais gosto e um dos mais interessantes, o EthernetShield (http://www.arduino.cc/en/Main/ArduinoEthernetShield) ,que implementa a pilha TCP/IP e suporte a UDP, possibilitando a comunicação via ethernet! Por ser de fácil implementação, utilizaremos o modelo que conta com o chip da Wiznet 5100 (Figura1)

Figura1 - EthernetShield da WizNet



Testando a placa

Primeiramente você deverá ter privilégios de Administrador para configurar a sua placa de rede no PC. Para que a comunicação possa ser estabelecida sem problemas entre o Arduino e o PC, atribua o IP: 192.168.1.14, Gateway: 192.168.1.1 e Máscara de subrede: 255.255.255.0. Caso não saiba como configurar sua placa de rede no Windows veja esse link: http://www.baboo.com.br/conteudo/modelos/Configurando-uma-rede-domestica-no-Windows-XP_a5307_z0.aspx

Para um teste inicial, "espete" a placa EthernetShield no Arduino, conecte o cabo usb ao PC(os leds da shield acenderão indicando que a placa está energizada), conecte uma extremidade do cabo UTP RJ-45M no conector RJ-45F do Arduino e a outra extremidade do conector na placa de rede do PC. Abra a IDE do Arduino, carregue o código abaixo, salve e faça o upload do sketch: 


/* ---------------------------------------------
 * Teste EthernetShield V1.0 Rev0.0
 * Arduino-ce
 * Comunidade Cearense de Hardware Livre
 * http://groups.google.com/group/arduino-ce?hl=pt-br 
 * http://arduino-ce.blogspot.com 
 * janeiro de 2011
 ---------------------------------------------*/
#include <Ethernet.h>//Biblioteca EthernetShield 

#define SAMPLES 500 //Número de amostras de temperaturas
#define sensortemp 0 //Pino analógico em que estará conectado o sensor LM35

int tempvector[SAMPLES]; //Vetor que armazenará as temperaturas
double tempSensor = 0.0; //Variável auxiliar
int  valAnalog = 0; // Variável para aramazenar a leitura do sensor LM35


byte mac[]     = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //Define o endereço físico da placa
byte ip[]      = { 192, 168, 1, 15 };  // Ip da EthernetShield
byte gateway[] = { 192, 168, 1, 1 };   // Gateway (opcional)
byte subnet[]  = { 255, 255, 255, 0 }; // Mascara de subrede

Server server(80); //Cria o objeto na porta 80

void setup()
{
  Ethernet.begin(mac, ip, gateway, subnet); //Inicializando a ethernet
  server.begin(); //Inicializando o servidor web
}

void loop()
{
  Client client = server.available(); //
  if (client) {
    // uma requisição http termina com uma linha em branco
    boolean current_line_is_blank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read(); // Recebe caractere do browser e guarda em "c"
        // Se chegamos ao fim da linha (recebeu uma nova linha
        // de caractere) e a linha está em branco, a requisição http termina
        // para que possamos enviar uma resposta!
        if (c == '\n' && current_line_is_blank) {
          // Envia um cabeçalho padrão de resposta HTTP 
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
          break;
        }
        if (c == '\n') {
          // Se começamos uma nova linha...
          current_line_is_blank = true;
        } 
        else if (c != '\r') {
          // Se ainda temos um caractere na linha atual...
          current_line_is_blank = false;
        }
      }
    }

    client.println("<html>"); //Início do código HTML
    client.println("Arduino na web!");
    client.println("</html>"); //Fim do código HTML 
  } 
  // Damos ao navegador um tempo para receber os dados
  delay(1);
  client.stop();// Fecha a conexão 
}



Após feito o upload para o Arduino, clique em iniciar&gt;executar&gt; digite "cmd" sem aspas, no prompt de comando digite "ping 192.168.1.15 -t" sem aspas. Isso é o teste básico de conexão via rede! Se tudo estiver OK ficará como a tela abaixo:

Figura2 - Pingando no Arduino + EthernetShield



Agora, abra o seu navegador e digite o endereço 192.168.1.15, a janela deverá exibir conforme abaixo:

Figura3 - Teste no Browser


Montando o WebTemp

Desconecte o cabo usb do Arduino e conecte o sensor LM35 conforme figura abaixo:

Figura4 - Conexão EthernetShield com LM35


Reconecte o cabo usb, abra a IDE do Arduino, carregue o código abaixo, salve e faça o upload do sketch: 



/* ---------------------------------------------
 * WebTemp V1.0 Rev0.0
 * Monitor de temperatura via TCP/IP
 * Arduino-ce
 * Comunidade Cearense de Hardware Livre
 * http://groups.google.com/group/arduino-ce?hl=pt-br 
 * http://arduino-ce.blogspot.com 
 * janeiro de 2011
 ---------------------------------------------*/
#include <Ethernet.h>//Biblioteca EthernetShield 

#define SAMPLES 500 //Número de amostras de temperaturas
#define sensortemp 0 //Pino analógico em que estará conectado o sensor LM35

int tempvector[SAMPLES]; //Vetor que armazenará as temperaturas
double tempSensor = 0.0; //Variável auxiliar
int  valAnalog = 0; // Variável para aramazenar a leitura do sensor LM35


byte mac[]     = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //Define o endereço físico da placa
byte ip[]      = { 192, 168, 1, 15 };  // Ip da EthernetShield
byte gateway[] = { 192, 168, 1, 1 };   // Gateway (opcional)
byte subnet[]  = { 255, 255, 255, 0 }; // Mascara de subrede

Server server(80); //Cria o objeto na porta 80

void setup()
{
  Ethernet.begin(mac, ip, gateway, subnet); //Inicializando a ethernet
  server.begin(); //Inicializando o servidor web
}

void loop()
{
  Client client = server.available(); //
  if (client) {
    // uma requisição http termina com uma linha em branco
    boolean current_line_is_blank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read(); // Recebe caractere do browser e guarda em "c"
        // Se chegamos ao fim da linha (recebeu uma nova linha
        // de caractere) e a linha está em branco, a requisição http termina
        // para que possamos enviar uma resposta!
        if (c == '\n' && current_line_is_blank) {
          // envia um cabeçalho padrão de resposta HTTP 
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
          break;
        }
        if (c == '\n') {
          // Se começamos uma nova linha...
          current_line_is_blank = true;
        } 
        else if (c != '\r') {
          // Se ainda temos um caractere na linha atual...
          current_line_is_blank = false;
        }
      }
    }

    client.println("<html>"); //Início do código HTML
    client.println("<font face='arial' size='4' color='green' >WEBTEMP V1.0</font><hr>"); //Exibe texto com formatação    
    for (int i=0; i &lt;= SAMPLES; i++) // Incrementa i ate i = SAMPLES
    {    
      valAnalog = analogRead(sensortemp); // Leitura do pino analogico correspondente ao sensor e guarda em valAnalog
      tempvector[i] =( 5.0 * valAnalog * 100.0)/1024.0; //Armazena as temperaturas num vetor de tamanho = SAMPLES
      tempSensor = tempSensor +tempvector[i]; // Soma as temperaturas e armazena em tempSensor
    } 
    tempSensor = tempSensor/SAMPLES;  // Calcula a média das temperaturas e as armazena em 'tempSensor'

    client.println("<h1>"); //Inicio do cabeçalho H1

    client.print(tempSensor); //Exibe a temperatura  

    client.print("&deg;"); // Referência do caratere(graus º) na codificação Latin-1 (ISO-8859-1)     client.println("C" </h1><br>);// Exibe o "C" e finaliza a tag H1

    client.println("<input type='button' value='Refresh' onClick='window.location.href=window.location.href'>");    
    client.println("</html>"); //Fim do código HTML          
  } 
  // Damos ao navegador um tempo para receber os dados
  delay(1);
  client.stop();// Fecha a conexão 
}



Observe que a maior parte o trecho em negrito foi copiado do tutorial anterior com uma mudança, apenas, na exibição da temperatura (vide trecho em cor verde)

Agora, abra o seu navegador e digite o endereço 192.168.1.15, a janela deverá exibir conforme abaixo:

Figura5 - WebTemp em funcionamento




Deixando o projeto mais profissional (Sugestão)

Para acomodar o Arduino + EthernetShiled + LM35 utilizei a caixa SFE Arduino Project Enclosure (http://www.robotshop.com/world/sfe-arduino-project-enclosure.html), disponível na Robotshop, eu sei é um pouco caro, mas fica um ótimo acabamento! Vide fotos do projeto finalizado:


Figura6

Figura7

Figura8


Figura9


Alimentando a placa

Se o local monitorado possui um computador com porta usb disponível, a alimentação do circuito poderá ser feita por ela, entretanto, se o local monitorado não tiver computador próximo, o circuito poderá ser alimentado por uma fonte externa de 12V x 500mA (Figuras 10 e 11), essa fonte custa em torno de R$25,00 em lojas de eletrônicas. Outra opção seria utilizar uma fonte de carregador de celular com entrada USB (Figuras 12 e 13), que custa menos de R$ 5,00 no DealExtreme (http://www.dealextreme.com/c/batteries-chargers-204)


Figura10

Figura11

Figura12

Figura13
.  


Sugestões:

- O Firmware pode ser alterado para receber até 6 sensores de temperatura, podendo monitorar mais de um ponto, deve-se, no entanto, utilizar cabos blindados e de curto alcance, visto que interferências externas podem prejudicar a leitura do sensor por causa do próprio tamanho do cabo!

- Um Access Point pode ser conectado diretamente ao EthernetShield, o que possibilita o monitoramento via Wifi pelo notebook ou celular com essa tecnologia!


Por enquanto é só. Até o próximo tutorial!



domingo, 16 de janeiro de 2011

Monitor de Temperatura com Log

Esse é um projeto bem simples, porém bastante útil para quem precisa monitorar ambientes ou cargas em que a temperatura representa um risco, sejam cargas perecíveis ou mesmo uma sala com computadores (servidores). O sensor  utilizado é o LM35 (http://www.national.com/ds/LM/LM35.pdf), barato, preciso e fácil de encontrar nas lojas de eletrônica, ele é um sensor de circuito integrado que mede a temperatura(ºC) com uma saída elétrica proporcional a mesma, por ter um invólucro de plástico(TO-92) ele é resistente a oxidação, podendo ficar exposto a intempéries do ambiente monitorado!


O LM35 tem 3 pinos, onde:

V+      alimentamos com 5V vindo do Arduino;
GND  ligamos ao gnd correspondente do Arduino;
OUT  saíde de tensão correspondente a temperatura(ºC).

Figura1 - Pinos LM35

O fator de escala é 0,01 V  por grau Celcius, ou seja, a cada 0,01V no pino OUT corresponde a 1ºC. Se tivermos 0,5v teremos uma temperatura de 50ºC, se tivermos 1V, teremos uma temperatura de 100ºC e assim por diante...

Como a saída (OUT) do LM35 é analógica, devemos, portanto, conectá-la a um pino de entrada analógica  do Arduino- no projeto o pino escolhido foi o 0 (zero)- As ligações ao Arduino ficarão como mostra a Figura2.


Figura2 - Conexão ao Arduino

O Programa abaixo lê a temperatura periodicamente em um intervalo definido(1s) e envia a informação via serial para o computador.


/* ---------------------------------------------
 * Temp_logger V1.0 Rev0.0
 * Monitor de temperatura para sala de servidores
 * Arduino-ce
 * Comunidade Cearense de Hardware Livre
 * http://groups.google.com/group/arduino-ce?hl=pt-br 
 * http://arduino-ce.blogspot.com 
 * janeiro de 2011
 ---------------------------------------------*/

#define SAMPLES 500 //Número de amostras de temperaturas
#define sensortemp 0 //Pino analógico em que estará conectado o sensor LM35
#define TEMPO_LEITURA 1000 //Intervalo entre cada leitura do sensor LM35 em milisegundos! OBS: 1000ms = 1s

int tempvector[SAMPLES]; //Vetor que armazenará as temperaturas
double tempSensor = 0.0; //Variável auxiliar
int  valAnalog = 0; // Variável para aramazenar a leitura do sensor LM35

void setup() 
{ 
  Serial.begin(9600); //Iniciando Serial
}

void loop() 
{  
  for (int i=0; i <= SAMPLES; i++) // Incrementa i ate i = SAMPLES
  {    
    valAnalog = analogRead(sensortemp); // Faz a leitura do pino analógico do sensor e armazena em valAnalog
    tempvector[i] =( 5.0 * valAnalog * 100.0)/1024.0; //Armazena as temperaturas num vetor de tamanho = SAMPLES
    tempSensor = tempSensor +tempvector[i]; // Soma as temperaturas e armazena em tempSensor
  } 
  tempSensor = tempSensor/SAMPLES;  // Calcula a média das temperaturas e as armazena em tempSensor
  Serial.println(tempSensor); //Envia a temperatura para porta COMX
  delay(TEMPO_LEITURA);// Espera um tempo determinado em TEMPO_LEITURA (milisegundos)
}




O valos analógico do sensor LM35 é lido e armazenado em valAnalog que por sua vez é multiplicado pela tensão de referência (5V) depois multiplicado por 100.0 depois dividido por 1024.0. Isso ocorre porque no pino analógico temos uma escala de leitura que vai de 0(zero) a 1024, portanto, nossa escala de tensão correspondente tem que estar no limiar de 0 até 1024, onde 0  corresponde a temperatura mínima e 1024 corresponde a temperatura máxima. Após esse cálculo obtemos a temperatura em ºC e armazenamos no vetor tempvector de tamanho igual a SAMPLES, logo esse valor é somado com o posterior e armazenado em  tempSensor. Após somadas todas as temperaturas dividimos pelo total de amostras (SAMPLES) para termos uma média, isso torna o processo de captação de temperatura mais preciso!

Por fim, imprimimos, com uma quebra de linha, a temperatura Serial.println(tempSensor); no nosso projeto ele está na na porta COM3 (Verifique a porta que o seu Arduino está utilizando!). Para conferir o funcionamento basta clicar no botão "Serial Monitor" na IDE do Arduino, conforme figura abaixo.

Figura3 - Serial Monitor

Após conferido o funcionamento iremos criar um script para o computador, que capture as temperaturas recebidas pela porta COM3 e as escreva em um arquivo de texto - que pode ser exportado para uma planilha posteriormente. Abra o bloco de notas do Windows, cole o script abaixo altere a porta, a extensão e salve-o como TempLogger.VBS:


Const ForReading = 1
Const ForWriting = 2


Set fso = CreateObject("Scripting.FileSystemObject")
Set com = fso.OpenTextFile("COM3:9600,N,8,1", ForReading)


Set objFSO = CreateObject("Scripting.FileSystemObject")
Set objFile = objFSO.OpenTextFile("C:\TempLogger.txt", ForWriting, True)


MsgBox("Iniciado TempLogger")


Do While com.AtEndOfStream <> True
temperatura = com.ReadLine
        objFile.Write(now())
        objFile.Write(" ")
objFile.WriteLine(temperatura)
WScript.Sleep(100)
Loop


objFile.Close
com.Close()



Certifique-se que que a IDE do Arduino esteja fechada e que nenhum outro programa esteja usando a mesma porta! Execute o script e, se tudo ocorrer bem, a janela abaixo será exibida:


As temperaturas já estão sendo colhidas. Vá ao direório C:\ e abra o arquivo TempLogger.txt, o arquivo estará armazenando a temperatura do sensor a cada 1s conforme figura abaixo. Altere o tempo para sua necessidade, bastando modificar SAMPLES no firmware e enviá-lo ao Arduino. Lembrando que 1000ms corresponde a 1s!





Deixando o projeto mais profissional

Para finalizar, acondicionaremos o Arduino em uma caixa pra tornar o projeto mais profissional. Utilizei uma caixa Caixa Patola PB-86 (http://www.patola.com.br/index.php?pagina=info_produto.php&produto_id=100&titulo=PB-086) mas você pode usar uma similiar! Além disso foi utilizado um ferro de solda, para soldar os fios no sensor; cola de silicone, para prender o sensor fora da caixa; um alicate de corte, para cortar um pequeno quadrado deixando o espaço para o conector USB do Arduino, também foi utilizado e um parafuso de 6mm com porca para fixar o Arduino na tampa da caixa. Vejam as fotos de como ficou.











 
Por enquanto é só! Até o próximo tutorial!