pulseIn() no me deja acumular los pulsos contados

Hola, estoy intentando montar un lector de pulsos de inyección para mi moto, la parte electrónica ya la he preguntado en otro hilo de hadware (muchísimas gracias de verdad).

Me encuentro con el problema de que al usar pulseIn() para leer estos datos, los pulsos los lee bien con respecto al tiempo que es lo que necesitaba, ya que antes lo leia con interrupciones y no soy capaz de decirle a arduino que cuente las interrupciones cada segundo acumuladas y me las muestre en pantalla.

al usar pulseIn() añado una variable que se llama Litrosporhora a la que le añado += para que resulte: Litrosporhora = Litrosporhora + anchodepulso;

hasta aquí bien, el problema viene cuando quiero imprimir Litrosporhora. el valor no sube constantemente si no que fluctua hasta 9 o 10 y luego vuelve a bajar a un número inferior.

PD: he resumido el código ya que contiene un menú con botones y demás. está probado con interrupciones y el mismo código funciona. No sé si será porque según he visto el arduino se queda colgado mientras lee, ya que los botones no funcionan con normalidad (tardan en reaccionar) y con interrupciones sí.

#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

int adc_key_val[5] = {50, 200, 400, 600, 800 };
int NUM_KEYS = 5;
int lcd_key = 0;
int adc_key_in = 0;
int key = -1;
int oldkey = -1;
int x=0;

const int numerodemenus = 5;
char titulomenu [numerodemenus][16]={"Ajuste L/H: ", "Ajuste RPM: "};

int litros= 1;
int RPM = 1200;
int derecha = 0;
int menu = 1;
const int menusmaximos = 2;
boolean enmenu = false;
boolean menu2 = false;
int sumar = 1;
int restar = -1;
int delayboton = 50;
unsigned long tiempoactual = 0;
unsigned long espera = 0;
byte ajusteconsumo = 1;
byte ajusterpm= 1;
char division = 1;
unsigned long ms = 500000;
float total = 0;

const int pin0 = 2;
const int pin1 = 3;
volatile bool pulso = 0;
volatile bool pulso1 = 0;
volatile unsigned long tiempo = 0;
volatile unsigned long tiempo1 = 0;
unsigned long tiempo_anterior = 0;
unsigned long tiempo_anterior1 = 0;
bool subida = 0;
bool subida1 = 0;
float Litrosporhora;
float Litrosporhora1;
float Litrosporhora2;

float TIEMPO = 500;
unsigned long tiempo_0 = 0;
unsigned long tiempo_1 = 0;
float anchodepulso = 0;

void setup() {
  cargarConfig();
    lcd.begin(16,2);
    Serial.begin(250000);
    updateMenu();
    espera = millis();
    pinMode(pin0, INPUT);
    attachInterrupt(digitalPinToInterrupt(pin0), leer, CHANGE);
    attachInterrupt(digitalPinToInterrupt(pin1), leer1, CHANGE);

}
void loop() {

  updateMenu();
  botones();

      anchodepulso = pulseIn(2, HIGH, ms)/1000;
      Litrosporhora += anchodepulso;

}
void imprimir_datos(){
  if ((millis() > TIEMPO + tiempo_0)&&(!enmenu)) {
          tiempo_0 = millis();
          //Litrosporhora1 += Litrosporhora;
          //Litrosporhora2
          lcd.setCursor(7,0);
          lcd.print (anchodepulso/100);
          lcd.setCursor(7, 1);
          lcd.print(Litrosporhora, 1);
          //Litrosporhora1=0;
          }

video

VID-20200502-WA0068.gif|0x0

Las operaciones con float no son confiables. Mejor opera todo en unsigned long y al final antes de mostrar divides este 1000 y 100.

gracias Kike_GL por responder, me ocurre que no me da el mismo valor con pulseIn() que con interrupciones.

anchodepulso = pulseIn(2, HIGH, ms);
        Litrosporhora += anchodepulso;
        Litrosporhora1 += Litrosporhora;
        Litrosporhora2 += Litrosporhora1;
        if(anchodepulso!=0){Serial.println (Litrosporhora);}
 

 /*  if (pulso == 1){

     if (subida ==1){
        Serial.println(tiempo - tiempo_anterior);
        Litrosporhora = tiempo - tiempo_anterior;
        Litrosporhora1 += Litrosporhora/100;
        Litrosporhora2 += Litrosporhora1;
        }
   
      tiempo_anterior = tiempo;
      subida = !subida;
      pulso = 0;

así los leo y me da pulseIn() un valor de 10 y interrupciones 2.5

La verdad que esperar que se te responda a algo que no esta completamente presentado es difícil.
Si no se ve todo el código no se comprende bien el problema.
Si tu pudieras corregirlo no pedirías ayuda, y para brindarla es necesario dominar todo el panorama.

Por favor si tu código es mayor a 9k subelo como adjunto, pero debe estar completo.

Ahora basicamente si tienes dos interrupciones una que cambie con RISING y otra con FALLING puedes facilmente medir el tiempo de un pulso.
También existe un pin dedicado en el arduino que es el pin 7 que hace INPUT CAPTURE o sea sirve para leer pulsos y medir con precisión su ancho usando los timers.

Cuando uses RISING o sea el flanco de subida o sea cuando va de 0 a 1 la señal activas un flag o sea una variable booleana.
Cuando se active FALLING tomas el tiempo que le llevó a la señal cambiar de 1 a 0 y por ejemplo podrás medir el ancho de un pulso que va de 0 a 1.... x useg y luego de 1 a 0.

En la segunda interrupción cambias el flag de nuevo y con ello presentas en el loop el resultado.