Robot-Car - La vitesse (3ème partie)

Pour réaliser ce projet, il est conseillé d'avoir suivi les pages : 

• L298n - Driver Pont H
• HC-05 - Bluetooth
• Les buzzers actif et passifs
• Le signal PWM
• Robot-Car - Les moteurs (1ere partie)
• Robot-Car - Feux AV/AR et klaxon (2ème partie)

Les jumpers JMP2 et JMP3 du L298n renvoient du +5v sur ENA et ENB, se qui permet de faire tourner les moteurs à leur maximum de puissance, donc à leur maximum de vitesse.

Pour controler la vitesse, il suffit simplement de modifier la tension envoyée sur ENA et ENB.

On retire les jumpers JMP2 et JMP3, et l’on relie ENA et ENB, chacune sur une pin Digital PWM de l'Arduino.

On envoie sur la pin PWM, une tension variable entre 0v et +5v suivant la valeur du PWM (0 à 255) utilisée pour gérer la vitesse des moteurs.

  (Tension d'alimentation +5v / 255) * La valeur du PWM = Tension de sortie  

Voir page Le signal PWM

Pin PWM de l'Arduino Uno

• D3, D5, D6, D9, D10 ou D11

ENA et ENB 

Le câblage à changer par rapport à la page Robot-Car - Les moteurs

La construction switch case est semblable à une série de if regroupé dans une seule composition.

La condition est remplacée par une expression évaluée par le switch.

Chaque case mentionne la valeur de l’expression pour laquelle ses instructions doivent être exécutées.

Dans notre code, le switch(command) évalue le contenu de la variable command,

Et suivant le contenu de la variable command, le case exécute l'instruction correspondante.

Chaque ligne case doit se terminer par la commande break.

L'application Bluetooth RC Controller envoie les caractères suivants en fonction de la position du curseur de vitesse.

De gauche à droite,      MINIMUM     0, 1, 2, 3, 4, 5, 6, 7, 8, 9 et q    MAXIMUM  

1ére étape

On mesure la tension max aux bornes du bornier des moteurs avec les jumpers JMP2 et JMP3, les moteurs tournerons à la vitesse maximum, cette tension est fonction de la tension d'alimentation globale des batteries utilisées. 

Pour mon Robot-Car, j'utilise 6 piles +1,5v rechargeables , et j'ai mesuré une tension globale de 6x1.5 = +9v , lorsque les piles sont chargées aux max

J'ai constaté que les piles +1,5v rechargeables donnent +1,5v lorsque qu'elles sont chargées au max et seulement +1,3v à +1,2v après quelques heures d'utilisation.

2ème étape

On retire les jumpers JMP2 et JMP3 et l'on câble les broches ENA et ENB sur des pins PWM  de l'Arduino.

3ème étape

Puisque l'application propose 10 "sauts" pour la vitesse (de 1 à q), nous pouvons donc établir que la valeur de départ du PWM est 255 / 10 = 25,5

Et que à chaque "saut" , on rajoute 25,5 , etc ...

• 0  = 0
• 1  = 25,5
• 2 = 51
• 3 = 76,5
• 4 = 102
• 5 = 127,5
• 6 = 153
• 7 = 178,5
• 8 = 204
• 9 = 229,5
• q = 255

(J'ai volontairement enlevé les chiffres apres la virgule)

On fait une régle de trois, pour connaitre les tensions à appliquer aux bornes des moteurs

(7.8v / 255) x (la valeur PWM) = Tension de sortie

On constate que les moteurs tournerons seulement à partir 

de la valeur case '5'

Donc il faut adapter les valeurs PWM pour que les moteurs 

tournent avec toutes les valeurs de case

Exemple dans mon code:     

Ces valeurs correspondent à mon Robot-Car avec une alimentation de +7.8v. 

Avec une alimentation différente, vous devez recalculer les tensions moteurs

• switch(command) évalue le contenu de la variable command
• si la variable command contient 5, la ligne case '5' ....   est éxecutée, et la valeur 127 est affectée à la variable valeur_PWM 
• la pin PWM (valeur 127) envoie une  tension de (7.8v / 255) x 127, ce qui  correspond environ à une tension de 3.88v.
• la ligne se termine par la commande break.

Utilisation :

• switch case
• analogWrite pour le PWM
• digitalWrite pour le HIGH et LOW
• tone et noTone

/*
 * ter un Robot-Car en Bluetooth avec un Smartphone Android ONLY
 * Application Bluetooth RC Controller
 * Alimenter 6 x piles 1,2v 2500mA = 7.8v
 * HC-05 - RXD en D1, TXD en D0, VCC en +5v ,GND en GND
 * L298n - ENA en D11, IN1 en D13, IN2 en D12, IN3 en D8, IN4 en D7, ENB en D6 
 * Feux AV en D2, Feux AR en D3, Klaxon en D4
*/
int ena = 11;  //Moteur A
int in1 = 13;
int in2 = 12;
int in3 = 8;  //Moteur B
int in4 = 7;
int enb = 6;
int valeur_PWM = 0; // variable PWM de 0 à 255
char t;
int feuAV = 2;  // broche feu AV
int feuAR = 3;  // broche feu AR
int klaxon = 4; // broche klaxon AV
int Tempo=200;

void setup() {
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  pinMode(ena, OUTPUT);
  pinMode(enb,OUTPUT);
  pinMode(feuAV,OUTPUT);
  pinMode(feuAR,OUTPUT);
  pinMode(klaxon,OUTPUT);
  Serial.begin(9600);
}

void loop() {
  if (Serial.available()>0) {
    t = Serial.read();
    Serial.println(t);
       
    switch (t) {
      /*  Calcul de la tension moteur avec pile 7.8v => (7.8v/255)*valeur_PWM
          en dessous de 3.8v les moteurs ne tournent pas( Moteur mini +3v)
          On constate une réelle différence entre la tension calculée 
          et la tension réelle mesurée 
      */
      case '0':valeur_PWM = 0;break; 
      case '1':valeur_PWM = 128;break; 
      case '2':valeur_PWM = 128;break;
      case '3':valeur_PWM = 156;break; 
      case '4':valeur_PWM = 156;break; 
      case '5':valeur_PWM = 184;break; 
      case '6':valeur_PWM = 184;break; 
      case '7':valeur_PWM = 212;break; 
      case '8':valeur_PWM = 212;break; 
      case '9':valeur_PWM = 255;break; 
      case 'q':valeur_PWM = 255;break; 
      }
      analogWrite(ena,valeur_PWM);
      analogWrite(enb,valeur_PWM);
// Les Moteurs
if(t == 'F'){            //AV 13-8 - lettre F
  digitalWrite(in1,HIGH);
  digitalWrite(in2,LOW);
  analogWrite(ena,valeur_PWM);  //PWM
  digitalWrite(in3,HIGH);
  digitalWrite(in4,LOW);
  analogWrite(enb,valeur_PWM);  //PWM
}
else if(t == 'B'){      //AR 12-7 - lettre B
  digitalWrite(in1,LOW);
  digitalWrite(in2,HIGH);
  analogWrite(ena,valeur_PWM);  //PWM
  digitalWrite(in3,LOW);
  digitalWrite(in4,HIGH);
  analogWrite(enb,valeur_PWM);  //PWM
}
else if(t == 'L'){      //DROITE 12-8 - lettre L
  digitalWrite(in1,LOW);
  digitalWrite(in2,HIGH); 
  analogWrite(ena,valeur_PWM);  //PWM
  digitalWrite(in3,HIGH);
  digitalWrite(in4,LOW);
  analogWrite(enb,valeur_PWM);  //PWM
}
else if(t == 'R'){      //GAUCHE 13-7 - lettre R
  digitalWrite(in1,HIGH);
  digitalWrite(in2,LOW);
  analogWrite(ena,valeur_PWM);  //PWM
  digitalWrite(in3,LOW);
  digitalWrite(in4,HIGH);
  analogWrite(enb,valeur_PWM);  //PWM
}
else if(t == 'S'){      //STOP (all motors stop)= S - Lettre S
  digitalWrite(in1,LOW);
  digitalWrite(in2,LOW);
  digitalWrite(in3,LOW);
  digitalWrite(in4,LOW);
}
delay(100);
}
// Feux AV et AR
else if(t == 'W'){      //Feu AV ON = W - Lettre W
  digitalWrite(feuAV,HIGH);
}
else if(t == 'w'){      //Feu AV Off = w - Lettre w (petit)
  digitalWrite(feuAV,LOW);
}
else if(t == 'U'){      //Feu AR ON = U - Lettre U
  digitalWrite(feuAR,HIGH);
}
else if(t == 'u'){      //Feu AR Off = X - Lettre u (petit)
  digitalWrite(feuAR,LOW);
}
else if(t == 'X'){      //Warning ON = X
  digitalWrite(feuAV,HIGH);
  digitalWrite(feuAR,HIGH);
  delay(100);
  digitalWrite(feuAV,LOW);
  digitalWrite(feuAR,LOW);
  delay(100);  
}
else if(t == 'x'){      //Warning Off = x - Lettre u (petit)
  digitalWrite(feuAV,LOW);
  digitalWrite(feuAR,LOW);
}
// Klaxon
else if(t == 'V'){      //Klaxon On = V - lettre V
  tone(klaxon,750,250);   // tone(pin,frequence,durée);
  delay(Tempo);
  tone(klaxon, 1000,250);
  delay(Tempo);
  tone(klaxon, 900,250);
  delay(Tempo);
}
else if(t == 'v'){      //Klaxon Off = v - Lettre v (petit)
  noTone(klaxon);
}
delay(100);
}

Télécharger le code ino

(Le fichier est zippé)