28 agosto 2014

Controle de motor de passo com ponte H L298N

A maioria dos projetos que eu vejo utilizando o driver motor ponte H L298N  envolve o controle de motores DC. Faz sentido pois uma das grandes vantagens desse módulo é que ele suporta correntes de até 2A por canal. 

Mas com esse módulo também é possível controlarmos motores de passo. Vamos ver como isso funciona, mostrando antes as especificações e pinagem :

Ponte H L298N Arduino

Especificações ponte H L298N

  • Tensão de Operação: 6~35v
  • Chip: ST L298N (datasheet)
  • Controle de 2 motores DC ou 1 motor de passo
  • Corrente de Operação máxima: 2A por canal ou 4A máx
  • Tensão lógica: 5v
  • Corrente lógica: 0~36mA
  • Limites de Temperatura: -20 a +135°C
  • Potência Máxima: 25W
  • Dimensões: 43 x 43 x 27mm
  • Peso: 30g
Pinagem ponte H L298N

Pinagem

  • MOTOR A e MOTOR B são os conectores utilizados para ligação de 2 motores DC ou 1 motor de passo
  • ATIVA MA e ATIVA MB - Podem ser ligados aos pinos PWM do Arduino para controle de velocidade do motor
  • ATIVA 5V e 5v - Esta placa possui um regulador de tensão integrado. Quando o módulo é alimentado por fonte externa (6 à 35v) e um jumper está colocado no conector Ativa 5v, o pino 5v possui uma SAÍDA de +5v. Quando não há jumper no pino Ativa 5v, o pino 5v se comporta como ENTRADA, podendo ser utilizado , por exemplo, os 5v do Arduino para alimentação. Portanto, tome cuidado ao utilizar o pino 5v e evite danos ao módulo.
  • 6-35v e GND - Pinos alimentação externa
  • ENTRADA - Barramento com os pinos de IN1 a IN4. IN1 e IN2 controlam o Motor A, e IN3 e IN4 controlam o Motor B. No caso de motores de passo, os 4 pinos são utilizados

Eu testei esse módulo com um motor de passo bipolar, retirado de uma impressora (o mesmo que eu utilizei no post Controlando motor de passo bipolar com o módulo Easydriver). Como o motor é de 12 volts, utilizei uma fonte externa para alimentação. Repare que o pino GND do Arduino deve ser ligado ao GND da fonte externa :


Circuito Arduino Uno - Ponte H L298N


Com esse motor eu vou usar a sequência mostrada na tabela abaixo, que se refere ao motor que eu tenho. A bobina 1 está ligada aos fios amarelo e cinza, e a bobina 2 aos fios marrom e verde, e provavelmente são diferentes das cores dos fios do motor que você tiver aí. De qualquer forma, basta descobrir quais são os pares das bobinas.


Motor de passo - Sequencia de ativação 4 passos


Com base na tabela, vou acionando os pinos 8, 9, 10 e 11 do Arduino com pequenos intervalos, movimentando o motor. Como estamos acionando diretamente os pinos, não vamos utilizar bibliotecas nesse programa.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// Programa : Ponte H L298N e motor de passo
// Autor : Arduino e Cia

// Conexoes modulo - Arduino
int IN1 = 8;
int IN2 = 9;
int IN3 = 10;
int IN4 = 11;

void setup()
{
  // Define os pinos como saida
  pinMode(IN1,OUTPUT);
  pinMode(IN2,OUTPUT);
  pinMode(IN3,OUTPUT);
  pinMode(IN4,OUTPUT);
}

int tempo = 10;

void loop()
{
  // Passo 1
  digitalWrite(IN1, 1);
  digitalWrite(IN2, 0);
  digitalWrite(IN3, 0);
  digitalWrite(IN4, 1);
  delay(tempo);  

  // Passo 2
  digitalWrite(IN1, 0);
  digitalWrite(IN2, 1);
  digitalWrite(IN3, 0);
  digitalWrite(IN4, 1);
  delay(tempo);

  // Passo 3
  digitalWrite(IN1, 0);
  digitalWrite(IN2, 1);
  digitalWrite(IN3, 1);
  digitalWrite(IN4, 0);
  delay(tempo);

  // Passo 4
  digitalWrite(IN1, 1);
  digitalWrite(IN2, 0);
  digitalWrite(IN3, 1);
  digitalWrite(IN4, 0);
  delay(tempo);
}

Adapte o programa ao seu projeto, ajustando a sequência de ativação, alterando o sentido de rotação e modificando o programa para que o motor se movimente em ângulos pré-determinados.

21 agosto 2014

Controlando motor de passo bipolar com o módulo Easydriver

Controle motores de passo de uma maneira muito simples com o Módulo Motor de Passo Easydriver, um módulo feito para controlar motores de passo bipolares de 4, 6 ou 8 fios. Funcionou perfeitamente para controlar um motor de 12 v que eu havia retirado de uma impressora antiga, e estava esquecido na gaveta. :-)

Módulo motor de passo Easydriver
 
Controlado pelo CI A3967, o módulo não funciona apenas com 12 volts : a tensão de entrada pode ser de 7 à 30 volts. A comunicação com o microcontrolador é feita por meio de apenas 3 pinos : um para o controle de passo, outro para a direção e o terceiro vai ligado ao GND.

A tensão do nível de sinal também é ajustável, podendo ser tanto 3.3v como 5v, bastando para isso fechar o contato SJ2 no lado esquerdo da placa. Isso permite que o módulo seja usado tanto em projetos que utilizem o Arduino Uno ou Mega (nível de sinal de 5v), como o Arduino Due (nível de sinal de 3.3v).

Veja na imagem abaixo com o detalhe da pinagem que essa placa permite ainda o controle dos micropassos do motor (utilizando os pinos MS1 e MS2), possui uma saída de 5v para alimentar algum outro circuito/sensor, além do potenciômetro no lado esquerdo para controle da corrente fornecida ao motor.

Easydriver - Pnagem

No site oficial do desenvolvedor (http://www.schmalzhaus.com/EasyDriver/), você encontra  informações completas sobre todas as funcionalidades dessa placa.

Para testar o motor de impressora esquecido na gaveta, eu fiz a seguinte ligação :

Circuito Easydriver e motor de passo 12v Arduino

Antes de ligar o motor, eu precisava descobrir quais eram os pares das bobinas. No meu caso, o motor tinha 4 fios e simplesmente utilizei o multímetro e segui as instruções desse site, que explica o procedimento para motores bipolares, unipolares e híbridos.

O programa abaixo gira o motor por uma volta completa, e depois faz a mesma coisa no sentido inverso. Ajuste o programa para o número de passos do seu motor alterando a variável passos_motor no início do programa. 

Como utilizamos apenas dois pinos do Arduino para enviar ao módulo os valores dos passos e da direção, não precisamos carregar nenhuma biblioteca especial.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// Programa : Controle de motor de passo com Easydriver
// Autor : Arduino e Cia

// Pinos conectados ao Step e Dir do Easydriver
int pino_passo = 5;
int pino_direcao = 4;

int direcao = 1;

// Quantidade de passos para uma volta completa
// Ajuste de acordo com o seu motor
int passos_motor = 360;

void setup() 
{
  // Define os pinos como saida
  pinMode(pino_passo, OUTPUT);
  pinMode(pino_direcao, OUTPUT);
}

void loop()
{
  // Define a direcao de rotacao
  direcao = 1;
  digitalWrite(pino_direcao, direcao);
  for (int p=0 ; p < passos_motor; p++)
  {
    digitalWrite(pino_passo, 1);
    delay(1);
    digitalWrite(pino_passo, 0);
    delay(1);
  }
  delay(1000);
  
    // Inverte a direcao de rotacao
  direcao = 0;
  digitalWrite(pino_direcao, direcao);
  for (int p=0 ; p < passos_motor; p++)
  {
    digitalWrite(pino_passo, 1);
    delay(1);
    digitalWrite(pino_passo, 0);
    delay(1);
  }
  delay(1000);
}


19 agosto 2014

Dimmer com o módulo sensor de luz LDR

Nesse post vamos ver como acender luzes automaticamente e regular a luminosidade de um led utilizando o módulo sensor de luz LDR.

Módulo sensor de luz LDR

O módulo funciona com alimentação de 3.3 à 5v e tem um CI comparador de tensão LM393, além de um potenciômetro para ajuste de sensibilidade.

Possui duas saídas : uma analógica (A0), que nesse post vamos utilizar para ajustar o brilho de um led, e uma digital (D0), que gera o valor 0 ou 1 na saída, e que vamos utilizar para acionar um segundo led.

Módulo LDR - Detalhes

No lado direito um led vermelho indica quando o módulo está energizado, e no lado esquerdo um led verde indica a alteração do estado da saída digital D0. Essa alteração da porta D0 pode ser regulada por meio do potenciômetro existente na placa : você determina em qual nível de luminosidade a saída D0 será acionada.

Você pode usar esse tipo de informação para controlar o acionamento de um relé que acende uma lâmpada caso escureça, ou então algum tipo de alarme que, digamos, você queira que funcione apenas durante a noite (ou durante o dia, por que não ?).

Vamos montar um circuito que vai utilizar as duas portas do módulo, sendo que a analógica vai controlar o brilho do led vermelho (será um dimmer), e a outra vai acender ou apagar um led verde conforme a regulagem feita no potenciômetro :

Circuito Arduino módulo LDR


O led vermelho está ligado à porta digital 6, que possui a função PWM (Pulse Width Modulation - Modulação por largura de pulso), e com isso podemos controlar a luminosidade do led de acordo com o valor que vamos enviar para essa porta (0 à 255).

Já o led verde vai simplesmente acender ou apagar conforme o estado da porta D0 do módulo.

Programa dimmer com módulo sensor de luz LDR


O programa lê o valor da entrada analógica A3, converte o valor lido (de 0 a 1023),para um valor de 0 a 255 e envia esse valor para a porta digital 6 (led vermelho). 

Ao ler o valor da porta digital 2, ele acende ou apaga o led verde :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// Projeto : Modulo sensor de luz LDR
// Autor : Arduino e Cia

//Led vermelho ligado a porta 6 - PWM
int pinoled = 6;  
//Led vermelho ligado a porta 7
int pinoled2 = 7;
//Pino ligado a porta A0 do modulo LDR
int pino_analogico_A0 = A3; 
//Pino ligado a porta D0 do modulo LDR
int pino_digital_D0 = 2;

//Armazena o valor lido da porta D0
int valord0 = 0;
//Armazena valor lido da porta A0, entre 0 e 1023
int valora0 = 0;  

float luminosidade = 0; //Valor de luminosidade do led

void setup()
{
   //Define os pinos dos leds como saida
   pinMode(pinoled, OUTPUT);  
   pinMode(pinoled2, OUTPUT); 
   //Define os pinos do modulo como entrada
   pinMode(pino_analogico_A0, INPUT); 
   pinMode(pino_digital_D0, INPUT);
   Serial.begin(9600);        
}

void loop()
{
  //Le o valor da porta digital do modulo
  valord0 = digitalRead(2);
  switch(valord0)
  {
    case 0:
    digitalWrite(pinoled2, LOW);
    break;
    case 1:
    digitalWrite(pinoled2, HIGH);
    break;
  }
  
  //Le o valor da porta analogica do modulo
  valora0 = analogRead(pino_analogico_A0);
  
  //Converte e atribui para a variavel "luminosidade" o
  //valor lido da porta analogica
  luminosidade = map(valora0, 0, 1023, 0, 255);  

  //Mostra o valor lido do potenciometro e a luminosidade
  //no Serial Monitor
  Serial.print("Valor da porta analogica : "); 
  Serial.print(valora0);   
  Serial.print(" = Luminosidade : ");
  Serial.println(luminosidade);  

  //Envia sinal analogico para a saída do led, com luminosidade variavel
  analogWrite(pinoled, luminosidade);  
  delay(100);
}

Carregue o programa no Arduino e teste o módulo cobrindo o LDR ou direcionando uma lanterna para o sensor, e observe a variação no acionamento dos leds.

14 agosto 2014

Conectando módulo gravador de voz e player ISD1820 ao Arduino

Grave até 10 segundos de som com o Módulo gravador de voz e player ISD1820. A gravação é feita por meio do microfone embutido na placa, e a reprodução utiliza um alto-falante comum de 8 ohms. Dependendo do seu projeto esse módulo pode até ser ligado à um amplificador. O som é armazenado na memória EEPROM interna do ISD1820.

Módulo gravador de voz e player ISD1820

Existem vários módulos baseados no CI ISD1820, mas todos funcionam da mesma maneira, o que muda geralmente é o hardware para selecionar algum tipo de configuração do módulo, disposição dos botões, etc. 

Esse que eu tenho possui 3 botôes para controle e um conector de 12 pinos que serve para ligação ao microcontrolador e também executar algumas funções específicas. Vamos olhar os detalhes desse módulo :

Módulo gravador de voz ISD1820 - Detalhes

  1. Botão REC :  Mantenha o botão pressionado para gravar até 10 segundos de som
  2. Botão PLAYE : Reproduz todo o conteúdo da gravação presente na memória EEPROM
  3. Botão PLAYL : Reproduz a gravação enquanto o botão estiver sendo pressionado
  4. ISD1820 : chip controlador de gravação e reprodução (datasheet)
  5. Led : Acende quando o módulo está no modo de gravação, e pisca rapidamente ao final da reprodução
  6. Microfone
  7. Conector de 12 pinos : Controle, alimentação e funções REP (repetição) e FT
  8. Conector para o alto-falante

O conector de 12 pinos é dividido em duas partes. No lado direito, os pinos REC, P-E e P-L tem as mesmas funções dos botões REC, PLAYE e PLAYL, respectivamente, e são ativados em nível alto (HIGH).  O pino FT (Feed Through) faz com que o som detectado pelo microfone seja reproduzido diretamente no alto-falante. GND e VCC correspondem à alimentação do módulo (3 à 5v).

Módulo gravador de voz ISD1820 - Conector


No lado esquerdo, um jumper nos dois pinos superiores (REP), reproduz de forma contínua a gravação contida na memória, até que o jumper seja retirado. Nos dois pinos inferiores (FT), um jumper realiza a mesma função do pino FT explicado anteriormente : ele envia o som detectado pelo microfone diretamente para o alto-falante. Esses dois jumpers podem ser substituídos por botões, assim fica mais fácil para ligar e desligar as funções. Ainda no lado esquerdo, os dois pinos centrais (NC), não são utilizados.

Testar esse módulo é muito fácil, já que você pode simplesmente alimentá-lo com uma tensão de 3 à 5v, e usar os botões para gravação e reprodução, conforme explicado acima. 

Para testar o módulo com o Arduino, siga o esquema de conexão abaixo :

Circuito Arduino - Gravador de voz ISD1820
Depois carregue este programa no Arduino. Ele aciona o pino de gravação (REC) 5 segundos após o carregamento do programa, mantendo o pino ativo por 10 segundos. Nesse tempo o led do módulo irá acender, indicando que os sons estão sendo armazenados na memória. O programa então faz uma pausa de 5 segundos, e em seguida reproduz os sons que foram gravados.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Programa : Gravador de voz e player ISD1820
// Autor : Arduino e Cia

// Pino ligado ao REC do modulo
int pino_rec = 5;
// Pino ligado ao P-E (PLAYE) do modulo
int pino_playe = 7;

void setup()
{ 
  pinMode(pino_rec, OUTPUT);
  pinMode(pino_playe, OUTPUT);
}

void loop()
{
  delay(5000);
  // Inicia a gravacao
  digitalWrite(pino_rec, HIGH);
  delay(10000);
  // Para a gravacao
  digitalWrite(pino_rec, LOW);
  // Aguarda 5 segundos
  delay(5000);
  // Inicial a reproducao
  digitalWrite(pino_playe, HIGH);
  delay(100);
  digitalWrite(pino_playe, LOW);
  // Aguarda 20 segundos e reinicia o processo
  delay(20000);
}  

Você pode utilizar esse módulo não só com o Arduino, mas também com outras placas e controladores, como por exemplo o Raspberry Pi e o PIC, bastando seguir o mesmo esquema de ativação dos pinos de controle.

12 agosto 2014

Teclado touch para Arduino - Touch Shield Sparkfun

Adicione um teclado touch ao seu projeto com este Touch Shield da Sparkfun, um teclado capacitivo para ser utilizado com o Arduino, e que utiliza a conexão I2C para comunicação:
 
Teclado Touch Shield Sparkfun

A tecnologia capacitiva, muito usada em touch screen de tablets, computadores e afins, é aquela em que você não precisa "apertar" a tela (essas são as resistivas), apenas passar o dedo (ou um material condutor) e o contato é feito internamente. Isso gera uma enorme vantagem em termos de durabilidade.

Características do Touch shield Sparkfun


O teclado Touch Shield para Arduino pode ser utilizado tanto em forma de shield como ligado externamente, já que você pode por exemplo montar um painel com ele, e o Arduino não precisa necessariamente ficar grudado ao teclado.

Essa ligação externa também pode ser usada quando você vai usar o shield com outros tipos de Arduino. Vamos explicar.

Esse shield foi feito originalmente para ser acoplado ao Arduino Uno R3, usando os pinos 3.3v, SDA, SCL e o pino digital 2, que vai ser utilizado para a interrupção.

No Arduino Mega, por exemplo, os pinos SDA e SCL são o 20 e o 21, logo o Shield não irá funcionar se você encaixa-lo diretamente, mas vai funcionar se você realizar uma conexão externa e ligar os pinos analógicos 4 e 5 do Shield nos pinos 20 (SDA) e 21 (SCL) do Mega. Vamos mostrar isso na prática daqui a pouco.

O teclado em si é formado por 9 teclas,  numa matriz 3x3, e no lado direito do shield podemos observar que há um espaço para mais três eletrodos (pinos ELE9, ELE10 e ELE11), assim você pode ter até 12 teclas disponíveis.

A imagem abaixo mostra os pinos e conexões do Shield, conforme comentamos acima. As portas não identificadas estão livres para uso :

Touch Shield - Pinagem
 
Assim, se você deseja ligar o shield sem usar barra de pinos, ligando os fios diretamente ao Arduino, faça a seguinte conexão :
  • Pino 4 do Shield ao pino SDA do Arduino
  • Pino 5 do Shield ao pino SCL do Arduino
  • Pino GND do Shield ao GND do Arduino (repare na imagem acima que não pode ser qualquer pino GND do Shield. Precisa ser exatamente o indicado no lado esquerdo, ao lado do pino 13)
  • Pino 3.3v do Shield ao 3.3v do Arduino
  • Pino 5v do Shield ao 5v do Arduino
Sua ligação ficará dessa maneira se você utilizar o shield com o Arduino Uno :

Circuito Teclado Touch - Arduino Uno

E dessa se você for utilizar um Arduino Mega :

Circuito Teclado Touch - Arduino Mega








Programa Touch Shield Arduino


O programa abaixo, sem alterações, pode ser utilizado nos dois circuitos mostrados acima. Antes de compilar o programa, coloque os arquivos mpr121.hi2c.h, defs.h e types.h na mesma pasta do programa. Esses arquivos você encontra nesse link. Sua pasta deve ficar mais ou menos assim :

Estrutura de arquivos


  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
//Programa : Teste Touch Shield Sparkfun
//Alteracoes e adaptacoes : Arduino e Cia 
//Baseado no programa original de 
//Aaron Weiss, based on the MPR121 Keypad Example by Jim Lindblom

// Inclui as bibliotecas
#include "mpr121.h"
#include "i2c.h"

// Numero maximo de digitos
#define DIGITS 11 

// Relaciona as entradas do teclado com o numero
// dos eletrodos
#define UM 8
#define DOIS 5
#define TRES 2
#define QUATRO 7
#define CINCO 4
#define SEIS 1
#define SETE 6
#define OITO 3
#define NOVE 0

//Extras (nao utilizado)
#define ELE9 9
#define ELE10 10
#define ELE11 11

//Pino interrupcao
int irqpin = 2;  

void setup()
{
  //Define o pino da interrupcao como entrada e o 
  //coloca em HIGH
  pinMode(irqpin, INPUT);
  digitalWrite(irqpin, HIGH);
  
  Serial.begin(9600);
  
  DDRC |= 0b00010011;
  PORTC = 0b00110000; 
  //Inicializa a comunicacao I2C
  i2cInit();
  
  delay(100);
  //Inicializa o MPR121
  mpr121QuickConfig();
  
  //Cria uma interrupcao e a aciona quando um botao
  //e pressionado e o pino da interrupcao vai para LOW
  attachInterrupt(0,getNumber,LOW);
  
  //Mensagem inicial
  Serial.println("Aguardando...");
}

void loop()
{
  //Coloque aqui algum codigo adicional
}

void getNumber()
{
  int i = 0;
  int touchNumber = 0;
  uint16_t touchstatus;
  char digits[DIGITS];
  
  touchstatus = mpr121Read(0x01) << 8;
  touchstatus |= mpr121Read(0x00);
  
  //Verifica quantas teclas foram pressionadas
  for (int j=0; j<12; j++)
  {
    if ((touchstatus & (1<<j)))
      touchNumber++;
  }
  
  if (touchNumber == 1)
  {
    if (touchstatus & (1<<SETE))
      digits[i] = '7';
    else if (touchstatus & (1<<QUATRO))
      digits[i] = '4';
    else if (touchstatus & (1<<UM))
      digits[i] = '1';
    else if (touchstatus & (1<<OITO))
      digits[i] = '8';
    else if (touchstatus & (1<<CINCO))
      digits[i] = '5';
    else if (touchstatus & (1<<DOIS))
      digits[i] = '2';
    else if (touchstatus & (1<<NOVE))
      digits[i] = '9';
    else if (touchstatus & (1<<SEIS))
      digits[i] = '6';
    else if (touchstatus & (1<<TRES))
      digits[i] = '3';
      
    Serial.print("Tecla pressionada : ");
    Serial.println(digits[i]);
    i++;
  }
  
  //Nao realiza nenhuma acao caso mais de uma tecla
  //seja pressionada
  else if (touchNumber == 0)
    ;
  else
    ;
}

Após carregar o programa no Arduino, abra o serial monitor e acione as teclas do shield. A cada tecla pressionada, você terá uma saída correspondente no Serial Monitor :

Touch Sparkfun - Serial Monitor

Claro que você não ficará limitado aos números de 1 a 12 do shield. Com pequenas alterações, é possível imprimir strings e até mesmo acionar as portas do Arduino a cada acionamento das teclas.

05 agosto 2014

Sensor de temperatura IR TMP006 Adafruit

Parece só mais um sensor de temperatura, mas esse Sensor de temperatura IR TMP006 da Adafruit tem algumas características bem legais. Ele não serve especificamente para medir a temperatura ambiente (apesar de poder ser utilizado para tal). Sua função principal é atuar como um medidor de temperatura de objetos : basta você apontar o sensor para o objeto e ele vai determinar a sua temperatura baseado na radiação infravermelha emitida.


Sensor de temperatura IR TMP006 Adafruit

Esse módulo também permite o uso de até 8 sensores na mesma linha I2C, mediante a mudança de endereço de cada módulo, assim podemos ter um sistema completo de monitoramento de temperatura, em várias fases.

Características do sensor de temperatura IR TMP006


A alimentação vai de 3 à 5 Volts, e a comunicação com o Arduino é feita por meio da conexão I2C, ligando-se o pino SDA ao pino analógico A4 do Arduino Uno (pino 20 no Arduino Mega), e o SCL ao pino analógico A5 (pino 21 no Arduino Mega).

Sensor IR TMP006 - Detalhe Pinagem


Ok, mas e os outros 3 pinos ? DRDY, AD1 e AD0 ?

Esses são utilizados justamente quando você precisa de mais de um módulo no mesmo barramento. Por padrão, os pinos AD1 e AD0 estão ligados ao GND, atribuindo assim ao módulo o endereço 0x40. Se você ligar tanto o AD1 como o AD0 no Vcc, você terá um módulo com endereço 0x45. A tabela abaixo mostra como deve ser a conexão dos pinos para cada endereço (que vai do 0x40 ao 0x47 - 8 sensores, como comentamos no início) :

Tabela I2C TMP006
 
O pino DRDY (Data Ready) não tem muita função na maioria das vezes, mas se você deseja saber exatamente o momento em que a temperatura foi lida pelo sensor e o módulo está pronto para a próxima leitura, basta checar o momento em que o estado desse pino vai para o estado LOW (baixo), e então efetuar uma nova medição.

Circuito sensor de temperatura IR TMP006


Mostre os valores de temperatura em um display LCD 16x2 efetuando a seguinte ligação:

Circuito Arduino sensor de temperatura IR TMP006

O programa utiliza a biblioteca Arduino_TMP006, disponível nesse link. Descompacte o arquivo, e renomeie a pasta Arduino_TMP006-master para Arduino_TMP006. Depois, coloque essa pasta dentro da pasta LIBRARIES da IDE (ambiente de programação) do seu Arduino.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// Programa : Teste sensor de temperatura IR TMP006
// Alteracoes e adaptacoes : Arduino e Cia

/*************************************************** 
  This is an example for the TMP006 Barometric Pressure & Temp Sensor

  Designed specifically to work with the Adafruit TMP006 Breakout 
  ----> https://www.adafruit.com/products/1296

  These displays use I2C to communicate, 2 pins are required to  
  interface
  Adafruit invests time and resources providing this open source code, 
  please support Adafruit and open-source hardware by purchasing 
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#include <Wire.h>
#include <Adafruit_TMP006.h>
#include <LiquidCrystal.h>

// Conexoes do modulo :
// - Conectar pino Vcc do modulo ao 3.3 V ou 5V do Arduino
// - Conectar Gnd ao Gnd do Arduino
// - Conectar o pino SDA ao pino A4 do Arduino (pino 20 no Mega)
// - Conectar o pino SCL ao pino A5 do Arduino (pino 21 no Mega)


Adafruit_TMP006 tmp006;
// Utilize a sintaxe abaixo para definir outro endereco
// Adafruit_TMP006 tmp006(0x41);

// Inicializa o LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 

// Array que desenha o simbolo de grau
byte a[8]= {B00110,B01001,B00110,B00000,B00000,B00000,B00000,B00000,}; 

void setup() 
{ 
  Serial.begin(9600);
  Serial.println("Adafruit TMP006");

  if (! tmp006.begin()) 
  {
    Serial.println("No sensor found");
    while (1);
  }
  // Inicializa o LCD e imprime informacoes iniciais
  lcd.begin(16, 2);
  lcd.createChar(1, a); 
  lcd.setCursor(0,0);
  lcd.print("Adafruit TMP006");
  //Atribui a "1" o valor do array "A", que desenha o simbolo de grau
  lcd.setCursor(0,1);
  lcd.print("Temp.:");
}

void loop() 
{
   float objt = tmp006.readObjTempC();
   
   //Imprime os dados de temperatura na serial
   Serial.print("Object Temperature: "); 
   Serial.print(objt); 
   Serial.println("C");
   
   //Imprime os dados de temperatura no display
   lcd.setCursor(7,1);
   lcd.print(objt);
   lcd.setCursor(12,1);
   lcd.write(1);
  
   //Aguarda 4 segundos e realiza a próxima leitura
   delay(4000);
}

Algumas considerações devem ser feitas sobre esse sensor, principalmente sobre o ângulo de leitura. Esse sensor tem um ângulo de leitura bem grande, então você deve observar a proximidade do objeto com o sensor. Tome como exemplo um pequeno objeto que você está segurando com a mão.  Dependendo da distância do sensor, ele pode estar lendo a temperatura da sua mão, e não a temperatura do objeto, por isso fique atento à esse detalhe. Informações completas sobre ângulo de leitura e outras informações sobre o sensor TMP006 você pode obter nesse link.

Outra questão é a superfície do objeto a ser medido. Esse sensor apresenta melhores condições na leitura de objetos de cor escura. Objetos com superfície polida ou metálica podem apresentar alguma variação nos dados lidos pelo sensor.

Existe uma tabela que apresenta os coeficientes de emissão de radiação de calor de alguns materiais. Um material na cor preta tem coeficiente 1, que seria o valor ideal. Uma folha de alumínio tem o coeficiente 0,09 , o que dificulta a leitura. Já um tijolo tem o coeficiente 0,93. Quanto mais próximo de 1 for esse valor, melhor a leitura.