Le Programme GLAP-Box est une solution innovante qui permet aux utilisateurs de capturer du texte à partir d’un clavier et de le stocker dans un fichier. Il offre une méthode simple et pratique pour saisir des données et les enregistrer pour une utilisation ultérieure. Grâce à cette technologie, les utilisateurs peuvent facilement capturer des informations et les conserver pour une utilisation future. Cet article explorera en détail le Programme GLAP-Box et ses avantages pour les utilisateurs.
Programme GLAP-Box : L’appui sur un BP lance la capture de texte dans un fichier
1. Présentation
- L’appui sur un BP connecté à l’Arduino lance la capture d’une chaine texte dans un fichier sur la GLAP-Box. Ceci montre le principe de datalogging de toutes sortes…. en 1 ligne de code spécifique côté Arduino !
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 captureTexte(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 pour enregistrer du texte dans un fichier */
// — 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
// — 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+ »captureDataTexte(Bouton poussoir appuyé !) »); //– forme captureDataTexte(String dataTexteIn)
Serial.println(entete+« captureDataTexte(« +millis()+ » : Bouton poussoir appuyé !, monFichier.txt) »);//— forme captureDataTexte(String dataTexteIn, String nomFichierTexteIn)
//Serial.println(entete+ »captureDataTexte(« +millis()+ » : Bouton poussoir appuyé !, monFichier.txt,true) »);//— forme captureDataTexte(String dataTexteIn, String nomFichierTexteIn, boolean flagErase)
// attention, si le flagErase==true, le fichier est effacé à chaque fois. A utiliser seulement 1 fois au début de préférence.
//– le fichier est enregistré sur la Glapbox dans dirDataTexte qui est Bureau/data/texte/ par défaut
// — ou autre chemin définit par setDirDataTexte() dans le programme Processing sur la GLAP-Box
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 : 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
- L’appui sur le bouton poussoir entraîne la synthèse vocale de la chaine envoyée sur le port série au format direTexte(chaine)
Articles similaires:
- Programme GLAP-Box : le programme minimum utilisant la librairie Glapbox
- Programme GLAP-Box : Test de la lecture de fichiers sons
- Programme GLAP-Box : L’appui sur un BP lance la lecture d’un fichier son
- Programme GLAP-Box : L’appui sur un BP lance la synthèse vocale
- Programme GLAP-Box : L’appui sur un BP lance l’exécution d’une ligne de commande (exemple avec Skype)
Articles Liés
- 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…
- Programme GLAP-Box : L'appui sur un BP lance la capture d'une image webcam.
Le Programme GLAP-Box est une solution innovante qui permet de capturer des images à partir…