Le programme GLAP-Box est une solution innovante qui permet aux utilisateurs de lancer des lignes de commande à partir d’un simple clic sur un bouton physique (BP). Cette technologie offre une variété d’avantages, notamment une plus grande commodité et une plus grande sécurité. Par exemple, en utilisant GLAP-Box, les utilisateurs peuvent lancer Skype en appuyant sur un BP, ce qui leur permet d’accéder à leurs contacts et à leurs conversations plus rapidement et plus facilement. Dans cet article, nous allons examiner en détail le fonctionnement du programme GLAP-Box et ses avantages pour les utilisateurs.
Programme GLAP-Box : L’appui sur un BP lance l’exécution d’une ligne de commande (exemple avec Skype)
1. Présentation
- L’appui sur un BP connecté à l’Arduino lance l’exécution d’une ligne de commande système sur la Glapbox via Processing.
- Prérequis : L’application Skype doit ici être installée sur la Glapbox et on pourra activer également la connexion automatique pour disposer de la possibilité de recevoir des appels entrants sans avoir rien d’autre à faire.
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
- Un premier appui sur un BP envoie sur le port série la chaine executeCommance(chaine,flagWait) ou executeCommance(chaine) qui est reconnue par le programme Processing.
- Un second appui sur le BP envoie sur le port série la chaine stopApp(chaine) qui est également 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 : 31/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 application – ici Skype */
// — 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 4 : 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=4; // Constante pour la broche 4
// — 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 —
boolean etatApp=false; // variable pour mémoriser l’état de la webradio coté PC
String enteteSerie=« glapbox: »; // l’entete doit etre la meme dans le programme Processing – glapbox: par défaut
// — 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) {
if (etatApp==false) {
Serial.println(enteteSerie+« executeCommande(skype,false) »);
etatApp=true;
delay(500); // anti-rebond
} // fin if etatWebRadio
else {
Serial.println(enteteSerie+« stopApp(skype) »);
etatApp=false;
delay(500); // anti-rebond
} // fin else
} // fin if digital
//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 : 16/8/2012.
// ——- Licence du code de ce programme : GPL v3—–
/////////////// Description du programme ////////////
// Utilise le port Serie
// 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 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
Glapbox glapbox; // Déclare objet Glapbox qui donne accès aux fonctions de la librairie
// 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
// initialisation objet Glapbox
glapbox=new Glapbox(this); // initialise objet 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
} // 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
//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
5. Fonctionnement
- Un premier appui sur le bouton poussoir entraîne le lancement de l’application skype
- Un second appui éteint Skype.
- Et ainsi de suite…
Articles similaires:
- Programme GLAP-Box : le programme minimum utilisant la librairie Glapbox
- Programme GLAP-Box : L’appui sur un BP lance la synthèse vocale
- Programme GLAP-Box : L’appui sur un BP lance la lecture d’un fichier son
- Programme GLAP-Box : Test de la lecture de fichiers sons
- Programme GLAP-Box : L’appui sur un BP lance la capture de texte dans un fichier
Articles Liés
- Programme GLAP-Box : L'appui sur un BP lance la capture de texte dans un fichier
Le Programme GLAP-Box est une solution innovante qui permet aux utilisateurs de capturer du texte…
- GLAP-Box : Eteindre la GLAP-Box.
La GLAP-Box est un dispositif innovant qui permet aux utilisateurs de contrôler leurs appareils électroniques…
- Programme GLAP-Box : L'appui sur un BP lance la capture d'une séquence d'images webcam.
Le Programme GLAP-Box est une technologie innovante qui permet de capturer des séquences d'images webcam…