Serial utilisant Programming USB Port ne fonctionne pas sans SerialUSB

Bonjour

Le code utilise Serial et Serial USB sur une Arduino Due, mais Serial ne fonctionne pas seul ! Pourquoi ?
Pouvez m’expliquer pourquoi Serial ne fonctionne pas être connecté u PC par 2 ports USB
1 Seul USB devrait être nécessaire !..
Où est mon erreur ? …

Le code de mon Arduino Due utilisant Serial et SerialUSB doit :
Les codes joints sont des extraits utilisant Serial et SerialUSB
A) Lire par le “Programming Port” des données de consignes issus de SimTools (un logiciel qui extrait la télémétrie des jeux et qui renvoie par le port COM des consignes de position moteurs)
B) La position actuelle des moteurs est mesurée directement par l’ADC de l’Arduino Due ( A1, A2, A3, A4)
C) Après calculs des correctifs de positions à effectuer pour atteindre les positions cibles à atteindre, l’Arduino Due commande pour chacun des 4 moteurs les signaux OUTPUT à appliquer ( 1 OUTPUT PWM et 2 OUTPUT Digitaux par moteur)

1) Serial et SerialUSB fonctionnent ensemble si: (2ports USB utilisé par Due sur PC)
La fonction void SerialWorker() lit correctement le port COM si le moniteur série de l’IDE du “Native USB port” est ouvert et utilisé par la fonction void Compare_Valeurs_Dynamiques()

2) SerialUSB fonctionne seul si: (mais avec 2ports USB utilisé par Due sur PC)
Quand le port COM “Programming Port” n’est pas utilisé par le logiciel extérieur (SimTools), les requêtes manuelles telles que XV00C … fonctionne.
J’envoie par l’IDE Arduino Série du " Programming Port" et je lis le résultat de l’interrogation sur la fenêtre de l’IDE Arduino Série du “Native USB Port”

**3) **Serial ne fonctionnent pas seul si: (Identique avec 1 ou 2ports USB utilisé par Due sur PC)[/u]
La fonction void SerialWorker() ne lit correctement le port COM si :
3a) La fonction void SerialWorker() n’arrive pas à lire le port COM si toutes les fonctions SerialUSB sont enlevées ou transformées.
Requêtes manuelles de void ParseCommand() transformé en Serial car le port COM n’est pas utilisé lors de l’interrogation et suppression de l’utilisation de la fonction de débugage void Compare_Valeurs_Dynamiques()
**3b) **Le moniteur série de l’IDE du “Native USB port” est ouvert mais pas utilisé par la fonction void Compare_Valeurs_Dynamiques()
3c) Seul le port COM “Programming Port” est branché
Merci de votre aide afin d’arriver à faire fonctionner le code avec uniquement “Programming Port” branché (en version sans fonction de débogage void Compare_Valeurs_Dynamiques()
Merci de vos retours d’expériences !
Extraits du code utilissant Sérial et SerialUSB
[/u] [u]void setup() {      Serial.begin(115200);                  //Idem  Serial.begin(250000);                    SerialUSB.begin (115200);  //Idem  SerialUSB.begin (250000);                  while (! SerialUSB); }[/u] [u]
[/u] [u]void SerialWorker() {   int buffer = 0;   int buffercount = -1;     while(Serial.available())   {     if(buffercount==-1)     {       buffer = Serial.read();       if(buffer != 'X')       {         buffercount=-1;       }       else       {         buffercount=0;       }     }     else     {       buffer = Serial.read();       commandbuffer[buffercount]=buffer;       buffercount++;       if(buffercount > 3)       {         if(commandbuffer[3]=='C')         {           ParseCommand();         }         buffercount=-1;       }     }   }                    }[/u] [u]
```
[u]void ParseCommand()
{
  int diff;
  int i;
  bool commande = false;
  String stringToPrint = “”;

switch (commandbuffer[0])
  {
    case ‘1’:
      i = 0;
      commande = true;                     
      break;
     
      …     
                               
    case ‘C’:                                                   
      commande = false;
      SerialUSB.println("");
      SerialUSB.println("Nb motors: " + String(NB_MOTORS));
      SerialUSB.println("Deadzone: " + String(DEADZONE));
      SerialUSB.println("Read Analog: " + String(READ_ANALOG));
      SerialUSB.println("Max speed when start/stop: " + String(SPEED_POS));
     
      if(USE_POT) stringToPrint=“Yes”;
      else stringToPrint=“No”;

SerialUSB.println("Use pot for global power: " + stringToPrint);

return;
      break;

case ‘V’:                                                   
      commande = false;
      SerialUSB.println("");
      SerialUSB.println(XPID_VER);       
           
      return;
      break;

case ‘M’:                                                     
      commande = false;
      SerialUSB.println("");
      for (int z=0;z<NB_MOTORS;z++)
      {
        SerialUSB.print(“Motor " + String(z+1) + “:  → “);     
        SerialUSB.print(”  Pot_Mini: " + String(motors[z][3]));
        SerialUSB.print(”  Pot_Maxi: " + String(motors[z][4]));
        SerialUSB.print(”  Deadzone: " + String(motors[z][5]));
        SerialUSB.print("  Standby: " + String(motors[z][6]));
        SerialUSB.print("  P: " + String(motors[z][7]));
        SerialUSB.print("  I: " + String(motors[z][8]));
        SerialUSB.print("  D: " + String(motors[z][9]));
        SerialUSB.println("");
      }
                             
    default:
      commande = false;
      return;
      break;
  }

if (commande)                                                                   
  {
    commande = false;                                                           
    motors[i][2]=(commandbuffer[1]*256)+commandbuffer[2];                       
    diff = constrain((GlobalPower * (motors[i][2] ))-2048,-2047,+2047);           
    motors[i][2]= map(diff,-2047,+2047,motors[i][3],motors[i][4]);               
    disable=0;                                                                   
  }[/u]
[/u] [u]
void loop()
{
  while (1==1)
  {
    FeedbackPotWorker();
    if (GP_select == 1)                                                     
    {
      GlobalPower = double(analogRead(GlobalPowerPin)) / 2058.0 ;           
    }
    else GlobalPower = 1.00;
   
    if (digitalRead(EmergencyPin) == LOW)                                 
    {
      for (int z=0;z<NB_MOTORS;z++)
      {
        motors[z][2] = motors[z][6];                                       
      }
    }
   
    else 
    SerialWorker();                                                   
    if(Serial.available())                                             
    {                                                                           
    Compare_Valeurs_Dynamiques();
    CalculatePID(4095);                                                   
   
    if(disable==0 || digitalRead(EmergencyPin) == LOW)                     
      {
      SetPWM();                                                           
      }
    }
  }
}

[/u] [u]
[u]void Compare_Valeurs_Dynamiques()                                         
{
int Global_Power_Majore;                                                 
                                                                                                                                       
  //  Moteur 1                                                               
              SerialUSB.print(" Cible * GlobalPower 1 = ");       
              Global_Power_Majore = GlobalPower * motors[0][2];
              SerialUSB.print(Global_Power_Majore);

SerialUSB.print("  Pot_1_Mini = “);           
              SerialUSB.print(motors[0][3]);           
                                 
              SerialUSB.print(”  Pot_1_Maxi = ");           
              SerialUSB.print(motors[0][4]);

SerialUSB.print("    pour atteindre_CIBLE 1 = ");     
              SerialUSB.print(motors[0][2]);

SerialUSB.print("    ADC 1 = ");
              SerialUSB.print(motors[0][1]);

SerialUSB.print("    Dernière_Erreur_PID 1 = “);           
              SerialUSB.print(motors[0][11]);   
               
              SerialUSB.print(”      Duty_PWM 1 = ");         
              SerialUSB.println (motors[0][12]);

…               
               
}[/u]
```

  while (! SerialUSB);

Si le câble USB n'est pas branché, le setup va bloquer sur cette ligne.

Ensuite si SerialUSB est NULL, tu ne devrais pas appeler de fonctions du genre SerialUSB.available(), SerialUSB.print(), etc.

hbachetti:

  while (! SerialUSB);

Si le câble USB n'est pas branché, le setup va bloquer sur cette ligne.
Ensuite si SerialUSB est NULL, tu ne devrais pas appeler de fonctions du genre SerialUSB.available(), SerialUSB.print(), etc.

Bonjour,
Dans mes multiples tentatives de faire lire « Serial » avec le code le plus simple, j’avais déjà essayé de supprimer totalement toutes les commandes des fonctions « SerialUSB »

Rappel du but souhaité dans la mesure du possible
A) Lire les données transitant par le port COM quand SimTools est en exécution
B) Quand le port COM "Programming Port" n’est pas utilisé par le logiciel extérieur (SimTools), je souhaiterais pouvoir utiliser des requêtes manuelles telles que XV00C …
( XV00C renvoie le chemin et le nom du croquis téléversé)fonctionne)

Je recommence avec ton aide la transformation du code
1) Suppression dans void setup() de SerialUSB.begin (115200) et de while (! SerialUSB);
2) void SerialWorker() : inchangé
3) Dans void ParseCommand() toutes les fonctions « SerialUSB » sont remplacées par des « Serial »
4) Dans void loop(), suppression de l’appel de void Compare_Valeurs_Dynamiques() est supprimé

Malgré la led RX du "Programming Port" qui clignote dès que SimTools envoie sa trame de consigne de position, je constate à nouveau aucune lecture de la trame sur le port Serial "Programming Port" (constat fait à l’aide des multimètres sur la sortie PWM et les sorties digitales )
Avant avec les extraits de code publiés et avec le "Programming Port" et "Native Port" de branchés, j’avais des relevés cohérents sur les multimètres et sur l’écran du Sérial Moniteur "Native Port"

Nota :
Je viens également essayé, dans une version provisoire, de supprimer toutes les requêtes manuelles dans void ParseCommand()
Constat dans cette version sans les requêtes manuelles

  1. Dans void ParseCommand() toutes les fonctions « SerialUSB » sont remplacées par des « Serial »

Si le programming port est dédié à un logiciel extérieur (SimTools), les réponses de ParseCommand() seront reçues par ce logiciel. Est-ce bien adéquat ?

Le logiciel du premier post peut fonctionner, mais il faut :

  • éviter while (! SerialUSB);
  • éviter d'utiliser l'objet SerialUSB s'il est NULL, comme ceci par exemple :

if (SerialUSB) SerialUSB.println("blabla");

Merci de ta réponse,

hbachetti:
Si le programming port est dédié à un logiciel extérieur (SimTools), les réponses de ParseCommand() seront reçues par ce logiciel. Est-ce bien adéquat ?

Les réponses de ParseCommand() ne seront pas reçues par SimTools car les interrogations (requêtes manuelles) du type XV00C et les autres n’ont pour but que de connaître le nom du croquis et de la configuration de certains paramètres du croquis
Elles ne s’effectuent que lorsque SimTools n’est pas en cours de travail et quand SimTools n’utilise pas le programming port
Les informations imprimées dans le moniteur série Arduino n’ont aucun intérêt en fonctionnement normal (hors débugage et recherche d’infos sur la configuration du croquis téléversé)
Je souhaite à terme pouvoir me passer (après mise au point) de l’usage du native port, l’affichage actuelle dans ma version initiale qui fonctionne envoie environ 180 caractères par moteur. Cela crée un affichage assez saccadé et surtout irrégulier selon horodatage du moniteur série.

Cela m’amène à une question: Comment modifier Loop () afin de mesurer le temps d’exécution de la boucle:
J’ai pensé à 2 solutions:

  1. En passant une pin en HIGH en début de boucle puis immédiatement en LOW ensuite (usage des registres). A l’aide d’un oscilloscope de base (DDS140 sur PC), mesurer le temps pendant la quelle la pin est restée HIGH.
    Avantage que je vois, permettre de visualiser le temps de la boucle Loop lorsque SimTools débite sur le port programming !
  2. Utiliser la fonction micros() …
    Comment tu modifierais Loop() pour effectuer une mesure de temps par le moniteur série du native port afin de ne pas perturbuer la lecture des consignes de position de SimTools qui arrive par le port programming

hbachetti:
Le logiciel du premier post peut fonctionner, mais il faut :

  • éviter while (! SerialUSB);
  • éviter d’utiliser l’objet SerialUSB s’il est NULL, comme ceci par exemple :

if (SerialUSB) SerialUSB.println(“blabla”);

Merci de ton avis ,
>< Eviter while (! SerialUSB); : Suppression dans setup () car cela fonction de façon identique avec ou sans , il semblerait néanmoins que l’affichage de Compare_Valeurs_Dynamiques() semble être quelque peu plus haché lors de l’impression dans serial moniteur du native port (impression peut-être !)
>< éviter d’utiliser l’objet SerialUSB s’il est NULL, comme ceci par exemple :
if (SerialUSB) SerialUSB.println(“blabla”);

> Je pense pas avoir utilisé SerialUSB s’il est NULL par le code. (à part dans setup())
> While (! SerialUSB) dans Setup() est maintenant supprimé
> Mais je ne dois être dans ce cas que lorsque le 2ème port n’est pas connecté et pas reconnu comme native port.

C’est en suivant ce raisonnement (si le native port n’est pas branché) que précédemment j’ai suivi tes directives et j’ai remplacé (sans succès) toutes les fonctions SerialUSB de ParseCommand() par des Serial, afin permettre à Serial de fonctionner que sur le programming port lorsque SimTools envoie ces trames de consignes et afin de pouvoir effectuer des interrogations de configuration du croquis lorsque SimTools est arrêté.(aucune liaison avec logiciel externe)

MAIS j’ai utilisé if(Serial.available()) dans Loop () afin que les calculs effectués par l’Arduino Due soient justes.
Il faut que l’Arduino mesure la position actuelles des moteurs et connaissent la consigne de position moteur à atteindre pour que le CPU puissent faire des calculs de correction de position correct.
Donc if(Serial.available()) dans Loop () avait pour but de d’attendre d’avoir les consignes de positions par le port COM et d’empêcher d’'effectuer des corrections de position erronées lors de mes tests sur mon coin de bureau (en cas de rotation du potentiomètre de feedback d’un moteur
if(Serial.available()) dans Loop () n’agit pas sur mon problème exposé au post 0

Avec ou Sans ce test cela ne permet pas à Serial de fonctionner sans le moniteur série du native port exécutant Compare_Valeurs_Dynamiques().

Pour résumé de façon imagée:
Le moniteur série du native port exécutant Compare_Valeurs_Dynamiques() se comporte comme un interrupteur établissant la lecture Serial de la trame de consigne provenant de SimTools

Avec //while (! SerialUSB); dans le setup, j’ai tenté d’isoler la ligne de commande établissant la lecture Serial en commentant ligne par ligne … , impossible d’isoler les lignes ne servant pas dans ce but. Un vrai casse tête !..
Un conflit ? … Bizarre , bizarre …
La suppression de while (! SerialUSB); dans setup(), ne dois pas influencer une lecture par Serial

Merci de ton aide !

Bonsoir,
Voici mon état d’avancement et mes questions

J’ai découvert que Compare_Valeurs_Dynamiques() se comporte comme un interrupteur établissant la lecture Serial de la trame de consigne provenant de SimTools, car il consomme du temps d’exécution de la boucle Loop()

void Compare_Valeurs_Dynamiques() lorsqu’elle était lancé dans void loop() effectuait cette temporisation
Le fonctionnement de void loop() nécessite un delayMicroseconds(200) au minimum et dans ce cas on peut commenter la ligne Compare_Valeurs_Dynamiques();

J’ai constaté selon la configuration Serial utilisé:

void loop() ne fonctionne pas sans delayMicroseconds(200)

SimTools est configuré pour envoyer sa trame de consigne moteur toutes les 3 mS
Pourquoi devoir retarder l’exécution de void loop() ?
void loop() devrait plus rapide que la période d’émission de la trame de consigne SimTools !

Code 100% Serial donc 1USB unique
Le fonctionnement de void loop() ne nécessite pas l’ouverture du moniteur série de « native port »
Les requêtes manuelles telles que XV00C … ne fonctionnent pas sur le « programming port » lorsque le port est libre (SimTools arrêté ou interrompu) Pourquoi ?
Serial (lecture de la trame SimTools) fonctionne à partir d’un delayMicroseconds(200);

Code SerialUSB (requêtes manuelles) + Serial (trames de consigne SimTools)
Sans while (! SerialUSB); dans void setup() , les requêtes manuelles (XV00C …) ne fonctionnent pas !

Le fonctionnement de void loop() nécessite l’ouverture du moniteur série de Native Port , même vide ! (Pourquoi ? )
La boucle void loop() nécessite donc pour fonctionner les 2 liaisons USB (Programming et Native)
Après le lancement de void loop() et son début d’éxécution, le « Native USB Port » peut être débranché
Le fonctionnement de void loop() nécessite un delayMicroseconds(200) au minimum . (Pourquoi ?)

Comment mesurer le temps d’éxécution de void Loop () ?
Pouvez vous me modifier void Loop () pour mesurer le temps en µs sur le moniteur série du Native Port ?

Merci d’avance car mes quelques essais me sortaient des temps qui devaient être erronées.

ci dessous loop () complète

void loop()
{
  //Program loop
  while (1==1)                                                                //Important hack: Use this own real time loop code without arduino framework delays
  {
    FeedbackPotWorker();
    if (GP_select == 1)                                                      // GP == "1" pour utiliser le potentiomètre sur A11    GP == "0" <=> Pas d'utilisation du potentiomètre sur A11, GP == "0" <=> Toujours 100%.
     {
      GlobalPower = double(analogRead(GlobalPowerPin)) / 2058.0 ;            //GlobalPower = Lecture de la Position sur la pin A11 et puis elle est divisée par 512 pour obtenir un coefficient entre 0 et 1,99.(4096/2058=1.99)
     }
    else GlobalPower = 1.00;
    
    if (digitalRead(EmergencyPin) == LOW)                                    // LOW <=> Niveau bas <=>  Met EmergencyPin au GND 
     {
      for (int z=0;z<NB_MOTORS;z++)
      {
        motors[z][2] = motors[z][6];                                        //  Si EmergencyPin au GND ==> Position Cible  = Position Standby 
      }
    }
    
    else  
    SerialWorker();                                                     // S'il n'y a pas d'arrêt d'urgence : lecture de la trame reçue de Simtools
    if(Serial.available())                                              // Indispensable pour calcul avec ADC et Cible car si SimTools n'envoie pas de trame cible, ADC fonctionne seul ==> Valeurs erronées
    {                                                                   // Necessaire libérer COM3 pour permettre de lancer les requêtes XC00C... Il faut que l'USB ne reçoit pas des données cibles de SimTools           
   delayMicroseconds(200);
   CalculatePID(4095);                                                     // Calcul PID avec PWM 12 bits à duty 100% 
    
    if(disable==0 || digitalRead(EmergencyPin) == LOW)                      // S'il y a pas d'indicateur d'arrêt moteurs OU pas d'arrêt d'urgence de déclenché
      {
      SetPWM();                                                             // Determination des signaux de commandes des variateurs de fréquence pilotant les moteurs
      }
    }
  }
}

Les requêtes manuelles telles que XV00C … ne fonctionnent pas sur le « programming port » lorsque le port est libre (SimTools arrêté ou interrompu) Pourquoi ?

Si la trame reçue était affichée sur la console avant de parser la commande, on y verrait peut-être plus clair.

Le fonctionnement de void loop() nécessite l'ouverture du moniteur série de Native Port , même vide ! (Pourquoi ? )

Il n'y a aucune raison. Pour t'en convaincre charge un sketch blink.
Si la ligne while (! SerialUSB); est en place, le sketch ne démarrera pas si l'USB natif n'est pas branché.
Sinon, tout fonctionnera normalement.

Comment mesurer le temps d'éxécution de void Loop () ?

Enregistrer la valeur retournée par millis() ou micros() en entrant et en sortant, faire la différence.

hbachetti:
Si la trame reçue était affichée sur la console avant de parser la commande, on y verrait peut-être plus clair.

Je comprends pas ta réponse ...
Ce que je constate les requêtes manuelles fonctionne avec SerialUSB: Saisie par exemple de XV00C sur la fenêtre de saisie du moniteur série Programming Port + envoie puis lecture de la réponse sur la fenêtre de réponse du moniteur série du Native Port
Avec les requêtes manuelles utilisant la fonction Serial lors que le Programming Port et libre (non utilisé par SimTools) Avec 1 seul cable USB sur le Programming Port + avec le Programming Port libre , je saisie par exemple XV00C dans la fenêtre de saisie + Envoi , la led RX du Programming Port clignote sue la carte.
Mais la fenêtre de réponse reste vide.
Je loupe quelque chose dans la manipulatio avec Serial pour les requêtes manuelles ....

hbachetti:
Il n'y a aucune raison.

Je me suis mal exprimé, je suis d'accord, normalement Loop() ne nécessite pas l'ouverture du moniteur série pour fonctionner!
C'est bien à cause de cette anomalie que je m'interroge !...
Ainsi à cause de la second anomalie : nécessité d'un delayMicroseconds(200) pour avoir des output corrects

Et pourtant avec le test manuel de SimTools ( sans passer par les extractions de la télémétrie du jeu) et mes multimètres sur le Output PWM et OutPut Digitales quand j'établie ce test manuel, une trame de consigne est émise sur le port COM.
En 1er, je n'ai aucune variations des tensions sur les Output PWM et OutPut Digitales

Ni en bougeant le potentiomètre de lecture ADC ( Feedback de la positon actuelle des moteurs)
Ni en bougeant le curseur de la commande manuelle de SimTools
Pour établir des variations de tensions sur Output PWM et sur OutPut Digitales en fonction du curseur de la commande manuelle de SimTools, je dois :
Avoir un second câble USB et reconnu sur le port Native USB
Et ouvrir le moniteur série du ce Native Port

A propos du delayMicroseconds(200) minimum qui est nécessaire à l'exécution de la boucle Loop (), as-tu une explication ?
Logiquement, je devrais plutôt maintenir Loop () à une vitesse d'exécution inférieure au temps de lecture de la trame de consignes de 10 octets reçus à 115200 baud (mon code de test est paramétré sur 2 moteurs)

Une question à propos de l'horodatage sur la fenêtre de réponse du série moniteur, la précisons de lecture de 1ms est fiable ? pour une première estimation de la période d'exécution de la boucle Loop ?

Merci de ta patience ,cela me chagrine de ne pas comprendre les phénomènes no compris !

Je comprends pas ta réponse …

Afficher la trame reçue avec Serial.println()

hbachetti:
Afficher la trame reçue avec Serial.println()

OK

J'aurais une question de novice:!

Y-a-t il un moyen afin de voir, lorsque Loop () ne fonctionne pas, sur quelle ligne de code il butte.

Dans mes vieux souvenirs, il me semble que dans VisualBasic pour Office, il y avait une fonction pour le débugage qui suivait ligne par ligne le déroulement du programme pas par pas.

Dans IDE Arduino ou un autre soft freeware, y-a-il une fonction similaire.

Quelle est la meilleur manière de débugger un croquis Arduino ?

Non, il faut afficher sur la console.

Tfou57:
Je comprends pas ta réponse ...
Ce que je constate les requêtes manuelles fonctionne avec SerialUSB: Saisie par exemple de XV00C sur la fenêtre de saisie du moniteur série Programming Port + envoie puis lecture de la réponse sur la fenêtre de réponse du moniteur série du Native Port

hbachetti:
Non, il faut afficher sur la console.

La console dont tu parles , c'est bien la fenêtre qui s'ouvre après avoir sélectionner Serial Monitor ou la Loupe ?
Comment dois-je pratiquer pas à pas ?

La console est un soft annexe ? Avec le monitor série et avec un port unique utilisé , je ne vois pas vraiement comment saisir une requête manuelle du type XV00C par le Programming Port et obtenir obtenir une réponse sur la fenêtre de réponse du même port.
Sur 2 ports, Programming Port et Native Ports et le croquis téléversé dans la DUE utilisant SerialUSB et Serial, cela fonctionne trés bien quand SimTools libère le Programming Port
Saisie de la requête XV00C se fait alors par le monitor série du Programming Port et la réponse se fait sur le second moniteur série du Native Port.

Je cherche à faire fonctionner le croquis téléversé dans la DUE pour que les requêtes manuelles (SimTools arrêté) et pour que les lectures de la trame de SimTools se fassent en utilisant uniquement la fonction Serial !
Fonctionnement recherché similaire à celui décrit en utilisant les 2 ports de la DUE, mais en monopolisant un seul Programming Port

A propos de la façon d'effectuer un débogage précis , vous ne m'avez pas répondu.
Si une ligne de code bloque le code en attendant une condition qui n'arrive jamais, comment déceler cette ligne. ?
Dans mon code actuel utilisant SerialUSB, pour les requêtes manuelles et Serial pour la branche de traitement de la trame de consigne SimTools , j'aimerais trouver quelle est la ligne bloquante nécessitant la temporisation obligatoire de 200µs (illogique) et la ligne imposant l'ouverture du moniteur série du Native Port (non utilisé et illogique également dans cette branche du code.

Merci d'aider un novice qui pose des questions qui semblent être pas être à-propos pour un utilisateur Arduino.
Un petit grain de sable bloque souvent un projet
Merci 2 points bloquant temporisation obligatoire de 200µs (illogique) et la ligne imposant l'ouverture du moniteur série du Native Port

La console dont tu parles , c'est bien la fenêtre qui s'ouvre après avoir sélectionner Serial Monitor ou la Loupe ?

Oui.

Si une ligne de code bloque le code en attendant une condition qui n'arrive jamais, comment déceler cette ligne. ?

En affichant une ligne de debug avant l'attente de la condition, et aussi après.

Tfou57:
...
Avec les requêtes manuelles utilisant la fonction Serial lors que le Programming Port et libre (non utilisé par SimTools) Avec 1 seul cable USB sur le Programming Port + avec le Programming Port libre , je saisie par exemple XV00C dans la fenêtre de saisie + Envoi , la led RX du Programming Port clignote sue la carte.
Mais la fenêtre de réponse reste vide.
Je loupe quelque chose dans la manipulatio avec Serial pour les requêtes manuelles ....
...

hbachetti:
Oui.

Afin d'éliminer les doutes sur ma façon de tester l'interrogation des requêtes manuelles telle que XV00C ou XC00C ou XM00C...
Est-ce que ma façon de tester décrite ci dessous est juste !
Peux-tu m'expliquer comment faire pour saisir XV00C dans la ligne d'envoie du moniteur série Programming Port et recevoir le résultat dans la fenêtre du même Programming Port ?

Je n'arrive pas à comprendre à comprendre comment envoyé et recevoir par le même moniteur série sur 1 port unique.
Il y a certainement une syntaxe à rajouter à XV00C pour recevoir la réponse à l'interrogation.
Merci de me décrire comment procéder !
Rappel: le code pour les requêtes manuelles fonctionnent avec SerialUSB (TX sur Programming Port et RX sur Native port quand le Programming Port est libre ( SimTools arrêté)
Je n'ai pas trouver pour l'instant d'exemple similaire

Merci pour vos informations qui vous semblent basiques et qui me font tourner en rond !

Peux-tu m'expliquer comment faire pour saisir XV00C dans la ligne d'envoie du moniteur série Programming Port et recevoir le résultat dans la fenêtre du même Programming Port ?

La fenêtre est associée à un port. Donc ce qui est envoyé en cliquant sur envoyer est forcément reçu sur le port correspondant de l'ARDUINO, et vice-versa.

Rappel: le code pour les requêtes manuelles fonction avec SerialUSB (TX sur Programming Port et RX sur Native port quand le Programming Port est libre ( SimTools arrêté)

Il n'y a aucune raison pour qu'il y ait une différence.

Il y a certainement une syntaxe à rajouter à XV00C pour recevoir la réponse à l'interrogation.

Un port série n'a pas de syntaxe. C'est l'émetteur et le récepteur qui l'imposent, et ils se comprennent ou pas.

hbachetti:
La fenêtre est associée à un port. Donc ce qui est envoyé en cliquant sur envoyer est forcément reçu sur le port correspondant de l'ARDUINO, et vice-versa.

Il n'y a aucune raison pour qu'il y ait une différence.

Un port série n'a pas de syntaxe. C'est l'émetteur et le récepteur qui l'imposent, et ils se comprennent ou pas.

Si ce qui est envoyé sur le Programming Port, dans le cas d'un unique port connecté est forcément reçu sur le port correspondant Programming Port (unique port en usage sur l'ARDUINO), mon problème doit venir du Programming Port qui doit être planté
Si le port était planté , le moniteur série associé devrait être grisé , Non ?

Comme dans le code j'ai 2 branches qui utilise Serial , une par le moniteur série et l'autre en automatique par la lecture de la trame série de SimTools, la configuration du Setup () ne suffit peut-être pas ?

Dans Setup j'ai actuellement:

void setup()
{     
  Serial.begin(115200);                    
  while(! Serial);                         
 ...                             
{

Je devrais peut-être rajouter des while(! Serial); au début des fonctions devront déclencher les réponses à mes requêtes manuelles type XV00C
Peut-être à chaque fois Serial.begin(115200); suivi de while(! Serial);

Merci pour le temps que vous m'accorder !

Un port série ne plante pas. Il est ouvert ou non.