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
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.
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
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.
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
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.
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).
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).
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.
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à :
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).
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
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 9 octobre 2017 à 15:07, par Marco En réponse à : Construire une voiture télécommandée
Franchement ce tuto est génial, j’aimerai construire ma propre voiture RC mais je suis pas super bon en mécanique, je me demande si il est possible d’acquérir une voiture télécommandée par chère comme celles-ci, la démonter et m’amuser ensuite à monter un arduino dessus en suivant ce tuto, est-ce envisageable ou y aura t’il des problèmes de blocage constructeur ?
J’aimerai commencer petit avec une Silverlit Exost 360°, c’est possible selon vous ?
# Le 17 décembre 2017 à 22:22, par Eric P. En réponse à : Construire une voiture télécommandée
Bonsoir,
Merci pour le compliment, et désolé pour le délai de réponse (pas toujours le temps d’aller voir s’il y a des messages en attente sur le forum).
Vous pouvez tout à fait "hacker" une voiture RC du commerce. Choisissez un modèle le moins cher possible, de manière à ne pas avoir de regret si ça se passe mal ;)
Certains produits utilisent cependant des servos particuliers (sans doute pour des raisons d’économie) qui ne se pilotent pas comme des servos RC standard. Le problème c’est qu’on ne le sait qu’une fois qu’on a étripé la bête. On peut toujours les remplacer, mais cela demande du coup quelques aptitudes au bricolage.
On ne peut rien dire sur ce point du produit sélectionné, car il n’y a aucune information quant à la manière dont les moteurs sont contrôlés. Il ne serait pas surprenant que l’ensemble des fonctions radio + puissance soient assurées par une unique carte électronique totalement propriétaire, là encore pour des raisons de cout.
Si on veut ne pas avoir de surprise, il est préférable de s’orienter vers un châssis RC standard qu’on équipera d’une Arduino au lieu du module récepteur. L’avantage est que le contrôle moteur et la direction sont pilotés via des signaux RC classiques, qu’on produit en toute simplicité sur l’Arduino via la bibliothèque "Servo".
Faites un tour sur les sites de distributeurs comme Hobbyking par exemple. Vous y trouverez probablement une bonne base de départ.
Cordialement - Eric
Répondre à ce message
# Le 31 janvier 2017 à 22:04, par Adrien En réponse à : Construire une voiture télécommandée
Salut
j’ai besoin de précision mais très rapidement si possible pour savoir quelle carte arduino prendre si j’ai un véhicule rc à quatre roues et que je veux faire suivre une ligne au véhicule mais en tournant que les roues de devant comme une voiture normal
cordialement merci davance à ce pour votre aide.
Repondez moi, s’il vous plaît, à l’adresse : adrienmosser@gmail.com
# Le 17 février 2017 à 14:33, par Eric P. En réponse à : Construire une voiture télécommandée
N’importe quelle carte de base est suffisante pour ce type d’application. Une Uno devrait donc faire l’affaire.
Cordialement.
Répondre à ce message
# Le 21 septembre 2016 à 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
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