La mesure angulaire de la réponse d’un capteur analogique est une tâche complexe qui nécessite une précision et une précision extrêmes. Cet article expliquera les principes de base de la mesure angulaire et fournira des informations sur les méthodes et les outils nécessaires pour réaliser cette tâche. Il expliquera également comment les résultats peuvent être interprétés et comment les erreurs peuvent être évitées. Enfin, il fournira des exemples pratiques pour illustrer les principes et les méthodes discutés.
Réaliser la mesure angulaire de la réponse d’un capteur analogique
Exemple de mesure angulaire avec détection d’une flamme de bougie placée à 40 cm du capteur
Les demi-cercles concentriques représentent les niveaux de tension. Un rayon tous les 10 degrés
(cliquer sur l’image pour agrandir)
1. Présentation
- Ce programme permet d’effectuer la mesure angulaire de la réponse d’un capteur analogique.
- Le capteur est placé sur un servomoteur dont on commande le positionnement.
- Le positionnement du servomoteur est contrôlé par une chaîne de caractère au format servo(000)
- Le programme renvoie une réponse de la mesure sur la port série sous la forme d’une chaine de caractères au format « resultatCan=valeur » : cette valeur est utilisée par le programme Processing pour afficher le résultat de la mesure.
- Le programme Processing fait parcourir au servomoteur les positions de 0° à 180° et affiche le résultat de la mesure correspondante.
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
- Utilise la conversion analogique numérique 10 bits
- Utilise un servomoteur
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
- 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é
- une plaque d’essai pour montage sans soudures,

- des straps,

- un servomoteur standard

- un capteur analogique, par exemple un capteur de flamme analogique – DFRobot,

3. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
- Connecter un servomoteur sur la broche 2
- 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.
- En ce qui concerne la ligne de commande du servomoteur par la carte Arduino :
Pour plus de détails, voir : Principes d’utilisation des alimentations avec une carte Arduino et des servomoteurs
- Connecter la sortie analogique du capteur sur la voie Analogique 0 de la carte Arduino

- On fixera le capteur sur le servomoteur :

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
- Le programme écoute le port Série et analyse la chaîne reçue.
- Le servomoteur est positionné à partir d’une chaine de caractères reçue sur le port série de la forme « servo(000) » où 000 est la valeur de l’angle sur lequel le servomoteur doit se positionner.
- Une mesure analogique est alors éxécutée et est renvoyée sur le port Série sous la forme « resultat=valeur ».
- Ce résultat est utilisable par l’interface Processing coté PC.
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
- Lancer le programme processing :
- Clic sur le bouton « Mesure » lance la mesure angulaire sur 180° par le servomoteur
- La courbe s’affiche :
Exemple de mesure angulaire avec détection d’une flamme de bougie placée à 40 cm du capteur
Les demi-cercles concentriques représentent les niveaux de tension. Un rayon tous les 10 degrés
(cliquer sur l’image pour agrandir)
- et les messages de communications s’affiche dans la console de Processing :

8. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur 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 : 1/3/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 ? ———
/* Un servomoteur est positionné à partir d’une chaine de caractères reçue sur le port série
de la forme « servo(000) » où 000 est la valeur de l’angle sur lequel le servomoteur doit se positionner.
Une mesure analogique est alors éxécutée et est renvoyée sur le port Série sous la forme « resultat=valeur »
Ce résultat est utilisable par une interface Processing coté PC
*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise / fonctionne avec une interface Processing coté PC
// Utilise un servomoteur
// ——– Circuit à réaliser ———
// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
// ******* ATTENTION : il est possible de connecter directement 2 ou 3 servomoteurs sur la carte Arduino
// Au-delà : utiliser une interface de puissance16
// Connecter un servomoteur sur la broche 2
// /////////////////////////////// 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 —
//— Constantes utilisées avec le servomoteur
const int ANGLE_MIN=10; // angle position MIN en degrés
const int POS_MIN=600; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur
// par exemple POS_MIN=600 pour ANGLE_MIN=10° avec un futaba S3003
const int ANGLE_MAX=170; // angle position MAX en degrés
int POS_MAX=2300; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur
// POS_MAS=2300 pour ANGLE_MIN=170° pour futaba s3003
// — Déclaration des constantes des broches E/S numériques —
const int broche_servo=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
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 angleServo=0; // angle servomoteur
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//— Création objet servomoteur
Servo mon_servo; // crée un objet servo pour contrôler le servomoteur
// ////////////////////////// 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_servo.attach(broche_servo); // attache l’objet servo à la broche de commande du servomoteur
//mon_servo.attach(broche_servo, POS_MIN, POS_MAX); // attache l’objet servo à la broche de commande du servomoteur avec calibrage auto
// ——- Broches en sorties numériques ——-
pinMode (broche_servo,OUTPUT); // Broche broche_servo 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 ——-
Serial.println(« Arduino OK »); // debug
//—- positionnement initial servomoteur
mon_servo.writeMicroseconds(angle(90)); // crée impulsion à partir valeur angle – plus précis que write()
delay(1000);
} // 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 —
//—- 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
if (chaineReception.substring(0,6)==« servo(« ) { // si reçoit l’instruction servo(000)
// nb substring : dernier caractere exclu
Serial.print(« Arduino va executer : « );
Serial.print(« servo(« ); // affiche
//————- extraction valeur angle servomoteur —— 3 chiffres
//—- extraction 1er chiffre
valeur=chaineReception.charAt(6); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServo=valeur;
//—- extraction 2ème chiffre
valeur=chaineReception.charAt(7); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServo=angleServo*10+valeur;
//—- extraction 2ème chiffre
valeur=chaineReception.charAt(8); // extrait valeur ASCII du caractere
valeur=valeur–48; // extrait valeur numérique du caractere
angleServo=angleServo*10+valeur;
Serial.print(angleServo); // affiche
if (chaineReception.substring(9,10)==« ) ») { // si fermeture parenthèse = instruction valide
Serial.println(« ) »); // affiche
Serial.println(« Instruction valide ! »); // affiche
//—– positionnement du servomoteur —-
//angleServo=constrain(angleServo,0,180); // oblige valeur angle Servo
mon_servo.writeMicroseconds(angle(angleServo)); // crée impulsion à partir valeur angle – plus précis que write()
delay(100); // laisse temps positionnement
Serial.println(« Servomoteur mis en position »); // affiche
Serial.print(« resultatCan= »);
Serial.println(analogRead(A0));
;
} // fin si fermeture parenthèse
} // — fin si reçoit instruction servo(000)
//————- fin analyse chaine —————
chaineReception=« »; //RAZ le String de 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 ////////////////////
//————- 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 ////////////////////
9. Le programme Processing : Oscilloscope angulaire simple de 0 à 180° – échelle 0-1024

9.1 Description
- L’appui sur le bouton graphique lance la mesure angulaire.
- Ce programme processing va envoyer vers Arduino sur le port série une chaîne au format « servo(000) » où 000 est la valeur de l’angle à utiliser pour positionner le servomoteur.
- Après chaque instruction de positionnement, le programme Processing attend la mesure reçue depuis Arduino et décode les chaînes reçues.
- Les angles de 0 à 180° sont parcourus.
9.2 Ressources utiles
- librairie pour interface graphique GUI controlP5
9.3 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
// www.mon-club-elec.fr
// par X. HINAULT – Mars 2011 – tous droits réservés
/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise la librairie GUI controlP5
// Utilise un/des bouton(s) simple(s) (Button)
/*
Tracé angulaire de la mesure analogique reçue par le port série depuis un capteur analogique placé sur un servomoteur.
*/
// 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
Button b1,b2, b3; // déclare un/des objets Button
// Button [] b= new Button[n]; // crée un tableau de n Button b[i] – 1er indice est 0
// 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);
//—- variables du programme
float xo, yo; // point référence graphique
float decalage,rayon;
float angle_radians;
float xpos, ypos, xpos0, ypos0;
boolean enCours=false; // variable témoin
int compt=0; // comptage
int mesure=0; // variable mesure
int coeff=1; // coeff tracé
// 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 (rouge); // 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
smooth(); // activation lissage des formes
// — initialisation fenêtre de base —
size(800, 500); // 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 Button =========
//—- 1er bouton : bouton mesure —-
// addButton(String theName, float theValue, int theX, int theY, int theW, int theH)
b1=controlP5.addButton(« boutonMesure »,0,10,10,50,24); // initialise et ajoute un Button au ControlP5
// méthodes propres à l’objet Button
// méthodes communes à tous les controles (objet Controller)
b1.setLabelVisible(true); // affichage des labels
b1.setLabel(« Mesure »); // fixe label objet
b1.setDecimalPrecision(2); // fixe la précision
b1.setColorActive(color(255,0,0)); // fixe la couleur active
b1.setColorBackground(color(255,0,255)); // fixe couleur fond
b1.setColorForeground(color(0,0,255)); // fixe couleur avant
b1.setColorCaptionLabel(color(0,0,0)); // fixe couleur Label
b1.setColorValueLabel(color(0,0,255)); // fixe la couleur valeur
// 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, Over et Active
//b1.setImages(loadImage(« imageDefault.png »),loadImage(« imageOver.png »), loadImage(« imageActive.png »),loadImage(« imageDefault.png »));
//—— 2ème bouton – bouton Coeff —
b2=controlP5.addButton(« boutonCoeff »,0,10,35,50,24); // initialise et ajoute un Button au ControlP5
// méthodes communes à tous les controles (objet Controller)
b2.setLabelVisible(true); // affichage des labels
b2.setLabel(« Coeff x » + coeff); // fixe label objet
//—— 3ème bouton – bouton RAZ —
b3=controlP5.addButton(« boutonRAZ »,0,10,60,50,24); // initialise et ajoute un Button au ControlP5
// méthodes communes à tous les controles (objet Controller)
b3.setLabelVisible(true); // affichage des labels
b3.setLabel(« RAZ »); // fixe label objet
traceInitial();
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
//————- Code pour port série —-
// myPort.write(‘H’); // envoie le caractère sur le port Série
// myPort.write(« chaine\n »); // envoie la chaine suivi saut ligne sur le port Série
// Accès à la valeur des objets GUI controlP5
//— accès à la valeur courante du Button —
//println(« Valeur Button= « + b1.value());
//delay(100);
// 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
print(« Arduino envoie : « );
print (inString); // affichage brut de la chaine recue
inString = trim(inString); // enlève espace blancs de la chaine recue
//int inByte_brut=int(inString); // conversion valeur reçue en valeur numérique entiere
//float inByte = float(inString); // conversion valeur reçue en valeur numérique décimale
//—- analyse chane reçue —
if (match(inString,« resultatCan »)!=null) { // si la chaine reçue contient « mesure »
String testString[]=split(inString,« = »); // utilisé pour analyser string en réception
mesure=int(testString[1]);
println (« Valeur= »+mesure); // affiche valeur reçue
if (enCours==true) { // si comptage en cours
compt=compt+1; // incrémente compt
if (compt<=9) { // de 0 à 9
// envoi angle 00compt
myPort.write(« servo(00 »+str(compt)+« )\n« ); // envoie la chaine suivi saut ligne sur le port Série
println(« Chaine envoyée : servo(00 »+str(compt)+« )\n« );
} // fin if compt <10
if ((compt>9) && (compt<100)) { // si compt entre 10 et 99
// envoi angle 0compt
myPort.write(« servo(0 »+str(compt)+« )\n« ); // envoie la chaine suivi saut ligne sur le port Série
println(« Chaine envoyée : servo(0 »+str(compt)+« )\n« );
} // fin if compt entre 10 et 100
if ((compt>99) && (compt<=180)) { // si compt entre 100 et 180
// envoi angle compt
myPort.write(« servo(« +str(compt)+« )\n« ); // envoie la chaine suivi saut ligne sur le port Série
println(« Chaine envoyée : servo(« +str(compt)+« )\n« );
} // fin if compt entre 100 et 180
//—– trace le point en cours
stroke (jaune); // couleur pourtour RGB
angle_radians=radians(compt);
//—- coordonnées point courant
xpos=xo+(cos(angle_radians)*rayon*mesure/1024*coeff);
ypos=yo–(sin(angle_radians)*rayon*mesure/1024*coeff);
line(xpos0, ypos0, xpos,ypos);
//— mémorise point courant
xpos0=xpos;
ypos0=ypos;
if (compt==180) {
enCours=false; // stoppe comptage
// envoi angle 000
myPort.write(« servo(000)\n« ); // envoie la chaine suivi saut ligne sur le port Série
println(« Chaine envoyée = » + « servo(000)\n« );
}// fin si compt==180
}//fin si en cours
} // fin si match mesureCan
} // 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 Button ——
void boutonMesure(int theValue) { // fonction évènement Button de meme nom – reçoit la valeur
println(« Evènement Bouton Mesure avec valeur = « +theValue);
compt=0;
enCours=true;
// envoi angle 000
myPort.write(« servo(000)\n« ); // envoie la chaine suivi saut ligne sur le port Série
println(« Chaine envoyée = » + « servo(000)\n« );
} // fin bouton mesure
void boutonCoeff(int theValue) { // fonction évènement Button de meme nom – reçoit la valeur
println(« Evènement Bouton Coeff avec valeur = « +theValue);
coeff=coeff+1;
if (coeff>5) coeff=1; // RAZ Coeff 1 à 5
b2.setLabel(« Coeff x » + coeff); // fixe label objet
} // fin bouton mesure
void boutonRAZ(int theValue) { // fonction évènement Button de meme nom – reçoit la valeur
println(« Evènement Bouton RAZ avec valeur = « +theValue);
if (enCours==false)traceInitial(); // efface tracé en cours et retrace tracé initial si pas mesure en Cours
} // fin bouton mesure
void traceInitial() { // fonction de tracé initial
// tracé initial du graphe
background(0,0,0); // couleur fond fenetre
fill(noir); // couleur remplissage RGB
stroke (vert); // couleur pourtour RGB
strokeWeight(1); // largeur pourtour
decalage=(width*0.1);
rayon=((width–decalage)/2);
xo=decalage+rayon–5; // point x de référence du graphique
yo=height–5; // point y de référence du graphe
rect(xo, yo, 1,1);
// tracé des arcs de cercle voltage 0 à 5V
for (int i=5; i>=1; i—) {
//arc(x, y, width, height, start, stop)
arc(xo,yo,rayon*2*0.2*i,rayon*2*0.2*i,PI,TWO_PI);
}
// tracé des rayons angulaires tous les 10°
for (int angle=0; angle<=18; angle++) { // défile de 0 à 180 degres
angle_radians=radians(angle*10);
line (xo,yo,xo+(cos(angle_radians)*rayon),yo–(sin(angle_radians)*rayon));
}
// tracé de la courbe
//— point n-1 initial
xpos0=xo;
ypos0=yo;
/* code test trace – debug
for (int angle=0; angle<=180; angle++) { // défile de 0 à 180 degres
stroke (jaune); // couleur pourtour RGB
angle_radians=radians(angle);
//rect(xo+(cos(angle_radians)*rayon/2),yo-(sin(angle_radians)*rayon/2),1,1);
//—- coordonnées point courant
xpos=xo+(cos(angle_radians)*rayon/2);
ypos=yo-(sin(angle_radians)*rayon/2);
line(xpos0, ypos0, xpos,ypos);
//— mémorise point courant
xpos0=xpos;
ypos0=ypos;
}
*/
}
//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
Articles similaires:
- Oscilloscope angulaire simple de 0 à 180° – échelle 0-1024
- Saisir une chaîne dans un champ texte et l’envoyer vers le port Série
- Positionnement servomoteur à l’aide d’une chaîne de caractère envoyée depuis Processing
- http://web.archive.org/web/20210804223007/http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ATELIERSSerieEnvoiPCVersArduinoProcessing
- Recevoir une chaine de caractères depuis Processing via le port série USB
Articles Liés
- Mesure d'une intensité à l'aide du capteur de courant +/-5A ACS714 (affichage graphique Processing)
La mesure d'une intensité est une tâche importante pour de nombreuses applications industrielles et domestiques.…
- Visualiser dans une interface Processing 3D la réponse d'un capteur accéléromètre analogique ADXL335 (+/-3g, 3 axes).
L'utilisation de la technologie 3D est devenue de plus en plus populaire ces dernières années,…
- Ethernet en mode serveur : Serveur réseau de datalogging avec stockage dans une SD-Card et accès distant dans une interface Processing
L'Ethernet en mode serveur est une technologie révolutionnaire qui permet aux utilisateurs de créer un…