#include <AccelStepper.h>
#include <MultiStepper.h>
AccelStepper mp1(4, 9, 11, 10, 12);
AccelStepper mp2(4, 5, 7, 6, 8);
const int joyPinX = A0;
const int joyPinY = A1;
int x, y, buttonVal, vitesse;
int Maxvitesse = 800;
int dist = 12000;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
mp1.setMaxSpeed(Maxvitesse);
mp2.setMaxSpeed(Maxvitesse);
mp1.setAcceleration(400);
mp2.setAcceleration(400);
}
void loop() {
// put your main code here, to run repeatedly:
checkJoy();
if (x > 800) {
vitesse = 500;
dist--;
setMove(vitesse);
move();
}
if (x < 300) {
vitesse = -500;
dist++;
setMove(vitesse);
move();
}
if (y < 300) {
vitesse = -500;
setMove(vitesse);
while (dist < 12000) {
move();
dist++;
}
}
if (y > 800) {
vitesse = 500;
setMove(vitesse);
while (dist > 1) {
move();
dist--;
}
}
if (x < 800 && x > 300 && y > 300 && y < 800) {
vitesse = 0;
setMove(vitesse);
}
Serial.println(dist);
}
void checkJoy() {
x = analogRead(joyPinX);
y = analogRead(joyPinY);
}
void setMove(int vit) {
mp1.setSpeed(-vit);
mp2.setSpeed(vit);
}
void move() {
mp1.runSpeed();
mp2.runSpeed();
}
Je suis en train de créer un rideaux automatique afin de le baisser et remonter avec un joystick.
Lorsque je veux le remonter d'un coup je pousse le joystick à droite et lorsque je veux le redescendre d'un coup le joystick a gauche sachant que je gère la durée de la montée/descente avec une variable dist. Lorsque je veux le redescendre ou remonter a un niveaux que je souhaite je monte et baisse le joystick.
Voici mon problème : lorsque je veux redescendre ou remonter automatiquement sans avoir utiliser le joystick avant cela fonctionne. Mais lorsque je monte ou baisse un petit peu le joystick ma variable dist lorsque je lance ma boucle while atteins directement la valeur cible de la boucle sans passer par les instructions de la boucle.
Ce qui semble contradictoire avec le code puisque l'ouverture/fermeture automatique est lancée par une action sur l'axe Y.
Cette boucle ne fait pas avancer le moteur d'un pas à chaque itération de la boucle. Donc tu n'as pas le droit de faire incrémenter/décrémenter dist à chaque itération.
Le moteur n'avance que si un certain temps (fixé par la vitesse) s'est écoulé.
En admettant que la vitesse que tu as choisie n’entraîne jamais de saut de pas et que tu ne demandes jamais d'aller au-delà des extrémités, Il faudrait que tu travailles en nombre de pas à effectuer et non pas en nombre d'itération des boucles.
Pourtant j'utilise la fonction move() sur l'axe x et cela fonctionne.
Mais c'est uniquement avec la boucle while() que cela ne fonctionne pas.
En effet j'utilise l'axe x afin de pouvoir le baisser ou monter a la hauteur que je veux.
Et c'est la variable dist qui est modifiée à chaque utilisation de l'axe x ensuite lorsque j'utilise l'axe y en fonction de la valeur de dist la durée d'activation des moteurs sera plus ou moins longue.
La boucle while s'exécute très rapidement.
move() appelle runSpeed() mais runSpeed() ne fait pas avancer le moteur d'un pas à chaque appel donc dist s'incrémente plus vite que n'avance le moteur.
Lorsque tu fais avancer avec l'axe des X la boucle est plus lente (il y a entre autres le Serial.println() qui prend un peu de temps).
En fait, ton codes actuel joue sur le temps d'exécution du programme et c'est mal.
La librairie accelStteper ne fonctionne pas comme ça.
On lui donne des consignes (vitesse, nombre de pas à faire) et dans loop() on doit appeler l'une des méthodes runXXXX() tant que la consigne n'a pas été atteinte.
Cela implique de fonctionner en nombre de pas à effectuer.
Il faut donc connaitre au départ combien de pas il faut faire pour aller d'une extrémité à l'autre et ensuite il faut savoir à chaque instant où on se trouve dans ce compte de pas.
Par exemple au départ on est au pas 0. On sait qu'il faut faire N pas pour aller à l'extrémité.
On appelle move() avec comme consigne de faire N pas et ensuite on boucle sur run() tant que la consigne n'est pas atteinte (run retourne un booléen qui indique si le moteur est à destination ou pas).
Lorsqu'on reprend la main on sait que l'on est à la position N.
Si tu veux te déplacer plus lentement tu donnes une consigne de n pas (n positif ou négatif suivant le sens) lorsque le moteur s'arrête tu sais que tu est à la position N±n.
Le mieux, c'est de lire la doc car il y a plusieurs manières d'arriver au même résultat suivant le comportement que l'on attend du programme.
Il faut penser à donner une vitesse et une accélération raisonnables pour éviter que le moteur saute des pas et que tu ne saches plus on tu te trouves.
Cela veut dire aussi qu'il faut un moyen de savoir où on se trouve lorsqu'on démarre. Il faudrait avoir à minima un fin de course pour avoir une position de référence.
tu peux passer le Serial à 115200, c'est sans risque et ton prg perdra moins de temps à écrire sur le moniteur. perdra n'est pas le bon mot car pour le debug, on ne perd pas de temps, on en gagne
perdra n'est pas le bon mot car pour le debug, on ne perd pas de temps, on en gagne 
