Medição de Temperatura Usando-se Termopar Tipo K

Helvio Fernando Guedes

Osnir Dias Junior

Vinicius Baldo

CÂMPUS CATANDUVA - SP

JULHO DE 2018
1. INTRODUÇÃO

Nas indústrias atualmente vem-se utilizando um dispositivo que

possui uma maior gama de aplicações, versatibilidade, simplicidade e
confiabilidade para medição de temperatura entre as faixas de -200°C a +
1700°C, os termopares. Estes correspondem a dispositivos elétricos utilizados
para a medição de temperatura. Foram descobertos por acaso em 1822, um
físico Thomas Seebeck ligou dois metais onde foi gerada uma tensão elétrica
em função da temperatura.
O termopar é um transdutor que compreende dois pedaços de fios
dissimilares, unidos em uma das extremidades, um termopar deve exibir
algumas propriedades como:

a) F.e.m termal relativamente grande;

b) Precisão de calibração;
c) Resistência a corrosão e oxidação;
d) Relação f.e.m./temperatura aproximadamente linear.

Os termopares são encontrados em diversos formatos, estes

possuem características diferentes como: aplicação que se deseja do mesmo,
temperatura suportada, exatidão, confiabilidade de leitura, especificação do tipo
de liga e construção física externa.
No presente trabalho será utilizado o termopar tipo K. Este tipo é
formado por fios de Chromel, como termoelemento positivo e Alumel, como
termoelemento negativo, este é adequado para medição contínua de -200 °C
até 1260 °C podem ser utilizados em uso contínuo em atmosfera oxidantes ou
completamente inertes, é resistente à oxidação em temperaturas altas e possui
uma sensibilidade de aproximadamente 41 µV/°C.
Segundo Moreira 2002, a uma grande variedade de meios em que o
termopar pode ser incorporado como um sensor capaz de medir temperaturas
de um sistema físico. Porém são necessários alguns cuidados para garantir
uma correta indicação da temperatura onde ele será utilizado, como:
 a) Garantir que a junção de medição esteja em uma condição
isotérmica;
b) Ser conectado a dois sistemas físicos em duas temperaturas
diferentes;
c) A junção de referência deve ser isotérmica para propiciar uma
temperatura conhecida e assim auxiliar na obtenção de uma
interface do sinal, que isola o sensor da instrumentação, para
garantir uma confiança na medição usando o termopar deve-se
seguir alguns passos por usuário ou por funções automáticas do
instrumento como:

i. Estabelecer uma junção referência isotérmica;

ii. Conhecer a temperatura da junção de referência;
iii. Usar as tabelas padronizadas ou as funções de referências
para determinar a tensão Seebeck na temperatura da junção
referência;
iv. Fazer uma medição exata da tensão Seebeck do termopar;
v. Somar as duas tensões;
vi. Usar as tabelas padronizadas ou as funções de referência
para determinar a temperatura medida.

A tensão de Seebeck é a tensão de um circuito aberto por meio da

junção de referência e assim aumenta à medida que a diferença da
temperatura entre as junções aumenta.

2. OBJETIVO

O presente projeto tem como objetivo principal a aplicação dos

conhecimentos adquiridos no decorrer do curso de Tecnologia em Mecatrônica
Industrial, a confecção do sistema de instrumentação para medição de
temperatura do termopar tipo K, como já foi mencionado anteriormente, este
sistema será utilizado posteriormente no trabalho de conclusão de curso, sua
finalidade será de monitorar a temperatura do corpo de prova que sairá do
interior de um forno a uma temperatura próxima a 900 °C, que será imerso em
um fluido para a refrigeração deste corpo de prova, o termopar que estará
monitorando a temperatura será responsável pela aquisição dos dados
necessários para o equacionamento da transferência de calor entre o fluido e o
corpo.
Neste projeto da disciplina de sistemas microcontrolados, o sensor
de temperatura será instrumentado e calibrado para atender as medições de
temperatura em uma faixa de 0 – 1000 °C.

3. MATERIAIS E METODOS

A metodologia adota no presente projeto constituiu em montar o

circuito primeiramente em uma placa específica para uso eletrônico a
protoboard, onde se foi possível construir o circuito eletroeletrônico para testar
o funcionamento dos mesmos, para após serem confeccionadas as placas de
circuito impresso.

Os componentes eletrônicos exigidos para integração do projeto

foram:

a) Amplificador de instrumentação, no qual foi utilizado o AD620,

necessitando de uma tensão negativa, foi confeccionado uma
fonte simétrica de tensões entre as faixas de -5 e +5 volts;
b) Conversor analógico / digital, no qual foi utilizado MCP3202;
c) Display LCD para a visualização dos valores de medição.

A conversão do sinal e o ganho do sistema, foram estabelecidos

pelos componentes externos, sendo eles o conversor AD e o amplificador
AD620, sem nenhuma influência do microcontrolador ATMEGA328p ou do
código de programação.
3.1. Termopar Tipo K

O fio positivo deste termopar é feito de Chromel, uma liga de 90% de

níquel e 10% de cromo e o fio negativo é feito de Alumel, uma liga com 94,5%
de níquel, associado a manganês, alumínio e silício, sua faixa de trabalho é de
0 a 1250 °C. Embora por possuir valor de mercado acima do que o termopar
tipo J, não é utilizado na medição de temperaturas inferiores a cerca de 400°C.

2.2. Amplificador de Instrumentação AD620

Este componente é um dispositivo que requer apenas o uso de um

resistor para a sua definição de ganho, podendo ser definido uma faixa de
ganho de 1 a 1000. Devido a necessidade de se obter a aquisição de dados de
temperaturas do termopar tipo K próxima a real, este componente é de suma
importância no projeto.
Para a determinação do ganho, foi utilizado uma equação para a
determinação do mesmo. O equacionamento é apresentado a seguir:

G = (R1 / R2) + 1

2.3. Conversor Analógico Digital MCP3202

O MCP3202 é um conversor analógico digital de 12 bits, que possui

circuitos integrados conhecidos como circuitos de amostragem e retenção, no
seu sistema de microchip, a comunicação do MCP3202 com o microcontrolador
foi realizada através da interface serial simples, compatível com o protocolo
SPI.

2.4. Conversor de Tensão

Para a conversão de tensão necessária para a confecção do projeto,

que necessitava de uma faixa de tensão de -5 a +5 para a alimentação do pino
4 do amplificador AD620, foi desenvolvida uma fonte simétrica. A figura 1
ilustra visualmente circuito realizado no software PROTEUS.
 Figura 1. Fonte de Alimentação

Fonte: Autor, 2018.

2.5. Circuito Integrado Termopar Tipo K

Após os testes e a simulação no software PROTEUS, pode-se

confeccionar a placa de circuito impresso para a fixação dos componentes a
mesma, a figura 2 ilustra visualmente o circuito integrado.

Figura 2. Circuito do Termopar Tipo K. (a) Circuito; (b) Simulação da placa em 3D.

(a) (b)
Fonte: Autor, 2018.
2.6. Aquisição do Equacionamento do Range

Para se obter a equação necessária para a definição da faixa de

temperatura para o presente projeto, foi utilizado a tabela do fabricante do
termopar, onde os dados são apresentados em milivolts gerado pela junção da
junta fria do termopar e o software EXCEL para traçar uma linha de tendência e
encontrar o equacionamento a ser incluído na programação, cada grau Celsius
apresentado na tabela possui um valor em milivolts, a faixa de trabalho do
termopar tipo K para este projeto é de 0 a 1000 °C, conforme já foi dito
anteriormente. Foi digitalizado em uma planilha do excel todos os valores de 0
a 1000 graus Celsius com seus respectivos valores em milivolts. A figura 3
apresenta visualmente a equação obtida para o presente trabalho.

Figura 3. Equação obtida através da linha de tendência.

Fonte: Autor, 2018.

2.7. COMPONENTES

Para a realização do projeto foram adquiridos os componentes

necessários para a confecção do mesmo. A tabela 1 apresenta os itens
adquiridos para o projeto, com seus respectivos valores de mercado.

Tabela 1. Componentes utilizados no projeto.

Componentes Unidade Valor R$

Termopar Tipo K 01 70,00

Placa Fenolite 10CM x 10CM 01 5,00

Arduino UNO 01 49,90

Display LCD 16x2 01 24,00

Regulador de Tensão 7805 01 4,50

Regulador de Tensão 7905 01 4,50

Amp. Operacional LM741 01 4,00

Sensor LM35 01 8,90

Microchip AD620 01 24,00

Microchip MCP3202 01 12,00

Borne 3 vias 03 7,00

Borne 2 vias 02 3,00

Diodo 1N4007 04 1,00

Capacitor 100p 02 1,20

Capacitor 100n 02 1,20

Capacitor 330 n 02 1,20

Capacitor 2200u 02 1,20

LED Vermelho 01 1,00

Resistor de 10K Ohms 04 2,00

Resistor de 3K Ohms 02 1,00

CUSTO TOTAL DO PROJETO 226,60

2.4. Programação do Projeto

A programação do projeto, foi desenvolvida na plataforma AVR

Studio 5.1, a mesma será apresentada a seguir.

Biblioteca (def_principais.h)

#ifndef _DEF_PRINCIPAIS_H
#define _DEF_PRINCIPAIS_H

#define F_CPU 16000000UL //define a frequencia do microcontrolador - 16MHz

#include <avr/io.h> //definições do componente especificado

#include <util/delay.h> //biblioteca para o uso das rotinas de _delay_ms e
_delay_us()
#include <avr/pgmspace.h> //para o uso do PROGMEM, gravação de dados na memória
flash
#include <stdlib.h> //para conversão de valores
#include <math.h>
#include <avr/interrupt.h>

//Definições de macros para o trabalho com bits

#define set_bit(y,bit) (y|=(1<<bit)) //coloca em 1 o bit x da variável

Y
#define clr_bit(y,bit) (y&=~(1<<bit)) //coloca em 0 o bit x da
variável Y
#define cpl_bit(y,bit) (y^=(1<<bit)) //troca o estado lógico do bit x da
variável Y
#define tst_bit(y,bit) (y&(1<<bit)) //retorna 0 ou 1 conforme leitura do bit

#endif

Código Principal (Termopar.c)

/*
* Termopar.c
*
* Created: 10/05/2018 22:48:02
* Author: HELVIO GUEDES
*/

#include "def_principais.h"
#include "LCD.h"
#include "LTC1298.h"
#include "USART.h"

unsigned int Temp_LM35;

unsigned int temperatura;
unsigned char digitos[tam_vetor];
float Vconv_LM35=0, Tensao_TP=0, Temp_Real;
char MAIN_String[20], MEASURES=5;
unsigned long int valor;

int main()
{
DDRD = 0xFF;

//configura ADC

ADMUX = 0b11000000; //Tensão interna de ref (1.1V), canal 0

ADCSRA = 0b11101111; /*habilita o AD, habilita interrupção, modo de
conversão contínua, prescaler = 128*/
ADCSRB = 0x00; //modo de conversão contínua
set_bit(DIDR0,0); //desabilita pino PC0 como I/0, entrada do ADC0
DDRC = (0<<0);

inic_SPI();
inic_LCD_4bits();
initUSART(BAUD_PRESCALE);
 sei();

while(1)

{
valor=0;
for(int i=0; i<MEASURES; i++) {valor+=spi();}
valor = valor/(MEASURES+1);

valor=spi();

Tensao_TP = (((valor*0.001220703125)/85.71)*1000); //G=85.71

Vconv_LM35 = (((0.0417*Temp_LM35)-0.1537)/10); //y=0,0417x-0,1537 #

x=(y+0,1537)/0,0417

Temp_Real = ((Vconv_LM35+Tensao_TP+0.1537)/0.0417); //y=0,0417x-

0,1537

ident_num(Temp_Real, digitos);
cmd_LCD(0x81,0);
escreve_LCD(digitos);
printString("Temperatura: ");
printString(digitos);
printString(" C\n");

_delay_ms(1000);
}
}

ISR(ADC_vect)

{
Temp_LM35 = (ADC + (ADC*19)/256); //Converção do LM35
}

Biblioteca LCD (LCD.h)

#ifndef _LCD_H
#define _LCD_H

#include "def_principais.h"

//Definições para facilitar a troca dos pinos do hardware e facilitar a re-

programação

#define DADOS_LCD PORTD //4 bits de dados do LCD no PORTD

#define nibble_dados 0 //0 para via de dados do LCD nos 4 LSBs do PORT empregado
(Px0-D4, Px1-D5, Px2-D6, Px3-D7)

//1 para via de dados do LCD nos 4 MSBs do PORT empregado (Px4-D4, Px5-D5, Px6-
D6, Px7-D7)

#define CONTR_LCD PORTD //PORT com os pinos de controle do LCD (pino R/W
em 0).
#define E PD6 //pino de habilitação do LCD (enable)
#define RS PD7 //pino para informar se o dado é uma instrução ou
caractere
#define tam_vetor 5 //número de digitos individuais para a conversão por
ident_num()
#define conv_ascii 48 //48 se ident_num() deve retornar um número no formato
ASCII (0 para formato normal)

//sinal de habilitação para o LCD

#define pulso_enable() _delay_us(1); set_bit(CONTR_LCD,E); _delay_us(1);

clr_bit(CONTR_LCD,E); _delay_us(45)

//protótipo das funções

void cmd_LCD(unsigned char c, char cd);

void inic_LCD_4bits();
void escreve_LCD(char *c);
void escreve_LCD_Flash(const char *c);

void ident_num(unsigned int valor, unsigned char *disp);

#endif

Código LCD (LCD.c)

#include "LCD.h"

//-------------------------------------------------------------------------------
// Sub-rotina para enviar caracteres e comandos ao LCD com via de dados de 4 bits
//-------------------------------------------------------------------------------

void cmd_LCD(unsigned char c, char cd) //c é o dado e cd indica se é instrução

ou caractere

{
if(cd==0)
clr_bit(CONTR_LCD,RS);
else
set_bit(CONTR_LCD,RS);

//primeiro nibble de dados - 4 MSB

#if (nibble_dados)

//compila código para os pinos de dados do LCD nos 4 MSB do PORT

DADOS_LCD = (DADOS_LCD & 0x0F)|(0xF0 & c);
#else

//compila código para os pinos de dados do LCD nos 4 LSB do PORT

DADOS_LCD = (DADOS_LCD & 0xF0)|(c>>4);

#endif

pulso_enable();

//segundo nibble de dados - 4 LSB

#if (nibble_dados)

//compila código para os pinos de dados do LCD nos 4 MSB do PORT

DADOS_LCD = (DADOS_LCD & 0x0F) | (0xF0 & (c<<4));
#else
 //compila código para os pinos de dados do LCD nos 4 LSB do PORT
DADOS_LCD = (DADOS_LCD & 0xF0) | (0x0F & c);

#endif

pulso_enable();

if((cd==0) && (c<4)) //se for instrução de retorno ou limpeza espera LCD
estar pronto
_delay_ms(2);
}

//-----------------------------------------------------------------------------//
//Sub-rotina para inicialização do LCD com via de dados de 4 bits //
//-----------------------------------------------------------------------------//

void inic_LCD_4bits() //sequência ditada pelo fabricando do circuito integrado

HD44780
{
//o LCD será só escrito. Então, R/W é sempre zero.

clr_bit(CONTR_LCD,RS); //RS em zero indicando que o dado para o LCD será

uma instrução
clr_bit(CONTR_LCD,E); //pino de habilitação em zero

_delay_ms(20); //tempo para estabilizar a tensão do LCD, após VCC

ultrapassar 4.5 V (na prática pode ser maior).

//interface de 8 bits

#if (nibble_dados)
DADOS_LCD = (DADOS_LCD & 0x0F) | 0x30;
#else
DADOS_LCD = (DADOS_LCD & 0xF0) | 0x03;
#endif

pulso_enable();//habilitação respeitando os tempos de resposta do LCD

_delay_ms(5);
pulso_enable();
_delay_us(200);
pulso_enable();

/*até aqui ainda é uma interface de 8 bits.

Muitos programadores desprezam os comandos acima, respeitando apenas o tempo de
estabilização da tensão (geralmente funciona). Se o LCD não for inicializado
primeiro no modo de 8 bits, haverá problemas se o microcontrolador for
inicializado e o display já o tiver sido.*/

//interface de 4 bits, deve ser enviado duas vezes (a outra está abaixo)

#if (nibble_dados)
DADOS_LCD = (DADOS_LCD & 0x0F) | 0x20;
#else
DADOS_LCD = (DADOS_LCD & 0xF0) | 0x02;
#endif

pulso_enable();
cmd_LCD(0x28,0);//interface de 4 bits 2 linhas (aqui se habilita as 2
linhas)
//são enviados os 2 nibbles (0x2 e 0x8)
 cmd_LCD(0x08,0); //desliga o display
cmd_LCD(0x01,0); //limpa todo o display
cmd_LCD(0x0C,0); //mensagem aparente cursor inativo não piscando
cmd_LCD(0x80,0); //inicializa cursor na primeira posição a esquerda - 1a
linha
}

//-------------------------------------------------------------------------------
//Sub-rotina de escrita no LCD - dados armazenados na RAM
//-------------------------------------------------------------------------------
void escreve_LCD(char *c)
{
for (; *c!=0;c++) cmd_LCD(*c,1);
}

//-------------------------------------------------------------------------------
//Sub-rotina de escrita no LCD - dados armazenados na FLASH
//-------------------------------------------------------------------------------

void escreve_LCD_Flash(const char *c)

{
for (;pgm_read_byte(&(*c))!=0;c++) cmd_LCD(pgm_read_byte(&(*c)),1);
}

//-------------------------------------------------------------------------------
//Conversão de um número em seus digitos individuais
//-------------------------------------------------------------------------------

void ident_num(unsigned int valor, unsigned char *disp)

{
unsigned char n;

for(n=0; n<tam_vetor; n++)

disp[n] = 0 + conv_ascii; //limpa vetor para armazenagem do digitos

do
{
*disp = (valor%10) + conv_ascii; //pega o resto da divisao por 10
valor /=10; //pega o inteiro da divisão por 10
disp++;

}while (valor!=0);
}

Blibioteca USART (USART.h)

#include "def_principais.h"
#ifndef BAUD
#define BAUD 9600 /* set a safe default baud rate */
#endif

#define USART_HAS_DATA bit_is_set(UCSR0A, RXC0)

#define USART_READY bit_is_set(UCSR0A, UDRE0)
#define BAUD_PRESCALE F_CPU/16/BAUD-1

void initUSART(unsigned int PRESCALE);

void transmitByte(unsigned int data);
unsigned int receiveByte(void);
void printString(char myString[]);
unsigned int readString(char myString[], unsigned int maxLength);
Código USART (USART.c)

#include "USART.h"
#include <util/setbaud.h>

void initUSART(unsigned int PRESCALE)

{
UBRR0H = /*(unsigned char)*/(PRESCALE>>8); //Ajusta a taxa de transmissão
UBRR0L = /*(unsigned char)*/PRESCALE;

UCSR0A = 0;
UCSR0B = (1 << TXEN0) | (1 << RXEN0) | (1 << RXCIE0);/* Enable USART
transmitter/receiver and interruption*/
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00); /* 8 data bits, 1 stop bit */
}

void transmitByte(unsigned int data) //uint8_t

{
while (!( UCSR0A & (1<<UDRE0)) );
UDR0 = data;
}

unsigned int receiveByte(void)

{
while (!(UCSR0A & (1<<RXC0)));
return UDR0;
}

void printString(char myString[])

{
unsigned int i = 0;
while (myString[i])
{
transmitByte(myString[i]);
i++;
}
}

Biblioteca LTC1298 (LTC1298.h)

#ifndef LTC1298_H_
#define LTC1298_H_

#include "def_principais.h"

/* LTC1298 Modo de operacao do conversor AD------------------- */

#define CH0 0xC // Ler Chanel 0
#define CH1 0xE // Ler Chanel 1 */
#define DF0 0x8 // Ler (Chanel 0 - Chanel 1)
#define DF1 0xA // Ler (Chanel 1 - Chanel 0)
#define LSB 0 // Setar ordem LSB primeiro
#define MSB 1 // Setar ordem MSB primeiro

/* Definicao dos pinos SPI - pinos da placa Arduino ------------------- */

#define DD_SS (1<<DDB2) //pin 10: SS

#define DD_MOSI (1<<DDB3) //pin 11: MOSI
#define DD_MISO (1<<DDB4) //pin 12: MISO
#define DD_SCK (1<<DDB5) //pin 13: SCK
#define habilita_SS() clr_bit(PORTB,PB2) // SS habilita em zero
#define desabilita__SS() set_bit(PORTB,PB2)
#define amostras 10

void inic_SPI();
unsigned char USART_SPI(unsigned char dado);
unsigned int spi();
uint8_t SPI_MasterTransmit(uint8_t cData);
uint16_t ltc1298_Read(uint8_t mode, uint8_t bitOrder );

#endif /* LTC1298_H_ */

Código LTC 1298 (LTC1298.c)

#include "LTC1298.h"

uint16_t tempH,tempL; //char

void inic_SPI()

{
DDRB = DD_MOSI | DD_SCK | DD_SS;

//configurac?a?o dos pinos de entrada e sai?da da SPI

PORTB |= (1<<DD_SS)|(1<<DD_MOSI)|(1<<DD_SCK);

// estado inicial dos pinos

SPSR &= ~(1<<SPI2X);

// status do registrador duplex em zero

SPCR &= ~((1<<SPIE)|(1<<CPHA)|(1<<DORD)|(1<<CPOL));

// bits com zero

SPCR |= (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(1<<SPR0);

// bits com 1: habilita interrupcao dado ajustado na subida e amostragem

na descida do sinal de clock prescaler 128
}

unsigned int spi()

{
_delay_ms(100); //diminuir esse tempo
habilita_SS();
USART_SPI(CH0 | MSB);
tempH=USART_SPI(0x00); //0x00
tempL=USART_SPI(0x00);
 desabilita__SS();
unsigned int valor16bits = (tempH<<5) | ( tempL >>3);
_delay_ms(1);
return valor16bits;
}

unsigned char USART_SPI(unsigned char dado)

{
SPDR = dado; //envia um byte
while(!(SPSR & (1<<SPIF))); //espera envio
return SPDR; //retorna o byte recebido
}

3. RESULTADOS

Após ser realizado todos os procedimentos descritos neste relatório,

foi possível a confecção do projeto, em alguns momentos foram apresentadas
algumas dificuldades na elaboração, mas as mesmas foram salientadas, a
figura 4, apresenta visualmente o projeto concluído para a apresentação na
disciplina de sistemas microcontrolados.

Figura 4. Projeto confeccionado.

Fonte: Autor, 2018.

4. CONCLUSÕES

Concluímos que o projeto foi muito benéfico, onde vimos na prática o

uso da programação da linguagem de alto nível e também o uso de novos
componentes eletrônicos, que melhores adaptasse ao circuito. É sabido que
em processos industriais os sensores de temperatura são utilizados em alta
escala para diversas aplicações, portanto todo conhecimento adquirido no
decorrer do projeto foi de grande proveito para agregação de novos
conhecimentos em sistemas microcontrolados.

5. REFERÊNCIAS BIBLIOGRÁFICAS

Lima, C. B; Vilaça, M.V.M. AVR e ARDUINO: Técnicas de Projeto. 2. ed. –

Florianópolis: Ed. dos autores, 2012.