Salut a tous
 j 'utilise deux moteurs que j 'aimerais asservir en vitesse

Comme Dispositif ou matériel utilise:

- une voiture robot avec deux moteurs Dc
- deux capteurs rotatifs incrémentaux (gauche & droit) de types optocoupleur
- un Motorschield (L298N) pour l asservissement de mes moteurs

j 'utilise ces deux capteurs incrémentaux  pour le calcul de la vitesse que je voulais asservir

- A partir de ces deux capteurs et de mes fonctions interrupts ( dans le code) je peux calculer la vitesse en tours/s en sachant que le disque codeur a 20 tics par tour et je peux de ce fait le convertir en cm/s puisque je connais le rayon de ma roue

- J 'ai donc créer la fonction asservissement dans mon programme code ou je calcule la vitesse chaque 250 ms et je l'asservis .

Par contre mon asservissement ne fonctionne pas comme souhaitée , je ne me rapproche pas de la valeur de la consigne

Merci

#include <SimpleTimer.h>

SimpleTimer timer; 

// définition des pins de l'Arduino qui contrôlent le  moteur droit (jaune)
#define pinIN1 8
#define pinIN2 12
#define pinENA 6 // doit être une pin PWM     

// définition des pins de l'Arduino qui contrôlent le  moteur gauche(Bleue)
#define pinIN3 13
#define pinIN4 4
#define pinENB 5 // doit être une pin PWM   


#define trigger 9 // Arduino Pin an HC-SR04 Trig  doit etre un pwm (Couleur orange )
#define echo  7 // Arduino Pin an HC-SR04 Echo doit etre pwm (cable blanc)

volatile long distance = 0;

volatile int  comptageImpulsion_gauche=0; // variable accessible dans la routine interruption externe 0
volatile int comptageImpulsion_droite=0; // variable accessible dans la routine interruption externe 1

const int radius = 3.325;


int timerId;
         
volatile int vitMoteur = 0.;      
volatile int vitMoteur_gauche = 0.; 
volatile  double vitesse_droite ;
volatile  double vitesse_gauche ;
volatile  double vit ;
volatile  double erreur;

// nombre de ticks sur le disque codeur
const int pas= 20 ;

// consigne du moteur
double consigne_moteur= 30.0; // cm/s

// init calculs asservissement PID
double erreur_precedente= consigne_moteur;  // (en cm/s)
double somme_erreur = 0;
double erreur_precedente_gauche= consigne_moteur;  // (en cm/s)
double somme_erreur_gauche = 0;


//Definition des constantes du correcteur PID
double kp = 0.4;           // Coefficient proportionnel    
double ki = 2;              // Coefficient intégrateur
double kd = 1;           // Coefficient dérivateur



// duree d asservissement
double temps_asservissement = 250; // millisseconde


double dt = temps_asservissement /1000 ;  // seconde

unsigned long duree ;


void setup() {

  Serial.begin(9600);


  // Moteur Gauche
  pinMode(pinIN1, OUTPUT);
  pinMode(pinIN2, OUTPUT);
  pinMode(pinENA, OUTPUT);
  analogWrite(pinENA, 0);  // Initialisation sortie moteur à 0 
  delay(300);                // Pause de 0,3 sec pour laisser le temps au moteur de s'arréter si celui-ci est en marche
// Moteur droit
  pinMode(pinIN3, OUTPUT);
  pinMode(pinIN4, OUTPUT);
  pinMode(pinENB, OUTPUT);
  analogWrite(pinENB, 0);  // Initialisation sortie moteur à 0 
  delay(300);                // Pause de 0,3 sec pour laisser le temps au moteur de s'arréter si celui-ci est en marche



attachInterrupt(1, vitessedroite, RISING );
attachInterrupt(0, vitessegauche, RISING);

timerId= timer.setInterval(temps_asservissement, asservissement);


}

void loop() {

timer.run(); 



  


}

void asservissement(){

noInterrupts();
int gauche = comptageImpulsion_gauche;
int droite=comptageImpulsion_droite;

// reinitialisation de mon tick de la codeuse
 comptageImpulsion_gauche= 0; //  
 comptageImpulsion_droite= 0;


/******* calcul des vitesses en cm/s ********/
double rotation_gauche = ( gauche/ pas)/dt ;      // vitesse du moteur gauche en tour/s
double vitesse_gauche = ( 2*3.14*radius)*rotation_gauche; // cm /s
double rotation_droite = (droite/ pas)/dt ;// vitesse du moteur droit en  1 tour/s
double vitesse_droite = (2*3.14*radius)*rotation_droite;
 
double vit_droite = vitesse_droite;
double vit_gauche = vitesse_gauche;

/******* fin de calu des vitesses en cm/s ********/



/******* Régulation PID moteur droit ********/
 double erreur = consigne_moteur-vit_droite;
somme_erreur=somme_erreur+ erreur ;
double delta = erreur -erreur_precedente;
erreur_precedente = erreur;
vitMoteur = (kp*erreur +ki*somme_erreur+ kd*delta) ;
 /******* FIN Régulation PID moteur Droit ********/

/******* Régulation PID moteur gauche ********/
 double erreur_gauche = consigne_moteur-vit_gauche;
somme_erreur_gauche=somme_erreur_gauche+ erreur ;
double delta_gauche = erreur -erreur_precedente_gauche;
erreur_precedente_gauche = erreur_gauche;
vitMoteur_gauche = (kp*erreur_gauche +ki*somme_erreur_gauche+ kd*delta_gauche) ;
 /******* Régulation PID moteur gauche********/


/******* En cas de saturation ********/
if (vitMoteur_gauche > 255) {
   vitMoteur_gauche= 255;  // sachant que l'on est branché sur un pont en H L298
 } 
 else if (vitMoteur_gauche <0) {
  vitMoteur_gauche= 0;
 }
 
if (vitMoteur > 255) {
   vitMoteur = 255;  // sachant que l'on est branché sur un pont en H L298
 } 
 else if (vitMoteur <0) {
  vitMoteur = 0;
 }
/******* En cas de saturation ********/


/******* Sortir PWM moteur gauche et droite ********/
avancer_droite(vitMoteur);
avancer_gauche(vitMoteur_gauche);
/******* Sortir PWM moteur gauche et droite ********/

interrupts();

/******* lire dans le moniteur ********/
 Serial.print("vitMoteur_gauche :");
 Serial.print(vitMoteur_gauche);
 Serial.println();

Serial.print("vitMoteur_droite:");
Serial.print(vitMoteur);
Serial.println();
   

  }


 void avancer_gauche(int Powerrate){
  analogWrite( pinENA, Powerrate );
  digitalWrite( pinIN1, false );
  digitalWrite( pinIN2, true );}


  void avancer_droite (int power){
  // Moteur droit 
   analogWrite( pinENB, power );
  digitalWrite( pinIN3, LOW );
  digitalWrite( pinIN4, HIGH );
  }

void vitessegauche() {// la fonction appelée par l'interruption externe n°0

comptageImpulsion_gauche=comptageImpulsion_gauche+1; // Incrémente la variable de comptage

}

void vitessedroite() {// la fonction appelée par l'interruption externe n°1

comptageImpulsion_droite=comptageImpulsion_droite+1; // Incrémente la variable de comptage

}

-
Edité par LudovicSofo 14 février 2019 à 18:03:20

Désactiver les interruptions le temps de copier les variables de comptage et les remettre à zéro, c'est une très bonne chose.

En revanche, les laisser désactiver le temps de faire les lourds calcul sur les double, ce n'est pas une bonne idée, tu risque de manquer des impulsions.

Ton appel à interrupts() ligne 167 devrait plutôt se retrouver ligne 114, après avoir remis les compteur à 0.

Ainsi, ton arduino continuera de compter les pulses le temps de faire les calculs d'asservissement

***

Tu devrais aussi vérifier le type de tes variables avant de faire des division.

Avoir des compteur sur des entiers, c'est tout à fait logique, cela permet de faire une incrémentation beaucoup plus vite que sur un float.

En revanche, quand tu fais (gauche/ pas), vu que les variables gauche et pas sont des int, il s'agit d'une division entière, qui donnera un chiffre entier.

Par exemple, 39/20 donnera le résultat 1 et non 1.95 comme on pourrait s'y attendre.

Bref, tu devrais convertir tes variables en double lorsque cela est nécessaire.

Merci de votre réponse

"Ainsi, ton Arduino continuera de compter les pulses le temps de faire les calculs d'asservissement "

En comptant les pulses pendant le temps de faire des calculs asservissement n 'entraîne t -il pas une possibilité d avoir des erreurs lors du calcul des vitesses (gauche et droite), car sur la ligne 116 et 118 j 'utilise dt (Temps d 'asservissement)

Je pense alors que le temps d 'asservissement ne sera plus dt mais plutôt (dt + le temps ou tu actives l'interrupt jusqu’à la fin de l'asservissement) ?

***

Concernant les types de variables dans la ligne 116 et 118 

Puisque le temps d'asservissement dt est un double, je me suis dit forcement que j aurais un double comme sortie (Vitesse gauche et droite)

Dois je d'abord convertir (gauche/pas) en double avant d'effectuer mon calcul ?

je pourrais donc écrire par exemple a la ligne 114

double value = double(gauche/pas);
double vitesse gauche =  value /dt;

Merci de votre réponse

Pour ta première question, un petit résonnement inverse permet d'y répondre facilement :

Sur ton programme arduino, tu utilises un timer pour déclencher le traitement des calculs toutes les 250ms.

Donc ta fonction de calcul est exécuté toutes les 250ms et fait ses calculs avec un dt correspondant à 250ms.

Imaginons que ces calculs prennent 248ms (ce qui est un peu disproportionné mais c'est très bien pour mon explication), alors les interruptions seront désactivées pendant 248ms puis activé pendant 2ms.

Donc au final, tes pulses ne seront pris en compte que pendant 2ms alors que tes calculs se basent sur 250ms.

Trouves tu normales de compter des pulses pendant seulement 2ms ???

Bref, il te faut désactiver les interruptions le moins de temps possible !

En faite, ce qu'il faut voir, c'est que pendant que l'arduino fait ses calculs pour l'asservissement N, il y a l'interruption qui tourne en arrière plan pour incrémenter la valeur du compteur qui servira à l'asservissement N+1

***

Sur ta ligne de calcul 116 et 118, tu as plusieurs opérations sur une seule ligne.

Cependant, l'arduino ne peut pas exécuter tout d'un coup, il procède par etape.

Cela revient à avoir ce code :

tmp = gauche/ pas
rotation_gauche = tmp / dt

Les variables gauche et pas étant des entiers, la division se fera sur un nombre entier et tmp sera un nombre entier (donc 39/20 donnera 1)

Ensuite, vient la division tmp par dt, qui se fera sur des nombres flotant car dt est un nombre flotant.

Pour bien faire, il te faut donc faire des conversions AVANT calcul et non APRES calcul.

Tu devrais doit avoir cette ligne :

rotation_gauche = ( ((double)gauche) / ((double)pas) ) / dt;

Il est peut-être intéressant d'effectuer tous les calculs en entiers: ça augmente nettement la vitesse de traitement. Certains compilateurs permettent également de désactiver les float et les double ce qui permet de gagner en espace mémoire également.

Si tu travailles au centième près, il suffit mettre à l'échelle: par exemple, 0.03 deviendra 3 pour les calculs. Pareil pour les résultats : par exemple un résultat entier égal à 12546 correspondra en fait à 125.46

Merci de votre Aide

Je voudrais également déterminer exactement les facteurs kp,ki, etkd . Pour cela j 'ai besoin de la fonction transfert de mon système. Je ne sais pas comment je pourrais les obtenir

Jusqu'ici j 'ai pris ces valeurs par essai ou tâtonnement

J'ai pense a étudié mon système (Moteur + voiture) a l'aide d 'équations différentielles mais je n 'ai aucun paramètre de mon moteur (Interne résistance etc...)

Toute aide sera la bienvenue

Le plus simple à mon avis est de procéder à une identification expérimentale. La méthode de Strejc date un peu mais est facile à mettre en application. Ca peut être une bonne base.

Ensuite, il existe des méthodes permettant de déterminer les constantes Kp, Ki et Kd: Ziegler Nichols par exemple (encore une fois très ancienne, mais relativement facile à mettre en oeuvre)

Merci de votre réponse j 'ai quelque appréhension

j ai pense donc a faire une réponse impulsionnelle de mon système c est a dire je vais donner a l 'entrée de mon Système (Moteur +voiture) un Pwm (Y) de 255 et mesurer donc la valeur de mes capteurs (X) comme indique sur la figure suivante. Est ce bien pense? si Oui comment je peux l’implémenter sur Arduino?

Comment vais je pouvoir en plus enregistrer les valeurs mesures de mes capteurs que je vais ensuite pouvoir traiter ?

A partir de ces valeurs (Courbe du bas) je pourrais  obtenir la courbe de ma fonction de transfert . J'ai pense par la suite a l'aide de pid tuner de Matlab de trouver mes facteurs Kp,ki et kd . Est ce donc possible ?

-
Edité par LudovicSofo 21 février 2019 à 16:59:19

Je pensais à un générateur de tension de en entrée du système à identifier et à un relevé en sortie avec un oscilloscope numérique.

Mais si tu as déjà fait le câblage, pourquoi ne pas utiliser ta maquette en effet. Du coup, pourquoi une sortie PWM? Une sortie numérique est parfaitement capable d'envoyer ton échelon. Il faudrait voir ce fameux schéma. Sur quoi envoies-tu la pwm?

"Comment vais je pouvoir en plus enregistrer les valeurs mesures de mes capteurs que je vais ensuite pouvoir traiter ?"

Comment ça, "en plus" ? Il te faut faire un programme pour faire l'identification, puis, une fois le système identifié, tu détermines les réglages Kp, Ki et Kd que tu injectes dans un autre programme qui lui sera chargé de faire la régulation de l'ensemble.

Le programme pour faire l'identification que je comptes utiliser est Excel Tableau , la détermination de mes facteurs Kp, Ki et kd je compte le faire avec Pid Tuner de Matlab 

j 'ai pense a envoyer les valeurs mesurées de mon capteur rotatif incrémental dans un Excel Tableau a travers le macro PLX-DAQ (vu sur Google)  , j 'obtiendrai probablement  fonction transfert système (X(t)) en fonction du temps selon la courbe suivante ( j'ai des doutes) . Au cas ou je l'obtiens je pourrai passer a l’étape de la détermination des facteurs Kp ,Ki et kd

Pour envoyer l’échelon j 'ai utilise une sortie Numérique (PinIN5)

j 'ai essaye d’écrire un code pour cela

 
#include <SimpleTimer.h>

SimpleTimer timer; 

// définition des pins de l'Arduino qui contrôlent le  moteur gauche (jaune)
#define pinIN1 8
#define pinIN2 12
#define pinENA 6 // doit être une pin PWM 

#define pinIN5 7
// définition des pins de l'Arduino qui contrôlent le  moteur droit (Bleue)
#define pinIN3 13
#define pinIN4 4
#define pinENB 5 
 
volatile int comptageImpulsion_gauche=0; // variable accessible dans la routine interruption externe 0
volatile int comptageImpulsion_droite=0;

volatile  double vitesse_droite ;
volatile  double vitesse_gauche ;

volatile long entfernung = 0;
const int radius = 3.325  ; // cm;
const int pas= 20 ;


void setup() {
    
 Serial.begin(115200);
// Moteur Gauche
  pinMode(pinIN1, OUTPUT);
  pinMode(pinIN2, OUTPUT);
  pinMode(pinENA, OUTPUT);
 pinMode(pinIN5, OUTPUT);
 // Moteur droit
  pinMode(pinIN3, OUTPUT);
  pinMode(pinIN4, OUTPUT);
  pinMode(pinENB, OUTPUT);

timer.setInterval(1000, ISR_timerone);
   
attachInterrupt(1, vitessedroite, RISING);  //vitesse droite
attachInterrupt(0, vitessegauche, RISING);  // vitesse gauche

Serial.println("CLEARDATA");  // on efface les données déjà présentes, s'il y a lieu
Serial.println("LABEL,Temps,Vitesse"); // 


delay(2000);
}
 
void loop() {


digitalWrite(pinIN5, HIGH);
int tension = digitalRead(pinIN5);
while (tension == HIGH)
 {
    timer.run();
    avancer();
    
    
}

}

void avancer(){

analogWrite(pinENA, 255); 
digitalWrite(pinIN1, false); 
digitalWrite(pinIN2, true);
 
analogWrite(pinENB, 255); 
digitalWrite(pinIN3, false); 
digitalWrite(pinIN4, true);

}
void vitessegauche() {// la fonction appelée par l'interruption externe n°0

comptageImpulsion_gauche=comptageImpulsion_gauche+1; // Incrémente la variable de comptage

}

void vitessedroite() {// la fonction appelée par l'interruption externe n°1

comptageImpulsion_droite=comptageImpulsion_droite+1; // Incrémente la variable de comptage

}

void ISR_timerone()
{
   
  float rotation_gauche = ( ((double)comptageImpulsion_gauche) / ((double)pas)) ;// calculate RPS for Motor 1 tour/s
  float vitesse_gauche = (2*3.14*radius)*rotation_gauche;
  float rotation_droite = ( ((double)comptageImpulsion_droite) / ((double)pas)) ;// calculate RPS for Motor 1 tour/s
  float vitesse_droite = (2*3.14*radius)*rotation_droite;
 

  
  Serial.print("DATA,TIME,"); //envoi de la vitesse en excel
  Serial.println(vitesse_droite);
  comptageImpulsion_gauche= 0; //  reset counter to zero
  comptageImpulsion_droite= 0;
 
  
  
}

Quand je compile ma valeur de la vitesse droite mesurée n 'est pas constante malgré le fait que dans la fonction avancer le PWM reste constant a 255 j 'obtiens cela:

Toute Proposition , remarque est toujours la bienvenue

Merci d 'AVANCE

Quel est la résolution de tes capteurs incrémentaux (nombres de valeurs par tour)?

Tu fais un calcul de vitesse toutes les secondes? Ca correspond à combien de tours environ à pleine vitesse?

Fais-tu les mesures à vide ou en charge?

Schéma stp (bis) 

Chacun de mes capteurs a 20 valeurs par tour (j 'utilise deux interruptions externes pour chacun de mes capteurs)

-
Edité par LudovicSofo 23 février 2019 à 21:27:55

Oui le résultat affiche devrait correspondre  en cm/s

Oui le moteur entraîne ma voiture robot voici a quoi elle ressemble

https://www.youtube.com/watch?v=uW8YVcBjPGU

Par rapport a mes questions du post précédent je suis un peu confus

-
Edité par LudovicSofo 24 février 2019 à 19:14:36

Il est possible que pendant que tu fais ton calcul de vitesse tu loupes des impulsions. En principe, une routine d'interruption doit être la plus courte possible et tant qu'elle n'est pas terminée les interruptions sont désactivées.

Je ne connait pas bien le processeur utilisé, mais il me semble qu'une seule demande d'interruption non traitée peut être mémorisée. Toutes les autres sont donc perdues.

Il faudrait que tu diminues nettement le temps de calcul de la vitesse ou que tu la calcules dans la boucle principale éventuellement de manière à ne pas louper d'interruption.

Merci de votre reponse

j'utilise une carte Arduino uno avec un Processeur Atmega 328 . Je vais donc essayer de diminuer le temps de calcul de la vitesse . J'espere que je vais pouvoir avoir une vitesse constante lorsque le moteur tourne a pleine vitesse

A propos de la méthode a laquelle je souhaite déterminer mes facteurs kp, ki et kd  en passant par le macro PLX-DAQ , Est-elle réalisable?

LudovicSofo a écrit:

A propos de la méthode a laquelle je souhaite déterminer mes facteurs kp, ki et kd  en passant par le macro PLX-DAQ , Est-elle réalisable?