L’affichage graphique des résultats d’une mesure analogique sur un ordinateur est une pratique courante dans de nombreux domaines. Cette méthode permet de visualiser les données et de les analyser plus facilement. Elle est particulièrement utile pour les applications qui nécessitent une précision et une précision élevées, telles que les tests de laboratoire, les tests de production et les tests de qualité. Dans cet article, nous allons examiner les différentes méthodes pour afficher le résultat d’une mesure analogique sous forme graphique sur un PC.
Afficher le résultat d’une mesure analogique sous forme graphique sur le PC.
Présentation
Ce programme affiche le résultat d’une conversion analogique numérique sous forme graphique sur le PC dans une interface Processing. Le but ici est d’exploiter quasiment en pleine échelle la mesure fournie par la carte Arduino (1024 niveaux)
L’essentiel de ce programme en fait se passe côté PC : l’interface processing réalise un affichage grand format (dans une fenêtre 800×800) de la mesure. On peut même pousser jusqu’à 800×1000 selon l’écran qu’on a… L’intérêt est de pouvoir utiliser au maximum la sensibilité de l’Arduino qui rappelons-le fait une mesure sur 1024 niveaux (5mV de précision environ) : autant pouvoir en profiter…
La courbe correspondant à la mesure s’affiche donc côté PC : çà permet de se fabriquer un oscilloscope numérique basse fréquence et basse tension à 25 Euros (prix de la carte Arduino…!), certes limité mais qui rendra de fiers services pour des tests de capteurs et autres…
Cette page est une reprise modifiée de l’exemple : http://arduino.cc/en/Tutorial/Graph
Ce programme utilise les fonctionnalités suivantes :
- la connexion série vers le PC
- la conversion analogique numérique 10bits sur les voies analogiques analog 0,
Matériel Nécessaire
L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,
- des straps,
- une résistance variable linéaire de 10 KOhms,
Instructions de montage
- Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
- Broche Analog 0 (=broche 14) en entrée Analogique
Le schéma théorique du montage
Le schéma théorique du montage
Le circuit du montage
Le schéma du montage à réaliser
(Les traits pointillés symbolisent la connexion interne à la carte Arduino entre les broches 0 et 1 et l’entrée USB)
Explication du programme
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.
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
Au niveau de la partie déclarative :
Déclaration des constantes de broches
- Déclaration des constantes pour les broches utilisées dans le programme :
Déclaration des variables globales
- Déclaration des variables globales du programmes :
- Déclaration des variables globales utilisées pour la conversion analogique-numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique
Au niveau de la fonction d’initialisation setup( ) :
Initialisation des fonctionnalités utilisées :
- On initialise les différentes fonctionnalités utilisées :
- Initialisation de la communication série avec le PC
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
Au niveau de la boucle principale, la fonction loop ( ) :
- On réalise une mesure analogique à l’aide de l’instruction analogRead(),
- Ensuite en envoie cette mesure sous forme d’une chaîne se terminant par un saut de ligne vers le PC à l’aide de l’instruction Serial.println(),
- une pause entre 2 mesures vient moduler la vitesse d’affichage ( à adapter au besoin )
mesure_brute=analogRead(Voie_0);
// affiche valeur numerique entière ou à virgule au format décimal
Serial.println(mesure_brute);
delay(100); // fixe une pause entre 2 mesures
// plus le délai est court, plus la trace est rapide
- Le programme recommence en boucle les instructions de la fonction loop( ).
Se reporter aux commentaires présents dans le programme pour plus de détails.
Mise en oeuvre du programme
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
Fonctionnement
- L’essentiel de se programme en fait se passe côté PC : l’interface processing réalise un affichage grand format (dans une fenêtre 800×800) de la mesure. On peut même pousser jusqu’à 800×1000 selon l’écran qu’on a… L’intérêt est de pouvoir utiliser au maximum la sensibilité de l’Arduino qui rappelons le fait une mesure sur 1024 niveaux (5mV de précision environ) : autant pourvoir en profiter…
- La courbe correspondant à la mesure s’affiche donc côté PC : çà permet de se fabriquer un oscilloscope numérique basse fréquence et basse tension à 25 Euros (prix de la carte Arduino…!), certes limité mais qui rendra de fier service pour des tests de capteurs et autres…
Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// par X. HINAULT – 01/2010
// — Que fait ce programme ? —
/* Affiche le résultat brut d’une conversion analogique numérique sur la fenêtre terminal du PC*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise la conversion analogique numérique 10bits sur les voies analogiques analog 0,
// — Circuit à réaliser —
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
// Broche Analog 0 (=broche 14) en entrée Analogique : connecter la sortie d’une résistance Variable 10K elle-même connectée entre 0 et 5V
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
// — constantes des broches —
const int Voie_0=0; //declaration constante de broche analogique
// — Déclaration des variables globales —
int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
// — Initialisation des fonctionnalités utilisées —
//**************** 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 au démarrage —
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
} // fin de la fonction setup()
// ********************************************************************************
//*************** 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 —
// acquisition conversion analogique-numerique (CAN) sur la voie analogique
mesure_brute=analogRead(Voie_0);
// affiche valeur numerique entière ou à virgule au format décimal
Serial.println(mesure_brute);
delay(10); // fixe une pause entre 2 mesures
// plus le délai est court, plus la trace est rapide
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// — Fin programme —
Le programme complet Processing :
A copier/coller directement dans l’éditeur Processing et lancer le programme.
// Graphing sketch
// Ce programme reçoit des chaine de caractère ASCII
// depuis le port Série à 115200 bauds et les affiche sous forme de courbe
// dans une fourchette de 0 to 1023,
//lorsque les données sont suivies d’un retour de ligne
// Created 20 Apr 2005
// Updated 18 Jan 2008
// by Tom Igoe
//
// modifié par X. HINAULT – January 2010
// www.mon-club-elec.fr
*/
import processing.serial.*;
Serial myPort; // Variable Port Série
int xPos = 1; // variable abscisse – x
int xPos0=1; // variable mémorisation xPos n-1
float yPos=1; // variable yPos – ordonnée
float yPos0=1; // variable yPos n-1
void setup () {
// initialise la fenêtre
size(int(screen.width*0.9), int(screen.height*0.9));
// 90% de l’écran par défaut – régler au besoin –
// viser taille maxi en hauteur – taille fenêtre (x,y)
// Liste tous les ports disponible et affiche le résultat
println(Serial.list());
// Le port COM3 est listé avec l’indice 1
// donc j’ouvre le port Serial.list()[1].
// A adapter si votre port est différent – cf liste qui s’affiche à l’exécution
myPort = new Serial(this, Serial.list()[0], 115200);
// ne génère aucun évènement Série tant qu’aucun caractère saut de ligne n’est reçu
myPort.bufferUntil(‘\n‘);
// initialise le fond de la fenêtre
background(255);// 0 = noir – 255 = blanc
}
void draw () {
// tout se passe dans la fonction SerialEvent car le programme reçoit des données
}
void serialEvent (Serial myPort) {
// mémorise la chaîne de caractères reçue
String inString = myPort.readStringUntil(‘\n‘);
if (inString != null) {
// enlève les espaces
inString = trim(inString);
// convertit la chaîne en valeur numérique
float inByte = float(inString);
// ré-échelonne la valeur pour affichage
inByte = map(inByte, 0, 1023, 0, height);
yPos=inByte; // l’ordonnée est la valeur reçue par le port série
// trace la ligne
stroke(0,0,255); // fixe la couleur utilisée pour le tracé en RVB
line (xPos0,height–yPos0,xPos,height–yPos); // trace une ligne en tenant compte valeur reçue
xPos0=xPos; // mémorisation xPos n-1
yPos0=yPos; // mémorisation xPos n-1
// à la fin de l’écran revient au début
if (xPos >= width) {
xPos = 0;
xPos0=0; // pour retour de la trace sans ligne
background(255); // 0 pour noir – 255 pour blanc…
}
else {
// incrémente la position horizontale (abscisse)
xPos++;
}
}
}
