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 |

GLAP-Box : Lancer/stopper la lecture aléatoire avec VLC et régler le volume du système embarqué à l'aide de 4 boutons poussoirs.

Par X. HINAULT - Page créée le : 22/7/2011.

(cliquer sur l'image pour agrandir)

1.  Présentation

L'appui sur 4 BP envoie vers la GLAP-Box (interface Processing) des chaines :

  • qui incrémentent / décrémentent le volume du système.
  • lancent / stoppent la lecture aléatoire du contenu d'un fichier avec VLC

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  Un PC fixe + une carte Arduino + une GLAP-Box

  • qui intègre l'espace de développement Arduino / Processing accessible par VNC depuis un PC fixe,
  • ... 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,
  • quatre 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

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

  • L'appui sur le BP PLUS envoie la chaine "volumePLUS" sur le port Série
  • L'appui sur le BP MOINS envoie la chaine "volumeMOINS" sur le port Série
  • L'appui sur le BP VLC ON envoie la chaine "lanceVLC" sur le port Série
  • L'appui sur le BP VLC OFF envoie la chaine "stoppeVLC" sur le port Série

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

Il est possible de tester le bon fonctionnement de ce programme dans un Terminal série en suivant la procédure ci-dessous. Ce programme est destiné cependant à être utilisé avec le programme Processing ci-dessous.

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

7.3  Fonctionnement

  • Lancer côté PC le programme Processing.
  • L'appui sur les BP de volume entraîne la baisse/la diminution du volume système.
  • L'appui sur les BP de contrôle de VLC entraîne le lancement / l'arrêt de la lecture aléatoire par VLC.

8.  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 : 22/7/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 4 BP envoie vers la GLAP-Box (interface Processing) des chaines :

    - qui incrémentent / décrémentent le volume du système.
    - lancent / stoppent la lecture aléatoire du contenu d'un fichier avec VLC

    */


// --- Fonctionnalités utilisées ---

// Utilise la connexion série matérielle vers le PC
// Utilise / fonctionne avec une interface Processing coté PC

// -------- Circuit à réaliser ---------

// La connexion série matérielle 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

// /////////////////////////////// 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_MOINS=2; // Constante pour la broche 2
const int BP_PLUS=3; // Constante pour la broche 3

const int BP_VLC_ON=4; // Constante pour la broche 4
const int BP_VLC_OFF=5; // Constante pour la broche 5

// --- 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 matérielle à 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_MOINS,INPUT); // Broche BP_MOINS configurée en entrée
 pinMode (BP_PLUS,INPUT); // Broche BP_PLUS configurée en entrée

 pinMode (BP_VLC_ON,INPUT); // Broche BP_VLC_ON configurée en entrée
 pinMode (BP_VLC_OFF,INPUT); // Broche BP_VLC_OFF configurée en entrée

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  
 digitalWrite (BP_MOINS,HIGH); // Rappel au + activé sur la broche BP_MOINS configurée en entrée
 digitalWrite (BP_PLUS,HIGH); // Rappel au + activé sur la broche BP_PLUS configurée en entrée

 digitalWrite (BP_VLC_ON,HIGH); // Rappel au + activé sur la broche BP_VLC_ON configurée en entrée
 digitalWrite (BP_VLC_OFF,HIGH); // Rappel au + activé sur la broche BP_VLC_OFF configurée en entrée

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

if (digitalRead(BP_PLUS)==APPUI) {

  Serial.println("volumePLUS");
  delay(250); // pause anti-rebond

}

if (digitalRead(BP_MOINS)==APPUI) {

  Serial.println("volumeMOINS");
  delay(250); // pause anti-rebond

}

if (digitalRead(BP_VLC_ON)==APPUI) {

  Serial.println("lanceVLC");
  delay(250); // pause anti-rebond

}

if (digitalRead(BP_VLC_OFF)==APPUI) {

  Serial.println("stoppeVLC");
  delay(250); // pause anti-rebond

}

} // 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 attend la réception des chaines :
  • "volumePLUS" ou "volumeMOINS" pour le réglage du volume
  • "lanceVLC" et "stoppeVLC" pour le contrôle de VLC
  • Lorsque l'une des 2 chaines de contrôle du volume est reçue, le programme lance l'exécution d'une ligne de commande basée sur le programme amixer qui permet de régler le volume du système. Pour plus de détails, voir : ** Controler le volume du son en ligne de commande
  • Lorsque l'une des 2 chaines de contrôle de VLC est reçue, le programme lance l'exécution d'une ligne de commande pour la lecture aléatoire du contenu d'un fichier avec VLC ou l'arrêt de VLC.

9.2  Ressources utiles

9.3  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
// www.mon-club-elec.fr
// par X. HINAULT - Juillet 2011 - tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise la ligne de commande programmée (Ubuntu)

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import processing.serial.*; // importe la librairie série processing

// déclaration objets

// --- port Série ---
Serial  myPort; // Création objet désignant le port série

String cheminRepertoire="/home/hinault/Bureau/musiques_videos/tubes/"; // chemin complet avec / de fin

String[] command ; // pour envoi ligne de commande



// déclaration variables globales

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

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

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


} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

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

        //------------- Code pour port série ----
        //  myPort.write('H'); // envoie le caractère sur le port Série
        // myPort.write("chaine\n"); // envoie la chaine suivi saut ligne sur le port Série
// Code pour la ligne de commande appelée par Processing


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

                println("chaine reçue : "+ inString); // affiche la chaine dans la console


          //xxxxxxxxxxxxxxxxxxxxxxxx Gestion chaine texte pour espeak xxxxxxxxxxxxxxxx

          if (match(inString,"volumePLUS")!=null) { // si chaine contenant volumePLUS reçue

              println("Chaine volumePLUS valide reçue !"); // debug

              augmenteVolume (); // augmente le volume


          } // fin si chaine volumePLUS

          if (match(inString,"volumeMOINS")!=null) { // si chaine contenant volumeMOINS reçue

              println("Chaine volumeMOINS valide reçue !"); // debug

              diminueVolume (); // diminue le volume


          } // fin si chaine volumeMOINS


          if (match(inString,"lanceVLC")!=null) { // si chaine contenant lanceVLC reçue

              println("Chaine lanceVLC valide reçue !"); // debug

              lanceVLC (cheminRepertoire); // lance VLC


          } // fin si chaine lanceVLC


          if (match(inString,"stoppeVLC")!=null) { // si chaine contenant stoppeVLC reçue

              println("Chaine stoppeVLC valide reçue !"); // debug

             stoppeVLC (); // stoppe VLC


          } // fin si chaine stoppeVLC

        } // fin si chaine recue sur port série pas vide


} // fin de la fonction de gestion des évènements Série

// Code pour la ligne de commande appelée par Processing

void augmenteVolume() {

 //------ code type pour augmenter volume par ligne commande (Ubuntu) ----

// commande : amixer -c 0 sset Master,0 90%

command = new String[6]; // tableau String pour la ligne de commande

// mplayer /home/hinault/Bureau/mes_sons/r2d2_2.mp3 -quiet
command[0] = "amixer";
command[1] = "-c";
command[2] = "0";
command[3] = "sset";
command[4] = "Master,0";
command[5] = "5%+";


//--- exécution de la ligne de commande (code Java)

try {

    Runtime rt = Runtime.getRuntime();

    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;

   //delay(300);

    //while ((line = in.readLine()) != null) { // évite d'attendre fin processus
      if ((line = in.readLine()) != null) {
      System.out.println(line);
      } // fin if

    //}//fin while


 } // fin try

// catch (IOException e) { // gestion exception
 //   e.printStackTrace();

 // } //--- fin catch

catch (Exception e) { // gestion exception
    e.printStackTrace();

  } //--- fin catch

 finally {
        } // fin finally


 // fin d'exécution de la ligne de commande --

}

//------------ fin fonction augmente volume


//------------- fonction diminue volume ---

void diminueVolume() {

 //------ code type pour augmenter volume par ligne commande (Ubuntu) ----

// commande : amixer -c 0 sset Master,0 90%

command = new String[6]; // tableau String pour la ligne de commande

// mplayer /home/hinault/Bureau/mes_sons/r2d2_2.mp3 -quiet
command[0] = "amixer";
command[1] = "-c";
command[2] = "0";
command[3] = "sset";
command[4] = "Master,0";
command[5] = "5%-";


//--- exécution de la ligne de commande (code Java)

try {

    Runtime rt = Runtime.getRuntime();

    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;

   //delay(300);

    //while ((line = in.readLine()) != null) { // évite d'attendre fin processus
      if ((line = in.readLine()) != null) {
      System.out.println(line);
      } // fin if

    //}//fin while


 } // fin try

// catch (IOException e) { // gestion exception
 //   e.printStackTrace();

 // } //--- fin catch

catch (Exception e) { // gestion exception
    e.printStackTrace();

  } //--- fin catch

 finally {
        } // fin finally


 // fin d'exécution de la ligne de commande --

} // ---- fin fonction diminue volume

//--------------- fonction lance lecture aléatoire VLC -------------

void lanceVLC(String cheminRepIn) {

 //------ code type pour relancer systeme par ligne commande (Ubuntu) ----

// commande : vlc chemin_répertoire --volume 1024 -Z --random

command = new String[6]; // tableau String pour la ligne de commande


command[0] = "vlc"; // cvlc sans interface graphique
command[1] = cheminRepertoire;
command[2] = "--volume";
command[3] = "1024";
command[4] = "-Z";
command[5] = "--random";

println("Lancement lecture VLC aléatoire...");

//--- exécution de la ligne de commande (code Java)


try {

    Runtime rt = Runtime.getRuntime();

    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;

   //delay(300);

    //while ((line = in.readLine()) != null) { // évite d'attendre fin processus
      if ((line = in.readLine()) != null) {
      System.out.println(line);
      } // fin if

    //}//fin while


 } // fin try

// catch (IOException e) { // gestion exception
 //   e.printStackTrace();

 // } //--- fin catch

catch (Exception e) { // gestion exception
    e.printStackTrace();

  } //--- fin catch

 finally {
        } // fin finally


 // fin d'exécution de la ligne de commande --

}

//------------ fin fonction lance VLC aléatoire -------


void stoppeVLC() {

 //------ code type pour relancer systeme par ligne commande (Ubuntu) ----

// commande : killall -TERM vlc

command = new String[3]; // tableau String pour la ligne de commande


command[0] = "killall";
command[1] = "-TERM";
command[2] = "vlc";
//command[3] = "";
//command[4] = "";
//command[5] = "";

println("Stoppe VLC...");

//--- exécution de la ligne de commande (code Java)

try {

    Runtime rt = Runtime.getRuntime();

    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;

   //delay(300);

    //while ((line = in.readLine()) != null) { // évite d'attendre fin processus
      if ((line = in.readLine()) != null) {
      System.out.println(line);
      } // fin if

    //}//fin while


 } // fin try

// catch (IOException e) { // gestion exception
 //   e.printStackTrace();

 // } //--- fin catch

catch (Exception e) { // gestion exception
    e.printStackTrace();

  } //--- fin catch

 finally {
        } // fin finally


 // fin d'exécution de la ligne de commande --

}

//------------ fin fonction stoppe VLC aléatoire -------

//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX

10.  Utilisation concrète

  • Une Glap-Box radio à 2 balles...