Présentation générale d’un
microcontrôleur
Présentation
Une carte à microcontrôleur est une carte qui rassemble les éléments essentiels d’un ordinateur : processeur, mémoire, interface d’entrée-sortie.Il existe de nombreuses marques proposant ce type de cartes, dont ARDUINO, Educaduino,… La carte ARDUINO est une carte électronique qui comporte un microcontrôleur, c’est-à-dire une carte électronique programmable par ordinateur.
Utilités
Ces cartes possédant des entrées et sorties, elles permettent :
- d’échantillonner et de traiter des signaux électriques (tensions électriques directe-ment mesurables ouissues de capteurs : température, pression, luminosité,. . . ) ;
- de commander des éléments (DEL, moteur, buzzer. . . ) ; on parle d’actionneurs.
Analogie avec le quotidien
Radar de recul, arrosage automatique, éclairage par détecteur de présence, détecteur de fumée. . .
Différence avec une carte d’acquisition
La carte d’acquisition permet uniquement de faire des acquisitions de données contrairement au microcontrôleur qui en plus de faire des acquisitions de données est programmable.
Programmation
La programmation de ces cartes se fait via le port USB d’un ordinateur, par codage directement en langage Arduino basé sur C++.
Installer Arduino (Windows)
Installer Arduino en téléchargeant la version adaptée (Windows, Mac, Linux,..) sur ce lien :
https://www.arduino.cc/en/Main/Software
Cliquer sur « I Agree » Cliquer sur « Next » Cliquer sur « Install »
Ouvrir le logiciel Arduino
Vérifier que le type de carte choisi est bien « Arduino/Genuino Uno » depuis le menu [Outils][Type de carte]
Vérifier que la carte est reconnue en sélectionnant le bon port de communication de la carte Arduino, depuis le menu [Outils][Port].
Découverte de la carte ARDUINO UNO
Présentation de la carte ARDUINO
Présentation de la plaque de montage (Breadboard)
En pratique, on relie souvent les 2 lignes du bas aux broches 5V (ligne intérieure) et GND (ligne extérieure).
Mise en application
Présentation du logiciel ARDUINO.IDE
- Les accolades sont « les conteneurs » du code programme.
- Les points virgules terminent les instructions
- Les commentaires (lignes de code ignorés par le programme) s’effectue de la manière suivante :
/* ligne ou paragraphe sur plusieurs lignes*/// ligne unique de commentaire
Réalisation d’un montage simple avec une LED
Nous allons faire allumer une LED, connectée sur la broche13. La résistance utilisée est de 220 ohms.
Dans le logiciel ARDUINO IDE, la programmation se fait de la façon suivante :
void setup() { /* « void », littéralement « vide», sert à définir une fonction mais ne renvoie aucune valeur et setup ne s’exécute
qu’une seule fois, sert à déclarer les entrées et les sorties */
pinMode (13, OUTPUT) ; /* définit le mode de la broche: ici on demande que la broche n°13 soit une sortie */
}
void loop () { /* loop = exécute une boucle parce qu’on va de-mander au programme d’être en permanence « en alerte » pour pouvoir allumer
la LED */
digitalWrite (13,HIGH) ; /*littéralement « écriture digitale », instruction qui permet de définir 1 état: HAUT. Le microcontrôleur connecte la broche
13 au +5V ce qui a pour effet d’allumer la LED.*/
}
int led1=13 /* Les variables sont à noter avant le void setup */
void setup() {
pinMode (led1, OUPUT) ;
}
void loop () {
digitalWrite (led1,HIGH) ;
}
Evolution du code pour faire clignoter la LED
int led1=13
void setup() {
pinMode (led1, OUPUT) ;
}
void loop () {
digitalWrite (led1,HIGH) ; /*littéralement « écriture digitale », instruction qui permet de définir 1 état: HAUT. Le microcontrôleur connecte la
broche 13 au +5V ce qui a pour effet d’allumer la LED.*/
delay(1000) ; /*L’instruction « retard 1000 » indique au micro-contrôleur de ne rien faire pendant 1000 millisecondes soit 1 seconde.*/
digitalWrite (led1,LOW) ; /*littéralement « écriture digitale », instruction qui permet de définir 1 état: BAS. Le microcontrôleur connecte la broche 13
au GND ce qui a pour effet d’éteindre la LED.*/
delay(1000) ; /*L’instruction « retard 1000 » indique au micro-contrôleur de ne rien faire pendant 1000 millisecondes soit 1 seconde.*/
}
Exemple avec l’allumeur de réverbère
Ci dessous un exemple simple de code qui permet de programmer un dispositif d’allumeur de réverbère en langage Arduino.
/*
Allumage d'une LED pour un faible éclairement d'une photorésistance (LDR) /* Pour insérer un commentaire, il faut encadrer le texte entre /* et */ */
*/
int Valeur_A0; /* Le mot « Valeur_A0 est associé à un entier » */
void setup() { /* « void », littéralement « vide », sert à définir une fonction mais ne renvoie aucune valeur et setup ne s’exécute qu’une seule fois,
sert à déclarer les entrées et les sorties */
pinMode (13,OUTPUT); /* définit le mode de la broche: ici on demande que la broche n°2 soit une sortie */
}
void loop() {
Valeur_A0=analogRead(A0); /*demande de lire la valeur de la tension sur la borne analogique A0: on récupère ici une tension en Volt qui va être convertie en une
valeur comprise entre 0 et 1023 */
if (Valeur_A0<100) { /*littéralement « écriture digitale » , instruction qui permet de définir 1 état: soit LOW, correspondant à 0V, soit HIGH, correspondant
à 5V. Ici on demande : si la valeur lue en A0 est inférieure à 500 (donc si il fait nuit), la broche numérique n°2 doit être placée
dans l’état « HIGH », c’est à dire 5V. Donc la led (= le réverbère) s’allumera. */
digitalWrite(13,HIGH);
}
else { /*sinon si la tension est supérieure à 4V alors la broche n°2 doit être placée dans l’état « LOW», c’est à dire 0V. Donc la led ne
s’allumera pas.*/
digitalWrite(13,LOW) ; }
delay(250); /*on attend 250 ms avant la prochaine boucle */
}
Affichage de valeurs dans le moniteur série
Pour afficher les valeurs mesurées dans le moniteur série, il faut :
- Initialiser le moniteur série dans le void setup en écrivant la ligne :
Serial.begin(9600); 9600 est une valeur standard de vitesse de transmission de données en bauds (ou bits/s)
- Dans le void loop, faire afficher la valeur mesurée avec Serial.print(Valeur);
ou Serial.println(Valeur); si on veut un retour à la ligne après affichage.
Attention ! Une fois le code lancé, penser à cliquer sur la petite loupe en haut à droite pour afficher le moniteur série !
Attention : La valeur mesurée sur les entrées analogiques (A0, A1, …) est comprise entre 0 et 1023 et correspond à une tension entre 0 et 5V.
Pour une mesure de tension, il faut donc déclarer une nouvelle variable et faire calculer la valeur de tension avec la formule :
Tension = Valeur mesurée x 5/1023
int Valeur_A0;
float U_A0;
// Procédure d'initialisation des périphériques
void setup() {
// Initialisation de la communication série avec le terminal à 9600 baud.
Serial.begin(9600);
}
// Boucle principale Arduino.
void loop()
Valeur_A0 = analogRead(A0); // Valeur comprise entre 0 et 1023
U_A0 = Valeur_alim *5.0/1023; // Calcul de la tension U_A0 (on « force » le caractère flottant de la valeur avec 5.0 dans le calcul)
Serial.print(" Tension sur A0: "); // Affichage de la tension en V sur le moniteur série
Serial.print(U_A0);
Serial.println(" V"); // println pour retour à la ligne
delay(1000); // Délai en ms pour la stabilisation de la ten-sion
}
BONUS : Peut-on programmer une carte Arduino avec le langage Python ?
Oui c’est possible ! Il faut pour cela utiliser la bibliothèque nanpy.
Pour que la carte Arduino soit prête à être programmée en Python, il faut :
- Dans Arduino, d’abord téléverser Nanpy à partir de la bibliothèque d’exemple (dossier zip à télécharger avant)
- Dans Pyzo, utiliser la bibliothèque nanpy (à installer au préalable).
Vous trouverez ici des explications détaillées ainsi que des fichiers à télécharger (bibliothèques, tutoriels, exemples d’activités Arduino avec les codes Python et codes Arduino équivalents,…) :