Contrôler la rotation de 2 servomoteurs (tourelle pan/tilt) à partir d’une interface Processing

L’utilisation de servomoteurs pour contrôler des mouvements est une technologie très répandue dans le domaine de la robotique. La possibilité de contrôler la rotation de deux servomoteurs à partir d’une interface Processing offre aux développeurs une méthode simple et efficace pour créer des systèmes robotiques complexes. Dans cet article, nous allons examiner les différentes étapes nécessaires pour contrôler la rotation de deux servomoteurs (tourelle pan/tilt) à partir d’une interface Processing. Nous verrons comment configurer le matériel et le logiciel, et comment utiliser l’interface Processing pour contrôler les servomoteurs.

Contrôler la rotation de 2 servomoteurs (tourelle pan/tilt) à partir d’une interface Processing

(cliquer sur l’image pour agrandir)

1. Présentation

Deux servomoteurs connectés à la carte Arduino sont contrôlés à l’aide de sliders (contrôles linéaires réglables) dans une interface Processing basique.
L’interface Processing envoie sur le port série une chaine de caractères sous la forme servoPan(000) où 000 est la valeur de l’angle de positionnement du servomoteur.
Le programme Arduino analyse la chaine reçue et en extrait la valeur d’angle reçue
Le servomoteur est positionné dans la position voulue
La vitesse est également réglable
On pourra ainsi contrôler une tourelle dite « pan/tilt » (pan – axe panoramique et tilt – inclinaison) permettant de contrôler la position d’un capteur de distance, une webcam, etc…

Ce programme utilise les fonctionnalités suivantes :

Utilise deux servomoteurs

Ressources utiles associées à ce programme :

La librairie Servo – pour contrôler les servomoteurs.

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é

deux servomoteurs standards type Futaba S3003

Pour étalonner un servomoteur dont on ne connaît pas les caractéristiques, voir le page : https://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerieDepuisPCPositionServomoteur

Idéalement, un Shield kit EasyCard pour utilisation simplifiée jusqu’à 20 servos et/ou 6 capteurs analogiques – Easyrobotics

une tourelle PanTilt de chez http://www.easyrobotics.fr

3. Instructions de montage

Enficher la carte d’extension EasyCard broche à broche sur la carte Arduino
Connecter le servomoteur « pan » (rotation panoramique) sur la broche 8
Connecter le servomoteur « tilt » (rotation inclinaison) sur la broche 9

Dans le cas d’une carte Arduino :
- l’intensité maximale disponible sur une broche est de 40mA
- l’intensité maximale cumulée pour l’ensemble des broches est 200mA
- l’instensité maximale que peut fournir l’alimentation 5V de la carte est 500mA.
Par conséquent, avec une carte Arduino :
- En ce qui concerne la ligne de commande du servomoteur par la carte Arduino :
  - on pourra commander directement autant de servomoteur que l’on veut (broche de commande) avec une carte Arduino, le nombre maximal étant 200mA / I commande, soit 100 environ dans le cas du Futaba S3003, ce qui est largement supérieur au nombre de broches de la carte.
- Il n’y aura par ailleurs pas besoin d’amplification (type ULN 2803) sur la ligne de commande du servomoteur même si l’on utilise un grand nombre de servomoteurs.
- En ce qui concerne l’alimentation principale des servomoteurs par une carte Arduino
  - on ne peut alimenter que 3 à 4 servomoteurs simultanément par l’alimentation 5V de la carte Arduino, le nombre maximal étant 500mA / I fonctionnement = 500 / 120 = 4 servomoteurs dans le cas du Futaba S3003.
  - Une alimentation externe sera indispensable dès que l’on dépassera ce nombre pour ne pas risquer de « griller » la carte Arduino.

Pour plus de détails, voir : Principes d’utilisation des alimentations avec une carte Arduino et des servomoteurs

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

L’interface Processing envoie sur le port série une chaine de caractères sous la forme servoPan(000) où 000 est la valeur de l’angle de positionnement du servomoteur.
Le programme Arduino analyse la chaine reçue et en extrait la valeur d’angle reçue
Le servomoteur est positionné dans la position voulue
La vitesse est également réglable

7. Mise en oeuvre du programme

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

7.2 Fonctionnement

Le servomoteur « pan » se positionne en fonction de la position du Joystick de l’axe 1.
Le servomoteur « tilt » se positionne en fonction de la position du Joystick de l’axe 2.
L’appui sur les BP rouge/bleu réinitialise la position de chaque servomoteur.

8. 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 : 15/5/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 ? ———
/* Deux servomoteurs connectés à la carte Arduino sont contrôlés
à partir du PC (interface Processing)

Controle par chaine de la forme : servoPan(000) avec 000 = angle en degrés

// — Fonctionnalités utilisées —

// Utilise / fonctionne avec une interface Processing coté PC
// Utilise 2 servomoteurs

// ——– Circuit à réaliser ———

// ******* ATTENTION : il est possible de connecter directement 2 ou 3 servomoteurs sur la carte Arduino
// Connecter un servomoteur PAN sur la broche 8
// Connecter un servomoteur TILT sur la broche 9

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

#include <Servo.h> // librairie pour servomoteur

// — Déclaration des constantes utiles —
const int APPUI=LOW; // constante pour tester état BP

//— Constantes utilisées avec le servomoteur
const int ANGLE_MIN=0; // angle position MIN en degrés
const int POS_MIN=550; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur
// POS_MIN=550 pour ANGLE_MIN=0 avec un futaba S3003

const int ANGLE_MAX=172; // angle position MAX en degrés
int POS_MAX=2400; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur
// POS_MAX=2400 pour ANGLE_MAX=172 pour futaba S3003

// pour étalonner un servomoteur, voir la page :
//https://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerieDepuisPCPositionServomoteur

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

const int broche_servoPan=8; // Constante pour la broche 8
const int broche_servoTilt=9; // Constante pour la broche 8

// — 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
long nombreReception=0; // variable de stockage du nombre reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre reçu sur le port Série
String chaineReception=« »; // déclare un objet String vide pour reception chaine

int valeur=0; // variable reception valeur port série

int angleServoPan=90; // variable de position du servo Pan en degrés
int angleServoTilt=90; // variable de position du servo Tilt en degrés

int angleServoPan0=90; // variable de la dernière position du servo Pan en degrés
int angleServoTilt0=90; // variable de la dernière position du servo Tilt en degrés

int vitesse=10; // variable utilisée pour délai entre 2 lecture port Série

// — Déclaration des objets utiles pour les fonctionnalités utilisées —

//— Création objet servomoteur
Servo mon_servoPan; // crée un objet servo pour contrôler le servomoteur 1
Servo mon_servoTilt; // crée un objet servo pour contrôler le servomoteur 2

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

//— Initialisation Servomoteur
mon_servoPan.attach(broche_servoPan); // attache l’objet servo à la broche de commande du servomoteur Pan
mon_servoTilt.attach(broche_servoTilt); // attache l’objet servo à la broche de commande du servomoteur Tilt

// ——- Broches en sorties numériques ——-
pinMode (broche_servoPan,OUTPUT); // Broche broche_servoPan configurée en sortie
pinMode (broche_servoTilt,OUTPUT); // Broche broche_servoPan 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 ——-

// ——- Codes d’initialisation utile ——-

mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle – plus précis que write()
mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle – plus précis que write()

Serial.println(« Arduino OK »); // debug

delay(200);

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

//—- code type réception chaine sur le port série —
while (Serial.available()>0) { // tant qu’un octet en réception
octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

if (octetReception==10) { // si Octet reçu est le saut de ligne
Serial.println (« Chaine recue= »+chaineReception); // affiche la chaine recue

break; // sort de la boucle while
}
else { // si le caractère reçu n’est pas un saut de ligne
chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
}

} // fin tant que octet réception

//—– une fois que le saut de ligne est reçu, on sort du While et on se positionne ici

// —- analyse de la chaine recue sur le port Série —-
chaineReception=chaineReception.trim(); // enlève les espaces

//—– gestion servomoteur PAN —-
if (chaineReception.substring(0,9)==« servoPan(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

Serial.print(« Arduino va executer : « );

Serial.print(« servoPan(« ); // affiche

//————- extraction valeur angle servomoteur —— 3 chiffres

//—- extraction 1er chiffre
valeur=chaineReception.charAt(9); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServoPan=valeur;

//—- extraction 2ème chiffre
valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServoPan=angleServoPan*10+valeur;

//—- extraction 3ème chiffre
valeur=chaineReception.charAt(11); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServoPan=angleServoPan*10+valeur;

Serial.print(angleServoPan); // affiche

if (chaineReception.substring(12,13)==« ) ») { // si fermeture parenthèse = instruction valide

Serial.println(« ) »); // affiche
Serial.println(« Instruction valide ! »); // affiche

//—– positionnement du servomoteur —-

angleServoPan=constrain(angleServoPan,ANGLE_MIN,ANGLE_MAX); // oblige valeur angle Servo
mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle – plus précis que write()
//angleServoPan0=angleServoPan; // mémorise dernière valeur angle prise en compte

//delay(1000); // laisse temps positionnement

Serial.println(« Servomoteur mis en position »); // affiche

} // fin si fermeture parenthèse

} // — fin si reçoit instruction servoPan(000)

//——————— gestion servomoteur Tilt ——————————-

//—– gestion servomoteur TILT —-
if (chaineReception.substring(0,10)==« servoTilt(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

Serial.print(« Arduino va executer : « );

Serial.print(« servoTilt(« ); // affiche

//————- extraction valeur angle servomoteur —— 3 chiffres

//—- extraction 1er chiffre
valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServoTilt=valeur;

//—- extraction 2ème chiffre
valeur=chaineReception.charAt(11); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServoTilt=angleServoTilt*10+valeur;

//—- extraction 3ème chiffre
valeur=chaineReception.charAt(12); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServoTilt=angleServoTilt*10+valeur;

Serial.print(angleServoTilt); // affiche

if (chaineReception.substring(13,14)==« ) ») { // si fermeture parenthèse = instruction valide

Serial.println(« ) »); // affiche
Serial.println(« Instruction valide ! »); // affiche

//—– positionnement du servomoteur —-

angleServoTilt=constrain(angleServoTilt,ANGLE_MIN,ANGLE_MAX); // oblige valeur angle Servo
mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle – plus précis que write()
//angleServoTilt0=angleServoTilt; // mémorise dernière valeur angle prise en compte

//delay(1000); // laisse temps positionnement

Serial.println(« Servomoteur mis en position »); // affiche

} // fin si fermeture parenthèse

} // — fin si reçoit instruction servoTilt(000)

//—————- gestion vitesse ————————

//—– gestion servomoteur TILT —-
if (chaineReception.substring(0,8)==« Vitesse(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

Serial.print(« Arduino va executer : « );

Serial.print(« servoTilt(« ); // affiche

//————- extraction valeur angle servomoteur —— 3 chiffres

//—- extraction 1er chiffre
valeur=chaineReception.charAt(8); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
vitesse=valeur;

//—- extraction 2ème chiffre
valeur=chaineReception.charAt(9); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
vitesse=vitesse*10+valeur;

//—- extraction 3ème chiffre
valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
vitesse=vitesse*10+valeur;

Serial.print(vitesse); // affiche

if (chaineReception.substring(11,12)==« ) ») { // si fermeture parenthèse = instruction valide

Serial.println(« ) »); // affiche
Serial.println(« Instruction valide ! »); // affiche

} // fin si fermeture parenthèse

} // — fin si reçoit instruction servoTilt(000)

//————- fin analyse chaine —————

chaineReception=« »; //RAZ le String de réception

delay(vitesse*5); // fixe la vitesse de mouvement du servo – entre 2 lecture analogique

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

//————- fonction calibrage impulsion servomoteur à partir valeur angle en degrés

int angle(int valeur_angle) {

int impuls=0;
impuls=map(valeur_angle,ANGLE_MIN,ANGLE_MAX,POS_MIN, POS_MAX);
return impuls;

} // fin fonction impulsion servomoteur

// ////////////////////////// Fin du programme ////////////////////

[$[Get Code]]

9. Le programme Processing

9.1 Description

2 réglages linéaires graphiques (sliders) permettent de régler :
- la valeur de l’angle du servomoteur PAN (rotation panoramique)
- la valeur de l’angle du servomoteur TILT (rotation inlinaison)
un 3ème slider permet de régler la vitesse de rotation utilisée
une chaine de caractères au format servoTilt(000) est envoyée sur le port série et affichée dans la console.

9.2 Ressources utiles

la librairie controlP5

9.3 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
// www.mon-club-elec.fr
// par X. HINAULT – Mai 2011 – tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise la librairie GUI controlP5
// Utilise un/des réglage(s) linéaire(s) (Slider)

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

Slider sPan, sTilt, sVitesse; // déclare un/ des objet Slider

// déclaration variables globales

//—— déclaration des variables de couleur utiles —-
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);

// XXXXXXXXXXXXXXXXXXXXXX Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

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

// —- initialisation paramètres graphiques utilisés
colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
fill(0,0,255); // couleur remplissage RGB
stroke (0,0,0); // couleur pourtour RGB
rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
//strokeWeight(0); // largeur pourtour
frameRate(15);// Images par seconde

// — initialisation fenêtre de base —
size(450, 425); // ouvre une fenêtre xpixels x ypixels
background(0,0,0); // 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
// 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 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 Sliders =========

//———— slider Pan —————-
// addSlider(theName, theMin, theMax, theDefaultValue, theX, theY, theW, theH)
sPan=controlP5.addSlider(« sPan »,0,180,90,40,height–50,350,25); // ajoute un Slider au ControlP5
//s1 = (Slider)controlP5.controller(« MonSlider1 »); // initialise l’objet Slider déclaré

// méthodes propres à l’objet Slider
sPan.setNumberOfTickMarks(181); // fixe le nombre crans – n+1 pour n valeurs
//s1.setNumberOfTickMarks((int(s1.max())+1); // fixe le nombre crans – n+1 pour n valeurs
sPan.showTickMarks(false); // affichage des repères
sPan.setSliderMode(Slider.FIX); // fonctionnement du slider FLEXIBLE ou FIX

// méthodes communes à tous les controles (objet Controller)
sPan.setLabelVisible(true); // affichage des labels
sPan.setLabel(« PAN »); // fixe label objet
sPan.setDecimalPrecision(0); // fixe la précision
sPan.setColorActive(rouge); // fixe la couleur active
//sRouge.setColorBackground(color(255,255,0)); // fixe couleur fond
sPan.setColorForeground(rouge); // fixe couleur avant
//sRouge.setArrayValue(new float[] {100,255} ); // fixe les valeurs min/max du Slider ?
sPan.setColorCaptionLabel(blanc); // fixe couleur Label
sPan.setColorValueLabel(noir); // fixe la couleur valeur

//———— slider Tilt —————-
// addSlider(theName, theMin, theMax, theDefaultValue, theX, theY, theW, theH)
sTilt=controlP5.addSlider(« sTilt »,0,180,90,(height/2)–10,10,25,350); // ajoute un Slider au ControlP5
//s1 = (Slider)controlP5.controller(« MonSlider1 »); // initialise l’objet Slider déclaré

// méthodes propres à l’objet Slider
sTilt.setNumberOfTickMarks(181); // fixe le nombre crans – n+1 pour n valeurs
//s1.setNumberOfTickMarks((int(s1.max())+1); // fixe le nombre crans – n+1 pour n valeurs
sTilt.showTickMarks(false); // affichage des repères
sTilt.setSliderMode(Slider.FIX); // fonctionnement du slider FLEXIBLE ou FIX

// méthodes communes à tous les controles (objet Controller)
sTilt.setLabelVisible(true); // affichage des labels
sTilt.setLabel(« TILT »); // fixe label objet
sTilt.setDecimalPrecision(0); // fixe la précision
sTilt.setColorActive(vert); // fixe la couleur active
//sTilt.setColorBackground(color(255,255,0)); // fixe couleur fond
sTilt.setColorForeground(vert); // fixe couleur avant
//sTilt.setArrayValue(new float[] {100,255} ); // fixe les valeurs min/max du Slider ?
sTilt.setColorCaptionLabel(blanc); // fixe couleur Label
sTilt.setColorValueLabel(noir); // fixe la couleur valeur

//———— slider Vitesse —————-
// addSlider(theName, theMin, theMax, theDefaultValue, theX, theY, theW, theH)
sVitesse=controlP5.addSlider(« sVitesse »,1,20,10,10,height–15,400,10); // ajoute un Slider au ControlP5
//s1 = (Slider)controlP5.controller(« MonSlider1 »); // initialise l’objet Slider déclaré

// méthodes propres à l’objet Slider
sVitesse.setNumberOfTickMarks(20); // fixe le nombre crans – n+1 pour n valeurs
//s1.setNumberOfTickMarks((int(s1.max())+1); // fixe le nombre crans – n+1 pour n valeurs
sVitesse.showTickMarks(false); // affichage des repères
sVitesse.setSliderMode(Slider.FIX); // fonctionnement du slider FLEXIBLE ou FIX

// méthodes communes à tous les controles (objet Controller)
sVitesse.setLabelVisible(true); // affichage des labels
sVitesse.setLabel(« Vitesse »); // fixe label objet
sVitesse.setDecimalPrecision(0); // fixe la précision
sVitesse.setColorActive(jaune); // fixe la couleur active
//sVitesse.setColorBackground(color(255,255,0)); // fixe couleur fond
sVitesse.setColorForeground(jaune); // fixe couleur avant
//sVitesse.setArrayValue(new float[] {100,255} ); // fixe les valeurs min/max du Slider ?
sVitesse.setColorCaptionLabel(blanc); // fixe couleur Label
sVitesse.setColorValueLabel(noir); // fixe la couleur valeur

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

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

// tout se passe dans les fonctions évènements des contrôles graphiques

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

print (inString); // affichage brut de la chaine recue

} // fin condition chaine recue pas vide

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

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

//—— fonction gestion globale des évènements GUI controlP5
public void controlEvent(ControlEvent theEvent) {
//println(theEvent.controller().name());// affiche le nom de l’évènement
}

// —— gestion évènement Slider ——
void sPan(float valeur) { // fonction évènement Slider de meme nom – reçoit la valeur
println(« Evènement Slider Pan avec valeur = « +valeur);

println(« Envoi sur port série = « +int(valeur));

if (valeur>100)myPort.write(« servoPan(« +int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série
if ((valeur<100) && (valeur>9))myPort.write(« servoPan(0 »+int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série
if (valeur<=9)myPort.write(« servoPan(00 »+int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série

}

// —— gestion évènement Slider ——
void sTilt(float valeur) { // fonction évènement Slider de meme nom – reçoit la valeur
println(« Evènement Slider Tilt avec valeur = « +valeur);
println(« Envoi sur port série = « +int(valeur));

if (valeur>100)myPort.write(« servoTilt(« +int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série
if ((valeur<100) && (valeur>9))myPort.write(« servoTilt(0 »+int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série
if (valeur<=9)myPort.write(« servoTilt(00 »+int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série

}

// —— gestion évènement Slider ——
void sVitesse(float valeur) { // fonction évènement Slider de meme nom – reçoit la valeur
println(« Evènement Slider Vitesse avec valeur = « +valeur);
println(« Envoi sur port série = « +int(valeur));

//if (valeur>100)myPort.write(« Vitesse(« +int(valeur)+ »)\n »); // envoie la valeur suivie d’un saut de ligne sur le port Série
if ((valeur<100) && (valeur>9))myPort.write(« Vitesse(0 »+int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série
if (valeur<=9)myPort.write(« Vitesse(00 »+int(valeur)+« )\n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série