plantage à cause du Serial.begin

Voici un programme que j’utilise quand je sort sur le palier et qu’il y a mon voisin chinois qui ne comprend pas bien le français ou qui est sourd comme un pot:

void setup(void)
{
  Serial.begin(115200);
}

void loop()
{
  Serial.println("Bonjour");
  delay(1000);
}

Sachant que l’on peut choisir la vitesse de transmission en cours de programme, on n’est pas obligé de mettre Serial.begin dans le setup.
Voici mon programme n°2 pour mon chinois:

void setup(void)
{
}

void loop()
{
  Serial.begin(115200);
  Serial.println("Bonjour");
  delay(1000);
}

Et si il ne me répond vraiment pas, je supprime le delay:

void setup(void)
{
}

void loop()
{
  Serial.begin(115200);
  Serial.println("Bonjour");
}

Je m’attendais à une multitude de Bonjour, mais au lieu de ça j’ai seulement:

⸮婯-V⸮

Sympa l’Arduino, il se met à parler chinois.

Je comprends qu’en réinitialisant la liaison il envoie à ma console n’importe quoi. Mais je n’ai plus de boucle du tout. Il n’y a qu’un seul affichage. Que se passe-t-il?

Dernier essais pour voir si il se plante ou pas:

void setup(void)
{
}

void loop()
{
  for (byte i=0; i<9; i++)
  {
    Serial.begin(115200);
    Serial.println("Bonjour");
  }
  delay(1000);
  Serial.println("Bonjour");
  delay(1000);
}

Avec le delay, il doit bien pouvoir afficher le mot. Ben non. Mais si on ne fait que 8 boucles, il parle dans les deux langues mais fait bien une boucle.

Ca marche avec un voisin Sénégalais ?

Et en mode tam-tam ou signaux de fumée qu'est-ce que cela donne ?

Et si tu mettais le délai juste après le Serial.begin(115200) ?
Il manque peut-être quelques µs au micro pour terminer de configurer la liaison série.

Ca marche avec un voisin Sénégalais ?

Il faudrait que je déménage ou que mon chinois se mette en couple avec un sénégalais. Je n'ai pas encore essayé.

Et en mode tam-tam ou signaux de fumée qu'est-ce que cela donne ?

J'ai essayé en mode fumée un fois. Mais la carte depuis boude et ne répond plus. En fait de signaux, je n'ai eu qu'un trait (T en morse?)

Et si tu mettais le délai juste après le Serial.begin(115200) ?
Il manque peut-être quelques µs au micro pour terminer de configurer la liaison série.

Si on met une tempo après le println, il n'y a plus de plantage. On n'en met jamais après l'initialisation. Le problème vient quand on réinitialise la liaison pendant un envoi. Mais ce qui est drôle, c'est que cela ne plante qu'a partir de 9 fois.
Si il lui manque du temps, il pourrait envoyer n'importe quoi, mais pas se planter.

Est-ce que le '9' dépend du débit choisi ?
Il s'agit de quelle carte ? Certaines sont plus rapides que d'autres.

Est-ce que le '9' dépend du débit choisi ?

Même chose à 9600 bauds, ça boucle pour 8 et ça plante pour 9.
Mais j'ai Q⸮K⸮⸮e Du coup mon chinois va perdre son latin.

je n'ai jamais utilisé serial.end() , ça donnerai quoi dans la boucle ?
qui sait en plus de la libération de Rx et TX il a peut être des effets secondaires....

Serial.end()

Ca existe ce truc? :grin:

En fait, je ne cherche pas à faire fonctionner la liaison, mais je me mets à la place d'un débutant qui mettrait les deux lignes dans loop() et qui après va me poser la question pourquoi ça plante? Pour moi, quand j'utiliser Serial.begin, il est une seule fois dans le setup.

vileroi:
Ca existe ce truc? :grin:

J'en découvre aussi l'existence mais cette fonction est tout à fait logique.
Il faut bien couper l'activation de l'UART pour libérer les pins D0 et D1 si on a besoin de s'en servir à autre chose.

Idem pour l'I2C il existe une fonction pour libérer les pins "momentanément" affectée à SDA et SCL.

Et si tu ajoutes

while (!Serial) ;

après le begin, ça améliore les choses?

Si oui, il serait intéressant de mesurer la durée de cette attente, avec un micros()...

Voici le code pour mesurer les temps:

void setup(void)
{
}
unsigned long t;
void loop()
{
    Serial.begin(115200);
    t=micros();
    while (!Serial) ;
    Serial.println(micros()-t);
}

le temps mesuré (en µs) est de:
temps.gif
C'est assez carré comme mesure! et la boucle ne fonctionne pas non plus.

temps.gif

Damned !

(Blake et Mortimer, vol. 3, page 12)

A mon avis Serial.begin() vire tous les caractères présents dans le buffer d'émission de l'UART.
Il faudrait un petit délai après Serial.print(), à 115200 une centaine de µs par caractère.

C'est pas pour le faire fonctionner. Sinon il suffit de ne pas appeler 10 fois Serial.begin Mais je suis curieux de voir pourquoi cela plante...

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.