Bloqueo entre radiofrecuencia y la interrupción para llevar el tiempo

Hola a tod@s

estoy haciendo un proyecto y el código no da errores, pero al ejecutarse y enviar datos por radio, envía uno y se queda "tostao".
El código sólo de envío, en programa aparte, funciona... pero no todo junto.
Alguna ayuda? idea? gracias desde ya

Os adjunto el código, correcto, pero se bloquea. He puesto mensajes del serial para ir viendo qué ejecuta y donde casca.
Casi todo está comentado.

gracias de nuevo :clap: :clap: :clap:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <TimerOne.h>
#include <VirtualWire.h>
int led = 13;
//Emisor radio frecuencia
//const int dataPin = 12;                            // - PIN del emisor (Pequeño) D12
const int dataPin = 9;                            // - PIN del emisor (Pequeño) D12

//                     Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity
LiquidCrystal_I2C lcd( 0x27, 2,   1,  0,  4,  5,  6,  7,           3, POSITIVE );
//LCD
//A5->SCL                                             - A5
//A4->SCA                                             - A4
//Botón marcado como D2/D3/D4
#define BTN2 2 // pin al que se conecta el pulsador 1 - D2
#define BTN3 3 // pin al que se conecta el pulsador 2 - D3
#define BTN4 4 // pin al que se conecta el pulsador 3 - D4
//Buzzer D5
const int buzzer = 5;                              // - D5
//Tiempos para botón 2 y botón 4
unsigned int tiempo=0;
volatile long int tiempo1 = 30;
volatile long int tiempo2 = 20;
//Variable para la interrupción
volatile long int Time=tiempo1;
//Otras variables
String msg="";
char msg1[2]="";
//Para el botón 4 de tiempos?
int buttonPushCounter = 0;  
int buttonState = 0;    
int lastButtonState = 0; 
//Para el botón 3 de start y stop
int contador = 0;
int estado = 0;

unsigned long tAntes = 0;
unsigned long tAhora = 0;
unsigned long tEjecucion = 1000;

//Define e inicializa*********************************************
void setup(void)
{
  pinMode(led, OUTPUT); 
  //Control
  Serial.begin(9600);
  // Configura el pin del push como entrada con resistor pullup
  pinMode(BTN2, INPUT_PULLUP);              //botonera
  pinMode(BTN3, INPUT_PULLUP);              //botonera
  pinMode(BTN4, INPUT_PULLUP);              //botonera
  
  vw_setup(2000);                           //emisor
  vw_set_tx_pin(dataPin);                   //emisor
  pinMode(buzzer, OUTPUT);                  //buzzer  
  //Configura salida pantalla LCD
  lcd.begin(16,2);
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Menu:");  

  Timer1.initialize(1000000);               //Configura el TIMER en 1 Segundo 
  Timer1.attachInterrupt(Temporizador) ;    //Configura la interrupción del Timer 1
  Timer1.stop();
  Time=Time+1;
}

//Repetido en bucle***********************************************
void loop(void)
{
  if((9-tAhora/1000)==0)    //Pasado el tiempo de menú
    {
      //Serial.println("Funcionando... ");
      lcd.setCursor(0,0);
      lcd.print("Funcionando:");  
      lcd.setCursor(0,1);
      lcd.print(msg);
      lcd.setCursor(8,1);     
      sprintf(msg1,"%02d \n", Time);  //Da formato de dos dígitos  
      lcd.print(msg1);
      lcd.setCursor(10,1);
      lcd.print("  ");
      
  //Botón tiempo 1    
    if( digitalRead( BTN2) == LOW ){  // sin pulsar
     //Tiempo 1 o verde 1 línea
    }else{                            // pulsado
      Serial.println("Pulsado BTN2");
      msg="Tiempo";
      Time=tiempo1;
    }
  //Botón Start-Stop
    if( digitalRead( BTN3) == LOW ){  // sin pulsar
     //Sin pulsar START-STOP o rojo;
    }else{                            // pulsado
      Serial.println("Pulsado Start-Stop");
      start_stop();
      delay(250);
      Serial.println("Pasado delay250");
    }
  //Botón tiempo2
    if( digitalRead( BTN4) == LOW ){  // sin pulsar
      //Sin pulsar Tiempo 2 o Dos Líneas;
    }else{                            // pulsado
      Serial.println("Pulsado BTN4");
      msg="Tiempo:";
      Time=tiempo2; 
    }
    //
   }else{
    menu();
    if((9-tAhora/1000)==0)    //Pasado el tiempo de menú
      {
      lcd.clear();         
      }
   }
}

//Menú inicial******************************************************
void menu(){
  //Saca el menú inicial (tiempos cambiables? más delante...)
  tAhora = millis();

  if( tAhora - tAntes >= tEjecucion )
  {
    tAntes = tAhora;
    lcd.setCursor(0,1);
    lcd.print("Tiempo:");
    msg="Tiempo:";
    lcd.setCursor(9,1);
    lcd.print(tiempo1);
    lcd.setCursor(11,1);
    lcd.print("-");
    lcd.setCursor(12,1);
    lcd.print(tiempo2);
    lcd.setCursor(9,0);  
    lcd.print(9-tAhora/1000);  //Cuenta atrás desde 9 segundos
  }
}

//Start y Stop***********************************************
void start_stop(){
   //Pasadas?
  Serial.print("Botón Start-Stop"); 
  buttonState = digitalRead(BTN3);
  if(buttonState==1){  
  Serial.print("Rojo = ");
  Serial.print(buttonState);
  Serial.println(" Pulsado");
  Serial.print("Tiempo: ");
  Serial.println(Time);
      if(buttonState && estado==0){     // si pulsador presionado y en estado stop
        Time=Time+1;
        Timer1.start();                 // Inicia la cuenta atrás
                
        msg="Quedan:";
        estado=1;                       // guardamos el estado encendido   
  Serial.print(msg);
  Serial.println(estado);
      } else {                          // si pulsador presionado y led encendido
        Timer1.stop();                  // Para la cuenta atrás
        msg="Parado:";
        estado=0;                       // guardamos el estado apagado   
  Serial.print("Tiempo: ");
  Serial.println(Time);
  Serial.print(msg);
  Serial.println(estado);
      
      }
  }
}
void Emite()
{
   //Envía datos
    Serial.println("Envío datos");
    String str;  
    char buf[VW_MAX_MESSAGE_LEN];
    digitalWrite(led, HIGH);
    str = "i" + String(Time);               // Convertir a string
    str.toCharArray(buf,sizeof(buf));       // Convertir a char array
    vw_send((uint8_t *)buf, strlen(buf));   // Enviar array
    vw_wait_tx();                           // Esperar envio
    delay(250);
    //Fin proceso envío datos  
}

//Función de la Interrupción cuando se ejecuta el TIMER**************************************
void Temporizador(void)
{
  //Decrementa el timer
  Time--;
  tiempo=Time;
  Serial.print("TIME: ");
  Serial.println(Time);

  Emite();                                    //Envía datos
  
  digitalWrite(led, HIGH);
    
  if(Time==0){
    Serial.println("Fin del tiempo!!!");
    msg="Tiempo!";
    tone(buzzer, 1000); // Envío 1KHz señal sonido...
    delay(250);
    tone(buzzer, 400);  // Envío 400Hz señal sonido...
    delay(250);
    Timer1.stop();      //Detiene la cuenta
  }
  digitalWrite(led, LOW);
}
`

Su publicacion se MUEVE a su ubicacion actual ya que es mas adecuada.

@jlijo71b Por favor, edita tu post y pon el código de acuerdo a las Normas del Foro, punto 7.

Primera observación (y te aseguro que fui directo a ver esto), no puedes usar el puerto serial dentro de una rutina de servicio de interrupción, tampoco tone() y mucho menos poner delays.
O sea, hiciste todo lo que no se debe hacer dentro de una ISR (bueno, no todo, al menos no usaste millis()...) :wink:

Si encuentro algo más te digo pero ya lo que te indiqué es suficiente para que el programa se "cuelgue".

Saludos

PD: Una buena guía sobre interrupciones que vale la pena leer
https://www.gammon.com.au/interrupts

Muchas gracias por la ayuda, como se puede ver, en arduino soy principiante :smile:
He modificado el post según norma (culpa mía de las prisas).

Sigue quedando colgado tras comentar lo indicado, con lo que además, algo más tendrá.
Adjunto código actual y gracias de nuevo a tod@s, pues esto no me deja dormir :sweat_smile:eso y mi cabeza, que ya no tiene arreglo y doy vueltas y vueltas :stuck_out_tongue_winking_eye:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <TimerOne.h>
#include <VirtualWire.h>
int led = 13;
//Emisor radio frecuencia
//const int dataPin = 12;                            // - PIN del emisor (Pequeño) D12
const int dataPin = 9;                            // - PIN del emisor (Pequeño) D12

//                     Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity
LiquidCrystal_I2C lcd( 0x27, 2,   1,  0,  4,  5,  6,  7,           3, POSITIVE );
//LCD
//A5->SCL                                             - A5
//A4->SCA                                             - A4
//Botón marcado como D2/D3/D4
#define BTN2 2 // pin al que se conecta el pulsador 1 - D2
#define BTN3 3 // pin al que se conecta el pulsador 2 - D3
#define BTN4 4 // pin al que se conecta el pulsador 3 - D4
//Buzzer D5
const int buzzer = 5;                              // - D5
//Tiempos para botón 2 y botón 4
unsigned int tiempo=0;
volatile long int tiempo1 = 30;
volatile long int tiempo2 = 20;
//Variable para la interrupción
volatile long int Time=tiempo1;
//Otras variables
String msg="";
char msg1[2]="";
//Para el botón 4 de tiempos?
int buttonPushCounter = 0;  
int buttonState = 0;    
int lastButtonState = 0; 
//Para el botón 3 de start y stop
int contador = 0;
int estado = 0;

unsigned long tAntes = 0;
unsigned long tAhora = 0;
unsigned long tEjecucion = 1000;

//Define e inicializa*********************************************
void setup(void)
{
  pinMode(led, OUTPUT); 
  //Control
  Serial.begin(9600);
  // Configura el pin del push como entrada con resistor pullup
  pinMode(BTN2, INPUT_PULLUP);              //botonera
  pinMode(BTN3, INPUT_PULLUP);              //botonera
  pinMode(BTN4, INPUT_PULLUP);              //botonera
  
  vw_setup(2000);                           //emisor
  vw_set_tx_pin(dataPin);                   //emisor
  pinMode(buzzer, OUTPUT);                  //buzzer  
  //Configura salida pantalla LCD
  lcd.begin(16,2);
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Menu:");  

  Timer1.initialize(1000000);               //Configura el TIMER en 1 Segundo 
  Timer1.attachInterrupt(Temporizador) ;    //Configura la interrupción del Timer 1
  Timer1.stop();
  Time=Time+1;
}

//Repetido en bucle***********************************************
void loop(void)
{
  if((9-tAhora/1000)==0)    //Pasado el tiempo de menú
    {
      //Serial.println("Funcionando... ");
      lcd.setCursor(0,0);
      lcd.print("Funcionando:");  
      lcd.setCursor(0,1);
      lcd.print(msg);
      lcd.setCursor(8,1);     
      sprintf(msg1,"%02d \n", Time);  //Da formato de dos dígitos  
      lcd.print(msg1);
      lcd.setCursor(10,1);
      lcd.print("  ");
      
  //Botón tiempo 1    
    if( digitalRead( BTN2) == LOW ){  // sin pulsar
     //Tiempo 1 o verde 1 línea
    }else{                            // pulsado
      Serial.println("Pulsado BTN2");
      msg="Tiempo";
      Time=tiempo1;
    }
  //Botón Start-Stop
    if( digitalRead( BTN3) == LOW ){  // sin pulsar
     //Sin pulsar START-STOP o rojo;
    }else{                            // pulsado
      Serial.println("Pulsado Start-Stop");
      start_stop();
      delay(250);
      Serial.println("Pasado delay250");
    }
  //Botón tiempo2
    if( digitalRead( BTN4) == LOW ){  // sin pulsar
      //Sin pulsar Tiempo 2 o Dos Líneas;
    }else{                            // pulsado
      Serial.println("Pulsado BTN4");
      msg="Tiempo:";
      Time=tiempo2; 
    }
    //
   }else{
    menu();
    if((9-tAhora/1000)==0)    //Pasado el tiempo de menú
      {
      lcd.clear();         
      }
   }
}

//Menú inicial******************************************************
void menu(){
  //Saca el menú inicial (tiempos cambiables? más delante...)
  tAhora = millis();

  if( tAhora - tAntes >= tEjecucion )
  {
    tAntes = tAhora;
    lcd.setCursor(0,1);
    lcd.print("Tiempo:");
    msg="Tiempo:";
    lcd.setCursor(9,1);
    lcd.print(tiempo1);
    lcd.setCursor(11,1);
    lcd.print("-");
    lcd.setCursor(12,1);
    lcd.print(tiempo2);
    lcd.setCursor(9,0);  
    lcd.print(9-tAhora/1000);  //Cuenta atrás desde 9 segundos
  }
}

//Start y Stop***********************************************
void start_stop(){
   //Pasadas?
  Serial.print("Botón Start-Stop"); 
  buttonState = digitalRead(BTN3);
  if(buttonState==1){  
  Serial.print("Rojo = ");
  Serial.print(buttonState);
  Serial.println(" Pulsado");
  Serial.print("Tiempo: ");
  Serial.println(Time);
      if(buttonState && estado==0){     // si pulsador presionado y en estado stop
        Time=Time+1;
        Timer1.start();                 // Inicia la cuenta atrás
                
        msg="Quedan:";
        estado=1;                       // guardamos el estado encendido   
  Serial.print(msg);
  Serial.println(estado);
      } else {                          // si pulsador presionado y led encendido
        Timer1.stop();                  // Para la cuenta atrás
        msg="Parado:";
        estado=0;                       // guardamos el estado apagado   
  Serial.print("Tiempo: ");
  Serial.println(Time);
  Serial.print(msg);
  Serial.println(estado);
      
      }
  }
}
void Emite()
{
   //Envía datos
    Serial.println("Envío datos");
    String str;  
    char buf[VW_MAX_MESSAGE_LEN];
    digitalWrite(led, HIGH);
    str = "i" + String(Time);               // Convertir a string
    str.toCharArray(buf,sizeof(buf));       // Convertir a char array
    vw_send((uint8_t *)buf, strlen(buf));   // Enviar array
    vw_wait_tx();                           // Esperar envio
    delay(250);
    //Fin proceso envío datos  
}

//Función de la Interrupción cuando se ejecuta el TIMER**************************************
void Temporizador(void)
{
  //Decrementa el timer
  Time--;
  tiempo=Time;
  //Serial.print("TIME: ");
  //Serial.println(Time);

  Emite();                                    //Envía datos
  
  digitalWrite(led, HIGH);
    
  if(Time==0){
    //Serial.println("Fin del tiempo!!!");
    msg="Tiempo!";
    //tone(buzzer, 1000); // Envío 1KHz señal sonido...
    //delay(250);
    //tone(buzzer, 400);  // Envío 400Hz señal sonido...
    //delay(250);
    Timer1.stop();      //Detiene la cuenta
  }
  digitalWrite(led, LOW);
}

Creo que no entendiste...

Emite();

tampoco puedes llamarla desde la ISR, sigues repitiendo los mismos problemas (Serial, delay...).
Las rutinas de interrupción tienen que ser muy cortas y rápidas.

Lo que debes hacer es setear una variable (recuerda que debes declararla volatile) que indique que es momento de enviar datos.
Desde el loop() verifica el estado de esa variable y envía los datos si corresponde (llama a Emite()), dispara tonos y todo lo que se te ocurra.
Reitero, desde loop(), nunca desde la ISR.

Algo así

volatile bool listoParaEmitir;

...

//Función de la Interrupción cuando se ejecuta el TIMER**************************************
void Temporizador(void)
{
  //Decrementa el timer
  Time--;
  tiempo=Time;

  listoParaEmitir= true;  // indica que es momento de emitir

  if(Time==0){
    Timer1.stop();      //Detiene la cuenta
  }
}

// en loop()
if (listoParaEmitir) {
  listoParaEmitir = false;  // prepara la variable un próximo conteo
  Emite();   // acá sí es seguro emitir, imprimir, pitar y lo que se te ocurra.
}

Hola de nuevo

he modificado según tus indicaciones, pero algún error tiene que cuando emite, una vez, ya se bloquea.
He puesto para que los leds de placa se enciendan y apaguen, pues algunas veces el puerto serie no obtiene nada y sigue habiendo actividad, pero no es el caso.
Cuando comento la función que emite, sigue la cuenta atrás y sin problema, pero si hago que emita (que es lo que necesito para el proyecto), lo hace una vez y queda ko luego.

De nuevo incorporo el programa con las modificaciones antes indicadas y que seguro son correctas, pero algo le queda que hace que se bloquee. GRACIAS!!!

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <TimerOne.h>
#include <VirtualWire.h>
int led = 13;
//Emisor radio frecuencia
//const int dataPin = 12;                            // - PIN del emisor (Pequeño) D12
const int dataPin = 9;                            // - PIN del emisor (Pequeño) D12
volatile bool listoParaEmitir;
//                     Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity
LiquidCrystal_I2C lcd( 0x27, 2,   1,  0,  4,  5,  6,  7,           3, POSITIVE );
//LCD
//A5->SCL                                             - A5
//A4->SCA                                             - A4
//Botón marcado como D2/D3/D4
#define BTN2 2 // pin al que se conecta el pulsador 1 - D2
#define BTN3 3 // pin al que se conecta el pulsador 2 - D3
#define BTN4 4 // pin al que se conecta el pulsador 3 - D4
//Buzzer D5
const int buzzer = 5;                              // - D5
//Tiempos para botón 2 y botón 4
unsigned int tiempo=0;
volatile long int tiempo1 = 30;
volatile long int tiempo2 = 20;
//Variable para la interrupción
volatile long int Time=tiempo1;
//Otras variables
String msg="";
char msg1[2]="";
//Para el botón 4 de tiempos?
int buttonPushCounter = 0;  
int buttonState = 0;    
int lastButtonState = 0; 
//Para el botón 3 de start y stop
int contador = 0;
int estado = 0;

unsigned long tAntes = 0;
unsigned long tAhora = 0;
unsigned long tEjecucion = 1000;

//Define e inicializa*********************************************
void setup(void)
{
  pinMode(led, OUTPUT); 
  //Control
  Serial.begin(9600);
  // Configura el pin del push como entrada con resistor pullup
  pinMode(BTN2, INPUT_PULLUP);              //botonera
  pinMode(BTN3, INPUT_PULLUP);              //botonera
  pinMode(BTN4, INPUT_PULLUP);              //botonera
  
  vw_setup(2000);                           //emisor
  vw_set_tx_pin(dataPin);                   //emisor
  pinMode(buzzer, OUTPUT);                  //buzzer  
  //Configura salida pantalla LCD
  lcd.begin(16,2);
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Menu:");  

  Timer1.initialize(1000000);               //Configura el TIMER en 1 Segundo 
  Timer1.attachInterrupt(Temporizador) ;    //Configura la interrupción del Timer 1
  Timer1.stop();
  Time=Time+1;
}

//Repetido en bucle***********************************************
void loop(void)
{
  if((9-tAhora/1000)==0)    //Pasado el tiempo de menú
    {
      //Serial.println("Funcionando... ");
      lcd.setCursor(0,0);
      lcd.print("Funcionando:");  
      lcd.setCursor(0,1);
      lcd.print(msg);
      lcd.setCursor(8,1);     
      sprintf(msg1,"%02d \n", Time);  //Da formato de dos dígitos  
      lcd.print(msg1);
      lcd.setCursor(10,1);
      lcd.print("  ");
  //Verifica si tiene que emitir, tras pasar por el contador de tiempo está activo  
    if (listoParaEmitir) {
      listoParaEmitir = false;  // prepara la variable un próximo conteo
      Serial.print("Listo para emitir: ");   
      Emite();                  // aquí sí es seguro emitir, imprimir, pitar y lo que se te ocurra.
      Serial.print(Time);
      Serial.println(" Tiempo emitido");
    }      
  //Botón tiempo 1    
    if( digitalRead( BTN2) == LOW ){  // sin pulsar
     //Tiempo 1 o verde 1 línea
    }else{                            // pulsado
      Serial.print("Pulsado BTN2 Tiempo ");
      msg="Tiempo";
      Time=tiempo1;
      Serial.println(Time);
    }
  //Botón Start-Stop
    if( digitalRead( BTN3) == LOW ){  // sin pulsar
     //Sin pulsar START-STOP o rojo;
    }else{                            // pulsado
      Serial.println("Pulsado Start-Stop");
      start_stop();
      delay(250);
      Serial.println("Pasado delay250");
    }
  //Botón tiempo2
    if( digitalRead( BTN4) == LOW ){  // sin pulsar
      //Sin pulsar Tiempo 2 o Dos Líneas;
    }else{                            // pulsado
      Serial.print("Pulsado BTN4 Tiempo ");
      msg="Tiempo:";
      Time=tiempo2;
      Serial.println(Time); 
    }
    //
   }else{
    menu();
    if((9-tAhora/1000)==0)    //Pasado el tiempo de menú
      {
      lcd.clear();         
      }
   }
}

//Menú inicial******************************************************
void menu(){
  //Saca el menú inicial (tiempos cambiables? más delante...)
  tAhora = millis();

  if( tAhora - tAntes >= tEjecucion )
  {
    tAntes = tAhora;
    lcd.setCursor(0,1);
    lcd.print("Tiempo:");
    msg="Tiempo:";
    lcd.setCursor(9,1);
    lcd.print(tiempo1);
    lcd.setCursor(11,1);
    lcd.print("-");
    lcd.setCursor(12,1);
    lcd.print(tiempo2);
    lcd.setCursor(9,0);  
    lcd.print(9-tAhora/1000);  //Cuenta atrás desde 9 segundos
  }
}

//Start y Stop***********************************************
void start_stop(){
   //Pasadas?
  Serial.print("Botón Start-Stop "); 
  buttonState = digitalRead(BTN3);
  if(buttonState==1){  
  Serial.print("Rojo = ");
  Serial.print(buttonState);
  Serial.println(" Pulsado");
  Serial.print("Tiempo: ");
  Serial.println(Time);
      if(buttonState && estado==0){     // si pulsador presionado y en estado stop
        Time=Time+1;
        Timer1.start();                 // Inicia la cuenta atrás
                
        msg="Inicia:";
        estado=1;                       // guardamos el estado encendido   
 
        Serial.print(msg);
        Serial.println(estado);
      } else {                          // si pulsador presionado y led encendido
        Timer1.stop();                  // Para la cuenta atrás
        msg="Parado:";
        estado=0;                       // guardamos el estado apagado   
  Serial.print(msg);
  Serial.println(estado);
      
      }
  }
}
void Emite()
{
   //Envía datos
    String str;  
    char buf[VW_MAX_MESSAGE_LEN];
    digitalWrite(led, HIGH);
    str = "i" + String(Time);               // Convertir a string
    str.toCharArray(buf,sizeof(buf));       // Convertir a char array
    vw_send((uint8_t *)buf, strlen(buf));   // Enviar array
    vw_wait_tx();                           // Esperar envio
    digitalWrite(led, LOW);
    //Fin proceso envío datos  
}

//Función de la Interrupción cuando se ejecuta el TIMER**************************************
void Temporizador()
{
  //Decrementa el timer
  digitalWrite(led, HIGH);
  Time--;
  tiempo=Time;

  listoParaEmitir= true;  // indica que es momento de emitir

  if(Time==0){
    Timer1.stop();      //Detiene la cuenta
  }
  digitalWrite(led, LOW);
}

Creo que encontré el problema (problemón).
VirtualWire usa el timer 1.

Hola, estoy buscando hace tiempo sobre lo que comentas... pero el problema es que no sé cómo hacer para evitar dicha coincidencia.
O si pudiera usar otra librería... no sé que solución darle por ahora. GRACIAS!!! :clap:

O sea que ya sabías que el problema era el timer y recién ahora lo dices.

La solución es simple, usa millis().

Saludos

Perdona, lo he sacado hace unas Horas y como he dicho ,soy novato... Con lo que de ahí a saber solucionarle, me llevará horas y días.
Agradezco toda tu ayuda y sigo intentando, ahora buscando alguna otra librería que use otra forma de contar el tiempo exacto y no sea incompatible con la de emisión/recepción.
Gracias de nuevo

A ver... El tiempo con millis() es exacto, en todo caso la inexactitud se da (si se diera) por el tiempo que demore el resto de tu código para permitir verificar si ya pasó un segundo pero ese problema lo tienes también usando interrupciones.

1 Like

Esta usando un timer a 1 seg de que inexactitud hablamos?

Timer1.initialize(1000000);               //Configura el TIMER en 1 Segundo 

Claramente puede lograr mejores cosas pero con millis() consigues de 1 mseg a lo que gustes.

1 Like

Gracias a los dos por la ayuda.
El código tenía errores de programación, indicados por MaximoEsfuerzo y a su vez, encontró el bloqueo producido por ambas bibliotecas (la de envío y la de timer) en las interrupciones.
Además, al igual que Surbyte, indicó la posibilidad de usar millis().
Todo ello es correcto, aunque yo por "facilitar" y tras seguir indagando, he encontrado la librería MsTimer2 en el enlace GitHub - PaulStoffregen/MsTimer2: Run a function using a timer
Otra opción válida, como las aportadas. Muchas Gracias!!!

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.