Logo Mon Club Elec

L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

L’interface Processing est un outil puissant qui permet aux utilisateurs de créer des programmes informatiques et des applications interactives. Une des fonctionnalités intéressantes de Processing est la possibilité de lire des sons différents en appuyant sur 5 boutons poussoirs (BP). Cette fonctionnalité permet aux utilisateurs de créer des expériences audio interactives et de développer des applications audio. Dans cet article, nous allons examiner en détail comment l’appui sur 5 BP peut lancer la lecture de 5 sons différents dans l’interface Processing.

L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

1.  Présentation

5 boutons poussoirs permettent de déclencher 5 sons dans l’interface
Processing et lancent la lecture du fichier son mp3 voulu.

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.
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

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

  • une plaque d’essai pour montage sans soudures,
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing
  • des straps,
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing
  • 5 boutons poussoirs pour CI,
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

3.  Instructions de montage

  • 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
  • Broche 3 : Un BP connecté au 0V
  • Broche 4 : Un BP connecté au 0V
  • Broche 5 : Un BP connecté au 0V
  • Broche 6 : Un BP connecté au 0V

4.  Le schéma théorique du montage

L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

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

5.  Le circuit du montage

L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

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

6.  Fonctionnement du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
  • une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing
Le déroulement du programme

7.  Explication du programme

7.1  Au niveau de la partie déclarative :

7.2  Au niveau de la fonction d’initialisation setup( ) :

7.3  Au niveau de la boucle principale, la fonction loop ( ) :

8.  Mise en oeuvre du programme

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

8.2  Préparation du Terminal côté PC dans le logiciel Arduino

  • Côté PC, il faut ouvrir la fenêtre terminal de l’IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing
  • La fenêtre « Terminal » s’ouvre alors :
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing
  • Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :
L’appui sur 5 BP lance la lecture de 5 sons différents dans l’interface Processing

8.3  Fonctionnement

9.  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 : 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 ? ———
 /* 5 boutons poussoirs permettent de déclencher 5 sons dans l’interface
Processing et lancent la lecture du fichier son mp3 voulu. */

// — 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
// Broche 3 : Un BP connecté au 0V
// Broche 4 : Un BP connecté au 0V
// Broche 5 : Un BP connecté au 0V
// Broche 6 : 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_1=2; // Constante pour la broche 2
const int BP_2=3; // Constante pour la broche 3
const int BP_3=4; // Constante pour la broche 4
const int BP_4=5; // Constante pour la broche 5
const int BP_5=6; // Constante pour la broche 6

// — 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_1,INPUT); // Broche BP_1 configurée en entrée
 pinMode (BP_2,INPUT); // Broche BP_2 configurée en entrée
 pinMode (BP_3,INPUT); // Broche BP_3 configurée en entrée
 pinMode (BP_4,INPUT); // Broche BP_4 configurée en entrée
 pinMode (BP_5,INPUT); // Broche BP_5 configurée en entrée

// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-  
 digitalWrite (BP_1,HIGH); // Rappel au + activé sur la broche BP_1 configurée en entrée
 digitalWrite (BP_2,HIGH); // Rappel au + activé sur la broche BP_2 configurée en entrée
 digitalWrite (BP_3,HIGH); // Rappel au + activé sur la broche BP_3 configurée en entrée
 digitalWrite (BP_4,HIGH); // Rappel au + activé sur la broche BP_4 configurée en entrée
 digitalWrite (BP_5,HIGH); // Rappel au + activé sur la broche BP_5 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_1)==APPUI){
 Serial.println(251); // envoie la valeur vers le PC (Processing) suivie d’un saut de ligne
 delay(1000);
}

if (digitalRead(BP_2)==APPUI){
 Serial.println(252); // envoie la valeur vers le PC (Processing) suivie d’un saut de ligne
  delay(1000);
}

if (digitalRead(BP_3)==APPUI){
 Serial.println(253); // envoie la valeur vers le PC (Processing) suivie d’un saut de ligne
  delay(1000);
}

if (digitalRead(BP_4)==APPUI){
 Serial.println(254); // envoie la valeur vers le PC (Processing) suivie d’un saut de ligne
  delay(1000);
}

if (digitalRead(BP_5)==APPUI){
 Serial.println(255); // envoie la valeur vers le PC (Processing) suivie d’un saut de ligne
  delay(1000);
}

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

 

10.  Le programme complet en langage Processing

A copier/coller directement dans l’éditeur Processing

// Programme processing
// généré avec le générateur de code Processing
// X. HINAULT – Janvier 2011 – tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise les sons avec la librairie Minim

/////////////// ENTETE DECLARATIVE ////////////

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

// 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 in; // déclare un objet Audioplayer pour lire les sons

// déclaration variables globales

/////////////// Fonction SETUP ////////////

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

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

        //————- initialisation port série —-
        println(Serial.list()); // affiche dans la console la liste des ports séries
        myPort = new Serial(this, Serial.list()[0], 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 —-
        // 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

} // fin fonction Setup

/////////////// Fonction Draw ////////////

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

        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

/////////////// Autres Fonctions ////////////

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

                inString = trim(inString); // enlève espace blancs de la chaine recue
                int inByte_brut=int(inString); // conversion valeur reçue en valeur numérique entiere
                float inByte = float(inString); // conversion valeur reçue en valeur numérique décimale

            if (inByte_brut==251) {

              //————- code type lecture fichier son —-

              in = minim.loadFile(« ../mes_sons/393.mp3 »); // charge un fichier son dans l’objet Audioplayer
              // taille par défaut du buffer 1024
              // le fichier doit etre dans le répertoire /mes_sons/ meme niveau que rep programme

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

            }

          if (inByte_brut==252) {

              //————- code type lecture fichier son —-

              in = minim.loadFile(« ../mes_sons/r2d2wst3.mp3 »); // charge un fichier son dans l’objet Audioplayer
              // taille par défaut du buffer 1024
              // le fichier doit etre dans le répertoire /mes_sons/ meme niveau que rep programme

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

            }

            if (inByte_brut==253) {

              //————- code type lecture fichier son —-

              in = minim.loadFile(« ../mes_sons/genial_bonaldi.mp3 »); // charge un fichier son dans l’objet Audioplayer
              // taille par défaut du buffer 1024
              // le fichier doit etre dans le répertoire /mes_sons/ meme niveau que rep programme

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

            }

            if (inByte_brut==254) {

              //————- code type lecture fichier son —-

              in = minim.loadFile(« ../mes_sons/grande_vadrouille.mp3 »); // charge un fichier son dans l’objet Audioplayer
              // taille par défaut du buffer 1024
              // le fichier doit etre dans le répertoire /mes_sons/ meme niveau que rep programme

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

            }

            if (inByte_brut==255) {

              //————- code type lecture fichier son —-

              in = minim.loadFile(« ../mes_sons/kopff_merde.mp3 »); // charge un fichier son dans l’objet Audioplayer
              // taille par défaut du buffer 1024
              // le fichier doit etre dans le répertoire /mes_sons/ meme niveau que rep programme

              in.play(); // lance la lecture du son
              //delay (in.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
        in.close();
        minim.stop();
        super.stop();

}

 

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