1 - MAKEBLOCK / Prise en main du robot
Nous allons voir comment vérifier l'installation du robot à l'aide d'un des programmes de tests. Nous allons voir le principe des instructions simples successives et la notion de variables.
1 - Les programmes de base : installation
Si vous êtes dans ma salle, cette partie ne vous servira à rien : les bibliothèques sont déjà installées. Néanmoins, si vous désirez ensuite le faire chez vous, vous pourrez toujours en revenir.
Nous allons donc voir :
- Où télécharger les bibliothèques supplémentaires
- Où placer ces bibliothèques dans le répertoire d'Arduino
2 - Le programme de test de déplacement
Pour voir si votre robot est bien monté, rien de mieux que de le faire avancer.
01° Ouvrir le logiciel Arduino puis, dans fichier, chercher Exemples --- MakeBlock Drive --- Me_DCMotor --- DCMotorTestDrive.
Vous devriez obtenir une fenêtre contenant le code suivant :
#include "MeOrion.h"
MeDCMotor motor1(PORT_1);
MeDCMotor motor2(PORT_2);
MeDCMotor motor3(M1);
MeDCMotor motor4(M2);
uint8_t motorSpeed = 100;
void setup()
{
}
void loop()
{
motor1.run(motorSpeed); /* value: between -255 and 255. */
motor2.run(motorSpeed); /* value: between -255 and 255. */
motor3.run(motorSpeed);
motor4.run(motorSpeed);
delay(2000);
motor1.stop();
motor2.stop();
motor3.stop();
motor4.stop();
delay(100);
motor1.run(-motorSpeed);
motor2.run(-motorSpeed);
motor3.run(-motorSpeed);
motor4.run(-motorSpeed);
delay(2000);
motor1.stop();
motor2.stop();
motor3.stop();
motor4.stop();
delay(2000);
}
02° Dans Outils --- Ports, séléctionnner le bon port de communication après avoir branché le robot à l'aide du connecteur Mini-USB.
03° Téléverser (icone flêche) le croquis (script, programme), placer le robot de tel façon à ce qu'il ne puisse pas tomber et activer le bouton ON une fois le croquis téléversé.
Vous devriez constater que le robot avance et recule.
Nous allons étudier un peu le code que nous lui avons envoyé.
#include "MeOrion.h"
MeDCMotor motor1(PORT_1);
MeDCMotor motor2(PORT_2);
MeDCMotor motor3(M1);
MeDCMotor motor4(M2);
uint8_t motorSpeed = 100;
Ces lignes se trouvent en début de croquis et hors des deux fonctions de base : il s'agit des importations de bibliothèques à inclure (ici MeOrion.h), ainsi que des déclarations de variables :
- Les 4 premiers commencencent par MeDCMotor. Il s'agit du constructeur de la classe qui permet d'obtenir un objet permettant d'interagir avec le moteur.
- On place les adresses de ces objets dans les variables motor1 à motor4
Qu'est-ce qu'une variable ? (1)
Voyez dans un premier temps, la variable comme un alias permettant d'accéder à un contenu mémoire.
Sur la ligne ci-dessous, l'ordinateur va créer une zone mémoire et va y stocker 100. On nomme cela la déclaration de la variable.
uint8_t motorSpeed = 100;
On pourra alors accéder à la valeur stockée simplement en tapant motorSpeed. L'ordinateur remplacera alors cela par le contenu : 100.
C'est pareil mais plus compliqué avec ceci :
MeDCMotor motor1(PORT_1);
On déclare une variable motor1 qui fait référence aux données multiples et nombreuses d'un objet de classe MeDCMotor. La variable motor1 permettra alors d'agir sur l'objet créé en utilisant un point comme dans :
motor1.stop();
04° Compter le nombre de moteurs sur votre robot et le nombre d'instance de la classe MeDCMotor. Problème ?
Image provenant des ressources 3D libres du site Grabcad Community
Et oui : 4 variables-objets "moteur" mais 2 moteurs réels ! Pourquoi ? Simplement car c'est un programme test. Or, on dispose de deux façon de commander les moteurs :
- Soit en utilisant les connecteurs RJ45 (les prises "internet")
- Soit en utilisant directement les connecteurs qu'on place sur la prise orange
05° Suivre les cables d'alimentation de vos moteurs pour trouver la solution utilisée sur votre robot.
Vous devriez constater que nous n'utilisons pas les RJ45 mais l'interface orange.
Sur quoi branche-t-on les prises RJ45 ?
Comme vous avez pu le constater, la carte du robot ne ressemble pas à un Arduino Uno. Il s'agit d'une carte Orion, carte qui intègre plus de chose que la Uno basique :
Cette platine est composée d'un coeur compatible arduino™ UNO-328 (base ATmega328) associé à un contrôleur de moteur spécialisé de type "TB6612", lequel sera directement capable de piloter 2 moteurs "cc" (6 à 12 V / 1 A max.)
Nos moteurs sont donc directement placés sur les prises moteur 1 et 2 et pas sur les prises "colorées".
Mais pourquoi autant de couleurs d'ailleurs ?
Comme vous pouvez le constater, chaque couleur correspond à un type particulier de connectique interne. Il faut donc vérifier que les dispositifs soient bien branchés sur une prise comptatible. Et pour cela, le code-couleur est bien pratique (à partir du moment où on sait où trouver l'information pour savoir qui fait quoi).
MeDCMotor motor1(PORT_1);
MeDCMotor motor2(PORT_2);
Vous pouvez constater que le constructeur de l'objet-moteur doit être informé du port sur lequel le moteur est supposé branché. Ici, la variable contenant l'adresse de l'objet motor1 va permettre de commander un moteur branché sur le port 1.
Et ça tombe bien : c'est un port ROUGE, sur lequel on peut brancher un moteur DC (DC pour Direct Courant en anglais, CC Courant Continu en français).
06° Supprimer toutes les lignes de codes faisant référence aux objets motor1 et motor2 : le programme test agit sur ces ports mais nous n'y avons rien branché : les moteurs sont commandés par les deux prises directes.
#include "MeOrion.h"
MeDCMotor motor3(M1);
MeDCMotor motor4(M2);
uint8_t motorSpeed = 100;
void setup()
{
}
void loop()
{
motor3.run(motorSpeed);
motor4.run(motorSpeed);
delay(2000);
motor3.stop();
motor4.stop();
delay(100);
motor3.run(-motorSpeed);
motor4.run(-motorSpeed);
delay(2000);
motor3.stop();
motor4.stop();
delay(2000);
}
07° Comment se nomment les variables qui font références aux prises directes ?
...CORRECTION...
Il existe des centaines de lignes de code cachées qui sont néanmoins utilisées par l'appel à la bibliothèque .
Pour connaitre la variable permettant de faire référence aux prises, il faut aller voir le constructeur de l'objet-moteur qui permet de faire le lien entre le moteur réel et le code arduino.
On voit alors que les variables se nomment M1 et M2.
MeDCMotor motor3(M1);
MeDCMotor motor4(M2);
Regardons maintenant sous la déclaration des objets-moteur :
uint8_t motorSpeed = 100;
Cette fois, la variable motorSpeed fait référence à une valeur unique : le nombre entier 100.
En C, on doit donner le type de la variable lors de sa déclaration. Ici, c'est uint8_t. Ce n'est pas très clair non ?
Voici donc un peu d'aide :
- Le int fait référence à integer : le terme français correspond à nombre entier.
- Le u fait référence à unsigned (nombre sans signe) : cela veut dire que le nombre stocké ne pourra être que positif ou nul.
- Le 8 fait référence au nombre de bits utilisés pour stocker la valeur. 8 bits ici.
- Le _t finit tous ces types de variables, pour les distinguer des types plus classiques du C (char, int ...)
08° Pourquoi la valeur contenue ne peut-elle aller que de 0 à 255 au maximum ? Pensez au binaire.
Pour comprendre cela, il faut comprendre le fonctionnement interne et la méthode de stockage des entiers dans l'ordinateur.
Si vous n'avez pas réussi à répondre à la question précédente : aller voir là-bas (partie 1 et 2) :
La réponse est donc 'évidente' maintenant :
On code le nombre à l'aide des 8 bits : XXXX XXXX, X pouvant valoir 0 ou 1.
Pour obtenir le maximum, il faut placer tous les bits à 1.
| Nombre M = | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| Les bits codent | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| On obtient donc | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
D'ou la valeur de M en base 10 : M = 128+64+32+16+8+4+2+1 = 255.
Passons aux deux fonctions principales :
void setup()
{
}
Cette fonction ne fait rien, elle est complément vide pour le test. Rappel : cette fonction est automatiquement appelée au tout début du lancement du croquis. Elle permet donc de réaliser des actions qui doivent impérativement être effectuées avant de lancer le robot à l'action.
Le reste du code est stocké dans la fonction loop() qui tournera en boucle.
void loop()
{
motor3.run(motorSpeed);
motor4.run(motorSpeed);
delay(2000);
motor3.stop();
motor4.stop();
delay(100);
motor3.run(-motorSpeed);
motor4.run(-motorSpeed);
delay(2000);
motor3.stop();
motor4.stop();
delay(2000);
}
La fonction delay a besoin qu'on lui transmette un argument entre parenthèses : le temps d'attente voulu. Ce temps est exprimé en ms (millisecondes). Ainsi 3000 veut dire 3000 ms, soit 3s.
09° Décrire ce que devrait faire ce programme.
...CORRECTION...
On commence par activer le moteur avec la méthode run (on remarquera le point entre l'objet et la méthode qu'on veut appliquer sur cet objet).
On transmet la valeur contenu dans la variable motorSpeed (100) pour les deux moteurs.
Le robot va donc avancer en ligne droite car les 2 moteurs tournent à l'identique.
Pause de 2000ms, soit 2s.
On stoppe les 2 moteurs avec la méthode stop. Pause de 0,1s.
On transmet -motorSpeed avec la méthode run : les deux moteurs tournent à l'envers et le robot va donc reculer.
On stoppe l'ensemble pendant 2s.
10° Décrire ce que devrait faire le programme ci-dessous. Donner notamment les vitesses de la première avancée et la vitesse de la seconde avancée.
void loop()
{
motor3.run(motorSpeed+20);
motor4.run(motorSpeed+20);
delay(2000);
motor3.stop();
motor4.stop();
delay(100);
motor3.run(motorSpeed-20);
motor4.run(motorSpeed-20);
delay(2000);
motor3.stop();
motor4.stop();
delay(2000);
}
...CORRECTION...
Vérifiez que votre programme contient bien les déclarations initiales.
On considère ici que la variable motorSpeed contient intialement 100.
Lors de la première marche avant, on avance donc en transmettant 120 aux méthodes run.
Lors de la deuxième marche avant, on avance donc en transmettant 80 aux méthodes run.
3 - Quelques petits défis
11° Déterminer la déviation vers la droite ou la gauche à bout de 2 mètres.
12° Tester un programme qui permette de compenser cette déviation.
13° Modifer la vitesse du moteur en modifiant simplement le contenu de la variable motorSpeed.
14° Créer un programme permettant au robot de tourner à 90°. Travailler avec une vitesse de 80 pour limiter l'imprécision.
15° Créer un programme permettant au robot de tourner à 45°.
16° En déduire la commande pour le faire tourner de 22°.
17° Créer un programme permettant au robot de partir de votre poste, de sortir de la salle pour aller jusqu'au tableau d'affichage et de revenir.
18° Créer un même programme qui devra tourner dans deux robots et permettant aux deux robots de se tourner autour sans jamais se percuter.
Voilà pour cette première approche.
Qu'est-ce qu'une variable ? (2)
Lorsque le programme arrive à MeDCMotor motor1(PORT_1);, il lance la création d'un objet assez complexe basé sur la classe MeDCMotor.
Cet objet comporte des données ET des lignes de code permettant de contrôler le PORT_1. On place l'ensemble dans la mémoire à partir d'une adresse-mémoire qui possède une référence précise.
L'ordinateur rajoute ensuite une ligne dans un tableau qu'on nomme l'espace des noms : on fait le lien entre le mot motor1 et l'adresse à laquelle on vient de créer l'objet de type MeDCMotor.
Ainsi, lorsqu'on tape motor1, l'ordinateur va lire le tableau de l'espace des noms : il va alors chercher le type de données contenues (MeDCMotor)et la référence de l'emplacement mémoire (111 123) qui correspond.
Lorsque le contenu est "simple" (un nombre unique, un caractère unique ...), l'ordinateur va chercher la référence et simplement renvoyer le contenu placé à cet emplacement.
Ainsi, si vous tapez motorSpeed, l'ordinateur va aller lire le contenu identifié comme un integer et stocké à l'emplacement 333 123. Il vous renvoie alors directement 100.
Un peu de vocabulaire :
Dans la suite du cours, on nommera les variables désignant des contenus typés simples par les mots variables de structure, variables simples, ou encore des variables typées. Exemple : motor1.
Les variables pointant un objet seront nommées variables de référence ou variables-objet. Exemple : motorSpeed.