Go Down

Topic: problem of programmation maybe? (Read 274 times) previous topic - next topic

bvking

I don't manage to have good values of speed with a program of tachymetre.

Can anyone help me?

UKHeliBob

What do you see when you print the state variable ?
Do the values look correct ?
What have you got the Line ending set to in the Serial monitor ?
Please do not send me PMs asking for help.  Post in the forum then everyone will benefit from seeing the questions and answers.

bvking

stateB should be the speed here it is vit captée du moteur B and echantillion(indice).

When you look at the tick or signal it's very strange

tick= :71284.00
SIGNAL = :561
vit captée du moteur B: 285
echantillion(indice) : 285
vitesse moyenne du moteur B: 131
 vit moy Constrainte à A: 154
tick= :59380.00
SIGNAL = :673
vit captée du moteur B: 237
echantillion(indice) : 237
vitesse moyenne du moteur B: 143
 vit moy Constrainte à A: 164
tick= :70268.00
SIGNAL = :569
vit captée du moteur B: 281
echantillion(indice) : 281
vitesse moyenne du moteur B: 146
 vit moy Constrainte à A: 166
tick= :508.00
SIGNAL = :13204
vit captée du moteur B: 2
echantillion(indice) : 2
vitesse moyenne du moteur B: 125
 vit moy Constrainte à A: 150
tick= :316.00
SIGNAL = :-4490
vit captée du moteur B: 1
echantillion(indice) : 1
vitesse moyenne du moteur B: 96
 vit moy Constrainte à A: 126
tick= :204.00
SIGNAL = :-530
vit captée du moteur B: 0
echantillion(indice) : 0
vitesse moyenne du moteur B: 88
 vit moy Constrainte à A: 120
tick= :304.00
SIGNAL = :506
vit captée du moteur B: 1
echantillion(indice) : 1
vitesse moyenne du moteur B: 80
 vit moy Constrainte à A: 114
tick= :76816.00
SIGNAL = :520
vit captée du moteur B: 307
echantillion(indice) : 307
vitesse moyenne du moteur B: 111
 vit moy Constrainte à A: 138
tick= :32760.00
SIGNAL = :1221
vit captée du moteur B: 131
echantillion(indice) : 131
vitesse moyenne du moteur B: 124
 vit moy Constrainte à A: 149
tick= :44020.00
SIGNAL = :908
vit captée du moteur B: 176
echantillion(indice) : 176
vitesse moyenne du moteur B: 142
 vit moy Constrainte à A: 163
tick= :41184.00
SIGNAL = :971
 

TomGeorge

Hi,

Please read the first post in any forum entitled how to use this forum.
http://forum.arduino.cc/index.php/topic,148850.0.html then look down to item #7 about how to post your code.
It will be formatted in a scrolling window that makes it easier to read.

Can you please post a copy of your circuit, in CAD or a picture of a hand drawn circuit in jpg, png?

Thanks...  Tom.. :)
Everything runs on smoke, let the smoke out, it stops running....

bvking

Sorry for the presentation of my last post.

In my project i have to measure the speed of motor B to assign proportionnaly a motorA

You can see a motor with "helice"  and a encoded wheel

A L293D to control motor B and motor A (not plugged here)

And a steppermotor with a encoded whell.

bvking


PaulS

Quote
stateB should be the speed
No, it shouldn't. A state is something like on or off, in motion or stopped, or opening, closing, opened, or closed.
Speed is NOT a state.

Perhaps if you used reasonable names, the problem would become apparent.

Code: [Select]
   delay(100);
You just pissed away any chance at accuracy.

Code: [Select]
 volatile byte* port = portInputRegister(digitalPinToPort(pin));
It is pointless to declare local variables volatile.

I got
       lost trying
   to follow
                         your piss-poorly
         indented code.

    Use Tools + Auto Format before you post code again.

The Serial.print() statements in the program do not produce the output that you claim.
The art of getting good answers lies in asking good questions.

bvking

Code: [Select]



// Bug-fix pour Arduino 1.0.6
#define NOT_AN_INTERRUPT -1


//Ports de commande du moteur B

int motorPin1 = 4;
int motorPin2 = 5;
int enablePin = 6;
 
// Vitesse du moteur
int state = 0;

/* constantes pour la broche de mesure */
const byte PIN_SIGNAL = 2; //broche 2 ou 3 non obligatoire en entrée

float freq=0;


void setup() {
  
    
    /* Met la broche en entrée, ici capteur à fourche */  
  pinMode(PIN_SIGNAL, INPUT_PULLUP);


 
  //CONTROLE MOTEUR
    // Configuration des ports en mode "sortie"
    pinMode(motorPin1, OUTPUT);
    pinMode(motorPin2, OUTPUT);
    pinMode(enablePin, OUTPUT);
    
    // Initialisation du port série
    Serial.begin(9600);
}
 
void loop() {
  
  
  



// CONTROLE MOTEUR VIA MONITEUR SERIE
// Pont en H L298N

    if (Serial.available() > 0)
    {
    
      state = Serial.parseInt();
  
      //
      // Sens du mouvement
      //
      if (state > 0) // avant
      {
        digitalWrite(motorPin1, HIGH);
        digitalWrite(motorPin2, LOW);
        Serial.print("Avant ");
        Serial.println(state);
      }
      else if (state < 0) // arrière
      {
        digitalWrite(motorPin1, LOW);
        digitalWrite(motorPin2, HIGH);
        Serial.print("Arriere ");
        Serial.println(state);
      }
      else // Stop (freinage)
      {
        digitalWrite(motorPin1, HIGH);
        digitalWrite(motorPin2, HIGH);
        Serial.println("Stop");
      }
 
      //
      // Vitesse du mouvement
      //
      analogWrite(enablePin, abs(state));
    }
    delay(100);
    
    //TACHYMETRE
     /* Mesure la durée de la (demi) période */
  unsigned long periode = pulseInCycle(PIN_SIGNAL, HIGH, 1000000);
// periode est-il nombre de signaux par seconde?
// avec juste un signal par seconde */
 // Serial.println(1000000 / periode); // plus le resultat est grand moins la roue va vite
 
    /* Affiche le résultat de la mesure en tourparseconde donc la ferquence
  
 // avec 40  signaux par tour */
 // Serial.println(1000000 / (40*periode)); // disque de 20 trous soit 2*20 etat
 
freq=   (1000000 / (40*periode));
  
  Serial.print(" periode " ); Serial.println(periode); //:  plus la freq est petite plus la roue va lentement
// si la periode est trop lente soit moins de 1 signal par seconde alors pas de frequence


 if  (periode <1)
   {
    periode=1000000;
    }
      else //
      {
        periode=periode;

       }

  
  
 

  if  (freq <0.001)
   {
    freq=0;
    }
      else //
      {
        freq=freq;

       }

   Serial.print(" frequence autre:" );  Serial.println( 1000000/( 40*periode));
    Serial.print(" frequence :" );  Serial.println( freq);  

  
  delay(100);
}

unsigned long pulseInCycle(byte pin, byte startState, unsigned long timeout) {
 
  /* Compute low-level bitmask and port for direct I/O reading */
  byte bitmask = digitalPinToBitMask(pin);
  volatile byte* port = portInputRegister(digitalPinToPort(pin));
  byte mask = startState ? bitmask : 0;

  /* Get the starting time (for the timeout handling) */
  unsigned long startMicros = micros();

  /* Wait the end of the current starting state (avoid partial measure) */
  while ((*port & bitmask) == mask) {
    if (micros() - startMicros > timeout)
      return 0;
  }
  
  /* Wait for the next starting state */
  while ((*port & bitmask) != mask) {
    if (micros() - startMicros > timeout)
      return 0;
  }
  
  /* Start the counter */
  unsigned long start = micros();

  /* Measure the starting state duration */
  while ((*port & bitmask) == mask) {
    if (micros() - startMicros > timeout)
      return 0;
  }

  /* Measure the ending state duration */
  while ((*port & bitmask) != mask) {
    if (micros() - startMicros > timeout)
      return 0;
  }

  /* Compute the total duration */
  return micros() - start;
  
}
/[code]
[/code]

I don't understant wich state you want I print.
I tried startState and startMicros but it was not declared in the scope.

UKHeliBob

Quote
I don't understant wich state you want I print.
The one named state
Please do not send me PMs asking for help.  Post in the forum then everyone will benefit from seeing the questions and answers.

TomGeorge

Hi,

Can you please post a copy of your circuit, in CAD or a picture of a hand drawn circuit in jpg, png?


Thanks... Tom... :)
Everything runs on smoke, let the smoke out, it stops running....

bvking

Hi,
When I started my program I had a new problem without change anything.

Now, when I write whatever speed in the serial motor, after one loop, the monitor write stop as if I have written 0 myself!

So I have written 222, three times to control the motor B.

Here 222 is the variable state which I control with the monitor (the speed that I control myself not measured).


Code: [Select]

222
 periode 87108
 frequence autre:0
 frequence :0.00
Avant 222
222
 periode 96256
 frequence autre:0
 frequence :0.00
Avant 222
222
 periode 90112
 frequence autre:0
 frequence :0.00
/[code]
[/code]

bvking

Sorry don't look at the last results, it was an other program

My program stopped because of the carriage return I guess.

By the way I return the program where I put a delay of 100.
[/code]


// Bug-fix pour Arduino 1.0.6
#define NOT_AN_INTERRUPT -1
// TACHYMETRE SETUP

// programme pour le tachymetre sans bibliotheque pour utiliser n'importe qu'elle broche interruption
// pas seulement la deux ou trois



float tick=0; // . nombre d'interruption =0 pour l'encodeur à fourche // number of interruption to compute pulsation (speed detected)
int SIGNAL=0;

// // PROGRAM TO SMOOTH PULSATION WITH 20 SAMPLE

// Définition du nombre d'échantillons
// pour le calcul de la moyenne glissante de la vitesse du moteur B

const int nEchantillons = 20;  // 20 sample

int echantillon[nEchantillons];    // un tableau pour stocker les échantillons lus
int indice = 0;                    // l'indice de l'échantillon courant
int total = 0;                   // la somme des échantillons mémorisés
int moyenne = 0;                 // la moyenne des échantillons mémorisés // AVERAGE of PULSATION (speed detected))



//Ports de commande du moteur B

int motorPin1 = 4;
int motorPin2 = 5;
int enablePin = 6;

//Ports de commande du moteur A

int motorPin1A = 8;
int motorPin2A = 3;
int enablePinA = 7;


// Vitesse du moteur B initialisation// Speed motor B

int state = 0; // vitesse assignée  au moteur B par le moniteur serie (speed assigned to motor B by the serial monitor)
float w= 0; //frequence de B (pulsation of moteur B)
float acc=0; // acc de B pas utilisé (not used)
int stateB = 0; // echantillon de vitesse de B .  (pulsation measured by encodeur of motor B)


// Vitesse du moteur A initialisation// Speed motor A

// la vitesse du moteur A est proportionnelle à la moyenne de la vitesse captée du moteur B
// the speed of the motor A is proportional to the average of the speed of the motor B


int moyenneCA =0; // vitesse moyenne Contrainte pour controler vitesse A // average speed Constraint to control speed A


/* constantes pour la broche de mesure */
const byte PIN_SIGNAL = 2; //broche 2 ou 3 n'est pas obligatoire en entrée
// 9 fonctionne et les entrées A1...A5 aussi

void setup() {
 
   
   /* Met la broche en entrée, ici capteur à fourche */  
 pinMode(PIN_SIGNAL, INPUT_PULLUP);

 // On remplit le tableau d'échantillons avec des 0
 for (int i = 0; i < nEchantillons; i++) {
   echantillon = 0;
 }



 //CONTROLE MOTEUR
   // Configuration des ports en mode "sortie"
   pinMode(motorPin1, OUTPUT);
   pinMode(motorPin2, OUTPUT);
   pinMode(enablePin, OUTPUT);
   pinMode(motorPin1A, OUTPUT);
   pinMode(motorPin2A, OUTPUT);
   pinMode(enablePinA, OUTPUT);
   // Initialisation du port série
   Serial.begin(9600);
}

void loop() {

 /*   // CAPTEUR TCPM de B en mode "entrée"
valB = analogRead (TCPM);
int tensioneta = map(valB, -1000, 1000, -100, 100);
delay (10);*/

// CONTROLE MOTEUR B VIA MONITEUR SERIE // CONTROL B MOTOR WITH MONITOR SERIE
// Pont en H L298N // H BRIDGE L298N

   if (Serial.available() > 0)
   {
   
     state = Serial.parseInt();
 
     //
     // Sens du mouvement
     //
     if (state > 0) // avant
     {
       digitalWrite(motorPin1, HIGH);
       digitalWrite(motorPin2, LOW);
       Serial.print("Avant ");
       Serial.println(state);
     }
     else if (state < 0) // arrière
     {
       digitalWrite(motorPin1, LOW);
       digitalWrite(motorPin2, HIGH);
       Serial.print("Arriere ");
       Serial.println(state);
     }
     else // Stop (freinage)
     {
       digitalWrite(motorPin1, HIGH);
       digitalWrite(motorPin2, HIGH);
       Serial.println("Stop");
     }

     //
     // Vitesse du mouvement
     //
     analogWrite(enablePin, abs(state));
     
   
   delay(100);
     }
 Serial.print("state: "); Serial.println(state);
 
     // VITESSE CAPTEE du MOTEUR B par l'encodeur à fourche
     // speed encoded of B motor
     
 // Measure the duration of the half-period //
 // Mesure la durée de la (demi) période //
 unsigned long periode = pulseInCycle(PIN_SIGNAL, CHANGE, 1000000);

float tick = periode;
  SIGNAL= (1000000 / periode * 40);

 Serial.print ("tick= :");  Serial.println (tick);
 

   Serial.print ("SIGNAL = :");  Serial.println (SIGNAL);

if  (periode > 10000000)
  {
   SIGNAL=0;
   
   }
     else //
     {
       SIGNAL= SIGNAL;

      }


 Serial.print ("periode = :");  Serial.println (periode);

// avec juste un signal par tour */
 
 
 Serial.print ("signalbis"); Serial.println(1000000 / periode *40 );

// avec 40 signaux par tour car
// disque de 20 trous soit 20*2 =40 etat/tour)*/
//  Serial.print ("tourparsec = :");
//  Serial.println ( tick/1000000*40);
// Serial.print ("tourparmin = :");
//  Serial.println ( tick /1000000*40*60);
 
 
 //float w= (2*PI*tick/1000000*40); // omega=2PI*frequency;  
 //Serial.print("vit angul w = :"), Serial.println(w);


   
 // VITESSE CAPTEE DU MOTEUR  B en tour par second (in RPS)
   
 stateB= (tick /1000000*40*100); //entre 0 et 200
 Serial.print ("vit captée du moteur B: ") ; Serial.println (stateB);


  // CALCUL MOYENNE /AVERAGE CALCULATION
 
  // Soustraction de l'echantillon précédent
 total = total - echantillon[indice];
 
 // Lecture du capteur
 echantillon[indice] = (stateB);
 Serial.print ("echantillion(indice) : ");
 Serial.println (echantillon[indice]);
 
 // Ajout du dernier echantillon
 total = total + echantillon[indice];
 
 // Incrémentation de l'indice
 indice++;
 // si on est à la fin du tableau ...
 if (indice >= nEchantillons) {
   // ...retour au début
   indice = 0;
 
 }
 // calcul de la moyenne
 moyenne = total / nEchantillons;


 Serial.print("vitesse moyenne du moteur B: "); // average speed of motor B
 Serial.println(moyenne);
 delay(1);

 // CONTROLE DU MOTEUR A par rapport à la vitesse moyenne  de B "la moyenne de stateB"
 // MOTOR CONTROL A relative to the average speed of B "the stateB average"
 
 /* if (moyenne > 0) // avant
     {
       digitalWrite(motorPin1, HIGH);
       digitalWrite(motorPin2, LOW);
       Serial.print("Avant ");
       Serial.println(stateA);
     }
     else if (moyenne < 0) // arrière
     {
       digitalWrite(motorPin1, LOW);
       digitalWrite(motorPin2, HIGH);
       Serial.print("Arriere ");
       Serial.println(stateA);
     }
     else // Stop (freinage)
     {
       digitalWrite(motorPin1, HIGH);
       digitalWrite(motorPin2, HIGH);
       Serial.println("Stop");
     }  //*/
       digitalWrite(motorPin1A, LOW);
       digitalWrite(motorPin2A, HIGH);

// ETALONNER LA VITESSE MIN ET MAX DU MOTEUR A
// CALIBRATE THE MIN AND MAX SPEED OF THE MOTOR A

// moyenneC=  constrain (moyenne, 50,200);
 moyenneCA = map (moyenne, 50, 250, 90,250);
 Serial.print(" vit moy Constrainte à A: "); // average speed contsraint to motor A
 Serial.println(moyenneCA);
 analogWrite(enablePinA, (moyenneCA));
       
//  delay(1);

}

unsigned long pulseInCycle(byte pin, byte startState, unsigned long timeout) {

 /* Compute low-level bitmask and port for direct I/O reading */
 byte bitmask = digitalPinToBitMask(pin);
 volatile byte* port = portInputRegister(digitalPinToPort(pin));
 byte mask = startState ? bitmask : 0;

 /* Get the starting time (for the timeout handling) */
 unsigned long startMicros = micros();

 /* Wait the end of the current starting state (avoid partial measure) */
 while ((*port & bitmask) == mask) {
   if (micros() - startMicros > timeout)
     return 0;
 }
 
 /* Wait for the next starting state */
 while ((*port & bitmask) != mask) {
   if (micros() - startMicros > timeout)
     return 0;
 }
 
 /* Start the counter */
 unsigned long start = micros();

 /* Measure the starting state duration */
 while ((*port & bitmask) == mask) {
   if (micros() - startMicros > timeout)
     return 0;
 }

 /* Measure the ending state duration */
 while ((*port & bitmask) != mask) {
   if (micros() - startMicros > timeout)
     return 0;
 }

 /* Compute the total duration */
 return micros() - start;


   }  
[/code]

and here some result (222) is the "state" the speed I decided to give to the motor B

Code: [Select]



state: 222
tick= :47028.00
SIGNAL = :840
periode = :47028
signalbis840
vit captée du moteur B: 188
echantillion(indice) : 188
vitesse moyenne du moteur B: 89
 vit moy Constrainte à A: 121
state: 222
tick= :316.00
SIGNAL = :-4512
periode = :316
signalbis126560
vit captée du moteur B: 1
echantillion(indice) : 1
vitesse moyenne du moteur B: 86
 vit moy Constrainte à A: 118






Go Up