Leer RPMs y Delay al mismo tiempo? [SOLUCIONADO]

Hola a todos

Estoy realizando un programa para leer los RPMs de un ventilador de 3 pines, este circuito incluye un pushbutton de inicio y una pantalla LCD (el botón y la pantalla tienen luces led) estoy usando un Arduino Mega 2560.

El programa consiste en que al presionar el botón, se encienda el ventilador, lea los RPMs por 7 seg. aproximadamente, y de una respuesta... Si los rpms estan dentro del valor, la respuesta sera "paso prueba" en LCD, y el LCD y el pushbutton encenderán en verde, en caso contrario de que el valor este por debajo se imprimirá "fallo prueba" y el pushbutton encenderán en rojo, por 4 segundos, y volverá a inicio a estado de "listo para probar"

Todo funciona excepto que los 7 segundos que debería tardar leyendo los RPMs mientras en el LCD dice "probando"... en esos 7 segundos deja de leer los RPM..... Estoy utilizando interrupciones para leer los RPMs es por eso que no funciona el Delay, soy relativamente nueva en programación, me ayudan con algun modo de que me lea los RPM y me haga el delay al mismo tiempo? ya intente con millis y con banderas pero creo que aun no soy buena usándolos porque no logree que quedara :frowning:

/*
  Filename: RPM Ventilador 3 pines
*/

#include <LiquidCrystal.h>

//Inicializar los pines conectados a la pantalla
LiquidCrystal lcd(53, 37, 39, 41, 43, 45);

static int PulsosFan;  // contador de impulsos
const int hallsensor = 18;  // pin 2, que está unido a interrupción 0

int Ventilador = 28;  // pin de encendido/apagado del ventilador
int Boton = 42;  // boton de inicio


// LED indicador de la prueba
int Boton_enable = 36;
int Boton_green = 38;
int Boton_red = 40;

int rpms;
bool banderaint = 1;
bool valor,anterior;


// LCD indicador de la prueba
int LCD_blue = 49;
int LCD_green = 47;
int LCD_red = 51;


void setup()
{

  lcd.begin(16, 2);  // Inicia la interfaz para el LCD screen, y determina sus dimensiones (ancho,alto) en este caso (16x2)

  pinMode(Ventilador, OUTPUT);
  pinMode(Boton, INPUT_PULLUP);
  pinMode(Boton_enable, OUTPUT);
  pinMode(Boton_green, OUTPUT);
  pinMode(Boton_red, OUTPUT);
  digitalWrite(Boton_enable, HIGH);

  pinMode(LCD_green, OUTPUT);
  pinMode(LCD_red, OUTPUT);
  pinMode(LCD_blue, OUTPUT);
  digitalWrite(LCD_blue, HIGH);
  
  
  lcd.blink();  // Displayamos el Blinking del Cursor sobre el LCD
  delay(2000);
  lcd.noBlink();  // Apagamos el Blinking del Cursor sobre el LCD
   
  lcd.print("INICIANDO...");  // Imprime "INICIAR PRUEBA" en pantalla
  delay(2000);
  lcd.clear();
  
  pinMode(hallsensor, INPUT);
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(hallsensor), rpm, RISING);
 
}

void loop() {
  inicio:
  banderaint = 1;  // empieza la interrupción
  
  lcd.clear();
  delay(10);
  lcd.print("READY TO TEST");
  lcd.setCursor(0,0);
  delay(999);  // retardo de casi 1 segundo
  Serial.print(PulsosFan * 30);  // como son dos interrupciones por vuelta (contador * (60/2))
  Serial.println("RPM");
  rpms = PulsosFan * 30;
  PulsosFan = 0;
   
  valor = digitalRead(Boton);
   
  if (!valor && anterior){
    
      delay(50);
      digitalWrite(Ventilador, HIGH); // se enciende ventilador
      lcd.clear();
      delay(50);
      lcd.print("Probando...");  // imprime "Probando..." en pantalla
      delay(7000);
      
      if ((rpms >= 8800) && (rpms <= 13, 200)) {
      digitalWrite(Ventilador, LOW);  // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("PASO PRUEBA");  // imprime "PASO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW);  // se apaga pantalla zaul
      digitalWrite(Boton_green, HIGH);  // se enciende led verde
      digitalWrite(LCD_green, HIGH);  // se enciende pantalla verde
      delay(4000);  // se mantiene led verde y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_green, LOW);  // se apaga led verde
      digitalWrite(LCD_green, LOW);  // se apaga pantalla verde
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
      }
      
    else {
      digitalWrite(Ventilador, LOW);  // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("FALLO PRUEBA");  // imprime "FALLO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW);  // se apaga pantalla zaul
      digitalWrite(Boton_red, HIGH);  // se enciende led rojo
      digitalWrite(LCD_red, HIGH);  // se enciende pantalla rojo
      delay(4000);  // se mantiene led rojo y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_red, LOW);  // se apaga led rojo
      digitalWrite(LCD_red, LOW);  // se apaga pantalla rojo
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
      }
     
  banderaint = 0;  // termina interrupción
  Serial.println(rpms);
  }

  anterior = valor;
  goto inicio;
}
  
void rpm()  // función que se ejecuta durante cada interrupción

{
  if (banderaint == 1) {
    PulsosFan++;  // se incrementa en uno el contador
  }
}

Espero puedan ayudarme :pray: llevo semanas con esto :pray:

Vamos por partes...
Lo que no puedes es usar delay() dentro de una rutina de atención de interrupciones, pero no hay problema si se usa fuera de todo lo que tenga que ver con la interrupción.

Esta declaración está mal

static int PulsosFan;

Primero no tiene sentido declarar static una variable global, se usa (a veces) con las variables locales.
Segundo, la variable debe ser volatile ya que se modifica en la interrupción.
Entonces lo correcto es

volatile int PulsosFan;

Por seguridad también modificaría la declaración de banderaint

volatile bool banderaint = 1;

Aparte de estos "detalles" no menores, el mayor problema es que calculas rpms antes de contar los pulsos durante 7 segundos.
Tu código lee los pulsos luego del "retardo de casi 1 segundo" cuando debería hacerlo luego del delay de 7 segundos.
Hay otras cosas que "me hacen ruido" (no me gustan), independientemente del uso de delay() que me parece que en este caso no es algo que moleste realmente.
Lo voy a revisar más a fondo pero ya tienes algunas cosas para corregir.

Saludos

Ademas de lo que dice @anon90500195 a mi lo que no me gusta es que en todo momento tienes activadas las interrupciones y simplemente conectas o no conectas el contador. Ademas tienes algunas cosas desordenadas y repetida. prueba este y fijate como y cuando conectar las interrupciones.

/*
  Filename: RPM Ventilador 3 pines
*/

#include <LiquidCrystal.h>

//Inicializar los pines conectados a la pantalla
LiquidCrystal lcd(53, 37, 39, 41, 43, 45);

volatile int PulsosFan;  // contador de impulsos
const int hallsensor = 18;  // pin 2, que está unido a interrupción 0

int Ventilador = 28;  // pin de encendido/apagado del ventilador
int Boton = 42;  // boton de inicio


// LED indicador de la prueba
int Boton_enable = 36;
int Boton_green = 38;
int Boton_red = 40;

int rpms;
bool valor, anterior;


// LCD indicador de la prueba
int LCD_blue = 49;
int LCD_green = 47;
int LCD_red = 51;


void setup(){

  lcd.begin(16, 2);  // Inicia la interfaz para el LCD screen, y determina sus dimensiones (ancho,alto) en este caso (16x2)

  pinMode(Ventilador, OUTPUT);
  pinMode(Boton, INPUT_PULLUP);
  pinMode(Boton_enable, OUTPUT);
  pinMode(Boton_green, OUTPUT);
  pinMode(Boton_red, OUTPUT);
  digitalWrite(Boton_enable, HIGH);

  pinMode(LCD_green, OUTPUT);
  pinMode(LCD_red, OUTPUT);
  pinMode(LCD_blue, OUTPUT);
  digitalWrite(LCD_blue, HIGH);


  lcd.blink();  // Displayamos el Blinking del Cursor sobre el LCD
  delay(2000);
  lcd.noBlink();  // Apagamos el Blinking del Cursor sobre el LCD

  lcd.print("INICIANDO...");  // Imprime "INICIAR PRUEBA" en pantalla
  delay(2000);
  lcd.clear();

  pinMode(hallsensor, INPUT);
  Serial.begin(9600);
}

void loop() {
inicio:
  lcd.clear();
  delay(10);
  lcd.setCursor(0, 0);
  lcd.print("READY TO TEST");

  valor = digitalRead(Boton);

  if (!valor && anterior) {
    lcd.print("Probando...");  // imprime "Probando..." en pantalla
    digitalWrite(Ventilador, HIGH); // se enciende ventilador
    delay (2000);// Que coja y estabilice revoluciones
    PulsosFan = 0;
    attachInterrupt(digitalPinToInterrupt(hallsensor), rpm, RISING);// interrupciones activadas
    delay(7000);  // retardo de 7 segundos midiendo las interrupciones
    detachInterrupt(digitalPinToInterrupt(hallsensor));// interrupciones desactivadas
    digitalWrite(Ventilador, LOW); // se apaga ventilador
    rpms = PulsosFan * 30 / 7;// como son dos interrupciones por vuelta (contador * (60/2)) Y /7 segundos de la medida
    Serial.print(rpms * 60);  // rpms a RPM
    Serial.println(" RPM");


    lcd.clear();
    delay(50);


    if ((rpms >= 8800) && (rpms <= 13200)) {

      lcd.print("PASO PRUEBA");  // imprime "PASO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW);  // se apaga pantalla zaul
      digitalWrite(Boton_green, HIGH);  // se enciende led verde
      digitalWrite(LCD_green, HIGH);  // se enciende pantalla verde
      delay(4000);  // se mantiene led verde y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_green, LOW);  // se enciende led verde
      digitalWrite(LCD_green, LOW);  // se apaga pantalla verde
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
    }

    else {
      lcd.print("FALLO PRUEBA");  // imprime "FALLO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW);  // se apaga pantalla zaul
      digitalWrite(Boton_red, HIGH);  // se enciende led rojo
      digitalWrite(LCD_red, HIGH);  // se enciende pantalla rojo
      delay(4000);  // se mantiene led verde y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_red, LOW);  // se apaga led rojo
      digitalWrite(LCD_red, LOW);  // se apaga pantalla rojo
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
    } 
    Serial.println(rpms);
  }
  anterior = valor;
  goto inicio;
}

void rpm() { // función que se ejecuta durante cada interrupción
  PulsosFan++;  // se incrementa en uno el contador
}

NOTA: en los encendidos de led e impresiones los he mirado muy por encima compruebalos.
Saludos.

Hola, mil gracias por responder @anon90500195 realice las correcciones, pero sigue sin leerme los rpm durante esos 7 segundos :sweat_smile: de momento lo tengo asi:

/*
  Filename: RPM Ventilador 3 pines
*/
#include <LiquidCrystal.h>

//Inicializar los pines conectados
LiquidCrystal lcd(53, 37, 39, 41, 43, 45);

volatile int PulsosFan;  // Contador de impulsos
const int hallsensor = 18; // pin 2, que está unido a interrupción 0

int Ventilador = 28;  // pin de encendido/apagado del ventilador
int Boton = 42; // Boton de inicio

// LED indicador de la prueba
int Boton_enable = 36;
int Boton_green = 38;
int Boton_red = 40;
int rpms;
volatile bool banderaint = 1;
bool valor,anterior;

int LCD_blue = 49;
int LCD_green = 47;
int LCD_red = 51;


void setup()
{

  lcd.begin(16, 2); // Inicia la interfaz para el LCD screen, y determina sus dimensiones (ancho,alto) en este caso (16x2)
  
  pinMode(Boton, INPUT_PULLUP);
  pinMode(Boton_enable, OUTPUT);
  pinMode(Boton_green, OUTPUT);
  pinMode(Boton_red, OUTPUT);
  digitalWrite(Boton_enable, HIGH);

  pinMode(LCD_green, OUTPUT);
  pinMode(LCD_red, OUTPUT);
  pinMode(LCD_blue, OUTPUT);
  digitalWrite(LCD_blue, HIGH);
  
  
  lcd.blink(); // Displayamos el Blinking del Cursor sobre el LCD
  delay(2000);
  lcd.noBlink(); // Apagamos el Blinking del Cursor sobre el LCD
   
  lcd.print("INICIANDO..."); // Imprime "INICIAR PRUEBA" en pantalla
  delay(2000);
  lcd.clear();
  
  pinMode(hallsensor, INPUT);
  Serial.begin(9600);
   
}

void loop() {
  inicio:
  
  lcd.clear();
  delay(50);
  lcd.setCursor(0,0);
  lcd.print("READY TO TEST");
  delay(999);
    
  valor = digitalRead(Boton);
  if (!valor && anterior){
      banderaint = 1;  // empieza la interrupción
      delay(50);
      digitalWrite(Ventilador, HIGH); // se enciende ventilador
      lcd.clear();
      delay(50);
      lcd.print("Probando...");  // imprime "Probando..." en pantalla
      delay(999);  // retardo de casi 1 segundo

      attachInterrupt(digitalPinToInterrupt(hallsensor), rpm, RISING);
      
      Serial.print(PulsosFan * 30);  // como son dos interrupciones por vuelta (contador * (60/2))
      Serial.println("RPM");
      rpms = PulsosFan * 30;
      PulsosFan = 0;     
      delay(7000);

       
      if ((rpms >= 8800) && (rpms <= 13, 200)) {
      digitalWrite(Ventilador, LOW);  // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("PASO PRUEBA");  // imprime "PASO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW); // se apaga pantalla zaul
      digitalWrite(Boton_green, HIGH); // se enciende led verde
      digitalWrite(LCD_green, HIGH); // se enciende pantalla verde
      delay(4000);  // se mantiene led verde y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_green, LOW); // se apaga led verde
      digitalWrite(LCD_green, LOW); // se apaga pantalla verde
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
      }
      
    else {
      digitalWrite(Ventilador, LOW);  // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("FALLO PRUEBA");  // imprime "FALLO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW); // se apaga pantalla zaul
      digitalWrite(Boton_red, HIGH);  // se enciende led rojo
      digitalWrite(LCD_red, HIGH);  // se enciende pantalla rojo
      delay(4000);  // se mantiene led rojo y mensaje "FALLO PRUEBA" durante 4 segundos
      digitalWrite(Boton_red, LOW);  // se apaga led rojo
      digitalWrite(LCD_red, LOW);  // se apaga pantalla rojo
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
    }
    
  banderaint = 0;  // termina interrupción
  Serial.println(rpms);
  }

  anterior = valor;
  goto inicio;
}
  
void rpm()  // función que se ejecuta durante cada interrupción
{
  if (banderaint == 1) {
    PulsosFan++;  // se incrementa en uno el contador
  }
}

Se que probablemente mi error este donde calculo los RPMs, pero hasta el momento sigo sin lograr corregirlo :pray:

Pero sigues calculando rpms antes del delay de 7 segundos!

Probá así

      delay(7000);
      rpms = PulsosFan * 30;
      Serial.print(rpms);  // como son dos interrupciones por vuelta (contador * (60/2))
      Serial.println("RPM");
      
      PulsosFan = 0;     
      

Hola, mil gracias por responder @gonpezzi , el programa sigue sin leerme los RPM durante los 7 segundos.. se que algo debo tener mal acomodado, pero no consigo descubrir que :slightly_frowning_face:

*/
#include <LiquidCrystal.h>

//Inicializar los pines conectados
LiquidCrystal lcd(53, 37, 39, 41, 43, 45);

volatile int PulsosFan;  // Contador de impulsos
const int hallsensor = 18; // pin 2, que está unido a interrupción 0

int Ventilador = 28;  // pin de encendido/apagado del ventilador
int Boton = 42; // Boton de inicio

// LED indicador de la prueba
int Boton_enable = 36;
int Boton_green = 38;
int Boton_red = 40;
int rpms;
volatile bool banderaint = 1;
bool valor,anterior;

int LCD_blue = 49;
int LCD_green = 47;
int LCD_red = 51;


void setup()
{

  lcd.begin(16, 2); // Inicia la interfaz para el LCD screen, y determina sus dimensiones (ancho,alto) en este caso (16x2)

  pinMode(Ventilador, OUTPUT);
  pinMode(Boton, INPUT_PULLUP);
  pinMode(Boton_enable, OUTPUT);
  pinMode(Boton_green, OUTPUT);
  pinMode(Boton_red, OUTPUT);
  digitalWrite(Boton_enable, HIGH);

  pinMode(LCD_green, OUTPUT);
  pinMode(LCD_red, OUTPUT);
  pinMode(LCD_blue, OUTPUT);
  digitalWrite(LCD_blue, HIGH);
  
  
  lcd.blink(); // Displayamos el Blinking del Cursor sobre el LCD
  delay(2000);
  lcd.noBlink(); // Apagamos el Blinking del Cursor sobre el LCD
   
  lcd.print("INICIANDO..."); // Imprime "INICIAR PRUEBA" en pantalla
  delay(2000);
  lcd.clear();
  
  pinMode(hallsensor, INPUT);
  Serial.begin(9600);
   
}

void loop() {
  inicio:
  
  lcd.clear();
  delay(50);
  lcd.setCursor(0,0);
  lcd.print("READY TO TEST");
  delay(999);
    
  valor = digitalRead(Boton);
  if (!valor && anterior){
    lcd.print("Probando...");  // imprime "Probando..." en pantalla
    digitalWrite(Ventilador, HIGH); // se enciende ventilador
    delay (2000);// Que coja y estabilice revoluciones
    PulsosFan = 0;
    attachInterrupt(digitalPinToInterrupt(hallsensor), rpm, RISING);// interrupciones activadas
    delay(7000);  // retardo de 7 segundos midiendo las interrupciones
    detachInterrupt(digitalPinToInterrupt(hallsensor));// interrupciones desactivadas
    digitalWrite(Ventilador, LOW); // se apaga ventilador
    rpms = PulsosFan * 30 / 7;// como son dos interrupciones por vuelta (contador * (60/2)) Y /7 segundos de la medida
    Serial.print(rpms * 60);  // rpms a RPM
    Serial.println(" RPM");
    delay(50);

       
      if ((rpms >= 8800) && (rpms <= 13, 200)) {
      digitalWrite(Ventilador, LOW);  // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("PASO PRUEBA");  // imprime "PASO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW); // se apaga pantalla zaul
      digitalWrite(Boton_green, HIGH); // se enciende led verde
      digitalWrite(LCD_green, HIGH); // se enciende pantalla verde
      delay(4000);  // se mantiene led verde y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_green, LOW); // se apaga led verde
      digitalWrite(LCD_green, LOW); // se apaga pantalla verde
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
      }
      
    else {
      digitalWrite(Ventilador, LOW);  // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("FALLO PRUEBA");  // imprime "FALLO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW); // se apaga pantalla zaul
      digitalWrite(Boton_red, HIGH);  // se enciende led rojo
      digitalWrite(LCD_red, HIGH);  // se enciende pantalla rojo
      delay(4000);  // se mantiene led rojo y mensaje "FALLO PRUEBA" durante 4 segundos
      digitalWrite(Boton_red, LOW);  // se apaga led rojo
      digitalWrite(LCD_red, LOW);  // se apaga pantalla rojo
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
    }

  Serial.println(rpms);
  }

  anterior = valor;
  goto inicio;
}
  
void rpm()  // función que se ejecuta durante cada interrupción
{
    PulsosFan++;  // se incrementa en uno el contador
}

de momento lo tengo asi :sweat_smile:

Estás mezclando mis correcciones con el código de @gonpezzi , aclara lo que haces porque sino ayudarte se complica.

Compilaste y corriste con mi corrección tu código original antes de afirmar que no funciona?

Y agrego: No está mal lo que hiciste originalmente, la interrupción puede estar habilitada todo el tiempo, nada lo impide, lo importante es en que momento reseteas el contador de pulsos y (obviamente) en que momento los lees.

Hola, si lo probe, tengo dos programas abiertos, en uno hice las modificaciones que me recomendó usted, y en otro las modificaciones que me recomendó el otro compañero.

Tambien queria agregar que la razón por la que uso tantos delay cercas de las impresiones en la pantalla, es porque mi pantalla tarda unos milisegundos en leer, es por eso que el código tiene tantos delays :sweat_smile:

(la segunda modificación que me recomendo todavia no la hacia al escribir este mensaje) una vez echa si me funciono perfectamente
:smiley:

wooow ya me funciona correctamente!!!

Muchas gracias!!! :raised_hands: :ok_hand: :star_struck:

Asi quedo el SOLUCIONADO:

/*
  Filename: RPM Ventilador 3 pines
*/
#include <LiquidCrystal.h>

//Inicializar los pines conectados
LiquidCrystal lcd(53, 37, 39, 41, 43, 45);

volatile int PulsosFan;  // contador de impulsos
const int hallsensor = 18; // pin 2, que está unido a interrupción 0

int Ventilador = 28;  // pin de encendido/apagado del ventilador
int Boton = 42; // Boton de inicio

// LED indicador de la prueba
int Boton_enable = 36;
int Boton_green = 38;
int Boton_red = 40;
int rpms;
volatile bool banderaint = 1;
bool valor,anterior;

int LCD_blue = 49;
int LCD_green = 47;
int LCD_red = 51;


void setup()
{

  lcd.begin(16, 2); // Inicia la interfaz para el LCD screen, y determina sus dimensiones (ancho,alto) en este caso (16x2)

  pinMode(Ventilador, OUTPUT);
  pinMode(Boton, INPUT_PULLUP);
  pinMode(Boton_enable, OUTPUT);
  pinMode(Boton_green, OUTPUT);
  pinMode(Boton_red, OUTPUT);
  digitalWrite(Boton_enable, HIGH);

  pinMode(LCD_green, OUTPUT);
  pinMode(LCD_red, OUTPUT);
  pinMode(LCD_blue, OUTPUT);
  digitalWrite(LCD_blue, HIGH);
  
  
  lcd.blink(); // Displayamos el Blinking del Cursor sobre el LCD
  delay(2000);
  lcd.noBlink(); // Apagamos el Blinking del Cursor sobre el LCD
   
  lcd.print("INICIANDO..."); // Imprime "INICIAR PRUEBA" en pantalla
  delay(2000);
  lcd.clear();
  
  pinMode(hallsensor, INPUT);
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(hallsensor), rpm, RISING);
 
}

void loop() {
  inicio:
  banderaint = 1;  // empieza la interrupción
  
  lcd.clear();
  delay(10);
  lcd.print("READY TO TEST");
  lcd.setCursor(0,0);
  delay(999);  // retardo de casi 1 segundo

   
  valor = digitalRead(Boton);
  if (!valor && anterior){

      delay(50);
      digitalWrite(Ventilador, HIGH); // se enciende ventilador
      lcd.clear();
      delay(50);
      lcd.print("Probando...");  // imprime "Probando..." en pantalla
      
      delay(7000);
      rpms = PulsosFan * 30;
      Serial.print(rpms);  // como son dos interrupciones por vuelta (contador * (60/2))
      Serial.println("RPM");
      PulsosFan = 0;     
 
      if ((rpms >= 8800) && (rpms <= 13, 200)) {
      digitalWrite(Ventilador, LOW); // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("PASO PRUEBA");  // imprime "PASO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW); // se apaga pantalla zaul
      digitalWrite(Boton_green, HIGH); // se enciende led verde
      digitalWrite(LCD_green, HIGH); // se enciende pantalla verde
      delay(4000);  // se mantiene led verde y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_green, LOW); // se apaga led verde
      digitalWrite(LCD_green, LOW); // se apaga pantalla verde
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
      }
      
    else {
      digitalWrite(Ventilador, LOW); // se apaga ventilador
      lcd.clear();
      delay(50);
      lcd.print("FALLO PRUEBA");  // imprime "FALLO PRUEBA" en pantalla
      digitalWrite(LCD_blue, LOW); // se apaga pantalla zaul
      digitalWrite(Boton_red, HIGH);  // se enciende led rojo
      digitalWrite(LCD_red, HIGH);  // se enciende pantalla rojo
      delay(4000);  // se mantiene led rojo y mensaje "PASO PRUEBA" durante 4 segundos
      digitalWrite(Boton_red, LOW);  // se apaga led rojo
      digitalWrite(LCD_red, LOW);  // se apaga pantalla rojo
      digitalWrite(LCD_blue, HIGH);  // se enciende pantalla azul
      lcd.clear();
      delay(50);
    }
    
  banderaint = 0;  // termina interrupción
  Serial.println(rpms);
  }

  anterior = valor;
  goto inicio;
}
  
void rpm()  // función que se ejecuta durante cada interrupción
{
  if (banderaint == 1) {
    PulsosFan++;  // se incrementa en uno el contador
  }
}

Muchas gracias, como escribi abajo, esta fue la solución correcta ! mil gracias @anon90500195
:star_struck: :ok_hand: :raised_hands: :grin:

Recuerdo que mi profesor de programación, nos contó a todos, prohibido usar GOTO, para evitar malas formas de programar.

Uh! No lo había visto!

@cristylm quita esa linea (la del goto) que además es innecesaria porque el programa solito vuelve al principio del loop. Justamente por eso se llama loop, porque al terminar de ejecutar la última instrucción salta hasta el inicio y vuelve a ejecutarse y así hasta el fin de los tiempos (o hasta que lo apagues :laughing: )

Saludos

Moderador:
Por favor, lee las Normas del foro y en el futuro no doble postees variaciones del mismo tema. Sigue en el hilo YA abierto hasta agotar todas tus dudas.