Le EeePC-Bot est un robot qui peut effectuer des tests simples des moteurs avec une annonce sonore par synthèse vocale de l’action en cours. Il est basé sur une interface Processing qui utilise le logiciel de synthèse vocale eSpeaker appelé par ligne de commande programmée sous Ubuntu. Dans cet article, nous allons examiner en détail le fonctionnement du EeePC-Bot et comment il peut être utilisé pour effectuer des tests simples des moteurs avec une annonce sonore par synthèse vocale.
EeePC-Bot : Test simple des moteurs avec annonce sonore par synthèse vocale de l’action en cours (interface Processing utilisant le logiciel de synthèse vocale eSpeaker appelé par ligne de commande programmée – Ubuntu)
(cliquer sur l’image pour agrandir)
1. Présentation
- Programme de test simple des moteurs avec annonce sonore par synthèse vocale 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 à la chaîne de caractères à synthétiser vocalement précédée du mot clé « espeak= ».
- Après réception de la chaine de caractères, l’interface Processing déclenche la synthèse vocale à l’aide du logiciel eSpeaker qui est appelé par une ligne de commande programmée dans Processing (Ubuntu)
- L’intérêt d’utiliser la synthèse vocale avec le logiciel eSpeaker est à mon avis multiple :
- possibilité de faire « cohabiter » la synthèse vocale et la lecture de son dans un même programme (Minim pose des soucis pour faire les 2 dans un même programme)
- le logiciel eSpeaker est très paramétrable (plusieurs modèles de voix, vitesse et hauteur de la voix réglables, etc…) et est exécutable en ligne de commande.
- la synthèse vocale dispense d’enregistrer des fichiers sons et permet de définir « à la volée » dans le code ce que l’on veut faire dire au robot.
- la synthèse vocale permet d’utiliser des variables numériques qui seront parlées, ce qui rend le programme très souple !!
- La limite, c’est que çà marche sur un système Gnu/Linux et probablement pas sous Windows… Mais ici, je développe un projet centré sur un système Ubuntu embarqué… donc la compatibilité multiplateformes n’est pas essentielle.
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
Ressources utiles associées à ce programme :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
- Test simple annonce sonore avec le logiciel Mplayer (fichiers sons)
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
2.2 Le matériel suivant pour réaliser le montage associé
- des straps,
- Un shield DFRobot motor Driver 2A (basé sur L298) pour contrôle de 2 moteurs CC
- 2 moto-réducteurs CC de la série MFA 950 (0,840A en 12V) ne nécessitant pas plus de 2 Ampères, sous 7 à 12V.
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
Le schéma théorique du montage (cliquer pour agrandir)
5. Le circuit du montage
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
- A chaque étape, le programme envoie sur le port série une chaine de caractère correspondant au message à synthétiser précédée de « espeaker= ».
8. Le programme complet en langage Arduino
- On appelle la fonction direTexte(« texte ») pour émettre une chaine sous la forme espeak= sur le port série.
A copier/coller directement dans l’éditeur 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 ? ———
/* Ce programme envoie une chaine de la forme espeak=texte
dans la fonction parleSon(chaine,true/false)
Le paramètre true/false permet d’attendre ou non la fin du son.
*/
// — 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 —
// — 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 —
Serial.flush(); // vide buffer série
parleSon(« test_des_moteurs », true); // joue son et attend fin son
//xxxxxxxxxxxxxxxx Test moteur gauche AVANT xxxxxxxxxxxxxxxxxxx
parleSon(« moteur gauche en marche avant – vitesse maximale », true); // synthese vocale son
//—- l’utilisation simultanée de Minim et espeak est problématique
moteurGauche(AVANT, 255); // moteurGauche en Avant à fond
delay(3000); // moteur tourne 3 secondes
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,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
parleSon(« moteur_gauche_en_marche_arrière – vitesse maximale »,true); // joue son et attend fin son
moteurGauche(ARRIERE, 255); // moteur Gauche en ARRIERE et à fond
delay(3000);
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,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
parleSon(« moteur_droit_en_marche_avant – vitesse maximale »,true); // joue son et attend fin son
moteurDroit(AVANT, 255); // moteur Droit en Avant à fond
delay(3000);
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,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
parleSon(« moteur_droit_en_marche_arrière – vitesse maximale »,true); // joue son et attend fin son
moteurDroit(ARRIERE, 255); // moteur Droit en ARRIERE et à fond
delay(3000);
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,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
parleSon(« j’avance – vitesse maximale »,true); // joue son et attend fin son
enAvant(255); // en avant à fond
delay(3000);
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,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
parleSon(« je_recule – vitesse maximale »,true); // joue son et attend fin son
enArriere(255); // en avant à fond
delay(3000);
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,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
parleSon(« je_tourne_a_droite – vitesse maximale »,true); // joue son et attend fin son
tourneDroite(255); // tourne à droite à fond
delay(3000);
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,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
parleSon(« je_tourne_a_gauche – vitesse maximale »,true); // joue son et attend fin son
tourneGauche(255); // tourne à gauche à fond
delay(3000);
arret(); // stoppe les moteurs
parleSon(« arret des moteurs »,true); // joue son et attend fin son
//joueSon(« r2d2_1.mp3 », true); // joue son et attend fin son
delay(1000); // pause
while(1);
} // 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 ////////////////////
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
//————- 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 ////////////////////
(:source lang=arduino :)
9. Programme Processing côté PC
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT – Février 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
/*
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.
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
// — 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
//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 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[8];
// 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]=« \ »« +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();
}
}
/* >>>>>>>>>>>>>>>>>>>>>>>>> page man de espeak <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
ESPEAK(1) ESPEAK(1)
NAME
espeak – A multi-lingual software speech synthesizer.
SYNOPSIS
espeak [options] [<words>]
DESCRIPTION
espeak is a software speech synthesizer for English, and some other
languages.
OPTIONS
-h Show summary of options.
-f <text file>
Text file to speak
–stdin
Read text input from stdin instead of a file
If neither -f nor –stdin, <words> are spoken, or if none then text is
spoken from stdin, each line separately.
-q Quiet, don’t produce any speech (may be useful with -x)
-a <integer>
Amplitude, 0 to 20, default is 10
-l <integer>
Line length. If not zero (which is the default), consider lines
less than this length as and-of-clause
-p <integer>
Pitch adjustment, 0 to 99, default is 50
-s <integer>
Speed in words per minute, default is 160
-v <voice name>
Use voice file of this name from espeak-data/voices
-b Input text is 8-bit encoding
-m Indicates that the text contains SSML (Speech Synthesis Markup
Language) tags or other XML tags. Those SSML tags which are sup‐
ported are interpreted. Other tags, including HTML, are ignored,
except that some HTML tags such as <hr> <h2> and <li> ensure a
break in the speech.
-w <wave file name>
Write output to this WAV file, rather than speaking it directly
-x Write phoneme mnemonics to stdout
-X Write phonemes mnemonics and translation trace to stdout. If
rules files have been built with –compile=debug, line numbers
will also be displayed.
–stdout
Write speech output to stdout
–compile=<voice name>
Compile the pronunciation rules and dictionary in the current
directory. =<voice name> is optional and specifies which lan‐
guage
–path=<path>
Specifies the directory containing the espeak-data directory
–phonout=<filename>
Write output from -x -X commands and mbrola phoneme data to this
file
–punct= »<characters> »
Speak the names of punctuation characters during speaking. If
=<characters> is omitted, all punctuation is spoken.
-k <integer>
Indicate capital letters with: 1=sound, 2=the word « capitals »,
higher values = a pitch increase (try -k20).
–voices[=<language code>]
Lists the available voices. If =<language code> is present then
only those voices which are suitable for that language are
listed.
–compile=voicename
Compile the pronunciation rules and dictionary in the current
directory. =<voice name> is optional and specifies which lan‐
guage
–compile=debug
Compile the pronunciation rules and dictionary in the current
directory as above, but include line numbers, that get shown
when -X is used.
AUTHOR
eSpeak was written by Jonathan Duddington <jonsd@jsd.clara.co.uk>. The
webpage for this package can be found at http://espeak.source‐
forge.net/.
This manual page was written by Luke Yelavich <themuso@ubuntu.com>, for
the Ubuntu project (but may be used by others).
July 25, 2007 ESPEAK(1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
*/
//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
10. Pour aller plus loin…
- On peut exécuter ce programme sur le eeePC embarqué et prendre la commande à distance depuis un PC fixe en utilisant un simple accès au bureau à distance par VNC du PC embarqué. Voir ici : Configurer un accès bureau distant entre 2 PC sous Ubuntu
Articles similaires:
- EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant le logiciel Mplayer appelé par ligne de commande programmée – Ubuntu)
- EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant le logiciel Mplayer appelé par ligne de commande programmée – Ubuntu)
- EeePC-Bot : Test simple des moteurs avec annonce sonore de l’action en cours (interface Processing utilisant la libairie Minim)
- EeePC-Bot : Contrôle des moteurs depuis une interface Processing avec annonce sonore par synthèse vocale et bruitages sonores
- Test simple des moteurs CC du EeePC-Bot
