No artigo vamos ensinar passo a passo de como fazer uma leitura de termopar diretamente, sem o uso de transdutores, através do CLP Opller OPS012 (Shield Industrial) usando a linguagem do Arduino.
Para entendermos como funciona a leitura, primeiro precisamos saber o que é um termopar e como ele funciona.
Termopar é um sensor de temperatura formado por dois metais distintos unidos em uma extremidade, ao gerar uma diferença de temperatura, entre a extremidade unida (junta quente) e a livre (junta fria), a liga metálica gera uma tensão na ordem de microvolts. Na indústria o uso do termopar é comumente utilizado para medição de temperatura, pois tem uma faixa de medição bem ampla podendo medir de temperaturas negativas até temperaturas acima de 1000ºC.
Atualmente existem vários modelos que se diferenciam pela composição da liga metálica e faixa de operação. Os mais usados são os tipos K (cromel – alumel) opera na faixa: -270°C a 1200°C e J (ferro – constantan) opera na faixa: -210°C a 760°C. Na indústria o termopar é utilizado junto a um transdutor que tem a capacidade de ler os microvolts e transforma-lo em escala de engenharia 0 a 10V ou 4 a 20mA.
O nosso CLP OPS012 tem a capacidade de fazer a leitura direta de temperatura, pois conta com uma tecnologia de leitura de termopar interna. Para realizar a medição basta conectar o polo positivo e o negativo do termopar no borne do CLP e fazer um jumper do GND para o polo negativo para ter uma referência.
Depois só falta programar o CLP, que utiliza o esp32 como processador compatível com a IDE do Arduino.
Segue a baixo o passo a passo e logo depois um código base de exemplo.
Para conseguir utilizar o modulo primeiro é necessário baixar a biblioteca: HX711_ADC. Pode ser encontrada na internet ou em Gerenciador de bibliotecas na própria IDE do Arduino seguindo os passos a baixo:
1- Em ferramentas selecione Gerenciar Bibliotecas.
2- Na aba de pesquisa procure por HX711_ADC.
3- Procure pela biblioteca que pesquisou e clique em instalar, caso já esteja instalado estará igual a figura a baixo. Assim que instalar, estará pronto para o uso.
Para usar a biblioteca precisamos incluí-la para isso vá em Sketch e entre em incluir biblioteca como na imagem abaixo:
Procure pela biblioteca que acabou de instalar e clique nela para incluí-la.
Caso esteja tudo certo ficará assim:
//Biblioteca para temperatura/carga
#include < HX711_ADC.h >O segundo passo é a pinagem, precisamos declarar os pinos que serão usados, use a imagem a baixo como guia. Nomeie como desejar.
//Definição dos pinos do controlador
//Saidas digiais
#define pin_Y1 13
#define pin_Y2 12
#define pin_Y3 27
#define pin_Y4 26
#define pin_Y5 25
#define pin_Y6 33
//Entradas digitais
#define pin_X1 15
#define pin_X2 14
#define pin_X3 39
#define pin_X4 36
//Entradas analógicas
#define AV3 35
#define AV4 34
//Saidas analogicas
#define AO1 32
#define AO2 23
//Entradas de temperatura - a placa conta com duas entradas de temperatura
const int Temp_DOUT_PIN1 = 18;
const int Temp_SCK_PIN1 = 5;
const int Temp_DOUT_PIN2 = 19;
const int Temp_SCK_PIN2 = 4;O terceiro passo é declarar as variáveis que irão armazenar os valores de temperatura, siga as imagens abaixo:
//variaveis para o teste de temperatura
unsigned long tempTime1 = 0; //tempo para realização de cada leitura para ter uma estabilidade maior
long Raw_temp1 = 0; //armazena valores analógicos de 24bits (-8388607 a 8388607)
double temp1 = 0; //armazenas os valoes em graus, já calibrados
unsigned long tempTime2 = 0;
long Raw_temp2 = 0;
double temp2 = 0;O próximo passo é fazer a chamada da biblioteca e nomeá-la. No exemplo usamos os nomes Sensor1 e Sensor2, para cada sensor, faça a chamada da biblioteca com um nome diferente. A biblioteca exige que na chamada declare os pinos, existem duas pinagens específicas o pino DOUT e o pino SCK escreva na ordem do exemplo.
//chamada da biblioteca identificando os pinos, pinagens do HX711(DOUT e SCK)
//Prefixo DOUT Prefixo SCK
HX711_ADC Sensor1(Temp_DOUT_PIN1, Temp_SCK_PIN1);
HX711_ADC Sensor2(Temp_DOUT_PIN2, Temp_SCK_PIN2);No setup inicie a biblioteca com os comandos como no exemplo.
//incio da biblioteca HX711
//a biblioteca funciona tanto para a leitura de celula de carga e de temperatura
//para a leitura de temperatura alguns parametros tem que ser ajustados dessa forma
Sensor1.begin(); //incia a biblioteca
//inicia a leitura depois do tempo definido em ms (para o sensor gerar uma leitura sem muitas ocilações inicias)
//e false no caso da leitura de temperatura, caso queira fazer uma leitura de celula de carga trocar para true
Sensor1.start(2000, false);
//coloca o fator de calibração em 1, para ter a certeza que não havera mudanças nos valores medidos, caso esteja
//fazendo a leitura de celula de carga coloque o valor de calibração que satisfazer a leitura
Sensor1.setCalFactor(1);
Sensor2.begin();
Sensor2.start(2000, false);
Sensor2.setCalFactor(1);A preparação para a leitura de temperatura está pronta agora no loop inicie o código para a leitura. Primeiramente estabelecemos o intervalo de leitura do sensor, como na imagem.
//primeiro dizemos de quanto em quanto tempo faremos a leitura em ms
if (millis() >= (tempTime1 + 1000)) {// nesse caso a leitura está sendo feita a cada 1000 ms
tempTime1 = millis(); //reinicia a contagem do tempo para a proxima leitura
}Depois utilizamos uma função da biblioteca (.update) para saber se o conversor já obteve os valores da leitura feita pelo sensor de temperatura.
//primeiro dizemos de quanto em quanto tempo faremos a leitura em ms
if (millis() >= (tempTime1 + 1000)) {// nesse caso a leitura está sendo feita a cada 1000 ms
if (Sensor1.update()) { //aguarda o conversor realizar a leitura da entrada analogica
}
tempTime1 = millis(); //reinicia a contagem do tempo para a proxima leitura
}
Agora utilizamos a função (.getData) para registrar o valor lido em uma variável, no exemplo colocamos um “Serial.println()” para facilitar a compreensão de que esse valor raw será utilizado na calibração, mas não é necessário coloca-lo neste ponto do código
//primeiro dizemos de quanto em quanto tempo faremos a leitura em ms
if (millis() >= (tempTime1 + 1000)) {// nesse caso a leitura está sendo feita a cada 1000 ms
if (Sensor1.update()) { //aguarda o conversor realizar a leitura da entrada analogica
//realiza a leitura e registra um valor analogico
Raw_temp1 = Sensor1.getData();
Serial.print("Valor Raw da entrada 1: ");
Serial.println(Raw_temp1); //Utilizar esse valor para calibração
}
tempTime1 = millis(); //reinicia a contagem do tempo para a proxima leitura
}
Pronto, a leitura já está feita, agora precisamos calibrar para obter valores em graus. Utilize a função “map” nela primeiro coloque a variável que utilizou no passo acima.
//É necessário calibrar a leitura para cada tipo de sensor e para obter valores em graus
//Valor_Calibrado = map(Valor_Entrada, Entrada_min, Entrada_Max, Valor_Min, Valor_Max);
//Nesse exemplo os valores de calibração foram:
//Valor_Min = 0 graus obteve uma Entrada_min = 8386500
//Valor_Max = 25 graus obteve uma Entrada_Max = 8387580
//o valor está com duas casa decimais
temp1 = map(Raw_temp1, );
Depois, utilizando um algum sensor calibrado e confiável, meça a temperatura ambiente ou a de algum liquido e mergulhe o sensor que está utilizando nele (essa temperatura será a controle, no exemplo usamos 0 graus). O valor analógico gerado, que é explicado no passo anterior, é equivalente a essa temperatura então marque esse valor e utilize na função map como entrada min e a temperatura como valor mínimo.
//É necessário calibrar a leitura para cada tipo de sensor e para obter valores em graus
//Valor_Calibrado = map(Valor_Entrada, Entrada_min, Entrada_Max, Valor_Min, Valor_Max);
//Nesse exemplo os valores de calibração foram:
//Valor_Min = 0 graus obteve uma Entrada_min = 8386500
//Valor_Max = 25 graus obteve uma Entrada_Max = 8387580
//o valor está com duas casa decimais
temp1 = map(Raw_temp1, 8386500, , 0, );
Por último, aqueça o líquido e meça a temperatura que se encontra, (essa temperatura será a segunda de controle, no exemplo usamos 25 graus). O valor analógico gerado é equivalente a essa temperatura então marque esse valor e utilize na função “map” como entrada max e a temperatura como valor max. Para ter uma maior precisão utilizamos duas casas decimais, repita esses 3 passos para cada sensor utilizado.
//É necessário calibrar a leitura para cada tipo de sensor e para obter valores em graus
//Valor_Calibrado = map(Valor_Entrada, Entrada_min, Entrada_Max, Valor_Min, Valor_Max);
//Nesse exemplo os valores de calibração foram:
//Valor_Min = 0 graus obteve uma Entrada_min = 8386500
//Valor_Max = 25 graus obteve uma Entrada_Max = 8387580
//o valor está com duas casa decimais
temp1 = map(Raw_temp1, 8386500, 8387580, 0, 2500);
temp2 = map(Raw_temp2, 8386500, 8387580, 0, 2500);
Para visualizar a temperatura utilize a função “Serial.println()” dentro dos parênteses coloque as variáveis que declarou para receber os valores lidos. A variável que usou para receber os valores calibrados está com duas casas decimais, então para visualizar a temperatura corretamente divida ela por 100, como no exemplo.
Serial.print("Temperatura1: "); //imprime um texto
Serial.print(temp1 / 100); //de acordo com a calibração a cima imprime o valor da temperatura em graus com duas casas decimais
Serial.print("/");
Serial.println(Raw_temp1); //imprime o valor de temperatura em um valor analogico
Serial.print("Temperatura2: ");
Serial.print(temp2 / 100);
Serial.print("/");
Serial.println(Raw_temp2);
Esse foi o tutorial de leitura de temperatura caso tenha ficado alguma duvida entre em contato conosco via e-mail: contato@opller.com.
Caso tenha interesse na aquisição do produto, entre na loja através do link: https://loja.opller.com/ops012