Durchflussmesser mit Display und Reset-Taste - wie mit Arduino realisieren

#include <Wire.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4 // not used / nicht genutzt bei diesem Display
Adafruit_SSD1306 display(OLED_RESET);

int const signal_pin = 2; // D2
int const signal_pin_interrupt_number = 0; // INT0, 

void setup()   {                

    // initialize with the I2C addr 0x3C / mit I2C-Adresse 0x3c initialisieren
    display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
    
#define DRAW_DELAY 118
#define D_NUM 47
 pinMode(signal_pin, INPUT_PULLUP);
 long counter;
 float verbrauch = counter / 10.5;
// attach an interrupt handler when the signal goes from low to high
 attachInterrupt(signal_pin_interrupt_number, counter, RISING);

}
static int events = 0;
void counter() {
  ++events;
}
void loop() {
  display.clearDisplay();
  
  // set text color / Textfarbe setzen
  display.setTextColor(WHITE);
  // set text size / Textgroesse setzen
  display.setTextSize(1);
  // set text cursor position / Textstartposition einstellen
  display.setCursor(1,0);
  // show text / Text anzeigen
  display.println("Benzinverbrauch:");
  display.setTextSize(3);
  display.setCursor(24,10);
  display.println(verbrauch);
  display.display();
  delay (1000);
    
}

// der IRQ-PIN 2/3 auf dem der Sensor geschaltet ist
#define PIN_FUEL	2

#define FLOW_AVG_CNT   8
#define FLOW_AVG_MSK   0x07
#define FLOW_AVG_SH    3  		              // n/8, # shift right für Divison
volatile uint32_t MesureAvg[FLOW_AVG_CNT];  // die jeweils letzten n Messungen in uS




static uint32_t FlowCntTank;                // # Impulse gesamt entnommen

void setup()
{
  // da der Sensor fallende Flanken liefert den PIN intern mit einem PULL-UP versehen
  pinMode( PIN_FUEL, INPUT_PULLUP );
  // dann die Interrupt-Service Routine für diesen PIN definieren, IRQ Auslöser ist fallende Flanke
  attachInterrupt( digitalPinToInterrupt(PIN_FUEL), FlowIRQ, FALLING );
}


// ============================
// capture Durchfluss interrupt
// ============================
void FlowIRQ( void )    // >> ISR( PCINT1_vect ) PIN change IRQ
{
 static uint8_t  CaptureIdx;
 static uint32_t LastMicros;
 register uint32_t uS = micros();

  // Pulse/Min und entspr. Abstände
  //   1mL = 10,5 Pulse = 5714,29mS
  //  50mL =  525 Pulse =  114,29mS
  // 800mL = 8400 Pulse =    7143uS
  // für Flowanzeige je n Messungen zur Durchschnittsberechnung sichern
  if( LastMicros )                                // aus irgendeinem Grund löst der IRQ nach Init 1x aus, 1. IRQ verwerfen
    MesureAvg[CaptureIdx++] = uS - LastMicros;
  CaptureIdx &= FLOW_AVG_MSK;
  LastMicros = uS;

  FlowCntTank++;                               // Summe der Pulse, entnommenes Volumen
}





#define	TIM_BASE 10									// Timeraufruf alle 10mS
static uint8_t TmoVolumeRefresh;
  #define TMO_VOL_REFRESH  (1000/TIM_BASE)  // jede Sek. das Restvolumen berechnen
static uint8_t  TmoFlowCalc;
  #define TMO_FLOW_CALC     (500/TIM_BASE)  // alle 500mS die akt. Durchflussmenge berechnen
static uint8_t TmoFlowOff;
  #define TMO_FLOW_OFF  TMO_FLOW_CALC + (100/TIM_BASE)  // mS ohne Flow Impuls


static float Flow;                            // akt. Flow in mL
static uint16_t VolumeConsumed;               // akt. entnommene Menge in mL

static uint32_t FlowCntLast = -1;


// dann noch eine Routine die alle 10mS aufgerufen wird
// davon abgeleitet dann alle 500mS eine Flowberechnung und jede Sek. eine Restvolumen
// ==========
// 10mS Timer
// ==========
void Tim10mS()
{
  // ------------------------------------
  // Durchflussmenge berechnen, alle n mS
  // ------------------------------------
  if( TmoFlowCalc )
    TmoFlowCalc--;
  else if( FlowCntTank != FlowCntLast )       // liegt neue Messung vor ? oder Init ?
    {
    uint32_t Avg = 0L;
    uint8_t Idx;

    Idx = FLOW_AVG_CNT;
    while( Idx-- )
      Avg += MesureAvg[Idx];                    // Summe der Messungen in uS
    Avg >>= FLOW_AVG_SH;                        // Sum/n, Mittelwert Impulsabstand in uS

    // Impuls Anzahl auf 1 Min hochrechnen, akt. Flow
    float FCntMin;
    if( Avg )                                   // Division durch 0 vermeiden ;)
      {
      FCntMin = (60L*1000L*1000L) / Avg;
      // # uL/Pulse auf ml/Min umrechnen
      Flow = (FCntMin * uL_OnePulse) / 1000.0;  // uL > mL
      }

    // akt. entnommene Menge
    VolumeConsumed = ((float)FlowCntTank * uL_OnePulse) / 1000.0;

    FlowCntLast = NV_FlowCntTot;
    TmoFlowCalc = TMO_FLOW_CALC;            // nur alle n mS bewerten und das nur bei Änderungen
    TmoFlowOff  = TMO_FLOW_OFF;             // Zeit ohne Impulse bis Durchfluss Stopp erkannt
    }


  // ----------------------------
  // Motor steht, kein Durchfluss
  // ----------------------------
  if( TmoFlowOff && (--TmoFlowOff == 0) )   // entnommene Menge sichern nur wenn wir ausreiched Flow hatten
    {
    Flow = 0;                          // Flow Anzeige = 0mL/Min
    //memset( MesureAvg, 0, sizeof(MesureAvg) );  // Durchnitt neu berechnen
    }
}