Logo Mon Club Elec

EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)

Le EeePC-Bot est un robot autonome qui peut être contrôlé à l’aide d’une interface Processing utilisant la librairie Minim. Il est capable de tester simplement les moteurs et d’annoncer sonorement l’action en cours. Ce robot est une solution pratique pour les développeurs qui cherchent à tester leurs moteurs sans avoir à se soucier des détails techniques. Dans cet article, nous allons examiner en détail le fonctionnement du EeePC-Bot et comment il peut être utilisé pour tester simplement les moteurs avec annonce sonore de l’action en cours.

EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)

EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)

(cliquer sur l’image pour agrandir)

1.  Présentation

  • Programme de test simple des moteurs avec annonce sonore de l’opération en cours dans une interface Processing sur le PC connecté à la carte Arduino. Le programme Arduino envoie sur le port série une chaine de caractères correspondant au nom du fichier son à lire.
  • Après réception de la chaine de caractères, l’interface Processing déclenche la lecture d’un fichier son à l’aide de la librairie Minim qui implémente Javasound dans Processing (multi-plateformes)

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC

Ressources utiles associées à ce programme :

2.  Matériel Nécessaire

2.1  L’espace de développement Arduino

  • … pour éditer, compiler le programme et programmer la carte Arduino.
EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)

2.2  Le matériel suivant pour réaliser le montage associé

  • des straps,
EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)
EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)
EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)

3.  Instructions de montage

  • La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
  • Connexion de l’interface DFRobot 2A Moteur CC sur les broches de la carte Arduino :
    • Connecter broche de sens du moteur 1 sur la broche 4
    • Connecter broche de vitesse du moteur 1 sur la broche 5
    • Connecter broche de sens du moteur 2 sur la broche 7
    • Connecter broche de vitesse du moteur 2 sur la broche 6

4.  Le schéma théorique du montage

EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)

Le schéma théorique du montage (cliquer pour agrandir)

5.  Le circuit du montage

EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)

Le schéma du montage à réaliser (cliquer pour agrandir)

6.  Explication du programme

7.  Mise en oeuvre du programme

7.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

7.2  Fonctionnement

8.  Le programme complet en langage Arduino

A copier/coller directement dans l’éditeur Arduino

// — Programme 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 : 30/03/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 ? ———
 /*  */

// — Fonctionnalités utilisées —

// Utilise une carte d’interface moteurs CC DFRobot 2A
// Utilise la connexion série vers le PC

// ——– Circuit à réaliser ———

// Connexion de l’interface DFRobot 2A Moteur CC sur les broches de la carte Arduino :
// Connecter broche de sens du moteur 1 sur la broche 4
// Connecter broche de vitesse du moteur 1 sur la broche 5
// Connecter broche de sens du moteur 2 sur la broche 7
// Connecter broche de vitesse du moteur 2 sur la broche 6

// /////////////////////////////// 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 —

const int AVANT=1; // constante sens moteur
const int ARRIERE=0; // constante sens moteur
const int STOP=0; // constante vitesse moteur
// — Déclaration des constantes des broches E/S numériques —

//—- broches commandes premier moteur —
const int sensMoteur1=4; // Constante pour la broche 4
const int vitesseMoteur1=5; // Constante pour la broche 5

const int sensMoteurGauche=4; // Constante pour la broche 4
const int vitesseMoteurGauche=5; // Constante pour la broche 5

//—- broches commande premier moteur
const int vitesseMoteur2=6; // Constante pour la broche 6
const int sensMoteur2=7; // Constante pour la broche 7

const int vitesseMoteurDroit=6; // Constante pour la broche 6
const int sensMoteurDroit=7; // Constante pour la broche 7

// — Déclaration des constantes des broches analogiques —

// — Déclaration des variables globales —

 int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
 long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
 long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
 String chaineReception=«  »; // déclare un objet String vide pour reception chaine

// — 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

// ——- Broches en sorties numériques ——-  
 pinMode (sensMoteurDroit,OUTPUT); // Broche sensMoteurDroit configurée en sortie
 pinMode (vitesseMoteurDroit,OUTPUT); // Broche vitesseMoteurDroit configurée en sortie

 pinMode (vitesseMoteurGauche,OUTPUT); // Broche vitesseMoteurGauche configurée en sortie
 pinMode (sensMoteurGauche,OUTPUT); // Broche sensMoteurGauche configurée en sortie

// ——- 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 ——-  

Serial.println(« Serie Arduino OK »);

} // 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()

// — ici instructions à exécuter par le programme principal —

//— fichiers sons espeaker disponibles :
// test_des_moteurs.wav
// stop_moteur.wav
// moteur_gauche_en_marche_avant.wav
// moteur_droit_en_marche_avant.wav
// moteur_gauche_en_marche_arriere.wav
// moteur_droit_en_marche_arriere.wav
// je_tourne_a_droite.wav
// je_recule.wav
// j_avance.wav

//— Code type DFRduino 1A – DFRobot 2A
Serial.flush(); // vide buffer série

//joueSon(« test_des_moteurs.mp3 », true); // joue son et attend fin son
joueSon(« test_des_moteurs.wav », true); // joue son et attend fin son

//xxxxxxxxxxxxxxxx Test moteur gauche AVANT xxxxxxxxxxxxxxxxxxx

//joueSon(« test_moteur_gauche_avant.mp3 », true); // joue son et attend fin son
joueSon(« moteur_gauche_en_marche_avant.wav »,true); // joue son et attend fin son

moteurGauche(AVANT, 255); // moteurGauche en Avant à fond

delay(1000); // moteur tourne 3 secondes

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_4.mp3 », true); // joue son et attend fin son

delay(1000); // pause

//xxxxxxxxxxxxxxxx Test moteur gauche ARRIERE xxxxxxxxxxxxxxxxxxx

//—- message annonce
joueSon(« moteur_gauche_en_marche_arriere.wav »,true); // joue son et attend fin son

moteurGauche(ARRIERE, 255); // moteur Gauche en ARRIERE et à fond

delay(1000);

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_3.mp3 », true); // joue son et attend fin son

delay(1000); // pause

//xxxxxxxxxxxxxxxx Test moteur droit AVANT xxxxxxxxxxxxxxxxxxx

//—- message annonce
joueSon(« moteur_droit_en_marche_avant.wav »,true); // joue son et attend fin son

moteurDroit(AVANT, 255); // moteur Droit en Avant à fond

delay(1000);

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_4.mp3 », true); // joue son et attend fin son

delay(1000); // pause

//xxxxxxxxxxxxxxxx Test moteur droit ARRIERE xxxxxxxxxxxxxxxxxxx

//—- message annonce
joueSon(« moteur_droit_en_marche_arriere.wav »,true); // joue son et attend fin son

moteurDroit(ARRIERE, 255); // moteur Droit en ARRIERE et à fond

delay(1000);

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_2.mp3 », true); // joue son et attend fin son

delay(1000); // pause

//xxxxxxxxxxxxxxxx Test marche avant  xxxxxxxxxxxxxxxxxxx

//—- message annonce
joueSon(« j_avance.wav »,true); // joue son et attend fin son

enAvant(255); // en avant à fond

delay(1000);

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_1.mp3 », true); // joue son et attend fin son

delay(1000); // pause

//xxxxxxxxxxxxxxxx Test marche arriere xxxxxxxxxxxxxxxxxxx

//—- message annonce
joueSon(« je_recule.wav »,true); // joue son et attend fin son

enArriere(255); // en avant à fond

delay(1000);

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_1.mp3 », true); // joue son et attend fin son

delay(1000); // pause

//xxxxxxxxxxxxxxxx Test tourne droite xxxxxxxxxxxxxxxxxxx

//—- message annonce
joueSon(« je_tourne_a_droite.wav »,true); // joue son et attend fin son

tourneDroite(255); // tourne à droite à fond

delay(1000);

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_1.mp3 », true); // joue son et attend fin son

delay(1000); // pause

//xxxxxxxxxxxxxxxx Test tourne droite xxxxxxxxxxxxxxxxxxx

//—- message annonce
joueSon(« je_tourne_a_gauche.wav »,true); // joue son et attend fin son

tourneGauche(255); // tourne à gauche à fond

delay(1000);

arret(); // stoppe les moteurs
joueSon(« stop_moteur.wav »,true); // joue son et attend fin son

joueSon(« r2d2_1.mp3 », true); // joue son et attend fin son

delay(1000); // pause

while(1); //stop

} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////

// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////

//———— fonction déclenche lecture fichier coté PC ——–
void joueSon(String fichierSon, boolean retour) { // fonction joue son à partir nom fichier – si retour=true, attend caractère H fin son

  Serial.println(fichierSon);  //—– Message série pour message sonore dans Processing

  if (retour==true) { // si doit attendre fin son
    while (Serial.available()==0); // attend arrivée d’une réponse
    while(Serial.read()!=‘H’); // attend un H renvoyé par Processing à la fin son
  } // fin if retour==true

} // fin joueSon

//————- fonctions gestion moteurs robot —————

//— fonction controle moteur Droit
void moteurDroit(int sens, int vitesse) { // sens = 0 en arriere, sens = 1 en avant,

  analogWrite(vitesseMoteurDroit,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
  digitalWrite(sensMoteurDroit,sens); // Marche arriere

}

//— fonction controle moteur Gauche
void moteurGauche(int sens, int vitesse) { // sens = 0 en arriere, sens = 1 en avant,

  analogWrite(vitesseMoteurGauche,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
  digitalWrite(sensMoteurGauche,sens); // Marche arriere

}

//— fonction stop = arret complet
void arret() {

  analogWrite(vitesseMoteurGauche,STOP); // génère une impulsion PWM sur la broche de vitesse du moteur
  analogWrite(vitesseMoteurDroit,STOP); // génère une impulsion PWM sur la broche de vitesse du moteur

}

//—- fonction tourne à Droite
void tourneDroite (int vitesse) {

  moteurGauche(AVANT, vitesse);
  moteurDroit(ARRIERE, vitesse);

}

//—- fonction tourne à Gauche
void tourneGauche (int vitesse) {

  moteurGauche(ARRIERE, vitesse);
  moteurDroit(AVANT, vitesse);

}

//—- fonction en arriere
void enArriere (int vitesse) {

  moteurGauche(ARRIERE, vitesse);
  moteurDroit(ARRIERE, vitesse);

}

//—- fonction en avant
void enAvant (int vitesse) {

  moteurGauche(AVANT, vitesse);
  moteurDroit(AVANT, vitesse);

}

//—- vitesse
void vitesse (int vitesse) { // modifie la vitesse sans modifier le sens

   analogWrite(vitesseMoteurGauche,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
   analogWrite(vitesseMoteurDroit,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
}

// ////////////////////////// Fin du programme ////////////////////

 

9.  Programme Processing côté PC

9.1  Explication

9.2  Ressources utiles

  • La librairie Minim

9.3  Le programme complet en langage Arduino

  • Mettez des fichiers sons dans le répertoire de votre choix. Indiquer dans le programme le chemin des fichiers sons et tester plusieurs sons en changeant le nom du fichier son dans le programme. Vous trouverez ici une série de sons utilisables, dont quelques bruits de r2d2 sympas…

A copier/coller directement dans l’éditeur Arduino

// Programme processing
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT – Mars 2011 – tous droits réservés

/////////////// Description du programme ////////////
// Utilise un/des objets String (chaîne de caractère)
// Utilise le port Serie
// Utilise la librairie GUI controlP5
// Utilise un/des bouton(s) simple(s) (Button)
// Utilise un/des champ(s) texte (Textfield)
// Ajoute un bouton et un champ pour chemin fichier

/*
Reçoit la chaine renvoyée par Arduino et l’affiche dans la console.
Le fichier son voulu est joué en fonction de la chaine de caractères reçue.

Permet également l’envoi vers Arduino pour tests d’une chaîne texte saisie dans un champ texte.

*/

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import processing.serial.*; // importe la librairie série processing

import ddf.minim.*; // importe la librairie minim de gestion des sons sous Processing
// cette librairie doit être présente dans le répertoire /libraries du répertoire Processing
// voir ici : http://code.compartmental.net/tools/minim/

//— il existe un conflit entre espeaker et la librairie minim qui ne peuvent pas tre utilisés en meme temps

import controlP5.*; // importe la librairie GUI controlP5
// cette librairie doit être présente dans le répertoire /libraries du répertoire Processing
// voir ici : http://www.sojamo.de/libraries/controlP5/

// déclaration objets

String chaineEnvoi = «  »; // déclare un objet String (chaine de caractère)

// — port Série —
Serial  myPort; // Création objet désignant le port série

// — sons —
Minim minim; // déclare un objet de type Minim de portée globale
AudioPlayer player; // déclare un objet Audioplayer pour lire les sons

// — interface GUI —
ControlP5 controlP5; // déclare un objet principal de la librairie GUI controlP5

Button envoiButton; // déclare objet Button  

Textfield chaineText; // déclare des objets Textfield

// déclaration variables globales

//—— déclaration des variables de couleur utiles —-
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage

        // —- initialisation paramètres graphiques utilisés
        colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
        fill(0,0,255); // couleur remplissage RGB
        stroke (0,0,0); // couleur pourtour RGB
        rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
        imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
        //strokeWeight(0); // largeur pourtour
        frameRate(30);// Images par seconde

        // — initialisation fenêtre de base —
        size(400, 130); // ouvre une fenêtre xpixels  x ypixels
        background(0,0,0); // couleur fond fenetre

// — initialisation des objets et fonctionnalités utilisées —

        //————- initialisation port série —-
        println(Serial.list()); // affiche dans la console la liste des ports séries
        // Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec  Serial.list()[index]
        myPort = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série
        //myPort = new Serial(this, « /dev/ttyUSB0 », 115200); // Initialise une nouvelle instance du port Série
        myPort.bufferUntil(\n); // attendre arrivée d’un saut de ligne pour générer évènement série

        //————- initialisation objets de la librairie Minim (sons) —-
        // initialise l’objet Minim déclaré – cet objet donne accès à Javasound
        minim = new Minim(this); // Initialise l’objet Minim – le parent utilisé est this par défaut

        //— chargement d’un fichier son —-
        player = minim.loadFile(« test_des_moteurs.mp3 »); // charge un fichier son dans l’objet Audioplayer
        // ajouter le fichier sons dans le répertoire du programme via Sketch > Add File
        // taille par défaut du buffer 1024

        //—- infos sur le fichier sons et objets sons Minim —
/*      println(« **** Infos Audio **** »);
        player.printControls(); // pour avoir info sur les paramètres sons disponibles et leurs grandeurs
        println(« Volume actuel= »+player.getVolume()); // affiche la valeur du volume actuel
        println(« Durée Totale= »+player.length()+ »ms »); // affiche la taille du fichier
        println(« Taille Buffer= »+player.bufferSize()); // affiche la taille du buffer utilisé
        println(« Format Audio= »+player.getFormat()); // affiche le format du fichier audio
        println(« Taux Echantillonage= »+player.sampleRate()); // affiche le taux d’échantillonage du fichier audio
        println(« Type= »+player.type()); // affiche le type du fichier audio (Mono ou stéréo)
        println(« Position= »+player.position()); // affiche la position dans le fichier son
        println();
*/

        //======== Initialisation Objets GUI ControlP5 =========

        controlP5 = new ControlP5(this); // initialise l’objet principal de la librairie GUI controlP5

        // typeObjet nomObjet=controlP5.addObjet(paramètres); // pour info : déclaration / initialisation possible en 1 ligne
        // Textfield field = controlP5.addTextfield(« myWindowTextfield »,70,130,100,20); // exemple

        //======== Initialisation Objets Button =========

        //—- le bouton envoi chaine
        envoiButton=controlP5.addButton(« envoiButton »,0,width60,height40,50,24); // initialise et ajoute un Button au ControlP5
        envoiButton.setLabelVisible(true); // affichage des labels
        envoiButton.setLabel(« ENVOI »); // fixe label du bouton
        envoiButton.setColorActive(color(255,0,0)); // fixe la couleur active
        envoiButton.setColorForeground(color(0,255,255)); // fixe couleur avant

        //======== Initialisation Objets Textfield =========

        //—- champ texte saisie chaine
        chaineText=controlP5.addTextfield(« cheminText »,10,height40,300,20); // initialise et ajoute un Textfield au ControlP5
        chaineText.setAutoClear(false); // autoeffacement après return
        chaineText.setValue(chaineEnvoi); // initialise Texte du champ
        chaineText.setLabelVisible(true); // affichage des labels
        chaineText.setLabel(« CHEMIN »); // fixe label
        chaineText.setColorActive(color(255,0,0)); // fixe la couleur active
        chaineText.setColorForeground(color(0,255,255)); // fixe couleur avant

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

  // tout se passe dans la fonction SerialEvent

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

//————- Fonction de gestion des évènements série —-
void serialEvent (Serial myPort) { // fonction appelée lors de la survenue d’un évènement série

        // ******** Gestion de la valeur reçue sur le port série : **********

        String inString = myPort.readStringUntil(\n); // chaine stockant la chaîne reçue sur le port Série
        // saut de ligne en marque de fin

        if (inString != null) { // si la chaine recue n’est pas vide

        print (inString); // affichage brut de la chaine recue

        //xxxxxxxxxxxxxxxxxxxxxxxx Gestion nom de fichier xxxxxxxxxxxxxxxx

        //———— analyse de la chaine reçue et sélection son ——–
        String nomFichier=«  »; // String pour nom fichier

        //—- jeu de sons r2d2 récupérés sur le web —
        if (match(inString,« r2d2_1.mp3 »)!=null) nomFichier=« r2d2_1.mp3 »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« r2d2_2.mp3 »)!=null) nomFichier=« r2d2_2.mp3 »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« r2d2_3.mp3 »)!=null) nomFichier=« r2d2_3.mp3 »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« r2d2_4.mp3 »)!=null) nomFichier=« r2d2_4.mp3 »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« r2d2_5.mp3 »)!=null) nomFichier=« r2d2_5.mp3 »; // test la chaine reçue et définit nom fichier son associé

        //—- jeu de sons espeaker enregistrés —
        if (match(inString,« moteur_gauche_en_marche_arriere.wav »)!=null) nomFichier=« moteur_gauche_en_marche_arriere.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« test_des_moteurs.wav »)!=null) nomFichier=« test_des_moteurs.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« stop_moteur.wav »)!=null) nomFichier=« stop_moteur.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« moteur_gauche_en_marche_avant.wav »)!=null) nomFichier=« moteur_gauche_en_marche_avant.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« moteur_droit_en_marche_avant.wav »)!=null) nomFichier=« moteur_droit_en_marche_avant.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« moteur_droit_en_marche_arriere.wav »)!=null) nomFichier=« moteur_droit_en_marche_arriere.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« je_tourne_a_droite.wav »)!=null) nomFichier=« je_tourne_a_droite.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« je_tourne_a_gauche.wav »)!=null) nomFichier=« je_tourne_a_gauche.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« je_recule.wav »)!=null) nomFichier=« je_recule.wav »; // test la chaine reçue et définit nom fichier son associé
        if (match(inString,« j_avance.wav »)!=null) nomFichier=« j_avance.wav »; // test la chaine reçue et définit nom fichier son associé

        //if (match(inString, » »)!=null) nomFichier= » »; // test la chaine reçue et définit nom fichier son associé

         if (nomFichier!=«  ») { // si une chaine valide a été reçue

           //— chargement du fichier son —-
           //player = minim.loadFile(« test_des_moteurs.mp3 »); // charge un fichier son dans l’objet Audioplayer
           player = minim.loadFile(nomFichier); // charge un fichier son dans l’objet Audioplayer
            // ajouter le fichier sons dans le répertoire du programme via Sketch > Add File
            // taille par défaut du buffer 1024
           //player.setVolume(65535); // fixe le volume 0-65536

            player.play(); // lance la lecture du son
            delay (player.length()+500); // attend la durée du son + délai

           //— signale à Arduino fin son
           myPort.write(‘H’); // envoie le caractère sur le port Série

         } // fin si chaine valide

        } // fin condition chaine recue pas vide

} // fin de la fonction de gestion des évènements Série

//————- Fonction d’arret de la librairie Minim —-

void stop(){ // fonction d’arrêt de la librairie Minim

        // toujours fermer les objets Minim
        player.close();
        minim.stop();
        super.stop();

}

// Gestion des évènements des objets GUI controlP5 —-

//—— fonction gestion globale des évènements GUI controlP5
public void controlEvent(ControlEvent theEvent) {
        //println(theEvent.controller().name());// affiche le nom de l’évènement
}

        //—- evenement bouton envoi chaine

void envoiButton(int theValue) { // fonction évènement Button de meme nom – reçoit la valeur

        println(« Evènement envoiButton »);

        myPort.write(chaineText.getText()+« \n« ); // envoie la chaine suivi saut ligne sur le port Série
        print(« Envoi de la chaine : »);
        print(chaineText.getText()+« \n« );
        chaineText.setValue(«  »); // vide le champ texte

} // fin evènement bouton envoi

// —— gestion évènement Textfield ——

        //—- evenement champ texte chemin fichier

public void chaineText(String theText) { // fonction évènement Textfield de meme nom – déclenché par return – reçoit la chaine

        //println(« Evènement CheminText avec valeur = « +theText);

        chaineEnvoi=theText; // mémorise le contenu du champ

        //println(« Le chemin est : »+chaineEnvoi);

} // fin evènement champ texte chemin fichier

//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX

 

10.  Pour aller plus loin…

Noter cet article

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Archive Mon Club Elec

Articles populaires

Newsletter

Inscrivez-vous maintenant et bénéficiez d'un soutien continu pour réaliser vos travaux électriques en toute sécurité.