Arduino Forum

International => Français => Topic started by: rhum187 on Jul 16, 2012, 02:09 pm

Title: Communication RS232 (programmation)
Post by: rhum187 on Jul 16, 2012, 02:09 pm
Bonjour à tous,

J'ai déjà posté pas mal de fois sur ce sujet alors j'ai jugé bon de créer un nouveau topic pour la partie programmation.

Niveau hardware : pas de problème, mes deux Uno sont interfacés via deux MAX202

Je souhaite envoyé :

Code: [Select]

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

void loop()
{
  delay(500);
  Serial.write('D');
  Serial.write(1);
  Serial.write(64);
  Serial.write(128);
  Serial.write(255);
}


Le caractère D me permet de détecter que j'envoie bien les commandes de PWM pour mes moteurs : il me sert de "top départ". J'envoie donc ensuite 4 commandes de PWM sur la liaison série et c'est ces 4 valeurs que je souhaite récupérer.

J'ai donc utilisé le code ci dessous pour les récupérer :
Code: [Select]

char message[4];
int n_octet = 5;

void setup()
{
  Serial.begin(9600);
  //pinMode(13, OUTPUT);
}

void loop()
{
  if (Serial.available()>0)
  {
    if(Serial.read()!='D')
    {
      delay(50);
    }
   
    else
    {
      for(int n=1; n<n_octet; n++)
      {
        message[n]=Serial.read();
        Serial.print(message[n]);
      }
    }
  }
}


Malheureusement, je visualise sur le port série : FF FF FF 01 au lieu du 01 40 80 FF attendu...
Je ne comprends vraiment pas pourquoi ...
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 16, 2012, 02:55 pm
bonjour,

Vérifie le bon fonctionnement de ton montage à base de MAX202 en réalisant une "boucle locale".
Pour ce faire relie le Tx au Rx d'un côté et regarde si ce que tu envoi de l'autre coté te revient correctement.

Ps: Tu as bien croisé Rx et Tx entre tes deux UNO ?
Si tu ne croise pas tu auras Tx -> Tx et Rx -> Rx ce qui ne marchera pas.
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 16, 2012, 03:07 pm
La liaison est opérationnelle... j'ai l'impression que c'est un problème de code...
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 16, 2012, 03:55 pm
Voila ce qu'à donné ma boucle :

mon code :

Code: [Select]

char message[4];

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

void loop()
{
  delay(500);
  Serial.write('D');
  Serial.write(1);
  Serial.write(64);
  Serial.write(128);
  Serial.write(255);
 
  if (Serial.available() > 0)
  {
   for(int n=0; n<5; n++)
      {
        message[n]=Serial.read();
        Serial.print(message[n]);
      }
  }
  Serial.flush();
}


Et les résultats obtenus avec XCTU en PJ.

Ce que je vois :

La trame envoyée apparaît bien correctement : 44 01 40 80 FF
La trame reçue est bien identique à la trame envoyée...
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 16, 2012, 04:29 pm
Le problème qu'il y a c'est que le Serial.read "rate" des octets.

Je joins deux screens pour argumenter mon propos :

Le premier [COM11] correspond aux trames envoyées
Le second [COM13] correspond aux trames reçues (puis réaffichée)

Je joins aussi les deux codes utilisés :

Code écriture :
Code: [Select]

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

void loop()
{
  delay(500);
  Serial.write('D');
  Serial.write(1);
  Serial.write(64);
  Serial.write(128);
  Serial.write(255);
}


Code lecture :
Code: [Select]

char message[4];
int n_octet = 5;

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

void loop()
{
  if (Serial.available()>0)
  {
    if(Serial.read()!='D')
    {
     delay(50);
    }
   
    else
    {
      for(int n=0; n<n_octet; n++)
      {
        message[n]=Serial.read();
        Serial.print(message[n]);
      }
    }
  }
  Serial.flush();
}
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 16, 2012, 05:46 pm
Bonjour,

Tu doit ajouter une boucle d'attente avant de lire un octet ;)

Code: [Select]
// ...
while(Serial.available() < 1);
message[n]=Serial.read();
// ...
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 17, 2012, 09:05 am
Bizarrement ça marche beaucoup mieux... ;)

Merci (encore) Skywodd !

Encore quelques ajustements avec mes deux programmes complets mais ça devrait le faire... j'ai une bonne base maintenant !
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 17, 2012, 01:22 pm

Bizarrement ça marche beaucoup mieux... ;)

Si tu savais le temps que j'ai mis avant de trouver cette astuce au début ...
Le truc bête par excellence dont la doc arduino ne parle pas :smiley-yell:
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 17, 2012, 06:14 pm
J'en ai vraiment marre... je pensais avoir terminer mon code avec tes précieux conseils et voilà que je viens de m'apercevoir que la PWM des pins 10,9 et la PWM des pins 6,5 ne sont pas cadencés de manière identique... :/

Quand j'observe au scope j'ai une fréquence de environ 490Hz pour les pins 10 et 9 et j'ai le double pour les 6 et 5.

Alors il me vient deux quetions :

1/ Est-ce que ça sera la même chose sur la Nano (car je développe mon code sur une Uno)
2/ Est-ce que c'est possible de la changer facilement ? J'ai regardé un peu...  :smiley-eek-blue:

Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 17, 2012, 07:44 pm

1/ Est-ce que ça sera la même chose sur la Nano (car je développe mon code sur une Uno)

Oui c'est une différence logiciel liée au "core arduino", pas à la carte.


2/ Est-ce que c'est possible de la changer facilement ? J'ai regardé un peu...  :smiley-eek-blue:

Oui et non

Regarde ici :
http://arduino.cc/playground/Code/PwmFrequency
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 17, 2012, 08:11 pm
Ok,

ce qui veut dire que je ne peux ni faire tomber les pins 5 et 6 à 490Hz ni monter les pins 9 et 10 à 970Hz car il manque le case 128



Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 17, 2012, 09:35 pm

ce qui veut dire que je ne peux ni faire tomber les pins 5 et 6 à 490Hz ni monter les pins 9 et 10 à 970Hz car il manque le case 128

C'est vraiment un point critique que tes PWM est une fréquence identique ?
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 17, 2012, 09:47 pm
Ben je me posais la question justement...

Je pense que le composant auquel je les envoie s'en moque un peu...

EDIT : C'est la ds de mon pont en H : http://www.ti.com/lit/ds/symlink/drv8432.pdf
Title: Re: Communication RS232 (programmation)
Post by: zoroastre on Jul 17, 2012, 10:15 pm
Yep!

Si çà peut aider, tu peux piloter autant de servos que tu veux avec un seul PWM et sur n'importe quelle pinoche.

Je viens de plus ou moins faire le tour ce week-end de mes servos ;)

http://arduino.cc/forum/index.php/topic,114551.msg863024.html#msg863024

@+

Zoroastre.
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 03:00 pm
Merci zoroastre,

J'ai regardé ton topic avec beaucoup d'attention et ça pourra éventuellement m'aider ;)

Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 04:59 pm
Je viens de rentrer dans la 4ème dimensions... ^^

Non, pas encore, malheureusement, il y a un problème que je n'arrive pas à résoudre.

Je fais communiquer deux Arduino. Avec le premier j'envoie ça :

Code: [Select]

  Serial.print('M'); // Permet l'identification des commandes moteurs par le programme robot
  Serial.write(ZONE); // Permet le débogage des conditions à l'aide du VI
  Serial.write((int)PWM1);
  Serial.write((int)PWM2);
  Serial.write((int)PWM3);
  Serial.write((int)PWM4);


et avec le deuxième je veux lire la valeur des PWM donc j'ai écrit (avec l'aide de Skywodd ;)) :
Code: [Select]

byte PWM_MOT[4]; // Tableau de 6 octets
int n_octet = 4;
int pin_PWM_A = 10;
int pin_PWM_B = 9;
int pin_PWM_C = 6;
int pin_PWM_D = 5;

void setup()
{
  Serial.begin(9600); // Paramétrage de la vitesse de la liaison série
}

/*********************** DEBUT DE LA BOUCLE PRINCIPALE ********************************************/
void loop()
{
  if(Serial.available()>0)
  {
    if(Serial.read()!='M')
    {
     delay(50);
    }
    else
    {
      for(int n=1; n<=n_octet; n++)
      {
        while(Serial.available() < 1);
        PWM_MOT[n]=Serial.read();
      }
    }
    //analogWrite(pin_PWM_A, PWM_MOT[1]);
    //analogWrite(pin_PWM_B, PWM_MOT[2]);
    //analogWrite(pin_PWM_C, PWM_MOT[3]);
    //analogWrite(pin_PWM_D, PWM_MOT[4]);
   
    //Serial.print(PWM_MOT[0]);
    Serial.print(PWM_MOT[1]);
    Serial.print(PWM_MOT[2]);
    Serial.print(PWM_MOT[3]);
    Serial.print(PWM_MOT[4]);
    //Serial.print(PWM_MOT[5]);
   
    Serial.println();
   
  }
  else
  {
    analogWrite(pin_PWM_A, 0);
    analogWrite(pin_PWM_B, 0);
    analogWrite(pin_PWM_C, 0);
    analogWrite(pin_PWM_D, 0);
  }
 
  Serial.flush();
  delay(50);
}


Et je vous joins les deux screen XCTU qui m'ont permis de constater que il y avait +1 sur la PWM4 alors que je n'ai rien fait pour... enfin je pense
COM11 : Arduino qui envoit les infos
COM13 : Arduino qui reçoit et qui les (ré)affichent
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 18, 2012, 05:30 pm

Ben je me posais la question justement...

Je pense que le composant auquel je les envoie s'en moque un peu...

Ça n'as aucune réelle importance, dans le pire des cas cela ne joue que sur le sifflement / grésillement résiduelle du moteur en sortie (si tu utilise un moteur).
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 05:33 pm
Oui je pense aussi.

Par contre ma différence de 1, même si ce n'est que 1 me perturbe un peu plus...
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 18, 2012, 06:05 pm

Par contre ma différence de 1, même si ce n'est que 1 me perturbe un peu plus...

Rooo! Je sort le fusil et les cartouches si tu ne vois pas tes erreurs ;)

Erreur 1 :
Prototype :
Code: [Select]
Serial.write(uint8_t);

Ton code :
Code: [Select]
Serial.write((int)PWM4);

Note : uint8_t = 1 octet non signé (0 ~ 255), int = 2 octets signé (-32767 ~ 32767)

--

Erreur 2 :
Déclaration :
Code: [Select]
byte PWM_MOT[4]; // Tableau de 6 octets
(hummm 6 tu est sûr ;))

Ton code ensuite :
Code: [Select]
//Serial.print(PWM_MOT[0]);
    Serial.print(PWM_MOT[1]); // <-
    Serial.print(PWM_MOT[2]);
    Serial.print(PWM_MOT[3]);
    Serial.print(PWM_MOT[4]); // <-
    //Serial.print(PWM_MOT[5]);


Note : en C/C++ les tableaux commencent à 0 et se terminent à taille_max - 1, exemple int[2] -> int[0], int[1]

--

Erreur 3 :
Déclaration :
Code: [Select]
byte PWM_MOT[4];
int n_octet = 4;


Ton code :
Code: [Select]
for(int n=1; n<=n_octet; n++) // -> n = 1, n = 2, n = 3, n = 4
{
  while(Serial.available() < 1);
  PWM_MOT[n]=Serial.read(); // <-
}


Voir note plus haut.
--

Erreur 4 :

Tu envois 6 octets mais tu en lit seulement 4 (+ 1 pour le if) ;)

--

Correction :

Envoi :
Code: [Select]
Serial.write((uint8_t)'M'); // Permet l'identification des commandes moteurs par le programme robot
Serial.write((uint8_t)ZONE); // Permet le débogage des conditions à l'aide du VI
Serial.write((uint8_t)PWM1);
Serial.write((uint8_t)PWM2);
Serial.write((uint8_t)PWM3);
Serial.write((uint8_t)PWM4);


Réception :
Code: [Select]
const byte NB_OCTETS = 5;
const byte PIN_PWM_A = 10;
const byte PIN_PWM_B = 9;
const byte PIN_PWM_C = 6;
const byte PIN_PWM_D = 5;

byte PWM_MOT[NB_OCTETS];

void setup() {
  Serial.begin(9600); // Paramétrage de la vitesse de la liaison série
}

/*********************** DEBUT DE LA BOUCLE PRINCIPALE ********************************************/
void loop() {
 
  if(Serial.available() > 0) {
   
    if(Serial.read() != 'M') {
      delay(50);
    }
    else {

      for(int n = 0; n < NB_OCTETS; ++n) {
        while(Serial.available() < 1);
        PWM_MOT[n] = Serial.read();
      }

      //analogWrite(PIN_PWM_A, PWM_MOT[1]);
      //analogWrite(PIN_PWM_B, PWM_MOT[2]);
      //analogWrite(PIN_PWM_C, PWM_MOT[3]);
      //analogWrite(PIN_PWM_D, PWM_MOT[4]);

      Serial.print(PWM_MOT[0]);
      Serial.print(PWM_MOT[1]);
      Serial.print(PWM_MOT[2]);
      Serial.print(PWM_MOT[3]);
      Serial.print(PWM_MOT[4]);
      Serial.println();
    }
  }
  else {
   
    analogWrite(PIN_PWM_A, 0);
    analogWrite(PIN_PWM_B, 0);
    analogWrite(PIN_PWM_C, 0);
    analogWrite(PIN_PWM_D, 0);
  }

  // Serial.flush(); // Pas de flush() quand on ne sait pas ce que ça signifie ;)
  delay(50);
}
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 06:22 pm
Quote
Pas de flush() quand on ne sait pas ce que ça signifie ;)


Heu, pour moi je vidais le buffer de lecture à chaque fois que j'ai terminé mais je me suis rendu compte que je mettre ou pas n'avais aucun effet...

Ca a du te faire pas mal de boulot alors merci pour ton temps je regarde ça et je te fais un retour avant 19h (si mon chef me sort pas une réunion surprise du chapeau...)
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 18, 2012, 06:27 pm

Heu, pour moi je vidais le buffer de lecture à chaque fois que j'ai terminé mais je me suis rendu compte que je mettre ou pas n'avais aucun effet...

Justement tu as tout faux ;)
Depuis arduino 1.0 Serial.flush() bloque le programme jusqu'à ce que toute les données en Tx soit émise.

Pour vider le buffer entrant il faut faire une boucle de ce genre :
Code: [Select]
while(Serial.available() > 0) Serial.read();


Ca a du te faire pas mal de boulot alors merci pour ton temps je regarde ça et je te fais un retour avant 19h (si mon chef me sort pas une réunion surprise du chapeau...)

Bof juste 5 minutes entre deux bricolages 8)
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 06:31 pm
Quote
Depuis arduino 1.0


Je bosse encore sur la 0023
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 18, 2012, 06:39 pm

Quote
Depuis arduino 1.0


Je bosse encore sur la 0023

Ce qui ne change rien au fait que flush() n'as rien à faire dans ton prog ;)
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 06:46 pm
Ok,

bon ben écoute sans surprise ça fonctionne beaucoup mieux avec les uint8_t

Quote
(hummm 6 tu est sûr )


Non bien sur mais je n'avais pas maj mon commentaire... ça reste une erreur me dirais mes profs...  XD

Quote
(+ 1 pour le if)


tu voulais dire le :

Code: [Select]
while(Serial.available() < 1);

que tu m'as fait rajouté... ;)

Code: [Select]
while(Serial.available() > 0) Serial.read();
Ha ok, le fait de faire un read vide le buffer si je comprends bien !



Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 06:57 pm
Code: [Select]
const byte NB_OCTETS = 5;
const byte PIN_PWM_A = 10;
const byte PIN_PWM_B = 9;
const byte PIN_PWM_C = 6;
const byte PIN_PWM_D = 5;


Et une petite question au passage : pourquoi avoir choisi de déclarer ça en const byte ?

Ma supposition : const veut dire que ça ne bouge pas (c'est bien le propre d'une constante)
byte car un octet suffit pour coder ces valeurs

J'ai bon ? j'ai bon ? :)
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 18, 2012, 07:00 pm

Ma supposition : const veut dire que ça ne bouge pas (c'est bien le propre d'une constante)
byte car un octet suffit pour coder ces valeurs

J'ai bon ? j'ai bon ? :)

C'est ça.

Const = constante = qui ne change pas (si on tente de changer la valeur d'un const = erreur de compilation)
byte = 1 octet = économie de ram vu que l'on stocke juste un nombre avec pour valeur max 255.
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 07:05 pm
Parfait ben plus qu'à faire les deux modifs pour juste afficher les 4 PWM et ça devrait être bon avec qqch du style :

Code: [Select]
const byte NB_OCTETS = 4;
.
.
.
byte PWM_MOT[NB_OCTETS-1];
.
.
.
for(int n = 2; n < NB_OCTETS+2; ++n)
      {
        while(Serial.available() < 1);
        PWM_MOT[n] = Serial.read();
      }

Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 18, 2012, 07:12 pm
Alors voyons, chevrotine pour gros gibier ou cartouches, hummm ... :smiley-mr-green:

Code: [Select]
for(int n = 2; n < NB_OCTETS+2; ++n) // n = 2, n = 3, n = 4, n = 5
{
  while(Serial.available() < 1);
  PWM_MOT[n] = Serial.read();
}

Les tableaux en C/C++ commencent à zéro !
(Souligné, gras, surligné, je peut pas faire plus lisible ;))

Correction :
Code: [Select]
Serial.read();  // Laisse de côté l'octet "ZONE" (est-ce bien utile de l'envoyer du coup ? Pour moi non ;))
for(byte n = 0; n < NB_OCTETS - 1; ++n)  {
  while(Serial.available() < 1);
  PWM_MOT[n] = Serial.read();
}
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 07:16 pm
Quote
Alors voyons, chevrotine pour gros gibier ou cartouches, hummm


hahaha, c'était une blague... !

J'espère que tu ne penses pas que je serais capable de faire ça... :smiley-eek-blue:
Title: Re: Communication RS232 (programmation)
Post by: skywodd on Jul 18, 2012, 07:18 pm

hahaha, c'était une blague... !

J'espère que tu ne penses pas que je serais capable de faire ça... :smiley-eek-blue:

cf :
Quote
Rooo! Je sort le fusil et les cartouches si tu ne vois pas tes erreurs

Humour ;)
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 07:52 pm
Pour vraiment être sûr d'avoir bien compris et un peu pour passer pour un idiot aussi...

Dans le code corrigé que tu m'as donné tu aurais très bien pu écrire

byte PWM_MOT[NB_OCTETS-1]

dans le sens ou tu ne remplis que 5 octets du tableau alors que tu définis un tableau de 6 octets (PWM_MOT[5]) ?
Title: Re: Communication RS232 (programmation)
Post by: zoroastre on Jul 18, 2012, 08:23 pm
Yep!

Oulala ! Tu as un problème avec les tableaux dites donc  :smiley-mr-green:

Lorsque tu définis un tableau, il faut bien distinguer la valeur entre crochet et la manière dont le µC va le gérer.

byte monTableau[6] = {1, 2, 3, 4, 5, 6};

La valeur entre crochet est telle que nous la comptons nous autre humain, il contient bien ici 6 élements (ou 6 cases mémoires).

Je ne rentrerais pas dans le détail du pourquoi, c'est comme çà un point c'est tout ;)

Par contre, le microcontrolleur comme tout bon microcontroleur, commence à compter à partir de 0,

Reprenons :

byte monTableau[6] = {1, 2, 3, 4, 5, 6}; // comptage pseudo-humain
......................................0, 1, 2, 3, 4, 5     // comptage du microcontrolleur

Ainsi, lorsque tu créés une boucle ou un appel à ce tableau, tu utilises le langage du µC et commences à compter à partir de zero :

monTableau[0] = 1
monTableau[1] = 2
monTableau[2] = 3
monTableau[3] = 4
monTableau[4] = 5
monTableau[5] = 6

A savoir que lorsque tu fabriques un tableau, tu fais appel à la gestion de la mémoire du microcontrolleur et à un moment donné, il faut bien dire à la mémoire que le tableau est fini.
Si tu essayais d'appeler monTableau[12], le compilateur te retournerait une erreur car tu as créé un tableau de 6 cases et pas 13 ;)

En esperant avoir clarifié un peu la situation  XD

@+

Zoroastre.
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 18, 2012, 08:25 pm
Parfaitement clair maintenant !

Merci à tous les deux !
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 19, 2012, 02:04 pm
Je reviens vous embêter ;)

Voilà ce que j'ai fait :
Code: [Select]
const byte PIN_PWM_A = 10;
const byte PIN_PWM_B = 9;
const byte PIN_PWM_C = 6;
const byte PIN_PWM_D = 5;

const byte PIN_COM = 4; // Déclaration de la pin COM de l'arduino
const byte PIN_LED = 2; // Déclaration de la pin LED de l'arduino

const byte NB_OCTETS = 4;
byte PWM_MOT[NB_OCTETS]; // Tableau de NB_OCTETS octets

void setup()
{
  Serial.begin(9600); // Paramétrage de la vitesse de la liaison série
  while(Serial.available() > 0) Serial.read(); // On vide le buffer de lecture
  pinMode(PIN_COM, OUTPUT); // Paramétrage de la pin COM en sortie
  pinMode(PIN_LED, OUTPUT); // Paramétrage de la pin LED en sortie
}

/*********************** DEBUT DE LA BOUCLE PRINCIPALE ********************************************/
void loop()
{
  digitalWrite(PIN_COM, LOW); // Paramétrage communication filaire
  digitalWrite(PIN_LED, HIGH); // Paramétrage des LEDs à l'état haut
 
  if(Serial.available() > 0)
  {
    int premier_octet = Serial.read();
    switch (premier_octet)
    {
      case 'M':
        Serial.read(); // On vide le 2ème octet du buffer de lecture correspondant à la zone Nunchunk
        for(int n = 0; n < NB_OCTETS; ++n) // On rempli le tableau d'octets
        {
          while(Serial.available() < 1); // Attente des données entre chaque tour de boucle (programme plus rapide que la com)
          PWM_MOT[n] = Serial.read(); // Stockage des valeurs de PWM dans le tableau
        }

        analogWrite(PIN_PWM_A, PWM_MOT[0]);
        analogWrite(PIN_PWM_B, PWM_MOT[1]);
        analogWrite(PIN_PWM_C, PWM_MOT[2]);
        analogWrite(PIN_PWM_D, PWM_MOT[3]);
     
        Serial.print(PWM_MOT[0]);
        Serial.print(PWM_MOT[1]);
        Serial.print(PWM_MOT[2]);
        Serial.print(PWM_MOT[3]);
        Serial.println();
        break;
       
      default:
        delay(1);
    }
  }
  else
  {
    analogWrite(PIN_PWM_A, 0);
    analogWrite(PIN_PWM_B, 0);
    analogWrite(PIN_PWM_C, 0);
    analogWrite(PIN_PWM_D, 0);
  }
  delay(50);
}


Mon code fonctionne plutôt bien. Par contre, je me suis amusé à enlever le delay(50) à la fin et là ça ne fonctionne plus comme attendu : j'affiche la zone et les 3 premières PWM... Pourtant en faisant "dérouler le programme dans ma tête" ça ne devrait rien changer...
Title: Re: Communication RS232 (programmation)
Post by: rhum187 on Jul 24, 2012, 03:17 pm
Je pense avoir compris mon problème de delay :

Je pense que ça vient du programme boitier qui dans ça boucle principale a aussi un delay de 50ms

Je pense qu'il faut que les delay soient identiques dans les deux programmes pour que tout roule correctement.