probleme avec un programme

Mes servo font n'importe quoi et je sais pas pourquoi???(le prog n'est pas de moi je l'ai juste modifié!)

import processing.serial.*;

float Y_ref1=220;// ordonnée de ligne de référence dessin rectangle
//float X_ref1=220;
float Y_ref2=220;
float X_ref2=300;

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

float largeur2=50;
float hauteur2=180;

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

int SendValue2=0; // valeur envoyée à Arduino
float niveau2=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(300,300); //dimensionne la fenêtre processing (largeur x hauteur) //

//---- 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_ref1-hauteur1,largeur1, hauteur1); // 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_ref1-niveau1,largeur1, niveau1); // 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

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 (50,Y_ref2-hauteur2,largeur2, hauteur2); // 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 (50,Y_ref2-niveau2,largeur2, niveau2); // 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

}

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

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

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

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

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

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

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

}

if (keyCode == RIGHT) {

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

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

MySerialPort.write(SendValue2+48); // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9
delay (100); // pause
}
else if (keyCode == LEFT) {

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

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

MySerialPort.write(SendValue2+48); // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9

delay (100); // pause

}

}

// dessin des 2 rectangles du niveau
stroke(0); // contour noir
fill(255,255,255); // remplissage blanc
rect (10,Y_ref1-hauteur1,largeur1, hauteur1);

stroke(255,0,0); // contour rouge
fill(255,0,0); // remplissage rouge
rect (10,Y_ref1-niveau1,largeur1, niveau1);

//dessin des 2 rectangles du niveau
stroke(0); // contour noir
fill(255,255,255); // remplissage blanc
rect (100,Y_ref2-hauteur2,largeur2, hauteur2);

stroke(0,0,255); // contour rouge
fill(0,0,255); // remplissage rouge
rect (100,Y_ref2-niveau2,largeur2, niveau2);

}

// fin gestion port série

Le problème c'est que je n'arrive pas a contrôler correctement le servo placé sur la pin 10 (autre petit prog sur Arduino...)

Si vous avez une idée je suis preneur!

merci

Il faut aussi le code que tu as mis sur l'Arduino, c'est peut-être là qu se trouve le problème.

Autrement essaye de baisser la vitesse de ta liaison série, dans Processing et sur la carte.

Voici le prog sur Arduino:

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

// --- Déclaration des constantes ---
const int POS_MIN=550; // largeur impulsion pour position 0° servomoteur

const int POS_MAX=2330; // largeur impulsion pour position 180° servomoteur
// POS_MAS=2330 pour futaba s3003

// --- constantes des broches ---

const int broche_servo1=9; //declaration constante de broche
const int broche_servo2=10;

// --- Déclaration des variables globales ---
// variable position du servomoteur en degré

int position_servo1=0;
int position_servo2=0;

// variable de stockage des valeurs reçues

int OctetReception1=0;
int OctetReception2=0;
// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---
Servo mon_servo1; // crée un objet servo pour contrôler le servomoteur
Servo mon_servo2;

//**************** 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_servo1.attach(broche_servo1, POS_MIN, POS_MAX); // attache l'objet servo à la broche de commande du servomoteur
mon_servo2.attach(broche_servo2, POS_MIN, POS_MAX);
// ------- Broches en sortie -------

pinMode(broche_servo1, OUTPUT); //met la broche en sortie
pinMode(broche_servo2, OUTPUT);
// ------- Broches en entrée -------

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

// ------- position initiale du servomoteur
mon_servo1.write(position_servo1);
delay(200);
mon_servo2.write(position_servo2);
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

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

// calcule la nouvelle position
position_servo1=map(OctetReception1,0,9,0,180);

//positionne le servomoteur
mon_servo1.write(position_servo1);

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

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

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

// calcule la nouvelle position
position_servo2=map(OctetReception2,0,9,0,180);

//positionne le servomoteur
mon_servo2.write(position_servo2);

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

}// fin gestion octet en réception

}

// --- Fin programme ---

Si vous trouvez l'erreur merci d'avance

On va procéder plus simplement, c'est le code de "mon club elec"... normalement il n'y a pas de raison que ce code ne fonctionne pas.

Alors indique nous ce que tu as modifié. en procédant ainsi on va probablement trouvé ce qui ne va pas.

Bonjour,

Oui c'est le code de mon club elec ! J'ai voulu le modifier afin de faire bouger deux servo. Le premier avec les touches bas et haut du pad et le second avec celles droite et gauche. Le problème c'est que les info envoyées sur le pin 10 ne correspondent pas du tout ?! De plus, j'ai un petit problème d'affichage de mes rectangles mais ca je pense regarder d'autre tuto et me dépatouiller !
Si vous avez une solution ?

Indique nous ce que tu as rajouté/modifié !

voila pour le code sur Process!

float Y_ref2=220;
float X_ref2=300;

float largeur2=50;
float hauteur2=180;

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

//////////////////////////////////////////////////////////////////////////////////////

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 (50,Y_ref2-hauteur2,largeur2, hauteur2); // 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 (50,Y_ref2-niveau2,largeur2, niveau2); // 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

////////////////////////////////////////////////////////////////////////////////////////////

if (keyCode == RIGHT) {

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

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

MySerialPort.write(SendValue2+48); // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9
delay (100); // pause
}
else if (keyCode == LEFT) {

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

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

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

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//dessin des 2 rectangles du niveau
stroke(0); // contour noir
fill(255,255,255); // remplissage blanc
rect (100,Y_ref2-hauteur2,largeur2, hauteur2); // 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(0,0,255); // contour rouge
fill(0,0,255); // remplissage rouge
rect (100,Y_ref2-niveau2,largeur2, niveau2); // 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

}

Et pour celui d'Arduino:

const int broche_servo2=10;

////////////////////////////////
int position_servo2=0;

// variable de stockage des valeurs reçues

int OctetReception2=0;

Servo mon_servo2;

///////////////////////////////////////////////////////////////////////////////////////

mon_servo2.attach(broche_servo2, POS_MIN, POS_MAX);

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

pinMode(broche_servo2, OUTPUT);

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

mon_servo2.write(position_servo2);
delay(200);

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

// calcule la nouvelle position
position_servo2=map(OctetReception2,0,9,0,180);

//positionne le servomoteur
mon_servo2.write(position_servo2);

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

J'ai trouvé une autre solution avec un autre prog!

Merci d'avoir pris le temps de regarder.