Go Down

Topic: Problème de compteur (Read 1 time) previous topic - next topic

Yab974

Bonjour à tous enfaite j'ai compris le problème, mais je sais pas trop comment le résoudre.

Enfaite comme le programme compte jusqu'à 10000 et que dépasse les 1000 milliseconde et ben l'arduino arrête de lire le port série.
Avait vous une idée de comment faire pour l'obliger à lire le port série?

dfgh

hello
voici ton prg à peine modifié pour mettre en évidence ton problème
lance le et tape "2356"

et regarde bien ton moniteur

puis au coup suivant, tapes 1
puis au coup suivant tapes 10
puis au coup suivant, tapes 100
puis au coup suivant tapes 1000
puis au coup suivant tapes 10000

Code: [Select]

int OrdreMarche; // variable de stockage des valeurs reçues sur le port Série
int stepcounter;
int distance;

void setup()   { // debut de la fonction setup()
  pinMode(8, OUTPUT);     
  pinMode(9, OUTPUT);
  digitalWrite(8, LOW);
  digitalWrite(9, LOW);
  Serial.begin(115200); // initialise connexion série à 115200 bauds
  Serial.println("Pret ");
}

void loop(){ // debut de la fonction loop()


  while (Serial.available() > 0)
  { // si un octet en réception

    int OrdreMarche = Serial.parseInt();
    int distance = Serial.parseInt();

    if (Serial.read() == '\n') Serial.print("OrdreMarche = ");Serial.println(OrdreMarche);
    {
      if (OrdreMarche== 1 ) // si Octet reçu est le 1
      {
        Serial.print("OrdreMarche = ");Serial.println(OrdreMarche);
        Serial.print("distance = ");Serial.println(distance);
        while(stepcounter <= distance )
        {
          digitalWrite(9, HIGH);
          delayMicroseconds(30);         
          digitalWrite(9, LOW);
          delayMicroseconds(30);
          stepcounter++;
          Serial.print("stepcounter = ");Serial.println(stepcounter);
         }
      distance=0;
      stepcounter=0;
      OrdreMarche= 0;
      }
    }
  }
}

Yab974

#17
Apr 24, 2017, 08:13 pm Last Edit: Apr 24, 2017, 08:21 pm by Yab974
Salut,
j'ai essayé le programme que tu m'as envoyé et :
quand je tape 2356 rien ne se passe
quand je tape 1 le programme se déroule
quand je tape 10 rien ne se passe
ni à 100 etc...

une fois que j'ai appuyé sur 1 le programme se déroule et plus rien ne se passe ensuite lorsque je tape 10 ou 10 etc.....


dfgh

quand tu tapes 1,
tu remplis les conditions pour entrer dans le if ordre de marche==1
et comme distance vaut 0 tu sors du  while(stepcounter <= distance ) aussitôt
 
mais je ne voulais pas faire fonctionner ton prg,
seulement te montrer qu'il ne fonctionnait pas comme tu le pensais.

à toi de suivre les affichages et comprendre ce qui se passe

Yab974

Tout à fait c'est le but de mon programme.

Ce que je veux c'est relativement simple :

1 - Réception de la valeur distance par la liaison série
2- Réception de la consigne de marche ou d'arrêt (valeur ordre de marche 1 ou 2 )

Si la valeur de marche = 0 alors je remets à 0 le compteur.
Si la valeur de marche = 1 je réalise mon programme et déroule le compteur jusqu'à ce que le compteur = la valeur de distance.
Puis il suffit que je change la valeur de marche pour remettre à 0 le compteur
Puis si je remets 1 à Ordre de marche le programme redémarre.

Tout les étapes fonctionnent très bien lorsque la valeur de distance est inférieur à 10000.

Mais dès que la valeur de distance est = ou supérieur à 10000.

le programme se déroule bien mais il devient pour moi impossible de remettre 0 dans la variable ordre de marche via le port Série.

Je pense que cela vient du temps de lecture du port série et que nous dépassons un certain temps car c'est quand même bizarre de pour une valeur de 9999 cela fonctionne et que pour 10000 ça ne fonctionne pas.

Dans l'attente de votre avis.

infobarquee

tu fais un peu fausse route car tu envoie des chiffres.
tu pourrais envoyer une lettre avec un chiffre par exemple et sans retour chariot dans la console.
M190 par exemple pour Marche et 190 pas

ca donne ca en gros

Code: [Select]
while (Serial.available() > 0) {
   int index=Serial.read(); // lire un premier caractère

  Serial.print("index : "); Serial.println(index);


   // filtrer : il doit etre une lettre minuscule ou majuscule
   if(index >= 'A' && index <= 'z'){
     int valeur = Serial.parseInt();

 switch(index){
case 'M': // M190 par ex.
       valeur=constrain(valeur,0,15000); // eviter les dépassements
       analogWrite(moteur,valeur);
       break;

     }
}
AUCUNE AIDE PAR MP

Yab974

merci pour ton aide,
mais ce que je n'arrive pas à comprendre c'est comment faire pour recevoir deux valeurs distincte que je sépare par des "," sur ma liaison série avec cette solution.
Par exemple je pourrais tout simplement envoyer un "m" et "a" pour l'ordre de marche et des chiffres ensuite mais pour les lire séparément je sais pas trop comment faire.

infobarquee

c'est assez clair dans le code, non?
index==>lettre
parseInt===>valeur

donc tu envoie M190, il va lire index = M et valeur =190
pas plus compliqué
ligne suivante S0 par exemple
index S pour stop et valeur 0 pour remise à zéro du compteur
AUCUNE AIDE PAR MP

Yab974

merci je vais tester cela

Yab974

Bonjour,
je voulais vous remercier car cela fonctionne correctement en mettant l'ordre de marche avec des lettres.

Merci beaucoup,
cordialement,
Yab974

Yab974

Rebonjour à tous,
j'ai de nouveau un problème avec mon programme,
je voudrais avoir deux moteurs différents avec deux consignes de distance tout cela piloté par processing mais  j'arrive à faire tourner mes moteurs mais au bout d'un moment mon programme plante et mes moteurs soit ne bougent plus ou n'arrête plus de tourner.
Je pense que cela vient de la consigne de distance.
Vous trouverez les deux programmes ci-dessous :
programme processing :
Code: [Select]

import controlP5.*;
import processing.serial.*;
ControlP5 cp5;
char OrdreMarche ='A',OrdreMarche2 ='A';
int distance, stepcounter,distance2;

Serial  myPort;
void setup() { // fonction d'initialisation exécutée 1 fois au démarrage

  size(600, 300); // ouvre une fenêtre xpixels  x ypixels
  background(255); // couleur fond fenetre
  println(Serial.list());
  myPort = new Serial(this, Serial.list()[0], 115200);
  myPort.clear();
  PFont font = createFont("arial", 20);

  cp5 = new ControlP5(this);
  cp5.addTextfield("input")
    .setPosition(20, 100)
    .setSize(200, 40)
    .setFont(font)
    .setFocus(true)
    .setColor(color(255, 0, 0))
    ;
  cp5.addTextfield("distance2")
    .setPosition(20, 200)
    .setSize(200, 40)
    .setFont(font)
    .setFocus(true)
    .setColor(color(255, 0, 0))
    ;
} // fin fonction Setup

void  draw()
{
  background(255);// fonction exécutée en boucle
  fill(0);
  text("moteur 1", 30, 10);
  text("moteur 2", 200, 10);
  if (OrdreMarche == 'A')
  {
    fill(0);
    text("Marche", 10, 30);
    fill(0, 255, 0);
    ellipse(30, 55, 40, 40);
  }
  if (OrdreMarche2 == 'A')
  {
    fill(0);
    text("Marche", 180, 30);
    fill(0, 255, 0);
    ellipse(200, 55, 40, 40);
  }
  if (OrdreMarche == 'M')
  {
    fill(0);
    text("Arrêt", 60, 30);
    fill(255, 0, 0);
    ellipse(70, 55, 40, 40);
  }
  if (OrdreMarche2 == 'M')
  {
    fill(0);
    text("Arrêt", 230, 30);
    fill(255, 0, 0);
    ellipse(240, 55, 40, 40);
  }
  distance= int(cp5.get(Textfield.class, "input").getText());
  distance2= int(cp5.get(Textfield.class, "distance2").getText());
  println (OrdreMarche+","+distance+","+distance2);
  myPort.write(""+OrdreMarche+OrdreMarche2+","+distance+","+distance2+","); // envoi de consigne à l'arduino, il faut bien penser à mettre des virgule en "" afin de séparer les variables.
  myPort.write("\n");
  text(stepcounter, 100, 10);
}

void mousePressed()
{
  if ( mouseX >= 15 && mouseX <=45 && mouseY >= 40 && mouseY<=70)
  {
    OrdreMarche = 'M' ;
  }
   if ( mouseX >= 175 && mouseX <=215 && mouseY >= 40 && mouseY<=70)
  {
    OrdreMarche2 = 'M' ;
  }
  if ( mouseX >= 55 && mouseX <=85 && mouseY >= 40 && mouseY<=70)
  {
    OrdreMarche = 'A' ;
  }
  if ( mouseX >= 225  && mouseX <=265 && mouseY >= 40 && mouseY<=70)
  {
    OrdreMarche2 = 'A' ;
  }
}

 void serialEvent (Serial myPort)
 {
   String retour = myPort.readStringUntil('\n'); //lit la donnée jusqu'à la fin de ligne
   if (retour!= null)
   {
     retour = trim(retour);
     stepcounter = int (retour);
   }
 }


et le code arduino :
Code: [Select]

char OrdreMarche[2]; // variable de stockage des valeurs reçues sur le port Série
int stepcounter,stepcounter2;
int distance;

void setup()   { // debut de la fonction setup()
  pinMode(8, OUTPUT);     
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);     
  pinMode(11, OUTPUT);
  digitalWrite(8, LOW);
  digitalWrite(9, LOW);
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  Serial.begin(115200); // initialise connexion série à 115200 bauds
}

void loop(){ // debut de la fonction loop()


  while (Serial.available() > 0 ) { // si un octet en réception

    Serial.readBytes(OrdreMarche,2);
    int distance = Serial.parseInt();
    int distance2 = Serial.parseInt();

    if (Serial.read() == '\n') {
      if (OrdreMarche[0]== 'M' ) { // si Octet reçu est le 1
        while(stepcounter <= distance )
        {
          digitalWrite(9, HIGH);
          delayMicroseconds(30);         
          digitalWrite(9, LOW);
          delayMicroseconds(30);
          stepcounter = stepcounter++;
        }
       
      }
      if (OrdreMarche[1]== 'M' ) { // si Octet reçu est le 1
        while(stepcounter2 <= distance2 )
        {
          digitalWrite(11, HIGH);
          delayMicroseconds(30);         
          digitalWrite(11, LOW);
          delayMicroseconds(30);
          stepcounter2 = stepcounter2++;
        }
       
      }
           
      if (OrdreMarche[0]== 'A' ) { // si octet reçu est le L

        stepcounter = 0;
      }
      if (OrdreMarche[1]== 'A' ) { // si octet reçu est le L

        stepcounter2 = 0;
      }
      Serial.println(OrdreMarche);
    }
   
  }
}



je pense que le problème vient de la réception des données au niveau de l'arduino mais je suis pas sur dans l'attente de votre avis,
merci d'avance.
Bonne journée,
Cordialement,

dfgh

hello
dans processing, "draw" est l'équivalent de "loop"

donc tu noies ton UNO sous un flux constant d'ordres de "marche"

fais ce test que je viens de faire:
dans processing, tu déclares "long compteur_serie"

puis dans draw tu modifies la fin de draw
distance= int(cp5.get(Textfield.class, "input").getText());
  distance2= int(cp5.get(Textfield.class, "distance2").getText());
  println (OrdreMarche+","+OrdreMarche2+","+distance+","+distance2+","+stepcounter);
  myPort.write(""+OrdreMarche+OrdreMarche2+","+distance+","+distance2+","); // envoi de consigne à l'arduino, il faut bien penser à mettre des virgule en "" afin de séparer les variables.
  myPort.write("\n");
  text(stepcounter, 100, 10);
  println(compteur_serie++);


et regarde ce qui se passe dans la fenetre noire

Yab974

merci pour cette remarque en effet avec le code test j'ai bien vu que j'envoyais trop souvent sur la liaison série.
j'ai donc modifié le code pour envoyer uniquement lorsque j'ai une valeur qui change mais malheureusement au bout d'un moment j'ai toujours le même problème ou plus rien ne se passe.
Surtout quand j'envoie des valeurs supérieur à 9999.

dfgh

tu laisses la partie processing de coté
tu mets ce prg dans l'arduino et tu envoies par la ligne de cde du moniteur

MM,10000,2   et return
tu regardes sur le moniteur ce qui se passe et tu en tires tes conclusions
Code: [Select]


char OrdreMarche[2]; // variable de stockage des valeurs reçues sur le port Série
int stepcounter1,stepcounter2;
int distance1;
int distance2;

byte buffer[512];

void setup()   { // debut de la fonction setup()
  pinMode(8, OUTPUT);     
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);     
  pinMode(11, OUTPUT);
  digitalWrite(8, LOW);
  digitalWrite(9, LOW);
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  Serial.begin(115200); // initialise connexion série à 115200 bauds
}

void loop(){ // debut de la fonction loop()


  while (Serial.available() > 0 ) { // si un octet en réception
//Serial.readBytes(buffer, longueur);
    Serial.readBytes(OrdreMarche,2);
    distance1 = Serial.parseInt();
    distance2 = Serial.parseInt();

    //if (Serial.read() == '\n')
    {
Serial.print("OrdreMarche[0] ");Serial.println(OrdreMarche[0]);
Serial.print("OrdreMarche[1] ");Serial.println(OrdreMarche[1]);


//for(int f=0;f<5;f++){Serial.print("OrdreMarche[");Serial.print(f);Serial.print("] ");Serial.println(OrdreMarche[f]);}

     
Serial.print("distance1 ");Serial.println(distance1);
Serial.print("distance2 ");Serial.println(distance2);

      if (OrdreMarche[0]== 'M' ) { // si Octet reçu est le 1
        while(stepcounter1 <= distance1)
        {Serial.print("distance1 ");Serial.println(distance1);
          digitalWrite(9, HIGH);
          delayMicroseconds(30);         
          digitalWrite(9, LOW);
          delayMicroseconds(30);
          stepcounter1++;
          Serial.print("stepcounter1 ");Serial.println(stepcounter1);
        }
       distance1=0;stepcounter1 =0;
      }
      if (OrdreMarche[1]== 'M' ) { // si Octet reçu est le 1
        while(stepcounter2 <= distance2 )
        {Serial.print("distance2 ");Serial.println(distance2);
          digitalWrite(11, HIGH);
          delayMicroseconds(30);         
          digitalWrite(11, LOW);
          delayMicroseconds(30);
          stepcounter2++;
          Serial.print("stepcounter2 ");Serial.println(stepcounter2);
        }
       distance2=0;stepcounter2 =0;
      }
           
      if (OrdreMarche[0]== 'A' ) { // si octet reçu est le L

        stepcounter1 = 0;Serial.println("  A  OrdreMarche[0] ");Serial.println(OrdreMarche[0]);
      }
      if (OrdreMarche[1]== 'A' ) { // si octet reçu est le L

        stepcounter2 = 0;Serial.println("  A  OrdreMarche[1] ");Serial.println(OrdreMarche[1]);
      }
     
    }
   
  }
}


Yab974

Bonjour,
J'ai essayé ton programme sans me soucier de processing et je n'arrive pas à trouver le problème sachant qu'il marche plus ou moins bien.

J'ai réessayer mon programme avec processing et le problème c'est qu'il marche correctement si les valeurs de distance 1 et distance 2 ne dépasse jamais 9999.

je trouve cela quand même étrange.

franchement si vous avez une idée je suis partant car je désespère.


Go Up