Bonjour je me présente J-M je suis nouveau sur le forum, et nouveau dans la conception de programme sur arduino.
Ma demande, vu que je n'ai pas vraiment le temps d'étudier tout les termes et astuces des commandes,
j'ai besoin de commander 5 servo (avec possibilité de régler leurs vitesses de fonctionnement) c'est 5 servo vont commander des ailes ils doivent fonctionner par paire sauf le dernier qui est pour le relevage des ailes.la première paire pour ouverture ailes(gauche et droite) 2e paire pour déploiements des ailes(gauche droite) et le dernier redressement de la paire d'aile.
jusque là assez simple, mon soucis est qu'il faudrait que chaque partie soit commander par un seul et unique bouton poussoir qui en l'actionnant 1x ouvre les ailes 2 x déploie les ailes et 3 redresse les ailes. et inversement dans l'autre sens avec un second( j'avais vu une commande comme ça pour 4 led fonctionnement style échelle)
J'ai besoin de ce programme rapidement pour tester le tout.
Je me doute que chacun doit se débrouiller et programmer mais la je suis vraiment coincé
le matériels dont je dispose
-Platine uno R3
-plaque prototype pour fillerie
-platine de commande 16 servoPCA9685
-2 servo hitec HS485HB
-2 servo goteckGS-9025MG
-5 ieme servo pas encore défini
-bouton poussoir Lylypad pour vetements
-batterie 6v
Pour ceux qui me créerais ce programme je vous en remercie d'avance et je posterai plus tard les photos de ce que j'ai réalisé
Demandez au moderator de déplacer votre post dans le forum français (mais vu votre demande il vaudrait mieux écrire cela en anglais et aller dans l'espace gigs and collaboration et être prêt à rétribuer un contributeur pour le code votre place.)
Please ask the moderator to move your post to the French forum but given your ask you should probably write that in English, be ready to offer compensation (you are looking someone to do your work and clearly express not willing to learn and needing it quick), and post in the gigs and collaboration forum
Pour avoir un comportement/réaction différent par bouton tu peux t'inspirer de ce tuto. Il ne te restera plus qu'à commander tes servos selon le bouton qui est appuyé...
bonjour, voici un code que j'ai rentré mais rien ne fonctionne comme je le voudrais
j'ai mis compteur de bp les servos vont sans arrêt et sans appuyer sur les bp
aussi vu que il y a 2 paires de servos pour les premier ils sont censé pour un partir de 0 et l'autre de 42 mais ça donne pas le resultat voulu
de plus il ne s'arrete jamais donc le prog s'excucute sans arrêt et se deconnecte aussi du pc comme si je retirais le cable usb
quelqu'un pourrait il m'aider
#include <Servo.h> //import de la bibliothèque Servo
/* déclaration des constantes pour les noms des broches ; ceci selon le schéma*/
const int btn_minus = 2;
const int btn_plus = 3;
int servo_0 = 6;
int servo_1 = 7;
int servo_2 = 8;
int servo_3 = 9;
int servo_4 = 10;
/* déclaration des variables utilisées pour le comptage et le décomptage */
int nombre_servo = 0; //le nombre qui sera incrémenté et décrémenté
int etat_bouton; //lecture de l'état des boutons (un seul à la fois mais une variable suffit)
int etat_servo_0 = 0;
int etat_servo_1 = 42;
int etat_servo_2 = 0;
int etat_servo_3 = 60;
int etat_servo_4 = 0;
Servo Servo_ouverture_D;
Servo Servo_ouverture_G;
Servo Servo_deploiement_D;
Servo Servo_deploiement_G;
Servo Servo_relevage;
void setup() {
Servo_ouverture_D.attach(servo_0); // on relie l'objet au pin de commande
Servo_ouverture_G.attach(servo_1); // on relie l'objet au pin de commande
Servo_deploiement_D.attach(servo_2); // on relie l'objet au pin de commande
Servo_deploiement_G.attach(servo_3); // on relie l'objet au pin de commande
Servo_relevage.attach(servo_4); // on relie l'objet au pin de commande
pinMode(btn_plus, INPUT_PULLUP);
pinMode(btn_minus, INPUT_PULLUP);
pinMode(servo_0, OUTPUT);
pinMode(servo_1, OUTPUT);
pinMode(servo_2, OUTPUT);
pinMode(servo_3, OUTPUT);
pinMode(servo_4, OUTPUT);
}
int memoire_plus = HIGH; //état relâché par défaut
int memoire_minus = HIGH;
void loop() {
Servo_ouverture_D.write(42);
Servo_ouverture_G.write(0);
Servo_deploiement_D.write(60);
Servo_deploiement_G.write(0);
Servo_relevage.write(0);
//lecture de l'état du bouton d'incrémentation
etat_bouton = digitalRead(btn_plus);
//Si le bouton a un état différent que celui enregistré ET que cet état est "appuyé"
if((etat_bouton != memoire_plus) && (etat_bouton == LOW))
{
nombre_servo++; //on incrémente la variable qui indique combien de LED devrons s'allumer
}
memoire_plus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant
etat_servo_0 = digitalRead(42);
etat_servo_1 = digitalRead(42);
etat_servo_2 = digitalRead(0);
etat_servo_3 = digitalRead(60);
etat_servo_4 = digitalRead(0);
//et maintenant pareil pour le bouton qui décrémente
etat_bouton = digitalRead(btn_minus); //lecture de son état
//Si le bouton a un état différent que celui enregistré ET que cet état est "appuyé"
if((etat_bouton != memoire_minus) && (etat_bouton == LOW))
{
nombre_servo--; //on décrémente la valeur de nombre_led
}
memoire_minus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant
//on applique des limites au nombre pour ne pas dépasser 4 ou 0
if(nombre_servo > 3)
{
nombre_servo = 3;
}
if(nombre_servo < 0)
{
nombre_servo = 0;
}
Servo_ouverture_D.write(0); // on dit à l'objet de mettre le servo à 0°
Servo_ouverture_G.write(42); // on dit à l'objet de mettre le servo à 0°
Servo_deploiement_D.write(0); // on dit à l'objet de mettre le servo à 0°
Servo_deploiement_G.write(60); // on dit à l'objet de mettre le servo à 0°
Servo_relevage.write(55); // on dit à l'objet de mettre le servo à 0°
}
void affiche(int valeur_recue)
{
//on éteint toutes les LEDs
if(valeur_recue <= 3)
{
digitalWrite(servo_0, HIGH);
digitalWrite(servo_1, HIGH);
digitalWrite(servo_2, HIGH);
digitalWrite(servo_3, HIGH);
digitalWrite(servo_4, HIGH);
}
//Puis on les allume une à une
if(valeur_recue >= 1)
{
digitalWrite(servo_0, LOW);
digitalWrite(servo_1, LOW);
digitalWrite(servo_2, HIGH);
digitalWrite(servo_3, HIGH);
digitalWrite(servo_4, HIGH);
}
if(valeur_recue >= 2)
{
digitalWrite(servo_2, LOW);
digitalWrite(servo_3, LOW);
}
if(valeur_recue >= 3)
{
digitalWrite(servo_4, LOW);
}
//appel de la fonction affiche() que l'on aura créée
//on lui passe en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_servo);
}[code]
corrigez votre post ci dessus et rajoutez lescode tags autour du code: [code]`` [color=blue]// your code is here[/color] ``[/code].
ça doit ressembler à cela:// your code is here
(faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit intenté correctement)
mettez toutes les déclarations de variables en haut, as au milieu des fonctions
int memoire_plus = HIGH; //état relâché par défaut
int memoire_minus = HIGH;
ici les commentaires n'ont rien à voir avec ce que fait le code
Servo_ouverture_D.write(0); // on dit à l'objet de mettre le servo à 0°
Servo_ouverture_G.write(42); // on dit à l'objet de mettre le servo à 0°
Servo_deploiement_D.write(0); // on dit à l'objet de mettre le servo à 0°
Servo_deploiement_G.write(60); // on dit à l'objet de mettre le servo à 0°
Servo_relevage.write(55); // on dit à l'objet de mettre le servo à 0°
...
essayez d'abord d'écrire votre programme "en français"
Que doit faire la partie initialisation
Quand on est dans la boucle, que doit on faire? avez vous différents états possibles? doivent-ils être mémorisés? comment passe-t-on d'un état à l'autre?
une fois que vous avez documenté cela, le code sera plus simple à écrire.
Bonjour J-M-L,
je débute donc je ne comprend pas tout..
j'ai modifié mon message
le "digital read" bin je sais pas trop si c'est necessaire?
Le but c'est de pouvoir par une pulsion sur le poussoir commander l'ouverture en 1 le déploiements en 2 et le relevage des ailes en 3 et puis inversement.
mais je n'ai pas besoin de faire répéter si il n'y en a pas besoin
Je veux que la commande est manuelle pour chaque mouvement
Maintenant si il y a moyen en appuyant plus d'un certains temps sur le poussoir ou les 2 en même temps de donner une fonction qui va procéder aux 3 mouvement d'ailes, c'est aussi bien
ps pour les écritures derrière les codes je n'ai pas toujours effacés quand j'ai recopiés les codes
AU départ les ailes sont repliées, fermées, et baissées dans le dos.
à la première pression sur un lylypad cousu sur un gant les ailes s'ouvrent.
2 e pression les ailes se déploient
et 3 e les ailes se redressent.
Donc au départ vu que les servos fonctionnent par paires le 1 et 2 sont en fonctionnement inversé donc le point de départ du gauche est de 0 degré et le droit commence à 42°
idem pour 3 et 4 le 5 étant normalement seul
1 bouton, un moteur. faites lui faire ce que vous voulez.
prenez éventuellement une librairie pour gérer le bouton comme ça vous n'avez pas à vous casser la tête. j'aime bien la OneButton Library parce qu'elle gère le click, double click, ou appui long.
Merci pour tes infos je vais essayer sinon je programme le schema complet et je coupe l'alim a chaque fois..
En attendant que je finisse par avoir ce dont je veux..
Encore merci.
voici une structure de code à regarder pour vous donner des idées. ça va détecter les simples click ou double click sur 2 boutons et décider d'une action (ici juste imprimer un texte) en fonction de ce qu'à fait l'utilisateur.
le câblage:
A1 --- bouton1 --- GND
A2 --- bouton2 --- GND
câble USB entre votre arduino et votre ordinateur
mettre la console série à [color=red]115200[/color] pour voir l'affichage
#include "OneButton.h"
// les type de détection que l'on peut suivre sur un bouton:
// void attachClick();
// void attachDoubleClick();
// void attachLongPressStart();
// void attachLongPressStop();
// void attachDuringLongPress();
// Le circuit avec des boutons momentannés
// On va utiliser la fonction de INPUT_PULLUP
// donc la connexion se fait
// A1 --- bouton1 --- GND
// A2 --- bouton2 --- GND
// la librairie se charge de mettre la pin en INPUT_PULLUP
OneButton bouton1(A1, true); // No de pin , booléen qui dit si actif LOW (PULLUP)
OneButton bouton2(A2, true); // No de pin , booléen qui dit si actif LOW (PULLUP)
// drapeaux de mémoire d'action
int appuiBouton1 = 0;
int appuiBouton2 = 0;
void setup() {
Serial.begin(115200); // attention mettre la console Série à 115200
// on enregistre les fonctions appelées en cas de simple ou double click
bouton1.attachClick(b1click);
bouton2.attachClick(b2click);
bouton1.attachDoubleClick(b1doubleclick);
bouton2.attachDoubleClick(b2doubleclick);
}
void loop() {
// On regarde l'état des boutons le plus souvent possible.
bouton1.tick();
bouton2.tick();
// ici ne pas faire de code qui bloquerait trop longtemps
// utliser les techniques de gestion d'état pour repasser par la boucle
// sinon on risque de rater des appuis sur les boutons
if (appuiBouton1) { // différent de zero, quelque chose s'est passé, agir en conséquence
// ne pas faire de code bloquant ou long ici !!!
if (appuiBouton1 == 1) {
Serial.print("click Bouton 1");
} else if (appuiBouton1 == 2) {
Serial.print("double click Bouton 1");
}
appuiBouton1 = 0; // remise à zero du drapeau
}
if (appuiBouton2) { // différent de zero, quelque chose s'est passé, agir en conséquence
// ne pas faire de code bloquant ou long ici !!!
if (appuiBouton2 == 1) {
Serial.print("click Bouton 2");
} else if (appuiBouton2 == 2) {
Serial.print("double click Bouton 2");
}
appuiBouton2 = 0; // remise à zero du drapeau
}
}
// Les fonctions appelées en cas d'action sur les boutons.
void b1click() {
appuiBouton1 = 1; // on met un drapeau pour dire que le bouton a été appuyé
}
void b1doubleclick() {
appuiBouton1 = 2; // on met un drapeau pour dire que le bouton a été double clické
}
void b2click() {
appuiBouton2 = 1; // on met un drapeau pour dire que le bouton a été appuyé
}
void b2doubleclick() {
appuiBouton2 = 2; // on met un drapeau pour dire que le bouton a été double clické
}