Error de sincronizacion millis y delay

Hola un saludo desde venezuela.

tengo este codigo que uso para controlar un calentador junto con max6675 por tiempo los datos me los muestra en una lcd pero tengo un problema de sincronzacion con el tiempo ,

con este delay si lo quito comparo con un cronometro y funciona bien van sincronizado los seg , pero la lectura del sensor de temperatura con una max 6675 se queda congelado.. para que el sensor lea la temperarura le coloco el delay y funciona pero el tiempo se atrasa con el tiempo real .. entre 15 seg y 20 de que manera podria solucionar para que funcione como debe ser o me den una orientacion..

adjunto el codigo o parte de el

void loop()
{
  while (FLAG_STOP == FALSE)
  {
    unsigned long CURRENT_MILLIS = millis();
    display_temp(ktc.readCelsius());
    display_tiempo();
    control_actuador();
    delay(200);    //                ERROR DESIGUAL 

    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS = CURRENT_MILLIS;
    }

    if (!digitalRead(STOP) || (tiempo == 0))
    {
      FLAG_STOP = TRUE;
    }
  }
  while (FLAG_STOP)
  {
    digitalWrite(SSR, LOW); // APAGA EL SSR
    digitalWrite(LED_PRO, LOW);  // APAGA INDICADOR PROCESO
    final_proceso();

    while (digitalRead(START) || tiempo == 0)
    {
      setpoint_temp = analogRead(ST_TEMP) * 0.1467;
      display_temp(setpoint_temp);
      display_temp_act();
      tiempo = analogRead(ST_TIME) * 0.176;
      display_tiempo();
      display_tiempo_act();
     // delay(50);  // delay de lectura POT
    }

    digitalWrite(LED_PRO, HIGH);  // ACTIVA INDICADOR MODO PROCESO
    FLAG_STOP = FALSE;
  //  delay(100); // ADD
  }
}

Si usas milis() y cargas una variable con su valor no puedes poner luego un delay() es una obviedad.

 unsigned long CURRENT_MILLIS = millis();
    display_temp(ktc.readCelsius());
    display_tiempo();
    control_actuador();
    delay(200);    //                ERROR DESIGUAL 
    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS = CURRENT_MILLIS;
    }

debiera er asi

    display_temp(ktc.readCelsius());
    display_tiempo();
    control_actuador();
    // delay(200);    no se para que quieres este delay
    unsigned long CURRENT_MILLIS = millis();
    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS = CURRENT_MILLIS;
    }

Insisto, replantea tu código, millis() no necesita de delays, solo crean problemas, no van de la mano juntos jamás.

Creo que el delay es necesario para que funcione bien el termómetro.
Entonces lo mejor sería esto (dejando el delay):

    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS +=1000;
    }

buenas tardes ,

la forma como me indica by surbyte va sincronizada , pero la lectura del sensor queda congelado no hace la lectura.

y la que me indica by noter comienza los seg rapidos y despues se sincroniza gual no me funciona

el delay de alguna forma hace que funcione el termómetro. en sus lectura , pero hacer perder la sincronizacion en tiempo real los seg
un saludo

Hola

Me pasaba algo similar con un servo que tenía que hacer un vaiven (0º-45º-0º-45º-0º) un número variable de veces. Si no ponía un delay entre 2 envíos de movimiento al servo,el servo se quedaba atascado sin moverse.

SERVO ATASCADO
...
  // Mueve el servo en vaiven
miServo.write(45);
miServo.write(0);
...

SERVO FUNCIONANDO
...
  // Mueve el servo en vaiven
 miServo.write(45);
delay(50);
miServo.write(0);
delay(50);
...

Como tenía que contar el tiempo de movimiento, me pasaba lo mismo que a ti, por lo que cambié el delay por una función delay_b donde no hacía nada y esperaba a que el servo terminara la primera orden para enviar la segunda y así sucesivamente:

...
// Mueve el servo en vaiven
miServo.write(45);
delay_b(50);
miServo.write(0);
delay_b(50);
...

void delay_b (int milisegundos) { //Retarda los milisegundos que se envian.
  unsigned long tempIni = millis(); //Lee millis()
  while ((millis() - tempIni) < milisegundos) {
  }
}

}

Con esto me funcionó. No he puesto todo el código pero miServo.writre() estaba en el loop y además iba contado el tiempo que al final daba bien.

Casi seguro que el delay que hay que poner después de leer el sensor es para la adquisición de los datos y no leerlos inmediatamente.

Creo que es similar a colocar un delay(5) en cada recepción de lectura del Serial. Si no lo colcaba, algunas veces fallaba la lectura.

Trozo de código
...

if (Serial.available()) //Nos dice si hay datos dentro del buffer
  {
    dato1 = Serial.read(); //Lee el comando
    delay(5); //Poner un pequeño delay para mejorar la recepción de datos
    while (Serial.available() > 0) //Mientras haya datos en el buffer...
//Hace algo con ellos
...

El código de la función delay_b es una obviedad pero espero que te sirva.

Un saludo

El problema con mi código es que no hemos iniciado el cronometro.
Coloca la instrucción
PREV_MILLIS=millis();
Antes del
while (FLAG_STOP == FALSE)

Yo para ayudarte necesito ver todo el código no algo parcial como lo que has posteado.

Adjunto el codigo completo para que puedan visualizarlo mejor y ver que tengo de mas y problemita con el delay
funciona el unico detalle es el que ya he posteado con anterioridad , hice los cambio que me sugirio note y surbyte pero igual

#define   ST_TEMP   A0
#define   ST_TIME   A1
#define   START     A2
#define   STOP      A3
#define  LED_SET    A4

#define   KTC_SO    2
#define   KTC_CS    3
#define   KTC_CLK   4

#define   LED_PRO   5
#define   BUZZER    6
#define   LCD_RS    7
#define   LCD_EN    8
#define   LCD_D4    9
#define   LCD_D5    10
#define   LCD_D6    11
#define   LCD_D7    12
#define   SSR       13

byte termo[8] = {
  B00100,
  B01010,
  B01010,
  B01110,
  B01110,
  B11111,
  B11111,
  B01110
};

byte reloj[8] = {
  0b00000,
  0b10101,
  0b01110,
  0b10001,
  0b10101,
  0b10001,
  0b01110,
  0b00000
};

byte arrowr[] = {

  B00000,
  B01000,
  B00100,
  B11110,
  B00100,
  B01000,
  B00000,
  B00000
};


unsigned int setpoint_temp;
unsigned int tiempo, cont = 0;
unsigned int display_time = 0;
unsigned long PREV_MILLIS = 0;

const int FALSE = 0;
const int TRUE = 1;

short FLAG_STOP = 0;
char buffer[16];

LiquidCrystal lcd(LCD_RS, LCD_EN, LCD_D4, LCD_D5, LCD_D6, LCD_D7);
MAX6675 ktc(KTC_CLK, KTC_CS, KTC_SO);

void setup() {
  digitalWrite(START, HIGH);  // Habilita Pullup Interna
  digitalWrite(STOP, HIGH);    // Habilita Pullup Interna
  digitalWrite(A5, HIGH);     // Habilita Pullup Interna
  digitalWrite(A6, HIGH);     // Habilita Pullup Interna
  digitalWrite(A7, HIGH);     // Habilita Pullup Interna
  digitalWrite(KTC_SO, HIGH); // Habilita Pullup Interna

  pinMode(BUZZER, OUTPUT);
  pinMode(LED_PRO, OUTPUT);
  pinMode(SSR, OUTPUT);
  pinMode(LED_SET, OUTPUT);

  lcd.begin(16, 2);
  mensaje_bienvenida();
  lcd.clear();
  lcd.createChar(0, arrowr);
  lcd.createChar (1, termo);
  lcd.createChar (2, reloj);

  while (digitalRead(START) || tiempo == 0)
  {
    setpoint_temp = analogRead(ST_TEMP) * 0.1956;
    display_temp(setpoint_temp);
    display_temp_act();
    tiempo = analogRead(ST_TIME) * 0.176;
    display_tiempo();
    display_tiempo_act();

  }

  lcd.clear();
  digitalWrite(LED_PRO, HIGH);  // APAGA INDICADOR MODO SET POINT

}
void mensaje_bienvenida() {
  lcd.clear();
  lcd.setCursor(1, 0); // 1-0
  lcd.print("...");
  lcd.setCursor(5, 1);
  lcd.print("...");
  delay(2000);
  lcd.clear();
  //  lcd.print("INICIALIZANDO");
  //  delay(200);
  //  lcd.print(".");
  //  delay(200);
  //  lcd.print(".");
  //  delay(200);
  //  lcd.print(".");
  //  lcd.clear();

}

void loop()
{
  while (FLAG_STOP == FALSE)
  {
    unsigned long CURRENT_MILLIS = millis();
    display_temp(ktc.readCelsius());
    display_tiempo();
    control_actuador();
    delay(500);    //  delay actualiza sensor

    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS = CURRENT_MILLIS;
    }

    if (!digitalRead(STOP) || (tiempo == 0))
    {
      FLAG_STOP = TRUE;
    }
  }
  while (FLAG_STOP)
  {
    digitalWrite(SSR, LOW); // APAGA EL SSR
    digitalWrite(LED_PRO, LOW);  // APAGA INDICADOR PROCESO
    final_proceso();
    lcd.clear();

    while (digitalRead(START) || tiempo == 0)
    {
      setpoint_temp = analogRead(ST_TEMP) * 0.1956;
      display_temp(setpoint_temp);
      display_temp_act();
      tiempo = analogRead(ST_TIME) * 0.176;
      display_tiempo();
      display_tiempo_act();

    }
    lcd.clear();
    digitalWrite(LED_PRO, HIGH);  // ACTIVA INDICADOR MODO PROCESO
    FLAG_STOP = FALSE;
    // delay(100); // ADD
  }
}
void display_temp(int cache_temp) {
  lcd.setCursor(0, 0);
  lcd.print("SENSOR");
  lcd.setCursor(12, 0);
  sprintf(buffer, "%u%c  ", cache_temp, 0xDF);
  lcd.print(buffer);
  lcd.setCursor(10, 0); // ADD arrowr
  lcd.write((byte)0);// ADD arrowr

}

void display_temp_loop(int cache_temp_set, int cache_temp_actual) {
  lcd.setCursor(0, 0);
  sprintf(buffer, "S:%d%cC  ACT:%u%c ", cache_temp_set, 0xDF, cache_temp_actual, 0xDF);
  lcd.print(buffer);
}

void display_tiempo() {

  unsigned int minuto, segundo;
  lcd.setCursor(0, 1);
  minuto = tiempo / 60;
  segundo = tiempo % 60;
  lcd.print("TIEMPO");
  lcd.setCursor(12, 1);
  sprintf(buffer, "%u:%0.2u ", minuto, segundo);
  lcd.print(buffer);
  lcd.setCursor(10, 1); // ADD arrowr
  lcd.write((byte)0); // ADD arrowr

}

void final_proceso() {

  lcd.clear();
  lcd.setCursor(4, 0);
  lcd.print("PROCESO");
  lcd.setCursor(3, 1);
  lcd.print("FINALIZADO");
  digitalWrite(LED_PRO, LOW);
  digitalWrite(LED_SET, LOW);
  digitalWrite(SSR, LOW);
  digitalWrite(BUZZER, HIGH);
  delay(1000);
  digitalWrite(BUZZER, LOW);
  //  delay(1000);
  //  digitalWrite(BUZZER, HIGH);
  //  delay(1000);
  //  digitalWrite(BUZZER, LOW);
  //  delay(1000);
  //  digitalWrite(BUZZER, HIGH);
  //  delay(1000);
  //  digitalWrite(BUZZER, LOW);
  //  delay(1000);
  //  digitalWrite(BUZZER, HIGH);
  //  delay(1000);
  //  digitalWrite(BUZZER, LOW);
  //  delay(1000);
  //  digitalWrite(BUZZER, HIGH);
  //  delay(1000);
  //  digitalWrite(BUZZER, LOW);
  //  delay(1000);

}

void display_temp_act()
{
  lcd.setCursor(0, 0);
  lcd.print("SP TEMP");
  lcd.setCursor(10, 0);
  lcd.write((byte)1);// termo ADD
}

void display_tiempo_act()
{
  lcd.setCursor(0, 1);
  lcd.print("ST TIEMPO");
  lcd.setCursor(10, 1);
  lcd.write((byte)2);   // reloj ADD

}
void control_actuador()
{
  if (ktc.readCelsius() >= setpoint_temp)
  {
    digitalWrite(SSR, LOW);
    digitalWrite(LED_SET, LOW);
  }
  else
  {
    digitalWrite(SSR, HIGH);
    digitalWrite(LED_SET, HIGH);
  }
}

¿Has probado haciendo los dos cambios que te ha propuesto noter?

noter:
Creo que el delay es necesario para que funcione bien el termómetro.
Entonces lo mejor sería esto (dejando el delay):

    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)

{
      tiempo--;
      PREV_MILLIS +=1000;
    }

noter:
El problema con mi código es que no hemos iniciado el cronometro.
Coloca la instrucción
PREV_MILLIS=millis();
Antes del
while (FLAG_STOP == FALSE)

Creo que no has probado con los dos cambios propuestos por noter.

con este cambio actualiza la lectura del sensor , pero los seg comienzan rapidamente despues va sincronizando

void loop()
{

 
  while (FLAG_STOP == FALSE)
  {
    unsigned long CURRENT_MILLIS = millis();
    display_temp(ktc.readCelsius());
    display_tiempo();
    control_actuador();
    delay(500);    //  delay actualiza sensor

    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS += 1000;         // esta sugerencia de note  
    }

con este cambio las lectura del sensor se congela y sincroniza en tiempo real

void loop()
{

  PREV_MILLIS = millis();     //este es el cambio que me sugirio NOTER
  
  while (FLAG_STOP == FALSE)
  {
    unsigned long CURRENT_MILLIS = millis();
    display_temp(ktc.readCelsius());
    display_tiempo();
    control_actuador();
    delay(500);    //  delay actualiza sensor

    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS = CURRENT_MILLIS;
    }

    if (!digitalRead(STOP) || (tiempo == 0))
    {
      FLAG_STOP = TRUE;
    }
  }

¿Has probado haciendo los dos cambios que te ha propuesto noter?

¡¡Juntos!! ¡¡A la vez!!

Aunque parezca obvio, no es lo mismo:

     PREV_MILLIS = CURRENT_MILLIS;

... que:

     PREV_MILLIS += 1000;

¿Pero, a efectos prácticos, cuál es la diferencia?

La diferencia es que en el primer caso nos aseguramos que siempre transcurre al menos el tiempo deseado (1000 milisegundos en este caso) entre la asignación de PREV_MILLIS y el que se cumpla la condición de tiempo transcurrido, ya que "el contador de tiempo parte desde el instante actual (CURRENT_MILLIS)", sin importar cuánto tiempo había pasado desde el instante anterior. Con ello nos aseguramos que al menos han pasado los 1000 milisegundos. Eso significa que podría haber sido más de 1000 milisegundos (y seguramente habrán sido más de 1000) con lo que poco a poco tendremos "perdidas de tiempo" y el contador de segundos se retrasará. Que es lo que te estaba pasando porque el delay() hace que el tiempo entre comparación y comparación sea algo superior a 1000 milisegundos (las instrucciones, aunque poco, tardan su tiempo en realizarse).

Esta forma de controlar los millis() viene bien cuando nos queremos asegurar de que el "evento" no se realiza antes del tiempo estipulado y es preferible que se realice más tarde. Por ejemplo, en tu caso podría ser el leer la temperatura. No queremos que entre lectura y lectura de temperatura pase menos de, por ejemplo, 500 milisegundos (podría ser tu caso, pero no lo es porque los millis() los estas usando para otra cosa, y estás usando el delay() para la temperatura).

En el segundo caso puede que transcurra más o menos tiempo del deseado (1000 milisegundos en este caso) entre la "actualización" de PREV_MILLIS y el que se cumpla la condición de tiempo transcurrido. No importa si transcurre menos de 1000 milisegundos o más de 1000 milisegundos, lo que nos importa es controlar que "salte" una vez por cada 1000 milisegundos que hayan pasado. Porque lo que queremos es contar de 1000 en 1000 los milisegundos transcurridos para saber lo más exactamente posible el "tiempo total" transcurrido. Esto es lo que se busca en este caso.

Tu caso sería un ejemplo práctico para usar ambos. Ya que por un lado se desea asegurar que siempre transcurra un tiempo mínimo entre consulta y consulta de la temperatura porque si se hacen dos demasiado rápidas falla la lectura. Y por otro lado se desea contar lo más exactamente posible el tiempo total transcurrido. Así que vamos a aprovechar lo que tienes para ejemplificar los dos casos. El que controla el tiempo transcurrido lo dejamos con los dos cambios que señaló noter y añadamos otro PREV_MILLIS_TEMPERATURA para quitarnos el delay() y controlar con millis() que el tiempo transcurrido entre lectura y lectura de temperatura es, como mínimo, de 500 milisegundos.

En programa llamaba a ktc.readCelsius() para mostrarse la temperatura y "casi al instante" vuelvía a llamar a ktc.readCelsius() dentro de la función control_actuador(). Así que para evitarlo he modificado la función y ahora recibe la temperatura, que leo una vez y se usa también para mostrar su valor.

#define   ST_TEMP   A0
#define   ST_TIME   A1
#define   START     A2
#define   STOP      A3
#define  LED_SET    A4

#define   KTC_SO    2
#define   KTC_CS    3
#define   KTC_CLK   4

#define   LED_PRO   5
#define   BUZZER    6
#define   LCD_RS    7
#define   LCD_EN    8
#define   LCD_D4    9
#define   LCD_D5    10
#define   LCD_D6    11
#define   LCD_D7    12
#define   SSR       13

byte termo[8] = {
  B00100,
  B01010,
  B01010,
  B01110,
  B01110,
  B11111,
  B11111,
  B01110
};

byte reloj[8] = {
  0b00000,
  0b10101,
  0b01110,
  0b10001,
  0b10101,
  0b10001,
  0b01110,
  0b00000
};

byte arrowr[] = {

  B00000,
  B01000,
  B00100,
  B11110,
  B00100,
  B01000,
  B00000,
  B00000
};


unsigned int setpoint_temp;
unsigned int tiempo, cont = 0;
unsigned int display_time = 0;
unsigned long PREV_MILLIS = 0;
unsigned long PREV_MILLIS_TEMPERATURA = 0; // <-- para controlar el tiempo de lectura de temperatura

const int FALSE = 0;
const int TRUE = 1;

short FLAG_STOP = 0;
char buffer[16];

LiquidCrystal lcd(LCD_RS, LCD_EN, LCD_D4, LCD_D5, LCD_D6, LCD_D7);
MAX6675 ktc(KTC_CLK, KTC_CS, KTC_SO);

void setup() {
  digitalWrite(START, HIGH);  // Habilita Pullup Interna
  digitalWrite(STOP, HIGH);    // Habilita Pullup Interna
  digitalWrite(A5, HIGH);     // Habilita Pullup Interna
  digitalWrite(A6, HIGH);     // Habilita Pullup Interna
  digitalWrite(A7, HIGH);     // Habilita Pullup Interna
  digitalWrite(KTC_SO, HIGH); // Habilita Pullup Interna

  pinMode(BUZZER, OUTPUT);
  pinMode(LED_PRO, OUTPUT);
  pinMode(SSR, OUTPUT);
  pinMode(LED_SET, OUTPUT);

  lcd.begin(16, 2);
  mensaje_bienvenida();
  lcd.clear();
  lcd.createChar(0, arrowr);
  lcd.createChar (1, termo);
  lcd.createChar (2, reloj);

  while (digitalRead(START) || tiempo == 0)
  {
    setpoint_temp = analogRead(ST_TEMP) * 0.1956;
    display_temp(setpoint_temp);
    display_temp_act();
    tiempo = analogRead(ST_TIME) * 0.176;
    display_tiempo();
    display_tiempo_act();

  }

  lcd.clear();
  digitalWrite(LED_PRO, HIGH);  // APAGA INDICADOR MODO SET POINT

}
void mensaje_bienvenida() {
  lcd.clear();
  lcd.setCursor(1, 0); // 1-0
  lcd.print("...");
  lcd.setCursor(5, 1);
  lcd.print("...");
  delay(2000);
  lcd.clear();
}

void loop()
{
  CURRENT_MILLIS_TEMPERATURA = millis() - 500; // <-- Lo ponemos 500 milisegundos en el "pasado" para forzar la lectura de la temperatura
  PREV_MILLIS = millis(); // <-- Inicializamos la "cuenta total" de tiempo
  while (FLAG_STOP == FALSE)
  {
    unsigned long CURRENT_MILLIS = millis();
    if (CURRENT_MILLIS - PREV_MILLIS_TEMPERATURA >= 500)
    {
      unsigned int temperatura = ktc.readCelsius();
      PREV_MILLIS_TEMPERATURA = CURRENT_MILLIS; // <-- Nos queremos asegurar que transcurran al menos 500 milisegundos
      display_temp(temperatura);
      display_tiempo();
      control_actuador(temperatura);
    }

    if (CURRENT_MILLIS - PREV_MILLIS >= 1000)
    {
      tiempo--;
      PREV_MILLIS += 1000; // <-- Queremos que decremente tiempo por cada 1000 milisegundos transcurridos
    }

    if (!digitalRead(STOP) || (tiempo == 0))
    {
      FLAG_STOP = TRUE;
    }
  }
  while (FLAG_STOP)
  {
    digitalWrite(SSR, LOW); // APAGA EL SSR
    digitalWrite(LED_PRO, LOW);  // APAGA INDICADOR PROCESO
    final_proceso();
    lcd.clear();

    while (digitalRead(START) || tiempo == 0)
    {
      setpoint_temp = analogRead(ST_TEMP) * 0.1956;
      display_temp(setpoint_temp);
      display_temp_act();
      tiempo = analogRead(ST_TIME) * 0.176;
      display_tiempo();
      display_tiempo_act();

    }
    lcd.clear();
    digitalWrite(LED_PRO, HIGH);  // ACTIVA INDICADOR MODO PROCESO
    FLAG_STOP = FALSE;
    // delay(100); // ADD
  }
}
void display_temp(int cache_temp) {
  lcd.setCursor(0, 0);
  lcd.print("SENSOR");
  lcd.setCursor(12, 0);
  sprintf(buffer, "%u%c  ", cache_temp, 0xDF);
  lcd.print(buffer);
  lcd.setCursor(10, 0); // ADD arrowr
  lcd.write((byte)0);// ADD arrowr

}

void display_temp_loop(int cache_temp_set, int cache_temp_actual) {
  lcd.setCursor(0, 0);
  sprintf(buffer, "S:%d%cC  ACT:%u%c ", cache_temp_set, 0xDF, cache_temp_actual, 0xDF);
  lcd.print(buffer);
}

void display_tiempo() {

  unsigned int minuto, segundo;
  lcd.setCursor(0, 1);
  minuto = tiempo / 60;
  segundo = tiempo % 60;
  lcd.print("TIEMPO");
  lcd.setCursor(12, 1);
  sprintf(buffer, "%u:%0.2u ", minuto, segundo);
  lcd.print(buffer);
  lcd.setCursor(10, 1); // ADD arrowr
  lcd.write((byte)0); // ADD arrowr

}

void final_proceso() {

  lcd.clear();
  lcd.setCursor(4, 0);
  lcd.print("PROCESO");
  lcd.setCursor(3, 1);
  lcd.print("FINALIZADO");
  digitalWrite(LED_PRO, LOW);
  digitalWrite(LED_SET, LOW);
  digitalWrite(SSR, LOW);
  digitalWrite(BUZZER, HIGH);
  delay(1000);
  digitalWrite(BUZZER, LOW);
}

void display_temp_act()
{
  lcd.setCursor(0, 0);
  lcd.print("SP TEMP");
  lcd.setCursor(10, 0);
  lcd.write((byte)1);// termo ADD
}

void display_tiempo_act()
{
  lcd.setCursor(0, 1);
  lcd.print("ST TIEMPO");
  lcd.setCursor(10, 1);
  lcd.write((byte)2);   // reloj ADD

}
void control_actuador(unsigned int temperatura)
{
  if (temperatura >= setpoint_temp)
  {
    digitalWrite(SSR, LOW);
    digitalWrite(LED_SET, LOW);
  }
  else
  {
    digitalWrite(SSR, HIGH);
    digitalWrite(LED_SET, HIGH);
  }
}

No lo he probado, así que no descarto fallos. Espero que sirva para ilustrar lo que he querido explicar.

Nota: he quitado líneas que habían comentadas porque el post era demasiado grande.
Nota2: he corregido el código, que accidentalmente lo puse sin cambios.

Mil gracias a los que tuvieron interés en ayudarme a corregir el código .

by IgnoranteAbsoluto , la solucion que me diste funciono. sincroniza en tiempo real y la lectura del sensor excelente

AGRADEZCO A TODOS SALUDO DESDE VENEZUELA.. MARACAIBO