Bonjour,
Mon projet global consiste à commander des moteurs d'aiguillages d'un réseau de train miniature depuis une appli Android sur mon smartphone. Les commandes sont émises en bluetotooth sur un module HC06 à un Arduino Uno. Celui-ci communique avec deux Arduino Mega via i2c. Pour tout cela, tout est OK, cela fonctionne comme je veux.
Sur chacun de mes Mega, je reçois les ordres de façon numérique : le(s) chiffres des dizaines correspondent un numéro du servo, les unités à la position (0 pour gauche, 5 pour droite, 9 = pas de mouvement, juste retour sur la position actuelle).
Pour chaque moteur, j'ai une position gauche et une position droite définie par l'angle, dans des tableaux.
Au démarrage du sketch, je mets mes servos dans une position initiale. Cela fonctionne, les servos fonctionnent pour basculer dans la position initiale voulue.
En revanche, je reçois bien les commandes, mais il n'y a pas de mouvement ! C'est sûrement une petite erreur... Mais je ne la vois pas ! Auriez-vous une idée ?
[code]
/*
Pour un Arduino Mega
*/
#include <Wire.h> // On ajoute la bibliothèque Wire.h qui permet la communication i2c
#include <Servo.h> // On ajoute la bibliothèque Servo.h qui permet la commande des servos
#define I2C_SLAVE_ADDRESS_MODULE_A_11 11 // On définit sous le nom "I2C_SLAVE_ADDRESS_MODULE_A_11" et la valeur 11 l'adresse de l'Arduino esclave du module A
const byte PIN_MOTEUR[16] = {0, 2, 0, 3, 0, 5, 0, 7, 0, 9, 0, 0, 0, 0, 10, 12}; // On définit une liste qui constient les numéros des pins des commandes des (servo)moteurs du module A
Servo servo_moteur[16]; // On définit une liste d'objets (servo)moteurs
// Pour les moteurs : 1 3 5 7* 9 14 15
word gauche_moteur[16] = { 0 , 60 , 2 , 60 , 4 , 60 , 6 , 30 , 8 , 150 , 10 , 11 , 12 , 13 , 140 , 120 }; // Définit un tableau de 16 valeurs de positions "gauche_moteur" pour les servos (le paramétrage correspond à la réalité des moteurs DLY2 du réseau)
word droite_moteur[16] = { 0 , 140 , 2 , 140 , 4 , 140 , 6 , 160 , 8 , 70 , 10 , 11 , 12 , 13 , 50 , 40 }; // Définit un tableau de 16 valeurs de positions "droite_moteur" pour les servos (le paramétrage correspond à la réalité des moteurs DLY2 du réseau)
int angle_avant, angle_commande, angle_final; // On définit les variables dans lesquelles on va stocker l'angle des servo(moteurs) avant, après mouvement, et l'angle de commande
int gauche_droite_info_moteur, num_moteur; // On définit les variables dans lesquelles on va stocker la commande (0 pour gauche, 5 pour droite, 9 pour demande position) et le numéro de moteur
int valeur_recue, valeur_a_transmettre; // On définit les variables dans lesquelles on va stocker la commande recue et la réponse à transmettre
void setup()
{
Wire.begin(I2C_SLAVE_ADDRESS_MODULE_A_11); // On démarre la communication i2c en tant qu'esclave sous l'adresse "I2C_SLAVE_ADDRESS_MODULE_A_11"
Serial.begin(9600); // On démarre la liaison série à 9600 baud
Serial.println("-------------------------------------");
Serial.println(" Je suis l'Ardunion esclave 1"); // On écrit "Je suis l'Arduino esclave 1" sur le moniteur série
Serial.println("-------------------------------------");
delay(100); // On attend 100 ms
Wire.onRequest(requestEvents); // On indique que c'est "requestEvents" qui est exécutée en cas de demande de l'Arduino maître
Wire.onReceive(receiveEvents); // On indique que c'est "receiveEvents" qui est exécutée en cas de réception de données de l'Arduino maître
initialisation_moteurs(); // On bascule les moteurs dans la position initiale
}
void loop()
{
} // Boucle loop vide
void requestEvents() // Fonction "requestEvents" qui est exécutée en cas de demande de l'Arduino maître
{
Serial.println(F("(Requête reçue)")); // On écrit "---> requête reçue" sur le moniteur série
Serial.print(F(">> Envoi de la valeur : ")); // On écrit "Envoi de la valeur : " sur le moniteur série
Serial.println(valeur_a_transmettre); // On écrit valeur_a_transmettre sur le moniteur série
Serial.println("-------------------------------------");
Wire.write(valeur_a_transmettre); // On envoie valeur_a_transmettre sur la liaison i2c
}
void receiveEvents(int numBytes) // Fonction "receiveEvents" qui est exécutée en cas de réception de données de l'Arduino maître et les stocke dans la variable numBytes
{
Serial.println(F("(Réception de données)")); // On écrit "---> réception de données" sur le moniteur série
Serial.print(F(">> "));
valeur_recue = Wire.read(); // On met la valeur reçue de la liaison i2c dans valeur_recue
Serial.print(numBytes); // On écrit numBytes sur le moniteur série
Serial.println(F(" octets reçus")); // On écrit " octets reçus" sur le moniteur série
Serial.print(F(">> Valeur reçue : ")); // On écrit "valeur reçue : " sur le moniteur série
Serial.println(valeur_recue); // On écrit valeur_recue sur le moniteur série
Serial.println("- - - - - - - - - - - - - - - - - - -");
num_moteur = valeur_recue / 10; // On met dans "num_moteur" le chiffre des dizaines de "valeur_recue"
gauche_droite_info_moteur = valeur_recue % 10; // On met dans "gauche_droite_info_moteur" le chiffre de commande (0,5 ou 9)
if (gauche_droite_info_moteur == 0) // Si "gauche_droite_info_moteur" = 0
{
attach_servos(); // On attache les (servo)moteurs
mouvement_servo(num_moteur, gauche_moteur[num_moteur]); // On bascule le moteur numéro "num_moteur" dans la position d'angle "gauche_moteur[num_moteur]"
detach_servos(); // On détache les (servo)moteurs
}
else if (gauche_droite_info_moteur == 5) // Sinon si "gauche_droite_info_moteur" = 5
{
attach_servos(); // On attache les (servo)moteurs
mouvement_servo(num_moteur, droite_moteur[num_moteur]); // On bascule le moteur numéro "num_moteur" dans la position d'angle "droite_moteur[num_moteur]"
detach_servos(); // On détache les (servo)moteurs
}
Serial.print(F(">> Angle du moteur ")); // On écrit ">> Angle du moteur " sur le moniteur série
Serial.print(num_moteur); // On écrit le numéro de moteur sur le moniteur série
Serial.print(F(" : ")); // On écrit ">> : " sur le moniteur série
Serial.println(angle_final); // On écrit la valeur de l'angle de commande demandé
Serial.println("- - - - - - - - - - - - - - - - - - -");
delay(1000); // On attend 1 seconde
// Puis on construit la valeur à renvoyer vers le Master et le téléphione, on la mettra dans valeur_a_transmettre
valeur_a_transmettre = valeur_recue + 100; // ----------> SERA A ENLEVER On fixe à valeur_recue + 100 la valeur à transmettre
}
void mouvement_servo(int num_moteur, int angle_commande) // ----------> A COMPLETER Fonction mouvement_servo, prend pour arguments le numéro de moteur et l'angle de commande
{
Serial.print(F(">> Mouvement fictif du moteur ")); // On écrit ">> Mouvement fictif du moteur " sur le moniteur série
Serial.print(num_moteur); // On écrit le numéro de moteur sur le moniteur série
Serial.print(F(" vers l'angle ")); // On écrit ">> vers l'angle " sur le moniteur série
Serial.println(angle_commande); // On écrit l'angle de commande demandé
Serial.println("- - - - - - - - - - - - - - - - - - -");
servo_moteur[num_moteur].write(angle_commande); // On bascule le (servo)moteur 15 dans la position angle_commande
}
void prepare_reponse_au_Master(int num_moteur, int angle_commande) // ----------> VERIFIER LES ARGUMENTS ET ECRIRE
{
}
int mesure_angle_servo(int num_moteur) // ----------> A MODIFIER POUR SEPARER "mesure_angle_servo" ET "prepare_reponse_au_Master" ET AJOUTER LES COMMENTAIRES La fonction prend pour argument le numéro de moteur et donne sa position en angle
{
int valeur_a_retourner, position_moteur; // On crée une variable locale "position_moteur"
servo_moteur[num_moteur].attach(PIN_MOTEUR[num_moteur]); // On attache le (servo)moteur pour le numéro de moteur demandé
position_moteur = servo_moteur[num_moteur].read(); // On lit la position du (servo)moteur demandé et on l'écrit dans "position_moteur"
servo_moteur[num_moteur].detach(); // On détache le (servo)moteur
return position_moteur; // On demande à la fonction de retourner la position du moteur
if (position_moteur == gauche_moteur[num_moteur])
{
valeur_a_retourner = 100 + 10 * num_moteur + 0;
}
else if (position_moteur == droite_moteur[num_moteur])
{
valeur_a_retourner = 100 + 10 * num_moteur + 5;
}
else valeur_a_retourner = 100 + 10 * num_moteur + 9;
return valeur_a_retourner;
}
void initialisation_moteurs() // Fonction qui initialise les moteurs dans la position de départ
{
attach_servos(); // On attache les (servo)moteurs
mouvement_servo(1, droite_moteur[1]); // On bascule le (servo)moteur 1 dans la position droite_moteur[1]
Serial.println(">> Moteur 1 initialisé à droite"); // On écrit ">> Moteur 1 initialisé à droite" sur le moniteur série
delay(100); // On attend 100 ms
Serial.println("- - - - - - - - - - - - - - - - - - -");
mouvement_servo(3, droite_moteur[3]); // On bascule le (servo)moteur 3 dans la position droite_moteur[3]
Serial.println(">> Moteur 3 initialisé à droite"); // On écrit ">> Moteur 3 initialisé à droite" sur le moniteur série
delay(100); // On attend 100 ms
Serial.println("- - - - - - - - - - - - - - - - - - -");
mouvement_servo(5, droite_moteur[5]); // On bascule le (servo)moteur 5 dans la position droite_moteur[5]
Serial.println(">> Moteur 5 initialisé à droite"); // On écrit ">> Moteur 5 initialisé à droite" sur le moniteur série
delay(100); // On attend 100 ms
Serial.println("- - - - - - - - - - - - - - - - - - -");
mouvement_servo(7, droite_moteur[7]); // On bascule le (servo)moteur 7 dans la position droite_moteur[7]
Serial.println(">> Moteur 7 initialisé à gauche"); // On écrit ">> Moteur 7 initialisé à gauche" sur le moniteur série
delay(100); // On attend 100 ms
Serial.println("- - - - - - - - - - - - - - - - - - -");
mouvement_servo(9, gauche_moteur[9]); // On bascule le (servo)moteur 9 dans la position gauche_moteur[9]
Serial.println(">> Moteur 9 initialisé à gauche"); // On écrit ">> Moteur 9 initialisé à gauche" sur le moniteur série
delay(100); // On attend 100 ms
Serial.println("- - - - - - - - - - - - - - - - - - -");
mouvement_servo(14, droite_moteur[14]); // On bascule le (servo)moteur 14 dans la position droite_moteur[14]
Serial.println(">> Moteur 14 initialisé à droite"); // On écrit ">> Moteur 14 initialisé à droite" sur le moniteur série
delay(100); // On attend 100 ms
Serial.println("- - - - - - - - - - - - - - - - - - -");
mouvement_servo(15, droite_moteur[15]); // On bascule le (servo)moteur 15 dans la position droite_moteur[15]
Serial.println(">> Moteur 15 initialisé à droite"); // On écrit ">> Moteur 15 initialisé à droite" sur le moniteur série
Serial.println("- - - - - - - - - - - - - - - - - - -");
delay(100); // On attend 100 ms
detach_servos(); // On détache les (servo)moteurs
Serial.println("-------------------------------------");
}
void attach_servos() // Fonction qui attache les (servo)moteurs
{
servo_moteur[1].attach(PIN_MOTEUR[1]); // On attache le (servo)moteur 1
servo_moteur[3].attach(PIN_MOTEUR[3]); // On attache le (servo)moteur 3
servo_moteur[5].attach(PIN_MOTEUR[5]); // On attache le (servo)moteur 5
servo_moteur[7].attach(PIN_MOTEUR[7]); // On attache le (servo)moteur 7
servo_moteur[9].attach(PIN_MOTEUR[9]); // On attache le (servo)moteur 9
servo_moteur[14].attach(PIN_MOTEUR[14]); // On attache le (servo)moteur 14
servo_moteur[15].attach(PIN_MOTEUR[15]); // On attache le (servo)moteur 15
}
void detach_servos() // Fonction qui détache les (servo)moteurs
{
servo_moteur[1].detach(); // On détache le (servo)moteur 1
servo_moteur[3].detach(); // On détache le (servo)moteur 3
servo_moteur[5].detach(); // On détache le (servo)moteur 5
servo_moteur[7].detach(); // On détache le (servo)moteur 7
servo_moteur[9].detach(); // On détache le (servo)moteur 9
servo_moteur[14].detach(); // On détache le (servo)moteur 14
servo_moteur[15].detach(); // On détache le (servo)moteur 15
}
[/code]
