problem of programmation maybe?

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

Can anyone help me?

motor_l298N_tachymetreafaire.ino (4.05 KB)

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 ?

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

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… :slight_smile:

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.

Sorry i forgot picture.

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.

   delay(100);

You just pissed away any chance at accuracy.

 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.

// 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.

I don't understant wich state you want I print.

The one named state

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... :)

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).

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]

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 /10000004060);

_ //float w= (2PItick/100000040); // omega=2PIfrequency; _

  • //Serial.print(“vit angul w = :”), Serial.println(w);*

  • // VITESSE CAPTEE DU MOTEUR B en tour par second (in RPS)*

_ stateB= (tick /100000040100); //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
    * *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* *