Répondre à la discussion
Page 1 sur 2 1 DernièreDernière
Affichage des résultats 1 à 30 sur 51

Compteur moto Problème interruptions arduino pour compteur KM/H et RPM



  1. #1
    2 terium

    Compteur moto Problème interruptions arduino pour compteur KM/H et RPM


    ------

    Bonjour à tous.

    Ayant un souci avec le programme ci dessous que je n'arrive pas à comprendre, je compte sur vos connaissances pour m'apporter un peu de lumière.

    Pour faire simple, je fais un compteur dans le but d’acquérir les RPM KM/H et TEMP° en me servant des deux entrées en interruptions D2 et D3

    Pour D2 j'ai une queue de cochon qui viens sur la base d'un BC547.
    Pour D3 j'ai un capteur IR MC005 qui compte les trous dans mon disque de frein.
    et je pilote une thermistance pour lire et moyennée la température moteur

    Sauf que ma fonction pour les KM/H (D3 donc interruption N°1) n'arrive à m'afficher que jusqu’à 25KM/H.

    Chaque bout de code a était tester a part avec le moniteur série et donne des résultats très correct! (avec deux diode IR en faisceau et une roue a trou lego technique).

    concernant la partie RPM j'ai bien quelque doute mais les résultats réel ne sont pas complètement aberrant pour un moteur 2T; 1600 à 2000 au ralenti et dans les 14000tr/min a balle.

    Pour les KM/H par contre..rester a 25 en pleine accélération.. j'ai un gros gros doute même avec une histoire de priorité dans les interruptions puisque même si je débranche le capteur D2, j'ai pareil..

    En bref! Je sèche complètement.

    Merci d'avance pour vos remarques/informations/conseils!!!



    Code:
    //PARTIE CAPTEURS NUMERIQUES
    
    int capteurRPM = 2; // capteur signal allumage sur PIN D2
    int capteurIR = 3; //capteur IR sur PIN D3 (IR TEST = PEUT ETRE N'IMPORTE QUEL CAPTEUR)
    //int led=13;
    unsigned int trous;
    unsigned int ignitions;
    int nbTourRoue;
    float tourRoue;
    //float km_H;
    //float RPM;
    unsigned long lastMillisKm_h;
    unsigned long tempsRevolutionKm_h;
    unsigned long lastMillisRpm;
    unsigned long tempsRevolutionRpm;
    
    //////*lecture de temperature en 3.3V Aref sur NTC 100K + R100K */////////
    
    unsigned long interval=200;
    unsigned long time;
    int ptr=0;  
    #define NUMSAMPLES 10 //nombre de lecture
    int samples[NUMSAMPLES];
    int ThermistorPin = A0; //pin analogique pour sonde NTC100K
    //(int) ActivationSonde = 12; // pin digital D12
    //float R1 = 10000;
    //float logR2, R2, T;
    //float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
    
    ///////////////////////////////////////////
    
    void setup()
    
    ////PARTIE SETUP CAPTEUR KMH / RPM //////////
    {
      trous=0;
      ignitions=0;
      nbTourRoue=0;
      tourRoue=1.415; //((2*3.14)*((13*25.4)/2)+60)=((2*3.14)*225.1)=1413.628cm=1.415m
      lastMillisKm_h=0;
      tempsRevolutionKm_h=0;
      lastMillisRpm=0;
      tempsRevolutionRpm=0;
      pinMode(capteurIR,INPUT);
      pinMode(capteurRPM,INPUT);
      attachInterrupt(0,nbIgnitions,RISING);
      attachInterrupt(1,nbTrous,FALLING);
      //pinMode(led,OUTPUT);
    
    //////PARTIE SETUP TEMPERATURE//////////////////  
     
      Serial.begin(9600);
      analogReference(EXTERNAL);
      pinMode(0,INPUT);
      pinMode(12,OUTPUT);
      digitalWrite(12,LOW);  
      
    //////FIN SETUP CAPTEURS///////  
      
      Serial.begin(9600);
      Serial.println("****DEBUT_PROGRAMME****");
      Serial.println("");
    }
    
    void loop()
    { 
      capteurRPM=digitalRead(2);
      capteurIR=digitalRead(3);
      
      ////////PARTIE KM/H ///////////////
      
     
      if(trous>=7){
        //detachInterrupt(1);
        tempsRevolutionKm_h= millis()-lastMillisKm_h;
        unsigned int km_H; //declaration de la variable dans la fonction pour gain de place => penalise la fonction //sendKmhToNextion();
        km_H=((tourRoue/1000)*(3600000/tempsRevolutionKm_h));
        
        nbTourRoue++;   
        
      /*  //partie pour visionnage sur ecran serie arduino
        Serial.print("nbtrous: ");
        Serial.print(trous);
        Serial.println("");
        Serial.print("tempsRevolutionKm_h:");
        Serial.print(tempsRevolutionKm_h);
        Serial.println("");
        Serial.print(km_H);
        Serial.print(" :KM/H");
        Serial.println("");
        Serial.print("nbTourRoue");   
        Serial.print(nbTourRoue);
        Serial.println("");
        Serial.print("lastMillisKm_h:");
        Serial.print(lastMillisKm_h);
        Serial.println("");
        Serial.print("millis");
        Serial.print(millis());
        Serial.println("");       */          
      
      
        
     //sendKmhToNextion();
        Serial.print("n1.val=");
        Serial.print("");
        Serial.print(km_H);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff); 
                                 
        trous=0;
        lastMillisKm_h=millis();
        
        //tempsRevolutionKm_h=0; //apparement inutile
        //attachInterrupt(1,nbTrous,FALLING);
           } 
          
     else if (millis()-lastMillisKm_h>=2000){ 
        
           
           //sendKmhToNextion();
        Serial.print("n1.val=");
        Serial.print("");
        Serial.print(00);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff); 
        
        lastMillisKm_h=millis(); }   
           
      ///////PARTIE TR/MIN //////////     
      
      if(ignitions>=50){
        //detachInterrupt(0);
        tempsRevolutionRpm= millis()-lastMillisRpm;
        unsigned int Rpm; //declaration dans la variable dans la fonction pour gain de place => penalise la fonction //sendRPMToNextion();
        Rpm =((ignitions*60000)/tempsRevolutionRpm);//equation a verifier!!!!!/!\/!\/!\  
        
     /*    //partie pour visionnage sur ecran serie arduino
        Serial.print("nbIgnitions: ");
        Serial.print(ignitions);
        Serial.println("");
        Serial.print("tempsRevolutionRPM:");
        Serial.print(tempsRevolutionRpm);
        Serial.println("");
        Serial.print(Rpm);
        Serial.print(" :RPM");
        Serial.println("");
        Serial.print("nbTourRoue");   
        Serial.print(nbTourRoue);
        Serial.println("");
        Serial.print("lastMillisRPM:");
        Serial.print(lastMillisRpm);
        Serial.println("");
        Serial.print("millis");
        Serial.print(millis());
        Serial.println("");      */     
          
      //sendRPMToNextion();
        Serial.print("n0.val=");
        Serial.print("");
        Serial.print(Rpm);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff); 
                                  
        ignitions=0;
        lastMillisRpm=millis();
        //tempsRevolutionRPM=0; //apparement inutile
        //attachInterrupt(0,nbIgnitions,RISING);
              }
           
      else if (millis()-lastMillisRpm>=2000){
        
           //sendKmhToNextion();
        Serial.print("n0.val=");
        Serial.print("");
        Serial.print(00);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff);
           
        lastMillisRpm=millis();  }  
           
      //////////PARTIE TEMPERATURE/////////////////////     
      
        float Moyenne;
      
      
        time=millis();
        while (millis()< (time+interval) ) ;
        ReadTemp(ptr);
        ptr ++;
       /* Serial.print("ptr");
        Serial.print( ptr);
        Serial.println();
        Serial.println("samples[]");
        Serial.println(samples[0]);
        Serial.println(samples[1]);
        Serial.println(samples[2]);
        Serial.println(samples[3]);
        Serial.println(samples[4]);
        Serial.println(samples[5]);
        Serial.println(samples[6]);
        Serial.println(samples[7]);
        Serial.println(samples[8]);
        Serial.println(samples[9]);
        Serial.println();*/
        
        if (ptr>=NUMSAMPLES){
          
          Moyenne = 0;
          for (int i=0; i<NUMSAMPLES; i++) {
          Moyenne += samples[i];}
          
          Moyenne /= NUMSAMPLES;
      /*  Serial.print ("Moyenne");
          Serial.print (Moyenne);
          Serial.println(); */
          
          float R1 = 10000;
          float logR2, R2, T;
          float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
          
          R2 = R1 * (1023.0 / (float)Moyenne - 1.0);
          logR2 = log(R2);
          T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
          T = T - 273.15;
          // T = (T * 9.0)/ 5.0 + 32.0; // pour affichage en degree Farhenheit
     
        /*  
          Serial.print ("Temperature:");
          Serial.print ( T);
          Serial.println ("C");  */   
          
         
          //sendTEMPToNextion();
          Serial.print("t3.txt=");
          Serial.print("\"");
          Serial.print(T);
          Serial.print("\"");
          Serial.write(0xff);
          Serial.write(0xff);
          Serial.write(0xff); 
         
          time=millis();
          ptr=0;}
      
    }
    
    
    
    ///////////////////partie attribuée aux fonctions!!!///////////////////////
    
    //fonction comptage nb trou
    
    void nbTrous() {trous++;}
    
    //fonction comptage ignitions
    
    void nbIgnitions(){ignitions++;}
       
    //fonction moyenne de TEMP°
    
    void ReadTemp(int n) {
      
       digitalWrite(12,HIGH);
       samples[n] = analogRead(ThermistorPin); //
       //Serial.println("samples[n]");
       //Serial.print(samples[n]);
       digitalWrite(12,LOW); }
    
    
    /*
    //fonction d'envoi Km/H
     void sendKmhToNextion()
    {
         Serial.print("n1.val=");
         Serial.print("");
         Serial.print(km_H);
         Serial.write(0xff);
         Serial.write(0xff);
         Serial.write(0xff);       //sendKmhToNextion(); //oblige a declarer de facon global la variable km_H
    }        
    //fonction d'envoi RPM
     void sendRPMToNextion()
    {
         Serial.print("n0.val=");
         Serial.print("");
         Serial.print(RPM);
         Serial.write(0xff);
         Serial.write(0xff);
         Serial.write(0xff);       //sendRPMToNextion(); //oblige a declarer de facon global la variable RPM
    }    
    */

    -----

  2. Publicité
  3. #2
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Bonjour, personne a de piste a me proposer??

    Une methode alternative?? Merci d'avance.

  4. #3
    paulfjujo

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    bonsoir,

    je suis plutot PIC que Arduino .. mais

    une identation correcte des fonctions permetterait une meilleur lisibilité , separation ..

    je ne vois pas où sont les traitements d'interruptions ?

    il se peut que la cadence d'interruption et le traitement interne dans lesdites interrupts
    fasse que le MCU , passe son temps à commuter du programme principal
    aux interrupts et ne peut donc plus progresser ..

    ça me rappel le bandeau de led (adresses ) d'un SOLAR 16-65 multitaches qui passait en feu fixe
    et ne faisait plus rien , à part commuter des taches ... tuer la tache à probleme ..pour repartir
    L'avantage sur ces vieilles bécanes c'est qu'on avait un visuel sur le deroulement du programme principal.

    un analyser logic peut permettre de deceler ce cas de figure sur un MCU.

  5. #4
    sandrecarpe

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Bonjour,
    Je sais pas comment fonctionne en interne la gestion de l'UART de l'arduino, mais à vu d'oeil ça me parait impossible qu'entre 2 mesures de vitesse tu puisses faire toutes ces transactions sur l'UART. Même avec des STM32 à 70MHz j'ai déjà eu ce problème (et pour des mesures de vitesse aussi, pour un robot), alors avec ces daubes d'arduino.....
    Solution :
    1 - utiliser un vrai microcontrôleur, pour une vingtaine d'euro on trouve des cartes de dev 100x plus performantes, avec déjà Ethernet et plus que tu n'aurais besoin (quand on sait qu'arduino vendent leur "shield" plus de 70€ pour l'Ethernet... C'est comme vouloir de faire escroquer en achetant chez Apple). Pour rester dans le meme niveau de compétence soft, les cartes MBED sont très biens pour ça.
    2 - bufferise les données avant de les envoyer. Autrement dit, effectue une série de mesure avant d'envoyer les résultats. Mais pendant l'envoi des résultats il faudra bien penser à quel ISR sera prioritaire sur qui, ou alors aucune interruption durant l'envoi
    Dernière modification par sandrecarpe ; 15/03/2020 à 08h28.

  6. A voir en vidéo sur Futura
  7. #5
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    On ne met pas tant de Serial.print entre une lecture et une remise à zéro.

    Tu peut utiliser aussi
    #define DEBUG 1

    Pour les Serial après des
    #ifdef DEBUG
    Serial....
    Serial....
    Serial....
    etc..
    #endif

    Pour ne pas avoir les serial en mode release.

    Mettre en commentaire #define pour ne pas avoir les Serial....


    Il y a une erreur de logique;

    Ta remise à zéro doit se faire immédiatement après sa lecture!
    LitTrous = trous;
    trous=0;

    On fait appel à une variable temporaire LitTrous!
    Puis on va compter le nombre nbTourRoue tout les 7 trous.
    Puis on doit conserver le reste s'il est >7.
    On compte le nombre de fois 7 en faisant ++ à chaque fois


    Code:
    int LitTrous =0;
    int reste = 0;
    
     if(trous>=7){
      // sauve la lecture et on l 'efface aussitôt !!!
      // 
      LitTrous = trous;
      trous=0;
    
      // On ajoute le reste du dernier passage
      LitTrous += reste;
    
      // compte   nbTourRoue; 
      while (LitTrous>7) {
              nbTourRoue++; 
              LitTrous -= 7;
             }
      // On mémorise le reste
      reste = LitTrous;
    A+, pat

  8. #6
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Bonjour Paulfjujo et Sandrecarpe et merci de vos retour.

    Paulfjujo concernant le traitement des interruptions, elles sont mises en place dans le setup.

    Je remarque d'ailleur deux serial.begin 9600 je vais deja en virer un..

    Pour la mise en forme du programme etant debutant j'ai fais au mieux pour pouvoir mis retrouver dedans.

    Sandrecarpe, je repond peut etre a cote de la plaque..mais j'ai aussi essayer en stoppant les routines d'interruptions pour l'envoi serie (com UART rx-tx avec l'ecran nextion.) Et en les reactivant ensuite(detach et attachinterrup)Mais cela ne change rien.

    Concernant ce que je demande a l'arduino...et par rapport a sa frequence de 16000hz(nano).

    Pour les tr/min..a 20000tr/min on est a 333tr/s soit 333hz qui represente environ 2.13% de capa

    Pour les km/h..le disque a 7 trous et pour une vitesse de 140km/h pour un perimetre de roue de 1.415m je tombe sur environ 193hz soit 1.2% de capa..

    En gros je pense le chatouiller a peine!!

    Je peut a la limite contenir les tr/min dans une certaine fourchette..genre regarder tous les x temps.. mais g absolument besoin de compter tous les trou du disque..

    Le programme n'en est cas sa version la plus simple pour l'instant..

    Ce que je n'arrive pas a comprendre..c'est le plafonnement a 25km/h meme si l'uart ne suis pas..pourquoi il n'affiche pas des valeur superieur a un moment donner?? Le capteur IR pourrais t-il simplement etre a la limite de sont fonctionnement?? Sur ma maquette je monte a la main sans probleme a plus de 70km/h donc je pense pas..et c'est vrai que le seul truc que j'ai pas pu tester c'est les deux interruptions en meme temps..mais le plafond a 25..pourquoi??ça bloquerai un coup a 12 ensuite a 20 a 30..ect..je comprendrai..mais que 25!! Ma foi..

    Bref je cherche une logique. Je vais deja essayer en augmentant le debit du serial begin et on vera.

    Merci des conseils en tous cas... meme si j'ai pas l'air..J'en prend bonne notes ^^

  9. Publicité
  10. #7
    sandrecarpe

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Concernant ce que je demande a l'arduino...et par rapport a sa frequence de 16000hz(nano).
    Pour les tr/min..a 20000tr/min on est a 333tr/s soit 333hz qui represente environ 2.13% de capa
    Pour les km/h..le disque a 7 trous et pour une vitesse de 140km/h pour un perimetre de roue de 1.415m je tombe sur environ 193hz soit 1.2% de capa..
    La lib arduino est tellement haute en abstraction que cette estimation de la charge CPU est sans aucun doute complètement à côté de la plaque et largement sous-estimée. Mais bon 333Hz ça devrait aller...

  11. #8
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Tu envoie sur le port série à 9600 baud environ 50 caractères avant de mettre à zéro ton compteur.
    Ce qui se passe pendant ce temps est effacé.

    1/9600 * 50 caractères * 10 bits/caractère =0,052 seconde
    Soit par seconde 1/0,052 = 19,2 passages par secondes.
    On est loin des 300 à 400 hz.
    A+, pat

  12. #9
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Sandrecarpe oui jme doute. Mais je sais que t'aura compris que je voulais dire, que je pense pas tapé dedans comme un malade au point de le faire craquer.

    En effet faudrais prendre le temps de boucle, les chevauchements, les risques de phases..ect. j'en passe et des meilleurs.. Je ne neglige cependant pas ta remarque!!

    Freepicbasic, j'avais pas vu ton com avant mon dernier poste. Et si je comprend bien. Le #define DEBUG 1 servirait a ne pas compiler les serial... de controles entre

    #ifdef DEBUG 1
    serial... ou "code"
    #endif DEBUG 1

    A la place des
    /*
    "Code"
    */
    Qui eux chargerai le preprocesseur a la compilation, en caractere??! C'est bien ça?

    Par contre les serial.prints pour le nextion sont imcompressiblent eux..là j'ai pas le choix!!

    Concernant ta remarque sur les trous. En effet cela ameliorera le comptage mais du coup, c'est bete, je ne vois pas quelle
    Variable prendre pour mon calcul! Ni ou le mettre..faut que j'y reflechisse.

    En tous cas. Merci à vous pour les pistes..
    Je vais ameliorer ma maquette. Il faut que je comprenne!!

  13. #10
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Ahhh freebasic donc ce serai la vitesse de com. ??

  14. #11
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    En partie oui.
    Mais surtout la remise à zéro tardive et la possibilité d'avoir + que 7 dans le compteur, il faut tenir compte de ce qui dépasse aussi , surtout si on fait quelque chose de long entre 2 passages.
    Dernière modification par freepicbasic ; 15/03/2020 à 13h54.
    A+, pat

  15. #12
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Bonjour Messieurs,

    bon ben merci bien Freepicbasic, tu m'as clairement permis de comprendre et ton analyse était la bonne.

    en modifiant un peut mon équation, la remise a zéro et surtout en améliorant la prise en compte du nombre de trous(interruptions), effectivement ça marche beaucoup mieux!!

    Le problème ne ce voyait pas sur les ignitions car la variable était injectée tel quel, Et comme jusqu’à présent j'avais fait mes Tests "lentement", tous ce passé comme je le pensée, mais en accélérant les rotations j'ai clairement compris ce qui ce passé en réalité!!

    Je dépassé largement les "7" trous et bien sur, je ne l'avais pas envisager, en pensant que le processeur serai largement plus rapide (rho l'erreur de stroumph!!).

    j'arrive donc maintenant largement au dessus de ce que j'aurais besoin ()

    test serial.jpg

    Je met une photo de la maquette que j'ai réalisée aussi, ci ça peut aider.

    Photo maquette test.jpg

    Par contre, j'ai fais les #define debug et je constate que le programme est plus lourd à la compilation quand je dé-commente le DEBUG2 pour les envois au nextion (alors qu'il y a moins de serial...) que lorsque je me sert du DEBUG1.

    Cela viendrait-il des SERIAL.WRITE que j'envoi au nextion??
    Quelle différence il y a entre serial.print et serial.write?

    Bon sinon ba j'ai plus qu'a gérer les débordement de variables. ça je devrais trouver comment faire!

    Et comme la résolution d'un problème mène toujours à un autre problème...()

    Je vais avoir besoin d'un p'tit coup de main concernant un morceau (simple svp) de programme permettant d’écrire des variables a l'extinction (shuntdown) dans l'EEPROM avec pour chaque variables un décalage d'adresse tenant compte bien sur du dépassement/bouclage (0-255), et bien évidement de leur relecture au démarrage... (un exemple pour 2 variables devrait déjà me permettre de comprendre)

    Je cherche de mon coté, mais là j'ai vraiment du mal, je trouve les codes complexe. et j'ai un peu peur de faire n'importe quoi!
    (rappel: je débute, soyez indulgent svp!!)

    Sinon ben je met le code qui marche pour mes interruptions.. qui sais, ça pourrait servir à quelqu'un!

    Code HTML:
    //PARTIE CAPTEURS NUMERIQUES
    
    int capteurIR = 2; //capteur IR sur PIN D2 (IR TEST = PEUT ETRE NIMPORTE QUEL CAPTEUR)
    int capteurRPM = 3; // capteur signal allumage sur PIN D3
    
    //int led=13;
    int trous;
    int copyTrous;
    unsigned long int lastCopyTrous;
    unsigned long int nbTourRoue;
    
    int ignitions;
    int copyIgnitions;
    float tourRoue;
    
    unsigned long lastMillisKm_h;
    unsigned long tempsRevolutionKm_h;
    unsigned long lastMillisRpm;
    unsigned long tempsRevolutionRpm;
    
    //////*lecture de temperature en 3.3V Aref sur NTC 100K + R100K */////////
    
    unsigned long interval=200;
    unsigned long time;
    int ptr=0;  
    #define NUMSAMPLES 10 //nombre de lecture
    int samples[NUMSAMPLES];
    int ThermistorPin = A0; //pin analogique pour sonde NTC100K
    //(int) ActivationSonde = 12; // pin digital D12
    //float R1 = 100000;
    //float logR2, R2, T;
    //float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
    
    ///////////////////////////////////////////
    
    void setup()
    
    ////PARTIE SETUP CAPTEUR KMH / RPM //////////
    {
      trous=0;
      copyTrous=0;
      lastCopyTrous=0;
      ignitions=0;
      copyIgnitions=0;
      nbTourRoue=0;
      tourRoue=1.415; //((2*3.14)*((13*25.4)/2)+60)=((2*3.14)*225.1)=1413.628cm=1.415m
      lastMillisKm_h=0;
      tempsRevolutionKm_h=0;
      lastMillisRpm=0;
      tempsRevolutionRpm=0;
      pinMode(capteurIR,INPUT);
      pinMode(capteurRPM,INPUT);
      attachInterrupt(0,nbTrous,FALLING);
      attachInterrupt(1,nbIgnitions,RISING);
      
      //pinMode(led,OUTPUT);
    
    //////PARTIE SETUP TEMPERATURE//////////////////  
     
      Serial.begin(115200);
      analogReference(EXTERNAL);
      pinMode(0,INPUT);
      pinMode(12,OUTPUT);
      digitalWrite(12,LOW);  
      
    //////FIN SETUP CAPTEURS/////// 
    
      //#define DEBUG1     //pour impression serie , decommentez pour activer
      #define DEBUG2     //pour impression nextion , decommentez pour activer
      
      #ifdef DEBUG1
      Serial.println("****DEBUT_PROGRAMME****");
      Serial.println("");
      #endif DEBUG1
      
    }
    
    void loop()
    {   
      capteurIR=digitalRead(2);
      capteurRPM=digitalRead(3);
      
      ////////PARTIE KM/H ///////////////
      
     
      if(trous>=7){
        
        //detachInterrupt(0);
        copyTrous=trous;
        trous=0;
        
        tempsRevolutionKm_h= millis()-lastMillisKm_h;
        int km_H; //declaration de la variable dans la fonction pour gain de place => penalise la fonction //sendKmhToNextion();
       
        km_H=((copyTrous*(tourRoue/7000))*(3600000/tempsRevolutionKm_h)); //(tourRoue) est diviser par 7000 car, 1000 pour passer
                                                                          // pour passer de metre a Km et, 7, car 7 trous = 1tour
                                                                          //l'operation permet la gestion du debordement de la 
                                                                          //condition, pour interruption trous>=7
        lastMillisKm_h=millis();
        
        lastCopyTrous=lastCopyTrous+copyTrous;
        
        nbTourRoue=(lastCopyTrous/7);
        
        #ifdef DEBUG1
        //partie pour visionnage sur ecran serie arduino
        Serial.print("millis");
        Serial.print(millis());
        Serial.println("");
        Serial.print("nbtrous: ");
        Serial.print(copyTrous);
        Serial.println("");
        Serial.print("tempsRevolutionKm_h:");
        Serial.print(tempsRevolutionKm_h);
        Serial.println("");
        Serial.print(km_H);
        Serial.print(" :KM/H");
        Serial.println("");
        Serial.print("nbTourRoue");   
        Serial.print(nbTourRoue);
        Serial.println("");
        Serial.print("lastMillisKm_h:");
        Serial.print(lastMillisKm_h);
        Serial.println("");                 
        #endif DEBUG1
      
        #ifdef DEBUG2
        //sendKmhToNextion();
        Serial.print("n1.val=");
        Serial.print("");
        Serial.print(km_H);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff); 
        #endif DEBUG2
        
        //attachInterrupt(0,nbTrous,FALLING);
           } 
          
     else if (millis()-lastMillisKm_h>=2000){ 
        
        #ifdef DEBUG2   
           //sendKmhToNextion();
        Serial.print("n1.val=");
        Serial.print("");
        Serial.print(00);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff); 
        #endif DEBUG2
        
        //lastMillisKm_h=millis();
            }   
           
      ///////PARTIE TR/MIN //////////     
      
      if(ignitions>=50){
        //detachInterrupt(1);
        copyIgnitions=ignitions;
        ignitions=0;
        tempsRevolutionRpm= millis()-lastMillisRpm;
        unsigned int Rpm; //declaration dans la variable dans la fonction pour gain de place => penalise la fonction //sendRPMToNextion();
        Rpm =((copyIgnitions*60000)/tempsRevolutionRpm);//equation a verifier!!!!!/!\/!\/!\  
        
        lastMillisRpm=millis();
        
        
        #ifdef DEBUG1
        //partie pour visionnage sur ecran serie arduino
        Serial.print("millis");
        Serial.print(millis());
        Serial.println(""); 
        Serial.print("nbIgnitions: ");
        Serial.print(copyIgnitions);
        Serial.println("");
        Serial.print("tempsRevolutionRPM:");
        Serial.print(tempsRevolutionRpm);
        Serial.println("");
        Serial.print(Rpm);
        Serial.print(" :RPM");
        Serial.println("");
        Serial.print("lastMillisRPM:");
        Serial.print(lastMillisRpm);
        Serial.println("");         
        #endif DEBUG1 
        
        #ifdef DEBUG2
      //sendRPMToNextion();
        Serial.print("n0.val=");
        Serial.print("");
        Serial.print(Rpm);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff); 
        #endif DEBUG2
     
        //attachInterrupt(1,nbIgnitions,RISING);
              }
           
      else if (millis()-lastMillisRpm>=2000){
        
        #ifdef DEBUG2
        //sendKmhToNextion();
        Serial.print("n0.val=");
        Serial.print("");
        Serial.print(00);
        Serial.write(0xff);
        Serial.write(0xff);
        Serial.write(0xff);
        #endif DEBUG2
           
       // lastMillisRpm=millis(); 
              }  
           
      //////////PARTIE TEMPERATURE/////////////////////     
      
        float Moyenne;
      
      
        time=millis();
        while (millis()< (time+interval) ) ;
        ReadTemp(ptr);
        ptr ++;
        
    /*    #ifdef DEBUG1
        Serial.print("ptr");
        Serial.print( ptr);
        Serial.println();
        Serial.println("samples[]");
        Serial.println(samples[0]);
        Serial.println(samples[1]);
        Serial.println(samples[2]);
        Serial.println(samples[3]);
        Serial.println(samples[4]);
        Serial.println(samples[5]);
        Serial.println(samples[6]);
        Serial.println(samples[7]);
        Serial.println(samples[8]);
        Serial.println(samples[9]);
        Serial.println();
        #endif DEBUG1    */           
        
        if (ptr>=NUMSAMPLES){
          
          Moyenne = 0;
          for (int i=0; i<NUMSAMPLES; i++) {
          Moyenne += samples[i];}
          
          Moyenne /= NUMSAMPLES;
          
          #ifdef DEBUG1
          Serial.print ("Moyenne");
          Serial.print (Moyenne);
          Serial.println(); 
          #endif DEBUG1          
          
          float R1 = 100000;
          float logR2, R2, T;
          float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
          
          R2 = R1 * (1023.0 / (float)Moyenne - 1.0);
          logR2 = log(R2);
          T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
          T = T - 273.15;
          // T = (T * 9.0)/ 5.0 + 32.0; // pour affichage en degree Farhenheit
     
          #ifdef DEBUG1
          Serial.print ("Temperature:");
          Serial.print ( T);
          Serial.println ("C");     
          #endif DEBUG1                      
    
          #ifdef DEBUG2
          //sendTEMPToNextion();
          Serial.print("t3.txt=");
          Serial.print("\"");
          Serial.print(T);
          Serial.print("\"");
          Serial.write(0xff);
          Serial.write(0xff);
          Serial.write(0xff); 
          #endif DEBUG2
          
          
          time=millis(); // peut surement etre suprimmer! faire test!
          ptr=0;}                    
      
    }
    
    
    
    ///////////////////partie attribuée aux fonctions!!!///////////////////////
    
    //fonction comptage nb trou
    
    void nbTrous() {trous++;}
    
    //fonction comptage ignitions
    
    void nbIgnitions(){ignitions++;}
       
    //fonction moyenne de TEMP°
    
    void ReadTemp(int n) {
      
       digitalWrite(12,HIGH);
       samples[n] = analogRead(ThermistorPin); //
       //Serial.println("samples[n]");
       //Serial.print(samples[n]);
       digitalWrite(12,LOW); }
    
    /*
    #ifdef DEBUG1
    //fonction d'envoi Km/H
     void sendKmhToNextion()
    {
         Serial.print("n1.val=");
         Serial.print("");
         Serial.print(km_H);
         Serial.write(0xff);
         Serial.write(0xff);
         Serial.write(0xff);       //sendKmhToNextion(); //oblige a declarer de facon global la variable km_H
    }        
    //fonction d'envoi RPM
     void sendRPMToNextion()
    {
         Serial.print("n0.val=");
         Serial.print("");
         Serial.print(RPM);
         Serial.write(0xff);
         Serial.write(0xff);
         Serial.write(0xff);       //sendRPMToNextion(); //oblige a declarer de facon global la variable RPM
    }    
    #endif DEBUG1 */
    Merci encore à vous pour le coup de patte!! c'est vraiment sympa!

    A pluche!
    Dernière modification par 2 terium ; 19/03/2020 à 11h08.

  16. Publicité
  17. #13
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Au sujet du debug , normallement on met en majuscule le mot peut être réservé au compilateur
    Ou alors changé DEBUG par MYDEBUG pour évité des problèmes de compilation

    Le fait mettre en commentaire le define doit diminuer la taille.
    Le compilateur peut aussi générer des infos de deboguage ASM.

    =============================

    Pour la sauvegarde des données juste avant l'arrêt , il faudra détecté la mise hors tension.
    Donc mettre une diode en entrée de Vin avec un condo qui va maintenir un cours instant la tension.
    Sur une entrée mettre un pont de résistances pour diminuer le 12V avant diode en 5V. et connecter à une pin libre en entrée.

    Faire un test avec que cette partie pour ce faire la main et voir si ça fonctionne avec un Serial à la fin pour vérifier

    ============================

    Pour écrire addr sera un int et val un char ou BYTE
    EEPROM.write(addr, val);

    Pour lire value BYTE ou char, addr un int
    val = EEPROM.read(addr);

    ===========================

    Si on veut mémoriser un long de 4 BYTE s , il faudra utiliser une astuce du C.
    Qui consiste à utiliser un pointeur de char qui lira un à un les 4 octets du long

    Code:
    // version détaillée pour comprendre
    
    // initialise les variables
    char val;
    int addr = 0;  // adresse à lire
    char *myPtr;   // pour convertir le pointer du long (long *) en pointeur de char (char *)
    //           (l'utilisation d'un pointeur non initialisé provoque l'erreur "Null pointer assignment")
    //           (Sur Arduino ça risque plutôt de planter, pas de gestion d'erreur)
    long MyCounter = 12345; // une valeur pour le test
    
    
    // le & indique le pointeur pas la variable
    myPtr = (char *) &MyCounter;
    
    val = *myPtr; // 1er octet
    EEPROM.write(addr, val);
    
    addr++;
    myPtr++;
    val = *myPtr; // 2em octet
    EEPROM.write(addr, val);
    
    addr++;
    myPtr++;
    val = *myPtr; // 3em octet
    EEPROM.write(addr, val);
    
    addr++;
    myPtr++;
    val = *myPtr; // 4em octet
    EEPROM.write(addr, val);
    Pour lire on fait l'inverse


    Code:
    // le & indique le pointeur pas la variable
    myPtr = (char *) &MyCounter;
    
    val = EEPROM.read(addr);
    *MyPtr = val
    addr++;
    myPtr++;
    
    val = EEPROM.read(addr);
    *MyPtr = val
    addr++;
    myPtr++;
    
    val = EEPROM.read(addr);
    *MyPtr = val
    addr++;
    myPtr++;
    
    val = EEPROM.read(addr);
    *MyPtr = val
    ============================== ==

    Autre façon, car le C nous permet d'écrire plus court.


    Code:
    int i;
    
    // le & indique le pointeur pas la variable
    myPtr = (char *) &MyCounter;
    
    for (i=0; i<4; i++)
    	EEPROM.write(addr, *(myPtr++) );
    
    
    
    myPtr = (char *) &MyCounter;
    for (i=0; i<4; i++)
    	*(myPtr++) = EEPROM.read(addr++);
    Dernière modification par freepicbasic ; 19/03/2020 à 16h54.
    A+, pat

  18. #14
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Bonjour.

    Merci freepicbasic pour ce coter pédagogue. C'est franchement très sympa de ta part.

    Pour la condition d'enregistrement j'ai plusieur possibilitées soit le shuntdown direct..effectivement c'est l'ideal..je passe par un lm7805 et j'ai une capa de 1000ųf en filtrage mais je sais pas si cela suffira, donc oui a tester..avec une entree et une condition. If intD low... Sinon j'ai la possibilitee d'enregistrer lorsque les ignitions stop.. chose non negligeable, je pense mais qui va forcement engendrer plus de sauvegardes. Cette parties reste encore a voir mais je devrais me debrouiller.

    Par contre, concernant les sauvegardes en elles mêmes.

    1er point, si je comprend bien la decomposition apres un enregistrement.je dois rajouter a la relecture un
    /"return val;
    myCounter=val; "/
    , et je suis bien content qu'il n'y ai pas d'histoire de bits lourd ou leger a decaller.

    2eme point: cette methode reste sur une adresse fixe des 4 octet de la variable long en partant de l'adresse 0!?c'est bien ça!?

    Donc la variable suivante a enregistrer devra initialiser..un int n=4 et la condition devra etre n<8; pour n++!(j'ai bien compris?)

    Ce qui fait que je ne decalle pas les adresses à chaque ecritures/enregistrements comme je pensais faire?

    Franchement c'est un peu chaud a comprendre cette histoire de pointeur.. C'est surement une question bete. Mais je vois pas comment faire pour decallees ces adresses ensuite..Si c'est faisable, et ce que ça engendre pour relire.

    Peut etre je vois trop complexe pour mon niveau.

    Merci en tous cas pour les infos!! Jme repete. Mais c'est vraiment cool.

    A plus.
    Dernière modification par 2 terium ; 21/03/2020 à 16h33.

  19. #15
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Pour le signal de sauvegarde c était surtout l'ensemble diode condo qui permet d'alimenter le µp un court instant après la descentes de la tension d'alimentation.

    Si l'on respecte l'ordre de sauvegarde on écrit octet par octet à la restitution c’est transparent.
    On peut ainsi faire une structure et utiliser le "sizeof(struct ...)" en transformant le pointeur en (char *) pour écrire et lire.
    A+, pat

  20. #16
    Seb.26

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    J'ai pas tout lu, mais appeler une It pour faire un ++ sur une variable n'est probablement pas la meilleure idéee.

    Utilise les pin d'un timer en mode compteur et soit tu relève les compteurs à interval réuliers, soit tu attends que le compteur déborde et tu regardes combien de temps c'est écoulé...

    << L'histoire nous apprend que l'on apprend rien de l'histoire. >>

  21. #17
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Seb26. Bonjour.

    En gros tu me conseil de changer mes conditions de lecture de mes interruption des if >= en truc genre..
    / if (il c'est passer 400millisecondes.)
    { code lecture trou/ignition => traitement / envoi. } /

    Ayant mieux compris maintenant..c'est ce que je compte faire histoire de soulager les serial.print.
    Dit moi si je me trompe. Sinon merci pour ton commentaire.

    Freepicbasic re.

    Là je crois que j'ai pas le niveau pour ton histoire de structure et transformer le pointeur en char. Pour etre honnete! Je dirai que j'ai carrement rien compris!

    Peut tu deja me dire si j'ai bien compris par rapport a mes question precedentes? (Decompo et adresse).

    Je t'en voudrais pas si tu me detailles l'histoire de structure ^^ .
    (Boulet..je comprend vite mais faut m'expliquer longtemps...)

    Merci les gars!

  22. #18
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Voilà le test pour écrire et lire une structure complète d'un coup dans l'EEPROM.


    Code:
    #include <EEPROM.h>
    
    // déclaration de la forme de la structutre
    // memo nom de la structure qui a 1 long et 3 int
    struct memo {
      long Count ;
      int var1;
      int var2;
      int var3;
    };
    
    // On créé une structure de type memo elle s'appelle Memo
    // Memo est le nom
    memo Memo;
    
    void setup() {
      // test sur le port serie
      Serial.begin(9600);
    
      // On initialise la structure avec des valeurs
      // histoire d'avoir quelque chose.
      // le point indique qu 'on a accès à la variable
      // ne pas confondre avec le pointeur Memo->var1 par exemple, qui nécessite des malloc !
     
      Memo.Count = 324999;
      Memo.var1 = 1;
      Memo.var2 = 2;
      Memo.var3 = 3;
    }
    
    void loop() {
      int i;
      int addr=0;
      char *myPtr;   // pour convertir le pointer de struct (struct *) en pointeur de char (char *)
    
      // On vérifie le contenu avant tout
      Serial.println("Original");
      Serial.println(Memo.Count);
      Serial.println(Memo.var1);
      Serial.println(Memo.var2);
      Serial.println(Memo.var3);
      Serial.println("");
    
      // le & indique le pointeur pas la variable
      // On converti le pointeur de structure
      myPtr = (char *) &Memo;
    
     // On écrit dans l'EEPROM
      for (i = 0; i < sizeof(memo); i++)
        EEPROM.write(addr++, *(myPtr++) );
    
      // On efface Tout pour être sur qu'on ne va pas relire ce qui était déjà dedans
      Memo.Count = 0;
      Memo.var1 = 0;
      Memo.var2 = 0;
      Memo.var3 = 0;
    
      // vérification de l'effacement
      Serial.println("Mise a zero");
      Serial.println(Memo.Count);
      Serial.println(Memo.var1);
      Serial.println(Memo.var2);
      Serial.println(Memo.var3);
      Serial.println("");
    
      // On relit toute la structure
      myPtr = (char *) &Memo;
      addr=0;
      for (i = 0; i < sizeof(memo); i++)
        *(myPtr++) = EEPROM.read(addr++);
    
      // vérification de la lecture
      Serial.println(" Lecture");
      Serial.println(Memo.Count);
      Serial.println(Memo.var1);
      Serial.println(Memo.var2);
      Serial.println(Memo.var3);
      Serial.println("");
    
    // On bloque le test !
    // Une fois suffit pour voir si ça fonctionne
      while (1);
    }
    ça donne ça ;

    Original
    324999
    1
    2
    3

    Mise a zero
    0
    0
    0
    0

    Lecture
    324999
    1
    2
    3
    A+, pat

  23. Publicité
  24. #19
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Ne pas confondre le type et la structure

    Le type est une déclaration qui n'apparait pas dans le programme en code ou en RAM et sert au compilateur !
    memo

    La structure elle est une réservation de mémoire dans la RAM.
    Memo

    On pourrait en avoir plusieurs, le type lui est unique !
    memo Memo;
    memo Memo1;
    memo Memo2;

    Les structures peuvent se copier avec un simple "="
    Memo1 = Memo ;


    Serial.println (sizeof(memo)) donne la longueur de la structure
    Dernière modification par freepicbasic ; 22/03/2020 à 17h25.
    A+, pat

  25. #20
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Bonjour Freepicbasic.

    Alors wouai. Tu m'envoi du lourd, lol!

    Si je comprend bien..le type memo est comme une variable en fait..et est lier a une structure(memo).

    Cela permet de ne pas avoir a gerer les adresses de chaque variables a enregistrer.(elles ce mettent directement les une derriere les autres..et ce..suivant la taille de la structure memo.).

    Pour faire evoluer l'adresse. J'ai plus qu'a trouver un systeme d'incrementation pour addr (exemple if alim LOW => addr++;eeprom write; ) et dire dans le for (i=addr; i<sizeof(memo)....;i++)? Pareil pour le eeprom.read

    Ensuite calculer l'espace total du memo en eeprom..et mettre une autre condition pour le retour a 0 de adress!!

    Est ce que,
    en mettant addr en eeprom aussi..cela est faisable pour retrouver la bonne adresse au demarrage!?

    J'ai bien tous compris??la solution que j'envisage est telle realisable? Ou c'est carrement risqué?.

    En tous cas..tu m'apprend des choses là.
    ET pour finir..le while (1).. je savais pas qu'on pouvais definir le nb de boucles!

    Merci a toi. Au plaisir.

  26. #21
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Eu..je crois que je dis des grosses betises là!!

    En fait. De cette maniere. Je pourrais jamais retrouver la bonne adresse!

    La question serait donc. Comment faire pour avoir une adresse de debut de memo flottante/evolutive? Et la retrouvee.

    Je sais pas si c'est faisable. Mais au moins. Je serais fixé!

    Rho la prise de tete.

  27. #22
    paulfjujo

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Citation Envoyé par 2 terium Voir le message

    Est ce que,
    en mettant addr en eeprom aussi..cela est faisable pour retrouver la bonne adresse au demarrage!?
    oui, c'est une bonne solution, (tres courante d'ailleurs)
    mettre l'adresse "en cours" en fond de memoire EEPROM (donc adresse eeprom connue et immuable)
    et limiter l'adresse maxi (en cours)pour ne pas l'ecrabouiller avec de nouvelles données

    la lire avant de stocker
    .. faire le stockage des datas
    puis mettre l'adresse (apres incrementation du Nb de bytes) pour la mettre à jour pour la prochaine fois

    si possible se debrouiller pour que le Nb de datas soit un multiple binaire ( ,32,64,128 ) dependant du type d'eeprom utilsée (voir datasheet)
    pour aussi gerer les ecritures/lectures modul PAGES eeprom
    Dernière modification par paulfjujo ; 23/03/2020 à 12h15.

  28. #23
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Paulfjujo bonjour.

    Oui mais si j'ai une adresse immuable pour retrouver les donnees..autant laisser la structure en place complete a l'adresse 0!!non?

    La methode que tu me propose est interessante, si effectivement, je dois ecrire plus en eeprom, que le nombre de fois ou j'ai besoin d'aller chercher les valeurs en question! Donc j'en prend bonnes notes.

    Je comprend que ce que je voudrais faire semble un peu complexe a priori.

    Autant ecrire: addr+1 avant eeprom.write me semble facile..

    Autant retrouver une adresse "flottante" au demarrage, semble beaucoup plus complexe.

    Merci pour les idees.

  29. #24
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    ET pour finir..le while (1).. je savais pas qu'on pouvais definir le nb de boucles!
    Non !
    while(1);
    Tourne infiniment sur lui même, ce n'est pas le nombre de boucle !
    La condition 1 est toujours vrai donc il boucle !
    C est une boucle forever
    Un genre de plantage volontaire.

    Si j'écrit
    for (i=0;i>1;i=i) ;
    La condition ne sera jamais vrai il boucle à l'infini.

    while(1); est plus simple, c est un classique !


    ici on déclare la forme de la structure c est tout , on lui donne un nom memo;
    struct memo {
    long Count ;
    int var1;
    int var2;
    int var3;
    };

    Et ici on reserve la place mémoire
    memo Memo

    En C On différencie les majuscules et les minuscules donc la structure en mémoire c est Memo !

    Donc pour écrire ou lire dans la mémoire Count on fait par exemple;

    Memo.Count = MyCount;
    ou
    MyCount = Memo.count;

    Pour sauvé;
    addr=0; // ou on sauve le bloc
    myPtr = (char *) &Memo; // adresse de l'octet en cours de sauvegarde
    for (i = 0; i < sizeof(memo); i++) // on fait le nombre d'écritures qu'il faut , la longueur se calcul automatiquement
    EEPROM.write(addr++, *(myPtr++) );

    C'EST TOUT !


    addr++ incrémente automatiquement adresse EEPROM
    (myPtr++) incrémente le pointeur d' Octet de la structure.
    Le * désigne le contenu de l octet qui est pointé.

    Si j'écris *myPtr++ j'incrémente le contenu pointé.
    (myPtr++) j'incrémente le pointeur.
    *(myPtr++) je lis le contenu puis j'incrémente le pointeur.

    Je sais que parfois la notion de pointeur et de contenu est difficile a comprendre quand on a pas fait d'assembleur.

    C est juste l'adresse de la boite aux lettres.
    Et le contenu la lettre.



    =================


    Addr=0;
    Je commence à l'adresse 0 de l'EEPROM
    Tu peux le mettre ou tu veux mais à priori l'EEPROM est vide.

    Si tu veux stocker autre chose il faudra connaitre forcément l'adresse suivante donc utiliser le sizeof de la structure précédente et ainsi de suite.

    adresse du prochain bloc à sauver
    Addr = sizeof(memo);


    La remarque de paulfjujo est très juste utiliser une puissance de 2
    L’utilisation du char dans la structure se passe mal par exemple, alors que les fonctions EEPROM elles nécessitent un simple octet.
    A+, pat

  30. Publicité
  31. #25
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Freepicbasic.

    Ok pour la structure en elle meme. J'ai, me semble t'il saisi le concept. Mais je demandais si il etait possible d'incrementer l'adresse de depart de lecture/enregistrement de la structure
    (Pour ne pas reecrire a chaque fois les donnees dans les memes octets eeprom.)

    Structure memo de variables..longueur total Memo en octets et principe des puissances de 2, je pense que j'ai cerne le truc.

    Je voudrais juste ne pas limité mes enregistrements (pour le futur et dans d'autres programmes..) aux 100000 effacement/ecritures des cases eeprom concernees.

  32. #26
    Seb.26

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Citation Envoyé par 2 terium Voir le message
    Seb26. Bonjour.

    En gros tu me conseil de changer mes conditions de lecture de mes interruption des if >= en truc genre..
    / if (il c'est passer 400millisecondes.)
    { code lecture trou/ignition => traitement / envoi. } /
    Non, ce qe je dis c'est que tu utilises des interuptions (donc du temps CPU) pour compter des impulsions sur une pin ... alors que le CPU via les Timer sait le faire en hard (donc 0 temps CPU).

    Dans la datasheet tu trouveras tout cela expliqué, mais en gros le principe :
    > sur chaque front de ta pin, le timer incremente un compteur
    > tu relève+raz ce compteur à intervalles réguliers pour déterminer a fréquence de ton signal.
    << L'histoire nous apprend que l'on apprend rien de l'histoire. >>

  33. #27
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    C est l'application classique du fréquencemètre qui permet d'incrémenter le compteur interne aussi rapidement qu'un circuit logique classique.
    ça serait surement plus pro...
    A+, pat

  34. #28
    freepicbasic

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Ok pour la structure en elle meme. J'ai, me semble t'il saisi le concept. Mais je demandais si il etait possible d'incrementer l'adresse de depart de lecture/enregistrement de la structure
    (Pour ne pas reecrire a chaque fois les donnees dans les memes octets eeprom.)
    Dans ce cas inutile de faire une structure si on écrit juste quelques octets, il suffit de pointer le bon endroit.
    Si on sait qu'un long fait 4 octets , alors var1 est à l'adresse 4 (addr=4; ) et on écrit 2 octets pour var1.

    De toutes façons, il est préférable de ne pas trop solliciter l' EEPROM , 1 écriture après chaque arrêt , elle durera très longtemps, surement plus longtemps que le montage...
    On peut lire autant de fois qu'on veut.
    A+, pat

  35. #29
    2 terium

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Seb.26

    bonsoir. Je viens de regarder le truc sur les timers et franchement pour moi. C'est du russo chinois arameén.

    Il y a des histoires de registres et de flag d'interruption qui remettent a 0 les timers. Faut manipuler des choses auxquelles je dirais clairement que j'y comprend fifre!!

    Alors je fais peut être fausse route..même surement!

    Mais si tu as un bout de code pour prendre en compte les impulsions sur une pin. Hors interruption. Je veut bien, car je ne vois pas comment un timer peut incrementer un pulse en rise ou fale qui change en frequence.

    Alors ce que tu dis a l'air plutot cool.

    Mais Eu.. jsuis paumé là!

  36. #30
    carcan

    Re : Compteur moto Problème interruptions arduino pour compteur KM/H et RPM

    Hello !

    j'ai lu en diagonale et il y a un truc qui me saute aux yeux : tu utilises la loin de Steinhart-Hart pour la conversion résistance --> température, je dis bravo, c'est la meilleure méthode pour avoir une mesure précise.
    Par contre, ce genre de calcul bouffe beaucoup de temps (j'ai déjà eu des soucis de timing avec des PIC18F et une conversion équivalente).

    Vérifies avec et sans la conversion t°, pour voir si ça affecte tes résultats. Si oui, tu peux te rabattre sur un tableau où tu rentres la valeur de l'ADC et tu en sors une température (entière) ... après tout, la t° du moteur, on ne doit pas la connaitre au degré près.

    Je suis une quiche en Timers pour Arduino, désolé ; mais Freepicbasic semble être calé ... et même en C en général, bravo !

    A+
    Laurent

Page 1 sur 2 1 DernièreDernière

Discussions similaires

  1. [Programmation] Réaliser un compteur d'impulsions pour compteur d'eau
    Par morzini dans le forum Électronique
    Réponses: 8
    Dernier message: 29/03/2016, 14h53
  2. Problème code arduino compteur de personnes
    Par savoyard74 dans le forum Électronique
    Réponses: 13
    Dernier message: 17/03/2015, 07h14
  3. Réponses: 20
    Dernier message: 13/08/2012, 16h17
  4. Led de compteur moto
    Par freddo73 dans le forum Électronique
    Réponses: 2
    Dernier message: 24/01/2009, 07h32
  5. Compteur moto
    Par benjy dans le forum Électronique
    Réponses: 5
    Dernier message: 15/10/2007, 21h34
Découvrez nos comparatifs produits sur l'informatique et les technologies.