Arduino & autres: de l'informatique dans nos motos.

[diabolo38]

Donc c'est logique de placer le goto après la (première) mesure P_n si celle -ci est erronée. Je me coucherai moins con ce soir

on revient de loin la

l'ordre chornolique c'est de droite a gauche et de haut en bas comme on lit
apres avoir relu ton code j'ai vu pas mal de truc bizare
donc dans le doute tu peu essayer cela stp

Code: Tout sélectionner

float alpha=0.6666; // un filtrage pas trop agressif (env 3 point)
// pour plus de rapidité il faut utilisé une arytmetique en virgule fix pas float
void loop(){
     uint32_t p;
     uint32_t rpm;
     //mesure periode du signal sur la pin "3" en se basant sus les front positif "HIGH" periode max 60ms
     per=periodeIn( 3, HIGH, 600000);

     // cas où p_n est inférieure à 6000 rpm (seuil pour le test moto) on fait rien
      if (p> 10000)       {
          Serial.println ("pulse >10000 ");
          goto nopulse;
      }
      rpm=60000000/p;
      //  rmp >12500  c'est une mesure aberante on fait rien
      if( rpm >12500 ){
          Serial.println ("rpm inst > 12500") ;
          goto nopulse;
      }
      // on filtre la valeurs instantané
      RPM=alpha*RPM+(1.0-alpha)*rpm;
      // en virgule fix ca serai qq chose comme 
      // alpha_fix = 512*0.66;
      // RPM=(RPM*alpha_fix+ (512-alpha_fix)*rpm*512)/512
      // RPM_entier=RPM/512
      Serial.println( RPM);

nopulse:
       delay (5);
}


[Spocky35]

Pas probant...

[diabolo38]

Pas probant...

moi je trouve que c'est pas trop mal
ok il reste des oscilalion de 50-100 rpm mais a 9500 rpm mais c'est a peine 1% donc tres honnete
tu peu essayer avec alpha = 0.9 tu vairas encore moins d'oscilation mais ca peu trop lissé des variation rapide

je vois trop de valeurs >12500
tu poyrais ajouté le print exact rpm dans ce cas ?
dans un log precedent je me souvient que tu avais bcp de valeurs 2x exact
ce qui me fait pensé que l'on mesure une 1/2 période certainement a cause d'un rebond du signal aux changement d'etat
si c'est bien le cas => l'igitech fournis de la "tut" !
Par contre il y a a une truc simple qui pourais aidé a corrirgé un peu cela
dans la mesure de la peirode on sauvegarde dans deux variables les temps pour avoir la durée haute et basse
et si il y a un ecart trop grand entre ces deux valeurs on prend le max des deux x 2 sinon on prend la somme
par ex

Code: Tout sélectionner

//au debut fichier
#ifndef ABS
     #define ABS(x) ((x)>0 ? (x) : -(x))
#endif
#ifndef MAX
   #define MAX(a,b)  ((a)>(b) ? (a) : (b))
#endif

//dans periodeIn
// calculé th tb a en focnton des differents  "micros" aux changement d"etat
uint32_t max_t=MAX(th,tb);
if( ABS(th-tb) > max_t/4 )
    return max_t*2;
else
    return th+tb;


[Spocky35]

J'ai trouvé comment sortir un log sous excel!

Voici celui fait à partir du code que j'avais envoyé http://d10.e-loader.net/2a7KKY2TbU.xlsx

Code: Tout sélectionner




////////////////////////////////////// LIBRAIRIES//////////////////////////////////////////////////////////////////////////



  #include <inttypes.h>



    #include <pins_arduino.h>











///////////////////////////////////////  VARIABLES ET CONSTANTES /////////////////////////////////////////////////////////////////////////



unsigned long RPM;   



int val = 0;

int val1 = 0;



//int mesure_n3,mesure_n2, mesure_n1, mesure_n =0; // REPRISE CODE Y2SLDVI



unsigned long p_n2,p_n1,p_n=0;



unsigned long delta;







unsigned long  periodeIn( uint8_t pin, int8_t state, unsigned long  timeout)



    {



    //  these code is inspird from  pulseIn  modifie to mesure over a full period rather than a pulse



            // cache the port and bit of the pin in order to speed up the



            // pulse width measuring loop and achieve finer resolution.  calling



            // digitalRead() instead yields much coarser resolution.



            uint8_t bit = digitalPinToBitMask(pin);



            uint8_t port = digitalPinToPort(pin);



            uint8_t stateMask = (state ? bit : 0);



            unsigned long tStart, tEnd; // keep initialization out of time critical area



            // convert the timeout from microseconds to a number of times through



            // the initial loop; it takes 16 clock cycles per iteration.



            unsigned long numloops = 0;



            unsigned long maxloops = microsecondsToClockCycles(timeout) / 16;



           



            // wait for any previous pulse to end



            while ((*portInputRegister(port) & bit) == stateMask)



                    if (numloops++ == maxloops)



                            return 0;



            numloops=0; //Alow maximum  time out again for input to come active



            // wait for the pulse to start



            while ((*portInputRegister(port) & bit) != stateMask)



                    if (numloops++ == maxloops)



                            return 0;



            // log time when we started



            tStart= micros();



            // wait for the pulse to stop



            while ((*portInputRegister(port) & bit) == stateMask)



                    if (numloops++ == maxloops)



                            return 0;



           



            // wait for the actiev edge to show again



            while ((*portInputRegister(port) & bit) != stateMask)



                    if (numloops++ == maxloops)



                            return 0;



            tEnd= micros();



     



            return tEnd-tStart;



    }



///////////////////////////////////////////   SETUP  ////////////////////////////////////////////////////////////////////////////



    void setup()



    {



      Serial.begin(9600);

int val = 0;

    Serial.println("CLEARDATA"); // clear data in excel



    }



///////////////////////////////////////////   LOOP  /////////////////////////////////////////////////////////////////////////







    void loop(){

 
Serial.print("DATA,TIME,"); // send comand to excel

          uint32_t p;
         uint32_t rpm;
         //mesure periode du signal sur la pin "3" en se basant sus les front positif "HIGH" periode max 60ms
         per=periodeIn( 3, HIGH, 600000);

         // cas où p_n est inférieure à 6000 rpm (seuil pour le test moto) on fait rien
          if (p> 10000)       {
              Serial.println ("pulse >10000 ");
              goto nopulse;
          }
          rpm=60000000/p;
          //  rmp >12500  c'est une mesure aberante on fait rien
          //if( rpm >12500 ){
          //    Serial.println ("rpm inst > 12500") ;
           //   goto nopulse;
         // }
          // on filtre la valeurs instantané
          RPM=alpha*RPM+(1.0-alpha)*rpm;
          // en virgule fix ca serai qq chose comme
          // alpha_fix = 512*0.66;
          // RPM=(RPM*alpha_fix+ (512-alpha_fix)*rpm*512)/512
          // RPM_entier=RPM/512
          //Serial.println( RPM);

    nopulse:
           delay (5);
    }
 
val1=RPM
 
Serial.println(val1); // send data

//val1 = random(0, 100); // random bet 0 and 100

//Serial.println(  RPM);

  nopulse:

  delay (20);











}





Celui avec l'essai que tu as demandé hier http://d24.e-loader.net/YJauYMerio.xlsx

Code: Tout sélectionner




////////////////////////////////////// LIBRAIRIES//////////////////////////////////////////////////////////////////////////



  #include <inttypes.h>



    #include <pins_arduino.h>











///////////////////////////////////////  VARIABLES ET CONSTANTES /////////////////////////////////////////////////////////////////////////



unsigned long RPM;   



int val = 0;

int val1 = 0;



//int mesure_n3,mesure_n2, mesure_n1, mesure_n =0; // REPRISE CODE Y2SLDVI

float alpha=0.6666; // un filtrage pas trop agressif (env 3 point)
    // pour plus de rapidité il faut utilisé une arytmetique en virgule fix pas float


unsigned long p_n2,p_n1,p_n=0;



unsigned long delta;







unsigned long  periodeIn( uint8_t pin, int8_t state, unsigned long  timeout)



    {



    //  these code is inspird from  pulseIn  modifie to mesure over a full period rather than a pulse



            // cache the port and bit of the pin in order to speed up the



            // pulse width measuring loop and achieve finer resolution.  calling



            // digitalRead() instead yields much coarser resolution.



            uint8_t bit = digitalPinToBitMask(pin);



            uint8_t port = digitalPinToPort(pin);



            uint8_t stateMask = (state ? bit : 0);



            unsigned long tStart, tEnd; // keep initialization out of time critical area



            // convert the timeout from microseconds to a number of times through



            // the initial loop; it takes 16 clock cycles per iteration.



            unsigned long numloops = 0;



            unsigned long maxloops = microsecondsToClockCycles(timeout) / 16;



           



            // wait for any previous pulse to end



            while ((*portInputRegister(port) & bit) == stateMask)



                    if (numloops++ == maxloops)



                            return 0;



            numloops=0; //Alow maximum  time out again for input to come active



            // wait for the pulse to start



            while ((*portInputRegister(port) & bit) != stateMask)



                    if (numloops++ == maxloops)



                            return 0;



            // log time when we started



            tStart= micros();



            // wait for the pulse to stop



            while ((*portInputRegister(port) & bit) == stateMask)



                    if (numloops++ == maxloops)



                            return 0;



           



            // wait for the actiev edge to show again



            while ((*portInputRegister(port) & bit) != stateMask)



                    if (numloops++ == maxloops)



                            return 0;



            tEnd= micros();



     



            return tEnd-tStart;



    }



///////////////////////////////////////////   SETUP  ////////////////////////////////////////////////////////////////////////////



    void setup()



    {


      Serial.begin(9600);

int val = 0;

    Serial.println("CLEARDATA"); // clear data in excel



    }



///////////////////////////////////////////   LOOP  /////////////////////////////////////////////////////////////////////////







    void loop(){

 
Serial.print("DATA,TIME,"); // send comand to excel

          uint32_t p;
         uint32_t rpm;
         //mesure periode du signal sur la pin "3" en se basant sus les front positif "HIGH" periode max 60ms
         p=periodeIn( 3, HIGH, 600000);

         // cas où p_n est inférieure à 6000 rpm (seuil pour le test moto) on fait rien
          if (p> 10000)       {
              Serial.println ("pulse >10000 ");
              goto nopulse;
          }
          rpm=60000000/p;
          //  rmp >12500  c'est une mesure aberante on fait rien
          //if( rpm >12500 ){
          //    Serial.println ("rpm inst > 12500") ;
           //   goto nopulse;
         // }
          // on filtre la valeurs instantané
          RPM=alpha*RPM+(1.0-alpha)*rpm;
          // en virgule fix ca serai qq chose comme
          // alpha_fix = 512*0.66;
          // RPM=(RPM*alpha_fix+ (512-alpha_fix)*rpm*512)/512
          // RPM_entier=RPM/512
          //Serial.println( RPM);


 
val1=RPM;
 
Serial.println(val1); // send data

//val1 = random(0, 100); // random bet 0 and 100

//Serial.println(  RPM);

  nopulse:

  delay (20);











}

et le fichier d'acquisition utilisé http://d11.e-loader.net/BW5EujsqKD.wav

[diabolo38]

les lien ameine ou source code pas au ficheir xls ?
au passage tu peu garder les fichier au format csv ? (je n'ai pas excel mais ooo)

Ci dessous le code pour mesure de periode avec la detection evoqué precedement fonction periodeIn2

Code: Tout sélectionner

#ifndef MAX
  #define MAX(a,b) ( (a)>(b) ? (a) : (b))
#endif
#ifndef ABS
  #define ABS(a) ( (a)<0 ? (-a) : (a))
#endif

unsigned long  periodeIn2( uint8_t pin, int8_t state, unsigned long  timeout)
{
//  these code is inspird from  pulseIn  modifie to mesure over a full period rather than a pulse
        uint8_t bit = digitalPinToBitMask(pin);
        uint8_t port = digitalPinToPort(pin);
        uint8_t stateMask = (state ? bit : 0);
        unsigned long tStart, tMed, tEnd; // keep initialization out of time critical area
        // convert the timeout from microseconds to a number of times through
        // the initial loop; it takes 16 clock cycles per iteration.
        unsigned long numloops = 0;
        unsigned long maxloops = microsecondsToClockCycles(timeout) / 16;
       
        // wait for any previous pulse to end
        while ((*portInputRegister(port) & bit) == stateMask)
                if (numloops++ == maxloops)
                        return 0;
        numloops=0; //Alow maximum  time out again for input to come active
        // wait for the pulse to start
        while ((*portInputRegister(port) & bit) != stateMask)
                if (numloops++ == maxloops)
                        return 0;
        // log time when we started
        tStart= micros();
        // wait for the pulse to stop
        while ((*portInputRegister(port) & bit) == stateMask)
                if (numloops++ == maxloops)
                        return 0;
        // log the transition time
        //
        tMed= micros();
        // wait for the active edge to show again 
        while ((*portInputRegister(port) & bit) != stateMask)
                if (numloops++ == maxloops)
                        return 0;
        tEnd= micros();
        int t1 = tMed - tStart;
        int t2 = tEnd - tMed;
        int tmax = MAX(t1,t2);
        int dt = ABS(t2-t1);
        if( dt >= tmax/4 ){
          return tmax*2;
        }
        else
          return tEnd-tStart;
}


[Spocky35]

Mince, je ne comprend pas comment il se fait que ces fichiers ne sont pas des feuilles de calcul!

Bon j'ai sans doute fait trop vite avant de partir au taf

Je refait ça mieux ce soir.

[Spocky35]

Si, j'ai compris
Voici les logs
Code Diabolo (du 14/01/13) http://d8.e-loader.net/4p6iJRt6Fq.csv
Code Spocky (du 13/01/13) http://d12.e-loader.net/ibM0LpSmZl.csv

[Spocky35]

je vois trop de valeurs >12500

Oui, c'était sur ce point que je trouvais le résultat "pas probant".

[diabolo38]

c'est quoi toute ces valeurs negative ? c'est juste meme pas possible normalement
dans ton code on voit jamios uen celu <0 juste quela cas filtré < 6000
c'est un gros souci a resoudre car jamais on devrais avoir de mesure de periode negative !
le rebouclage de micros() sur 32 bit peu donné une valeurs <0 toute les 30 min mais pas a ce rythme

pour etre safe if faudrait ajouté le test periode =0 ou trop petite (erreur rebond etc..)
je modifie et te post ca plus tard

Code: Tout sélectionner



////////////////////////////////////// LIBRAIRIES//////////////////////////////////////////////////////////////////////////
#include <inttypes.h>
#include <pins_arduino.h>




///////////////////////////////////////  VARIABLES ET CONSTANTES /////////////////////////////////////////////////////////////////////////

unsigned long RPM=0;
int val = 0;
int val1 = 0;

//int mesure_n3,mesure_n2, mesure_n1, mesure_n =0; // REPRISE CODE Y2SLDVI
float alpha=0.6666; // un filtrage pas trop agressif (env 3 point)
    // pour plus de rapidité il faut utilisé une arytmetique en virgule fix pas float

unsigned long p_n2,p_n1,p_n=0;
unsigned long delta;


unsigned long  periodeIn( uint8_t pin, int8_t state, unsigned long  timeout)
   {
    //  these code is inspird from  pulseIn  modifie to mesure over a full period rather than a pulse
            // cache the port and bit of the pin in order to speed up the
            // pulse width measuring loop and achieve finer resolution.  calling
            // digitalRead() instead yields much coarser resolution.
            uint8_t bit = digitalPinToBitMask(pin);
            uint8_t port = digitalPinToPort(pin);
            uint8_t stateMask = (state ? bit : 0);

            unsigned long tStart, tEnd; // keep initialization out of time critical area
            // convert the timeout from microseconds to a number of times through
            // the initial loop; it takes 16 clock cycles per iteration.

            unsigned long numloops = 0;
            unsigned long maxloops = microsecondsToClockCycles(timeout) / 16;

            // wait for any previous pulse to end
            while ((*portInputRegister(port) & bit) == stateMask)
                    if (numloops++ == maxloops)
                            return 0;
            numloops=0; //Alow maximum  time out again for input to come active
            // wait for the pulse to start
            while ((*portInputRegister(port) & bit) != stateMask)
                    if (numloops++ == maxloops)
                            return 0;
            // log time when we started
            tStart= micros();

            // wait for the pulse to stop
            while ((*portInputRegister(port) & bit) == stateMask)
                    if (numloops++ == maxloops)
                            return 0;

            // wait for the actiev edge to show again
            while ((*portInputRegister(port) & bit) != stateMask)
                    if (numloops++ == maxloops)
                            return 0;
            tEnd= micros();
            return tEnd-tStart;
}



///////////////////////////////////////////   SETUP  ////////////////////////////////////////////////////////////////////////////

    void setup()
    {
      Serial.begin(9600);

int val = 0;

    Serial.println("CLEARDATA"); // clear data in excel



    }


///////////////////////////////////////////   LOOP  /////////////////////////////////////////////////////////////////////////
void loop(){
    uint32_t p;
    uint32_t rpm;


    Serial.print("DATA,TIME,"); // send comand to excel

    //mesure periode du signal sur la pin "3" en se basant sus les front positif "HIGH" periode max 60ms
     p=periodeIn( 3, HIGH, 600000);

     // cas où p > 12 est inférieure à 6000 rpm (seuil pour le test moto) on fait rien
     if (p> 100000) {
          Serial.println ("pulse >10000 "); // env 6000 rpm
          goto nopulse;
      }
      if (p< 4800 ){
          Serial.println ("pulse <4800 ");  // 4.8ms = 12500 rpm
          goto nopulse;
      }

      rpm=60000000/p;
      //  rmp >12500  c'est une mesure aberante on fait rien
      //if( rpm >12500 ){
      //    Serial.println ("rpm inst > 12500") ;
       //   goto nopulse;
     // }
      // on filtre la valeurs instantané
      RPM=alpha*RPM+(1.0-alpha)*rpm;
      // en virgule fix ca serai qq chose comme
      // alpha_fix = 512*0.66;
      // RPM=(RPM*alpha_fix+ (512-alpha_fix)*rpm*512)/512
      // RPM_entier=RPM/512
      //Serial.println( RPM);

      val1=RPM;

      Serial.println(val1); // send data

nopulse:
     delay (20);
}


[Rony]

C'est pas sur une moto, mais j'ai eu l'occasion ces 3 derniers mois de bosser aussi avec un Arduino (Mega 2560) qui commande une imprimante 3D entièrement faite maison.
Une vieux Shuttle PC sert de boitier, j'ai rajouter des LEDs en façade, et quelques autres petites fonctions.
J'ai fini le projet aujourd'hui, voilà un peu ce que ça donne.


C'est fou le nombre d'utilité de ce petit circuit imprimé.

[diabolo38]

C'est pas sur une moto, mais j'ai eu l'occasion ces 3 derniers mois de bosser aussi avec un Arduino (Mega 2560) qui commande une imprimante 3D entièrement faite maison.
Une vieux Shuttle PC sert de boitier, j'ai rajouter des LEDs en façade, et quelques autres petites fonctions.
J'ai fini le projet aujourd'hui, voilà un peu ce que ça donne.


C'est fou le nombre d'utilité de ce petit circuit imprimé.

dans le shuttle il est pas a l"etroit ou moins le le mega ^^
sympas l'impimante 3D tou en pfoile alu ca jette je supposoe c'est des vis sans fin et moteur pas a pas

[splurk]

Y aurait des ingénieurs en systèmes embarqués par ici?

[Rony]

dans le shuttle il est pas a l"etroit ou moins le le mega ^^
sympas l'impimante 3D tou en pfoile alu ca jette je supposoe c'est des vis sans fin et moteur pas a pas

Oui au moins pas de souci pour la place en effet. Mais on avait ça à disposition ça évitait de recommander un boitier, et c'est joli.

Oui c'est des vis sans fin à rattrapage de jeu, et moteur pas à pas de 200 pas (et multiplicateur x16 par les amplis d'axes).

[Spocky35]

Diabolo, j'ai fait l'essai du dernier code que tu as envoyé, avec le même fichier de capture audio que les fois précédentes. Test réalisé trois fois.
En voici les résultats http://d5.e-loader.net/G5L3rqwx6N.csv

(c'est cool quand tu écris tout le code )

Je te laisse apprécier le résultat, c'est toi le compétent . A regarder l'enfilade de rpm obtenus, j'ai tendance à penser que c'est pas mal, de mieux en mieux ,même si il subsiste des "bad pulses".

[diabolo38]

Y aurait des ingénieurs en systèmes embarqués par ici?

euh moi mais j'ai un perdu la main sur le micros 8 bits

Les bad pulse je crois pas trop a un pb sur le code de mesure de la periode ou autre
mais je penche plus vair un vrais pb sur la qualité du signal d'entré (saleté d'ignitech )
pour le voir faut faire le ien entre wav et log serie donc pas evidant
qq details sur les valeurs <0

si on a des "glitch" (tres breve changement d'etat) on peu essayer des les détecté en soft et les ignorer
cela demande qq changement dans la detect de periode
edit : cf ci dessous on peu ajusté un peu la largeur des glitch par le
#define min_glitch_width 4
c'est tres basic et n'elimnera que le glitch sur les transitions
par la meme j'ai aussi mis en place la detection d'assymetrie des partie haute/basse qui devrais aussi eliminé qulues cas (ceuxcou on voyais periodeles/2 ie rpm*2)

Code: Tout sélectionner


///////////////////////////  MACROS AND HELPER /////////////////////

#ifndef MAX
  #define MAX(a,b) ( (a)>(b) ? (a) : (b))
#endif
#ifndef ABS
  #define ABS(a) ( (a)<0 ? (-a) : (a))
#endif