Club robotique de Sophia-Antipolis

Accueil > Projets et études > Nos jeunes roboticiens l’ont fait > Construire une voiture télécommandée

Construire une voiture télécommandée

Piloter un moteur continu avec une carte Arduino

samedi 28 novembre 2015, par Pierre M.

Il n’est pas possible de brancher directement un moteur à une carte Arduino parce que cette dernière ne peut pas lui délivrer suffisamment de courant : mon moteur nécessite environ 1A. Alors, comment fait-­on pour faire contrôler un moteur continu avec une carte Arduino ?

Mon but est de pouvoir utiliser ce moteur dans une voiture télécommandée. Je vais procéder en plusieurs étapes : tout d’abord je vais tenter de contrôler le moteur depuis la carte Arduino mais dans un seul sens et à vitesse constante.
Ensuite je vais essayer de le piloter toujours à vitesse constante mais dans les deux sens.
Enfin j’essaierai de trouver une solution pour lui faire varier la vitesse.

 Etape 1 : piloter le moteur dans un seul sens et à vitesse constante

La solution que j’ai trouvée pour contrôler le moteur est d’utiliser un composant électronique entre la carte Arduino et le moteur : un transistor MOSFET. La carte Arduino peut envoyer un signal au MOSFET (tension de 0 ou 5V). Ce dernier pourra alors laisser passer un courant fort pour actionner le moteur. Pour cela, voici comment j’ai fait. Au début, je vais vous dire tous les composants qu’il vous faut :

  • deux cartes Arduino UNO
  • un moteur continu en 2-12V
  • quelques fils de connexion
  • une plaque à essai (breadboard)
  • une source électrique (transformateur adapté au moteur)
  • un double pont en H L298N pour les moteurs
  • un double pont en H L9110 pour le servo moteur
  • une carte SHD-JK Joystick Shield V2.0
  • deux émetteurs /récepteurs RF24....
  • un servomoteur Nikko
JPEG - 107 ko

Je vais vous expliquer le fonctionnement du MOSFET. Il y a 3 pattes sur le MOSFET : la source, le drain et la gâchette. C’est un peu comme un interrupteur. Lorsqu’on applique une tension sur la gâchette, le MOSFET laisse passer le courant entre la source et le drain, sinon le circuit reste ouvert et le courant ne passe pas. Dans mon circuit, le MOSFET laisse passer le courant uniquement s’il reçoit une tension de 5V de l’Arduino. On peut ainsi contrôler le moteur en ouvrant le circuit.

On regarde sur Internet le datasheet du composant. On repère alors où se trouvent les pattes 1 ,2 et 3 en gardant la partie argenté à l’arrière du MOSFET. Sur la patte 1 du MOSFET on branche l’Arduino, sur la patte 2 on branche le moteur et sur la patte 3 on branche la GND.

PNG - 86.3 ko

Pour le montage, je choisis de contrôler mon moteur avec la sortie numéro 9 de l’Arduino que je branche sur la patte 1 du MOSFET. Je branche la patte 2 du MOSFET au moteur et la patte 3 à la masse (GND) de la batterie.

voici le code de mon programme (sketch) Arduino pour tester cela

/*
brancher la gâchette du mosfet sur la sortie 9
le moteur est alimenté avec 5V (en direct, pas via l'Arduino)
le MOSFET sert d'interrupteur (coupe la masse) du moteur
*/

int const MOTEUR = 9; // le moteur est branché sur la patte 9 via un mosfet
// la fonction setup est appelée quand on appuie sur le bouton reset ou
// quand on allume la carte Arduino.
void setup() {
  // la carte Arduino envoie un signal en sortie (output).
  pinMode(MOTEUR, OUTPUT);
}
// boucle infinie
void loop() {
  digitalWrite(MOTEUR, HIGH);   // faire tourner le moteur
  delay(5000);                  // attendre 5 secondes
  digitalWrite(MOTEUR, LOW);    // arrêter le moteur
  delay(3000);                  // attendre 3 secondes
}

résultat obtenu :

— > le moteur tourne pendant 5 secondes puis il s’arrête pendant 3 secondes et recommence

 Etape 2 : piloter le moteur dans les deux sens et toujours à vitesse constante

JPEG - 99.6 ko

Je vais avoir besoin d’un pont en H. Son rôle c’est de pouvoir inverser la polarité aux bornes du moteur. Je vais vous expliquer son fonctionnement.

Si on devait fabriquer un pont H, il faudrait 4 MOSFET et 2 portes NON (sachant que les MOSFET sont des variantes des transistors). Le schéma ressemble à une lettre H c’est pour ça que cela s’appelle un pont en H.

Pour réaliser cela, il faut brancher 6 fils :

  • 2 fils sur les pôles + et - de l’alimentation,
  • 2 fils sur les bornes du moteur (à la sortie des MOSFET).
  • 2 fils pour donner les ordres de tourner dans un sens ou dans l’autre ou de s’arrêter

Les portes NON sont des composants qui forcent à ce que deux éléments aient des états opposés. Par exemple lorsqu’un MOSFET (ou un interrupteurs) laisse passer le courant, un autre auquel il est lié par une porte NON n’est pas passant.

PNG - 61.1 ko
Pont en H avec MOSFET
schéma réalisé avec Fritzing

Dans mon schéma, pour commander le moteur, j’envoie des signaux sur les "gâchettes" (repère G sur le schéma) des MOSFET M1, M2, M3 et M4.

Les MOSFET canal N laissent passer la masse (borne - de l’alimentation). Au contraire, les MOSFET canal P laissent passer la borne + de l’alimentation.

La porte logique NON assure que les MOSFET N et P (M1 et M3 et/ou M2 et M4) ne puissent pas devenir passant en même temps car cela provoquerait un court-circuit !

Je préfère utiliser des MOSFET au lieu de simples interrupteurs (boutons poussoirs) car cela me permet d’automatiser c’est à dire de les commander depuis la carte Arduino.

Je peux donc adapter mon schéma avec une carte Arduino UNO

PNG - 44.7 ko
Pont en H avec MOSFET piloté par Arduino
schéma réalisé avec Fritzing

Lorsque l’on veut faire tourner le moteur dans un sens, on envoie un signal "HAUT" sur la pin 8 de l’Arduino et on envoie un signal "BAS" sur la pin 9. Pour changer de sens, on inverse les signaux : "BAS" sur la pin 8 et "HAUT" sur la pin 9. Pour arrêter le moteur on envoie des signaux identiques ("HAUT "et "HAUT" ou "BAS" et "BAS".

Pour des raisons de facilité, je n’ai pas fabriqué moi-même le pont en H. J’utilise un pont en H qui fonctionne comme je l’ai décrit et dont la référence est L293. Comme l’indique la datasheet, il permet de piloter des moteurs qui consomment jusqu’à 1A.

JPEG - 70.6 ko

voici le code de mon programme (sketch) Arduino pour tester cela

int const PIN9 = 9;
int const PIN8 = 8;
void setup() {
  // put your setup code here, to run once:
  pin Mode(PIN9,OUTPUT);
  pinMode(PIN8,OUTPUT);
}
void loop() {
  // put your main code here, to run repeatedly:
 
   digitalWrite(PIN9, HIGH);
  digitalWrite(PIN8, LOW);
  delay(3000);
 
  digitalWrite(PIN9, LOW);
  delay(500);
 
   digitalWrite(PIN9, LOW);
  digitalWrite(PIN8, HIGH);
  delay(3000);
 
  digitalWrite(PIN8, LOW);
  delay(500);
}

 Etape 3 : piloter le moteur en variant la vitesse

Pour faire varier la vitesse d’un moteur à courant continu, c’est simple, il suffit de faire varier la tension aux bornes du moteur. Oui... mais comment ?

Pour cela, le PWM est un procédé qui sert à précisément à faire varier la tension en fonction d’une tension de référence. PWM qui signifie Pulse Width Modulation (Modulation Largeur).

Dans mon cas, j’alimente mon moteur avec du 5V pour le faire tourner à sa vitesse maximum. Si je veux le faire tourner à mi-régime, je dois donc lui envoyer du 2,5V. Mais je ne sait pour le moment que envoyer 5V ou 0V (mosfet passant ou non passant).

Pour cela, le PWM est une sorte d’astuce qui consiste à découper le temps en tout petit morceau de temps (on dit qu’on fait de la modulation).

On peut alors envoyer 5V au moteur pendant un tout petit laps de temps puis lui envoyer 0V pendant un autre petit laps de temps et recommencer...De cette façon, le moteur aura l’impression de recevoir 2,5V (il utilise une tension moyenne).

JPEG - 44.1 ko

En utilisant le principe des moyennes, pour si je lui envoie 5V puis 4 fois de suite 0V, il aura reçu en moyenne 1V (qui correspond à 20% de la vitesse max).

JPEG - 17.5 ko

Comme exercice, j’ai voulu savoir combien de signaux de 5V et combien de signaux de 0V je devais envoyer pour obtenir 1,5V en moyenne. C’était assez difficile à résoudre pour moi car cet exercice demande des notions de mathématiques niveau 4ème !!!

En fait, on passe un temps X sur 5V et un temps Y sur 0 V . Le temps total est X + Y. On a donc l’ équation ( 5.X + 0.Y)/ (X+Y) = 1.5 V
Après résolution on a 35 X = 15 Y.
Cette équation est vérifiée si X est égal à 15 et Y est égal à 35.
Pour avoir 1.5V, il faudra donc 15 valeurs à 5V et 35 valeurs à 0V

Sur l’Arduino c’est plus simple car j’utilise une procédure qui fera automatiquement ce calcul et j’ai juste à lui spécifier la tension moyenne à obtenir (c’est très pratique). Le code ci-dessous permet de commander le moteur, dans les deux sens en faisant varier sa vitesse :

/**
Auteur : Frédéric et Pierre - janvier 2016
le pont en H est connecte sur les pin 9 et 10 de l'Arduino.
les deux pins sont capables de faire du PWM
**/

int const directionA = 9;
int const directionOpposeeA = 10;
void setup() {
  // initilationsation des commandes de direction
  pinMode(directionOpposeeA,OUTPUT);
  pinMode(directionA,OUTPUT);
}
void loop() {
   // DIRECTION DE A --> la vitesse varie
   digitalWrite(directionOpposeeA, LOW); //la direction opposee de A ne varie pas
   for(int vitesse = 50 ; vitesse < 120 ; vitesse+=10) {
        analogWrite(directionA, vitesse);
        delay(200);
   }
   delay(3000);
   
   
     // DIRECTION OPPOSEE de A --> la vitesse varie
   digitalWrite(directionA, LOW); //la direction de A ne varie pas
   for(int vitesse = 50 ; vitesse < 120 ; vitesse+=10) {
        analogWrite(directionOpposeeA, vitesse);
        delay(200);
   }
  delay(3000);
}

 Etape 4 : télécommander le moteur

Je souhaite pouvoir télécommander le moteur. Dans un premier temps, j’ai essayé d’utiliser une Nunchuk.

JPEG - 42.8 ko

Pour cela, j’ai branché un adaptateur pour connecter la manette. La manette permet d’envoyer des valeurs sur la position du joystick, sous la forme d’un nombre décimal. La communication avec la manette se fait en utilisant le protocole I2C.

Ca a fonctionné mais le résultat n’était pas très bon car il restait difficile de diriger la voiture avec cette manette.

J’ai donc préféré utiliser un joystick comme celui-là :

JPEG - 44.4 ko

Cette carte vient se connecter directement sur une seconde carte Arduino UNO qui me servira pour la télécommande. De plus, elle a le grand avantage de proposer un connecteur pour brancher un émetteur/récepteur type RF24 pour la liaison sans fil.

Les branchements sont les suivant :

Le code ci-dessous montre comment envoyer la commande à la voiture.

/*
Programme modifié par Frédéric et Pierre
18-12-2015
Joystick Shield avec HID USB Joystick
 * D'après ce lien : http://forum.freetronics.com/viewtopic.php?f=27&t=734&start=10#p10805
 *
 * BP A = D2
 * BP B = D3
 * BP C = D4
 * BP D = D5
 * BP E = D6
 * BP F = D7
 * BP Joy = D8
 * Axe Y = A1
 * Axe X = A0
 
récupère la valeur du nunchuck et éclaire une LED en fonction de la direction choisie
*/

#include "Servo.h"
#include "Wire.h"
#include "WiiChuck.h"
#include <SPI.h>
#include <RF24.h>
RF24 radio(9, 10);
// Single radio pipe address for the 2 modules RF24L01 to communicate.
const uint64_t pipe = 0xE8E8F0F0E1LL;
const int SEUIL = 60;
WiiChuck chuck = WiiChuck();
int valX = 0;
int valY = 0;
 
class Ordre {
  public:
    char c;
    int valX;
    int valY;
};
Ordre monOrdre;
 
void  preparer_ordre (char c){
  //ordre[0] = c;
  //ordre[1] = valX;
  //ordre[2] = valY;
  monOrdre.c = c;
  monOrdre.valX = valX;
  monOrdre.valY = valY;
}
 
 
 
 
void setup() {
  pinMode(2, INPUT_PULLUP);
  pinMode(3, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  pinMode(5, INPUT_PULLUP);
  pinMode(6, INPUT_PULLUP);
  pinMode(7, INPUT_PULLUP);
  pinMode(8, INPUT_PULLUP);
 
   Serial.begin(9600);
  //Serial.println("port série OK...");
  delay(100);  // une petite attente
 
  chuck.begin();
  //Serial.println("Chuck init OK...");
  chuck.update();
  //Serial.println("Chuck pret !");
 
 
  radio.begin();
  radio.openWritingPipe(pipe);
 
  Serial.println(sizeof(monOrdre));
}
void loop() {
  int buttons = ( (!digitalRead(2) << 2) | (!digitalRead(3) << 3) | (!digitalRead(4) << 0) |
                  (!digitalRead(5) << 1) | (!digitalRead(6) << 4) | (!digitalRead(7) << 5) |
                  (!digitalRead(8) << 6));
  int x = analogRead(A0);
  int y = analogRead(A1);
  //5V --> max=1024 mais en 3,3v  --> max 675
  valX = map(analogRead(A0), 0, 672, -255, 255); // Re-map the 10 bit inputs to 8 bit outputs
  valY = map(analogRead(A1), 0, 672, -255, 255);
 
  //valX = analogRead(A0);
  //valY = analogRead(A1);
  Serial.print("SANS MAP = ");
  Serial.print(x);
  Serial.print(" ");
  Serial.println(y);
 
  if (valX>SEUIL && valY<-SEUIL) preparer_ordre('C');
  else if (valX<-SEUIL && valY<-SEUIL) preparer_ordre('W');
  else if (valX>SEUIL && valY>SEUIL) preparer_ordre('E');
  else if (valX<-SEUIL && valY>SEUIL) preparer_ordre('A');
  else if (valX>SEUIL) preparer_ordre('D');
  else if (valX<-SEUIL) preparer_ordre('Q');
  else if (valY>SEUIL) preparer_ordre('Z');
  else if (valY<-SEUIL) preparer_ordre('S');
 
  if (monOrdre.c!='-'){
      Serial.print(monOrdre.c);
      Serial.print(" ");
      Serial.print(monOrdre.valX);  
      Serial.print(" ");
      Serial.println(monOrdre.valY);  
      if (radio.write( &monOrdre, sizeof(monOrdre) ))  //envoyer l'ordre
          Serial.println("ok");
        else
          Serial.println("failed");
  }
 
  delay(500);
  monOrdre.c= '-';  //RAZ
}

En complément, j’ai branché un émetteur/récepteur à la carte Arduino de la voiture. Celui-ci servira à la voiture pour écouter les ordres envoyés depuis la télécommande.

Le schéma des composants la voiture est donc le suivant :

......

Le code suivant permet à la voiture de recevoir les ordres envoyées par la télécommande et d’avancer et reculer à la vitesse demandée.

/*
 Programme modifié par Frédéric et Pierre
18-12-2015
recoit un ordre depuis l'emetteur et agit en consequence selon ordre[0]
  case 'Z' : avance
  case 'E' : avance_droite
  case 'D' : droite
  case 'C' : recule_droite
  case 'S' : recule
  case 'W' : recule_gauche
  case 'Q' : gauche
  case 'A' : avance_gauche
  ordre[1] = valX;
  ordre[2] = valY;
*/

#include <SPI.h>
#include "RF24.h"
//RF24
const uint64_t pipe = 0xE8E8F0F0E1LL;
RF24 radio(7,8);
class Ordre {
  public:
    char c;
    int valX;
    int valY;
};
Ordre ordreRecu;
//char ordreRecu[3]= {'-',0,0};
//pont en H
const int AVANCE = 9;
const int RECULE = 10;
const int GAUCHE =5;
const int DROITE = 6;
void setup(void)
{
  Serial.begin(9600);
  Serial.println("recepteur sans fil/");
 
  radio.begin();
  radio.openReadingPipe(1,pipe);
  radio.startListening();
 
  pinMode(AVANCE, OUTPUT);  
  pinMode(RECULE, OUTPUT);  
  pinMode(GAUCHE, OUTPUT);  
  pinMode(DROITE, OUTPUT);
 
 ordreRecu.c = '-';
  stop();
}
  void stop(){
    digitalWrite(DROITE, LOW);
    digitalWrite(GAUCHE, LOW);
    digitalWrite(AVANCE, LOW);
    digitalWrite(RECULE, LOW);
    Serial.print("STOP !!! ");
  }
  void droite(int X, int Y){
    digitalWrite(DROITE, HIGH);
    digitalWrite(GAUCHE, LOW);
    digitalWrite(AVANCE, LOW);
    digitalWrite(RECULE, LOW);
    Serial.print("droite ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
 
 
  void gauche(int X, int Y){
    digitalWrite(GAUCHE, HIGH);
    digitalWrite(DROITE, LOW);
    digitalWrite(AVANCE, LOW);
    digitalWrite(RECULE, LOW);
    Serial.print("gauche ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
 
 
  void avance(int X, int Y){
    digitalWrite(GAUCHE, LOW);
    digitalWrite(DROITE, LOW);
    analogWrite(AVANCE, Y);
    digitalWrite(RECULE, LOW);
    Serial.print("avance ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
 
 
  void recule(int X, int Y){
    digitalWrite(GAUCHE, LOW);
    digitalWrite(DROITE, LOW);
    digitalWrite(AVANCE, LOW);
    analogWrite(RECULE, -Y);
    Serial.print("recule ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
 
  void recule_droite(int X, int Y){
    digitalWrite(GAUCHE, LOW);
    digitalWrite(DROITE, HIGH);
    digitalWrite(AVANCE, LOW);
    analogWrite(RECULE, -Y);
    Serial.print("recule_droite ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
 
  void recule_gauche(int X, int Y){
    digitalWrite(GAUCHE, HIGH);
    digitalWrite(DROITE, LOW);
    digitalWrite(AVANCE, LOW);
    analogWrite(RECULE, -Y);
    Serial.print("recule_gauche ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
 
  void avance_droite(int X, int Y){
    digitalWrite(GAUCHE, LOW);
    digitalWrite(DROITE, HIGH);
    analogWrite(AVANCE, Y);
    digitalWrite(RECULE, LOW);
    Serial.print("avance_droite ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
 
  void avance_gauche(int X, int Y){
    digitalWrite(GAUCHE, HIGH);
    digitalWrite(DROITE, LOW);
    analogWrite(AVANCE, Y);
    digitalWrite(RECULE, LOW);
    Serial.print("avance_gauche ");
    Serial.print("--> X=");
    Serial.print(X);
    Serial.print(" Y=");
    Serial.println(Y);
  }
void loop(void)
{
    // if there is data ready
    if ( radio.available() )
    {
     
        radio.read( &ordreRecu, sizeof(ordreRecu) );
        Serial.print(ordreRecu.c);
        Serial.print(' ');
        Serial.print(ordreRecu.valX);
        Serial.print(' ');
        Serial.println(ordreRecu.valY);
         /*
          case 'Z' : avance
          case 'E' : avance_droite
          case 'D' : droite
          case 'C' : recule_droite
          case 'S' : recule
          case 'W' : recule_gauche
          case 'Q' : gauche
          case 'A' : avance_gauche
        */

        switch (ordreRecu.c) {
            case 'Z' : avance(ordreRecu.valX,ordreRecu.valY); break;
            case 'E' : avance_droite(ordreRecu.valX,ordreRecu.valY); break;
            case 'D' : droite(ordreRecu.valX,ordreRecu.valY); break;
            case 'C' : recule_droite(ordreRecu.valX,ordreRecu.valY); break;
            case 'S' : recule(ordreRecu.valX,ordreRecu.valY); break;
            case 'W' : recule_gauche(ordreRecu.valX,ordreRecu.valY); break;
            case 'Q' : gauche(ordreRecu.valX,ordreRecu.valY); break;
            case 'A' : avance_gauche(ordreRecu.valX,ordreRecu.valY); break;
         
        }
       
     
    }//end if adio.available()
 
}

 Etape 4 : diriger la voiture à gauche et à droite

Pour faire tourner la voiture de gauche à droit, j’utilise le système existant sur le chassis. Il s’agit d’une tringlerie commandée par un servo-moteur Nikko.
.....

 Etape 5 : télécommander la voiture

Pour diriger la voiture, souhaite disposer d’une télécommande sans fil. La communication sera donc de type point à point et non de type "broadcast". Ainsi, je souhaite par exemple appuyer sur le bouton HAUT. La voiture devra alors avancer. Si j’appuie à nouveau sur le bouton HAUT, la voiture avancera plus vite.
Ce n’est pas la télécommande qui interprètera les ordres, ce sera le programme de la voiture qui réalisera ce travail. Le rôle de la télécommande sera simplement d’envoyer des ordres à la voiture.

Il existe plusieurs solutions pour réaliser une simple communication sans fil point à point. Pour ma part, j’ai choisi d’utiliser un module RF24. Ce module utilise les fréquences radio 2,4 GHz. Il s’agit d’une fréquence très souvent utilisée. On la retrouve par exemple dans les télécommandes des portails.

la télécommande
Je dois donc construire une télécommande permettant de contrôler quatre directions et des vitesses variables. La télécommande devra envoyer des ordres à la voiture qui sera capable de recevoir les ordres et des les interpréter. Pour cela j’utile un module RF24 dans la télécommande et un module RF24 dans la voiture.

Ma télécommande présente simplement 4 boutons poussoir, une LED indiquant lorsque la télécommande est allumée et un interrupteur de mise en route. Pour contrôler l’ensemble j’utilise une seconde carte arduino (nano). La consommation électrique étant faible (pas de moteur ici), je peux utiliser une pile de 9v. La carte arduino fonctionne en 5V, j’utiliserai donc un régulateur de tension. Le module RF24 fonctionne en 3,3V, heureusement la carte nano arduino est capable de fournir une alimentation en 3,3V 20mA (suffisant pour le module RF24).

JPEG - 79.3 ko

Les boutons poussoirs que j’ai utilisé se ressemblent mais ne sont les mêmes (je n’en avais pas quatre identiques). En effet, certains boutons étaient "normalement ouverts" et d’autres "normalement fermés".

Voici le schéma de la télécommande.

Le code Arduino de la télécommande se contente d’envoyer des ordre à la voiture lorsque l’un des boutons poussoir est pressé. La méthode void verifier_button(int aButton, int posFermee) vérifie lorsque un bouton est pressé —> le paramètre posFermee permet de préciser s’il s’agit d’un BP "normalement ouvert" ou "normalement fermé".

voici le code arduino de la télécommande.

la voiture

JPEG - 99.8 ko
JPEG - 111.2 ko

La voiture devra recevoir les ordres émis depuis le module RF24 de la télécommande. Ce module sera donc relié à la carte arduino de la voiture. En outre, j’ai placé des LED de contrôle.
Les LED vertes indiquent que la voiture a reçu un ordre de la télécommande concernant la direction (bouton de la télécommande qui a été pressé).
Les LED jaunes indiquent à quelle vitesse la voiture doit fonctionner (25% 50% 75% ou 100%)
La LED rouge indique si la voiture doit reculer
Compte tenu du grand nombre de pin à manipuler, j’ai été obligé d’utiliser les sorties analogiques A0 à A4 comme des pin numériques et A5 comme une sortie pwm.

Voici le schéma de la télécommande.

pin 0 : -
pin 1 : -
pin 2 : LED verte gauche
pin 3 : LED verte haut
pin 4 : LED verte bas
pin 5 : LED verte droite
pin 6 : pont en H moteur propulsion INa1 (pwm)
pin 7 : RF24_CE
pin 8 : RF24_SCN
pin 9 : pont en H moteur propulsion INa2 (pwm)
pin 10 : pont en H moteur direction INb2 (pwm)
pin 11 : RF24_MOSI
pin 12 : RF24_MISO
pin 13 : RF24_SCK
pin A0 : LED jaune recule
pin A1 : LED jaune vitesse 25%
pin A2 : LED jaune vitesse 50%
pin A3 : LED jaune vitesse 75%
pin A4 : LED jaune vitesse 100%
pin A5 : pont en H moteur direction INb1 (pwm)

voici le code arduino de la télécommande.
La suite pendant nos séances du vendredi soir !

Vos commentaires

  • Le 21 septembre à 19:26, par Le Moujo En réponse à : Construire une voiture télécommandée

    super, c’est exactement ce qu’il me faut, du moins la 1ère partie, pour piloter les 2 mats sur mon crevettier guyannais. Je connaissais un peu Arduino mais pas le pont en H.
    J’utiliserais un ATTini84 plûtot que la UNO, programmé pour la descente des mats en position pêche, une pause, et la remontée des mats
    Merci
    Le Moujo

    JPEG - 77.5 ko

    Répondre à ce message

  • Le 28 novembre 2015 à 15:56, par Valere En réponse à : Piloter un moteur continu avec une carte Arduino

    Bonjour Pierre,
    C’est un bel article bravo. J’aimerais juste ajouter un petit quelque chose...
    Un moteur c’est un peu comme une bobine ; or quand on coupe l’alimentation d’une bobine, le courant ne s’annule pas tout de suite et cela fait une surtension. Donc quand on arrête le moteur on ne peut pas arrêter immédiatement le courant, si on le déconnecte tout simplement (couper le MOSFET) il y a une surtension, pour éviter que le MOSFET finisse par griller on ajoute une diode de "roue libre" en parallèle avec le moteur, comme ça on donne un chemin "de secours" au courant. Il n’est donc pas coupé brutalement et l’on n’a pas de surtension. C’est le même principe qu’ici pour un relais : http://www.astuces-pratiques.fr/electronique/la-diode-diode-de-roue-libre-pour-relais
    Pour le pont en H, c’est pareil il faut fournir un chemin pour évacuer le courant résiduel du moteur : http://perso.esiee.fr/~poulichp/PR201/Cmde_moteur/cmde_moteur.html
    On met 4 diodes (de type Schottky, car elles sont plus rapides), pour fournir des chemins au courant dans tous les cas (en fonction du sens de rotation du moteur).

    Répondre à ce message

  • Le 1er décembre 2015 à 18:45, par Mosfet En réponse à : Piloter un moteur continu avec une carte Arduino

    Utiliser des portes logiques alors que l’on a un µC à dispo, ce n’est pas très heureux.
    De plus, rien ne protège les Mos de leur destruction par le moteur

    • Le 17 décembre 2015 à 08:10, par Eric P. En réponse à : Piloter un moteur continu avec une carte Arduino

      Le recours à un micro n’est pas toujours nécessaire pour des fonctions de base. Un bon vieux 555 pour faire une tempo ou clignoter une LED ça marche très bien aussi. Et un programme sur micro ne pourra jamais aller aussi vite que des portes logiques câblées en direct.
      En d’autres termes, pas besoin de prendre la voiture quand on peut aller acheter le pain à pied :)
      Par conséquent, les deux approches se complètent et ne s’excluent pas.
      Pour ce qui est de la protection, il s’agit ici d’un projet exploratoire de découverte. Il n’a bien entendu pas les qualités d’un projet industriel fini. Il faut apprendre à marcher avant de chercher à courir ;) En ayant éventuellement fait cramer un composant du fait de l’absence de la protection adaptée, on comprend et on retient ce qu’il faut faire pour l’éviter. Côté pédagogie ce n’est pas si mal comme démarche ;)

    Répondre à ce message

Un message, un commentaire ?

modération a priori

Attention, votre message n’apparaîtra qu’après avoir été relu et approuvé.

Qui êtes-vous ?

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici
  • Ce formulaire accepte les raccourcis SPIP [->url] {{gras}} {italique} <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.

Ajouter un document