Bonjour à tous,
J'ai un problème de Noob très certainement mais je ne trouve pas d'explication sur des tutos.
Comment Dois je déclarer une variable pour que sa valeur reste identique sur plusieurs boucles ?
ex : durant l'une des boucle je dis à mon moteur que sa vitesse doit être 5, comment faire pour que la variable vitesse conserve sa valeur sans lui redonner de consigne ?
Merci 
Bonjour,
As-tu déjà écrit ton programme?
Si oui, postes le (entre balises code) avec quelques explicitons concernant le fonctionnement désiré.
pas facile de comprendre ta question car une variable garde ça valeur tant que tu ne lui donne pas une autre valeur, donne nous un code pour voir ou tu bloque .
bonjour,
+1 pour le code.
mais bon, le principe est simple a faire.
valeur = x
on donne la valeur 5
tant que valeur = de valeur_recue => valeur =valeur
si valeur différent de valeur_recue => valeur = valeur_recue
//inclusion des librairies
#include <Servo.h>
#include <CurieIMU.h>
#include <MadgwickAHRS.h>
#include <SoftwareSerial.h>
#include <math.h>
//Definition des ESC/moteurs
Servo ESC_1;
Servo ESC_2;
Servo ESC_3;
Servo ESC_4;
#define PinESC_1 9
#define PinESC_2 6
#define PinESC_3 5
#define PinESC_4 3
#define PinBleu 12
#define PinRouge 13
//variables d'echantillonage gyroscope
unsigned long tpsEchantillonageAX, tpsPrecedAX;
float accelScale, gyroScale;
// Creation d'un objet filtre
Madgwick filter;
// Creation d'un objet SorftwareSerial
SoftwareSerial mySerial(11, 4); // RX, TX
// Déclration des prototypes
void prepaMoteurs();
void vitesse(int speed1, int speed2, int speed3, int speed4);
float convertRawAcceleration(int aRaw);
float convertRawGyro(int gRaw);
void fonctionArret ();
//Boucle d'initialisation
void setup() {
pinMode ( PinBleu, OUTPUT);
pinMode ( PinRouge, OUTPUT);
digitalWrite ( PinBleu, HIGH);
//on initialise les ESCs
ESC_1.attach(PinESC_1);
ESC_2.attach(PinESC_2);
ESC_3.attach(PinESC_3);
ESC_4.attach(PinESC_4);
// Lecture Serial (si nécessaire)
Serial.begin(9600);
mySerial.begin(9600);
//on prépare les moteurs
prepaMoteurs();
// On lance le gyroscope
CurieIMU.begin();
CurieIMU.setGyroRate(25);
CurieIMU.setAccelerometerRate(25);
filter.begin(25);
// On ecrit les parametresgyro (nb g et degrees)
CurieIMU.setAccelerometerRange(2);
CurieIMU.setGyroRange(250);
// initialisation du taux d'echantillonage (besoin de lecture à 25 Hz donc toutes les 1000000/25 microsec)
tpsEchantillonageAX = 1000000 / 25;
tpsPrecedAX = micros();
digitalWrite ( PinBleu, LOW);
}
void loop() {
// initialisation des variables
// vitesses moteurs
//int speed1, speed2, speed3, speed4;
//coordonnées gyro
int aix, aiy, aiz;
int gix, giy, giz;
float ax, ay, az;
float gx, gy, gz;
float roulis, tangage, lacet;
float roulisWhish, tangageWish, lacetWish, vitesseWish;
unsigned long TpsMicro = micros();
int recu;
//Aquisition données de positions (sans delay)
if (TpsMicro - tpsPrecedAX >= tpsEchantillonageAX){
// recuperation données brutes
CurieIMU.readMotionSensor(aix, aiy, aiz, gix, giy, giz);
// convertion par passage dans les fonctions
ax = convertRawAcceleration(aix);
ay = convertRawAcceleration(aiy);
az = convertRawAcceleration(aiz);
gx = convertRawGyro(gix);
gy = convertRawGyro(giy);
gz = convertRawGyro(giz);
// filtre de calcul d'orientation
filter.updateIMU(gx, gy, gz, ax, ay, az);
// décuperation des données traitées dans le filtre
roulis = filter.getRoll();
tangage = filter.getPitch();
lacet = filter.getYaw();
//Serial.print("Orientation: ");
//Serial.print(lacet);
//Serial.print(" ");
//Serial.print(tangage);
//Serial.print(" ");
//Serial.println(roulis);
// on incrémente le temps préced
tpsPrecedAX += tpsEchantillonageAX;
}
int input;
int vitessepreced;
if(mySerial.available() > 1){
input = mySerial.parseInt();//read serial input and convert to integer (-32,768 to 32,767)
Serial.print ("Input : \n");
Serial.println (input);
if (input == 1){
digitalWrite (12, HIGH);
digitalWrite (13, LOW);
//fonctionArret();
}
else if (input == 2){
digitalWrite (12, LOW);
digitalWrite (13, HIGH);
}
else if (input >= 10 && input <= 30){
lacetWish = lacet - (input-20)/2 ;
lacetWish = fmod (lacetWish, 360);
}
else if (input >= 40 && input <= 60){
tangageWish = (input-50) ;
}
else if (input >= 100 && input <= 300){
vitesseWish = map ( input, 100, 300, 300, 950);
vitessepreced = vitesseWish;
}
}
// détermination des vitesses necessaires
// par rapport au throttle et à l'avancement
int speed1 = vitesseWish - tangageWish;
int speed2 = vitesseWish - tangageWish;
int speed3 = vitesseWish + tangageWish;
int speed4 = vitesseWish + tangageWish;
// par rapport au virage
if (lacetWish < lacet || (lacet - lacetWish) < 0){
speed1 += 5;
speed2 -= 5;
speed3 += 5;
speed4 -= 5;
}
else if (lacetWish > lacet || (lacet + lacetWish) > 360){
speed1 -= 5;
speed2 += 5;
speed3 -= 5;
speed4 += 5;
}
// correction pour la stabilite
if (roulis > 0){
speed1 += 5;
speed4 += 5;
speed2 -= 5;
speed3 -= 5;
}
else if (roulis < 0){
speed1 -= 5;
speed4 -= 5;
speed2 += 5;
speed3 += 5;
}
// C'est la partie suivante que j'aimerai éviter d'avoir à écrire
//Ecriture vitesse
if (input > 99){
vitesse(speed1, speed2, speed3, speed4);
Serial.print ("vitesses : \n");
Serial.println (speed1);
Serial.println (speed2);
Serial.println (speed3);
Serial.println (speed4);
}
mySerial.flush();//clear the serial buffer for unwanted inputs
delay(20);//delay little for better serial communication
}
//Fonctions diverses
//Armage des moteurs
void prepaMoteurs() {
///revoir le détail de cette séquence
Serial.println("Arming");
vitesse(0,0,0,0);
delay(10000);
vitesse(300, 300, 300, 300);
delay(3000);
vitesse(0, 0, 0, 0);
delay(4000);
}
//boucle d'écriture des vitesses
void vitesse(int speed1, int speed2, int speed3, int speed4){
// speed is from 0 to 100 where 0 is off and 100 is maximum speed
//the following maps speed values of 0-100 to angles from 0-180,
// some speed controllers may need different values, see the ESC instructions
int angle1 = map(speed1, 0, 1023, 0, 180);
int angle2 = map(speed2, 0, 1023, 0, 180);
int angle3 = map(speed3, 0, 1023, 0, 180);
int angle4 = map(speed4, 0, 1023, 0, 180);
ESC_1.write(angle1);
ESC_2.write(angle2);
ESC_3.write(angle3);
ESC_4.write(angle4);
}
// Boucles de convertion des donnees gyroscopiques
float convertRawAcceleration(int aRaw) {
// since we are using 2G range
// -2g maps to a raw value of -32768
// +2g maps to a raw value of 32767
float a = (aRaw * 2.0) / 32768.0;
return a;
}
float convertRawGyro(int gRaw) {
// since we are using 250 degrees/seconds range
// -250 maps to a raw value of -32768
// +250 maps to a raw value of 32767
float g = (gRaw * 250.0) / 32768.0;
return g;
}
void fonctionArret () {
while (mySerial.available() != 0){
int lecture = mySerial.parseInt();//read serial input and convert to integer (-32,768 to 32,767)
}
}
Voilà mon code, c'est pour un drone :
Sans la condition que j'ai indiquée par le commentaire que j'ai centré, à chaque fois que le drône reçoit une valeur autre que la valeur qui contrôle la hauteur, les valeurs de vitesse prenne pour valeur des chiffres très faibles ( genre 7 ou 12 ou 5 ) alors qu'elles sont censées restée entre 300 et 950...
Désolé mon code n'est pas très digeste mais je ne sais pas faire mieux
Merci pour votre aide
J'ai donc trouver ce qui ne va pas, j'ai déclarer mes valeurs dans la boucle et pas à l'exterieur... enfin il me semble que ce soit la source de mes problèmes. Quelqu'un pourrait par contre m'expliquer pour quoi on à des résultats si différents en fonction de l'endroit ou l'on déclare ses variables ?
Merci
Edit : Comment marquer le post comme résolu ?
Tu trouvera l'explication dans un tuto de C --> Visibilité des variables.
Ce n'est pas que je veux pas te répondre mais ce sera plus clair dans un tuto.
En règle générale tout ce qui touche au langage est expliqué dans les tuto généraux de C ou C++.
Le tuto conseillé par 68tjs est un "must read" si ce n'est pas déjà fait. Et sinon pour faire court si la variable est déclarée dans la boucle, à chaque passage dans la boucle elle est re-initialisée puisque tu repasse par la déclaration.