Dans cet article, nous allons aborder par la pratique l'utilité d'une carte de puissance, en l’occurrence la carte TB6612FNG afin de faire tourner deux moteurs.

Ceci servira de base à la construction d'une voiture électrique. Chaque roue avant sera alimentée par un des moteurs. En faisant tourner un des moteurs plus vite que l'autre, la voiture pourra ainsi tourner. Dans un autre article, nous verrons comment piloter cette voiture avec un capteur bluetooth avec comme télécommande une tablette android.

Pour piloter la carte de puissance, nous utiliserons une carte Arduino Uno.

Une carte de puissance a pour but de distribuer de la puissance, à la dose souhaitée, à des composants électriques, dans notre cas deux moteurs.

La carte de puissance est donc alimentée par une source d'énergie et la carte Arduino pilote cette carte afin de décider :

• de la puissance a distribué au moteur, ce qui permettra de le faire tourner plus ou moins vite (notion de PWM)
• du sens de la tension à appliquer au moteur, ce qui permettra de le faire tourner dans un sens ou dans un autre.

Description des broches de la carte de puissance TB6612FNG

Broche côté gauche

GND : vers GND de la carte Uno 

VCC : vers les 5V de la carte Uno

AO1 : vers le pôle - du moteur A

AO2 : vers le pôle + du moteur A => la tension à envoyer au moteur sera proportionnelle à la PWM choisie

BO2 : vers le pôle + du moteur B

BO1 : vers le pôle - du moteur B => la tension à envoyer au moteur sera proportionnelle à la PWM choisie

VMOT : vers le pôle + de la batterie

GND : vers le pôle - de la batterie

Broche côté droit

PWMA : vers une broche de type PWM de la carte Arduino => par programmation, on choisira la PWM à appliquer à cette broche, ce qui déterminera la tension à distribuer au moteur via les broches A01 et A02.

AIN2 : cette broche et la suivante permettent de déterminer le sens du courant à diffuser dans les broches A01/A02. Ainsi, pour faire avancer le moteur dans un sens, mettre AIN1 à HIGH, AIN2 à LOW et appliquer de la PWM à PWMA. Cette broche doit donc être reliée à une sortie digitale de la carte Arduino.

AIN1 : pour faire avancer le moteur dans un sens inverse, mettre AIN1 à LOW, AIN2 à HIGH et appliquer de la PWM à PWMA.

STBY : permet d'alumer ou éteindre le moteur. Il faut donc relier cette broche à une sortie digital de la carte Arduino

BIN1 : même logique que AIN1, mais pour contrôler un deuxième moteur que l'on nommera B

BIN2 : même logique que AIN2, mais pour contrôler un deuxième moteur que l'on nommera B

PWMB - même logique que PWMA mais pour contrôler la puissance du moteur nommé B

GND : à relier à GND de la carte Arduino.

Le code

Pour tester la voiture, on fera successivement :

• avance la voiture tout droit en distribuant la même puissance aux moteurs A et B
• tourner la voiture à droite en faisant tourner les roues de gauche un peu plus vite
• tourner la voiture à gauche en faisant tourner les roues de droite un peu plus vite
• reculer la voiture
• arrêter la voiture.

Le code ci-dessous indique les branchements entre la carte de puissance et l'arduino :

/* cablage des broches de la carte de puissance TB6612FNG vers la carte arduino */
#define PWMA 3
#define AIN1 2
#define AIN2 4
#define PWMB 5
#define BIN1 2
#define BIN2 4
#define STBY 6

 
void setup()
{
  /* definition des broches de la carte de puissance en tant que sortie */
  pinMode(PWMA,OUTPUT);
  pinMode(AIN1,OUTPUT);
  pinMode(AIN2,OUTPUT);
  pinMode(PWMB,OUTPUT);
  pinMode(BIN1,OUTPUT);
  pinMode(BIN2,OUTPUT);
  pinMode(STBY,OUTPUT);
  // Ouvre la voie série avec l'ordinateur
  Serial.begin(9600);
}
 
void loop() 
{
  startUp(); // on met la broche standby à HIGH
  goForward(30); // on avance avec une PWM de 30 pour les deux moteurs, donc on avance droit
  delay(5000); // on attend 5 secondes
  rotateRight(30); // on tourne a droite avec une pwm de 2*30 pour la roue gauche (moteur A) et de 30 pour la roue droite
  delay(2000); // on attend 2 secondes  
  rotateLeft(30); // on tourne a gauche avec une pwm de 30 pour la roue gauche et de 2*30 pour la roue droite
  delay(2000); // on attend 2 secondes
  shutDown(); // on met la broche standby à LOW, donc le moetr s'arrete
  startUp(); // on met la broche standby à HIGH
  goBackward(30); // on applique une PWD de 30 en ayant changé la polarité des tensions à appliquer aux moteurs pour faire tourner les moteurs dans le sens inverse
  delay(5000); // on attend 5 secondes
  shutDown(); // on arrete les moteurs avec broche standby à LOW
}


void startUp ()
{
  Serial.println("in startUp");
  digitalWrite(STBY,HIGH);
}

void shutDown ()
{
  Serial.println("in shutDown");
  digitalWrite(STBY,LOW);
}

void goForward (int pwm)
{
  Serial.println("in goForward");
  digitalWrite (AIN1,HIGH);
  digitalWrite (AIN2,LOW);
  analogWrite(PWMA,pwm);
  analogWrite(PWMB,pwm);  
}

void goBackward (int pwm)
{
  Serial.println("in goBackward");
  digitalWrite (AIN1,LOW);
  digitalWrite (AIN2,HIGH);
  analogWrite(PWMA,pwm);
  analogWrite(PWMB,pwm);    
}

void rotateRight (int pwm)
{
 Serial.println("in rotateRight");
 analogWrite(PWMA,2*pwm);
 analogWrite(PWMB,pwm); 
}

void rotateLeft (int pwm)
{
  Serial.println("in rotateLeft");
  analogWrite(PWMA,pwm);
  analogWrite(PWMB,2*pwm);   
}

Matériel nécessaire

• Une carte Arduino Uno
• Deux moteurs de Pololu modèle "50:1 Micro Metal Gearmotor HP with Extended Motor Shaft"
• Deux roues de Pololu modèle "Pololu Wheel 42×19mm Pair"
• Une carte de puissance de Pololu modèle "TB6612FNG Dual motor driver carrier"
• Une pile de 9V

Ce qui donne :

Bibliographie

Ci-dessous l'exemple en anglais qui traite de ce sujet :

http://www.embeddedrelated.com/showarticle/498.php