Fazendo um controlador de temperatura com arduino

[Guilherme Torres]

Consegui finalmente fazer os dois termopares funcionarem ao mesmo tempo com leituras coerentes e bem próximas. UFA!!! Que luta!!!

 

Próximo round será fazer acionar os relés SSR.

 

O relê do aquecimento eu já manjei, porque está muito claro no sketch. Mas o da ventoinha (fan) eu vi o slider no programa, mas não achei a porta no sketch.

 

Podem me ajudar?

 

PS. lembrando que vou usar uma ventoinha AC.

O que fez de diferente?

Qual era o problema?

[Weiler]

Weiler,

O sketch não tem o recurso da ventoinha. Vc que vai ter que bolar. Tenho aqui em algum lugar. Amanhã posto as linhas

 

Se você me pedisse para bolar um contrato eu faria em 10min. Mas linhas de programação......tsc tsc

 

Melhor contar com a sua ajuda... 

 

O que fez de diferente?

Qual era o problema?

 

Basicamente eu soldei os fios (antes estavam apenas plugados) e tinha um erro em uma das linhas do sketch.

 

Também mudei o tempo de retorno do loop do termopar de 250ms para 2000ms. Aí estabilizou a leitura. Agora a variação fica só na casa decimal.

[Guilherme Torres]

Weiler,

 

Fiz a alteração que você propôs no tempo de leitura do termopar. Elaborei, também, uma linha para excluir erros de leitura (que são constantes quando há corrente elétrica de qualquer forma (inclusive gerada por atrito) em contato com o sensor). Não sei se vai funcionar adequadamente, pois ainda não cheguei a testar essa linha (Já fiz outras abordagens, que não expus aqui porque não deram 100% certo).

 

Não fiz nada muito elaborado para o controle de potência do fan (então, não há zero cross, nem modulação via frequência, como no sketch original do TC4). Apenas especifiquei um analogWrite, já com a devida multiplicação da porcentagem pelo valor suportado pela porta analógica.

 

acho mais fácil postar o código aqui. Se tiver alguma sugestão, alteração, vamos trocando idéias aqui. O que acha?

 

Bom, segue o código:

 

 

 

 

 

#include <PID_Beta6.h>                // include the PID library
#include <MAX31855.h>

#define CELSIUS //RoastLogger default is Celsius - To output data in Fahrenheit comment out this one line
#define DP 1  // No. decimal places for serial output

#define maxLength 30                  // maximum length for strings used

const int arduino = 0;                // either overridden if power pot is set below 97% to power pot control
const int computer = 1;              

/****************************************************************************
 *
 * Arduino pin assignments
 *
 * The following are the pin assignments used by my setup.
 *
 * You only need to change the following 5 constants to suit the pin
 * assignments suitable for your Arduino board. You should use the pre defined SPI pins for your board
 * and an additional digital pin for the chip select 2 pin.  I have shown below the pins relevant for
 * a Teensy 2.0 and Arduino Duemilanove/Uno and compatible boards.
 *
 ****************************************************************************/

// set pin numbers:
const int pwmPin =  10;         // digital pin for pulse width modulation of heater

/**
// pins used to test Max 31855 with Teensy 2.0
const int CS1 = 4;        // CS (chip 1 select) pin
const int CS2 = 8;        // CS (chip 2 select)  pin
const int SO  = 3;        // SO pin
const int SCKa = 1;        // SCK pin
**/

// pins used to test Max 31855 with Arduino Duemilanove/Uno and compatible boards
const int CS1 = 11;        // CS (chip 1 select) pin
const int CS2 = 8;        // CS (chip 2 select)  pin
const int SO  = 12;        // SO pin
const int SCKa = 13;        // SCK pin



/****************************************************************************
 *  After setting the above pin assignments you can use the remainder of this
 *   sketch as is or change it, if you wish, to add additional functionality
 *
 ****************************************************************************/

MAX31855 readt1(SCK, CS1, MISO);
MAX31855 readt2(SCK, CS2, MISO);


// time constants
const int timePeriod = 2000;           // total time period of PWM milliseconds see note on setupPWM before changing
const int tcTimePeriod = 2000;         // 250 ms loop to read thermocouples

// thermocouple settings
float calibrate1 = 0.0;    // Temperature compensation for T1
float calibrate2 = 0.0;    // Temperature compensation for T2

// PID variables - initial values just guesses, actual values set by computer
double pidSetpoint, pidInput, pidOutput;
double pidBias = 0;
double pidP = 20.0;
double pidI = 45.0;
double pidD = 10.0;

//Specify the links and initial tuning parameters (last three are P I and D values)
PID myPID(&pidInput, &pidOutput, &pidSetpoint, &pidBias, pidP, pidI, pidD);


// set global variables

//temporary values for temperature to be read
float temp1 = 0.0;                   // temporary temperature variable
float temp2 = 0.0;                   // temporary temperature variable
float t1 = 0.0;                      // Last average temperature on thermocouple 1 - average of four readings
float t2 = 0.0;                      // Last average temperature on thermocouple 2 - average of four readings
float tCumulative1 = 0.0;            // cumulative total of temperatures read before averaged
float tCumulative2 = 0.0;            // cumulative total of temperatures read before averaged
int noGoodReadings1 = 0;             // counter of no. of good readings for average calculation
int noGoodReadings2 = 0;             // counter of no. of good readings for average calculation

int inByte = 0;                       // incoming serial byte
String inString = String(maxLength);  // input String


// loop control variables
unsigned long lastTCTimerLoop;        // for timing the thermocouple loop
int tcLoopCount = 0;                  // counter to run serial output once every 4 loops of 250 ms t/c loop

// PWM variables
int  timeOn;                          // millis PWM is on out of total of timePeriod (timeOn = timePeriod for 100% power)
unsigned long lastTimePeriod;         // millis since last turned on pwm
int power = 100;                      //use as %, 100 is always on, 0 always off default 100

int controlBy = arduino;              // default is arduino control. PC sends "pccontrol" to gain control or
                                      // swapped back to Arduino control if PC sends "arduinocontrol"

int fan =0; // requisito necessario para se ter a leitura do fan
int rettemp1 = 0; // variavel para manter a leitura anterior da temperatura caso haja erro



void setup()
{
 
  // start serial port at 115200 baud:
  Serial.begin(115200);
  // use establish contact if you want to wait until 'A' sent to Arduino before start - not used in this version
  // establishContact();  // send a byte to establish contact until receiver responds
  setupPWM();
 
  //set up pin modes for Max 31855
  pinMode(CS1, OUTPUT);
  pinMode(CS2, OUTPUT);
  pinMode(SO, INPUT);
  pinMode(SCKa, OUTPUT);
  // deselect both Max 31855
  digitalWrite(CS1, HIGH);
  digitalWrite(CS2, HIGH);
 
  //set up the PID
  pidInput = 0;                        // for testing start with temperature of 0
  pidSetpoint = 0;                   // default if not connected to computer
  myPID.SetOutputLimits(0,100);        // set output range 0 - 100 %
  myPID.SetInputLimits(0,250);         // 0 - 250 degrees C
  myPID.SetSampleTime(2000);           // set 2 second sample time for pID so equal to PWM cycle time
  //turn the PID on
  myPID.SetMode(AUTO);  
 
  Serial.println("Reset");            // flag that Arduino has reset used for debugging
}

/****************************************************************************
 * Set up power pwm control for heater.  Hottop uses a triac that switches
 * only on zero crossing so normal pwm will not work.
 * Minimum time slice is a half cycle or 10 millisecs in UK.  
 * Loop in this prog may need up to 10 ms to complete.
 * I will use 20 millisecs as time slice with 100 power levels that
 * gives 2000 milliseconds total time period.
 * The Hottop heater is very slow responding so 2 sec period is not a problem.
 ****************************************************************************/
void setupPWM() {
  // set the digital pin as output:
  pinMode(pwmPin, OUTPUT);      

  //setup PWM
  lastTimePeriod = millis();
  digitalWrite(pwmPin, HIGH);//set PWM pin on to start
}


void dofan() {
 
  pinMode (3, OUTPUT); // ESTABELECE O PIN 3 PWM COMO O PIN QUE VAI SER USADO PELA VENTOINHA AC
 
    analogWrite (3, (fan * 2.55));
}
 
 
// this not currently used
void establishContact() {
  //  while (Serial.available() <= 0) {
  //    Serial.print('A', BYTE);   // send a capital A
  //    delay(300);
  //  }
  Serial.println("Opened but no contact yet - send A to start");
  int contact = 0;
  while (contact == 0){
    if (Serial.available() > 0) {
      inByte = Serial.read();
      Serial.println(inByte);
      if (inByte == 'A'){
        contact = 1;
        Serial.println("Contact established starting to send data");
      }    
    }
  }  
}

/****************************************************************************
 * Toggles the heater on/off based on the current power level.  Power level
 * may be determined by arduino or computer.
 ****************************************************************************/
void doPWM()
{
  timeOn = timePeriod * power / 100; //recalc the millisecs on to get this power level, user may have changed
 
 if (millis() - lastTimePeriod > timePeriod) lastTimePeriod = millis();
 if (millis() - lastTimePeriod < timeOn){
      digitalWrite(pwmPin, LOW); // turn on
  } else {
      digitalWrite(pwmPin, HIGH); // turn off    
 }
 
}

/****************************************************************************
 * Called to set power level. Now always safe as hardware only turns heater on
 * if BOTH the Arduino AND the Hottop control board call for heat.
 ****************************************************************************/
void setPowerLevel(int p)
{
   if (p > -1 && p < 101) power = p;
}

/****************************************************************************
 * Called when an input string is received from computer
 * designed for key=value pairs or simple text commands.
 * Performs commands and splits key and value
 * and if key is defined sets value otherwise ignores
 ****************************************************************************/
void doInputCommand()
{
  float v = -1;
  inString.toLowerCase();
  int indx = inString.indexOf('=');

  if (indx < 0){  //this is a message not a key value pair

    if (inString.equals("pccontrol")) {
      controlBy = computer;      
    }
    else if (inString.equals("arduinocontrol")) {
      controlBy = arduino;        
    }

  }
  else {  //this is a key value pair for decoding
    String key = inString.substring(0, indx);
    String value = inString.substring(indx+1, inString.length());

    //parse string value and return float v
    char buf[value.length()+1];
    value.toCharArray(buf,value.length()+1);
    v = atof (buf);
   

    //only set value if we have a valid positive number - atof will return 0.0 if invalid
    if (v >= 0)
    {
      if (key.equals("power")  && controlBy == computer && v < 101){  
        
        setPowerLevel((long) v);//convert v to integer for power
                
      } else
      if (key.equals("sett2")){ // set PID setpoint to T2 value
        pidSetpoint = v;
        
      } else
      if (key.equals("pidbias")) { // set pid bias default is 0%
        pidBias = v;
        myPID.Reset();// this resets the PID deleting any accumulated error
      } else
      if (key.equals("pidp")) {
        pidP = v;
      } else
      if (key.equals("pidi")) {
        pidI = v;
      } else
      if (key.equals("pidd")) {
        pidD = v;
      }
      if (key.equals("fan")) {
        fan = v;
      }
    }
  }
}

/****************************************************************************
 * check if serial input is waiting if so add it to inString.  
 * Instructions are terminated with \n \r or 'z'
 * If this is the end of input line then call doInputCommand to act on it.
 ****************************************************************************/
void getSerialInput()
{
  //check if data is coming in if so deal with it
  if (Serial.available() > 0) {

    // read the incoming data as a char:
    char inChar = Serial.read();
    // if it's a newline or return or z, print the string:
    if ((inChar == '\n') || (inChar == '\r') || (inChar == 'z')) {

      //do whatever is commanded by the input string
      if (inString.length() > 0) doInputCommand();
      inString = "";        //reset for next line of input
    }
    else {
      // if we are not at the end of the string, append the incoming character
      if (inString.length() < maxLength) {
            inString += inChar;
      }
      else {
        // empty the string and set it equal to the incoming char:
      //  inString = inChar;
           inString = "";
           inString += inChar;
      }
    }
  }
}

/****************************************************************************
 * Send data to computer once every second.  Data such as temperatures,
 * PID setting etc.
 * This allows current settings to be checked by the controlling program
 * and changed if, and only if, necessary.
 * This is quicker that resending data from the controller each second
 * and the Arduino having to read and interpret the results.
 ****************************************************************************/
void doSerialOutput()
{
  //send data to logger
     
  float tt1;
  float tt2;
 
  #ifdef CELSIUS
    tt1 = t1;
    tt2 = t2;
  #else
    tt1 = (t1 * 9 / 5) + 32;
    tt2 = (t2 * 9 / 5) + 32;
  #endif   
 
  Serial.print("t1=");
  Serial.println(tt1,DP);
 
  //Comment out the next two lines if using only one thermocouple
  Serial.print("t2=");
  Serial.println(tt2,DP);

  Serial.print("power%=");
  Serial.println(power);
 
  Serial.print ("fan=");
  Serial.println (fan);
 

  // only need to send these if Arduino controlling by PID
  if (controlBy == arduino)
  {
    Serial.print("targett2=");
    Serial.println(pidSetpoint,DP);

    Serial.print("pidP=");
    Serial.println(pidP,DP);

    Serial.print("pidI=");
    Serial.println(pidI,DP);

    Serial.print("pidD=");
    Serial.println(pidD,DP);

    Serial.print("pidBias=");
    Serial.println(pidBias,DP);
  }
}

/****************************************************************************
 * Read temperatures from Max 31855 chips Sets t1 and t2, -1 if an error
 * occurred.  Max 31855 needs 240 ms between readings or will return last
 * value again. I am reading it once per second.
 ****************************************************************************/
void getTemperatures()
{
 
 temp1 =  readt1.readCelsius();
 temp2 =  readt2.readCelsius();
 
  //readt? returns 2000 if error
 if (temp1 < 2000)
 {
    tCumulative1 = tCumulative1 + temp1;
     noGoodReadings1 ++;
 }
 if (temp2 < 2000)
 {
    tCumulative2 = tCumulative2 + temp2;
    noGoodReadings2 ++;
 }
}

/****************************************************************************
* Purpose to adjust PID settings and compute new output value setting power
* to pidOutput on exit
****************************************************************************/
void updatePID(){

   pidInput = t2;
   
   myPID.SetTunings(pidP,pidI,pidD);
 
   myPID.Compute();

   setPowerLevel(pidOutput); // range set in setup to 0 - 100%
}

/****************************************************************************
 * Called by main loop once every 250 ms
 * Used to read each thermocouple once every 250 ms
 *
 * Once per second averages temperature results, updates PID and outputs data
 * to serial port.
 ****************************************************************************/
void do250msLoop()
{

    getTemperatures();
                      
    if (tcLoopCount > 3)  // once every four loops (1 second) calculate average temp, update PID and do serial output
    {
      
      tcLoopCount = 0;
      
      if (noGoodReadings1 > 0)  {t1 = tCumulative1 / noGoodReadings1;
     rettemp1 = t1;}
      else t1 = rettemp1;
      if (noGoodReadings2 > 0)  t2 = tCumulative2 / noGoodReadings2; else t2 = -1.0;
      noGoodReadings1 = 0;
      noGoodReadings2 = 0;
      tCumulative1 = 0.0;
      tCumulative2 = 0.0;
      
      // only use PID if in Arduino control.  If Computer control power is set by computer
        if (controlBy == arduino){
          updatePID(); // set to execute once per 2 seconds in setup, just returns otherwise
        }
        
       doSerialOutput(); // once per second
    }
    tcLoopCount++;

}


/****************************************************************************
 * Main loop must not use delay!  PWM heater control relies on loop running
 * at least every 40 ms.  If it takes longer then heater will be on slightly
 * longer than planned. Not a big problem if 1% becomes 1.2%! But keep loop fast.
 * Currently loop takes about 4-5 ms to run so no problem.
 ****************************************************************************/
void loop(){

  getSerialInput();// check if any serial data waiting

  // loop to run once every 250 ms to read TC's update PID etc.
  if (millis() - lastTCTimerLoop >= 250)
  {
    lastTCTimerLoop = millis();
    do250msLoop();  
  }

  doPWM();        // Toggle heater on/off based on power setting
  dofan();
}
 

[Weiler]

EUREKA!!!

Funciona que é uma beleza!!!     

 

Testei com a própria ventoinha e tudo está de acordo. Valeu demaaaaais!!!

 

Mas surgiu uma dúvida em relação ao controle da resistência. Em 100% ela não aciona o relê e consequentemente não aquece. Abaixo desse valor ela fica pulsando, e continua pulsando cada vez mais rápido até que chega em 0% e fica ligada direto.

 

Engraçado que o a ventoinha ficou como esperado (normal), sendo 0% desligada e 100% com força total.

 

A mesma lógica não se aplicaria à resistência???

[Guilherme Torres]

Inverte o código: onde está digitalWrite (HIGH) muda para LOW

E vice versa

[Guilherme Torres]

Deu certo? Outra coisa, na linha setpoint, coloca um valor bem baixo. Por padrão, quando não está conectado ao computador, ele está programado para aquecer e manter em 220°

[Weiler]

Opa! Deu certo sim!!!

 

A escala desinverteu, porém um efeito indesejado continua, que é o acionamento do relê por alguns segundos quando se liga o arduino até abrir o roastlogger.

 

Nesse final de semana eu foquei mais no hardware, porqe eu precisava terminar a montagem física dos fios, sensores e da caixa de controle.

 

Depois de tudo no lugar, fui testar a linha DC. Liguei a fonte 12v e o notebook para conferir a leitura dos termopares.

 

Pra minha surpresa, quando a fonte está desconectada do jack de alimentação, a leitura fica normal. Porém, quando conecto a fonte, o sensor ET dá pau (vai a -1), enquanto o outro marca, mas fica estranho.

 

Nenhum deles está em contato com a lata, mas é bem evidente que a ligação da fonte deve estar aterrando os sensores de alguma forma.

 

Sabe me dizer se aquele motor DC aterra a carcaça no negativo (-) ?!

[Guilherme Torres]

Depois vou ver o que fiz no sketch lá de casa (esse fiz aqui e não cheguei a testar conectado ao relê)

Quanto a erros de leitura, bem que avisei que não é fácil.

O motor é o grande culpado por interferências. O ideal seria ter uma bucha de cerâmica para conectar o motor no resto do conjunto. Quanto à ligação no eixo, uso um acoplamento de alumínio, que não é bom condutor.

 

Depois vou ver se bolo algo razoável para evitar erros de leitura. Mas, no momento, estou concentrado em outra coisa, que é fazer o meu tambor (importado) funcionar bem com o resto do conjunto do STC DUO.

[Weiler]

Legal, Guilherme! Suas dicas têm sido de muito valor.

 

O sensor ET eu o coloquei dentro de um "casulo" cerâmico, deixando à mostra apenas a ponta metálica. Testei a continuidade no multímetro e nem ele, nem a malha estão em contato com a carcaça do torrador.

 

Hoje a noite vou fazer mais testes com o motor e a fiação. Posso tentar isolar também com um anel de cerâmica. O duro é que eu já fiz a coisa para ficar meio "definitiva", daí desmontar e partir para a prancheta é tenso!!!

 

Mas, como um bom brasileiro, não desisto fácil.

 

E vamos trocando ideias.

 

Abs.

[Guilherme Torres]

Se não for colocar sensor BT, vai resolver esse casulo.

[Ricardo Esteves]

Affff... Hoje eu decidi entrar no ramo de torrador também. "Deixa ver o que tem no forum sobre o assunto..."
Meu Deus... 4 páginas de pop fun, 10 de arduino, 34 de dicas pra torrar na pipoqueira...
Então, eu decidi hoje, mas até ler tudo e fazer as compras...

[Guest Anita]

Ricardo, vai de tostex. Devem ser umas duas páginas.

[Ricardo Esteves]

Ah não, manual de mais.. Eu fui escoteiro mas hoje vivo de TI !! rsrsrs

Quero minha pipoqueira com whey protein, vulgo arduino...

[Santiago Luz]

Ricardo, vou seguir os passos do Mortari e montar a Pop Fun com controle em Arduino. Atualmente, minha pipoqueira está apenas com o mod de separar a alimentação da resistência e do ventilador. Ainda controlo a leitura e as potências manualmente. Foi legal por enquanto para brincar com a torra. Agora quero levar isso mais a sério, mas não tããão a sério assim. Então a Pop Fun com Arduino deve atender bem minhas expectativas. Já encomendei as peças no eBay e estou aguardando chegarem para começar a brincadeira.

 

Eu devo montar um tópico específico sobre essa modificação, com um passo a passo bem simples para qualquer um conseguir montar a sua. Pelo menos, essa é a minha intenção. Vamos ver se eu vou conseguir montar a minha e se vou conseguir montar o tópico! 

[marcosjost]

Leo, Guilherme....Parabens pelo trabalho e pesquisa.

Agora arrumei uma boa função pro meu forno best  encostado e meu Mega1280 encostado pos TCC.....

http://forum.clubedocafe.net/index.php?/topic/3926-torrador-com-forno-el%C3%A9trico-best-com-rotisserie/

 

Vou catar minhas caixas com cacarecos eletrónicos e shields de arduino e ver o que tenho e o que falta......

Iria pegar um pipoqueira, mas como lembrei do forno parado e vi esse topico e do philco....mudei de idéia....

 

UPDATE:

Enquanto não ponho a mão, vou deixar meus 50 cents para o pessoal que quiser conhecer mais sobre arduino e afins, alguns dos sites que uso como referencia, alem dos ja mencionados.

 

http://brasilrobotics.blogspot.com.br

 

http://www.eaduino.com.br/

 

http://pt.slideshare.net/felipenm/introduo-a-sistemas-embarcados-com-arduino-minicurso

 

https://www.arduino.cc/en/Tutorial/HomePage

 

https://www.circuitar.com.br/tutoriais/programacao-para-arduino-primeiros-passos/

[marcosjost]

Bom dia pessoal.

Com o dolar alto comprar peças de fora esta um pouco complicado, alem da demora.

Tem uma loja online que pego diversos componentes para arduino quando nao posso esperar muito por peças vindas de fora, normalmente tem um preço competitivo.

Pedi pra eles uma cotação baseada na lista que o Guilherme colocou aqui:

http://forum.clubedocafe.net/index.php?/topic/1365-fazendo-um-controlador-de-temperatura-com-arduino/page-6#entry34053

 

49,00 o termopar... 33,00 o lcd shield....nos links tem todos os valores.

O que acham dos componentes e valores?

 

A resposta

Olá Marcos

Tenho os produtos da loja:
http://lojabrasilrobotics.blogspot.com.br/
O sensor de temperatura mais indicado:
http://lojabrasilrobotics.blogspot.com.br/2015/02/termopar-tipo-k-r00.html
Vou ter esses relês para controle de resistências ou cargas:
http://lojabrasilrobotics.blogspot.com.br/search/label/Rel%C3%A9
E esses displays:
http://lojabrasilrobotics.blogspot.com.br/search/label/Display
Esse modelo pode ser de seu interesse:
http://lojabrasilrobotics.blogspot.com.br/2011/02/promocao-lcd-shield-r3300.html
Veja a lista de produtos por tópicos:
http://lojabrasilrobotics.blogspot.com.br/2013/04/blog-post_19.html
Sobre o controle PID basta baixar a biblioteca de PID no arduino e
fazer o controle não precisa comprar um pronto. Basta fazer o seu.

[Santiago Luz]

Pessoal, estou meio perdido. Chegaram as peças para eu fazer o controle da pipoqueira via Arduino. Aparentemente, consegui implementar o controle manual usando o RoastLogger. Mas eu gostaria mesmo é de usar o controle automático. Meu objetivo é carregar um template no RoastLogger e ele controlar a potência para perseguir o perfil do template. É possível funcionar dessa forma? Ou seria apenas pela lista de PID setpoints ou actions?

[sergio.m]

Mas um "template" que vc se refere não seria uma "lista de PID setpoints ou actions"?

 

Faz tempo que não uso o roastlogger (uso um programa que fiz), mas pelo que lembre, é só editar o arquivo que ele guarda os tais setpoints caso não queira usar a interface dele.

[Santiago Luz]

É diferente. Sergio. O template é quando você importa o log de uma torra que foi realizada anteriormente. Fica um perfil com coloração mais fraca para ser seguido durante a torra.

 

Pior que nem com os setpoints eu consegui fazer funcionar.

Não dá para visualizar os dados transmitidos e recebidos pelo Arduino quando o RoastLogger está funcionando?

[sergio.m]

Vc não conseguiu o controle manual pelo roastlogger? Então o hardware está ok. Talvez seja só questão de como configurar esse esquema dos setpoints.

[#magaldiespresso]

alguém recomenda algum  shield termopar k e rele ssr baratinho para eu começar minhas modificações na minha pipoqueira ?

Tava pensando em implementar no arduino  um vetor de tamanho 30 para torras de 15 minutos e atualizações a cada 30 segundos,  que iria atualizar o loop de torra em aprox. cada 30 segundos com a temperatura do indice "i" do vetor a ser percorrido, assim poderia entrar com os dados de qualquer curva manualmente, estou cometendo alguma gafe ?

[leo_bsb]

bom ver esse tópico firme e forte.

A boa notícia é que agora no site do roastlogger já tem um sketch pronto para o MAX31855. Só tem que alterar os pinos do LCD para quem usar o china.

abraço a todos.