View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

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

Par X. HINAULT - Page créée le : 12/1/2011.

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.

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

  • une plaque d'essai pour montage sans soudures,
  • des straps,
  • 5 boutons poussoirs pour CI,

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

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

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 ».
  • La fenêtre « Terminal » s'ouvre alors :
  • 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 :

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();

}