View  Edit  Attributes  History  Attach  Print  Search

Programme GLAP-Box : L'appui sur un BP lance la capture d'une image webcam.

Par X. HINAULT - Page créée le : 20/08/2012
GLAPBOX | Programmes GLAP-Box | librairie Glapbox

1.  Présentation

  • L'appui sur un BP connecté à l'Arduino lance la capture et l'enregistrement d'une image issue de la webcam de la GLAP-Box.

2.  Schéma fonctionnel

3.  Arduino

3.1  Le circuit du montage

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

3.2  Explication du programme Arduino

  • L'appui sur un BP envoie sur le port série la chaine captureImage(chaine) qui est reconnue par le programme Processing.

3.3  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino sur la GLAP-Box.


// --- 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 : 20/8/2012.

// ------- Licence du code de ce programme : GPLv3-----

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* L'appui sur un BP envoie une chaîne vers la GLAP-Box en vue de déclencher/stopper une webradio dans Firefox.  */

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

// Utilise la connexion série matérielle vers le 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 3 : Un BP connecté entre la broche et le 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=3; // Constante pour la broche 3

// --- Déclaration des constantes des broches analogiques ---


//const int Voie[6]={0,1,2,3,4,5}; //declaration constante de broche analogique


// --- Déclaration des variables globales ---

String entete="glapbox:"; // l'entete doit etre la meme dans le programme Processing

int compt=0; // compte le nombre d'appui

// --- 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,INPUT); // Broche BP configurée en entrée

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  
 digitalWrite (BP,HIGH); // Rappel au + activé sur la broche BP 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()


if (digitalRead(BP)==APPUI) { // si BP appuyé



   //Serial.println(entete+"captureImage(monImage.jpg)"); // forme captureImage(nomFichier)
   //Serial.println(entete+"captureImage(monImage,"+compt+",jpg)"); // forme captureImage(racineNomFichier, numeroImage, typeImage)
  //Serial.println(entete+"captureImage(monImage,-1,jpg)"); // forme captureImage(racineNomFichier, numeroImage, typeImage) avec getCurrentTime automatique pour numeroImage
  Serial.println(entete+"captureImage(monImage,auto,jpg)"); // alternative idem avec mot clé "auto" pour numéro image

   compt=compt+1; // incrémente compt

   delay(250); // anti-rebond



} // fin if BP==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 ////////////////////
 

3.4  Test du programme Arduino

  • Pour tester le programme Arduino, il suffit :
    • d'ouvrir le Terminal Série du logiciel Arduino
    • de vérifier le débit de communication utilisé (ici 115200)
  • La chaine envoyée doit s'afficher à chaque appui du BP.

Remarquer la "robustesse" du débogage possible pour la mise au point de la communication entre Arduino et la GLAP-Box : le Terminal Série permet de s'assurer qu'Arduino envoie bien la chaine voulue, indépendemment du programme Processing, un peu à la manière d'une "sonde" sur la communication USB.

4.  Le programme Processing

4.1  Description

  • L'interface Processing :
    • reçoit la chaine série
    • appelle la fonction analyseChaine() de la librairie Glapbox, fonction qui est capable notamment :
      • de reconnaître la chaîne direTexte(chaine) et d'appeler la fonction native de la librairie glapbox direTexte("chaine")
  • La fonction glapbox direTexte("chaine") lance la synthèse vocale de la chaine.

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

// Programme écrit le : 20/8/2012.

// ------- Licence du code de ce programme : GPL v3-----

/////////////// Description du programme ////////////
// Utilise la librairie GSVideo de capture et lecture vidéo
// Utilise la librairie GLAP-Box qui implémente tout plein de fonctions utiles

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

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

import codeanticode.gsvideo.*; // importe la librairie vidéo GSVideo qui implémente GStreamer pour Processing (compatible Linux)
// librairie comparable à la librairie native vidéo de Processing (qui implémente QuickTime..)- Voir Reference librairie Video Processing
// cette librairie doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// voir ici : http://gsvideo.sourceforge.net/

import monclubelec.glapbox.*; // importe librairie Glapbox qui comporte tout plein de fonctions utiles

// déclaration objets

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


GSCapture cam; // déclare un objet GSCapture représentant une webcam
// L'objet GSCapture étend PImage - se comporte comme un conteneur des frames issues de la webcam

Glapbox glapbox; // Déclare objet Glapbox qui donne accès aux fonctions de la librairie

// déclaration variables globales

// variable pour la taille de la capture video
int widthCapture=320; // largeur capture
int heightCapture=240; // hauteur capture
int widthDisplay=320; // largeur affichage
int heightDisplay=240; // hauteur affichage
int fpsCapture=20; // framerate (image/secondes) pour la capture video

// NB : pour la détection des markers, on peut utiliser une grande résolution facilement.
// Le résultat sera quand même rapide... et la précision plus élevée.



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

        size(widthDisplay, heightDisplay);

                //------------- 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 GSVideo (capture et/ou lecture video =========

        // GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
        // cam1 = new GSCapture(this, widthCapture, heightCapture,fpsCapture,"v4l2src","/dev/video0"); // Initialise objet GSCapture désignant webcam - avant GSVideo 1.0
        cam = new GSCapture(this, widthCapture, heightCapture,"v4l2src","/dev/video0", fpsCapture); // Initialise objet GSCapture désignant webcam - depuis GSVideo 1.0
        // largeur et hauteur doivent être compatible avec la webcam - typiquement 160x120 ou 320x240 ou 640x480...
        // Meilleurs résultats avec framerate webcam entre 20 et 30 et frameRate programme idem ou multiple plus grand (40 pour 20 par ex)
        // la liste des webcam installées sous Ubuntu (Gnu/Linux) est donnée par la commande : ls /dev/video*

        // cam1.play();  // démarre objet GSCapture = la webcam - version GSVideo avant 0.9
        cam.start();  // démarre objet GSCapture = la webcam - version GSVideo après 0.9

  // initialisation objet Glapbox
  glapbox=new Glapbox(this); // initialise objet Glapbox

  glapbox.setWebcam(cam); // configure la webcam utilisée par défaut sur la Glapbox

  glapbox.setEnteteSerie("glapbox:"); // l'entête utilisé doit être idem côté Arduino. "glapbox:" par défaut

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

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

// Code type capture GSVideo

  if (cam.available() == true) { // si une nouvelle frame est disponible sur la webcam

    //background(0);  // fond noir entre 2 images

    //------ gestion image webcam par GSCapture ------
    cam.read(); // acquisition d'un frame
    image(cam, 0,0,widthDisplay, heightDisplay); // affiche image
    //set(0, 0, cam); // affiche image - plus rapide

  } // fin if available


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


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

                glapbox.analyseChaine(inString,true); // analyse chaine reçue

                // la fonction analyseChaine reconnait de nombreuses fonctions
                // voir : http://www.mon-club-elec.fr/pmwiki_reference_lib_glapbox/pmwiki.php?n=Main.GlapboxanalyseChaine

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


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


//------------- Fonction d'arret de Processing ----

public void stop(){ // fonction d'arrêt de Processing

        cam.delete(); // efface l'objet GScapture

        super.stop(); // obligatoire

} // fin fonction stop()


//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX

 

5.  Fonctionnement

  • L'appui sur le bouton poussoir entraîne la capture de l'image courante de la webcam dans un fichier défini par la chaine envoyée sur le port série au format captureImage(chaine)