Vous aimez ce site ?
Soutenez-le !

Par compte Paypal ou carte bancaire
Vous pouvez donner dès 1€ !

Afficher le résultat d'une mesure analogique sous forme graphique sur le PC.

ARDUINO - EXPERT - CAN- PROCESSING
Par X. HINAULT - Créé le 20/02/2010

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 800x800) de la mesure. On peut même pousser jusqu'à 800x1000 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 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 :

const int Voie_0=0; //declaration constante de broche analogique

[Obtenir le Code]

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

int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique

[Obtenir le Code]

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

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission

[Obtenir le Code]

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 )

// 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(100); // fixe une pause entre 2 mesures
// plus le délai est court, plus la trace est rapide

[Obtenir le Code]

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 800x800) de la mesure. On peut même pousser jusqu'à 800x1000 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

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

[Obtenir le Code]

Le programme complet Processing :

A copier/coller directement dans l'éditeur Processing et lancer le programme.

/* Processing code for this example

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

[Obtenir le Code]