Bonjour,

Tout nouveau sur le forum, je viens d’acquérir mon UNO. J’ai bien assimilé la logique de programmation, mais je bute sur un point.

Je souhaite réaliser un compteur de vitesse et compte tours, mes données brutes seront des impulsions (niveau 1) sur une borne numérique par seconde. Je pense savoir compter les impulsions (dans une boucle) mais la notion du temps me pose problème. Il y a t’il une instruction qui défini le temps ? (exemple je compte les imputions dans une période de une seconde).

Merci pour vos réponses

Salutations

Philippe

La fonction millis te renvoie le nombre de milli seconde depuis que le Arduino a démarré.

Si tu veux être très précis, tu as la fonction micros qui te renvoie le nombre de micro seconde écoulé depuis que le Arduino a démarré.

-----

Ou alors, tu peux utiliser un timer qui te déclenche une interruption à interval régulier.

Il faut différencier deux façon de gérer le temps:

-un SP bloquant ou retournant un temps, pendant lequel tu consomme ton activité, souvent pour rien

-un Timer, programmé.

Pour ton utilisation, de loin c'est le timer. Savoir le nombre de µs qui se sont écoulées depuis le début, on s'en fout étant donné que l'acquisition peut être conditionnelle.

Renseigne toi sur les timers et les interruptions. C'est un outils très pratique : tu programme le timer, tu l'autorise. Puis tu fais ce que tu veux, quand le timer a fini de compter son temps (par exemple une seconde), il interrompt ton programme, réalise ce qu'il doit faire, et recommence.

Et du coup question sur cette interruption de programme :

entre l'arret du programme et son traitement, le roue continue à tourner...

Il va donc être possible de récupérer un grand nombre d'information, mais on risque rater des informations entre 2 traitements non ?

Les interruptions servent justement à interrompre le programme pour ne rater aucun évènement.

Petit exemple (en pseudo code) sans IT :

int passage = 0;

loop() {
    grosTraitement();
    if (évènement) {
        passage++;
    }
}

Dans ce code, si l'évènement arrive pendant le gros traitement (et se termine avant le if), alors ton code aura raté l'évènement ...

Par contre, si tu utilise ce code :

int passage = 0;

interruptionEvenement() {
    passage++;
    aquitementInterruption();
}

loop() {
    grosTraitement();
}

L'interruption vient interrompre le gros traitement et tu ne rates rien.

Après, tu pourrais dire : "et si j'ai énormément d'évènement, certains seront ratés non ?"

Oui, mais dans ce cas, cela signifie que ton petit arduino n'est tout simplement pas assez puissant pour gérer ton problème

farco a écrit:

Et du coup question sur cette interruption de programme :

entre l'arret du programme et son traitement, le roue continue à tourner...

Il va donc être possible de récupérer un grand nombre d'information, mais on risque rater des informations entre 2 traitements non ?

Pas si tu cales bien tes IT. En gros tu as les IT extérieures qui sont issues d'un passage de niveau 0 à 1 ou l'inverse, et donc détectables très facilement. Louper une interruption potentielle ça a deux causes ici : temps de traitement trop long (solution en dessous) ou fréquence du signal beaucoup trop rapide.

Pour avoir un temps de traitement court, au pire ton IT doit placer une variable dite de verrou à une certaine valeur, puis tu sors de l'it, et c'est ton programme principal qui traite. En général on admet qu'une interruption doit avoir le temps de traitement le plus court possible, afin de ne rien rater. Mais là encore ça trouve ses limites au temps de traitement de l'Arduino. Vois si tu peux choper le fichier LST généré à la compilation : il te donnera les instructions en assembleur (me rappelle plus si l'Arduino, du moins son logiciel, le fait mais normalement si...). Tu pourra voir à peu près ainsi par calcul le temps que nécessite ton "gros traitement" sur chaque Arduino. Si le UNO a une fréquence trop basse, tu peux passer au Due...mai splus compliqué à gérer d'un point de vue alim (3.3V).

Pour les IT internes, comme les timers, etc, les consignes sont en soit les mêmes.

L'arduino est équipé d'un uC obsolète mais il a quand même quelques timers-compteurs de dispo...

Tu as le choix :

1) un timer en mode compteur, compte les impulsions sur une entrée, une interruption toutes les secondes (par exemple) relève la valeur du compteur, ou bien une interruption déclenchée toutes les x impulsions regarde le temps que ça a pris

2) un timer en mode capture, mesure la période du signal en entrée, une interruption à chaque période relève la valeur et effectue le calcul

3) remplacer le timer en mode capture par du soft (post du dessus)

le choix de la bonne solution dépend de la fréquence du signal à mesurer et du nombre de timers dispo.

-
Edité par Lord Casque Noir 16 juillet 2013 à 9:13:41

Bonjour,

Avec vos conseils J’ai réalisé mon compteur de vitesse.

Je fais évoluer mon projet en ajoutant un module « totalisateur de kilomètres »

Les km sont enregistrés sur une carte SD.

A l’alimentation du compteur je lis bien mon kilométrage sur ma carte, mais je ne trouve pas la fonction pour convertir une variable alphanumérique en variable numérique.

Pouvez-vous m’aider ?

Merci

Philippe G

Bonjour

J’ai essayé d’utiliser « atoi » cela ne marche pas. Je ne dois pas programmer correctement.

Voici non bout de code « récupération des données sur SD »

 // lecture du contenu du fichier  

  dataFile=SD.open(nomFichier, FILE_READ); // ouvre le fichier en lecture - NOM FICHIER en 8.3 ++++

// un seul fichier ne peut etre ouvert à la fois - fermer au préalable tout fichier déjà ouvert

  Serial.println("------");

String contenuFichier=""; // chaine pour stocker contenu fichier

  if (dataFile){ // le fichier est True si créé

    Serial.println("Ouverture fichier OK");

    while (dataFile.available()) { // tant que des données sont disposnibles dans le fichier

// le fichier peut etre considéré comme un "buffer" de données comme le buffer du port série

char c = dataFile.read(); // lit le caractère suivant

      Serial.println(c); // affiche le caractère courant     

contenuFichier=contenuFichier+c; // ajoute le char au String 

    } // fin while available

    dataFile.close(); // fermeture du fichier obligatoire après accès

    Serial.println("Contenu du fichier : ");

    Serial.println(contenuFichier); // affiche le contenu du fichier

  } // si fichier existe

  else { // sinon = si probleme creation

    Serial.println("Probleme creation fichier");

  } // fin else

} // fin setup

Je souhaiterai transformer cette variable StringcontenuFichier en int contenuFichier pour

Programmer par exemple 

contenuFichier = contenuFichier * 2

Pouvez-vous décrire la bonne syntaxe de programmation.

Merci

Salutations

Philippe 

Avec des balises code, ce serait mieux

Sinon, atoi, c'est pour convertir des chaines de caractères type C (des char* ou char[]).

Si tu utilises la classe String de arduino, tu peux tout simplement utiliser la méthode toInt.

EXEMPLE:

void setup {

    Serial.begin(9600);

    String str = "21";

    Serial.print("s=");
    Serial.println(s);

    int i = str.toInt();
    int j = ( ( i * 2 ) + 5 );

    Serial.print("i=");
    Serial.println(i);
    Serial.print("j=");
    Serial.println(j);

}

void loop() {

}
    

Je te remercie la méthode « toInt() »  fonctionne bien.

Je vais pouvoir finaliser mon projet.

Salutations

PhilippeG

Bonjour,

Je cherche un petit programme qui pourrait décompter le temps. 

Toute aide est la bienvenu ! 

Merci !!! 

Mel

Bonjour,

Je cherche un programme qui pourrait décompter le temps.

Toute aide est la bienvenue !!

Merci !!! 

Mel

Bonjour MelColetti,

Sur quoi bloques tu exactement ?

La fonction millis te retourne le nombre de millis secondes depuis que la carte arduino est allumée.

Avec la valeur retournée, tu peux donc largement compter et décompter le temps qui s'écoule

Bonjour a tous,

Je suis un peu pommé sur le code de lorrio déposé le 15 Juillet 2013.

J'essai de faire tourner un code super vite avec une "queue" pour échanger des trames en TCP/IP

Le souci en faite c'est que je voudrais faire 2 taches en même temps sur un arduino Mega 2560, résultat lorsque je passe devant un capteur il m'arrive de le rater.

Savez vous comment faire des taches cyclique ou périodique sur Arduino???

Merci pour le coup de pouce!

Si ton capteur est reliée sur une pin attachée à une interruption, ton programme sera temporairement mis en pose pour exécuter la fonction d'interruption.

Avec cette technique, il est donc théoriquement impossible de rater un évènement.

Mais si tu tiens vraiment à faire une petite action périodiquement, tu peux utiliser un timer couplé à une interruption.

A fois fois que le timer annonce qu'il a finit de compter, il déclenche une interruption donc ton programme sera temporairement mis en pose pour exécuter la fonction d'interruption.

A noter que pendant une interruption, toutes autres demandes d'interruptions sont placées en file d'attente de traitement.

Du si tu utilises ton capteur sur pin d'interruption mais que tu as une autre interruption qui s'éternise dans ton code, tu peux rater un évènement.

A noter aussi que l'arduino est un processeur 8 bits qui fait ses calculs sur 8 bits donc tu lui demandes un calcul sur 16 bits (type int par exemple), il est obligé de le faire en 2 fois.

Par contre, ton interruption peut très bien se produire en pleins milieux des 2 opérations donc il est impératif de protéger les variables utilisées dans le code normal et dans les interruptions.

Je souhaiterais mettre un debimetre en amont du tuyau de ma douche afin de calculer un volume en tant reel. Le tout devra être  relié a des led afin de faire un jeu de couleur en fonction de la consommation de la douche. 

Le fait de mettre un timer va interrompre va t'il interrompre mon debitmetre ?

salut svp je veux avoir un programme sur arduino qui permet de calculer le temps d'arrêt d'une machine. je voudrais savoir la bibliothèque a utiliser et la fonction utilisée pour calculer le temps d'arrêt. merci

Plutôt que de t'incruster sur un vieux sujet, tu ferais mieux d'en ouvrir un nouveau

Mais dans tous les cas, on ne va pas faire le code à ta place.

Sur arduino, il y a la fonction millis qui renvoie le temps en ms depuis que la carte arduino est allumée.

A toi de t'en servir judicieusement pour calculer tes temps d'arrêt.

Même remarque que précédemment... plutôt que de t'incruster sur un vieux sujet, tu ferais mieux d'en ouvrir un nouveau.

Tu devrais aussi chercher RPM meter arduino sur google, tu trouveras pleins d'exemple de code

De quelle commande parles tu ?

Avec la fonction millis qui compte le temps ?

Oui, c'est théoriquement possible.

Mais il ne faut pas oublier que le quartz de l'arduino n'est pas extrêmement précis.

Et qu'il y a aussi le temps de latence de l'interruption qui compte le temps.

Au final, on pourrait dire que la fonction millis est précise à quelques pourcent prêt.

Donc quand millis donne un résultat de 3600000, il ne s'est pas forcément écoulé 1h mais peut-être 1h et 30 secondes.

Une horloge qui dérive de quelques secondes par heures, ça ne le fait pas trop...

Si tu veux faire une horloge avec un arduino, mieux vaut l'équiper d'un RTC pour assurer la fonction de gestion du temps.