Go Down

Topic: augmenter de 10 degrés l'inclinaison du servomoteurs à chaques envoie (Read 5363 times) previous topic - next topic

lesaccrosduvol

Bonsoir à tous

Désolé de ne pas avoir donné de nouvelle plutôt j'étais vraiment pris à m'occuper à essayé d'apprendre de nouvelle chose pour enfin finaliser mon programme.

Pour revenir au problème que vous avec soulevez pour
Quote

Je tiens à préciser que l'utilisation dont la variable " i " faisait l'objet premièrement, était de compter le nombre de fois que tu recevais la lettre 'H'. Je ne sais pas trop à quoi elle te sert maintenant, mais surement pas à compter quoi que ce soit... À quoi te sert elle maintenant ?


Je comprend pas trop comment cela fonctionne donc je préfère ne pas y toucher au cas où j'en est besoin un jour.
d'ailleurs je ne comprend pas cette partie à quoi sa sert au juste
Code: [Select]
void loop()
{ // debut de la fonction loop()
static uint8_t i = 0;
static uint8_t angleCourant = 0;


Sinon j'ai réussi à pondre ceci  XD

Code: [Select]
// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

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


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

//--- Constantes utilisées avec le servomoteur
int angle;

const int angleMin  = 2;
const int angleMax = 172;

// --- Déclaration des constantes des broches E/S numériques ---

const int broche_servo=2; // Constante pour la broche 2
const int broche_servo1=4; // Constante pour la broche 3
// --- Déclaration des constantes des broches analogiques ---


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

int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
String chaineReception=""; // déclare un objet String vide pour reception chaine
int position_servo=0;
int position_servo1=0;

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

//--- Création objet servomoteur
Servo mon_servo;  // crée un objet servo pour contrôler le servomoteur
Servo mon_servo1;  // crée un objet servo1 pour contrôler le servomoteur


// ////////////////////////// 2. 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 1 seule fois au démarrage du programme ---

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

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

//--- Initialisation Servomoteur
mon_servo.attach(broche_servo, angleMin, angleMax);  // attache l'objet servo à la broche de commande du servomoteur
mon_servo1.attach(broche_servo1, angleMin, angleMax);  // attache l'objet servo1 à la broche de commande du servomoteur


// ------- Broches en sorties numériques ------- 
pinMode (broche_servo,OUTPUT); // Broche broche_servo configurée en sortie
pinMode (broche_servo1,OUTPUT); // Broche broche_servo1 configurée en sortie

// ------- Broches en entrées numériques ------- 
mon_servo.write(position_servo);
mon_servo1.write(position_servo1);
// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ------- 

// ------- Initialisation des variables utilisées ------- 

}
// ********************************************************************************

////////////////////////////////// 3. 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()
static uint8_t i = 0;
static uint8_t angleCourant = 0;
        static uint8_t angleCourant1 = 0;
// --- ici instructions à exécuter par le programme principal ---

//---- code type réception valeur sur le port série ---

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

if (octetReception=='I') // si Octet reçu est le Q
{
angleCourant = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max
i = 90;
}

if (octetReception=='H' && i==0){ // si Octet reçu est le H et que c'est la première fois

                          angleCourant += 10; 
}
else if (octetReception=='H' && i>0){
angleCourant += (angleCourant <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='A' && i==0) {// si Octet reçu est le A et que c'est la première fois


                        angleCourant -= 10;   
                 }
else if (octetReception=='A' && angleCourant<=180){
angleCourant -= (angleCourant >= angleMin) ? 10 : 0; // Fait tourner de -10 Degrés le servomoteur

                 }
                mon_servo.write(angleCourant);
                delay(200);
}
                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

if (octetReception=='D') // si Octet reçu est le Q
{
angleCourant1 = 90; // positionne le servo1 à l'angle voulu en fonction des valeurs min/max
i = 90;
}

if (octetReception=='J' && i==0){ // si Octet reçu est le H et que c'est la première fois

                          angleCourant1 += 10; 
}
else if (octetReception=='J' && i>0){
angleCourant1 += (angleCourant1 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='M' && i==0) {// si Octet reçu est le A et que c'est la première fois


                        angleCourant1 -= 10;   
                 }
else if (octetReception=='M' && angleCourant<=180){
angleCourant1 -= (angleCourant1 >= angleMin) ? 10 : 0; // Fait tourner de -10 Degrés le servomoteur

                 }
                mon_servo1.write(angleCourant1);
delay(200);

}
}
// ////////////////////////// Fin du programme ////////////////////


// ////////////////////////// Mémo instructions ////////////////////
// ////////////////////////// Fin Mémo instructions ////////////////////


mais il y à encore quelques soucis les servos sont plutôt longs  et donc toutes les commandes ne sont pas toujours exécutées , ou j'ai peut être un problème dans le code ? (enfin pour le moment je n'en est pas l'impression, je pense plutôt que ce n'est pas assez rapide )

Si vous aviez des explications à tout cela merci


lesaccrosduvol

Bon j'ai essayé par moi même encore un peu d'enlever se qui pourrait ralentir mon programme

Code: [Select]
// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

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


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

//--- Constantes utilisées avec le servomoteur
int angle;

const int angleMin  = 2;
const int angleMax = 172;

// --- Déclaration des constantes des broches E/S numériques ---

const int broche_servo=2; // Constante pour la broche 2
const int broche_servo1=4; // Constante pour la broche 3
// --- Déclaration des constantes des broches analogiques ---


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

int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
String chaineReception=""; // déclare un objet String vide pour reception chaine
int position_servo=0;
int position_servo1=0;

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

//--- Création objet servomoteur
Servo mon_servo;  // crée un objet servo pour contrôler le servomoteur
Servo mon_servo1;  // crée un objet servo1 pour contrôler le servomoteur


// ////////////////////////// 2. 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 1 seule fois au démarrage du programme ---

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

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

//--- Initialisation Servomoteur
mon_servo.attach(broche_servo, angleMin, angleMax);  // attache l'objet servo à la broche de commande du servomoteur
mon_servo1.attach(broche_servo1, angleMin, angleMax);  // attache l'objet servo1 à la broche de commande du servomoteur


// ------- Broches en sorties numériques ------- 
pinMode (broche_servo,OUTPUT); // Broche broche_servo configurée en sortie
pinMode (broche_servo1,OUTPUT); // Broche broche_servo1 configurée en sortie

// ------- Broches en entrées numériques ------- 
mon_servo.write(position_servo);
mon_servo1.write(position_servo1);
// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ------- 

// ------- Initialisation des variables utilisées ------- 

}
// ********************************************************************************

////////////////////////////////// 3. 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()
static uint8_t i = 0;
        static uint8_t i1 = 0;
static uint8_t angleCourant = 0;
        static uint8_t angleCourant1 = 0;
// --- ici instructions à exécuter par le programme principal ---

//---- code type réception valeur sur le port série ---
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

if (octetReception=='D') // si Octet reçu est le Q
{
angleCourant1 = 90; // positionne le servo1 à l'angle voulu en fonction des valeurs min/max
i1 = 90;
}

if (octetReception=='J' && i1==0){ // si Octet reçu est le H et que c'est la première fois

                          angleCourant1 += 10; 
}
else if (octetReception=='J' && i1>0){
angleCourant1 += (angleCourant1 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='M' && i1==0) {// si Octet reçu est le A et que c'est la première fois


                        angleCourant1 -= 10;   
                 }
else if (octetReception=='M' && angleCourant<=180){
angleCourant1 -= (angleCourant1 >= angleMin) ? 10 : 0; // Fait tourner de -10 Degrés le servomoteur

                 }
               


if (octetReception=='I') // si Octet reçu est le Q
{
angleCourant = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max
i = 90;
}

if (octetReception=='H' && i==0){ // si Octet reçu est le H et que c'est la première fois

                          angleCourant += 10; 
}
else if (octetReception=='H' && i>0){
angleCourant += (angleCourant <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='A' && i==0) {// si Octet reçu est le A et que c'est la première fois


                        angleCourant -= 10;   
                 }
else if (octetReception=='A' && angleCourant<=180){
angleCourant -= (angleCourant >= angleMin) ? 10 : 0; // Fait tourner de -10 Degrés le servomoteur

                 }
                 
                mon_servo1.write(angleCourant1);
                mon_servo.write(angleCourant);
                delay(200);
}
               
}
// ////////////////////////// Fin du programme ////////////////////


// ////////////////////////// Mémo instructions ////////////////////
// ////////////////////////// Fin Mémo instructions ////////////////////


Mais j'ai découvert un truc si je met cette partie la
Code: [Select]
if (octetReception=='D') // si Octet reçu est le Q
{
angleCourant1 = 90; // positionne le servo1 à l'angle voulu en fonction des valeurs min/max
i1 = 90;
}

if (octetReception=='J' && i1==0){ // si Octet reçu est le H et que c'est la première fois

                          angleCourant1 += 10; 
}
else if (octetReception=='J' && i1>0){
angleCourant1 += (angleCourant1 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='M' && i1==0) {// si Octet reçu est le A et que c'est la première fois


                        angleCourant1 -= 10;   
                 }
else if (octetReception=='M' && angleCourant<=180){
angleCourant1 -= (angleCourant1 >= angleMin) ? 10 : 0; // Fait tourner de -10 Degrés le servomoteur

                 }


avant celle là

Code: [Select]
if (octetReception=='I') // si Octet reçu est le Q
{
angleCourant = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max
i = 90;
}

if (octetReception=='H' && i==0){ // si Octet reçu est le H et que c'est la première fois

                          angleCourant += 10; 
}
else if (octetReception=='H' && i>0){
angleCourant += (angleCourant <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='A' && i==0) {// si Octet reçu est le A et que c'est la première fois


                        angleCourant -= 10;   
                 }
else if (octetReception=='A' && angleCourant<=180){
angleCourant -= (angleCourant >= angleMin) ? 10 : 0; // Fait tourner de -10 Degrés le servomoteur

                 }
                 


ou inversement celle qui est écrire en première aura son servo qui répondra directement sans problème alors que celle en deuxième mettra du temps et parfois même ne répondra pas

si vous aviez des explications ??

fdufnews


Pour revenir au problème que vous avec soulevez pour
Quote

Je tiens à préciser que l'utilisation dont la variable " i " faisait l'objet premièrement, était de compter le nombre de fois que tu recevais la lettre 'H'. Je ne sais pas trop à quoi elle te sert maintenant, mais surement pas à compter quoi que ce soit... À quoi te sert elle maintenant ?


Je comprend pas trop comment cela fonctionne donc je préfère ne pas y toucher au cas où j'en est besoin un jour.
d'ailleurs je ne comprend pas cette partie à quoi sa sert au juste

C'est dommage parce que du coup ça fait n'importe quoi.
Code: [Select]
if (octetReception=='J' && i1==0){ // si Octet reçu est le H et que c'est la première fois
      angleCourant1 += 10; 
} else if (octetReception=='J' && i1>0){
      angleCourant1 += (angleCourant1 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

comme i n'est jamais modifié dans ton programme il est toujours à 0 et le second test n'est jamais vrai et du coup tu ne gères pas les butés correctement.
D'ailleurs entre nous comme l'incrément est toujours de 10 cette combine ne sert vraiment à rien du tout et elle pourrait se simplifier en un seul if
Code: [Select]
if (octetReception=='J'){ // si Octet reçu est le J
           angleCourant1 += (angleCourant1 <angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}


Attention au copié/collé
Code: [Select]
else if (octetReception=='M' && angleCourant<=180){
angleCourant1 -= (angleCourant1 >= angleMin) ? 10 : 0; // Fait tourner de -10 Degrés le servomoteur
                 }

Tu manipules angleCourant1 et tu fais un test sur angleCourant. En plus, ce test n'a pas de sens dans la mesure où tu testes si l'angle est inférieur ou égale à 180° avant de tester la ligne en dessous s'il est supérieur à angleMin ce qui a plus de sens vu que tu veux diminuer la valeur de l'angle.
Je pense que tu voulais écrire ça:
Code: [Select]
else if (octetReception=='M' && angleCourant1> angleMin){
angleCourant1 -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }


Il va sans dire que les remarques faites pour un servo sont valables sur le traitement de l'autre.

lesaccrosduvol

Bonsoir

Voilà j'ai terminer la première partie de mon projet je remercie vraiment "fdufnews " pour son aide mais aussi tout les membres du forum qui m'ont aidé. Je vous met une petite vidéo pour vous montrer.

http://www.youtube.com/watch?v=hFOehudW9u4

il me reste juste un petit problème car quand j'envoie la commande - 10 et que le servomoteur est déjà à 0 il va se positionner à 180° alors que je voudrai qu'il reste à 0° ( si je règle pas se problème sa risque de poser de sérieux problème en vol  :)  )

Bon sinon pour ma deuxième partie je vais essayé d'utiliser le module APC220 afin de pouvoir contrôler à distance . JE trouve que c'est celui qui irai le mieux pour se type de projet ; Avez vous des avis ? j'ai lu qu'il avait une porté jusqu'à 1100m peut on l'augmenter en changeant l'antenne ?

Voila je vous tiens au courant de la suite 

Et encore merci  :D

fdufnews


lesaccrosduvol

Voici le code arduino

Code: [Select]
// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

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


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

//--- Constantes utilisées avec le servomoteur
int angle;

const int angleMin  = 0;
const int angleMax = 180;

// --- Déclaration des constantes des broches E/S numériques ---

const int broche_servo=2; // Constante pour la broche 2
const int broche_servo1=4; // Constante pour la broche 3
const int broche_servo2=7;// Constante pour la broche 7
const int broche_servo3=8;// Constante pour la broche 8
// --- Déclaration des constantes des broches analogiques ---


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

int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
String chaineReception=""; // déclare un objet String vide pour reception chaine
int position_servo=0;
int position_servo1=0;
int position_servo2=0;
int position_servo3=0;

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

//--- Création objet servomoteur
Servo mon_servo;  // crée un objet servo pour contrôler le servomoteur
Servo mon_servo1;  // crée un objet servo1 pour contrôler le servomoteur
Servo mon_servo2;  // crée un objet servo2 pour contrôler le servomoteur
Servo mon_servo3;// crée un objet servo3 pour contrôler le servomoteur
// ////////////////////////// 2. 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 1 seule fois au démarrage du programme ---

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

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

//--- Initialisation Servomoteur
mon_servo.attach(broche_servo, angleMin, angleMax);  // attache l'objet servo à la broche de commande du servomoteur
mon_servo1.attach(broche_servo1, angleMin, angleMax);  // attache l'objet servo1 à la broche de commande du servomoteur
mon_servo2.attach(broche_servo2, angleMin, angleMax);  // attache l'objet servo2 à la broche de commande du servomoteur
mon_servo3.attach(broche_servo3, angleMin, angleMax);  // attache l'objet servo3 à la broche de commande du servomoteur


// ------- Broches en sorties numériques ------- 
pinMode (broche_servo,OUTPUT); // Broche broche_servo configurée en sortie
pinMode (broche_servo1,OUTPUT); // Broche broche_servo1 configurée en sortie
pinMode (broche_servo2,OUTPUT); // Broche broche_servo2 configurée en sortie
  pinMode (broche_servo3,OUTPUT); // Broche broche_servo3 configurée en sortie

// ------- Broches en entrées numériques ------- 
mon_servo.write(position_servo);
mon_servo1.write(position_servo1);
mon_servo2.write(position_servo2);
mon_servo3.write(position_servo3);
// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ------- 

// ------- Initialisation des variables utilisées ------- 

}
// ********************************************************************************

////////////////////////////////// 3. 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()
static uint8_t angleCourant = 0;
        static uint8_t angleCourant1 = 0;
        static uint8_t angleCourant2 = 0;
        static uint8_t angleCourant3 = 0;
// --- ici instructions à exécuter par le programme principal ---

//---- code type réception valeur sur le port série ---
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

if (octetReception=='I') // si Octet reçu est le I
{
angleCourant1 = 0; // positionne le servo1 à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='g'){ // si Octet reçu est le g et que c'est la première fois

                          angleCourant1 += 10; 
}
else if (octetReception=='g' ){
angleCourant1 += (angleCourant1 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='k') {// si Octet reçu est le k et que c'est la première fois


                        angleCourant1 -= 10;   
                 }
else if (octetReception=='k' && angleCourant1> angleMin){
angleCourant1 -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
               


if (octetReception=='I') // si Octet reçu est le I
{
angleCourant = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='h'){ // si Octet reçu est le h et que c'est la première fois

                          angleCourant += 10; 
}
else if (octetReception=='h'){
angleCourant += (angleCourant <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='a') {// si Octet reçu est le a et que c'est la première fois


                        angleCourant -= 10;   
                 }
else if (octetReception=='a' && angleCourant> angleMin){
angleCourant -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
                 
                 if (octetReception=='I') // si Octet reçu est le I
{
angleCourant2 = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='z'){ // si Octet reçu est le z et que c'est la première fois

                          angleCourant2 += 10; 
}
else if (octetReception=='z'){
angleCourant2 += (angleCourant2 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='s') {// si Octet reçu est le s et que c'est la première fois


                        angleCourant2 -= 10;   
                 }
else if (octetReception=='s' && angleCourant2> angleMin){
angleCourant2 -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
                 
                 
                  if (octetReception=='I') // si Octet reçu est le I
{
angleCourant3 = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='q'){ // si Octet reçu est le q et que c'est la première fois

                          angleCourant3 += 10; 
}
else if (octetReception=='q'){
angleCourant3 += (angleCourant3 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='d') {// si Octet reçu est le d et que c'est la première fois


                        angleCourant3 -= 10;   
                 }
else if (octetReception=='d' && angleCourant3> angleMin){
angleCourant3 -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
                 }
                 
                mon_servo1.write(angleCourant1);
                mon_servo.write(angleCourant);
                mon_servo2.write(angleCourant2);
                mon_servo3.write(angleCourant3);
                delay(200);
}
               

// ////////////////////////// Fin du programme ////////////////////


// ////////////////////////// Mémo instructions ////////////////////
// ////////////////////////// Fin Mémo instructions ////////////////////


J'ai essayé de corriger les copier coller j'espère ne pas trop en avoir oublié

lesaccrosduvol

#21
Feb 04, 2014, 09:20 pm Last Edit: Feb 04, 2014, 09:22 pm by lesaccrosduvol Reason: 1
et la première partie du code processing

Code: [Select]
// inclusion librairies utilisées
import processing.serial.*; // importe la librairie série processing

// déclaration variables

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

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

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

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

float Y_ref1=400; // ordonnée de ligne de référence dessin rectangle

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

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

float Y_ref2=400; // ordonnée de ligne de référence dessin rectangle

float largeur2=50;
float hauteur2=360; //360 représente 100% (0 à 9 = 180 positions)

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

float Y_ref3=400; // ordonnée de ligne de référence dessin rectangle

float largeur3=50;
float hauteur3=360; //360 représente 100% (0 à 9 = 180 positions)

int SendValue3=0; // valeur envoyée à Arduino
float niveau3=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(800,600); //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 (600,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 (600,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

// dessin des 2 rectangles du niveau de démmarrage (=50%)
 stroke (0); // trait de contour
 fill(255,255,255); // remplissage
 rect (400,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 (400,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

// dessin des 2 rectangles du niveau de démmarrage (=50%)
 stroke (0); // trait de contour
 fill(255,255,255); // remplissage
 rect (200,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 (200,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

// dessin des 2 rectangles du niveau de démmarrage (=50%)
 stroke (0); // trait de contour
 fill(255,255,255); // remplissage
 rect (10,Y_ref3-hauteur3,largeur3, hauteur3); // 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_ref3-niveau3,largeur3, niveau3); // 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(0);   // valeur initiale 0 pour format ASCII
 delay (100); // pause  
 MySerialPort.write(0);   // valeur initiale 0 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/18); // /18 pour avoir 18 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('g');   // envoie la valeur g
     delay (100); // pause  
   }
   else if (keyCode == DOWN) {// si touche BAS appuyée

   niveau=niveau-(hauteur/18); //
   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('k');   //envoie la valeur k
     delay (100); // pause  

   }
   if (keyCode == RIGHT) { // si touche droite appuyée

     niveau1=niveau1+(hauteur1/18); // /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('h');   // envoie la valeur h
     delay (100); // pause  
   }
   else if (keyCode == LEFT) {// si touche gauche appuyée

   niveau1=niveau1-(hauteur1/18); // /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('a');   // venvoi la valeur a
     delay (100); // pause  

   }
}


lesaccrosduvol

deuxième partie ( désolé sa faisait trop de caratère)

Code: [Select]
if (keyPressed) {
     if (key == 'i' || key == 'I') {
     niveau=0; // /18 pour avoir 18 niveaux
     
    niveau1=180; // /18 pour avoir 18 niveaux
           
    niveau2=180; // /18 pour avoir 18 niveaux
           
    niveau3=180; // /18 pour avoir 18 niveaux
     
       
     MySerialPort.write('I');   // valeur initiale + 48 pour format ASCII - envoie valeur 0 à 9
      delay (100); // pause
     }
     
          if (key == 'z' || key == 'Z') {
     
       niveau2=niveau2+(hauteur2/18); // /18 pour avoir 18 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('z');   // envoie la valeur z
      delay (100); // pause 
    }
    if (key == 's' || key == 'S') {
      niveau2=niveau2-(hauteur2/18); // /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('s');   //envoi la valeur s
      delay (100); // pause 
    }
       
          if (key == 'q' || key == 'Q') {
     
       niveau3=niveau3+(hauteur3/18); // /18 pour avoir 18 niveaux
      if (niveau3>=hauteur3)niveau3=hauteur3; // ne pas dépasser hauteur

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

      MySerialPort.write('q');   // envoie la valeur q
      delay (100); // pause 
    }
    if (key == 'd' || key == 'D') {
      niveau3=niveau3-(hauteur3/18); // /9 pour avoir 10 niveaux
    if (niveau3<=0)niveau3=0; // ne pas dépasser 0

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

      MySerialPort.write('d');   // envoie la valeur d
      delay (100); // pause 
    }
     
}

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

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

// dessin des 2 rectangles du niveau
  stroke(0); // contour noir
  fill(255,255,255); // remplissage blanc
  rect (200,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); // contour rouge
  fill(55,0,40); // remplissage rouge
  rect (200,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

// dessin des 2 rectangles du niveau
  stroke(0); // contour noir
  fill(255,255,255); // remplissage blanc
  rect (10,Y_ref3-hauteur3,largeur3, hauteur3); // 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); // contour rouge
  fill(55,220,40); // remplissage rouge
  rect (10,Y_ref3-niveau3,largeur3, niveau3); // 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


}


fdufnews

Code: [Select]
if (octetReception=='g'){ // si Octet reçu est le g et que c'est la première fois
      angleCourant1 += 10; 
}
else if (octetReception=='g' ){
    angleCourant1 += (angleCourant1 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

Cette forme d'écriture n'a aucun sens.
La première assertion est toujours vérifiée donc tu n'entres jamais dans le else et tu ne testes pas les butées.

Code: [Select]
if (octetReception=='k') {// si Octet reçu est le k et que c'est la première fois
     angleCourant1 -= 10;   
}
else if (octetReception=='k' && angleCourant1> angleMin){
      angleCourant1 -=  10; // Fait tourner de -10 Degrés le servomoteur
}

Même chose ici la première assertion est toujours vérifié avant l'autre et le else n'est jamais testé.

Pour utiliser un if .... else if ... il faut que les conditions s'excluent mutuellement sinon la première condition qui est remplie est exécutée.

lesaccrosduvol

Salut

c'est vrai tu a raison mais moi sa ma pas choqué (peut être parce que s'est encore un peut du déchiffrage pour moi) , mais maintenant que tu me le dit ses vrai que ses tout bêtes

Code: [Select]
////////////////////////////////////////////////////////SERVO/////////////////////////////////////////////////////////////////////////////////////////////

if (octetReception=='I') // si Octet reçu est le I
{
angleCourant = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='h'){
angleCourant += (angleCourant <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='a' && angleCourant> angleMin){
angleCourant -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
                 ///////////////////////////////////////////////////////////////SERVO1///////////////////////////////////////////////////////////////////////////////////////////////////

if (octetReception=='I') // si Octet reçu est le I
{
angleCourant1 = 0; // positionne le servo1 à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='g' ){
angleCourant1 += (angleCourant1 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='k' && angleCourant1> angleMin){
angleCourant1 -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
               
                 /////////////////////////////////////////////////////SERVO2/////////////////////////////////////////////////////////////////////////////
                 if (octetReception=='I') // si Octet reçu est le I
{
angleCourant2 = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='z'){
angleCourant2 += (angleCourant2 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='s' && angleCourant2> angleMin){
angleCourant2 -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
                 
                //////////////////////////////////////////////////////////SERVO3//////////////////////////////////////////////////////////////
               
                  if (octetReception=='I') // si Octet reçu est le I
{
angleCourant3 = 90; // positionne le servo à l'angle voulu en fonction des valeurs min/max

}

if (octetReception=='q'){
angleCourant3 += (angleCourant3 <= angleMax) ? 10 : 0; //fait tourner de +10 Degrés le servomoteur
}

                 if (octetReception=='d' && angleCourant3> angleMin){
angleCourant3 -=  10; // Fait tourner de -10 Degrés le servomoteur
                 }
                 }
                 
                mon_servo1.write(angleCourant1);
                mon_servo.write(angleCourant);
                mon_servo2.write(angleCourant2);
                mon_servo3.write(angleCourant3);
                delay(200);
}
               

// ////////////////////////// Fin du programme ////////////////////

Go Up