Acquisizione dati Moto

salve a tutti!!!
ho in mente da un po di tempo un progetto a parer mio molto ambizioso:

Ho una moto Honda CRF motard 450 del 2010 e sono riuscito a reperire un software HONDA che mi permette di modificare alcuni parametri nella centralina originale. Ho seguito una guida online su come creare un 'interfaccia adeguata a far comunicare la centralina con il pc e di conseguenza con il software honda.

Il software mette a disposizione una tabella con RPM in orizontale e TPS (apertura del comando dell’acceleratore) in verticale; da qui è possibile ingrassare o smagrire la carburazione/aumentare o diminuire l anticipo in determinate circostanze le quali essendo molto specifiche è impossibile capire “ad orecchio”.

ho pensato di acquisire i dati (RPM/TPS) dalla moto e metterli in relazione ad una sonda lambda (di cui la moto è sprovvista) per riuscire a capire con esattezza dove modificare la carburazione della moto. ( la regolazione dell’ anticipo sarebbe eventualmente lo step successivo).

il sensore del comando dell’acceleratore è un potenziometro alimentato dalla centralina a 5V quindi “nessun” problema per riuscire a leggerlo;
per i giri motore ho pensato di leggerli dalla bobina di accensione: un pin parte dalla centralina fino alla bobina con un segnale sempre alto, quando questo passa a basso avviene la scintilla. La moto può arrivare fino a 12.000 giri al minuto. ho provato a scrivere alcuni programmi per leggere i giri motore in questo modo e quello che potrebbe funzionare ed essere il piu preciso è questo (perdonatemi se ho scritto qualcosa di assurdo ma non è che sono alle prime armi ma molto meno!) :

float valori [4] = {0.0,0.0,0.0,0.0};
unsigned long Tt = 0 ;
unsigned int const TL = 100;



volatile int impulsi = 0;
float  somma_impulsi = 0.0;
 float  media_impulsi;
float RPM = 0;

int pot;
int TPS;


void setup() {
  
 Serial.begin(9600);
 attachInterrupt(digitalPinToInterrupt (2),contatore,FALLING);
 delay(1000);
}

void contatore(){
  impulsi ++; 
  }


void loop() {
           pot= analogRead(A1);         
          Tt=millis();         
                    

while (( millis()-Tt)<TL){
  //Serial.println("CONTO_IMPULSI_WHILE_1");
  }

                   // Serial.println("FINE WHILE_1");
                    valori[0] = impulsi;
                   // Serial.println(valori[0]);
                    impulsi=0;
                    
                    
         Tt=millis();
      //  Serial.println(Tt);
                   

                    
                    
while (( millis()-Tt)<TL){
  //Serial.println("CONTO_IMPULSI_WHILE_2");
  }
                    
                   // Serial.println("FINE WHILE_2");
                     valori[1] = impulsi;
                  //  Serial.println(valori[1]);
                    impulsi=0;
        Tt=millis();
    //   Serial.println(Tt);
                    
                   
                    
while (( millis()-Tt)<TL){
  //Serial.println("CONTO_IMPULSI_WHILE_3");
  }

                 //   Serial.println("FINE WHILE_3");
                    valori[2] = impulsi;
                  //  Serial.println(valori[2]);
                    impulsi=0;
       Tt=millis();
    //  Serial.println(Tt);
                    


                    
while (( millis()-Tt)<TL){
  //Serial.println("CONTO_IMPULSI_WHILE_4");
  }

                //    Serial.println("FINE WHILE_4");
                    valori[3] = impulsi;
                 //   Serial.println(valori[3]);
                    impulsi=0;
       Tt=millis();
   //    Serial.println(Tt);
                    
                    

       somma_impulsi = somma_impulsi + valori[0] + valori[1] + valori[2] + valori[3];
       media_impulsi = somma_impulsi/4; 
      // Serial.println(media_impulsi);
                  RPM =  (media_impulsi*1000/TL*60);
                 
                  TPS= map(pot,0,1023,0,100);                //lettura TPS



 
//Serial.print("RPM = ");
                 Serial.print(RPM);Serial.print("  ");
                  Serial.print(TPS);Serial.print("  ");
                  Serial.println();


 //Serial.println("%");

                 
valori[0] = 0.0; 
valori[1] = 0.0;
valori[2] = 0.0;
valori[3] = 0.0;
somma_impulsi=0;
media_impulsi=0.0;
RPM=0;

arduino entro in ciclo while per 100ms e conta gli impulsi con un interrupt (FALLING) salvandoli in un array poi esce ed entra in un altro per altri 100ms per 4 volte alla fine delle quali fa una media dei valori e la trasforma in giri al minuto e mi stampa la posizione del potenziometro.
non ho ancora provato sulla moto ma penso funzioni.
Il problema è che così posso avere un valore ogni 400ms e non facendo la media avrei +/- 100 RPM di errore
(vorrei utilizzare questo Sketch per un contagiri a display ma in un secondo momento)

ho pensato che per avere la massima precisione dovrei contare il tempo tra gli impulsi con pulseIn…
anche se non sono ancora riuscito ad usarlo bene volevo sapere se si poteva combinare con un interrupt per essere piu responsivo possibile o se si potesse combinare millis ad un interrupt in qualche modo. anche se pulseIn è bloccante il sistema che ho pensato con i while lo è altrettanto e non mi fornisce un valore esatto.

che ne dite? consigli? dritte? ogni parere è bene accetto!!
grazie Diego!

Visto che hai scritto ogni parer è accetto, mi permetto qualche considerazione sulla mappatura più che sul codice.
Immagino, anzi mi auguro, che tu sappia cosa stia facendo perchè la mappatura non è solo questione di ingrassare/smagrire la carburazione (attento a smagrire che squagli i pistoni come niente). La mappa, intesa come un piano cartesiano con due assi sul quale sono riportatii vari valori, ha solo poche zone su cui è opportuno metter mano non tanto per lo scopo che tu hai riportato, quanto per modificare entro certi paramettri l'erogazione della potenza e/o della coppia. Per quanto ho sperimentato io nel tuning, molto meglio è scaricare la mappa originale, visualizzarla e vedere dove e come ottimizzare con gli appositi software. La mappa modificabile è solo una parte del software "sparato" nella centralina e se questa è protetta (come normalmente è) appena cambi un valore cambia il checksum e la moto non parte più....spero di averti dato un idea approssimativa.
Per la lettura degli RPM ho visto qualche codice in giro in quanto volevo realizzarlo ma poi non l'ho più fatto avendo percrso altre strade.

PS: acceleratore e NON accelleratore.

Ti ringrazio per aver risposto ma devo fare alcune precisazioni:

So benissimo che la mappatura di una centralina non è ingrassare la carburazione o aumentare L anticipo ma questo software ufficiale Honda da la possibilità di modificare questi due parametri tra L altro entro dei range impostati nel software che ti impediscono di esagerare o creare danni al motore.
Ho già modificato la “mappa” con un’altra ufficiale Honda e naturalmente la moto è partita tranquillamente… proprio perché le centraline sono protette non vi si può entrare così facilmente almeno che il costruttore , come in questo caso, non abbia predisposto un software per farlo in sicurezza…
più che smagrire vorrei proprio ingrassare: la moto è già magra di suo per ridurre le emissioni essendo omologata all’uso su strada in più lo scarico aftermarket che monto mi darebbe la possibilità di ingrassare ulteriormente per sfruttarlo a pieno.
ti ringrazio comunque per aver speso del tempo per scrivere ma penso sei fuori strada…