Le moteur CC est un composant électrique qui peut être utilisé pour produire un mouvement rotatif ou linéaire. Il est largement utilisé dans de nombreuses applications, notamment les robots, les systèmes de contrôle industriel et les systèmes de transport. Dans cet article, nous allons vous montrer comment tester simplement un moteur CC à l’aide du shield DFRduino Motor Driver 1A. Nous allons vous expliquer comment connecter le moteur à l’Arduino et comment utiliser le shield pour contrôler le moteur. Nous allons également vous montrer comment tester le moteur et vérifier son bon fonctionnement.
Test simple de la commande d’un moteur CC à l’aide du shield DFRduino Motor Driver 1A
(cliquer sur l’image pour agrandir)
1. Présentation
Ce programme commande un moteur CC à l’aide d’une broche de sens et d’une broche de vitesse (PWM) via une carte DFRduino motor drive 1A (L293).
Ce programme utilise les fonctionnalités suivantes :
- Utilise un shield DFRduino motor Driver 1A (basé sur L293) pour contrôle de 2 moteurs CC
Ressources utiles associées à ce programme :
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
2.2 Le matériel suivant pour réaliser le montage associé
- des straps,
- Un shield DFRduino motor Driver 1A (basé sur L293) pour contrôle de 2 moteurs CC
- un ou 2 moteurs ou moto-réducteurs CC, ne nécessitant pas plus de 1 A et fonctionnant sous 7 à 12V.
3. Instructions de montage
- Enficher le shield broche à broche sur la carte Arduino
- connecter le moteur au bornier à vis M1
- connecter une alimentation 12V
4. Le schéma théorique du montage
Le schéma théorique du montage (cliquer pour agrandir)
5. Le circuit du montage
Le schéma du montage à réaliser (cliquer pour agrandir)
6. Explication du programme
6.1 Au niveau de la partie déclarative :
- On renomme les broches utilisée avec le moteur
- On déclare des constantes utiles
6.2 Au niveau de la fonction loop( ) :
- On réalise un test simple du moteur par rotation dans un sens, puis dans l’autre sens puis arrêt
- La vitesse est incrémentée à chaque passage
- Pour plus de détails sur l’impulsion PWM, voir la documentation de l’instruction analogWrite()
7. Mise en oeuvre du programme
7.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
7.2 Fonctionnement
- Le moteur tourne dans un sens pendant quelques secondes puis tourne dans l’autre sens puis s’arrête et ainsi de suite.
- La vitesse augmente à chaque passage.
8. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur Arduino
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr
// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 16/2/2011.
// ——- Licence du code de ce programme —–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// //////////////////// PRESENTATION DU PROGRAMME ////////////////////
// ——– Que fait ce programme ? ———
/* Ce programme commande un moteur CC à l’aide d’une broche de sens
et d’une broche de vitesse (PWM) via une carte DFRduino motor drive 1A (L293) */
// — Fonctionnalités utilisées —
// ——– Circuit à réaliser ———
// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…
// — Déclaration des constantes —
// — Inclusion des librairies —
// — Déclaration des constantes utiles —
// — Déclaration des constantes des broches E/S numériques —
const int sensMoteur1=4; // Constante pour la broche 2
const int vitesseMoteur1=5; // Constante pour la broche 3
const int AVANT=1; // constante sens moteur
const int ARRIERE=0; // constante sens moteur
// — Déclaration des constantes des broches analogiques —
// — Déclaration des variables globales —
int vitesse=105; // variable de vitesse
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter 1 seule fois au démarrage du programme —
// ——- Initialisation fonctionnalités utilisées ——-
// ——- Broches en sorties numériques ——-
pinMode (sensMoteur1,OUTPUT); // Broche sensMoteur1 configurée en sortie
pinMode (vitesseMoteur1,OUTPUT); // Broche vitesseMoteur1 configurée en sortie
// ——- Broches en entrées numériques ——-
// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-
// ——- Initialisation des variables utilisées ——-
} // fin de la fonction setup()
// ********************************************************************************
////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
//—– test du moteur —–
vitesse = vitesse + 50; // incrémente la vitesse
if (vitesse>255) vitesse=105; //RAZ vitesse
analogWrite(vitesseMoteur1, vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
digitalWrite(sensMoteur1,AVANT); // Marche avant
delay(3000);
analogWrite(vitesseMoteur1, vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
digitalWrite(sensMoteur1,ARRIERE); // Marche avant
delay(3000);
analogWrite(vitesseMoteur1,0); // génère une impulsion PWM sur la broche de vitesse du moteur
delay(3000);
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////
// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////
// ////////////////////////// Fin du programme ////////////////////
