communication série processing Archives

Le langage pour Processing , la communication série

–

Mise à jour le 10/09/2017 : La liaison série est un protocole de communication indispensable entre l’ordinateur et la carte Arduino ( ou bien un autre type de carte ) , via le câble de communication USB.Dans cet article , nous vous donnons quelques exemples avec des tutoriels pour vous familiariser à ce genre de communication série.

Sommaire :

Lecture d’un compteur dans la carte Arduino sur Processing
- Lecture d’une valeur sur la carte Arduino via la communication série ( coté Arduino )
- Affichage d’une valeur de la carte Arduino sur processing ( coté Processing )
Lecture de 3 valeurs sur la carte Arduino via le port série et animation d’un rectangle sur l’écran.
- Tutoriel vidéo
- Programme pour la carte Arduino lecture d’un joystick
- Programme pour Processing affichage d’une forme via la carte Arduino
Retour au menu Processing

– La communication série –
Lecture d’un compteur dans la carte Arduino
sur Processing ( AP001-P)

Programme pour Arduino ( AP001-A)

//
//
//
// *****************************************************
// * RedOhm                                            *
// *                                                   *
// *    Lecture d'une valeur sur la carte Arduino      *
// *       via le port serie                           *
// *                                                   *
// * code programme : AP001-A                          *
// *                                                   *
// * 13/08/2017                                        *
// * H.Mazelin                                         *
// *****************************************************




// Déclare une variable ( valeur )  de type int non-signée. ce type de variables 
// unsigned int stocke uniquement des valeurs positives, dans une fourchette 
// allant de 0 à 65535 
unsigned int valeur ;


// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties 
void setup() {
  
//ouvre le port série et fixe le debit de communication à 9600 bauds
 Serial.begin(9600);
}




 //Le programme principal s’exécute par une boucle infinie appelée Loop () 
  
void loop()

{


// incrémente la variable valeur de  un, sans modifier la variable valeur  
valeur = valeur +1 ;
// Affiche les données sur le port série suivi d'un caractère de "retour de chariot"
//(ASCII 13, or '\r') et un caractère de "nouvelle ligne" (ASCII 10, or '\n'). 
Serial.println(valeur);

// Réalise une pause dans l'exécution du programme pour la durée (en millisecondes)
// soit 2000 ms = 2 secondes 
delay(2000);

  
}

// *****************************************************

// * RedOhm *

// * *

// * Lecture d'une valeur sur la carte Arduino *

// * via le port serie *

// * *

// * code programme : AP001-A *

// * *

// * 13/08/2017 *

// * H.Mazelin *

// *****************************************************

// Déclare une variable ( valeur ) de type int non-signée. ce type de variables

// unsigned int stocke uniquement des valeurs positives, dans une fourchette

// allant de 0 à 65535

unsigned int valeur ;

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup() {

//ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin(9600);

}

//Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop()

{

// incrémente la variable valeur de un, sans modifier la variable valeur

valeur = valeur +1 ;

// Affiche les données sur le port série suivi d'un caractère de "retour de chariot"

//(ASCII 13, or '\r') et un caractère de "nouvelle ligne" (ASCII 10, or '\n').

Serial.println(valeur);

// Réalise une pause dans l'exécution du programme pour la durée (en millisecondes)

// soit 2000 ms = 2 secondes

delay(2000);

}

Retour au sommaire

Programme pour Processing ( AP001-P )

//
//
//
// *****************************************************
// * RedOhm                                            *
// *                                                   *
// *    Lecture d'une valeur sur la carte Arduino      *
// *       via le port serie                           *
// *                                                   *
// * code programme : AP001-P                          *
// *                                                   *
// * 13/08/2017                                        *
// * H.Mazelin                                         *
// *****************************************************


// Cette librairie permet de communiquer avec l'Arduino 
// il esn indispensable de l'installer pour communiquer 
import processing.serial.*;

 
// Crée un objet de type myPort
Serial port_de_com;  

// Declaration de la variable -> valeur_recu
// Cette fonction (string ) sert à stocker du texte.
// Dans notre exemple pour les données reçues sur le port série
String valeur_recu;  


// La fonction setup () est exécutée une fois, lorsque le programme démarre. 
// Il sert à définir les propriétés d'environnement initiales telles que la 
// taille de l'écran et à charger des supports tels que des images et des polices
// au démarrage du programme. 


void setup()
{
  
  // definition de la taille de la fenetre 
  // syntaxe : size (Hauteur fenetre,largeur fenetre )
  size(1000,600); 
  
  // choix de la couleur du fond de la fenetre 
  // syntaxe : background (rouge,vert,bleu )
  // valeur du rouge de 0 à 255 iden pour les autre couleurs
  // affichage du fond en jaune 
  background(255,255,128);  
  
  
  // Ouverture du port de communication 
  // par defaut sur le systeme Windows , cela ouvre generalement
  // le port COM 1
  String nom_du_port = Serial.list()[0]; 
  // initialise la connexion série à 9600 bauds
  // IMPORTANT : régler le recepteur avec la même valeur de transmission
  // soit dans notre exemple la carte Arduino
  port_de_com = new Serial(this, nom_du_port, 9600);
  
 
 
 

}

//Le programme principal s’exécute par une boucle infinie appelée draw () 
void draw()
{
  
  
  
  
  // ---------------  Affichage du titre -----------------------
  
  // Fill : Définit la couleur utilisée pour remplir les formes.
  // fill(r,g,b);
  // r = pour rouge
  // g = pour le vert
  // b = pour le bleu
  fill(0,0,0);
   
  
  // Choix de la taille de la police 
  // syntaxe => textSize( taille )
  // Taille => La taille des caractères est en de pixels.
  textSize(32);
  
  
  // Affichage d'un texte à l'écran
  // text (texte,x,y);
  // x => coordonnée x du texte
  // y => coordonnée y du texte 
  text("Lecture des informations envoyer par Arduino", 220, 75);
  
  // ---------- Fin de l'affichage du titre -----------------------
  
  
  
  // --------- Controle du port série ----------------------------
  
  // On vérifie si les données ou informations sont disponibles 
  // sur le port série.Si oui , on exécute le code ci-dessous 
  // entre crochets   
  if ( port_de_com.available() > 0) 
  {  
    
  
  // Comme des données sont disponibles sur le port série, alors
  // on fixe celle-ci dans la variable valeur_recu 
  valeur_recu = port_de_com.readStringUntil('\n'); 
    

} 

  // --------------- fin du controle du port série ------------- 




  // ------------------- Aide a la mise au point ---------------- 

  // La fonction println () écrit sur la zone de la console 
  // (le rectangle noir en bas de l'environnement de l'écran de 
  // Processing )
  //                 ** A savoir **
  // Cette fonction est souvent utile pour vérifier le bon fonctionnement
  // du programme .Notez que la fonction est relativement lente .Elle ne
  // fonctionne bien que sur des contrôles relativement lents comme dans 
  // notre exemple. On peut donc désactiver cette ligne de code qui ne sert 
  // que pour la mise au point .
  println(valeur_recu); 
  
  // ----------- Fin de la mise au point -------------------------- 
 
  
  // ----- Affichage de valeur du compteur de la carte Arduino ---
  
  // Désactive le dessin des contours de la forme dans notre cas le 
  // rectangle 
  noStroke();
  
  // Fill : Définit la couleur utilisée pour remplir les formes.
  // dans notre exemple le rectangle
  fill(255,255,128);
  
  // On dessine 
  rect(435,259,100,20); 
  
    
  // Choix de la taille de la police 
  textSize(16);
  
  // Fill : Définit la couleur utilisée pour remplir les formes.
  // dans notre exemple le texte  
  fill(0,0,0);
  
  // Affichage d'un texte à l'écran
  // suivi de la valeur du compteur de la carte Arduino 
  text("Valeur du compteur de la carte Arduino -> "+ valeur_recu, 115, 275); 
  
  // ---- Fin du traitement de l'affichage du compteur --------- 
  
 
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

// *****************************************************

// * RedOhm *

// * *

// * Lecture d'une valeur sur la carte Arduino *

// * via le port serie *

// * *

// * code programme : AP001-P *

// * *

// * 13/08/2017 *

// * H.Mazelin *

// *****************************************************

// Cette librairie permet de communiquer avec l'Arduino

// il esn indispensable de l'installer pour communiquer

import processing.serial.*;

// Crée un objet de type myPort

Serial port_de_com;

// Declaration de la variable -> valeur_recu

// Cette fonction (string ) sert à stocker du texte.

// Dans notre exemple pour les données reçues sur le port série

String valeur_recu;

// La fonction setup () est exécutée une fois, lorsque le programme démarre.

// Il sert à définir les propriétés d'environnement initiales telles que la

// taille de l'écran et à charger des supports tels que des images et des polices

// au démarrage du programme.

void setup()

{

// definition de la taille de la fenetre

// syntaxe : size (Hauteur fenetre,largeur fenetre )

size(1000,600);

// choix de la couleur du fond de la fenetre

// syntaxe : background (rouge,vert,bleu )

// valeur du rouge de 0 à 255 iden pour les autre couleurs

// affichage du fond en jaune

background(255,255,128);

// Ouverture du port de communication

// par defaut sur le systeme Windows , cela ouvre generalement

// le port COM 1

String nom_du_port = Serial.list()[0];

// initialise la connexion série à 9600 bauds

// IMPORTANT : régler le recepteur avec la même valeur de transmission

// soit dans notre exemple la carte Arduino

port_de_com = new Serial(this, nom_du_port, 9600);

}

//Le programme principal s’exécute par une boucle infinie appelée draw ()

void draw()

{

// --------------- Affichage du titre -----------------------

// Fill : Définit la couleur utilisée pour remplir les formes.

// fill(r,g,b);

// r = pour rouge

// g = pour le vert

// b = pour le bleu

fill(0,0,0);

// Choix de la taille de la police

// syntaxe => textSize( taille )

// Taille => La taille des caractères est en de pixels.

textSize(32);

// Affichage d'un texte à l'écran

// text (texte,x,y);

// x => coordonnée x du texte

// y => coordonnée y du texte

text("Lecture des informations envoyer par Arduino", 220, 75);

// ---------- Fin de l'affichage du titre -----------------------

// --------- Controle du port série ----------------------------

// On vérifie si les données ou informations sont disponibles

// sur le port série.Si oui , on exécute le code ci-dessous

// entre crochets

if ( port_de_com.available() > 0)

{

// Comme des données sont disponibles sur le port série, alors

// on fixe celle-ci dans la variable valeur_recu

valeur_recu = port_de_com.readStringUntil('\n');

}

// --------------- fin du controle du port série -------------

// ------------------- Aide a la mise au point ----------------

// La fonction println () écrit sur la zone de la console

// (le rectangle noir en bas de l'environnement de l'écran de

// Processing )

// ** A savoir **

// Cette fonction est souvent utile pour vérifier le bon fonctionnement

// du programme .Notez que la fonction est relativement lente .Elle ne

// fonctionne bien que sur des contrôles relativement lents comme dans

// notre exemple. On peut donc désactiver cette ligne de code qui ne sert

// que pour la mise au point .

println(valeur_recu);

// ----------- Fin de la mise au point --------------------------

// ----- Affichage de valeur du compteur de la carte Arduino ---

// Désactive le dessin des contours de la forme dans notre cas le

// rectangle

noStroke();

// Fill : Définit la couleur utilisée pour remplir les formes.

// dans notre exemple le rectangle

fill(255,255,128);

// On dessine

rect(435,259,100,20);

// Choix de la taille de la police

textSize(16);

// Fill : Définit la couleur utilisée pour remplir les formes.

// dans notre exemple le texte

fill(0,0,0);

// Affichage d'un texte à l'écran

// suivi de la valeur du compteur de la carte Arduino

text("Valeur du compteur de la carte Arduino -> "+ valeur_recu, 115, 275);

// ---- Fin du traitement de l'affichage du compteur ---------

}

Retour au sommaire .

– La communication série –

Lecture de 3 valeurs sur la carte Arduino
via le port série et animation
d’un rectangle sur l’écran

–

Tutoriel : Animation d’une forme sous Processing avec utilisation de la communication série

Pour plus d’information sur la carte Arduino Mega => oui j’en besoin

Programme pour Arduino ( Version 1.8.3 )

//
//
//

/*
 * RedOhm
 * 
 * 
 * Transfert des informations du joystock vers le port de 
 * communication  
 *              
 *              
 * Le 28/08/2017
 * H.Mazelin              
 * 
 * 
 */




// Déclaration et initialisation des broches d'entrée
// Le signal de l'axe X SUR A0
int JoyStick_X = A0;
// Le signal de l'axe Y SUR A1 
int JoyStick_Y = A1; 
// L'information du bouton sur la pin 3 
int Bouton = 3; 
 

/* 
 * Un programme Arduino doit impérativement contenir cette fonction .
 * Elle ne sera exécuter une seule fois au démarrage du microcontroleur
 * Elle sert à configurer globalement les entrées sorties  
 *  
 */
 
void setup ()
{
  //le potentiometre JoyStick_X est une entrée
  pinMode (JoyStick_X, INPUT);
  //le potentiometre JoyStick_Y est une entrée
  pinMode (JoyStick_Y, INPUT);
  //l'inter Bouton est une entrée
  pinMode (Bouton, INPUT);

   
  //Cette fonction a pour but de de forcer une entrée dans un état
  //défini. Dans notre exemple nous le forçons à l’État HAUT
  digitalWrite(Bouton, HIGH);  
  //ouvre le port série et fixe le debit de communication à 9600 bauds 
  Serial.begin (9600); 
 
}


//Le programme principal s’exécute par une boucle infinie appelée Loop () 
void loop ()
{
  // Déclare des variables de type "virgule-flottante", c'est à dire des nombres 
  // à virgules. Les nombres à virgule sont souvent utilisés pour l'expression 
  // des valeurs analogiques et continues
  float x, y;
  // Déclare une variable ( etat_du_bouton )  de type int 
  int etat_du_bouton;
   
  // Lit la valeur de la tension présente sur la broche spécifiée
  // dans notre cas la valeur JoyStick_X 
  x = analogRead (JoyStick_X);
  // Lit la valeur de la tension présente sur la broche spécifiée
  // dans notre cas la valeur JoyStick_Y 
  y = analogRead (JoyStick_Y);
  // Lit l"état (= le niveau logique) d'une broche précise en entrée
  // numérique dans notre cas (bouton)
  etat_du_bouton = digitalRead (Bouton);
  

  
    // ecrit les données sur le port série
    Serial.print(x);
    Serial.print(';');
    Serial.print(y);
    Serial.print(';');
    // ecrit les données sur le port série
    // puis effectue un saut de ligne avec la fonction  Serial.println  
    Serial.println(etat_du_bouton);

  // Réalise une pause dans l'exécution du programme pour la durée
  //(en millisecondes) indiquée en paramètre.
  delay (50);
}

* RedOhm

* Transfert des informations du joystock vers le port de

* communication

* Le 28/08/2017

* H.Mazelin

// Déclaration et initialisation des broches d'entrée

// Le signal de l'axe X SUR A0

int JoyStick_X = A0;

// Le signal de l'axe Y SUR A1

int JoyStick_Y = A1;

// L'information du bouton sur la pin 3

int Bouton = 3;

* Un programme Arduino doit impérativement contenir cette fonction .

* Elle ne sera exécuter une seule fois au démarrage du microcontroleur

* Elle sert à configurer globalement les entrées sorties

void setup ()

{

//le potentiometre JoyStick_X est une entrée

pinMode (JoyStick_X, INPUT);

//le potentiometre JoyStick_Y est une entrée

pinMode (JoyStick_Y, INPUT);

//l'inter Bouton est une entrée

pinMode (Bouton, INPUT);

//Cette fonction a pour but de de forcer une entrée dans un état

//défini. Dans notre exemple nous le forçons à l’État HAUT

digitalWrite(Bouton, HIGH);

//ouvre le port série et fixe le debit de communication à 9600 bauds

Serial.begin (9600);

}

//Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop ()

{

// Déclare des variables de type "virgule-flottante", c'est à dire des nombres

// à virgules. Les nombres à virgule sont souvent utilisés pour l'expression

// des valeurs analogiques et continues

float x, y;

// Déclare une variable ( etat_du_bouton ) de type int

int etat_du_bouton;

// Lit la valeur de la tension présente sur la broche spécifiée

// dans notre cas la valeur JoyStick_X

x = analogRead (JoyStick_X);

// Lit la valeur de la tension présente sur la broche spécifiée

// dans notre cas la valeur JoyStick_Y

y = analogRead (JoyStick_Y);

// Lit l"état (= le niveau logique) d'une broche précise en entrée

// numérique dans notre cas (bouton)

etat_du_bouton = digitalRead (Bouton);

// ecrit les données sur le port série

Serial.print(x);

Serial.print(';');

Serial.print(y);

Serial.print(';');

// ecrit les données sur le port série

// puis effectue un saut de ligne avec la fonction Serial.println

Serial.println(etat_du_bouton);

// Réalise une pause dans l'exécution du programme pour la durée

//(en millisecondes) indiquée en paramètre.

delay (50);

}

Retour au sommaire .

–

Programme pour Processing ( Version 3.3.4 )

Code programme : AP002-A

Nom du programme : communication_processing_joy_ky023

//
//
//
//
//
// *********************************************************
// * RedOhm                                                *
// *                                                       *
// *    Lecture de 3 valeurs sur la carte Arduino           *
// *       via le port serie et animation                  *        
// *        d'un rectangle sur l'ecran                     *
// *                                                       *
// * code programme : AP002-A                              *
// * Nom du programme : communication_processing_joy_ky023 *
// *                                                       *
// * 28/08/2017                                            *
// * B.Benoit & H.Mazelin                                  *
// *********************************************************


// Cette librairie permet de communiquer avec l'Arduino 
// il est indispensable de l'installer pour communiquer 
import processing.serial.*;

// Definition du port cible, en minuscules.
static String ARDUINO_PORT = "com15";

// Crée un objet de type myPort
Serial myPort;  

// Variable pour les données reçues sur le port serie
String message;

// Fonction permettant de vérifier l'existence du port cible souhaité.
boolean checkSerialPort(final String targetPort) {
  // Récupération de la liste des ports disponibles.
  final String[] serialPortList = Serial.list();
  // Itération sur chacun de ces ports.
  for (int i=0; i < serialPortList.length; i++)
    // Comparaison du nom du port (en minuscules), avec le port cible. 
    if (serialPortList[i].toLowerCase().equals(targetPort))
      return true;

  // Le port n'a pas été trouvé !
  return false;
}

void setup()
{
   
  // Fixe la taille de la fenêtre graphique en pixels (100x100 par défaut)
  // pour les parametre longeur , hauteur 
  // et fixe le mode graphique  cette commande est optionnel
  size(1000, 600, P3D);
 
  // Verification de l'existence du port cible.
  if (!checkSerialPort(ARDUINO_PORT)) {
    println("Impossible de trouver le port '" + ARDUINO_PORT + "'. Veuillez vérifier la configuration et la bonne connexion.");
    // Demande de sortie (différée) du programme.
    exit();
    // Sortie immédiate du setup().
    return;
  }
  
  // Initialisation concrète du port sur lequel communiquer avec l'Arduino.
  println("Initialisation du port '" + ARDUINO_PORT + "'.");
  myPort = new Serial(this, ARDUINO_PORT, 9600);
  myPort.bufferUntil('\n');
}

void draw()
{
  // Vérification de la disponibilité du port initialisé.
  if (myPort.available() > 0) 
  {
    // Récupération des prochaines valeurs lissées.
    float[] averageValues = getAverageValues(1);
    
    // Convertion des valeurs reçues depuis le Joystick.
    // La valeur brute 1 va être utilisée sur l'axe Y.
    // La valeur brute 2 va être utilisée sur l'axe X.
    // La troisième valeur correspond à l'état du bouton du Joystick
    //   => 1 = bouton NON pressé (valeur par défaut), 0 = bouton pressé
    float valeurBrute1 = averageValues[0];
    float valeurBrute2 = averageValues[1];
    boolean etatBouton = !(averageValues[2] == 1);
    
    // Mapping des valeurs en angle (exprimé en degré).
    // La plage de valeurs du Joystick est de 0 à 1023.
    float x = map(valeurBrute2, 0, 1023, 0, 360);
    float y = map(valeurBrute1, 0, 1023, 0, 360);
    
    // Si le bouton est pressé, on allume une lumière, et active un effet de zoom.
    if (etatBouton) {
      lights();
      //scale(1.1);
    }
    
   

    // Positionnement par défaut de l'affichage.
    background(0);
    translate(width/2, height/2);

    // Ajout d'un offset, pour que la position de départ soit celle d'une boite posée sur une surface plane.
    // Cela est variable et à ajuster en fonction du matériel utilisé (ici Joystick).
    x += 90;
    y -= 174;

    rotateX(radians(x));
    rotateY(radians(y));
    rotateZ(radians(90));

    // Remplissage de la boîte d'une couleur différente selon l'état du bouton du Joystick.
    if (etatBouton)
      fill(255,0,0);
    else
      fill(128,128,128);
    
    stroke(255);
    box(80,240,20);
  }
}



// *************************** creation de la fonction ********************************
//
// fixe un nombre pour un eventuel lissage 
// Controle du format 
// convertion en entier 
// Envoie des 3 valeurs, sous la forme d'un tableau.



float[] getAverageValues(int measureCount) {
  int iterationCount = measureCount;
  float valeurBrute1 = 0.0, valeurBrute2 = 0.0, etatBouton = 0.0;
  
  // Boucle jusqu'à ce que l'on obtienne le nombre de mesures demandées
  // (en ne prenant pas en compte tous les problèmes de format, de convertion 
  // en entiers ...).
  while (true) {
    // Lecture du prochain message disponible.
    message = myPort.readStringUntil('\n');
    // Vérification : on s'assure qu'un message AVEC fin de ligne est bien disponible
    // sur le port,sinon on ne fait rien de plus dans cette exécution de draw().
    // L'exécution suivante prendra en charge les messages en attente.
    if (message == null)
      continue;
    
    
    
    // Décodage du message reçu; il doit impérativement respecter le format : x;y
    final String[] values = message.split(";");
    if (values.length != 3) {
     println("Le message suivant ne respecte pas le format attendu (x;y): " + message);
     continue;
    }

    // Convertion des valeurs reçues en entiers (en gérant le cas où l'une des
    // valeurs n'est pas un entier).
    try {
      float nextvaleurBrute1 = Float.parseFloat(values[0].trim());
      float nextvaleurBrute2 = Float.parseFloat(values[1].trim());
      float nextetatBouton = Float.parseFloat(values[2].trim());
    
      // Prise en compte de ces nouvelles valeurs (pour le moment, on somme toutes les valeurs).
      valeurBrute1 += nextvaleurBrute1;
      valeurBrute2 += nextvaleurBrute2;
      etatBouton += nextetatBouton;
    } catch(NumberFormatException e) {
       // Affichage d'un message d'erreur. 
       println("Impossible de convertir l'une des valeurs en entier ... le message suivant est donc totalement ignoré : " + message);
       e.printStackTrace();
       continue; 
    }

    // Arrivé ici, on a la certitude d'avoir bien reçu et pris en compte une
    // nouvelle valeur, au bon format.C'est ici que l'on gère le nombre d'itération,
    // et la condition d'arrêt de la boucle infinie (while(true)). 
    if (--iterationCount <= 0)
      break;
  }
  
  // Envoie des 3 valeurs lissées, sous la forme d'un tableau.
  return new float[]{valeurBrute1/measureCount, valeurBrute2/measureCount, etatBouton/measureCount};
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

// *********************************************************

// * RedOhm *

// * *

// * Lecture de 3 valeurs sur la carte Arduino *

// * via le port serie et animation *

// * d'un rectangle sur l'ecran *

// * *

// * code programme : AP002-A *

// * Nom du programme : communication_processing_joy_ky023 *

// * *

// * 28/08/2017 *

// * B.Benoit & H.Mazelin *

// *********************************************************

// Cette librairie permet de communiquer avec l'Arduino

// il est indispensable de l'installer pour communiquer

import processing.serial.*;

// Definition du port cible, en minuscules.

static String ARDUINO_PORT = "com15";

// Crée un objet de type myPort

Serial myPort;

// Variable pour les données reçues sur le port serie

String message;

// Fonction permettant de vérifier l'existence du port cible souhaité.

boolean checkSerialPort(final String targetPort) {

// Récupération de la liste des ports disponibles.

final String[] serialPortList = Serial.list();

// Itération sur chacun de ces ports.

for (int i=0; i < serialPortList.length; i++)

// Comparaison du nom du port (en minuscules), avec le port cible.

if (serialPortList[i].toLowerCase().equals(targetPort))

return true;

// Le port n'a pas été trouvé !

return false;

}

void setup()

{

// Fixe la taille de la fenêtre graphique en pixels (100x100 par défaut)

// pour les parametre longeur , hauteur

// et fixe le mode graphique cette commande est optionnel

size(1000, 600, P3D);

// Verification de l'existence du port cible.

if (!checkSerialPort(ARDUINO_PORT)) {

println("Impossible de trouver le port '" + ARDUINO_PORT + "'. Veuillez vérifier la configuration et la bonne connexion.");

// Demande de sortie (différée) du programme.

exit();

// Sortie immédiate du setup().

return;

}

// Initialisation concrète du port sur lequel communiquer avec l'Arduino.

println("Initialisation du port '" + ARDUINO_PORT + "'.");

myPort = new Serial(this, ARDUINO_PORT, 9600);

myPort.bufferUntil('\n');

}

void draw()

{

// Vérification de la disponibilité du port initialisé.

if (myPort.available() > 0)

{

// Récupération des prochaines valeurs lissées.

float[] averageValues = getAverageValues(1);

// Convertion des valeurs reçues depuis le Joystick.

// La valeur brute 1 va être utilisée sur l'axe Y.

// La valeur brute 2 va être utilisée sur l'axe X.

// La troisième valeur correspond à l'état du bouton du Joystick

// => 1 = bouton NON pressé (valeur par défaut), 0 = bouton pressé

float valeurBrute1 = averageValues[0];

float valeurBrute2 = averageValues[1];

boolean etatBouton = !(averageValues[2] == 1);

// Mapping des valeurs en angle (exprimé en degré).

// La plage de valeurs du Joystick est de 0 à 1023.

float x = map(valeurBrute2, 0, 1023, 0, 360);

float y = map(valeurBrute1, 0, 1023, 0, 360);

// Si le bouton est pressé, on allume une lumière, et active un effet de zoom.

if (etatBouton) {

lights();

//scale(1.1);

}

// Positionnement par défaut de l'affichage.

background(0);

translate(width/2, height/2);

// Ajout d'un offset, pour que la position de départ soit celle d'une boite posée sur une surface plane.

// Cela est variable et à ajuster en fonction du matériel utilisé (ici Joystick).

x += 90;

y -= 174;

rotateX(radians(x));

rotateY(radians(y));

rotateZ(radians(90));

// Remplissage de la boîte d'une couleur différente selon l'état du bouton du Joystick.

if (etatBouton)

fill(255,0,0);

else

fill(128,128,128);

stroke(255);

box(80,240,20);

}

// *************************** creation de la fonction ********************************

// fixe un nombre pour un eventuel lissage

// Controle du format

// convertion en entier

// Envoie des 3 valeurs, sous la forme d'un tableau.

float[] getAverageValues(int measureCount) {

int iterationCount = measureCount;

float valeurBrute1 = 0.0, valeurBrute2 = 0.0, etatBouton = 0.0;

// Boucle jusqu'à ce que l'on obtienne le nombre de mesures demandées

// (en ne prenant pas en compte tous les problèmes de format, de convertion

// en entiers ...).

while (true) {

// Lecture du prochain message disponible.

message = myPort.readStringUntil('\n');

// Vérification : on s'assure qu'un message AVEC fin de ligne est bien disponible

// sur le port,sinon on ne fait rien de plus dans cette exécution de draw().

// L'exécution suivante prendra en charge les messages en attente.

if (message == null)

continue;

// Décodage du message reçu; il doit impérativement respecter le format : x;y

final String[] values = message.split(";");

if (values.length != 3) {

println("Le message suivant ne respecte pas le format attendu (x;y): " + message);

continue;

}

// Convertion des valeurs reçues en entiers (en gérant le cas où l'une des

// valeurs n'est pas un entier).

try {

float nextvaleurBrute1 = Float.parseFloat(values[0].trim());

float nextvaleurBrute2 = Float.parseFloat(values[1].trim());

float nextetatBouton = Float.parseFloat(values[2].trim());

// Prise en compte de ces nouvelles valeurs (pour le moment, on somme toutes les valeurs).

valeurBrute1 += nextvaleurBrute1;

valeurBrute2 += nextvaleurBrute2;

etatBouton += nextetatBouton;

} catch(NumberFormatException e) {

// Affichage d'un message d'erreur.

println("Impossible de convertir l'une des valeurs en entier ... le message suivant est donc totalement ignoré : " + message);

e.printStackTrace();

continue;

}

// Arrivé ici, on a la certitude d'avoir bien reçu et pris en compte une

// nouvelle valeur, au bon format.C'est ici que l'on gère le nombre d'itération,

// et la condition d'arrêt de la boucle infinie (while(true)).

if (--iterationCount <= 0)

break;

}

// Envoie des 3 valeurs lissées, sous la forme d'un tableau.

return new float[]{valeurBrute1/measureCount, valeurBrute2/measureCount, etatBouton/measureCount};

}

Retour au sommaire .