39 réponses à ce sujet

[Ludovic Dille]

Hello le soucis vient de ton test.
Lorsque tu mets cette instruction: "distance =( count/1200)*2"
Ça veut dire mets dans la variable distance le calcul suivant count/600 hors la variable count est remise aussi à 0 et donc à vitesse constante la variable count est constante

Ce que tu veux faire c'est intégrer ta vitesse donc

distance = distance + speed * dt

qui peut se simplifier en

distance += speed * dt
Qui maintenant veut dire rajoute à distance la valeur speed * dt
Et attention quand je dis speed * dt faut garder des unités cohérentes si ta vitesse est en km/h il faut alors avoir dt en heures pour qu'il te calcule une distance en km
 

[Nico47]

Ouais c'est pas faux 😀

Ok merci.

Je comprends le raisonnement, je me doutais bien que le fait de remettre count à zéro ne devait pas aider.

J'arrive à suivre l'opération, mais ce "dt" il sort d'où ??

[Sandro]

ce dt, c'est la période de l'intéruption (timerIsr), soit 0.1s (nb : il faut convertir en heures si ta vitesse est en km/h). Donc dt=0.1/60/60

 

Alternativement, tu peux calculer directement le count total, et l'utiliser pour calculer la distance parcourue depuis l'alummage du programme :

- tu crées une variable globale (en volatile) : volatile uint32_t total_count=0;

- juste avant de faire count =0; tu ajoutes total_count= total_count + count;    (ou total_count += count;)

- tu peux ensuite appliquer ton calcul que tu voulais appliquer à count (   distance =( count/1200)*2     )  en remplaçant count par total_count (nb: je suis pas certain sur le facteur deux, mais c'est plus simple de tester que d'essayer de vérifier de manière théorique)

[Mike118]

 

Petite question aussi, pourquoi dans les déclaration speed apparait en rouge??

 

Les variables qui apparaissent en rouge / orange ( ou de manière générale d'une autre couleur en fonction de l'IDE que tu choisis ( IDE = logiciel que tu utilises pour programmer ) sont des mots clefs qui ont été listées  par l'IDE ( par exemple l'IDE arduino ) comme " spéciaux " et devant apparaître "différemment ". Dans l'IDE arduino au  même titre tu as les mots clef pinMode, Serial et beaucoup d'autre  etc ... Sur le principe tu peux utiliser speed comme variable mais il est vrai que si il apparaît en rouge ou orange, mieux vaut éviter d'utiliser ce nom de variable pour éviter de prêter à confusion... 
 

Après quand je disais de poster le code, je parlais de le poster avec l'erreur On aurait ainsi pu être sûr de l'erreur commise pour l'expliquer ... 

 

Voici comme promis un code modifié Je te laisse prendre le soin de trouver le coefficient permettant de convertir le nombre de tick dans l'unité d'affichage souhaité. 
PS : pour améliorer la résolution je me suis permis de déplacer le / 2 ... 

void timerIsr()
{
    speed = count;              // on a le nombre de tick ( signé ) par unité de temps  = vitesse
    distance += count;          // Distance totale parcourue exprimée en ticks, Valeur signée
                                // à remplacer par distance+= count * coeff, avec coeff permettant de passer de ticks à unité souhaité
                                
    vitesse=speed*0.002*60/2;   // on multiplie par 0.002 (perimetre en km) on multiplie par 60 pour obtenir km/h
                                // multiplie par 10 on obtient tick/second divise par 1200 on obtient tour/second multiplie par 60 on obtient tour/min plus simplement on divise par 2.
    
    
    count=0; // On remet le compteur de tick à 0 
}

Note : Les remarques de Ludovic et Sandro avec vitesse et delta de temps ne sont pas fausse, au final c'est un peu la même chose que ce que je te propose, mais je le fais sans passer par la variable intermédiaire de vitesse ...  D'ailleurs c'est exactement ce que propose aussi Sandro en " alternatif "

 

[Nico47]

Ok, ce n'est pas tout clair pour moi mais ça me fait avancer.

Si tu déplaces le /2 speed qui est en tr/min n'est plus une vitesse juste par rapport à la réalité ???

[Mike118]

Pour éclaircir un peu : 


Quand ton moteur fait 1 tour, tu as parcourue une distance D et un nombre de tick T.  T et D sont deux constantes. 


en notant d un petit morceau de distance parcourue par rapport à un nombre t de tick; tu as d = t * D / T 

Dans le code ci dessus, t = count. 
                                       d = count * D / T    
                                       coef = D /T
D et T tu dois les trouver avec ta configuration ( je crois que tu l'as même déjà écrit dans les messages précédents) 

d c'est un bout de distance que tu as parcourue à un moment donné. 

Pour comptabiliser toutes la distance que tu as parcourue il faut sommer tous les d au fur et à mesure que tu les calculs.

D'où la ligne : 

distance += count * coef 

 

qui peut se traduire par 

distance = distance + d . 

Est ce un peu plus clair maintenant ?

[Nico47]

Ok
Donc le coef c'est la distance parcourue par tick.

Dans mon cas
une roue ( et non un moteur) de 2 mètre de périmètre

Et 1200 tick par tour.

Coef = 2/1200 = 0.00166666666

[Mike118]

Oui c'est ça tu peux écrire 
 

distance += count / 600.0;     // Préciser 600.0 au lieu de juste 600 c'est pour expliciter que tu veux un nombre à virgule comme résultat de l'opération...

[Nico47]

Si je comprends bien, le programme fait un "échantillonnage" du nombre de tick pendant une période donnée (0.1 s en l'occurrence) calcule par la suite avec cet échantillon une vitesse de rotation, une vitesse d'avancement et une distance, et ce tant que des changements sont détectés sur la pin 2.

[Mike118]

Le programme compte tous les ticks lorsque des changements arrivent sur la pin 2 ( interruption sur changement d'état ) , tout ces ticks comptés sont stocké dans la variable count.

Toute les 0.1s ( période que tu règles ) une interruption sur timer se déclenche et dans cette interruption, tu stocks le nombre de ticks qui ont été compté (count)  dans une variable  speed qui contient donc le nombre de ticks compté en 0.1s ( période d'occurrence de l'interruption sur timer ).  Et on remet count à 0 pour qu'il puisse compter convenable tous les ticks qui vont avoir lieu lors du prochain intervalle de 0.1s. 

Count représente donc bien une unité de " distance parcourrue " en tick, parcourrue pendant un laps de temps dt fixe ( 0.1s ) 

En " intégrant " cette information en continu ( calcul d'intégrale = Somme en continue ) tu obtiens la " distance totale parcourrue depuis le début ( en ticks, ou dans l'unité de ton choix en appliquant le coefficient adapté ) 
Grâce à cette information , en appliquant là  aussi le coefficient adapté tu peux connaître la vitesse dans l'unité de ton choix, speed étant par défaut une vitesse exprimée en ticks par 0.1s ... 

 

Si aucun changement n'est détecté sur la pin 2, count ne sera pas modifié mais quand même mis à 0 à chaque fois toute les 0.1s . Les calcule de vitesse donneront toujours 0 et la distance totale parcourrue restera fixe car distance += 0  ne changera pas la valeur de distance totale parcourrue .


J'espère avoir bien résumé le programme sans t'embrouiller .

[Nico47]

Pas d'embrouille, au contraire ça eclairci le fonctionnement.

Cela fonctionne, j'ai quelques chose de cohérent, en tr/min, km/h et distance en mètre.

Pour la surface c'est pas encore ça.
Je veux une surface en hectares (ha. 10000 M2)

J'ai donc créé deux variables de plus.
constante largeur outil= 3.00 mètre

volatile double surface= 0

Surface= (distance×largeur)/10000 pour avoir des ha et non des M2

J'ai donc une surface désigné ainsi 0.00ha
Mais lors du comptage il compte "large" en cause le fait qu'il arrondi les decimales

J'ai fait un test avec une surface en M2 et une surface en ha.

Quand le compteur arrive à 51m2 il compte automatiquement 0.01 ha (100m2).

C'est vraiment pas top niveau précision.

Faudrait il finalement tout calculé en mètres pour ne faire qu'une simple conversion en ha a la fin ??

[Sandro]

Bonjour,

je ne peux pas être totalement catégorique sans voir ton code a jour (une bonne pratique est de poster ton code à jour à chaque nouvelle question, comme ça on est sur de parler de la même chose).

 

Il ait possible qu'il y ait de gros arrondis (par exemple si tu utilises une variable de type entière (int, uint32_t, ...) à un moment où il faudrait utiliser float ou double.

 

Néanmoins, le plus probable me semble que ce soit simplement un problème d'affichage : par défaut, Serial.print et Serial.println n'affichent que deux chiffres après la virgule. Par conséquent, 49m² = 0.0049 ha, sera arrondi a 0.00 ha, alors que 51m²=0.0051 ha sera arrondi à 0.01 ha.

Néanmoins, on peut préciser explicitement le nombre de chiffres après la virgule :

Serial.println(1.23456);     //affichera 1.23
Serial.println(1.23456,0);   //affichera 1
Serial.println(1.23456,1);   //affichera 1.2
Serial.println(1.23456,2);   //affichera 1.23
Serial.println(1.23456,3);   //affichera 1.234
Serial.println(1.23456,4);   //affichera 1.2345
// ...

NB : la même chose fonctionne avec Serial.print

 

A noter que la précision des nombres floatant sur arduino (float et double, qui sur arduino sont identiques) est limités à 7 chiffres au total (ie on compte aussi les chffires avant la virgule). Sachant qu'en plus, les erreurs peuvent se cumuler au cours des calculs. Donc je déconseille de compter sur plus que 4-5 chiffres au total.

[Mike118]

Faudrait il finalement tout calculé en mètres pour ne faire qu'une simple conversion en ha a la fin ??

 

C'est une façon de faire oui. Après là encore si tu postes ton code avec " l'élément qui ne te convient pas " on pourras voir où est le problème et te corriger uniquement cette partie. =)

 

EDIT : Je me suis fait devancer par Sandro qui a je pense évoqué un problème pertinent concernant l'affichage.

[Nico47]

Voila voila. 

 

Et merci pour les explications.

 

 

 

donc je devrais inscrire

 

Serial.println(surface ,3);

 

ou simplement

 

Serial.println(1.23456,3) et toutes mes variables seront affichées avec 3 decimale??

[Mike118]

Oui en mettant 3 tu auras 3 décimales et en effet au vu du code c'est uniquement un problème d'affichage de décimales comme ce que disait Sandro =) 

Autre remarque comme ça en passant, tu n'es pas obligé de faire le calcul de surface dans l'interruption, tu peux le faire uniquement au moment où tu en as besoin. 
De plus si tu veux ralentir un peu l'exécution du loop tu peux par exemple faire comme ça : 

 

// Prérequis savoir utiliser un timer 
#include <TimerOne.h> // Pour le timer


// Prérequis savoir utiliser les define
// Partie à modifier pour indiquer en define quel pin est branché où A et B à brancher sur 2 et 4
#define ENCODEURA 2
#define ENCODEURB 4


// prérequis : volatile => pour toute variable qui sera utilise dans les interruptions 

volatile int count =0; // comptage de tick d'encoder  qui sera incrémenté sur interruption " On change " sur l'interruption matériel 0 qui se fait sur le pin 2
volatile double speed =0; // vitesse en tr/min 
volatile double vitesse =0; // vitesse d'avancement en km/h
volatile double distance =0; // distance en metres 
double largeur_outil = 3.00; // largeur du semoir en metres
double surface = 0;  // surface en ha
volatile byte laststate =0;  // etat précédent de l'encodeur
volatile uint8_t nbInterruptTimer = 0;


void setup()
{
// on initialise les entrées et sorties
 pinMode(ENCODEURA, INPUT_PULLUP);
 pinMode(ENCODEURB, INPUT_PULLUP);
 
 
attachInterrupt(0,counter, CHANGE); // on crée l'interruption sur changement sur la pin 2 => interruption 0, la routine counter va se faire toute seule sans l'appeler à chaque changement d'état sur le pin 2

Timer1.initialize(100000); // On défini le timeur : 100000 microseconds ( 0.1 sec - or 10Hz )
Timer1.attachInterrupt( timerIsr ); // attach the service routine here la fonction timerIsr est une routine qui va se faire automatiquement 10* par secondes sans l'appeler

Serial.begin(9600);
}

void loop()
{

if(nbInterruptTimer >= 10) {  // permet de limiter le nombre d'affichage à 1 fois par secondes car 10* 0.1s
  Serial.println("vitesse");
  Serial.println(vitesse); 
  surface = (distance*largeur_outil)/10000;// distance en metre et largueur en metre /10000 pour avoir ha 
  Serial.println("surface");
  Serial.println(surface, 4);
  Serial.println("distance");
  Serial.println(distance);
  nbInterruptTimer = 0;    // on remet le compte à 0 pour pouvoir recompter de 0 à 10 les prochaines interruptions
 }

}


// Encoder counter 0

void counter()
{
  byte state=PIND;
  
  state|=B11101011;  // mask pour ne regarder que les changements sur 2 et 4 
  // Modifier le MASK  B01111011 par BXXXXXXXX mettre des 0 là où sont les pins utilisés par l'encodeur
  if( state!=laststate)
  {
    (((state&(1<<ENCODEURA))>>ENCODEURA)^((state&(1<<ENCODEURB))>>ENCODEURB))?count--:count++;
    laststate=state;
  }
  
}


// Timer event to calculate speed from counters

void timerIsr()
{
    speed=count/2;              // on a le nombre de tick ( signé ) par unité de temps  = vitesse
                                // multiplie par 10 on obtient tick/second  divise par 1200 on obtient tour/second  multiplie par 60 on obtient tour/min plus simplement on divise par 2.
    vitesse=speed*0.002*60;     // on multiplie par 0.002 (perimetre en km) on multiplie par 60 pour obtenir km/h
    distance +=count/600.0;     // count*2(perimetre)/1200(tick par tour)
    count=0;                    // On remet le compteur de tick à 0 
    nbInterruptTimer++ ;        // Permet de compter le nombre d'interruptions effectuées
}

[Nico47]

Ok tu m'as devancé, je voulais justement savoir si ce n'était pas gênant d'avoir autant de calcul dans la boucle isr.

[Mike118]

En effet sur le principe de manière générale il faut faire en sorte de faire des boucles d'interruptions courtes ( que ce soit l'interruption sur Timer ou l'interruption sur changements ) . 
Donc on évite d'y mettre 300 lignes de codes très longue à exécuter.

 

Là dans ton cas précis les calculs en question sont très très très petits donc ce n'était pas grave du tout. C'était plus pour montrer ce qui est possible de faire ... 
En plus il faut savoir que là ta boucle loop  vu qu'elle ne fait pas grand chose s'exécute plus souvent que l'interruption sur Timer, donc sans le if que j'ai ajoutée avec le nbInterruptionTimer >= 10, il était plus rentable de faire le calcul comme tu le faisais dans l'interruption plutôt que dans le loop. 
Là avec le if en question on a diminué par 10 l'appel au calcul de la surface pour ne l'appeler que quand on en a besoin ( = avant de l'afficher ) . 



 

[Nico47]

Bonsoir a vous.

Merci pour l'aide, niveau compteur ca fonctionne.

J'ai donc voulu aller voir plus loin et m'attaquer au coté affichage.

Ecran 20x4, connecté I2C et plein de petits tests pour me familiariser au fonctionnement.

 

Donc en me servant d' un tuto you tube et du code qui va avec j'ai réussi a faire un quelque chose qui me plait.

Un menu:

Menu semoir => écran de travail ou je regroupe *vitesse d'avancement, *surface du travail en cours, *turbine ( surveillance rotation), *alarme ( semoir vide et autre souci).

Largeur semoir => la ou je pourrais modifier la largeur du semoir.

Surface=> deux compteur, un que l'on pourra remettre a zéro, et un total intouchable.

Etalonnage=> un truc que j'ai derrière la tête on y reviendra.

 

 

J'ai rajouté un bouton ( pin 9 menuButton) dans l'idée qu'une fois rentré sur un des sous menu je puisse revenir "en arriere" sur le menu principal.

 

Et voila ou j'en suis, si je supprime les delay je ne rentre pas dans les menus, la je comprend.

 

J'ai donc allongé delay dans void action1 et essayé plusieurs solution pour revenir sur le menu principal if, while….. mais sans succès, ca ne fonctionne pas.

 

J' aimerai savoir si mon idée  est réalisable avec ce code ou si celui ci n'est valable que pour réaliser une seule action a chaque sous menu.

 

Pour moi il faut que je cherche du cote de void executeAction,  bonne ou mauvaise idée??

 

Juste un petit coup de pouce merci.

[Sandro]

Bonsoir,

 

Je ne suis pas sur de comprendre exactement où et comment tu veux revenir en arrière.

- Si le but est de garder l'affichage des "actions" jusqu'à ce que tu appuis sur le bouton retour arrière (au lieu d'un délai fixe), alors ils suffit de remplacer le delay par

while(!digitalRead(bouton_arriere)) ;

-si le but est d'avoir deux niveaux (ou plus) de menus encastrés :

 

si revenir d'un cran en arrière te suffit, alors tu peux créer une variable "prev_menu" à laquelle tu donne la valeur de l'endroit où tu est actuellement juste avant de le quitter. Si tu appuis sur le bouton arrière, tu fais menu=prev_menu et tu actualise.

 

A noter que ça ne permet pas de remonter plus d'un cran en arrière.

 

Une alternative, ce serait de définir pour chaque menu quel est son "parent", et du coup faire menu=parent lorsqu'on appuie sur le bouton arrière.

[Nico47]

[quote name="Sandro" post="112988" timestamp="1613166434"]

Bonsoir,
 
Je ne suis pas sur de comprendre exactement où et comment tu veux revenir en arrière.
- Si le but est de garder l'affichage des "actions" jusqu'à ce que tu appuis sur le bouton retour arrière (au lieu d'un délai fixe), alors ils suffit de remplacer le delay par

while(!digitalRead(bouton_arriere)) ;

👍 C'est tout à fait ça !!

J'y ai passé quelques heures, sans grand résultat et je crois même que je l'ai testé cette solution, mais il arrive un moment où tout s'emmêle et où je me perds.
Dans ces cas là, c'est qu'il est temps d'aller au dodo 😂