j'ai un programme qui prend en conte sa vitesse de lecture, je fait une bête soustraction du millis pour avoir le Temp par boucle , quand je l'affiche sur le moniteur série celle si reste plus ou moins constante , à deux trois milliseconde prés , logique le programme n'utilise pas de boucle for ou while. mais déjà première petite question , pourquoi la variable n'est elle pas strictement constante ? quel sont les autre chose qui peuvent la faire varier? cela na pas trop d'importance , sa na pas trop d'impacte sur le programme simple curiosité.
venons en cœur du problème, quand je change le baud du moniteur série la vitesse n'est plus la même mais reste bien plus ou moins la même à chaque boucle.
j’arrive à avoir un Temp boucle très petit en métant le baud au max pour mon arduino uno (2000000).
mais mon programme et voué à se débrouiller seul par la suite sans moniteur. quel seras sa vitesse ?
la même que pour un baud maximum ou plus?
cela m’intéresse car cela me permettrais d'avoirs une précision meilleur.
voici mon jolie programme entièrement fais maison pour les curieux.
// variable temporelle
float tempjeu = 0.0;//temps depuis le lenssement du jeux
float tempprog = 0.0;// temps soustrayant les poses du aux arrets imprévus sur le parcour et les periodes de rotation.
const float finjeu = 100000.0; // temps de fin de jeux en mili seconde arréte le robot dans tout ces déplacement et action
float tempboucle = 0.0; // temp entre chaque boucle pour calculer l'étape la position à chaque boucle
float ecartp = 0.0; // variable calcule servant de repaire au tempboucle
//variable de condition
int contact = 1; // varible on off coup d'envois
int danger = 0;// détection d'un obstacle imprévus arrêt du véicule
int contboucle = 1; // variable contant les boucle pour afiché sur le moniteur que tout les x boucle et ne pas le debordé tout en le gradant sufisament rapide
//variable de calcule spatial
const float sud = 1500*PI; // orientation primaire utile en milli radiant
const float nord = PI*500;//...
const float est = 0.0;//...
const float ouest = PI*1000;//...
const float vmaxrec = 0.05;// vitesse max sur sol plat en mm par milli seconde
const float vmaxcirc = PI/12;//vitesse max circulaire sur sol plat en milliradant par milliseconde
float x = 0.0; // position d'origine en x en mm
float y = 0.0; // position d'origine en y en mm
float oriente ;
float n = 2.0;// marge de degrée pr arivé à l'orientation voulu se calcule en faisant vmaxcirc*tempbouclemax
float tempbouclemax = 0; //permet de calculé la magre de degrée n en fonction de la vitesse minimal du programe
float degresReel = PI*500; //direction de la tête du robot dans le repére x y en mradiant radiant au démarage
//tableau des trajectoire
int etape = 0; // étape dans l'avancement du programme
const int B = 5; //nombre d'étape
float parcour [3][B]{{500.0,600.0,600.0,200.0,4000.0},// déterminé la distance en mm
{nord,sud,est,ouest,PI*250},//déterminer la direction tableau servant d'interface pour stocker la trajectoire et les action à réaliser en degrée
{0.0,0.0,0.0,0.0,0.0,}}; // temprograme équivalent à l'éatape
void setup() {
Serial.begin(2000000);
oriente = parcour [1][0];
//remplire la derniére ligne du tableau
parcour [2][0]= parcour [0][0] / vmaxrec;
for (int i = 0 ; i <= B-1 ; i++){
parcour [2][i+1] = parcour [2][i] + (parcour [0][i+1] / vmaxrec);
}
for (int i = 0 ; i <= B-1 ; i++)
{
Serial.print("etape:");
Serial.print(i);
Serial.print(" ");
Serial.print("distance:");
Serial.print(parcour[0][i]);
Serial.print(" ");
Serial.print("orientation:");
Serial.print(parcour[1][i]);
Serial.print(" ");
Serial.print("temps cumulé:");
Serial.print(parcour[2][i]);
Serial.println(" ");
}
}
void loop() {
if (contboucle >= 50){contboucle = 0;}
contboucle = contboucle + 1;
// detecter le coup denvois
if (contact == 1){
//prise de valeur capteur//
// detecter un obstacle imprévut
//lecture détape //
if ( tempprog >= parcour [2][etape]){etape = etape + 1;}// faire evoluer la trajectoire
oriente = parcour [1][etape];//lire l'orientation visé
Serial.print(" oriente = ");
Serial.print(oriente);
Serial.print(" degresreel =");
Serial.print(degresReel);
Serial.print(" etape = ");
Serial.print(etape);
Serial.print(" n = ");
Serial.println(n);
if (danger == 0){
//gestion spatial//
//determiné la marge de précision en fonction de la vitesse du programe
if (tempboucle>tempbouclemax){tempbouclemax = tempboucle;
n = tempbouclemax*vmaxcirc/2;}
//gestion d'avancé rectiligne
if(((cos(oriente/1000)<cos(n/1000))&&(abs(oriente-degresReel)<=n))||((oriente-n<=0)&&((degresReel<=oriente+n)||(degresReel>=oriente-n+2000*PI)))||((oriente+n>=2000*PI)&&((degresReel<=oriente+n-2000*PI)||(degresReel>=oriente-n)))){ //si degresReel convient à l'orientation demandé avec une marge n (prenant en conte les écart n entre N et 2PI- n)
Serial.print("// orientation corecte//");
x = x + cos(degresReel / 1000) * tempboucle * vmaxrec ;//calculé x y théorique en m m, possiblement remplacé par un accélérométre dans la boucle principal
y = y + sin(degresReel / 1000) * tempboucle * vmaxrec ;}
//gestion de rotation
if(!(((cos(oriente/1000)<cos(n/1000))&&(abs(oriente-degresReel)<=n))||((oriente-n<=0)&&((degresReel<=oriente+n)||(degresReel>=oriente-n+2000*PI)))||((oriente+n>=2000*PI)&&((degresReel<=oriente+n-2000*PI)||(degresReel>=oriente-n))))){ //si degresReel ne convient pas à l'orientation demandé avec une marge n (prenant en conte les écart n entre N et 2PI- n)
Serial.print("orientation incorecte ");
degresReel = degresReel - vmaxcirc * tempboucle;//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal
}
}
Serial.print(" x=");
Serial.print(x);
Serial.print(" y=");
Serial.print(y);
}
while (degresReel < 0){ degresReel += PI*2000;} //rendre positif degresReel
while (degresReel >= PI*2000){degresReel -= PI*2000;} // le réduire sous PI*2000
//gestion temporelle//
if (tempjeu > finjeu){danger = 1;}
if (contact == 1){ tempjeu = tempjeu + tempboucle;
if ((danger == 0)&&(((cos(oriente/1000)<cos(n/1000))&&(abs(oriente-degresReel)<=n))||((oriente-n<=0)&&((degresReel<=oriente+n)||(degresReel>=oriente-n+2000*PI)))||((oriente+n>=2000*PI)&&((degresReel<=oriente+n-2000*PI)||(degresReel>=oriente-n))))){
tempprog = tempprog + tempboucle;}}
tempboucle = millis() - ecartp;
ecartp = millis();
Serial.print(" tempboucle = ");
Serial.print(tempboucle);
Serial.print(" tempprog = ");
Serial.print(tempprog);
}
Un survol du programme montre que dans la boucle figurent des calculs effectués sous condition, et plus précisément des calculs 'lourds' pour un Arduino (trigo).
Selon les combinaisons des conditions on peut imaginer des temps de calculs divers...ça parait logique au premier abord (on calcule ou pas x et y)
D'autre part l'affichage de x et y peut prendre plus ou moins de temps selon le nombre de chiffers à afficher.
Reste à évaluer ces différences théoriques de temps de traitement et s'assurer que ça rend bien compte des écarts constatés.....
changer l'état d'une sortie en début/fin de boucle et voir la durée à l'oscilloscope ou l'analyseur logique (à 10€)
Ne pas oublier que le hardware est , lui aussi, observable et qu'on peut aider le soft à se manifester sur des sorties...
ou
mémoriser la durée de boucle dans l'EEPROM et ensuite par un petit code approprié lire les données
if(((cos(oriente/1000)<cos(n/1000))&&(abs(oriente-degresReel)<=n))||((oriente-n<=0)&&((degresReel<=oriente+n)||(degresReel>=oriente-n+2000*PI)))||((oriente+n>=2000*PI)&&((degresReel<=oriente+n-2000*PI)||(degresReel>=oriente-n)))){ //si degresReel convient à l'orientation demandé avec une marge n (prenant en conte les écart n entre N et 2PI- n)
Serial.print("// orientation corecte//");
x = x + cos(degresReel / 1000) * tempboucle * vmaxrec ;//calculé x y théorique en m m, possiblement remplacé par un accélérométre dans la boucle principal
y = y + sin(degresReel / 1000) * tempboucle * vmaxrec ;}
//gestion de rotation
if(!(((cos(oriente/1000)<cos(n/1000))&&(abs(oriente-degresReel)<=n))||((oriente-n<=0)&&((degresReel<=oriente+n)||(degresReel>=oriente-n+2000*PI)))||((oriente+n>=2000*PI)&&((degresReel<=oriente+n-2000*PI)||(degresReel>=oriente-n))))){ //si degresReel ne convient pas à l'orientation demandé avec une marge n (prenant en conte les écart n entre N et 2PI- n)
Voilà 2 tests très lourds. Le second repose sur le même calcul que le premier mais complémente le résultat. Tu pourrais tout simplement faire un
if (condition)
.........
else
..........
et ta boucle serait 2 fois moins longue.
Faire fonctionner un programme en jouant sur le temps d'exécution d'une boucle de programme c'est se tirer une balle dans le pied. Il faudra ajuster à la moindre modification du code.
C'est généralement la conséquence d'une mauvaise architecture matérielle et/ou logicielle.
Pour faire un parallèle, imagine aller au lycée les yeux bandés en te fiant uniquement à la trotteuse de ta montre.
passer le if en else, est une très bonne idée , merci beaucoup.
normalement les chose qui varie en fonction du tempboucle se régules seul je n'aurais pas à le modifier quelconque valeurs à chaque fois :
if (tempboucle>tempbouclemax){tempbouclemax = tempboucle;
n = tempbouclemax*vmaxcirc/2;}
je pense sinon par la suite me basé sur d'autre capteur pour la spatialisation du robot notamment un gyroscope pour l'orientation du robot (les écarts d'angle sont dévastateur) . néanmoins la déduction des distance parcouru rectiligne en fonction du temps seras garder. je trouve trop complexe à mon niveau et avec le temps qui m'est impartie d'intégré des balises ou gps... de plus les écart rectiligne devrais êtres négligeable avec un bon moteur pas a pas et des chenille qui adhéré bien.
Je pense... que le traitement du temps que tu t'impose est du au faite qu**'il te faut exécuter un calcul et une correction immédiate** de la position de ton système sur le changement d'état de ton capteur "maitre".
De plus ton système est dit "rapide" selon ce que je comprends. Il doit donc réagir à une action"quasi" immédiate.
Ton programme: D’expérience je sais que l'utilisation de Serial.print() ralenti les programmes.
Supprime toutes les lignes d'informations pour n'en garder qu'une (le temps d'exécution) et tu verra une très net différence en gain de temps. Serial.print() à utiliser avec modération dans ce genre de système rapide. De plus une fois qu'un programme est "débbugé" et fonctionnel plus utile de laisser actif le moniteur série. (tu diminuera le temps d'exécution)
Je rejoint les "copain" sur le faite que tes comparaison sont énormes.!!
Certaines données de comparaison "PI*2000" sont des calculs (temps) sur des données constantes. => C'est une donnée que tu placer cette dans une variables !! (6283)
Tu fait trop de calcul dans tes condition d'exécutions => "oriente-degresReel" Ce genre de calcul fait parti du traitement des données.
Remarque: certain calcul que je considère "flotant" (à virgule) sont parfois inutile en cours de traitement car très lourd en espace mémoire et entrainent une dérive du résultat finale sur les arrondis.
Il est préférable de les exécuter en fin de traitement et parfois y appliquer un correctif "offset" si cela est utile. (Mais rarement fait de correctif).
Il est évidant que par le cumul de tout cela... il te manque les deux parties essentiels a retravailler.
La gestion de ton système. C'est a dire l'acquisition puis le traitements des données. Une fois cela fait tu les exploite a volonté pour tes condition d'exécution en sortie.
En bref... dans ton programme tu exploite des données et exécute le traitement en même temps.
L'outil à maitriser pour des système dit rapide est l'interruption. Mais là aussi la aussi il faut maitriser l'art du calcul avec l'exploitation du bon types de variables pour les données appropriées.
Tu aborde ton projet du mauvais coté... Tu souhaite réaliser une orientation sur une base de temps dans l’espace soit.
Mais tu ne prends pas en compte la vitesse linéaire de ton "robot". Si tu connais sa vitesse tu en déduit la distance parcouru dans le temps.
En fonction de la vitesse en tr/min max de ton moteur et des rapport de réduction possible tu peux la déterminer.
tout d'abord , tu me semble avoirs trés bien compris la difficulté du projet "la réactivité immédiate du robot". d'autre part celui si étant autonome devras être précis voila pourquoi j'ai mis les variables lié à l'orientation et au distance en float.
c'est peux étre les variables lier au temps et au vitesse qui peuvent étre mis en int? il me semblais étre obligé de les mètre en float car elle effectues des calcule avec d'autre float et que l'on ne mélange pas les int et les float.
le fait que le programme soit plus efficace sans le moniteur série est pour mois une très bonne nouvelle.
une phrase dons j'ai du mal à comprendre l’application:
"Remarque: certain calcul que je considère "flotant" (à virgule) sont parfois inutile en cours de traitement car très lourd en espace mémoire et entrainent une dérive du résultat finale sur les arrondis.
Il est préférable de les exécuter en fin de traitement et parfois y appliquer un correctif "offset" si cela est utile. (Mais rarement fait de correctif)."
je ne vois pas comment on peux se passé ou simplifier s'es calcule, j'ai l’impression que l'on rentre dans un niveau un peux compliqué pour moi.
enfin tu dit que ne prend pas en conte la vitesse linéaire de mon robot, mais n'es pas se que je fait avec les variable vmaxrec et vmaxcirc ?
sinon j'ai mis à jours le programme rajouté quelque calcule et un peux allégé quelque condition, il y à en fin de programme une condition qui se répété plus haut, je peux la déplacé plus haut mais pour l'instant je préféré bien séparé mais calcule temporelle du reste , je simplifierait cela quand le programme sera plus complet , quand il auras ces capteurs et moteur en plus.
// variable temporelle
float tempjeu = 0.0;//temps depuis le lenssement du jeux
float tempprog = 0.0;// temps soustrayant les poses du aux arrets imprévus sur le parcour et les periodes de rotation.
const float finjeu = 100000.0; // temps de fin de jeux en mili seconde arréte le robot dans tout ces déplacement et action
float tempboucle = 0.0; // temp entre chaque boucle pour calculer l'étape la position à chaque boucle
float ecartp = 0.0; // variable calcule servant de repaire au tempboucle
//variable de condition
int contact = 1; // varible on off coup d'envois
int danger = 0;// détection d'un obstacle imprévus arrêt du véicule
//variable de calcule spatial
const float sud = 1500*PI; // orientation primaire utile en milli radiant
const float nord = PI*500;//...
const float est = 0.0;//...
const float ouest = PI*1000;//...
const float vmaxrec = 0.05;// vitesse max sur sol plat en mm par milli seconde
const float vmaxcirc = PI/12;//vitesse max circulaire sur sol plat en milliradant par milliseconde
float x = 0.0; // position d'origine en x en mm
float y = 0.0; // position d'origine en y en mm
float oriente ;
float n = 2.0;// marge de degrée pr arivé à l'orientation voulu se calcule en faisant vmaxcirc*tempbouclemax
float tempbouclemax = 0; //permet de calculé la magre de degrée n en fonction de la vitesse minimal du programe
float degresReel = PI*500; //direction de la tête du robot dans le repére x y en mradiant radiant au démarage
//tableau des trajectoire
int etape = 0; // étape dans l'avancement du programme
const int B = 5; //nombre d'étape
float parcour [3][B]{{500.0,600.0,600.0,200.0,4000.0},// déterminé la distance en mm
{nord,sud,est,ouest,PI*250},//déterminer la direction tableau servant d'interface pour stocker la trajectoire et les action à réaliser en degrée
{0.0,0.0,0.0,0.0,0.0,}}; // temprograme équivalent à l'éatape
void setup() {
Serial.begin(2000000);
oriente = parcour [1][0];
//remplire la derniére ligne du tableau
parcour [2][0]= parcour [0][0] / vmaxrec;
for (int i = 0 ; i <= B-1 ; i++){
parcour [2][i+1] = parcour [2][i] + (parcour [0][i+1] / vmaxrec);
}
for (int i = 0 ; i <= B-1 ; i++)
{
Serial.print("etape:");
Serial.print(i);
Serial.print(" ");
Serial.print("distance:");
Serial.print(parcour[0][i]);
Serial.print(" ");
Serial.print("orientation:");
Serial.print(parcour[1][i]);
Serial.print(" ");
Serial.print("temps cumulé:");
Serial.print(parcour[2][i]);
Serial.println(" ");
}
}
void loop() {
// detecter le coup denvois
if (contact == 1){
//prise de valeur capteur//
// detecter un obstacle imprévut
//lecture détape //
if ( tempprog >= parcour [2][etape]){etape = etape + 1;}// faire evoluer la trajectoire
oriente = parcour [1][etape];//lire l'orientation visé
Serial.print(" oriente = ");
Serial.print(oriente);
Serial.print(" degresreel =");
Serial.print(degresReel);
Serial.print(" etape = ");
Serial.print(etape);
Serial.print(" n = ");
Serial.print(n);
Serial.print(" tpbmax= ");
Serial.println(tempbouclemax);
if (danger == 0){
//gestion spatial//
//determiné la marge de précision en fonction de la vitesse du programe
if ((tempboucle>tempbouclemax)&&(tempprog>1)){tempbouclemax = tempboucle;
n = tempbouclemax*vmaxcirc/2;}
//gestion d'avancé rectiligne
if(((cos(oriente/1000)<cos(n/1000))&&(abs(oriente-degresReel)<=n))||((oriente-n<=0)&&((degresReel<=oriente+n)||(degresReel>=oriente-n+2000*PI)))||((oriente+n>=2000*PI)&&((degresReel<=oriente+n-2000*PI)||(degresReel>=oriente-n)))){ //si degresReel convient à l'orientation demandé avec une marge n (prenant en conte les écart n entre N et 2PI- n)
Serial.print("// orientation corecte//");
x = x + cos(degresReel / 1000) * tempboucle * vmaxrec ;//calculé x y théorique en m m, possiblement remplacé par un accélérométre dans la boucle principal
y = y + sin(degresReel / 1000) * tempboucle * vmaxrec ;}
//gestion de rotation
else{ //si degresReel ne convient pas à l'orientation demandé avec une marge n (prenant en conte les écart n entre N et 2PI- n
Serial.print("orientation incorecte ");
if (/*si le plus cour est le sens trigo,condition en reflection*/){degresReel = degresReel + vmaxcirc * tempboucle;//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal alors tourné dans le sens trigo
}
else{degresReel = degresReel - vmaxcirc * tempboucle;}//calculer degresReel possiblement remplacé par un giroscope dans la cboucle principal alors tourné dans le sens horaire
}
}
Serial.print(" x=");
Serial.print(x);
Serial.print(" y=");
Serial.print(y);
}
while (degresReel < 0){ degresReel += PI*2000;} //rendre positif degresReel
while (degresReel >= PI*2000){degresReel -= PI*2000;} // le réduire sous PI*2000
//gestion temporelle//
if (tempjeu > finjeu){danger = 1;}//si le temp de jeux et dépassé arrété tout
if (contact == 1){ tempjeu = tempjeu + tempboucle;
if ((danger == 0)&&(((cos(oriente/1000)<cos(n/1000))&&(abs(oriente-degresReel)<=n))||((oriente-n<=0)&&((degresReel<=oriente+n)||(degresReel>=oriente-n+2000*PI)))||((oriente+n>=2000*PI)&&((degresReel<=oriente+n-2000*PI)||(degresReel>=oriente-n))))){
tempprog = tempprog + tempboucle;}}
tempboucle = millis() - ecartp;
ecartp = millis();
Serial.print(" tempboucle = ");
Serial.print(tempboucle);
Serial.print(" tempprog = ");
Serial.print(tempprog);
}
bengloo59:
le fait que le programme soit plus efficace sans le moniteur série est pour mois une très bonne nouvelle.
Je n'ai pas lu que "le programme soit plus efficace sans le moniteur série" , mais que "l'utilisation de Serial.print() ralenti les programmes. " (sic #7), ce qui est une évidence.
Pourquoi faites vous vos mesures de temps avec tous ces Serial.print si ils ne servent qu'au débogage?
Pourquoi n'utilisez vous pas micros() ?
bengloo59:
reste toujours à savoirs la vitesse de l' arduino seul sans moniteur, internet ne dit rien la dessus .
J'ai fait des essais avec ce programme (et une montre pour mesurer ) :
/*
* Une diode (rouge) sur D10 allumée en début de boucle
* éteinte en fin de boucle
*/
unsigned long delta = 0;
unsigned long time0 = 0;
const unsigned long c_nboucle = 5000; //5000 --> 30s à 9600 bauds
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode(10, OUTPUT);
digitalWrite(10, LOW);
}
void loop() {
unsigned long i = 0;
delay(3000); // délai pour trouver la montre
digitalWrite(10, HIGH); // feu
time0 = micros();
while ( i < c_nboucle) {
i++;
Serial.println(i);
}
delta = micros() - time0;
digitalWrite(10, LOW);
Serial.println(i);
Serial.println("");
Serial.print(" delta = ");
Serial.print(delta / 1000);
while(1);
}
Avec ou sans moniteur série , que l'arduino (UNO) soit alimenté par USB ou le jack en 12v, et si l'Arduino est alimenté par le jack, que le cable USB soit connecté entre le PC et l'arduino ou non (ouf) :
le temps d'exécution est strictement le même.
cela m'intéresse car cela me permettrais d'avoirs une précision meilleur.
Je ne comprends pas pourquoi tu teins à prendre en compte le temps d'exécution de ton programme.
Je comprendrais si tu faisais de la balistique et du calcul atomique dans l'espace temps.
Mais soit... c'est ton choix... je le respecte. Mais...
Pour en revenir au moniteur série et son incidence sur un programme.
Je vous propose une expérience... Ci dessous.
Premièrement. Sous une base de configuration à 9600 bauds.(moniteur)
Réalisez une mesure de temps programme. Puis notez la.
Ensuite passez sous commentaire les instructions Serial "X". puis notez le temps.
Sans modifier les calculs (exagéré) on constate que le temps
Deuxièmement.Sous une base de configuration à 20000000 bauds.(moniteur)
Réalisez les même consigne que dessus.
On constate qu'a vitesse de transmission élevé les informations inscrite ne se font pas correcte ou de façon aléatoire sans même respecter la séquences et les saut de ligne !!
Alors... vu de ces fait et sans modifier le calcul... pour moi... l'exploitation exagéré du moniteur série ralenti et ou perturbe l'exécution d'un programme.
Cela combiné au traitement de tes instructions ton programme n'atteindra pas ta "précision" attendu.
Tu n'a pas besoins de traiter ton système en prennent en compte le temps programme. Surtout si ton système évolue a des vitesse de l'ordre du mètre par seconde.
Pour ce qui est des calculs précis.
Exemple: PI2 /5 = 1.256 reviens aussi à faire 3.142/5 =1.256.
Pour être précis jusqu'au milliardième il fraudais calculer avec une autre variable de la même grandeur.
Tu devrais travailler ton programme et changer ton point de vu.
manumanu:
Alors... vu de ces fait et sans modifier le calcul... pour moi... l'exploitation exagéré du moniteur série ralenti et ou perturbe l'exécution d'un programme.
Non : c'est le moniteur série qui n'arrive pas à digérer les informations reçues à 2000000 bauds.
Jusqu'ici je n'ai jamais eu de problèmes à 1000000 bauds.
Non : c'est le moniteur série qui n'arrive pas à digérer les informations reçues à 2000000 bauds.
Jusqu'ici je n'ai jamais eu de problèmes à 1000000 bauds.
Il est anormale que le moniteur m'affiche deux fois l'instruction "tempsActu".
Même dans le setup() il ne respecte pas les instructions.
Ce que j’interprète des retours du moniteur c'est que le programme s'exécute de façon hasardeuses.
Le moniteur est esclave du l'Arduino et ne fait que afficher ce qui est transmis par l'execution programme.
Je me trompe peut être...
Merci ChristopheFr -Tu apporte de l'eau à mon moulin-
Tu démontre par l'insertion de delay(1) à bengloo59 que la vitesse de traitement du port série est trop élevé pour que son programme se comporte correctement.
manumanu:
Tu démontre par l'insertion de delay(1) à bengloo59 que la vitesse de traitement du port série est trop élevé pour que son programme se comporte correctement.
Ca ne démontre pas du tout que le programme arduino est affecté par la vitesse de transmission, ni que le problème soit du coté arduino.
