Détails

Clics : 10

Commande de vitesse d’un moteur à courant continu avec encodeur et PID

Ce programme Arduino permet de commander la vitesse d’un moteur à courant continu à l’aide d’un pont en H de type L298N, d’un encodeur incrémental et d’une correction PID.

Principe

L’encodeur mesure la vitesse réelle du moteur. Le programme compare cette vitesse à une consigne. L’erreur est ensuite corrigée par un régulateur PID qui ajuste automatiquement le rapport cyclique PWM.

Matériel utilisé

• Arduino Uno
• Pont en H L298N
• Moteur à courant continu
• Encodeur incrémental
• Alimentation adaptée au moteur

Branchements proposés

Programme Arduino

 
// Commande de vitesse d'un moteur CC avec encodeur et PID 
// Arduino Uno + pont en H L298N 
// Mesure de vitesse par encodeur incrémental 
 
const int pinPWM = 9; // ENA du L298N 
const int pinIN1 = 7; // IN1 du L298N 
const int pinIN2 = 8; // IN2 du L298N 
 
const int pinEncodeurA = 2; // Sortie A encodeur, interruption 0 
const int pinEncodeurB = 3; // Sortie B encodeur 
 
volatile long compteurImpulsions = 0; 
 
// À adapter selon l'encodeur utilisé 
const int impulsionsParTour = 20; 
 
// Consigne de vitesse 
float consigneRPM = 120.0; 
 
// Mesure de vitesse 
float vitesseRPM = 0.0; 
 
// Coefficients PID à régler expérimentalement 
float Kp = 1.2; 
float Ki = 0.4; 
float Kd = 0.05; 
 
// Variables PID 
float erreur = 0.0; 
float erreurPrecedente = 0.0; 
float integrale = 0.0; 
float derivee = 0.0; 
 
// Commande moteur 
float commandePID = 0.0; 
int commandePWM = 0; 
 
// Échantillonnage 
unsigned long tempsPrecedent = 0; 
const unsigned long periodeEchantillonnage = 100; // en ms 
 
void setup() { 
Serial.begin(9600); 
 
pinMode(pinPWM, OUTPUT); 
pinMode(pinIN1, OUTPUT); 
pinMode(pinIN2, OUTPUT); 
 
pinMode(pinEncodeurA, INPUT_PULLUP); 
pinMode(pinEncodeurB, INPUT_PULLUP); 
 
attachInterrupt(digitalPinToInterrupt(pinEncodeurA), compterImpulsion, RISING); 
 
// Sens de rotation du moteur 
digitalWrite(pinIN1, HIGH); 
digitalWrite(pinIN2, LOW); 
 
analogWrite(pinPWM, 0); 
 
tempsPrecedent = millis(); 
} 
 
void loop() { 
unsigned long tempsActuel = millis(); 
 
if (tempsActuel - tempsPrecedent >= periodeEchantillonnage) { 
float dt = (tempsActuel - tempsPrecedent) / 1000.0; 
tempsPrecedent = tempsActuel; 
 
// Lecture sécurisée du compteur d'impulsions 
noInterrupts(); 
long impulsions = compteurImpulsions; 
compteurImpulsions = 0; 
interrupts(); 
 
// Calcul de la vitesse en tr/min 
vitesseRPM = (impulsions / (float)impulsionsParTour) * (60.0 / dt); 
 
// Calcul de l'erreur 
erreur = consigneRPM - vitesseRPM; 
 
// Terme intégral 
integrale += erreur * dt; 
 
// Anti-emballement de l'intégrale 
if (integrale > 255) integrale = 255; 
if (integrale < -255) integrale = -255; 
 
// Terme dérivé 
derivee = (erreur - erreurPrecedente) / dt; 
 
// Calcul de la commande PID 
commandePID = Kp * erreur + Ki * integrale + Kd * derivee; 
 
erreurPrecedente = erreur; 
 
// Conversion en PWM 
commandePWM = (int)commandePID; 
 
// Saturation de la commande PWM 
if (commandePWM > 255) commandePWM = 255; 
if (commandePWM < 0) commandePWM = 0; 
 
analogWrite(pinPWM, commandePWM); 
 
// Affichage sur le moniteur série 
Serial.print("Consigne : "); 
Serial.print(consigneRPM); 
Serial.print(" tr/min | Vitesse : "); 
Serial.print(vitesseRPM); 
Serial.print(" tr/min | Erreur : "); 
Serial.print(erreur); 
Serial.print(" | PWM : "); 
Serial.println(commandePWM); 
} 
} 
 
void compterImpulsion() { 
compteurImpulsions++; 
} 

Remarques importantes

• La valeur impulsionsParTour doit être adaptée à l’encodeur utilisé.
• Les coefficients Kp, Ki et Kd doivent être réglés expérimentalement.
• Il faut impérativement relier les masses de l’Arduino, du L298N et de l’alimentation moteur.
• Si la vitesse mesurée est instable, il faut augmenter légèrement la période d’échantillonnage.