Neste Lab detalharemos a forma de Leitura de altas temperaturas utilizando um termopar do tipo K, para uma faixa de 0 a 1024 °C através do CI MAX6675 da Maxim Integrated. Um datalogger destes valores de temperatura também será implementado na aplicação.
MATERIAIS
- (1x) Arduino Nano (Atmega 328);
- (1x) Display LCD 16×2 (Controlador HD44780);
- (1x) Potenciômetro de 4K7 Ohms.
- (2x) Termopar tipo K (0 a 600°C);
- (1x) Módulo para cartão de memória com Shift Level;
- (1x) Cartão de memória mini SD;
- (2x) Módulo para leitura de termopar com o MAX6675 (0 a 1024°C);
- (1x) Protoboard;
- Cabos para ligação em protoboard.
O termopar
Um termopar é um dispositivo elétrico formado por dois materiais metálicos diferentes (termo elementos) que quando uma de suas extremidades está unida forma-se uma conexão ou junta que irá gerar uma pequena tensão devido a variação de temperatura. Posteriormente, esses níveis de tensão serão interpretados para representar temperaturas obedecendo ao princípio do efeito termoelétrico descoberto por Thomas Seebeck em 1821. A figura abaixo ilustra o princípio de funcionamento deste dispositivo.
Termopares comerciais são relativamente baratos, intercambiáveis com conexões padrões e podem medir uma grande gama de temperatura. Em contraste com a maioria dos métodos para medição de temperatura, os termopares não exigem alimentação ou qualquer forma externa de excitação. Sua principal limitação é a precisão de medida onde variações menores do que 1°C são difíceis de alcançar.
São largamente utilizados na indústria para medições de fornos industriais, turbinas a gás, exaustores, temperatura nas câmaras de motores de combustão interna, caldeiras de fermentação e outros diversos processos industriais que envolvam medições de altas temperaturas.
A tabela abaixo ilustra os tipos de termopares mais comuns e a faixa de operação de cada um.
Neste tutorial utilizaremos o termopar tipo K e sua composição abrange componentes como o Chromel [90% níquel e 10% cromo] e Alumel (níquel alumínio) [95% de níquel, 2% de manganês, 2% de alumínio e 1% de silício]. Assin, um dos lados do termopar é magnético enquanto o outro não. Grassas a esta grande diferença entre os materiais é que obtemos uma pequena tensão de acordo com a variação de temperatura.
COMPENSAÇÃO DE JUNTA FRIA OU JUNTA DE REFERÊNCIA
O nível de tensão gerada pelo termopar tipo K é extremamente baixo, na ordem de 41uV/°C, logo necessitamos de um sistema para amplificar e filtrar estes níveis de tensão para uma forma que possa ser interpretada pelos microcontroladores / microprocessadores comerciais.
Na teoria, a outra extremidade do termopar, a que está aberta, deveria ser imergida em um balde de gelo para gerar uma temperatura de referência para medição a 0 °C.
A menos que o usuário queira, para alcançar melhor precisão, um balde de gelo não é necessário se utilizarmos uma técnica chamada compensação de junta fria ou Cold Junction Compensation (CJC).
Basicamente, um sensor comum de temperatura, não necessariamente um do tipo k, é conectado próximo ao borne onde os cabos do termopar estão fixos – também chamado de ponto frio ou Cold End já que o ponto quente é onde há temperatura. A leitura desta temperatura é transformada em valor de tensão igual a tensão gerada por um termopar do tipo K naquele mesmo ponto. A figura abaixo ilustra o motivo pelo qual deve-se haver a compensação de junta fria.
Logo, para medirmos o sinal de um termopar utilizando um microcontrolador iremos necessitar de um amplificador operacional de instrumentação com alto ganho, um sensor de temperatura para medição da junta fria, um circuito para filtrar ruídos e de preferência um conversor AD de alta resolução.
MAX6675
O circuito integrado MAX6675 da Maxim Integrated contempla em sua construção toda a “circuitaria” mencionada no final da última seção. Possui um conversor AD de 12 bits de resolução, um sensor para compensação de junta fria, um controlador digital e a saída dos dados de temperatura já convertidos via protocolo SPI para conexão a qualquer tipo de microcontrolador. A imagem abaixo mostra os dois módulos utilizados neste tutorial já com o MAX6675 montado.
CONVERSÃO DE TEMPERTURA COM O MAX 6675
O MAX6675 já inclui em seu encapsulamento um sistema para condicionamento do sinal e filtro dos ruídos para converter o nível de tensão do termopar à um nível compatível com a entrada do ADC.
Antes de converter o sinal de tensão em uma temperatura equivalente, é necessário compensar a diferença entre a leitura da temperatura na junta fria e o ponto de referência zero virtual a 0°C. Para um termopar do tipo K, a tensão gerada muda 41uV a cada °C.
A ponta de medição dos termopares aplicados a este CI pode medir em uma faixa de 0 a 1023.75°C e o encapsulamento do CI, onde é medida a temperatura para a compensação de junta fria, deve estar em uma faixa de -20 a +85°C. Este sensor na verdade é um diodo de sinal que muda sua tensão de acordo com a mudança de temperatura. Está localizado dentro do encapsulamento do CI.
Para obter a temperatura final após as medições, o controlador interno do MAX adiciona o valor de tensão medido pelo diodo na junta fria ao valor de tensão já amplificado do termopar e os converte em uma resolução de 12 bits disponibilizando o resultado no pino SO (Serial Data Output) para ser lido por um microcontrolador. O diagrama exposto abaixo explica a composição dos 16 bits de dados fornecidos na saída do MAX6675.
INTERFACE SERIAL
O CI faz a leitura de temperatura e interpreta para disponibilizar em sua saída os dados através de uma interface serial. Por sua vez, esta é compatível com o protocolo SPI trabalhando somente em uma direção, sendo esta do chip para o microcontrolador ou no pino de dados MISO (Master Input, Slave Output) do SPI. A figura abaixo mostra a ligação típica entre o MAX e um microcontrolador.
Para estabelecer a comunicação o pino CS (Chip Select) deve ser colocado em nível 0 para interromper qualquer processo de conversão no AD e um sinal de clock deve ser aplicado ao pino SCK. Logo, no pino SO, teremos os 16 bits de dados expostos serialmente a cada borda de descida do sinal de clock sendo o bit mais significativo (bit 15) o primeiro e o menos significativo (bit 0) o último. Para iniciar um novo processo de conversão é necessário alterar o pino CS para nível alto novamente. O diagrama abaixo ilustra o protocolo de comunicação a ser estabelecido.
O conteúdo de cada bit da comunicação já foi exposto na figura 6 logo acima.
ESQUEMA DE LIGAÇÃO
O esquema de montagem deste tutorial está exposto abaixo. Note para a necessidade de um shift-level na entrada de dados do módulo do cartão pois o Arduino libera em sua saída um nível de 5V e este poderá danificar o cartão de memória que opera em 3V3. A imagem subsequente ilustra o módulo do cartão SD.
Algoritmo
O algoritmo que implementa este data log de temperatura para termopar tipo K está indicado abaixo. Como sempre, o código está bem comentado e fácil de ler. Faz o uso das bibliotecas para leitura e escrita no catão de memória, SPI e a famosa <LiquidCrystal.h> para o display de 16×2 que mostra os valores de ambos os sensores. Uma imagem da leitura é indicada abaixo e na sequencia temos o algoritmo.
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 |
/*************************************************************************** Arduino Lab 19 - Leitura de Termopar tipo K com MAX6675 **************************************************************************** -- IDE do Arduino Versão 1.8.3 -- Autor: Eduardo Avelar -- Blog: easytromlabs.com -- email: contato@easytromlabs.com -- Junho, 2018 ****************************************************************************/ #include <LiquidCrystal.h> #include <SPI.h> #include <SD.h> const int SO = 2; // MISO - Master Input, Slave Output - Para MAX6675 const int SCLK = 3; // SCLK - Serial Clock line - Para MAX6675 const int CS1 = A3; // CS1 - Chip Select 1 - Para MAX6675 const int CS2 = A2; // CS2 - Chip Select 2 - Para MAX6675 const int chipSelect = 10;// CS do cartão de memória double sensor1 = 0; // Variável para o sensor 1 double sensor2 = 0; // Variável para o sensor 2 // MOSI - pin 11 no Arduino // MISO - pin 12 no Arduino // CLK - pin 13 no Arduino // CS - pin 10 no Arduino // Declaração dos pinos do LCD - RS, E, D4, D5, D6, D7, D8, LiquidCrystal lcd(9, 8, 4, 5, 6, 7); // Declara dataFile como arquivo para salvar no SD File dataFile; // Gera um simbolo de graus uint8_t degree[8] = {140, 146, 146, 140, 128, 128, 128, 128}; // Protótipo de funções byte SPIRead(void); double readThermocouple(int ChipSelect); void storeSD(); void setup() { Serial.begin(9600); // Declaração do modo como as portas irão operar pinMode(CS1, OUTPUT); pinMode(CS2, OUTPUT); pinMode(SCLK, OUTPUT); pinMode(SO, INPUT); digitalWrite(CS1, HIGH); digitalWrite(CS2, HIGH); lcd.begin(16, 2); lcd.createChar(0, degree); lcd.setCursor(0, 0); lcd.print("Inicializando..."); delay(1000); // Confere se o cartão está presente e operante if (!SD.begin(chipSelect)) { lcd.setCursor(0, 0); lcd.print("Falha no cartao "); return; } lcd.setCursor(0, 0); lcd.print("Cartao OK "); delay(500); } void loop() { lcd.clear(); // Limpa o display // Linha 0, coluna 0 lcd.setCursor(0, 0); lcd.print("Sensor1: "); sensor1 = readThermocouple(CS1); lcd.print(sensor1, 1); lcd.write((byte)0); lcd.print("C"); // Linha 1, coluna 0 lcd.setCursor(0, 1); lcd.print("Sensor2: "); sensor2 = readThermocouple(CS2); lcd.print(sensor2, 1); lcd.write((byte)0); lcd.print("C"); storeSD(); // Função que faz o armazenamento das leituras no SD delay(10000); // Aguarda 10 Segundos para uma nova leitura e armazenamento no cartão } /**************************************************************************************/ // Função para armazenamento dos dados de leitura feitos anteriormente /**************************************************************************************/ void storeSD() { // Formata os dados para serem salvos no Cartão SD a cada 1 segundo String dataString = ""; // Declara uma string para salvar os dados no SD dataString += "Sensor1: "; dataString += String(sensor1); // Valor da leitura do sensor 1 dataString += " °C "; dataString += "Sensor2: "; dataString += String(sensor2); // Valor da leitura do sensor 2 dataString += " °C"; // Abre o arquivo, escreve e o fecha novamente dataFile = SD.open("datalog.txt", FILE_WRITE); // Se o arquivo esta presente, escreve no mesmo if (dataFile) { dataFile.println(dataString); dataFile.close(); } // Se o arquivo não abrir, indica no display else { lcd.setCursor(0, 0); lcd.print("Falha ao abrir "); lcd.setCursor(0, 1); lcd.print("o arquivo no SD "); } } /**************************************************************************************/ // Função para leitura dos dados de temperatura provindos do MAX6675 /**************************************************************************************/ double readThermocouple(int ChipSelect) { uint16_t v; // Declara variável de 16 bits - Tamanho ideal para o dado entregue pelo MAX digitalWrite(ChipSelect, LOW); _delay_ms(1); v = SPIRead(); // Leitura da parte alta - Primeiros 8 bits de dados v <<= 8; // Desloca 8 posições para a esquerda v |= SPIRead(); // Faz leitura da parte baixo e armazena nos 8 primeiros bits atravez de uma OR digitalWrite(ChipSelect, HIGH); // Confere o bit 2 para termopar acoplado ou não if (v & 0x4) { return NAN; } v >>= 3; // Descarta os 3 primeiros bits, onde apenas o bit 2 carrega o status e lê do bit 3 ao 14 return v * 0.25; // Multiplica pela resolução do MAX } /**************************************************************************************/ // Função que implementa um "SPI" via Software para leitura dos dados no MAX6675 /**************************************************************************************/ byte SPIRead(void) { int i; byte d = 0; // Laço FOR para apanhar 8 bits de cada vez for (i = 7; i >= 0; i--) { digitalWrite(SCLK, LOW); // Borda de descida do clock - Falling Edge _delay_ms(1); // Aguarda 1ms if (digitalRead(SO)) { // Faz a leitura do pino de dados de saída do MAX d |= (1 << i); // Armazena os bits lidos, 0 ou 1, na variável e desloca de acordo com o indice para } // preencher todo o byte de dados digitalWrite(SCLK, HIGH); // Borda de subida do clock - Rising Edge _delay_ms(1); // Aguarda 1ms } return d; // Retirna o byte de leitura dos dados lidos do MAX } |
Resultados
Ao termino da programação e testes iniciais de leitura da temperatura dos sensores comuns e armazenamento dos dados no cartão SD, iniciamos um teste com um aparelho denominado CAPPO 10 Plus, da empresa ECIL Instrumentação, que nada mais é do que um gerador de sinais calibrado. Este equipamento foi calibrado em Agosto/2017, possui um selo de calibração emitido pelo Inmetro e segue a norma NBR ISSO/IEC 17025. A imagem deste equipamento está indicada abaixo.
Realizamos 42 simulações de valores de temperatura para o termopar tipo K com o equipamento mencionado acima. Os resultados estão indicados na tabela abaixo. Notamos que até 530°C o MAX6675 comportou-se dentro do esperado para a faixa de tolerância indicada no datasheet. Após 530, obtemos leituras acima dos valores tolerantes. O gráfico após a tabela indica o valor de tolerância na linha alaranjada e os valore lidos pelo MAX na linha azul.
Os resultados das medições dos valores de tensão expostos na tabela acima foram feitos utilizando um multímetro de bancada MDM-8045C da minipa. A imagem deste multímetro com um dos valores de medição, a aproximadamente 650°C, está indicado abaixo.
Conclusão
Neste tutorial discutimos o método de leitura de temperatura utilizando os termopares do tipo K como sensores através do CI MAX6675. Um datalogs dos dados de temperatura também foi implementado utilizando um módulo para cartão SD.
Uma análise detalhada nos mostrou que os dados obtidos divergem dos apresentados no datasheet, no âmbito de tolerância de leituras de temperatura, para valores maiores do que 525°C até 1023°C.
Nossa análise nos mostrou também que este erro é devido principalmente a construção da placa e devido ao plano de terra do módulo de leitura.
28/11/2023 at 19:29
Boa noite!
Tudo bem?
Prezado Eduardo,
Primeiramente parabéns pela iniciativa.
Enviei um email para conversarmos sobre projeto particular.
Abraço.
05/07/2023 at 10:45
Execelente Post ! Parabéns !
09/08/2020 at 15:07
Boa tarde Eduardo Avelar!estou tentando montar este circuito em proteus 8.9 e a descrição dos pinos que tem no progecto não é igual ao que aparece no integrado atmega328p do proteus 8.9.
pode me dar sugestão /pista para correnta montagem em proteus? agradeço
13/08/2020 at 11:55
Olá Tote.
Infelizmente não tenho essa verão do proteus para lhe auxiliar.
Busque a compatibilidade no datasheet do componente.
30/09/2020 at 22:38
Ola Eduardo, primeiro parabens pelos artigos bem funcionais e didaticos. Segundo, pretendo montar um sistema c 8 entradas e gostaria de saber se somente adicionaria os disp. MAX e alteraria o código ou se necessitaria outras modificações?
01/10/2020 at 00:43
Olá Marcelo.
Voce deve ligar os pinos D2 e D3 da mesma forma como foi indicado neste tutorial. Já para os pinos CS\, vc deve obrigatoriamente ter um para cada sensor. Isso deve ser implementado no código.
Espero ter ajudado.
Até mais.
28/04/2020 at 11:02
Eduardo, eu tenho um Módulo Cartão Micro SD Para Arduino e apenas um termopar. O que mudaria nas ligações e programação? A variável double do termopar sai?
Grato
29/04/2020 at 09:26
Neste caso voce deveria ligar o sensor a entrada de sonsor 1, eliminar toda a chamada para leitura do sensor 1 pela SPI, eliminar a indicação de leituras no LCD e escrever no cartão SD somente as leituras do sensor 1.
21/04/2020 at 13:45
Boa tarde.
Como faço para ele mostrar a temperatura e a tensão correspondente em mV ?
29/04/2020 at 09:19
Teoricamente o conversor MAX6675, da forma como a leitura está sendo feita dentro da função readThermocouple(), já envia o valor da temperatura convertida.
Neste caso, voce teria que analizar o datasheet para ver a possibilidade de conversção ou então voce elabora uma função de conversão em função da faixa de temperatura já que não é uma relação linear.
Outra opção é voce desenvolver um circuito baseado em aplificadores operacionais e filtros.
29/04/2020 at 09:21
Paulo,
O Arduino está ligado a parte de potência e aplica o PWM aos Mosfets de potência.
18/03/2020 at 13:31
Obrigado pelo artigo Eduardo! Sou iniciante em Arduino, mas me ajudará bastante.
Você definiu o intervalo entre leituras como 10s na linha 89 do código né?
“89 delay(10000); ”
Então, para ter um sistema com taxa de aquisição de 2 Hz basta eu alterar essa linha para “delay(500)”? É isso mesmo?
Você respondeu uma outra pergunta similar (14/11/2019 at 20:59): “Na sua aplicação, coloque no minimo 500ms ou 1s devido a dar tempo do capacitor de sample and rolding descarregar.”
Isso significa que a maior taxa de aquisição que eu poderia usar é de 2 Hz, né?
Desde já, agradeço.
29/04/2020 at 09:02
Olá Felipe.
Desculpe a demora.
No caso, a limitação da aquisição está relacionado mais ao conversor de sinais MAX6675 do que com o AD do microcontrolador.
Teria que baixar o datasheet do mesmo e analizar este ítem.
03/12/2019 at 08:12
Aquele capacitor ilustrado no diagrama de montagem, é conectado nas entradas 5v e gnd??
12/12/2019 at 07:09
Gustavo, a qual capacitor você se refere? Indique o Label.
11/11/2019 at 20:58
sabe me dizer o tempo que o modulo max6675 demora fazer a medida de uma temperatura??
14/11/2019 at 20:59
Olá Gustavo.
O datasheet cita 220ms para tempo de conversão.
Na sua aplicação, coloque no minimo 500ms ou 1s devido a dar tempo do capacitor de sample and rolding descarregar.
Eduardo Avelar.
11/11/2019 at 11:23
Sabe me dizer quanto tempo em média leva para o módulo fazer cada leitura??
Ex: cada leitura leva 0,8 segundos para ser lida.
14/11/2019 at 21:00
Gustavo,
O datasheet fornece essa informação. Ele cita 220ms.
Eduardo Avelar.
23/09/2019 at 13:50
Olá sou novo no Arduino, eu tenho a duvida dos valores que meu sensor deu, no caso em um ambiente de temperatura 22 °C ele dá 25 ºC, eu vi no tutorial sobre a junta fria mas ainda não entendi, como faço para ter valores mais exatos ?
23/09/2019 at 14:25
Ola Victor.
Tente calibrar os valores do seu sensor utilizando uma referência, por exemplo outro aparelho que esteja lendo corretamente e que você confie.
Para baixas temperaturas, até 700°, a tolerância de leitura do MAX6675 é de +/- 5°C para uma temperatura de junta fria de 25°C.
A junta fria é o ponto de conexão entre o termopar e o CI de leitura, no caso o MAX.
Isso se faz necessário principalmente pela união de materiais diferentes,
Espero ter ajudado.
22/10/2019 at 10:25
Olá novamente, pelo que entendi, eu devo realizar a medição com meu termopar em um recipiente com uma temperatura que eu conheça, e após utilizar a mesma para corrigir os valores dos termopares?
14/11/2019 at 21:07
Victor,
O MAX6675 já fornece para você o valor da temperatura convertido e linearizado, já que o termopar não apresenta essa caracteristiva.
O encapsulamento dele possui um sensor de temperatura que indica para a lógica interna qual é a temperatura da “junta fria”.
Basta instalar o conversor no termopar, ligar no arduino, carregar o firmware e utilizar.
Eduardo Avelar.
17/06/2019 at 09:33
Bom dia !
Entendi. Caso não utilize o potenciômetro, então, o display funcionará no “máximo”, certo?
Outra dúvida: para alimentar 5v nos componentes, foi utilizado uma fonte externa?
Obrigado pela atenção
24/06/2019 at 23:46
Felipe,
Se observar nas figuras irá perceber que utilizei apenas os 5 volts proveniente da USB. Não é necessário mais do que isso.
Atenciosamente,
Eduardo Avelar.
12/06/2019 at 10:34
Não consegui identificar a ligação do potenciômetro listado. É irrelevante sua utilização? Agradeço desde já pelas dúvidas sanadas!
12/06/2019 at 11:08
Felipe,
Você se refere ao potenciômetro de ajuste de contraste do display?
Desculpe não ter colocado no esquema. Ele formará um divisor de tensão entre o VCC, VSS e o terminal central ligado ao pino 3 do display.
Atenciosamente,
Eduardo Avelar
12/06/2019 at 10:21
Sabe me informar o que pode ocorrer, eletronicamente, se houver um pico superior a 3.000 graus celsius por exemplo?
12/06/2019 at 11:00
Ola Felipe.
Não consegui encontrar no datasheet qual o valor máximo que pode ser aplicado por um curto espaço de tempo.
Se analisarmos o range de leitura que é de 0 a 1024°C, se você aplicar 3000°C estará ultrapassando em 3x o valor máximo.
Consequentemente um maior nível de tensão estará sendo aplicado ao conversor que ocasionará uma maior dissipação de potência.
Resumindo, eu não aconselho e Faria de tudo para evitar.
Espero ter ajudado.
Eduardo Avelar
26/03/2019 at 11:23
Olá novamente. Meu display LCD 16×2 tem o modulo i2C incorporado. como faz pra simplificar estas ligaçoes do seu projeto para adaptar a esta ligacao de apenas 4 fios?
28/03/2019 at 12:40
Marcelo,
Teoricamente voce deverá inserir a biblioteca para comunicação I2C com o display de 16×2 e dentro do void loop() voce deverá alterar para enviar os valores ao display utilizando a biblioteca I2C assim como voce já deve ter feito com qualquer aplicação com este display.
O restante é basicamente o mesmo apresentado neste tutorial.
Espero ter ajudado.
22/03/2019 at 15:04
obrigado pelo artigo.
23/03/2019 at 00:06
Obrigado pelo comentário Marcelo.
Continue nos acompanhando.
Abraço.
14/03/2019 at 16:31
É possível adicionar um terceiro ou quarto MAX no mesmo projeto, só colocando em outra porta analógica?
19/03/2019 at 11:39
Caro Kevin,
Este conversor comunica-se com o microcontrolador via protocolo SPI. As portas analógicas nesta aplicação estão trabalhando como pinos digitais de saída para ativar o Chip Select (CS) de cada conversor no momento da leitura, dentro do laço infinito LOOP.
Se deseja adicionar outro conversor, basta ligar os pinos de dados igual ao esquema, em paralelo, e adicionar outro pino de controle, no caso um CS3, onde nesta aplicação necessita ser analógico, já que todos os outros digitais estão ocupados com a comunicação para o cartão SD e o Displaya.
Espero ter ajudado.
Eduardo Avelar.