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 |

Allumer une LED à partir d'un bouton inverseur dans une interface Processing

Par X. HINAULT - Page créée le : 29/1/2011.

1.  Présentation

Ce programme permet d'allumer une LED connectée sur une broche de la carte Arduino à partir d'un bouton inverseur graphique dans l'interface Processing côté PC.

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
  • Les images suivantes utilisées par le programme Processing sont à enregistrer dans le répertoire du programme Processing (clic droit - enregistrer sous ) :

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... 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,
  • une LED rouge 5mm,
  • une résistance 1/4w de 200 Ohms environ,

3.  Instructions de montage

  • La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
  • Broche 2 : Une LED connectée en série avec sa résistance

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.  Fonctionnement du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ) )
  • une partie constituée d'une boucle sans fin que le programme répètera à l'infini ( fonction loop( ) ) : c'est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme

7.  Explication du programme

7.1  Au niveau de la partie déclarative :

  • On déclare la broche de LED

7.2  Au niveau de la fonction d'initialisation setup( ) :

  • On met la broche en sortie

7.3  Au niveau de la boucle principale, la fonction loop ( ) :

  • On teste si un caractère est disponible sur le port série :
    • si ce caractères est 'H', on allume la LED
    • si ce caractère est 'L', on éteint la LED

8.  Mise en oeuvre du programme

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

8.2  Fonctionnement

  • On lance le programme Processing côté PC :
    • Un clic sur le bouton graphique allume la LED
    • Un autre clic sur le bouton graphique éteint la LED

9.  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 : 29/1/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 ? ---------
 /* Ce programme permet d'allumer une LED connectée sur une broche de la carte Arduino à partir d'un bouton inverseur graphique dans l'interface Processing côté PC.  */

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

// Utilise la connexion série vers le PC

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

// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)

// Broche 2 : Une LED connectée en série avec sa résistance

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

// --- Déclaration des constantes des broches E/S numériques ---

const int LED=2; // Constante pour la broche 2

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


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

 int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
 String chaineReception=""; // déclare un objet String vide pour reception chaine


// --- 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 à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission


// ------- Broches en sorties numériques -------  
 pinMode (LED,OUTPUT); // Broche LED configurée en sortie

// ------- Broches en entrées numériques -------  

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

// ------- Initialisation des variables utilisées -------  

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

//---- code type réception valeur sur le port série ---

if (Serial.available()>0) { // si un octet en réception

        octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

        if (octetReception=='H') { // si Octet reçu est le H

            digitalWrite(LED, HIGH); // allume la LED

        }

        if (octetReception=='L') { // si octet reçu est le L

            digitalWrite(LED, LOW); // éteint la LED

        }

} // fin si octet réception



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


 

10.  Le programme complet associé en langage Processing

  • Les images utilisées doivent se trouver dans le répertoire du programme (à enregistrer dans le répertoire du programme):

A copier/coller directement dans l'éditeur Processing


// Programme processing
// généré avec le générateur de code Processing
// X. HINAULT - Janvier 2011 - tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise la librairie GUI controlP5
// Utilise un bouton inverseur (Toggle)

/*
L'appui sur un bouton graphique envoie le caractère H ou L
sur le port série afin d'allumer éteindre une LED connectée à la carte Arduino
*/


// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

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

import controlP5.*; // importe la librairie GUI controlP5
// cette librairie doit être présente dans le répertoire /libraries du répertoire Processing
// voir ici : http://www.sojamo.de/libraries/controlP5/

// déclaration objets

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

ControlP5 controlP5; // déclare un objet principal de la librairie GUI controlP5

Toggle t1; // déclare un/des objets Toggle

// déclaration variables globales

//------ déclaration des variables de couleur utiles ----
int blanc=color(255,255,255);


// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

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

        // --- initialisation fenêtre de base ---
        size(120, 120); // ouvre une fenêtre xpixels  x ypixels
        background(blanc); // couleur fond fenetre

// --- 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 - repérer l'indice du port série utilisé
        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 GUI ControlP5 =========

        controlP5 = new ControlP5(this); // initialise l'objet principal de la librairie GUI controlP5

        // typeObjet nomObjet=controlP5.addObjet(paramètres); // pour info : déclaration / initialisation possible en 1 ligne
        // Textfield field = controlP5.addTextfield("myWindowTextfield",70,130,100,20); // exemple

        //======== Initialisation Objets Toggle =========

        // addToggle(String theName, boolean theDefaultValue, float theX, float theY, int theWidth, int theHeight)
        t1=controlP5.addToggle("toggleLED",false,10,10,100,100); // initialise et ajoute un Button au ControlP5

        // méthodes propres à l'objet Toggle
        t1.setMode(ControlP5.DEFAULT); // fixe le mode de fonctionnement du Toggle : ControlP5.DEFAULT ou ControlP5.SWITCH

        // setImages(PImage theImageDefault,PImage theImageOver, PImage theImageActive,PImage theImageHighlight)
        // les images doivent etre de la meme taille que bouton, dans rép prog, type .jpg .png ..
        // un toggle n'utilise que image Default et Active
        t1.setImages(loadImage("imageDefault.png"),loadImage("imageDefault.png"), loadImage("imageActive.png"),loadImage("imageDefault.png"));



} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

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

// tout se passe dans la routine évènement du toggle

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX


// Gestion des évènements des objets GUI controlP5 ----


void toggleLED(int theValue) { // fonction évènement Toggle de meme nom - reçoit la valeur
        println("Evènement Toggle LED avec valeur = "+t1.getState());

        if (t1.getState()==true)myPort.write('H'); // envoie caractère H sur port Série si bouton toggle état 1
        if (t1.getState()==false)myPort.write('L'); // envoie caractère L sur port Série si bouton toggle état 0
}


//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX