Tracé d’un cercle calculé par une carte Arduino

1.  Présentation

Ce programme affiche un cercle dans une interface graphique Processing côté PC : on fait calculer à la carte Arduino la valeur des points du cercle pour chaque angle, à l’aide des fonctions mathématiques sinus et cosinus du langage Arduino.

La courbe des valeurs reçues est tracée dans une interface graphique Processing côté PC, programmé en grapheur X-Y (affiche un point à partir des coordonnées X,Y reçues).

Sur cette page,le programme Arduino et le programme Processing.

Ce programme utilise les fonctionnalités suivantes :

• la connexion série vers le PC

Voir également :

• Les fonctions mathématiques du langage Arduino
• La page de wikipédia consacrée au cercle : http://fr.wikipedia.org/wiki/Cercle

2.  Matériel Nécessaire

2.1  L’espace de développement Arduino

• … pour éditer, compiler le programme et programmer la carte Arduino.

3.  Instructions de montage

• Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)

4.  Le schéma théorique du montage

Le schéma théorique du montage

5.  Le circuit du montage

Le schéma du montage à réaliser

6.  Explication du programme Arduino

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.  Détails du programme

• Le programme calcule 360 valeurs des points du cercle à l’aide des fonctions sinus et cosinus. Les valeurs de sortie sont adaptées par un coefficient multiplicateur (rayon) à l’interface de sortie Processing et sont centrées dans la fenêtre Processing (600×600).
• La « clé » de ce programme est l’utilisation d’une seule valeur 32 bits (type long) pour transmettre à l’interface Processing les 2 valeurs X et Y via la connexion série. La valeur X est sur les 16 premiers bits, la valeur Y est sur les 16 bits de poids forts. La valeur 32 bits est construite dans une fonction dédiée côté Arduino et est décodée côté PC dans par l’interface Processing.
• Pour plus de précisions, se reporter aux commentaires présents dans les programmes ci-dessous.

8.  Mise en oeuvre du programme

8.1  Fonctionnement

• Lancer l’exécution du programme processing
• Faire un reset sur la carte Arduino : le graphique apparaît.

9.  Le programme complet en langage Arduino :

A copier/coller directement dans l’éditeur Arduino

// --- Programme Arduino ---
// Copyright X. HINAULT - Créé le 24/08/2010
// www.mon-club-elec.fr 

//  Code sous licence GNU GPL : 
//  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/>.
//  

// --- Que fait ce programme ? ---
/* Envoie vers le PC des valeurs numériques en coordonnées X-Y
pour affichage dans grapheur X,Y Processing 
envoie une valeur 32 bits avec X sur les 16 bits faibles et Y sur les 16 bits forts
Trace un cercle
*/

// --- Fonctionnalités utilisées ---
// Utilise la connexion série vers le PC 

// --- Circuit à réaliser ---
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)  

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

// --- Déclaration des constantes ---
const float pi=3.14159; // constante pi

// --- constantes des broches ---

// --- Déclaration des variables globales ---
long unsigned outValue; // valeur envoyée vers Processing 32 bits

float valeurf; // variable pour calcul 
int valeur; // variable pour envoi vers le PC

float yf_min, yf_max, yf_base, yf; // variables pour les ordonnées
float xf_min, xf_max, xf; // variables pour les abscisses

int y_min, y_max, y_base, y; // variables pour les ordonnées
int x_min, x_max, x; // variable pour les abcisses

float anglef, rayonf; // trace cercle
int x_centre, y_centre; // trace cercle

// --- Déclaration des objets utiles pour les 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 


// ------- Broches en sortie -------  


// ------- Broches en entrée -------  


// ------- Activation du rappel au + interne des broches en entrée si nécessaire -------  

//------ initialisation des variables utilisées 

valeurf=0.0; 
valeur=0; 

xf_min=0.0, xf_max=600.0, xf=0.0; // pour 600 valeurs
x_min=0, x_max=600, x=0;

yf_min=0.0, yf_max=600.0, yf_base=yf_max/2.0, yf=0.0; // échelle des y
y_min=0, y_max=600, y_base=y_max/2, y=0;

// Graphe 600 x 600 dans Processing

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


// trace un cercle

rayonf=200.0;
x_centre=300; y_centre=300;

//---- affiche point de début ---- 
calculOutValue (500,300); 

  Serial.println(outValue); // envoi valeur 32 bits avec Y bits poids forts et X bits poids faible vers Processing

  delay(1); // pause entre chaque valeur

for (int i=1; i<=360; i++) { // angle de 0 à 360

  anglef= i; 
  anglef=anglef*2*pi;
  anglef=anglef/360.0; 

  xf= rayonf * cos(anglef); 
  xf= x_centre+xf; 
  x= xf; 

  yf= rayonf * sin(anglef); 
  yf= y_centre+yf;
  y=yf; 

  calculOutValue (x,y); 

  Serial.println(outValue); // envoi valeur 32 bits avec Y bits poids forts et X bits poids faible vers Processing

  delay(1); // pause entre chaque valeur

} // fin boucle for i


while(1); // stoppe loop

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

//*************** Autres Fonctions du programme *************

void calculOutValue ( int valeur_x, int valeur_y) { // fonction de calcul de la valeur 32 bits à envoyer à Processing 

 //--- initialisation valeur envoyée vers Processing
  outValue=0; 

  // --- met y sur les bits de poids forts de la valeur 32 bits envoyée vers Processing
  outValue=valeur_y; 
  outValue=outValue<<16; // Décalage 16 bits à gauche

  // met x sur les bits de poids faible de la valeur 32 bits envoyée vers Processing
  outValue=outValue+valeur_x;

}

// --- Fin programme ---

10.  Le programme complet en langage Processing :

A copier/coller directement dans l’éditeur Processing

/* 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
 // chaque valeur reçue est au format 32bits avec les 16 bits poids faible pour X et 16 bits poids fort pour y
 // 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 - Aout 2010
 // www.mon-club-elec.fr
 */

 import processing.serial.*;

 Serial myPort;        // Variable Port Série

 int xPos=1;         // variable abscisse  - x
 int xPos0=9999;       // variable mémorisation xPos n-1 - 9999 au debut

 int yPos=1;  // variable yPos - ordonnée
 int 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)

size(600,600); // initialise la fenetre à la taille L x h 

 // Liste tous les ports disponible et affiche le résultat 
 println(Serial.list());

 // Le port utilisé est listé avec l'indice 0
 // donc j'ouvre le port Serial.list()[0].

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

 quadrillage(25); // trace quadrillage avec maille voulue - cf fonction ci-dessous

 }

 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 
 int inValue = int(inString); 


 // extraction de X à partir des 16ers bits = bits de poids faible
 xPos=inValue & 65535; // met à 0 les 16 bits de poids fort sans modifier les bits de poids faible (255 = 0x00FF)

 // extraction de Y à partir des 16 bits de poids forts
 yPos=inValue>>16; // décale les 16 bits de poids forts vers les 16 bits de poids faible qui sont perdus de fait

 // trace la ligne
 stroke(0,0,255); // fixe la couleur utilisée pour le tracé en RVB 

  //----- affichage debug des valeurs utiles -debug ------
  //print ("inValue="+binary(inValue) +"("+inValue+")" + " // "); // affiche inValue au format binaire (debug)
  //print ("xPos="+binary(xPos) +"("+xPos+")" +" // " ); // affiche X au format binaire dans la console (debug)
  //println ("yPos="+binary(yPos)+"("+yPos+")" ); // affiche Y au format binaire dans la console (debug)

 if (xPos0==9999) { // au premier passage
   point (xPos,height-yPos); // trace un seul point au premier passage
 }
 else {
   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... réinitialise l'écran au début  
 } 


 }  // fin while inString

 } // fin serial Event


void quadrillage (int maille) {

 stroke(0,255,0); // fixe la couleur utilisée pour le tracé en RVB 

 // lignes verticales

 for (int i=1; i<=width/maille; i++) {

   line (i*maille,height-1,i*maille,0); // trace une ligne verticale

 }

 // lignes horizontales 
 for (int i=1; i<height/maille; i++) {

   if (i==height/2/10) stroke(255,0,0);else stroke(0,255,0); // fixe la couleur de la ligne médiane

   line (0,height-(i*maille),width-1,height-(i*maille)); // trace ligne horizontale

 }

}