Problème sur boucle Do...While.

Bonjour à tous ceux qui liront ce message.
Je cale sur ce petit bout de code, j’aimerais que les trois valeurs que je demande d’afficher sur le moniteur série ne s’affiche qu’une fois.
Que manque-t-il pour que cela fonctionne et que l’affichage s’arrête…Actuellement ça tourne en boucle.
Merci pour vos réponse et votre aide.

int age = 38; 
int *pointeursurAge = &age;
int compteur = 0;
int touche = 0;

void setup() 
{

Serial.begin(9600);  // put your setup code here, to run once:

}

void loop() 
{
  do{ 
  Serial.println('&pointeursurAge');// put your main code here, to run repeatedly:
  delay(500);
  Serial.println('pointeursurAge');
  delay(500);
  Serial.println(*pointeursurAge);
  delay(500);
    compteur++;
    }while(compteur < 1);
}]

Bonjour,

Comme c'est indiqué dans le commantaire "// put your main code here, to run repeatedly"

Si tu veux exécuter ton code une seule fois mets le dans le setup.

De plus Serial.println('&pointeursurAge') et Serial.println('pointeursurAge') ne font sans doute pas ce que tu veux. Si tu veux afficher leur valeur enlève les ', mais il faudra certainement les caster en unsigned ou en int.

Bonsoir,
Ou tu fait comme dit Kamill ou tu utilise while

 while(compteur < 1){  // ou if(compteur < 1)   
........
    compteur++;
    }

Après il y a aussi le problème de ce que tu veut afficher

Relire la doc sur la différence entre while(condition) statement et do statement while(condition)le moment où se fait le test et donc l’exécution du statement n’est pas identique

Relire la doc sur la différence entre

Il y a quelque chose qui m’échappe?

J-M-L:
Relire la doc sur la différence entre while(condition) statement et do statement while(condition)le moment où se fait le test et donc l’exécution du statement n’est pas identique

Justement comme le dit savoriano si on utilise la première instruction le fonctionnement est celui recherché.

bonsoir,

à quelle fréquence se fait l’affichage ?

un “int” est un objet 16 bits sur arduino (de mémoire) et donc compter “+1” 65536 fois est super rapide pour un µC comme l’ATMega328 cadencé à 16MHz, du moins pour notre façon humaine de percevoir cette vitesse d’exécution.

est-tu sûr que ces affichages ne sont pas le fruit d’un débordement de ton compteur ? le µC peut faire au minimum 1 million de soustractions par seconde dans une boucle alors que ta liaison série réglée à 9600 Bd ne transmet qu’environ chaque ms

si tu veux stopper ton affichage, il faut brider ton compteur pour qu’il n’atteigne jamais sa valeur maxi, sinon il repassera indéfiniment en dessous de “zéro” et provoquera l’affichage suivant ta condition : n’oublie pas qu’au passage à la valeur maxi d’une variable signée on retombe à sa valeur mini, ici pour un “int” (16 bits, non signé) on passe de +32768 à -32767, donc tu te retrouves avec 32768 valeurs inférieures à ta valeur de consigne (<1), ce qui provoque une flopée d’affichages … et tu as de la chance : c’est seulement pendant la moitié du cycle …

mais même si tu utilisais un entier signé il y aurait ce passage à “zéro” qui provoquerait l’affichage : une fois toutes les 65536 boucles …

savoriano:
Il y a quelque chose qui m’échappe?

non - c’était pour l’OP. J’aurais dû être plus clair dans cette réponse.

——
@ 5_cylindres
C’est un bon point

Non seulement au début L’affichage se fait parce qu’il est demandé à chaque tour de loop Indépendamment de la valeur du compteur mais à la 32768eme loop il y’aurait eu toute une flopée d’affichages à cause du débordement

l’OP n’a sans doute pas attendu suffisamment devant sa console pour le voir cependant car la première limitation temporelle vient des delay() pour 1.5 secondes dans le do-while et donc cet effet débordement ne se verra que dans 49 152 secondes (soit 13 heures et 40 minutes environ) et ne sera pas visuellement perceptible / différent de la loop qui boucle sauf que ce sera le do-while qui va boucler en réalité

J-M-L:
... des delay() pour 1.5 secondes dans le do-while ...

justement, c'est une boucle "do{}while()".
on se moque donc (ici) totalement du résultat de la comparaison, elle sera exécutée à chaque rebouclage de la "loop{}" ... avant le test !

la fréquence période d'affichage des messages est donc d'1,5s (+ temps d'exécution des instructions).

Oui - tout a fait - sur ce point

es-tu sûr que ces affichages ne sont pas le fruit d'un débordement de ton compteur ?

Effectivement on « s’en moque » sauf au bout de 13 heures et 40 minutes où votre point précédent prend alors tout son sens Car la condition du do/while devient vraie (bien vu personne d’autre n’avait percuté sur ce point).

Les delays font que le débit en baud n’a pas d’importance dans ce cas par mais si on supprime ces délais alors votre autre point est aussi important car print devient bloquant dès que le buffer de 64 octets sera plein - à raison de 10 caractères par seconde ce sera alors le facteur limitant sur la vitesse d’exécution du code

Bref - Problème principal: utilisation de do/while au lieu de if (ou while mais pas vraiment l’instruction adaptée).

Les Problèmes connnexes que vous avez cités sont cependant très bien vus et à garder en tête

J-M-L:
dès que le buffer de 64 octets sera plein

il s’agit d’une émission sur le port série, pas d’une réception : le buffer de l’objet Serial ne sera jamais plein, et de toute façon le moniteur série (sur PC ou autre) est bien plus rapide qu’un petit µC cadencé à 16MHz.

les erreurs dans ce code ont déjà été listées :
les guillemets autour des noms, l’envoi dans la boucle qui se répète, etc…

sans trop modifier le code, int compteur = 0 peut simplement être remplacé par int compteur = 1 (ou toute valeur supérieure) et l’affichage ne se fera qu’une fois en virant compteur++ de la boucle … méthode de sauvage, je sais.

c’est peut-être aussi l’occasion d’(apprendre à)utiliser un booléen ?

il s'agit d'une émission sur le port série, pas d'une réception : le buffer de l'objet Serial ne sera jamais plein, et de toute façon le moniteur série (sur PC ou autre) est bien plus rapide qu'un petit µC cadencé à 16MHz.

Pas sûr de ce que vous voulez dire - Peut-être faites vous référence au fait qu’il y a des delay() Dans ce code et vous ne parlez pas du cas général ?

Pour clarifier ce que je disais (pour le cas général car j’avais dit « mais si on supprime ces délais « )

Le buffer d’émission fait aussi 64 octets. Quand vous faites un Serial.print() le contenu à imprimer est stocké dans la buffer (Circulaire) et la fonction retourne instantanément. Cependant s’il n’y a pas la place dans le buffer (soit vous voulez envoyer plus de 64 octets soit il y en avait dans le buffer et ce que vous rajoutez dépasse les 64) alors la méthode print() reste coincée (dans le write() sous jacent) le temps que la place soit disponible (Serial fonctionne par interruption et donc ça se vide en tache de fond. )

Que le PC soit super rapide n’a pas d’importance, c’est L’Arduino qui donne la cadence en fonction de son débit en bauds. Le PC de l’autre côté ne fait que écouter et effectivement pas de souci de taille de buffer pour les usages classiques sur un PC / Mac ou avec un OS un peu moderne.