27 abril 2013

LCD 16x2 + RTC + Numeros Grandes

Resolvi incrementar o post que eu fiz, sobre o LCD 16x2 (Display LCD Winstar WH1602A), e coloca-lo para funcionar com o DS1307 (RTC), do artigo anterior. A idéia foi juntar os 2 circuitos, e fazer um relógio mostrando os números, obviamente, no LCD.

Como eu não fiquei contente com o resultado, porque os números ficaram muito pequenos no LCD, comecei a caçar exemplos para aproveitar a tela inteira e mostrar os números em um formato maior, criando meu próprio programa. O resultado está aqui :

Relogio RTC DS1307 Arduino

RTC DS1307 - LCD 16x2


Se voce tiver dúvidas no circuito, recomendo a leitura dos posts mencionados, porque a ligação é exatamente a mesma. Vamos lá :
 
relogio Arduino DS1307
Carregue o seguinte programa no 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
 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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
//Programa : Relogio com numeros customizados
//Autor : Arduino e Cia

#include <LiquidCrystal.h> //Biblioteca LCD

#include "Wire.h" //Biblioteca para uso do RTC DS1307

#define DS1307_ADDRESS 0x68

byte zero = 0x00; 

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int numero, minutoanterior1,minutoanterior2,horaanterior1,horaanterior2;
int x = 0;

//Arrays para criação dos segmentos e customização dos números
byte LT[8] = 
{
  B01111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111
};
byte UB[8] =
{
  B11111,  B11111,  B11111,  B00000,  B00000,  B00000,  B00000,  B00000
};
byte RT[8] =
{
  B11110,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111
};
byte LL[8] =
{
  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B01111
};
byte LB[8] =
{
  B00000,  B00000,  B00000,  B00000,  B00000,  B11111,  B11111,  B11111
};
byte LR[8] =
{
  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11111,  B11110
};
byte UMB[8] =
{
  B11111,  B11111,  B11111,  B00000,  B00000,  B00000,  B11111,  B11111
};
byte LMB[8] =
{
  B11111,  B00000,  B00000,  B00000,  B00000,  B11111,  B11111,  B11111
};

void setup()
{
  Wire.begin();
  //Associa cada segmento criado, a um número
  lcd.createChar(0,LT);
  lcd.createChar(1,UB);
  lcd.createChar(2,RT);
  lcd.createChar(3,LL);
  lcd.createChar(4,LB);
  lcd.createChar(5,LR);
  lcd.createChar(6,UMB);
  lcd.createChar(7,LMB);

  lcd.begin(16, 2); //Inicializa o LCD

  //A linha abaixo pode ser retirada apos setar a data e hora
  //SelecionaDataeHora(); 
}

void loop()
{
  lcd.setCursor(8,0);
  lcd.print(".");
  lcd.setCursor(8,1);
  lcd.print(".");
  //Chama rotina que extrai as informacoes do DS1307 e mostra no LCD
  Mostrarelogio(); 
  delay(1000);
}

void SelecionaDataeHora()   //Seta a data e a hora do DS1307
{
  byte segundos = 00; //Valores de 0 a 59
  byte minutos = 44; //Valores de 0 a 59
  byte horas = 22; //Valores de 0 a 23
  byte diadasemana = 1; //Valores de 0 a 6 - 0=Domgino, 1 = Segunda, etc.
  byte diadomes = 17; //Valores de 1 a 31
  byte mes = 4; //Valores de 1 a 12
  byte ano = 13; //Valores de 0 a 99
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero); //Stop no CI para que o mesmo possa receber os dados

  // As linhas abaixo escrevem no CI os valores de data e 
  // hora que foram colocados nas variaveis acima
  Wire.write(ConverteParaBCD(segundos));
  Wire.write(ConverteParaBCD(minutos));
  Wire.write(ConverteParaBCD(horas));
  Wire.write(ConverteParaBCD(diadasemana));
  Wire.write(ConverteParaBCD(diadomes));
  Wire.write(ConverteParaBCD(mes));
  Wire.write(ConverteParaBCD(ano));
  Wire.write(zero); //Start no CI
  Wire.endTransmission(); 
}

byte ConverteParaBCD(byte val){ //Converte o número de decimal para BCD
  return ( (val/10*16) + (val%10) );
}

byte ConverteparaDecimal(byte val)  { //Converte de BCD para decimal
  return ( (val/16*10) + (val%16) );
}

void custom0()//Seleciona os segmentos para formar o numero 0
{ 
  lcd.setCursor(x, 0); //Seleciona a linha superior
  lcd.write((byte)0);  //Segmento 0 selecionado
  lcd.write(1);  //Segmento 1 selecionado
  lcd.write(2);
  lcd.setCursor(x, 1); //Seleciona a linha inferior
  lcd.write(3);  
  lcd.write(4);  
  lcd.write(5);
}

void custom1() //Seleciona os segmentos para formar o numero 1
{
  lcd.setCursor(x,0);
  lcd.write(1);
  lcd.write(2);
  lcd.setCursor(x+1,1);
  lcd.write(5);
}

void custom2() //Seleciona os segmentos para formar o numero 2
{
  lcd.setCursor(x,0);
  lcd.write(6);
  lcd.write(6);
  lcd.write(2);
  lcd.setCursor(x, 1);
  lcd.write(3);
  lcd.write(7);
  lcd.write(7);
}

void custom3()  //Seleciona os segmentos para formar o numero 3
{
  lcd.setCursor(x,0);
  lcd.write(6);
  lcd.write(6);
  lcd.write(2);
  lcd.setCursor(x, 1);
  lcd.write(7);
  lcd.write(7);
  lcd.write(5); 
}

void custom4()  //Seleciona os segmentos para formar o numero 4
{
  lcd.setCursor(x,0);
  lcd.write(3);
  lcd.write(4);
  lcd.write(2);
  lcd.setCursor(x+2, 1);
  lcd.write(5);
}

void custom5()  //Seleciona os segmentos para formar o numero 5
{
  lcd.setCursor(x,0);
  lcd.write((byte)0);
  lcd.write(6);
  lcd.write(6);
  lcd.setCursor(x, 1);
  lcd.write(7);
  lcd.write(7);
  lcd.write(5);
}

void custom6()  //Seleciona os segmentos para formar o numero 6
{
  lcd.setCursor(x,0);
  lcd.write((byte)0);
  lcd.write(6);
  lcd.write(6);
  lcd.setCursor(x, 1);
  lcd.write(3);
  lcd.write(7);
  lcd.write(5);
}

void custom7() //Seleciona os segmentos para formar o numero 7
{
  lcd.setCursor(x,0);
  lcd.write(1);
  lcd.write(1);
  lcd.write(2);
  lcd.setCursor(x+1, 1);
  lcd.write((byte)0);
}

void custom8()  //Seleciona os segmentos para formar o numero 8
{
  lcd.setCursor(x,0);
  lcd.write((byte)0);
  lcd.write((byte)6);
  lcd.write(2);
  lcd.setCursor(x, 1);
  lcd.write(3);
  lcd.write(7);
  lcd.write(5);
}

void custom9()  //Seleciona os segmentos para formar o numero 9
{
  lcd.setCursor(x,0);
  lcd.write((byte)0);
  lcd.write((byte)6);
  lcd.write((byte)2);
  lcd.setCursor(x+2, 1);
  lcd.write((byte)5);
}

void Mostrarelogio()
{
  byte minut[2];
  String minutostring;
  String digitosegundos;
  char buf;
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int segundos = ConverteparaDecimal(Wire.read());
  int minutos = ConverteparaDecimal(Wire.read());
  int horas = ConverteparaDecimal(Wire.read() & 0b111111); 
  int diadasemana = ConverteparaDecimal(Wire.read()); 
  int diadomes = ConverteparaDecimal(Wire.read());
  int mes = ConverteparaDecimal(Wire.read());
  int ano = ConverteparaDecimal(Wire.read());

  x = 0;
  numero = horas/10;
  
  //Condicional para evitar sobreposição de caracteres
  if (horaanterior1 != minutos %10) 
  {
    lcd.setCursor(0,0);
    lcd.print("   ");
    lcd.setCursor(0,1);
    lcd.print("   ");
    horaanterior1 = minutos %10;
  }

  //Chama rotina que mostra o numero customizado na tela
  mostranumero(); 

  x = 4;
  numero = horas % 10;
  if (horaanterior2 != minutos %10)
  {
    lcd.setCursor(4,0);
    lcd.print("   ");
    lcd.setCursor(4,1);
    lcd.print("   ");
    horaanterior2 = minutos %10;
  }
  mostranumero();
  
  x = 9;
  numero = minutos/10;

  if (minutoanterior1 != minutos %10)
  {
    lcd.setCursor(9,0);
    lcd.print("   ");
    lcd.setCursor(9,1);
    lcd.print("   ");
    minutoanterior1 = minutos %10;
  }
  mostranumero();

  x = 13;
  numero = minutos % 10;
  if (minutoanterior2 != minutos %10)
  {
    lcd.setCursor(13,0);
    lcd.print("   ");
    lcd.setCursor(13,1);
    lcd.print("   ");
    minutoanterior2 = minutos %10;
  }
  mostranumero();
}

void mostranumero() //Mostra o numero na posicao definida por "X"
{
  switch(numero)
    {
      case 0:custom0();
      break;
      case 1:custom1();
      break;
      case 2:custom2();
      break;
      case 3:custom3();
      break;
      case 4:custom4();
      break;
      case 5:custom5();
      break;
      case 6:custom6();
      break;
      case 7:custom7();
      break;
      case 8:custom8();
      break;
      case 9:custom9();
      break;
    }
}

O que o programa faz é criar blocos customizaveis, que vão formar os números grandes. Depois, associamos essas blocos conforme o caracter a ser gerado, assim, o número 1 será formado pelos blocos 1 (UB), 2 (RT), e 5 (LR), o número 2 será formado pelos blocos 6 (UMB), 6(UMB), 1(UB), 3(LL), 7(LMB) e 7(LMB) e assim por diante. É praticamente um quebra-cabeça, mas mais divertido. :-)

 Tente alterar essas linhas (byte UB[8], byte LT[8].....) para modificar o segmento e obter outros efeitos, como cantos retos, mais arredondados, etc.

Uma evolução do programa seria mostrar também a data, de tempos em tempos, ou ao toque de um botão, ou então usar esses blocos para montar as letras do alfabeto. Mas isso é assunto para outro post. Até lá !

20 abril 2013

Real Time Clock (RTC) DS1307

Hoje vou montar um esquema bem simples de relógio usando o DS1307, um circuito integrado RTC (Real Time Clock), que nada mais é do que um chip que "conta o tempo". Suas principais características são :
  • Conta Ano, mês, semana, dias da semana, dias, horas, minutos, segundo
  • Identifica anos bissextos
  • Utiliza interface I2C, usando apenas 2 pinos para se comunicar com o Arduino, ao contrário do seu antecessor DS1302, que usa 3 pinos.
Relogio de tempo real DS1307
Pinagem DS1307

Monte o circuito abaixo na protoboard. O cristal é de 32,768 KHz, eu tirei o meu de uma motherboard antiga. Tenho mais um que tirei de um relógio quebrado, que você com certeza também tem jogado em algum canto aí na sua casa. Vários aparelhos eletronicos tem um cristal desses dentro. ;-)

Cristal 32.768 khz


Circuito DS1307 e Arduino
Um detalhe é a bateria, que é obrigatória nesse circuito. Sem ela, o CI gera alguns resultados bem estranhos. A bateria serve também para que, caso o Arduino seja desligado, as informações de data e hora sejam preservadas. O consumo do CI é baixíssimo (500 nano ampéres), o que significa que uma bateria de 3V ligada permanentemente ao circuito dura muito tempo.

No meu caso, usei uma CR2032, dessas que a gente usa na motherboard do computador.

Protoboard - Arduino - DS1307
Finalmente, vamos ao programa. Carregue o programa abaixo no 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
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
// Programa : Data e Hora com DS1307
// Autor : Arduino e Cia

#include "Wire.h"

#define DS1307_ADDRESS 0x68

byte zero = 0x00; 

void setup()
{
  Wire.begin();
  Serial.begin(9600);
  //A linha abaixo pode ser retirada apos setar a data e hora
  SelecionaDataeHora(); 
}

void loop()
{
  Mostrarelogio();
  delay(1000);
}

void SelecionaDataeHora()   //Seta a data e a hora do DS1307
{
  byte segundos = 40; //Valores de 0 a 59
  byte minutos = 59; //Valores de 0 a 59
  byte horas = 23; //Valores de 0 a 23
  byte diadasemana = 1; //Valores de 0 a 6 - 0=Domingo, 1 = Segunda, etc.
  byte diadomes = 17; //Valores de 1 a 31
  byte mes = 4; //Valores de 1 a 12
  byte ano = 13; //Valores de 0 a 99
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero); //Stop no CI para que o mesmo possa receber os dados

  //As linhas abaixo escrevem no CI os valores de 
  //data e hora que foram colocados nas variaveis acima
  Wire.write(ConverteParaBCD(segundos));
  Wire.write(ConverteParaBCD(minutos));
  Wire.write(ConverteParaBCD(horas));
  Wire.write(ConverteParaBCD(diadasemana));
  Wire.write(ConverteParaBCD(diadomes));
  Wire.write(ConverteParaBCD(mes));
  Wire.write(ConverteParaBCD(ano));
  Wire.write(zero); //Start no CI
  Wire.endTransmission(); 
}

byte ConverteParaBCD(byte val){ //Converte o número de decimal para BCD
  return ( (val/10*16) + (val%10) );
}

byte ConverteparaDecimal(byte val)  { //Converte de BCD para decimal
  return ( (val/16*10) + (val%16) );
}

void Mostrarelogio()
{
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 7);
  int segundos = ConverteparaDecimal(Wire.read());
  int minutos = ConverteparaDecimal(Wire.read());
  int horas = ConverteparaDecimal(Wire.read() & 0b111111); 
  int diadasemana = ConverteparaDecimal(Wire.read()); 
  int diadomes = ConverteparaDecimal(Wire.read());
  int mes = ConverteparaDecimal(Wire.read());
  int ano = ConverteparaDecimal(Wire.read());
  //Mostra a data no Serial Monitor
  Serial.print("Data: ");
  Serial.print(diadomes);
  Serial.print("/");
  Serial.print(mes);
  Serial.print("/");
  Serial.print(ano);
  Serial.print(" ");
  Serial.print("Hora : ");
  Serial.print(horas);
  Serial.print(":");
  Serial.print(minutos);
  Serial.print(":");
  Serial.print(segundos);
  switch(diadasemana)
    {
      case 0:Serial.println(", Domingo");
      break;
      case 1:Serial.println(", Segunda");
      break;
      case 2:Serial.println(", Terca");
      break;
      case 3:Serial.println(", Quarta");
      break;
      case 4:Serial.println(", Quinta");
      break;
      case 5:Serial.println(", Sexta");
      break;
      case 6:Serial.println(", Sabado");
    }
}

O que ele faz nada mais é do que setar a data e a hora, como indicado no programa, e depois mostrar esses valores no serial monitor, como na figura abaixo :

Serial Monitor - RTC DS1307

A linha 15 do programa, com a indicação SelecionaDataeHora(), é utilizada para setar os dados iniciais do relógio e pode ser comentada posteriormente, já que o DS1307 estará sendo alimentado pela bateria. 

Por último, não podia esquecer do Datasheet do DS1307, que você encontra aqui.


11 abril 2013

Sensor de temperatura DS18B20 - Continuação

Continuando o assunto do sensor de temperatura DS18B20, hoje vou abordar a identificação e utilização desses sensores.

Encontrei muitos artigos na internet falando sobre esse sensor, mas poucos explicando como utilizá-los em quantidade, afinal, uma das grandes vantagens desse sensor é que você pode utilizar vários deles usando uma única porta do Arduino.

O que vamos mostrar do DS18B20


Partindo desse principio, vou apresentar um circuito com 2 sensores, e vamos utilizar 2 programas para :

1 - Identificar o endereço físico de cada sensor DS18B20
2 - Utilizar esse endereço físico para obter a temperatura do sensor desejado

Os exemplos, com as alterações de praxe (traduções/comentários), foram retiradas do site Hacktronics :

Monte o circuito abaixo, tomando cuidado com a pinagem do sensor :

sensor de temperatura DS18B20
Obs : Utilizei resistores de 4K7

Baixe as bibliotecas abaixo, e copie para a pasta LIBRARIES da IDE do seu Arduino :

Biblioteca OneWire :

Biblioteca Dallas :

Agora carregue o programa abaixo, que vai identificar os endereços físicos dos sensores:

 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
// Programa : Scan DS18B20
// Alterações : Arduino e Cia
// Este programa procura pelos sensores no circuito e mostra o valor 
// do endereço físico de cada sensor no Serial Monitor

#include <OneWire.h>

// Conecte o pino central dos sensores ao pino 10 do Arduino
OneWire  ds(10);  

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

void discoverOneWireDevices(void) 
{
  byte i;
  byte present = 0;
  byte data[12];
  byte addr[8];

  Serial.print("Procurando dispositivos DS18B20...\n\r");

  while(ds.search(addr)) 
  {
    Serial.print("\n\rEncontrado sensor \'DS18B20\' com endereco:\n\r");
    for( i = 0; i < 8; i++) 
    {
      Serial.print("0x");
       if (addr[i] < 16) 
       {
        Serial.print('0');

       }
      Serial.print(addr[i], HEX);

       if (i < 7) 
       {
        Serial.print(", ");
       }

    }

    if ( OneWire::crc8( addr, 7) != addr[7]) 
    {
        Serial.print("CRC nao e valido!\n");
        return;
    }
  }
  Serial.print("\n\r\n\rFinal da verificacao.\r\n");
  ds.reset_search();
  return;
}

void loop(void) 
{
  // Loop Vazio
} 

Após transferir o programa para o Arduino, abra o Serial monitor, e você verá uma tela como essa, mostrando o endereço de cada DS18B20 :

Serial monitor - Scan DS18B20

Mostrando a temperatura no serial monitor com o DS18B20


Agora que você já tem o endereço de cada sensor, vamos utilizar um outro programa que vai usar os endereços obtidos acima, relacionar cada um com uma variável, e mostrar as temperaturas na tela :

 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
// Programa : Leitor temperatura sensores DS18B20
// Alterações : Arduino e Cia
// Este programa usa o endereço físico de cada sensor para mostrar as 
// informações de temperatura no Serial Monitor

#include <OneWire.h>

#include <DallasTemperature.h>

// Conectar o pino central dos sensores ao pino 10 do Arduino
#define ONE_WIRE_BUS 10

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);
DeviceAddress insideThermometer = { 0x28, 0xE1, 0x20, 0x9D, 0x04, 0x00, 0x00, 0x1A };
DeviceAddress outsideThermometer = { 0x28, 0xE5, 0x82, 0x9D, 0x04, 0x00, 0x00, 0x76 };
DeviceAddress dogHouseThermometer = { 0x28, 0x59, 0xBE, 0xDF, 0x02, 0x00, 0x00, 0x9F };

void setup(void)
{
  // start serial port
  Serial.begin(9600);
  // Start up the library
  sensors.begin();
  // set the resolution to 10 bit (good enough?)
  sensors.setResolution(insideThermometer, 10);
  sensors.setResolution(outsideThermometer, 10);
  sensors.setResolution(dogHouseThermometer, 10);
}

void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  if (tempC == -127.00) 
  {
    Serial.print("Erro ao ler temperatura !");
  } 
  else 
  {
    Serial.print("C: ");
    Serial.print(tempC);
    Serial.print(" F: ");
    Serial.print(DallasTemperature::toFahrenheit(tempC));
  }
}

void loop(void)
{ 
  delay(10000);
  Serial.print("Lendo temperaturas...\n\r");
  sensors.requestTemperatures();
  Serial.print("Temperatura Sensor 1: ");
  printTemperature(insideThermometer);
  Serial.print("\n\r");
  Serial.print("Temperatura Sensor 2: ");
  printTemperature(outsideThermometer);
  Serial.print("\n\r");
  Serial.print("Temperatura Sensor 3: ");
  printTemperature(dogHouseThermometer);
  Serial.print("\n\r\n\r");
}

Abra o serial monitor , para obter a temperatura dos sensores, em Celsius e Fahrenheit :

Lendo temperatura sensores DS18B20

Por enquanto é só. Mais informações sobre o sensor e como obter o datasheet você pode encontrar no meu artigo anterior sobre o DS18B20, clicando aqui.

02 abril 2013

Sensor de temperatura DS18B20

O DS18B20 é um sensor de temperatura digital, sendo uma alternativa interessante ao LM35.

Sensor de temperatura DS18B20


As características do DS18B20 são :
  • Utilização de apenas 1 pino para conexão ao microcontrolador
  • Possibilidade de utilizar mais de 1 sensor na mesma porta do Arduino, pois cada sensor tem um endereço físico, podendo ser acessado individualmente pelo microcontrolador
  • Sua tensão de operação vai de 3.0V a 5.5V
  • Sua faixa de leitura de temperatura vai de -55°C a +125°C
  • Possui um alarme interno, que pode ser ativado caso a temperatura esteja fora de um limite pré estabelecido
  • Para obter o datasheet com as informações completas do DS18B20, clique aqui.


DS18B20 - Pinagem
No próximo artigo, vou mostrar como obter o endereço físico do DS18B20, e como utilizar esse endereço em um circuito com 2 sensores. Até lá !