L’envoi d’une chaine de caractères sur le port Série est une fonctionnalité très pratique qui permet de contrôler des programmes à distance. Cette fonctionnalité peut être utilisée pour lancer des fichiers son dans Processing, un langage de programmation visuelle. Dans cet article, nous allons voir comment envoyer une chaine de caractères sur le port Série et comment l’utiliser pour lancer un fichier son dans Processing.
L’envoi d’une chaine de caractères sur le port Série lance un fichier son dans Processing

1. Présentation
Ce programme envoie la chaine « joueSon » sur la port Série. Côté Processing, une interface écoute le port Série et joue un fichier son lorsque la chaîne est reçue.
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
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é
- rien d’autre
3. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
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
6.1 Le programme Arduino
- Le programme Arduino envoie la chaîne de caractère « joueSon » sur le port série au démarrage.
6.2 Le programme Processing
- Le programme Processing écoute le port Série et joue le son lorsque la chaîne est reçue.
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
- Lancer le programme dans l’interface Processing.
- Faire un reset sur la carte Arduino : le son sera déclenché côté PC.
8. Le programme complet en langage Arduino
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 : 12/1/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 ? ———
/* L’appui sur un bouton poussoir lance la lecture d’un son dans l’interface Processing côté PC */
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// ——– Circuit à réaliser ———
// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
// Broche 2 : Un BP connecté au 0V
// /////////////////////////////// 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 APPUI=LOW; // constante pour tester état BP
// — Déclaration des constantes des broches E/S numériques —
const int BP_PLAY=2; // Constante pour la broche 2
// — 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 ——-
// ——- Broches en entrées numériques ——-
pinMode (BP_PLAY,INPUT); // Broche BP_PLAY configurée en entrée
// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-
digitalWrite (BP_PLAY,HIGH); // Rappel au + activé sur la broche BP_PLAY configurée en entrée
// ——- Initialisation des variables utilisées ——-
} // 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 —
if (digitalRead(BP_PLAY)==APPUI) { // si appui sur le BP
Serial.println(255); // envoie la valeur 255 à vers Processing
delay(1000); // pause entre 2 appui
}
//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 ////////////////////
// ////////////////////////// Fin du programme ////////////////////
9. Le programme Processing
9.1 Description
- Ce programme écoute le port série et joue un son lorsque la chaine « joueSon » est reçue.
9.2 Ressources utiles
- Copier/coller un fichier nommé « monSon.mp3 » dans le même répertoire que le programme Processing. Par exemple, monSon.mp3
9.3 Le programme complet en langage Processing
A copier/coller directement dans l’éditeur Processing
// 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 les sons avec la librairie Minim
/*
Jouer un son lorsqu’une chaine de caractères est reçue sur le port Série
*/
// 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/
// déclaration objets
// — 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
// 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 fenêtre de base —
size(200, 200); // ouvre une fenêtre xpixels x ypixels
background(noir); // 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(« monSon.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
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
while(true); // stoppe boucle draw
} // 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
if (match(inString,« joueSon »)!=null) { // si la chaine est reçue
//———— lecture fichier sons ——
player.rewind(); // revient au début
player.play(); // lance la lecture du son
delay (player.length()+500); // attend la durée du son + délai
}
} // 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();
}
Articles similaires:
- L’Appui sur un BP lance la lecture d’un son dans l’interface Processing
- Processing Sons avec la librairie Minim : Lire un fichier sons
- Processing Sons avec la librairie Minim : le programme minimum
- Saisie d’une chaine de caractère dans Processing sélectionne fichier son
- L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing
Articles Liés
- Recevoir une chaine de caractères depuis Processing via le port série USB
L'utilisation du port série USB est un moyen pratique et efficace pour communiquer entre un…
- Réception d'une chaine saisie dans Processing et renvoi vers Processing
Avec l'avènement de l'ère numérique, les technologies de traitement de données sont devenues plus accessibles…
- Mesure analogique à distance (télémétrie) multivoies à partir d'une carte Arduino "serveur" via deux interfaces Processing Client/Serveur sur 2 PC connectés en réseau wifi.
La télémétrie est une technologie qui permet de mesurer des données à distance. Elle est…