Sciences de l'ingénieur

Pilotage d'un servo par clavier (flèche haut et bas)
http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertServoControlePositionClavierPC

ARDUINO

// --- Programme Arduino ---
// par X. HINAULT - 02/2010 
// www.mon-club-elec.fr 

// --- Que fait ce programme ? ---
/* Positionne un servomoteur à l'aide du clavier du PC - 10 positions
Utilise une interface processing de visualisation côté PC. 

L'appui sur les touches HAUT/BAS incrémente/décrémente une variable processing
La valeur (de 0 à 9) est envoyée vers l'Arduino

Lorsqu'un caractère est reçu,
la position est calculée et le servomoteur est positionné

*/

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

// --- Circuit à réaliser ---
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)  
// Connecter  sur la broche 2 (configurée en sortie)  la broche de commande d'un servomoteur.  la broche de commande d'un servomoteur. 
// Connecter les servomoteurs sur les broches de commandes utilisées

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

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

#include <Servo.h> // librairie pour servomoteur

// --- Déclaration des constantes ---
const int POS_MIN=550; // largeur impulsion pour position 0° servomoteur 
                       // POS_MIN=550 pour futaba S3003 
const int POS_MAX=2330; // largeur impulsion pour position 180° servomoteur
                                                 // POS_MAS=2330 pour futaba s3003

// --- constantes des broches ---

const int broche_servo=2; //declaration constante de broche 

// --- Déclaration des variables globales ---
// variable position du servomoteur en degré
int position_servo=0; 

// variable de stockage des valeurs reçues
int OctetReception=0; 

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---
Servo mon_servo;  // crée un objet servo pour contrôler le servomoteur


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

mon_servo.attach(broche_servo, POS_MIN, POS_MAX);  // attache l'objet servo à la broche de commande du servomoteur

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

pinMode(broche_servo, OUTPUT); //met la broche en sortie 

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


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

// ------- position initiale du servomoteur 
mon_servo.write(position_servo);
delay(200);

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

if (Serial.available()>0) { // si un octet en réception

  OctetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable 
  OctetReception=OctetReception-48; // isole valeur numerique 0-9 à partir valeur ASCII

  // calcule la nouvelle position 
  position_servo=map(OctetReception,0,9,0,180);

  //positionne le servomoteur 
  mon_servo.write(position_servo);


  //entre chaque changement de position 
  delay (200); 

}// fin gestion octet en réception

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

// --- Fin programme ---

PROCESSING (à coller sous processing)

// programme Processing 
// par X. HINAULT - 02/2010 
// www.mon-club-elec.fr 

// Interface Vumètre réglable par clavier HAUT/BAS et envoi série vers arduino valeur 0-9

// inclusion librairies utilisées 
import processing.serial.*; // importe la librairie série processing


// déclaration variables 

//--- variables utiles tracé vumètre 

float Y_ref=220; // ordonnée de ligne de référence dessin rectangle

float largeur=50;
float hauteur=180; //180 représente 100% (0 à 9 = 10 positions)

int SendValue=0; // valeur envoyée à Arduino 
float niveau=0.0; // 0% au départ

Serial MySerialPort; // variable désignant le port série


void setup(){ // fonction d'initialisation exécutée 1 fois au démarrage

  size(100,250); //dimensionne la fenêtre processing à 200x200 (largeur x hauteur) // 1ère instruction de Setup
  // si Size() oublié => fenêtre 100x100 par défaut -- 

  //---- initialisation port série --- 

  println(Serial.list()); // liste et affiche tous les ports disponibles

  // Open whatever port is the one you're using.
   MySerialPort = new Serial(this, Serial.list()[1], 115200); // vérifier si c'est le bon port qui est utilisé
   delay (100); // pause   

  background (255,255,255); // fixe la couleur du fond - format RGB 
  stroke(255,0,0); // fixe la couleur du trait de dessin et bordure - format RGB 
  //nostroke(); // Désactive trait de dessin et bordure

  // dessin des 2 rectangles du niveau de démmarrage (=50%)
  stroke (0); // trait de contour 
  fill(255,255,255); // remplissage 
  rect (10,Y_ref-hauteur,largeur, hauteur); // trace un rectangle de hauteur voulue 
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

  stroke (255,0,0); // trait de contour 
  fill(255,0,0); // remplissage rouge
  rect (10,Y_ref-niveau,largeur, niveau); // trace un rectangle de hauteur voulue 
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

  //----- initialisation valeur série ---- 
  MySerialPort.write(48);   // valeur initiale 0+ 48 pour format ASCII
  delay (100); // pause   
}

void  draw() { // fonction exécutée en boucle 

  //--- nb : la vitesse de rafraîchissement de l'écran est de 60 par seconde apr défaut  - cf frameRate()

}

// fonction de gestion des évènements 

//----- clavier --------

 void keyPressed() {// cette fonction est exécutée quand un touche est appuyée... 

if (key == CODED) { // si appui d'une touche particulière (les touches spéciales up, down, etc.. cf Keycode)

    if (keyCode == UP) { // si touche Haut appuyée

      niveau=niveau+(hauteur/9); // /9 pour avoir 10 niveaux
      if (niveau>=hauteur)niveau=hauteur; // ne pas dépasser hauteur

      SendValue=SendValue+1; // incrémente SendValue 
      if (SendValue >=9) SendValue=9; // Empêche débordement variable SendValue

      MySerialPort.write(SendValue+48);   // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9 
      delay (100); // pause   
    } 
    else if (keyCode == DOWN) {// si touche BAS appuyée 

    niveau=niveau-(hauteur/9); // /9 pour avoir 10 niveaux
    if (niveau<=0)niveau=0; // ne pas dépasser 0

     SendValue=SendValue-1; // décrémente SendValue 
      if (SendValue<=0) SendValue=0;// ne pas dépasser 0

      MySerialPort.write(SendValue+48);   // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9
      delay (100); // pause   

    } 

} // fin if key==coded

// dessin des 2 rectangles du niveau 
  stroke(0); // contour noir
  fill(255,255,255); // remplissage blanc
  rect (10,Y_ref-hauteur,largeur, hauteur); // trace un rectangle de hauteur voulue 
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

   stroke(255,0,0); // contour rouge
  fill(255,0,0); // remplissage rouge
  rect (10,Y_ref-niveau,largeur, niveau); // trace un rectangle de hauteur voulue 
//à partir du point x,y (rect(x,y,larg,haut)) en se basant sur ordonnée de référence

}

//------- souris -------
//void mousePressed() { // est appelée à chaque fois qu'un bouton de la souris est appuyé

//  }

//------- gestion du port Série ------

 //void serialEvent (Serial myPort) {



 // }  // fin gestion port série 

// --- Programme Arduino ---
// par X. HINAULT - 01/2010 

// --- Que fait ce programme ? ---
/* Test de la position d'un servomoteur par saisie directe de la largeur d'impulsion dans le Terminal côté PC*/

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

// --- Circuit à réaliser ---
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1) 
// Connecter Broche de commande d'un Servomoteur sur la broche 2 (configurée en sortie)

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

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

#include <Servo.h> // librairie pour servomoteur

// --- Déclaration des constantes ---

// --- constantes des broches ---

const int SERVO=2; //declaration constante de broche 


// --- Déclaration des variables globales ---

int ReceptionOctet=0; // variable de stockage des octets reçus par port série
int ReceptionNombre=0; // variable de calcul du nombre reçu par port série
int impulsion=1500; // variable pour impulsion - valeur médiane initiale

// --- Initialisation des fonctionnalités utilisées ---

Servo mon_servo; // crée un objet servo pour contrôler le servomoteur

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

mon_servo.attach(SERVO); // attache l'objet servo à la broche de commande du servomoteur

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

pinMode(SERVO, OUTPUT); //met la broche en sortie 



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


//--- lecture d'un nombre reçu par le Terminal et positionnement du servomoteur --- 
if (Serial.available()>0) { // si caractère dans la file d'attente

 //---- lecture du nombre reçu 
 while (Serial.available()>0) { // tant que buffer pas vide pour lire d'une traite tous les caractères reçus

 ReceptionOctet= Serial.read(); // renvoie le 1er octet présent dans la file attente série (-1 si aucun) 
 ReceptionOctet=ReceptionOctet-48; // transfo valeur ASCII en valeur décimale

 if ((ReceptionOctet>=0)&&(ReceptionOctet<=9)) ReceptionNombre = (ReceptionNombre*10)+ReceptionOctet; 
 // si valeur reçue correspond à un chiffre on calcule nombre

 delay(1); // pause pour laisser le temps au Serial.available de recevoir les caractères

 } // fin while

 Serial.print ("Nombre recu= ");
 Serial.println(ReceptionNombre); // affiche valeur numerique entière ou à virgule au format décimal


 //----- positionnement du servomoteur en fonction de la largeur d'impulsion demandée 
 impulsion=ReceptionNombre; 

 if (impulsion>2600)impulsion=2600; // pour éviter valeur supérieure à 2600 = position maxi possible servomoteur
 if (impulsion<300)impulsion=300; // pour éviter valeur inférieure à 300 = position maxi possible servomoteur

 mon_servo.writeMicroseconds(impulsion); // génère l'impulsion de la durée voulue en µs pour le servomoteur

 Serial.print ("Impulsion servomoteur = ");
 Serial.print(impulsion); // affiche valeur numerique entière 
 Serial.println (" microsecondes ");

 delay (1000); //entre chaque changement de position

 ReceptionNombre=0; // réinitialisation de la variable de calcul du nombre reçu

} // end if


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

// --- Fin programme ---