Archives par étiquette : joystick

Sommaire :

Communication en bluetooth d’une tablette vers Arduino
Mit Inventor création d’un controlPad
Mit inventor, le capteur d’orientation ( en cours )
2023-01-08 : Contrôler votre Smartphone avec le capteur de luminosité
2022-11-05 : 1/5 – Mit inventor creation d’un joystick analogique pour Arduino
2023-01-19 : 2/5 – Mit inventor un joystick analogique pour Arduino ,decryptage de la chaine de positionnnement .
2022-09-16 : Mit inventor le changement de page
Retour au menu Vidéo

Communication en bluetooth d’une tablette vers Arduino
avec Mit Inventor

Mise à jour le 08/10/2022.

Dans ce tuto ,nous allons travailler sur la communication entre une tablette sous Android et une carte Arduino équipée d’une carte bluetooth de type HC06

Nous allons donc étudier la partie interface sous Mit App Inventor pour la tablette et le traitement des informations avec l’ide Arduino

télécharger les fichiers . Retour au sommaire

Mit Inventor création d’un controlPad

Mise à jour 11/10/2022.

Cette vidéo est un tutoriel pratique détaillant la création d’une interface de contrôle pour piloter un robot mobile via une carte Arduino, utilisable sur tablette ou smartphone. Elle débute par une présentation générale du projet , suivie d’une session sur la réalisation de l’interface utilisateur avec le Designer dans MIT App Inventor . La majeure partie de la vidéo se concentre sur la programmation des blocs dans MIT App Inventor, illustrant comment les différents éléments de l’interface peuvent être programmés pour contrôler le robot. Le tutoriel se conclut avec un essai pratique du système et une conclusion , offrant une démonstration concrète de l’application en action et résumant les points clés appris.

télécharger les fichiers Retour au sommaire

2023-01-08- Mit inventor contrôler votre Smartphone avec le capteur de luminosité

Dans ce tutoriel, nous allons étudier sur Mit Inventor comment contrôler votre smartphone avec le capteur de luminosité ou bien retranscrire ces informations vers votre carte Arduino ou tout autre carte microcontrôleur. Avec ce type de capteur, nous pouvons créer un luxmètre ou d’autres applications qui réagissent avec la lumière. On peut bien évidemment s’en servir aussi comme capteur de proximité

télécharger les fichiers Retour au sommaire

2022-11-05- Mit inventor creation d’un joystick analogique pour
Arduino – 1/5

Dans ce tutoriel nous allons étudier sur Mit Inventor comment créer un joystick analogique sur votre tablette ou sur un smartphone afin de pouvoir piloter en Bluetooth une unité mobile avec la carte microcontrôleur Arduino. Vous aurez donc un ensemble de 5 tutoriels traitant de ce type de pilotage.

télécharger les fichiers Retour au sommaire

2023-01-19- Mit inventor un joystick analogique pour Arduino decryptage de la chaine de positionnnement 2/5

Dans ce tutoriel, nous allons étudier comment décrypter une chaîne de caractères de type String envoyé par Bluetooth depuis votre smartphone ou votre tablette vers arduino. Cette chaîne sera donc décryptée par arduino pour extraire les valeurs x et y de déplacement du joystick virtuel de votre application nous permettant de piloter un robot mobile , une plateforme ou tout autre objet qui peut être piloté . Cette vidéo nous permet de mettre en lumière les fonctions ou les méthodes à utiliser comme indexOf , concat ,substring.

Retour au sommaire

2022-09-16- Mit inventor le changement de page

Vous trouverez dans cette vidéo les informations nécessaires pour la création de plusieurs pages sur Mit Inventor et surtout la possibilité de naviguer entre elle.

Mit App Inventor est un soft pour la création d’applications pour toutes les plateformes basées sur Microsoft , qui évite le langage complexe de codage en bloc de construction visuelle par glisser-déposer.

Retour au sommaire

L3-37 : Tutoriel pour la version Dynamixel

Sommaire :

Matériel utile pour suivre les tutoriels
Modification de l’identifiant du servo
Etude des deplacements de la tête avec les servo Dynamixel
Pilotage d’un Dynamixel par le biais d’un potentiometre
Retour au menu

Matériel utile pour suivre les tutoriels

ArbotiX-M Robocontroller

Spécifications techniques du Robocontroller ArbotiX-M :

Microcontrôleur AVR 16 MHz (ATMEGA644p).
2 ports série, 1 dédié aux servo-contrôleurs Dynamixel, l’autre au module radio Xbee.
32 E / S, dont 8 peuvent fonctionner comme entrées analogiques.
Embases servo 3 broches (Gnd, Vcc, signal), sur les 8 entrées analogiques et sur les 8 E / S numériques.
Deux pilotes de moteur 1 A avec en-têtes moteur / encodeur combinés.
Module radio Xbee vendu séparément. Une installation typique nécessite 2 modules radio Xbee et un module explorateur Xbee pour vous permettre de contrôler votre robot à distance depuis votre ordinateur.
Ce contrôleur nécessite l’utilisation d’un câble FTDI ou ISP. Nous recommandons la carte de déploiement FTDI 3,3 V avec connecteur à 6 broches.
Avec des dimensions de 7,11 × 7,11 cm (2,8 « × 2,8 »), ce contrôleur a été conçu pour être utilisé avec les servomoteurs Dynamixel .

Ressources pour le Robocontroller ArbotiX-M

Le Robocontroller ArbotiX-M peut être utilisé avec l’environnement de développement Arduino. Un certain nombre de bibliothèques permettant de contrôler les servomoteurs AX-12 sont disponibles dans la liste de téléchargement ci-dessous.

Module joystick Gravity DFR0061

Module joystick Gravity DFRobot basé sur 2 potentiomètres (axes X et Y) et d’un bouton-poussoir pour des applications spécifiques. Il délivre deux sorties analogiques en fonction de la position des deux potentiomètres et une sortie logique en fonction du bouton-poussoir. Il est livré avec 3 cordons.

Alimentation : 5 Vcc
Sorties : 2 analogiques et 1 digitale
Dimensions : 37 x 32 x 25 mm

Référence DFRobot: DFR0061

Remarque: la nouvelle version du mappage des broches du port du capteur analogique a été modifiée comme ci-dessous :

Mappage du Joystik

Retour en haut de page

Etude des deplacements de la tête avec les servo Dynamixel

Materiel utile pour le tuto :

Un module ArbotiX-M Robocontroller

Nous allons vous initiez à lire les registres se trouvant à l’intérieur du servomoteur qui nous permet de définir le déplacement de notre servo , ceci afin de déterminer la butée basse et haute que l’on devra appliquer par logiciel pour les mouvements de la tête.

Pour pouvoir lire ses registres, il faut déverrouiller le couple afin pouvoir déplacer la base de la tête de L3 -37 manuellement Avant de se lancer dans l’explication du programme, nous allons vous faire une démonstration du déverrouillage et de la lecture des registres de déplacement par le biai du tuto ci-dessous .

Programme :

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Mesure de deplacement des moteurs dynamixel
//*  et verouillage du couple 
//*       
//* H-Mazelin
//* 29/10/2020
//*
//*************************************************************



//librairie qui permet d'implémentez le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>

//Cette librairies vous permet interagir avec les servos AX et MX  
#include <BioloidController.h>


// definition de la vitesse de transmission 
// le debit en bauds détermine la vitesse de communication serie entre 
// le controleur et le servo Dynamixel
BioloidController bioloid = BioloidController(1000000);


 
/*
 *  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 ()

{

 //ouvre le port série et fixe le debit de communication à 9600 bauds
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  delay(5000);
  // Information a l'operateur de l'ouverture du port de communication 
  // sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================");   

  // Lecture de la temperature du servo de droite actuel
  int temperature_d =ax12GetRegister(2,43,1);
  // Lecture de la temperature du servo de gauche actuel
  int temperature_g =ax12GetRegister(3,43,1);
  
  
  // Affichage de la lecture des registres contenant la temperature 
  Serial.print("Temperature du servo de droite : ");
   Serial.print(temperature_d);Serial.println(" Degres");    
  Serial.print("Temperature du servo de gauche : ");
   Serial.print(temperature_g);Serial.println(" Degres"); 
  Serial.print(" "); 
   Serial.println("Demarrage *********************");
  
// Procedure d'ecriture dans le registre 24 pour desactiver le couple 
//
// modification de la valeur 1 par la valeur 0
// 1 parametre : numero d'identifiant du servo
// 2 parametre : numero de registre a modifier 
// 3 parametre : Active ou desactive le couple 

 ax12SetRegister(2,24,0); 
  ax12SetRegister(3,24,0);
 Serial.println("Couple desactive sur le moteur de droite et de gauche");  
 
  
}

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

{ 

// Procedure de lecture pour la position du servo dans le registre 36
//
//
// 1 parametre : numero d'identifiant du servo
// 2 parametre : numero de registre a lire 
// 3 parametre : nombre d'octet a lire 

 int deplacement_d =ax12GetRegister(2,36,2);
  int deplacement_g =ax12GetRegister(3,36,2);
  
// Affichage de la lecture des registres contenant le deplacement 
 Serial.print("Deplacement du moteur de gauche : ");
  Serial.print(deplacement_g);Serial.print(" en points      "); 
   Serial.print("Deplacement du moteur de droite : ");
    Serial.print(deplacement_d);Serial.println(" en points      ");  
}

100

101

102

103

104

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

//*

//* IDE Arduino 1.0.6

//*

//* Mesure de deplacement des moteurs dynamixel

//* et verouillage du couple

//*

//* H-Mazelin

//* 29/10/2020

//*

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

//librairie qui permet d'implémentez le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

//Cette librairies vous permet interagir avec les servos AX et MX

#include <BioloidController.h>

// definition de la vitesse de transmission

// le debit en bauds détermine la vitesse de communication serie entre

// le controleur et le servo Dynamixel

BioloidController bioloid = BioloidController(1000000);

* 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 ()

{

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

Serial.begin(9600);

// on attent que le port de communication soit pret

delay(5000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

Serial.println("========================================");

Serial.println("Communication etablie");

Serial.println("========================================");

// Lecture de la temperature du servo de droite actuel

int temperature_d =ax12GetRegister(2,43,1);

// Lecture de la temperature du servo de gauche actuel

int temperature_g =ax12GetRegister(3,43,1);

// Affichage de la lecture des registres contenant la temperature

Serial.print("Temperature du servo de droite : ");

Serial.print(temperature_d);Serial.println(" Degres");

Serial.print("Temperature du servo de gauche : ");

Serial.print(temperature_g);Serial.println(" Degres");

Serial.print(" ");

Serial.println("Demarrage *********************");

// Procedure d'ecriture dans le registre 24 pour desactiver le couple

// modification de la valeur 1 par la valeur 0

// 1 parametre : numero d'identifiant du servo

// 2 parametre : numero de registre a modifier

// 3 parametre : Active ou desactive le couple

ax12SetRegister(2,24,0);

ax12SetRegister(3,24,0);

Serial.println("Couple desactive sur le moteur de droite et de gauche");

}

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

void loop()

{

// Procedure de lecture pour la position du servo dans le registre 36

// 1 parametre : numero d'identifiant du servo

// 2 parametre : numero de registre a lire

// 3 parametre : nombre d'octet a lire

int deplacement_d =ax12GetRegister(2,36,2);

int deplacement_g =ax12GetRegister(3,36,2);

// Affichage de la lecture des registres contenant le deplacement

Serial.print("Deplacement du moteur de gauche : ");

Serial.print(deplacement_g);Serial.print(" en points ");

Serial.print("Deplacement du moteur de droite : ");

Serial.print(deplacement_d);Serial.println(" en points ");

}

Retour en haut de page

Pilotage d’un Dynamixel par le biais d’un potentiometre

Ce tutoriel a pour but de vous initier à la programmation des servomoteurs Dynamixel . Nous avons pris comme base la tête de L3 -37 qui est une réalisation de RedOhm pour vous expliquer l’étalonnage et le fonctionnement pour piloter celle-ci avec un joystick. Le tuto s’articule en 4 phases :
la première étant la présentation de la base de la tête, le câblage d’un joystick et la carte contrôleur, vous avez aussi une explication sur le fonctionnement de la manette de jeu, et enfin une explication détaillée du programme.

Materiel utile pour le tuto :

Un module ArbotiX-M Robocontroller
Module joystick Gravity DFR0061

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Exemple de pilotage d'un servo Dynamixel
//*  avec un joystick pour la tete de L3-37
//*       
//* H-Mazelin
//* 16/11/2020
//*
//*************************************************************



//librairie qui permet d'implémenter le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>

//Cette librairie vous permet interagir avec les servos AX et MX  
#include <BioloidController.h>

// definition de la vitesse de transmission 
// le debit en bauds détermine la vitesse de communication serie entre 
// le controleur et le servo Dynamixel
BioloidController bioloid = BioloidController(1000000);

// broche sur lequel est branche le potentiometre
const int broche1 = A1;
const int broche7 = A7;

// variable contenant la valeur du potentiometre 
int valeurPotar1 = 0;
 int valeurPotar7 = 0;   
// valeur du potentiometre remis a l'echelle
int valeurPotar7_re = 0;
 int valeurPotar1_re= 0;
 
 
/*
 *  Un programme Arduino doit impérativement contenir cette fonction 
 *  Elle ne sera exécutee 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);
 // on attent que le port de communication soit pret
  delay(5000);
// Information a l'operateur de l'ouverture du port de communication 
// sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================");   

// Lecture de la temperature du servo de droite actuel
  int temperature_d =ax12GetRegister(2,43,1);
// Lecture de la temperature du servo de gauche actuel
  int temperature_g =ax12GetRegister(3,43,1);
  
  
// Affichage de la lecture des registres contenant la temperature 
Serial.print("Temperature du servo de droite : ");
 Serial.print(temperature_d);Serial.println(" Degres");    
  Serial.print("Temperature du servo de gauche : ");
   Serial.print(temperature_g);Serial.println(" Degres"); 
  Serial.print(" "); 
   Serial.println("Demarrage *********************"); 
}

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

{ 
// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeurPotar1=analogRead( broche1);
   valeurPotar7=analogRead( broche7);
// mise a l'échelle (valeur entre 0 et 300
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeurPotar7_re = map( valeurPotar7,0,1023,0,350);
   valeurPotar1_re = map( valeurPotar1,0,1023,0,350);


// Affichage de la valeur des potentiometre  
Serial.print("A7 - deplacement en x du potentiometre x -> ");
 Serial.println(valeurPotar7);
  Serial.print("A1 - deplacement en y du potentiometre x -> ");
   Serial.println(valeurPotar1);
// Affichage de la valeur re-etalonne des potentiometre  
Serial.print("A7 - Re-etalonne le deplacement en x du potentiometre -> ");
 Serial.println(valeurPotar7_re);
  Serial.print("A7 - Re-etalonne le deplacement en y du potentiometre -> ");
   Serial.println(valeurPotar1_re);
      


// envoie l'information de deplacement au servomoteur dynamixel340
   SetPosition(2,340+valeurPotar7_re);
// envoie l'information de deplacement au servomoteur dynamixel
// moteur de gauche   
   SetPosition(3,340+valeurPotar1_re); 


// Affichage du code pour le moteur x avec le calcul
Serial.print("Valeur de la position du moteur x => SetPosition(3,340+");
 Serial.print(valeurPotar7_re);
  Serial.println(");");
   Serial.print("Valeur du deplacement de moteur x => ");
    Serial.println(340 + valeurPotar7_re) ;
   
Serial.println("");
 Serial.print("Valeur de la position du moteur y => SetPosition(3,340+");
  Serial.print(valeurPotar1_re);
   Serial.println(");");
    Serial.print("Valeur du deplacement de moteur y => ");
     Serial.println(340 + valeurPotar1_re) ;  
  
   Serial.println("------------------");
   delay (100);
}

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

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

//*

//* IDE Arduino 1.0.6

//*

//* Exemple de pilotage d'un servo Dynamixel

//* avec un joystick pour la tete de L3-37

//*

//* H-Mazelin

//* 16/11/2020

//*

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

//librairie qui permet d'implémenter le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

//Cette librairie vous permet interagir avec les servos AX et MX

#include <BioloidController.h>

// definition de la vitesse de transmission

// le debit en bauds détermine la vitesse de communication serie entre

// le controleur et le servo Dynamixel

BioloidController bioloid = BioloidController(1000000);

// broche sur lequel est branche le potentiometre

const int broche1 = A1;

const int broche7 = A7;

// variable contenant la valeur du potentiometre

int valeurPotar1 = 0;

int valeurPotar7 = 0;

// valeur du potentiometre remis a l'echelle

int valeurPotar7_re = 0;

int valeurPotar1_re= 0;

* Un programme Arduino doit impérativement contenir cette fonction

* Elle ne sera exécutee 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);

// on attent que le port de communication soit pret

delay(5000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

Serial.println("========================================");

Serial.println("Communication etablie");

Serial.println("========================================");

// Lecture de la temperature du servo de droite actuel

int temperature_d =ax12GetRegister(2,43,1);

// Lecture de la temperature du servo de gauche actuel

int temperature_g =ax12GetRegister(3,43,1);

// Affichage de la lecture des registres contenant la temperature

Serial.print("Temperature du servo de droite : ");

Serial.print(temperature_d);Serial.println(" Degres");

Serial.print("Temperature du servo de gauche : ");

Serial.print(temperature_g);Serial.println(" Degres");

Serial.print(" ");

Serial.println("Demarrage *********************");

}

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

void loop()

{

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeurPotar1=analogRead( broche1);

valeurPotar7=analogRead( broche7);

// mise a l'échelle (valeur entre 0 et 300

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeurPotar7_re = map( valeurPotar7,0,1023,0,350);

valeurPotar1_re = map( valeurPotar1,0,1023,0,350);

// Affichage de la valeur des potentiometre

Serial.print("A7 - deplacement en x du potentiometre x -> ");

Serial.println(valeurPotar7);

Serial.print("A1 - deplacement en y du potentiometre x -> ");

Serial.println(valeurPotar1);

// Affichage de la valeur re-etalonne des potentiometre

Serial.print("A7 - Re-etalonne le deplacement en x du potentiometre -> ");

Serial.println(valeurPotar7_re);

Serial.print("A7 - Re-etalonne le deplacement en y du potentiometre -> ");

Serial.println(valeurPotar1_re);

// envoie l'information de deplacement au servomoteur dynamixel340

SetPosition(2,340+valeurPotar7_re);

// envoie l'information de deplacement au servomoteur dynamixel

// moteur de gauche

SetPosition(3,340+valeurPotar1_re);

// Affichage du code pour le moteur x avec le calcul

Serial.print("Valeur de la position du moteur x => SetPosition(3,340+");

Serial.print(valeurPotar7_re);

Serial.println(");");

Serial.print("Valeur du deplacement de moteur x => ");

Serial.println(340 + valeurPotar7_re) ;

Serial.println("");

Serial.print("Valeur de la position du moteur y => SetPosition(3,340+");

Serial.print(valeurPotar1_re);

Serial.println(");");

Serial.print("Valeur du deplacement de moteur y => ");

Serial.println(340 + valeurPotar1_re) ;

Serial.println("------------------");

delay (100);

}

Retour en haut de page

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 .

Système DFRobot

–

Mise à jour le 11/09/2021 : Dans cet article vous trouverez une partie du matériel DFRobot que RedOhm utilise pour ses applications , avec la documentation , les schémas , les programmes ;

Continuer la lecture →