Le EeePC-Bot est un robot qui combine des technologies avancées pour mesurer la distance avec un capteur analogique GP2D12 et annoncer le résultat de la mesure à l’aide d’une voix synthétique. Il utilise une interface Processing Mplayer pour lire des fichiers audio et Espeaker pour générer des voix synthétiques. La communication entre le robot et le capteur se fait par une chaine série. Grâce à cette technologie, le EeePC-Bot est capable de mesurer la distance entre 10 et 80 cm avec une précision remarquable.
EeePC-bot : Mesure de la distance par le capteur analogique GP2D12 (10 à 80cm) et annonce vocale du résultat de la mesure.
Explications
- Sur cette page, je vous montre un exemple de test sur le EeePC-Bot de mesure de la distance à l’aide du capteur de distance GP2D12 avec annonce vocale de la distance par le EeePC embarqué par synthèse vocale.
- Le programme Arduino de la carte Arudino :
- réalise une mesure moyennée de la sortie (non linéaire) du capteur de distance GP2D12.
- analyse ensuite cette pour déterminer la distance à partir d’un tableau de valeurs de référence.
- Puis une chaine de caractère pour synthèse vocale est envoyée sur le port série vers le EeePC du robot.
- Le programme Processing sur le EeePC embarqué du robot :
- analyse la chaine reçue sur le port série
- et lance la synthèse vocale en lançant le logiciel espeak par ligne de commande programmée (sous Ubuntu), lorsque la chaine reçue commence par « espeak= ».
- Remarquer notamment comment le programme Arduino utilise les variables pour la composition de la chaine de caractères envoyée pour la synthèse vocale : espeak pourra ainsi synthétiser des messages du type « distance comprise entre 30 et 35 centimètres » !
Ressources utiles
- Structure mécanique et électronique du EeePC-Bot
- Test simple annonce sonore avec le logiciel de synthèse vocale (espeak)
- Capteur de distance analogique GP2D12 (+10cm à +80cm)
Montage utilisé
Le montage utilisé pour ces tests est le suivant :
- Le capteur de distance GP2D12 est connecté sur la broche analogique 0.
Le programme Arduino sur la carte Arduino embarquée sur le EeePC-Bot
- Ce programme intègre toutes les fonctions utiles pour la commande des moteurs, bien qu’elles ne servent pas directement ici.
// 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 : 17/4/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 ? ———
/* Programme pour le EeePC-Bot
Réalise annonce vocale sur le EeePC de la distance mesurée
par envoie chaine sur le port série.
*/
// — Fonctionnalités utilisées —
// Utilise la connexion série matérielle vers le PC
// Utilise la conversion analogique numérique 10 bits
// Utilise une carte d’interface moteurs CC DFRobot 2A
// ——– Circuit à réaliser ———
// La connexion série matérielle 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 Gauche sur la broche 4
// Connecter broche de vitesse du moteur Gauche sur la broche 5
// Connecter broche de sens du moteur Droit sur la broche 7
// Connecter broche de vitesse du moteur Droit sur la broche 6
// Broche 14 : Sortie analogique capteur GP2D12
// /////////////////////////////// 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
const int MAXI=255; // constante vitesse moteur
const int MEDIUM=127; // constante vitesse moteur
// — Déclaration des constantes des broches E/S numériques —
const int sensMoteurGauche=4; // Constante pour la broche 4
const int vitesseMoteurGauche=5; // Constante pour la broche 5
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 —
const int GP2D12=0; // Constante pour la broche analogique 0
// — Déclaration des variables globales —
int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique
int distance; // distance référence
//— tableau de valeurs en millivolts pour distance de 5 en 5cm de 10 à 80 cm pour le capteur GP2D12
// 1ère valeur a l’index 0
int calibrage[]={
2370, // 10 cm – index 0
1700, // 15 cm – index 1
1300, // 20 cm – index 2
1100, // 25 cm – index 3
950, // 30 cm – index 4
830, // 35 cm – index 5
720, // 40 cm – index 6
650, // 45 cm – index 7
580, // 50 cm – index 8
540, // 55 cm – index 9
500, // 60 cm – index 10
480, // 65 cm – index 11
450, // 70 cm – index 12
430, // 75 cm – index 13
410, // 80 cm – index 14
400, // au delà 80cm – index 15
}; // fin du tableau
// — 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 matérielle à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// ——- Broches en sorties numériques ——-
pinMode (sensMoteurGauche,OUTPUT); // Broche sensMoteurGauche configurée en sortie
pinMode (vitesseMoteurGauche,OUTPUT); // Broche vitesseMoteurGauche configurée en sortie
pinMode (vitesseMoteurDroit,OUTPUT); // Broche vitesseMoteurDroit configurée en sortie
pinMode (sensMoteurDroit,OUTPUT); // Broche sensMoteurDroit configurée en sortie
//——— désactive broche 2 au cas où servomoteur connecté ——–
pinMode (2,OUTPUT); // Broche sensMoteurDroit configurée en sortie
digitalWrite(2,HIGH); // Broche au niveau bas
// ——- 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 ——-
// ——- Codes d’initialisation utile ——-
} // 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 —
//mesure_brute= analogRead(broche_analogique) ; // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée
//joueSon(« freesound_FromE.wav », true); // joue fichier son
joueSon(« freesound_Sonar_pings.ogg », true); // joue fichier son
mesuref=moyenneMesure(30, GP2D12); // réalise moyenne de 30 mesures analogiques sur voie GP2D12
distance=distanceGP2D12(mesuref); // renvoie la valeur de la distance correspondante à la valeur tension
//—– affichage du résultat ——–
if (distance==0) {// si valeur ne correspond pas au calibrage
Serial.println(« Distance hors plage de mesure »);
//parleSon(« Distance hors plage de mesure », false); // parle message sans attendre fin message
parleSon(« Aucun objet détecté », true); // parle message +/- attendre fin message
}
else { // si valeur distance calculée
Serial.print(« Distance comprise entre « ), Serial.print(distance), Serial.print( » cm et « );
Serial.print(distance+5),Serial.println( » cm. »);
//parleSon (« Distance comprise entre « , true), parleSon(distance,true), parleSon ( » centimètres et « , true);
//parleSon (distance+5, true), parleSon( » centimètres. », true);
String message;
message=« Distance comprise entre « + String(distance) + » et « + String(distance+5) + » centimètres. »;
parleSon(message, true); // parle message +/- attendre fin message
}
delay (1000); // entre 2 mesures
//— Code type DFRduino 1A – DFRobot 2A
//analogWrite(vitesseMoteur1,255); // génère une impulsion PWM sur la broche de vitesse du moteur
//digitalWrite(sensMoteur1,AVANT); // Marche avant
//analogWrite(vitesseMoteurGauche,255); // génère une impulsion PWM sur la broche de vitesse du moteur
//digitalWrite(sensMoteurGauche,AVANT); // Marche avant
//while(1); // stop loop
} // 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 réalisant une moyenne de n mesures analogiques sur voie analogique
float moyenneMesure(int nombreMesure, int voie) { // — fonction réalisant une moyenne de n mesures analogiques
//—- variables locales —
int mesure_can=0;
long cumul_can=0;
int moyenne_can=0;
float mesure_canf=0;
//—– calcul d’une moyenne de plusieurs mesures ——-
for (int i=0; i<nombreMesure; i++) // répète la mesure n fois
{
mesure_can=analogRead(voie);
cumul_can=cumul_can+mesure_can;
}
Serial.print(« cumul= »), Serial.println(cumul_can);
// calcul moyenne
moyenne_can=cumul_can/nombreMesure;
cumul_can=0; //RAZ cumul…
Serial.print(« moyenne= »), Serial.println(moyenne_can);
// mesure tension correspondante en mV
mesure_canf=float(moyenne_can);
mesure_canf=mesure_canf*5000.0;
mesure_canf=mesure_canf/1023.0;
Serial.print(« tension= »), Serial.println(mesure_canf);
return (mesure_canf); // valeur renvoyée par la fonction
} // — fin fonction moyenneMesure
//————- fonction renvoyant la distance en fonction de la mesure analogique GP2D12 —-
// cette fonction est nécessaire car la sortie analogique du GP2D12 n’est pas linéaire
int distanceGP2D12(float mesure_float) {
int dist=0; // RAZ variable locale distance
// ——- détermination de la distance à partir du tableau de reference
for (int j=0; j<=14; j++) { // teste les valeurs de calibrage
if ((int(mesure_float)<=calibrage[j]) && (int(mesure_float)>calibrage[j+1])) { // si la mesure comprise entre 2 valeurs
dist=10+(j*5); // calcule de la distance en cm à partir de l’index courant
}
} // fin boucle test calibrage
return (dist); // valeur renvoyée par la fonction
} // ———– fin fonction analyse distanceGP2D12 —-
//————- fonction parleSon() pour synthèse vocale ——-
void parleSon(String texte, boolean retour) { // envoie chaine pour synthese vocale sur le port Série – si retour=true, attend caractère H fin son
String envoi=« espeak= »+texte+« = »; // chaine comprise entre 2 =
Serial.println(envoi);
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 parle son
//—————- fonction joueSon() à partir fichier sons —-
void joueSon(String fichierSon, boolean retour) { // fonction joue son à partir nom fichier – si retour=true, attend caractère H fin son
String envoi=« mplayer= »+fichierSon+« = »; // chaine comprise entre 2 =
Serial.println(envoi); //—– 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
} //– fin moteurDroit —
//— 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
} // — fin moteurGauche —
//— 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
} // — fin arret
//—- fonction tourne à Droite
void tourneDroite (int vitesse) {
moteurGauche(AVANT, vitesse);
moteurDroit(ARRIERE, vitesse);
} // fin tourneDroite
//—- fonction tourne à Gauche
void tourneGauche (int vitesse) {
moteurGauche(ARRIERE, vitesse);
moteurDroit(AVANT, vitesse);
} // fin tourneGauche
//—- fonction en arriere
void enArriere (int vitesse) {
moteurGauche(ARRIERE, vitesse);
moteurDroit(ARRIERE, vitesse);
} // fin enArriere
//—- fonction en avant
void enAvant (int vitesse) {
moteurGauche(AVANT, vitesse);
moteurDroit(AVANT, vitesse);
} // fin enAvant
//—- 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 vitesse
// ////////////////////////// Fin du programme ////////////////////
// ////////////////////////// Mémo instructions ////////////////////
// ////////////////////////// Fin Mémo instructions ////////////////////
Le programme Processing sur le EeePC embarqué sur le EeePC-Bot
EeePC-Bot : Interface Processing Mplayer + Espeaker + Envoi / Réception chaine série
Description
-
- en réception série : réception chaîne caractères sur le port série et déclenchement en ligne de commande progammée :
- du logiciel espeak pour la synthèse vocale
- du logiciel mplayer pour les bruitages sonores
- en envoi série : envoi chaine de caractère sur le port Série par Champ Texte + bouton graphique
- en réception série : réception chaîne caractères sur le port série et déclenchement en ligne de commande progammée :
Code Processing du programme :
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT – Avril 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
// Utilise la ligne de commande programmée
// Utilise mplayer pour jouer des sons (Ubuntu)
// Utilise espeaker pour la synthèse vocale des sons (Ubuntu)
/*
Reçoit la chaine renvoyée par Arduino et l’affiche dans la console.
La chaine de texte reçue est synthétisée si le format est valide.
Le fichier son voulu est joué en fonction de la chaine de caractères reçue
à l’aide d’une ligne de commande programmée qui lance le logiciel système Mplayer (Ubuntu)
Permet également l’envoi vers Arduino pour tests d’une chaîne saisie dans un champ texte.
*/
// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX
// inclusion des librairies utilisées
import processing.serial.*; // importe la librairie série processing
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)
String[] command ; // pour envoi ligne de commande espeak
String nomFichier=« »; // variable pour nom du fichier son à jouer
String cheminFichier=« /home/xavier/Bureau/mes_sons/ »; // chemin complet avec / de fin
//— chemin où se trouvent les fichiers sons – à adapter selon les cas —
// — port Série —
Serial myPort; // Création objet désignant le port série
// — 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 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,width–60,height–40,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,height–40,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 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
//xxxxxxxxxxxxxxxxxxxxxxxxxx Gestion du nom de fichier son v2 xxxxxxxxxxxxxxxxxxxxxxxxxx
//———— analyse de la chaine reçue et sélection son ——–
//String nomFichier= » »; // String pour nom fichier
if (match(inString,« mplayer= »)!=null) { // si chaine contenant mplayer= reçue
println(« Chaine mplayer valide reçue ! « ); // debug
String[] chaines = split(inString, ‘=’); // sépare chaine par le signe =
println (chaines[0]); // chaine mplayer=
println (chaines[1]); // chaine nomfichier
if (chaines[1]!=« ») { // si une chaine valide a été reçue
joueSonMplayer(cheminFichier, chaines[1]); // appelle la fonction lecture son avec mplayer – sous Ubuntu
//— signale à Arduino fin son
myPort.write(‘H’); // envoie le caractère sur le port Série
} // fin si list[1] pas vide
} // fin si chaine espeak
//xxxxxxxxxxxxxxxxxxxxxxxx Gestion chaine texte pour espeak xxxxxxxxxxxxxxxx
if (match(inString,« espeak= »)!=null) { // si chaine contenant espeak= reçue
println(« Chaine espeak valide reçue ! « ); // debug
String[] chaines = split(inString, ‘=’); // sépare chaine par le signe =
println (chaines[0]); // chaine espeak
println (chaines[1]); // chaine à parler
if (chaines[1]!=« ») { // si une chaine valide a été reçue
direTexte (chaines[1]); // espeak la chaine extraite
//— signale à Arduino fin son
myPort.write(‘H’); // envoie le caractère sur le port Série
} // fin si list[1] pas vide
} // fin si chaine espeak
} // fin condition chaine recue pas vide
} // fin de la fonction de gestion des évènements Série
// 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
//——————— fonction lecture son avec Mplayer —————
void joueSonMplayer(String cheminSon, String fichierSon) {
//—— code type pour jouer son avec mplayer par ligne commande (Ubuntu) —-
command = new String[3]; // tableau String pour la ligne de commande
// mplayer /home/hinault/Bureau/mes_sons/r2d2_2.mp3 -quiet
command[0] = « mplayer »;
command[1] = cheminSon+fichierSon;
command[2]=« -quiet »;
//— pour info : mplayer r2d2_1.mp3 -af volume=3
//— exécution de la ligne de commande (code Java)
try {
Process p = exec(command); // exécute la commande
//— récupère la sortie de la commande dans la console de Processing
BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line = null;
while ((line = in.readLine()) != null) {
System.out.println(line);
}//fin while
} // fin try
catch (IOException e) { // gestion exception
e.printStackTrace();
} // fin catch
} //——————— fin joueSonMplayer
//————- fonction d’appel à espeak par ligne de commande —–
void direTexte(String texte) {
// le paquet espeak doit etre installé sous Ubuntu (depuis la logithèque)
command = new String[10];
// espeak -v fr -s 140 « lecture texte espeak »
// espeak -v fr -s 80 -p 30 \ »moteur droit en marche avant\ »
command[0] = « espeak »;
command[1] = « -v »;
command[2]=« fr+m4 »;
// les voix sont dans /usr/share/espeak-data/voices/!v
// les variantes dispo sont : croak f1 f2 f3 f4 fast klatt klatt2 klatt3 m1 m2 m3 m4 m5 m6 m7 whisper
// pour utiliser une variante faire : espeak -ven+m3
command[3]=« -s »; // la vitesse
command[4]=« 120 »; // entre 30 et 200
command[5]=« -p »; // la tonalité
command[6]=« 40 »; // entre 0 et 99
command[7]=« -a »; // l’amplitude = volume
command[8]=« 7 »; // entre 0 et 20
command[9]=« \ »« +texte+« \ »« ; // le texte entre guillemets
// param bien : voix m4/vitesse 120/ tonalité =40
// param bien : voix m2 / vitesse 100 / Tonalité = 20
//— exécution de la ligne de commande
try {
Process p = exec(command); // exécute la commande
//— récupère la sortie de la commande dans la console de Processing
BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line = null;
while ((line = in.readLine()) != null) {
System.out.println(line);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
Et aussi :
- Ce programme peut être contrôlé sur un PC fixe via accès au bureau distant du EeePC embarqué. Voir :
Articles Liés
- PyQt Lab' : Analyse d'une chaîne de caractères reçue sur le port Série et extraction de paramètres numériques
PyQt Lab est un outil puissant qui permet aux utilisateurs de développer des applications graphiques…
- Javascript : Graphique Dygraphs simple
Le Javascript est un langage de programmation très populaire et puissant qui permet aux développeurs…
- Javascript : Afficher 6 widgets graphiques fournis par une librairie graphique externe.
Le Javascript est un langage de programmation très populaire qui permet aux développeurs de créer…