LA CARTE ME AURIGA
La carte "Me Auriga" est basée sur un ATmega 2560, ce qui la rend plus performante que la carte Me Orion. Elle possède 10 ports dont 4 pouvant piloter des moteurs à l'aide d'un module "Me Dual DC Motor Driver".
La carte "Me Auriga" comporte :
-
une interface de puissance pilotant les moteurs à courant continu avec encodeur sous 6 à 12 V et 2,4 A max
-
deux capteurs de lumière
-
un capteur de bruit
-
un capteur de température
-
un gyroscope
-
un buzzer
-
un anneau de 12 led adressables
Malheureusement, la bibliothèque Makeblock ne gère pas l'intégralité des capteurs et led présents sur la carte "Me Auriga". L'utilisation du capteur de température et des encodeurs a été présentée sous forme d'exemples fournis par Makeblock mais nous verrons des exemples des autres fonctions dans les paragraphes suivants.
La carte "Me Auriga" comporte également un support sur lequel nous pouvons insérer un module Bluetooth, ce qui libère un port par rapport à la carte "Me Orion" mais ce module est connecté aux broches RX0 et TX0 (la même liaison série utilisée par le moniteur série et la même liaison série utilisée pour la programmation de la carte). Cela impose des contraintes non négligeables :
-
pour programmer la carte, il faut retirer le module Bluetooth puis débrancher la carte avant de remettre le module Bluetooth.
-
si le module Bluetooth est utilisé pour échanger des données avec un autre appareil Bluetooth, le moniteur série ne peut plus être utilisé.
Pour utiliser la carte Auriga avec une alimentation externe (piles ou accumulateurs), il faut brancher cette dernière dans le connecteur jack prévu à cet effet et appuyer sur le bouton rouge "POWER" situé juste à côté pour activer l'alimentation de la carte.
Ci-dessous, une vue détaillée de la carte "Me Auriga" avec les couleurs différenciant la nature des ports (Voir ici). Certains ports acceptent tous les types de modules (digitaux, analogiques et I2C).
Contrairement à la carte "Me Orion", nous pouvons faire quelques exercices sans posséder de modules complémentaires. Profitons-en !!!
Exemple N°1 : L'anneau de led RGB
Nous souhaitons reprendre l'exemple "ColorLoopTest" donné par Makeblock pour tester le module "Me led adressables" en l'adaptant pour pouvoir utiliser l'anneau de led intégré à la carte "Me Auriga". Cet exemple change aléatoirement la couleur des led.
Programme N°1 :
/* Led_Auriga est un programme qui change aléatoirement la couleur des led de la carte "Me Auriga" */
#include "MeAuriga.h" // appel de la bibliothèque
MeRGBLed led(0,12); // création de l'objet led
float j, f, k;
void setup()
{
led.setpin(44); // le module est branché sur la broche numérique N°44
}
void loop()
{
couleur(); // appel de la fonction couleur
}
void couleur()
{
for(int t = 0; t < 12; t++) // on allume successivement les 12 led
{
int rouge = 64 * (1 + sin(t / 2.0 + j / 4.0) ); // on fait varier la couleur rouge
int vert = 64 * (1 + sin(t / 1.0 + f / 9.0 + 2.1) ); // on fait varier la couleur verte
int bleu = 64 * (1 + sin(t / 3.0 + k / 14.0 + 4.2) ); // on fait varier la couleur bleu
led.setColorAt(t, rouge, vert, bleu); // on allume la led t avec les couleurs rouge, verte et bleu
}
led.show(); // on rafraichit l'anneau de led
j += random(1, 6) / 6.0; // on change aléatoirement l'état des variables j, f et k
f += random(1, 6) / 6.0;
k += random(1, 6) / 6.0;
}
Exemple N°2 : Les capteurs de lumière
Nous souhaitons indiquer, à l'aide de l'anneau de led adressables RGB, quel est le capteur de lumière recevant le plus de lumière.
Si les deux capteurs reçoivent autant de lumière, la led N°2 de l'anneau est allumée en blanc.
Si le capteur de lumière N°1 reçoit plus de lumière que le capteur de lumière N°2, la led N°1 s'allume en rouge.
Si le capteur de lumière N°2 reçoit plus de lumière que le capteur de lumière N°1, la led N°3 s'allume en rouge.
Programme N°2 :
/* Lumière_Auriga est un programme qui allume :
- la led 2 led de la carte "Me Auriga" si les deux capteurs de lumière reçoivent la mêm quantité de lumière
- la led 1 led de la carte "Me Auriga" si le capteur 1 reçoit plus de lumière que le capteur 2
- la led 3 led de la carte "Me Auriga" si le capteur 2 reçoit plus de lumière que le capteur 1
*/
#include "MeAuriga.h" // appel de la bibliothèque
MeRGBLed led(0,12); // création de l'objet led
MeLightSensor capteur_1(12); // création de l'objet capteur_1
MeLightSensor capteur_2(11); // création de l'objet capteur_2
int lum_1;
int lum_2;
void setup()
{
led.setpin(44); // le module est branché sur la broche numérique N°44
Serial.begin(9600);
}
void loop()
{
lum_1=capteur_1.read(); // on fait l'acquisition de la quantité de lumière reçue sur le capteur 1
lum_2=capteur_2.read(); // on fait l'acquisition de la quantité de lumière reçue sur le capteur 2
Serial.print("La valeur du capteur 1 est de ");
Serial.println(lum_1);
Serial.print("La valeur du capteur 2 est de ");
Serial.println(lum_2);
if ((lum_1>lum_2-10)&&(lum_1<lum_2+10)) // on introduit un intervalle pour éviter de faire clignoter les led 1 et 3
{
led.setColorAt(2, 100, 100, 100); // on allume la led 2 en blanc
led.setColorAt(1, 0 , 0, 0); // on éteint la led 1
led.setColorAt(3, 0 , 0, 0); // on éteint la led 3
Serial.println("La lumiere est la meme sur les deux capteurs");
}
if (lum_1>lum_2+10)
{
led.setColorAt(1, 100, 0, 0); // on allume la led 1 en rouge
led.setColorAt(2, 0 , 0, 0); // on éteint la led 2
led.setColorAt(3, 0 , 0, 0); // on éteint la led 3
Serial.println("Le capteur 1 recoit plus de lumiere");
}
if (lum_2>lum_1+10)
{
led.setColorAt(3, 100, 0, 0); // on allume la led 3 en rouge
led.setColorAt(1, 0 , 0, 0); // on éteint la led 1
led.setColorAt(2, 0 , 0, 0); // on éteint la led 2
Serial.println("Le capteur 2 recoit plus de lumiere");
}
led.show(); // on rafraichit l'anneau de led
delay(1000);
}
Exemple N°3 : Le capteur de son
Nous souhaitons capter un son et afficher le signal dans le traceur série. Nous souhaitons allumer l'anneau de led lorsqu'un son important est capté (ex : claquement de doigt).
Remarque : le boitier de protection de la carte "Me Auriga" atténue fortement les sons extérieurs. Il faut donc un bruit relativement important pour voir une variation.
Programme N°3 :
/* Son_Auriga est un programme qui capte le son grâce au capteur de la carte "Me Auriga", affiche le signal dans le traceur série et illumine l'anneau de led avec une couleur aléatoire à chaque augmentation brutale du son */
#include "MeAuriga.h" // appel de la bibliothèque
MeRGBLed led(0,12); // création de l'objet led
MeSoundSensor son(14); // création de l'objet son
long volume;
byte rouge=128;
byte vert=75;
byte bleu=90;
void setup()
{
led.setpin(44); // le module est branché sur la broche numérique N°44
Serial.begin(115200); // initialisation de la liaison série
}
void loop()
{
for(int i=0; i<32; i++)
{
volume = volume + son.strength();
}
volume >>= 5;
Serial.println(volume);
delay(10);
if( (volume>190)|| (volume<140) ) // si on capte un bruit
{
for(int i = 0; i < 12; i++) // on allume les 12 led en bleu
{
led.setColorAt(i, rouge, vert, bleu);
}
}
else
{ for(int i = 0; i < 12; i++) // on éteint les 12 led
{
led.setColorAt(i, 0, 0, 0);
}
}
led.show(); // on rafraichit l'anneau de led
delay(10);
rouge=random(0, 255); // on change la couleur des led pour le prochain allumage
vert=random(0, 255);
bleu=random(0, 255);
}
Exemple N°4 : Le capteur de température
Nous souhaitons capter la température et afficher sa valeur dans le moniteur série.
Remarque : le boitier de protection de la carte "Me Auriga" isole également le capteur de température de l'extérieur et la chaleur dégagée par les composants de la carte fausse le résultat de la mesure. Il est préférable d'utiliser le module "Me Capteur de température".
Programme N°4 :
/* Temp_Auriga est un programme qui capte la température grâce au capteur de la carte "Me Auriga" et affiche la valeur dans le moniteur série*/
#include "MeAuriga.h" // appel de la bibliothèque
MeOnBoardTemp capteur_temp(PORT_13); // création de l'objet capteur_temp
int temp;
int temp_celcius;
void setup()
{
Serial.begin(9600); // initialisation de la liaison série
}
void loop()
{
temp=capteur_temp.readAnalog(); // acquisition de la valeur du convertisseur analogique-numérique
temp_celcius=capteur_temp.readValue(); // acquisition de la valeur de la température
Serial.print("La valeur du CAN est de ");
Serial.println(temp);
Serial.print("La valeur de la temperature est de ");
Serial.print(temp_celcius);
Serial.println(" *C");
delay(200);
}
Exemple N°5 : Le gyroscope et le buzzer
Nous souhaitons faire sonner le buzzer de la carte "Me Auriga" lorsque celle-ci aura été déplacée. Nous afficherons les nouvelles coordonnées de la carte dans le moniteur série.
Programme N°5 :
/* Gyro_Auriga est un programme qui capte la température grâce au capteur de la carte "Me Auriga"
et affiche la valeur dans le moniteur série*/
#include "MeAuriga.h" // appel des bibliothèques
#include <Wire.h>
MeGyro gyro(0,0x69); // création de l'objet gyro
MeBuzzer buzzer; // création de l'objet buzzer
int X;
int Y;
int Z;
int X_memo;
int Y_memo;
int Z_memo;
void setup()
{
Serial.begin(9600); // initialisation de la liaison série
buzzer.setpin(45); // le buzzer est branché sur la broche numérique 45
gyro.begin(); // initialisation du gyroscope
X_memo=gyro.getAngle(1); // acquisition de la position initiale de la carte
Y_memo=gyro.getAngle(2);
Z_memo=gyro.getAngle(3);
Serial.print("X="); // on affiche dans le moniteur série
Serial.print(X);
Serial.print(" Y=");
Serial.print(Y);
Serial.print(" Z=");
Serial.println(Z);
}
void loop()
{
gyro.update();
X=gyro.getAngle(1); // acquisition de la position actuelle de la carte
Y=gyro.getAngle(2);
Z=gyro.getAngle(3);
if ((X!=X_memo) || (Y!=Y_memo) ||(Z!=Z_memo)) // si position différente de la précédente
{
buzzer.tone(400, 500); // on fait sonner le buzzer
Serial.print("X="); // on affiche la nouvelle position
Serial.print(X);
Serial.print(" Y=");
Serial.print(Y);
Serial.print(" Z=");
Serial.println(Z);
delay(100);
X_memo=X; // on mémorise la nouvelle position
Y_memo=Y;
Z_memo=Z;
}
}
