Le Programme GLAP-Box est une solution innovante qui permet de capturer des images à partir d’une webcam en appuyant simplement sur un bouton-poussoir. Cette technologie offre une solution pratique et efficace pour les utilisateurs qui souhaitent capturer des images à partir de leur webcam. Grâce à cette technologie, les utilisateurs peuvent facilement capturer des images à partir de leur webcam sans avoir à se soucier des paramètres techniques ou des logiciels compliqués. Le Programme GLAP-Box est une solution simple et pratique qui permet aux utilisateurs de capturer des images à partir de leur webcam en un seul clic.
Programme GLAP-Box : L’appui sur un BP lance la capture d’une image webcam.
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.
// 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 ——-
ÉlectroniqueChamp électrique : les notions fondamentales expliquées simplementSerial.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
// 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 160×120 ou 320×240 ou 640×480…
// 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
ÉlectroniqueBien chauffer son atelier d’électronique : confort, sécurité et continuité de travail// 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 : https://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)





