Le compte-tour est un outil très pratique pour les moteurs à courant continu (CC). Il permet de mesurer la vitesse de rotation du moteur et de l’afficher dans le terminal série. Grâce à cet outil, il est possible de surveiller et de contrôler la vitesse de rotation du moteur, ce qui est très utile pour les applications industrielles et les projets de robotique. Dans cet article, nous allons examiner en détail le fonctionnement et les avantages du compte-tour pour moteur CC avec affichage dans le terminal série.
Compte-tour pour moteur CC avec affichage dans le Terminal série
(cliquer sur l’image pour agrandir)
1. Présentation
Ce programme compte la vitesse d’un moteur CC en nombre de tours par minute. Ce programme utilise un optocoupleur en fourche et une interruption externe.
Le résultat est affiché dans la fenêtre Terminal du logiciel Arduino.
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
- Utilise l’interruption externe 0 (broche 2)
Ressources utiles associées à ce programme :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
- Optocoupleur en fourche (LITON LTH301-07)
Voir également :
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é
- une plaque d’essai pour montage sans soudures,

- des straps,

- un optocoupleur infra-rouge en fourche, type LTH301-7,

Pour plus de détails, voir : Optocoupleur en fourche (LITON LTH301-07)
3. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
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. Fonctionnement du programme
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme
7. Explication du programme
7.1 Au niveau de la partie déclarative :
7.2 Au niveau de la fonction d’initialisation setup( ) :
7.3 Au niveau de la boucle principale, la fonction loop ( ) :
8. Mise en oeuvre du programme
8.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
8.2 Préparation du Terminal côté PC dans le logiciel Arduino
- Côté PC, il faut ouvrir la fenêtre terminal de l’IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».

- La fenêtre « Terminal » s’ouvre alors :

- Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :

8.3 Fonctionnement
(cliquer sur l’image pour agrandir)
9. 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 compte la vitesse d’un moteur CC en nombre de tours par minute. Ce programme utilise un optocoupleur en fourche et une interruption externe.
Le résultat est affiché dans la fenêtre Terminal du logiciel Arduino. */
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise l’interruption externe 0 (broche 2)
// Utilise optocoupleur infra-rouge en fourche, type LTH301-7,
// ——– Circuit à réaliser ———
// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
// /////////////////////////////// 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 —
// — Déclaration des constantes des broches analogiques —
// — Déclaration des variables globales —
volatile long comptageImpuls=0; // variable accessible dans la routine interruption externe 0
long timeRef=0; // variable pour temps de référence en millisecondes
long delai=1000; // variable pour délai de comptage en millisecondes
// — 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 ——-
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
attachInterrupt(0, gestionINT0, RISING); // attache l’interruption externe n°0 à la fonction gestionINT0()
// mode déclenchement possibles = LOW, CHANGE, RISING, FALLING
// ——- Broches en sorties numériques ——-
// ——- 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 ——-
timeRef=millis(); // initialisation de la référence du comptage
} // 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()
if (millis()>(timeRef+delai)) { // si le delai de comptage est écoulé
timeRef=timeRef+delai; // réinitialise le délai de comptage
Serial.print(« Nombre Impulsions par seconde = »), Serial.println(comptageImpuls); // affiche impulsions/sec
Serial.print(« Nombre tour par seconde = »), Serial.println(comptageImpuls/2); // affiche nombre tours/sec
comptageImpuls=0; // RAZ comptage impulsions
} // fin si délai de comptage s’est écoulé
// — ici instructions à exécuter par le programme principal —
//while(1); // stop loop
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////
// ——————- fonction de gestion l’interruption externe n°0 (broche 2) —————-
// cette fonction est appelée à chaque fois que l’interruption a lieu selon le mode configuré (LOW, CHANGE, RISING, FALLING)
void gestionINT0() {// la fonction appelée par l’interruption externe n°0
comptageImpuls=comptageImpuls+1; // incrémente comptage Impulsion
// variableINT0 accessible ici
// ATTENTION : delay() et millis() non dispo ici – données série perdues
}
// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////
// ////////////////////////// Fin du programme ////////////////////
// ////////////////////////// Mémo instructions ////////////////////
// ////////////////////////// Fin Mémo instructions ////////////////////
Articles Liés
- Affiche le comptage simple des secondes dans le Terminal Série
Le Terminal Série est un outil puissant qui permet aux utilisateurs de communiquer avec des…
- Contrôler le sens et la vitesse d'un moteur à courant continu (CC) par réception d'une valeur entière sur le port Série depuis la fenêtre Terminal.
Le contrôle du sens et de la vitesse d'un moteur à courant continu (CC) est…
- Recevoir une valeur numérique entière saisie dans la fenêtre du Terminal Série
Lorsque vous travaillez avec des systèmes embarqués, il est souvent nécessaire de recevoir des données…