Detecção de variações bruscas de uma amostra em uma média de tempo

Olá amigos.

Estou com uma dificuldade e gostaria de ajuda.

Preciso detectar variações rápidas de temperatura dentro de um determinado espaço de tempo.

Ou seja, estou controlando a temperatura de um elemento Peltier que refrigera um capilar onde passa uma pequena quantidade de amostra.

Nesse capilar, existe um sensor de temperatura, que serve para equilibrar todo o sistema.

O problema é que quando o sistema está estabilizado a 20 graus, e eu injeto uma amostra que esta fora da temperatura, o sensor detecta essa variação brusca de temperatura e tenta refazer o controle da Peltier que já estava estabilizada estragando tudo.....!!!!

O que desejo é detectar essa variação brusca de temperatura dentro de um intervalo de tempo que a amostra está estavel .

Algum colega poderia ajudar ????

Exibições: 739

Responder esta

Respostas a este tópico

OI MA, bom dia.

Não entendi muito bem sua explicação.

Você quer detectar a variação brusca, mas não quer que o sistema corrija esta variação pela pastilha?

Esta variação  é brusca para outro valor e fica neste valor , ou varia e volta ao valor que era anteriormente?

Se for a ultima alternativa que citei, use um sistema de delay no circuito que ativa a pastilha Peltier.

Rui

Vamos lá.

Tenho um densímetro que mede soluções de álcool.

Uso uma seringa para injetar soluções nele. As soluções estão sempre em temperatura ambiente próximas de 30 graus.

Desenvolvi um sistema com pastilha Peltier que utiliza um algorítimo PID para controlar a pastilha e manter ela a 20 graus. Está funcionando muito bem.

Porém, quando eu injeto a solução que está mais quente que o densímetro (que já estava estabilizado a 20 graus),  o sistema PID "sente" essa variação brusca de temperatura e começa a mandar a Peltier "esfriar" novamente, fazendo com que o densímetro vá para uma temperatura mais baixa e depois volte a aquecer para novamente ficar a 20 graus.....

Isso demanda um tempo longo de estabilização e eu não posso ter esse tempo de espera.

Pensando nisso, se o sistema já estava a 20 graus e eu injeto uma amostra "quente", bastaria que o PID ficasse travado esperando a que "a amostra" adquira a temperatura da célula que esta a 20 graus correto?

Economizaria tempo de leitura......

Minha idéia é tentar algo do tipo:

Tirar médias da temperatura do sensor a cada dois segundos.

Se a temperatura do sensor não variar 0.5 (meio) grau durante dois segundos, o PID continua tratando de manter o sistema estável e estabilizando a temperatura normalmente.

Se a temperatura variar bruscamente mais que 0.5 (meio grau) DURANTE os dois segundos, o PID  seria travado por uma simples instrução que já existe no programa ( PwmOut = PwmOut;) e ficaria assim por 30 segundos, voltando a ser destravado após esse tempo.

Não sei como criar algo dessa forma, talvez usando a função Timer ou a função millis, onde o programa não fica travado por um delay.

Atualmente existe um botão que eu aperto e travo o pwm...mas queria utilizar um sistema que conseguisse "monitorar" essa variação rápida da temperatura pelo tempo e travar o sistema até a temperatura novamente ficar entre uma margem próxima a do meu setpoint de 20 graus.

Olá Max !

Deixa eu ver se entendi ; você quer que o sensor não detecte variações bruscas iniciais de temperatura mas depois que normalize as mesmas variações bruscas?

Se sim , uma das soluções seria aplicar um filtro (algorítimo ) de mediana móvel seguida de média. Usar mediana móvel implica na remoção dos chamados outiliers ( pontos fora de série ) e a média para diminuir o desvio padrão do conjunto dos dados analisados , além de você ganhar um tempo de leitura já que houve uma diminuição na frequência de amostragem. Assim suas variações bruscas são suavizadas e se aproximam mais do real.

Está usando qual micro controlador ?

Abraços.

Não. 

Pelo contrário, preciso que a cada dois segundos o sistema fique monitorando se a temperatura não varia 0.5 (meio) grau RAPIDAMENTE acima ou abaixo da temperatura do meu setpoint que é 20 graus.

Se a temperatura variar RAPIDAMENTE 0.5 graus acima ou abaixo do setpoint dentro de um intervalo de tempo, o sistema trava o pwm e aguarda a temperatura ficar dentro dos valores de 0.5 graus acima ou abaixo do  setpoint.

Estou usando um arduino mega

Criei um código que esta lendo as informações de temperatura enviadas pelo densímetro pela entra RX1 do arduino em formato de string.

Tudo funciona perfeitamente e o código que implementei usando algorítimo PID, funciona muito bem.

Mas quando está tudo a 20 graus e injeto uma amostra que está mais quente (30 graus) por exemplo, o PID sente essa variação(pelo sensor que está dentro do tubo de amostras) e recomeça a esfriar a Peltier que "já estava" equilibrada a 20 graus e até tudo se normalizar e entrar em equilíbrio térmico demora muito. 

Preciso de uma forma de perceber essa brusca variação (quase instantânea) da temperatura e travar o pwm por 30 segundos, sem travar o restante do programa usando qualquer tipo de delay.

Esse é o desafio que proponho aos colegas...

Vai ter que mudar suas rotinas no PID. Você esta com a faca e o queijo na mão.

Só não esta cortando o queijo como deveria...

Se deseja ajuda, informe o seu Sketch.

Importante fazer uma diagrama dos seus sensores/placa peltier/ Arduino

Qual sensor de temperatura esta usando ?

Qual o microcontrolador ?

Explique melhor o que deseja. 

Estou usando o arduino mega.

Após muito estudar o código, percebi que vou ter que partir para utilização de Autotune  no código.

Não estou utilizando a rotina autotune em meu código. 

Tentei implementar mas estou sim com dificuldades. Preciso de ajuda.

Segue o código sem a função autotune.

Gostaria de ajuda para implementar ela aqui.

//********** 17/11/15 ******* 12:35 *******************
//=========================================================
//
//---- Programa de Controle para Elementos Peltier ----
//
//=========================================================

// Por Max Anderson 11/2015
// Ligue os pinos do lcd dessa maneira:
// SCK - Pin 12
// MOSI - Pin 11
// DC - Pin 8
// RST - Pin 5
// CS - Pin 7

#include <LCD5110_Graph.h> // inclui a biblioteca do display 5110
#include <SoftwareSerial.h> //FAZ IMPORTAÇÃO DA BIBLIOTECA -
#include <Bounce.h> // biblioteca utilizada para delay de botões
#include <dht.h>


SoftwareSerial mySerial( 01, 02); // DEFINE OS PINOS A SEREM UTILIZADOS: RX, TX. RESPECTIVAMENTE - Porta virtual para o arduino nano
char buffer[30];// Tamanho do buffer de dados recebidos pela porta 1
byte GetData [7] = {0x01, 0x00, 0x00, 0x00, 0x08, 0x02, 0x03};//Pacote de dados de solicitação enviado ao densímetro
LCD5110 myGLCD(12, 11, 8, 5, 7); // define a sequência de ligação do display
extern unsigned char SmallFont[]; // define tamanho da fonte
extern unsigned char TinyFont[];
char tenstring [6]; // define tamanho da string
String str;
dht DHT;
String Temp_Ap; // String para concaternar Temperatura de aparelho
float Temp_Full = 20; // Variavel float para guardar temperatura de aparelho

#define AUMENTAR_PIN 10//7 sem display
#define DIMINUIR_PIN 6//8 sem display
#define CENTER_PIN 9 // botão para ajuste fino da temperatura
#define DEBOUNCE_TIME 5 // tempo em ms
#define DHT22_PIN A1 //Sensor de Umidade
#define pinoSensor A0 //Sensor externo de Temperatura (via circuito eletrônico com o AD 590)
long lastDebounceTime = 0; //Ultimo estado do botão
long debounceDelay = 50; //Atraso em delay
int buttonState = 0; // variavel para leitura do estado do botão
Bounce aumentar = Bounce(AUMENTAR_PIN, DEBOUNCE_TIME);
Bounce diminuir = Bounce(DIMINUIR_PIN, DEBOUNCE_TIME);
Bounce center = Bounce(CENTER_PIN, DEBOUNCE_TIME);
double count, count2 = 0; // Contadores dos botões

int direcaoA = 4;
int brakeA = 1;
int pwmA = 3;
int correnteA = 14;
int direcaoB = 4;
int brakeB = 1;
int pwmB = 3;
int k;
// Variáveis que guardam a temperatura máxima e mínima
int maxtemp = -100, mintemp = 100;
// Variáveis que guardam a umidade máxima e mínima
int maxhum = -100, minhum = 100;
int umidade;

int Val_05; // variavel para valor do buffer 6
int Val_06; // variavel para valor do buffer 7
int Val_08; // variavel para valor do buffer 9
int Val_09; // variavel para valor do buffer 10

double valorPot = 0; // registra o valor do potenciometro
double valorTemp = 0; // registra o valor da temperatura
double valorPelt = 0; // registra a potencia enviada para a Peltier
int valorPelt2 = 0;
int iniciar = 0;


unsigned long lastTime;
double Input, Output;
double errSum, lastInput;
float DifTemp, DifTemp2;

const int relePin = 4; // Pino de reversão do rele
int releState = LOW; // Inicializa o aparelho com rele desligado
int Buzz = 13; // Pino do Buzzer 13
// PARAMETROS PID

double kp = 0.7;//2 ----- 1 ----0.03
double ki = 0.1;//0.3 ------ 0.05 ---0.02
double kd = 0.05;//0.1 ------ 0.01 ---0.01

// Limites da potencia Peltier

int potMax = 255;
int potMin = -255;
int tempMax = 50;
int tempMin = 15;

//==============================================================================
// ********** Logica do Controle de Variação Brusca de Temperatura *********
long previousMillis1 = 0;
long Time1 = 1000;

float MinTemp = 0.5;//Graus Celsius
float MaxTemp = 0.5;//Graus Celsius
float Diferenca = 0;

//==============================================================================
// ------ Valor inicial para o Setpoint

double Setpoint = 20.0;
//==============================================================================
// ------ Valor inicial para a Umidade

int Umid = 20;
//==============================================================================

double iTerm;
int SampleTime = 0; // intervalo de tempo da funcao PID
int i, j;
int tempo;
//double pinoSensor = A0;// Pino analogico de entrada do LM 35
double valorLido = 0;
double temperatura = 0;
double temperatura2 = 0;
double temperatura3 = 0;
double tempData = 0x0000;

float soma = 0; // variavel que soma os valores obtidos
float media = 0; // variavel que calcula a media
float soma2 = 0;
float media2 = 0;
//------------------------------------------//

void setup() {

myGLCD.InitLCD();
myGLCD.setFont(SmallFont);
//Habilitação da serial
Serial.begin(19200);//Inicializa a porta
Serial.flush();
// pinMode(12, OUTPUT);//Para acender o Led de teste no pino 10
mySerial.begin(19200); //VELOCIDADE DE COMUNICAÇÃO DA SERIAL VIRTUAL -

pinMode(direcaoA, OUTPUT);
pinMode(pwmA, OUTPUT);
pinMode(brakeA, OUTPUT);
pinMode(correnteA, INPUT);

pinMode(direcaoB, OUTPUT);
pinMode(pwmB, OUTPUT);
pinMode(brakeB, OUTPUT);

pinMode(AUMENTAR_PIN, INPUT_PULLUP);
pinMode(DIMINUIR_PIN, INPUT_PULLUP);
pinMode(CENTER_PIN, INPUT_PULLUP);
digitalWrite(direcaoB, HIGH);
digitalWrite(brakeB, HIGH);
analogWrite(pwmB, 0);


pinMode(Buzz, OUTPUT);//Buzzer
digitalWrite(brakeA, LOW);


myGLCD.clrScr(); // Limpa o LCD de lixo

}
//------------------------------------------//

void loop()
{

count = 1;
DHT.read22(DHT22_PIN); //Lê as informações do sensor
umidade = DHT.humidity;
str.toCharArray(tenstring, 6); // define o tamanho da string d voltagem

// myGLCD.clrScr(); // Limpa o LCD de lixo
myGLCD.update(); // atualiza lcd

//-------------------------------------------------------
//----- BOTÃO AUMENTAR -------------------------------

if (aumentar.update() ) {
count = 0 ;
if (aumentar.read() == LOW && center.read() == HIGH) {
count++;
aumentar.rebounce(10);
if (Setpoint < 50)
Setpoint = Setpoint + 1;//Define qual o tamanho do salto
digitalWrite(Buzz, HIGH);
delay(100);
digitalWrite(Buzz, LOW);
}
}
//-----------------------------------------------------
//----- BOTÃO DIMINUIR ----------------------------
if (diminuir.update() ) {
count = 0 ;
if (diminuir.read() == LOW && center.read() == HIGH) {
count2++;
diminuir.rebounce(10);
if (Setpoint > 15)
Setpoint = Setpoint - 1;//Define qual o tamanho do salto
digitalWrite(Buzz, HIGH);
delay(100);
digitalWrite(Buzz, LOW);
}
}

//-----------------------------------------------------------
//----- BOTÃO CENTRAL -------------------------------
if (center.update()) {
count = 0 ;
if ( diminuir.read() == LOW && aumentar.read() == LOW) {
digitalWrite(Buzz, HIGH);
delay(100);
digitalWrite(Buzz, LOW);
}
}
//-----------------------------------------------

if (center.read() == LOW && diminuir.read() == LOW && aumentar.read() == HIGH) {
count2++;
center.rebounce(10);
if (Setpoint > 0)
Setpoint = Setpoint - 0.1;//Define qual o tamanho do salto
digitalWrite(Buzz, HIGH);
delay(100);
digitalWrite(Buzz, LOW);
}

//----------------------------------------------------
if (center.read() == LOW && aumentar.read() == LOW && diminuir.read() == HIGH) {
count2++;
center.rebounce(10);
if (Setpoint < 255)
Setpoint = Setpoint + 0.1;//Define qual o tamanho do salto
digitalWrite(Buzz, HIGH);
delay(100);
digitalWrite(Buzz, LOW);
}
//----------------------------------------------------
// if (diminuir.update() && aumentar.update()){
// count = 0 ;
if ( diminuir.read() == LOW && aumentar.read() == LOW) {
center.rebounce(10);
Setpoint = 20.0;//Define qual o tamanho do salto
digitalWrite(Buzz, HIGH);
delay(100);
digitalWrite(Buzz, LOW);
}
// }

//-------------------------------------------------------------------------------------
//-------------- Tratamento da Inicialização do Instrumento -----------------------
valorPot = ((Setpoint)); // Determina que o valor da peltier seja o Setpoint quando o aparelho é ligado
//valorTemp = getTemp(); //Original
if (Serial.available () == 0) {
iniciar = 0;
valorTemp = Setpoint;
temperatura3 = Setpoint;
// digitalWrite(Buzz, HIGH);
myGLCD.clrScr(); // Limpa o LCD de lixo
}
else {
valorTemp = Temp_Full;
iniciar = 1;
// digitalWrite(Buzz, LOW);
temperatura3 = Temp_Full;//Temperatura enviada diretamente pelo Densímetro (via serial TTL)br/> myGLCD.clrScr(); // Limpa o LCD de lixo
}

DifTemp = (temperatura3 - Setpoint);
DifTemp2 = abs (DifTemp);
// SampleTime = (DifTemp2*DifTemp2*(-0.00476)+DifTemp2*0.3381 + 0.5) * 1000;//Para 500 ms de time final
SampleTime = (DifTemp2*DifTemp2*(-0.007)+DifTemp2*0.4 + 0.1) * 1000; //Para 100 ms de time final

//-------------------------------------------------------
// ---- TRATAMENTO DAS FUNÇÕES PID --------------------
unsigned long now = millis();
int timeChange = (now - lastTime);
if (timeChange >= SampleTime) {
double error = valorPot - valorTemp;
errSum += error;
double dInput = (Input - lastInput);

iTerm += (ki * error);
if (iTerm > potMax) iTerm = potMax;
else if (iTerm < potMin) iTerm = potMin;

valorPelt  = kp * error + ITerm- kd * dInput;
if (valorPelt > potMax) valorPelt = potMax;
else if (valorPelt < potMin) valorPelt = potMin;

lastInput = Input;
lastTime = now;
}

if (valorPelt > potMax) {
valorPelt = potMax;
}
else if (valorPelt < potMin) {
valorPelt = potMin;
}


//--------------------------------------------------------------------------------------
// ----------- Envio de informações para a Ponte H e direção de acionamento -----------

if (valorPelt >= 0 && umidade < Umid) {
digitalWrite(direcaoA, HIGH);
digitalWrite(relePin, LOW); // Desliga o rele de reversão da Peltier(Aquecer)
analogWrite(pwmA, valorPelt);
// myGLCD.update(); // atualiza lcd
myGLCD.printNumF(valorPelt2, 0, 50, 24);
myGLCD.print("Aquecer", LEFT, 24);
valorPelt2 = valorPelt;
}
else if (valorPelt < 0 && umidade < Umid) {
digitalWrite(direcaoA, LOW);
digitalWrite(relePin, HIGH);// Liga o rele de reversão da Peltier(Esfriar)
analogWrite(pwmA, -valorPelt);
myGLCD.printNumF(-valorPelt2, 0, 50, 24);
myGLCD.print("Esfriar", LEFT, 24);
valorPelt2 = valorPelt;

}

if (valorPelt >= 0 && umidade >= Umid) {// Caso a humidade esteja alta e temperatura menor que 10 graus desligar peltier
valorPelt = 0;
analogWrite(pwmA, valorPelt);
myGLCD.printNumF(valorPelt2, 0, 50, 24);
myGLCD.print("Desl. ", LEFT, 24);
valorPelt2 = valorPelt;
}
else if (valorPelt <= 0 && umidade >= Umid) {
valorPelt = 0;
analogWrite(pwmA, valorPelt);
myGLCD.printNumF(valorPelt2, 1, 50, 24);
myGLCD.print("Desl. ", LEFT, 24);
valorPelt2 = valorPelt;
}

//*************************************************
//********* IMPRIME NO DISPLAY ********************
if (iniciar == 0) {
myGLCD.print("Iniciando..", CENTER, 1); //posição da escrita "Temperatura" no display
myGLCD.print("Humid. ", LEFT, 12); //posição da escrita "Temperatura" no display
myGLCD.printNumF(umidade, 0, 51, 12); //Posição do valor da Humidade no display
myGLCD.print("% ", RIGHT, 12); //posição da escrita "%" no display
// myGLCD.print("STime. ", LEFT, 12);
// myGLCD.printNumF(SampleTime, 0, 51, 12);
myGLCD.print("SetPoint", LEFT, 36);
myGLCD.printNumF(valorPot, 1, 55, 36 );
myGLCD.update(); // atualiza lcd
}
if (iniciar == 1) {
myGLCD.print("Temp.", LEFT, 1); //posição da escrita "Temperatura" no display
myGLCD.printNumF(temperatura3, 2, 40, 1); //Posição do valor da temperatura no display _ Para o DHT11 -- o primeiro "1" descreve o numero de casas decimais
myGLCD.print("C ", RIGHT, 1); //posição da escrita "Graus Temperatura" no display
myGLCD.print("Humid. ", LEFT, 12); //posição da escrita "Temperatura" no display
myGLCD.printNumF(umidade, 0, 51, 12); //Posição do valor da Humidade no display
myGLCD.print("% ", RIGHT, 12); //posição da escrita "%" no display
// myGLCD.print("STime. ", LEFT, 12);
// myGLCD.printNumF(SampleTime, 0, 51, 12);
myGLCD.print("SetPoint", LEFT, 36);
myGLCD.printNumF(valorPot, 1, 55, 36 );
myGLCD.update(); // atualiza lcd
}
//*************************************************
//*************************************************
valorPot = Setpoint; // Ajusta o valorPot para o Setpoint desejado.
soma = 0;
i = 0;
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
while (Serial.available() > 0)
{
int index = 0;
delay(100); // permite o buffer encher
int numChar = Serial.available();
if (numChar > 27) {
numChar = 27;
}
while (numChar--) {
buffer[index++] = Serial.read();
}
splitString(buffer);
}

mySerial.write(GetData, sizeof(GetData)); //Envia o pacote de solicitação de transmissão para o Densímetro pelo pino de transmissão escolhido (02
delay(100);
//-----------------------------------------------------------------------------------------
unsigned long currentMillis1 = millis(); //Tempo atual em ms
unsigned long changeTime;
if (currentMillis1 - previousMillis1 > Time1){
previousMillis1 = currentMillis1;//Salva o tempo atual

if (temperatura3 <= MinTemp && (millis() - changeTime) > previousMillis1){
valorPelt2 = valorPelt2;
digitalWrite(Buzz, HIGH);
delay(100);
digitalWrite(Buzz, LOW);
}
}


}//Void

//***************************************** FIM DO VOID LOOP *********************************************************************

//-----------------------------------------------------------------------
//---------- Tratamento dos caracteres recebidos -----------------------
void splitString(char* data)
{
char* parameter;
parameter = strtok (data, " ,");
while (parameter != NULL) {
setLED(parameter);
parameter = strtok (NULL, " ,");
}

// Limpa os textos e o buffer serial
for (int x = 0; x < 27; x++)
{
buffer[x] = '\0';
}
Serial.flush();
}
//-----------------------------------------------------------------------
//-------- Identificação dos pacotes que chegam pela serial ------------
void setLED(char* data) {
if ((data[0] == '@') && (data[13] == '!'))
{
if ((data[18] != 'N') && (data[19] != 'o') || (data[18] != 'D') && (data[19] != 'e'))// Caso o densímetro envie para a serial os
// caracteres 'N' e 'o' nas posições 18 ou 19 ou os caracteres 'D' e 'o' nas posições 18 ou 19
{
Temp_Ap = String(Val_05) + String(Val_06) + String(Val_08) + String(Val_09); // Concaterna strings
Temp_Full = Temp_Ap.toInt(); // transforma strint]g em int
Temp_Full = Temp_Full / 100;


/* Serial.println("Temperatura ");//Envia a temperatura para a saida serial monitor
Serial.println(Temp_Full);
Serial.println();
delay(100);
*/

}
// Variavel float para guardar densidade e temperatura
Val_05 = data[6] & 0x0F; // Remove parte alta do byte buffer 6
Val_06 = data[7] & 0x0F; // Remove parte alta do byte buffer 7
Val_08 = data[9] & 0x0F; // Remove parte alta do byte buffer 9
Val_09 = data[10] & 0x0F; // Remove parte alta do byte buffer 10

}

//---------------------------------------------------------------------------------------


} //Fim do programa !!!

Amigo,

Compartilho um trabalho meu com estas características, onde utilizei uma solução com Arrays:

Ajuste o intervalo entre as leituras do sensor conforme sua necessidade.

Espero que ajude.

Tanaka

Algoritmo de Leitura do Sensor

            Com o objetivo de conferir qualidade aos dados enviados ao site, foi criado um algoritmo para filtrar e eliminar possíveis ruídos ou erros de leitura do sensor.

            A leitura do sensor de ultrassom é realizada cada 100 milissegundos ou 0,1 segundos. Desta forma, 10 leituras a cada segundo que são inseridos em um Array conforme quadro 3. Neste exemplo, as posições 3 e 8 apresentam valores fora do padrão, caracterizando um ruído ou falha.

 

Quadro 3: Array de entrada de dados

dadosSensorUS1[]

Posição

0

1

2

3

4

5

6

7

8

9

Valor

22

21

22

134

23

22

23

23

0

22

Fonte: O autor

 

            Decorrido o tempo de 1 segundo, é realizado o processamento dos dados do Array, para a primeira filtragem dos dados. Nesta etapa os dados lidos são colocados em ordem crescente, ilustrado no quadro 4.

 

Quadro 4: Array ordenado (crescente)

dadosSensorORD[]

Posição

0

1

2

3

4

5

6

7

8

9

Valor

0

21

22

22

22

22

23

23

23

134

Fonte: O autor

 

            Em seguida, são eliminadas as duas primeiras e as duas últimas posições do Array, mantendo as seis posições intermediárias conforme quadro 5, eliminando possíveis erros ou ruídos de leitura, fazendo uma moderação de valores extremos.

 

Quadro 5: Array temporário

dadosSensorTMP[]

posição

0

1

2

3

4

5

valor

22

22

22

22

23

23

Fonte: O autor

 

            Desta forma, o valor final será o calculado pela média dos valores do Array temporário, neste exemplo 22, conferindo desta forma, relevância ao dado que será enviado ao site web.

Muito interessante.

Posso utilizar os valores diferentes do array para saber se houve uma diferença do restante das médias.

Penso no seguinte:

Se a última posição e a primeira posição forem maiores ou menores que a média geral, é sinal que houve a injeção de uma amostra de líquido com temperatura muito menor ou muito maior que as últimas leituras. Isso pode ser usado para travar as funções de PID do algorítimo até que a temperatura de célula volte a ficar na média.

Obrigado pela ajuda.

Mas o que pretendo neste momento, é inserir um modo de sintonia automática do PID para meu código.

Sei que existe uma biblioteca Autotune para o arduino.

Mas estou com dificuldades para ajustar ela para meu código.

Andei estudando outros códigos onde foi utilizada a biblioteca Autotune.

Mas ainda não consegui.

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço