D'accord, je vais regarder tout ça...
Pour le servomoteur, vous me conseillez plutôt quoi comme choix ?
Merci !
Et aussi... c'est quoi doubles déclarations?
lykhorn:
Et aussi... c'est quoi doubles déclarations?
Au début de ton programme tu écris ça :
long valeur3 = 0 ;
Puis ensuite au milieu :
int valeur3=analogRead(capteur); //Relever la valeur3
Déjà un long et un int ce n'est pas la meme chose mais en plus tu as déjà déclare valeur3, il faut donc que tu écrives
valeur3=analogRead(capteur); //Relever la valeur3
Vu comment tu utilises la variable valeur3, un int est suffisent tu n'as pas besoin d'un long, pour plus d'explication va voir sur la doc de Arduino les différents types de variables mais la déclaration de ta variable devrait etre
int valeur3 = 0 ;
c'est bon j'ai compris, d'ailleurs je ne vois pas pourquoi j'ai mis un int devant chacun de mes analogRead... 
Merci beaucoup !
J'ai utilisé plusieurs de ces petits moteurs. C'est assez facile quand on a cerné leur fonctionnement et surtout compris les commandes possibles à l'aide de la bibliothèque Servo.h qui nous mâche le travail.
Rien ne vaut un exemple de programme qui fonctionne pour aider un copain, du moins c'est ma façon de voir.
Ci-joint, le petit commentaire que je rédige chaque fois que j'expérimente un nouveau domaine sur Arduino.
Je te joins également en fichier attaché le documentation que je me rédige chaque fois que j'étudie dans le détail une bibliothèque relative au C d'Arduino.
Voici le petit programme dont il est question dans mes notes personnelles :
// Test de pilotage d'un Servomoteur par gestion angulaire.
// Un potentiomètre sur une entrés analogique génère la valeur de l'angle de commande.
// Utilise la librairie Servo.h fournie d'origine dans l'IDE.
#include <Servo.h>
Servo ServoMoteur; // Identificateur du moteur.
const byte Entree_mesuree = 5; // Entrée analogique 5 utilisée.
const byte Sortie_PWM = 10; // Broche PWM 10 utilisée.
float CNA; // Mesure analogique retournée par le CNA.
// Attention : Déclarer en float et non en byte, car
// les décimales affichées seraient des zéros.
byte CNA_binaire; // Conversion sur un octet.
void setup() {
ServoMoteur.attach(10); // Servo commandé par la PWM 10.
Serial.begin(19200);
}
void loop() {
CNA = analogRead(Entree_mesuree); //Sens direct si moteur RS2 MG/BB.
// CNA = 1024-CNA ; // Inverser le sens si moteur c'est le MC-1811 qui est utilisé.
CNA_binaire = CNA / 5.69; // Génère une valeur comprise entre 0 et 180.
ServoMoteur.write(CNA_binaire); // Transmet la consigne au servomoteur.
// Serial.println(CNA_binaire); // Affiche la valeur de la consigne sur la ligne USB.
}
Avec ce programme tu branches un potentiomètre entre le +5Vcc et la masse. Tu relie son curseur à l'entrée analogique A5. Ton servomoteur piloté par la sortie binaire PWM (D 10) va suivre angulairement les consignes du potentiomètre.
Bibli-Servo.pdf (23.8 KB)
Servomoteurs.pdf (76.9 KB)
Merci, cela m'a beaucoup aidée !
J'arrive à faire tourner mon moteur, pas encore exactement comme je voudrais, mais j'y suis presque 
Si vous avez encore la patience de m'aider un peu...
voilà mon programme:
#include <Servo.h>
Servo Servomoteur;
//Constantes
const int capteur=0; //Constante du capteur et numéro de sa broche analogique
//Variables
int valeur1 = 0 ;
int valeur2 = 0 ;
int valeur3 = 0 ;
int valeur4 = 0 ;
int valeurmax = 0 ;
int capteurPIN=0;
//Fonction Setup
void setup (){
pinMode(capteurPIN, INPUT); //Attacher la pin __ à l'objet Servomoteur
Servomoteur.attach(11); //Attacher le Servomoteur à la pin11, angle à 90°
Servomoteur.write(0); //Remettre l'angle à 0°
Serial.begin(9600);
}
//Fonction loop
void loop () {
Servomoteur.write(0);
valeur1=analogRead(capteur); //Relever la valeur1 du capteur
Serial.println(valeur1);
delay(2000);
if(valeur1>800 || valeur1<200) //Si la valeur1 est supérieure à 800 ou inférieure à 200
{Servomoteur.write(0);
delay(5000);} //Le moteur reste à l'arret
else
{valeurmax=valeur1; //La valeurmax prend la valeur1
Servomoteur.write(25); //Le moteur tourne jusqu'à 25°
delay(1000);
valeur2=analogRead(capteur); //Relever la valeur2 du capteur
Serial.println(valeur2);
delay(2000);
if(valeur2>800)
{Servomoteur.write(25);
delay(5000);
Servomoteur.write(0);} //Le moteur reste à l'arret
else
if(valeur2>valeurmax)
{valeurmax=valeur2; //La valeurmax prend la valeur2
Servomoteur.write(45);} //Le moteur tourne jusqu'à 45°
else
Servomoteur.write(45); //La valeur max est toujours valeur1 le moteur tourne jusqu'à 45°
delay(2000);
valeur3=analogRead(capteur); //Relever la valeur3
Serial.println(valeur3);
delay(2000);
if(valeur3>800)
{Servomoteur.write(45);
delay(5000);} //Le moteur reste à l'arret
else
if(valeur3>valeurmax)
{valeurmax=valeur3;
Servomoteur.write(75);}
else
Servomoteur.write(75);//La valeurmax reste valeur1 ou valeur2, le moteur tourne jusqu'à 75°
valeur4=analogRead(capteur); //Relever la valeur4
Serial.println(valeur4);
delay(2000);
if(valeur4>800)
{Servomoteur.write(75);
delay(5000);} //Le moteur reste à l'arret
else if(valeur4>valeurmax)
{Servomoteur.write(75);
Serial.println(valeurmax);}
//La valeur4 esr la plus élevée, le moteur reste donc en place
else if(valeurmax==valeur3)
{Servomoteur.write(45);} //La valeur3 est la plus élevée, le moteur tourne jusqu'à la postion v3
else if(valeurmax==valeur2)
{Servomoteur.write(25);} //La valeur2 est la plus élevée, le moteur tourne jusqu'à la postion v2
else
{Servomoteur.write(0);} //La valeur1 est la plus élevée, le moteur retourne à sa position de départ
delay(5000);} //Attendre une heure
}
Le seul problème que j'ai, c'est au début (entre autre) ; quand la valeur2 est supérieure à 800, elle retourne bien à 0, mais ensuite elle enchaine directement sur l'angle 45°, alors que je souhaiterai que le programme reprenne du début...
Pareil pour la valeur3>800...
Si vous avez une solution...
Merci !
Bonjour les copains,
Désolé, mais je suis sur le départ pour aller aider mon garçon Xavier à déménager. Du coup je n'ai pas le temps d'écrire et de tester tout un programme. Si c'était le cas, je crois que personnellement j'opterais pour une structure "switch case".
Chaque cas « case » serait relatif à une position désirée sur tous les axes. Je m'orienterais vers une procédure void() avec en entrées les paramètres angulaires désirés. Ainsi chaque "case" effectuerait un appel à cette procédure en lui envoyant les valeurs angulaires. Comme il se doit, chaque "bloc" du case serait terminé par un break.
C'est infiniment moins bien que de proposer un programme qui a fait ses preuves, mais si ça peut te donner une piste, j'en serai
Bonsoir !
Je réponds tard, je sais, mais je tenais à remercier ceux qui m'ont aidé.
J'ai passé mon Oral sur la programmation hier et tout c'est bien déroulé, tout fonctionne, enfin, c'est super !
Merci encore !