Bonjour,
Je souhaiterais faire tourner mon moteur durant une durée déterminée, une fois que j'ai appuyé sur mon interrupteur. Sauf que je n'arrive pas à me servir de la fonction millis()...
Je voudrais remplacer dans le code ci-dessous la fonction Stepcount par la fonction millis mais je n'y arrive pas.
#include <Stepper.h>
const int stepsPerRevolution = 200; // change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8,9,10,11);
// this constant won't change:
const int buttonPin = 7; // the pin that the pushbutton is attached to
const int ledPin = 13; // the pin that the LED is attached to
// Variables will change:
int stepCount = 0; // counter for the number of button presses
int buttonState = 0; // current state of the button
int lastButtonState = 0; // previous state of the button
void setup() {
// initialize the button pin as a input:
pinMode(buttonPin, INPUT);
// initialize the LED as an output:
pinMode(ledPin, OUTPUT);
// initialize serial communication:
Serial.begin(9600);
}
void loop() {
// read the pushbutton input pin:
buttonState = digitalRead(buttonPin);
// compare the buttonState to its previous state
if ((buttonState != lastButtonState) && (buttonState == HIGH) )
{
digitalWrite(ledPin, HIGH);
while ((buttonState == HIGH) && (stepCount < 100))
{
myStepper.step(1);
Serial.print("steps:" );
Serial.println (stepCount);
stepCount++;
delay(500);
buttonState = digitalRead(buttonPin);
}
}
digitalWrite(ledPin, LOW);
stepCount =0;
lastButtonState = buttonState;
}
J'ai essayé comme cela en déclarant t1, t2 et time comme unsigned long time;
void loop() {
t1=millis();
// read the pushbutton input pin:
buttonState = digitalRead(buttonPin);
// compare the buttonState to its previous state
if ((buttonState != lastButtonState) && (buttonState == HIGH) )
{
digitalWrite(ledPin, HIGH);
while ((buttonState == HIGH) && (time < 10000))
{
t2= millis();
myStepper.step(1);
time = t2-t1;
Serial.print("time:" );
Serial.println (time);
delay(500);
buttonState = digitalRead(buttonPin);
}
}
digitalWrite(ledPin, LOW);
lastButtonState = buttonState;
time=0;
}
Je suis inspiré de cette réponse mais je ne comprends pas trop comment ca marche...
http://forum.arduino.cc/index.php?topic=159470.0
Cela fonctionne une fois mais après la variable time ne revient pas à zéro j'ai l'impression.
Merci pour votre aide.
Merci beaucoup pour ton aide.
La gestion du bouton ne fonctionne pas. C'est un interrupteur 2 positions avec 3 pins:
- un sur le + de la carte
- un sur le - de la carte
- un sur le pin 7
Je souhaite que le moteur se lance uniquement quand le bouton est sur HIGH et qu'il s’arrête sur LOW même si la temporisation turnTime n'est pas finie.
Merci encore.
merci beaucoup, je teste ca de suite!
Une autre question, j'ai testé le premier programme en rentrant comme paramètre stepTime = 0, je suis donc à la vitesse max. qui est de 1.04 mm/s.
J'ai rentré comme durée 96154 ms, ca fonctionne nickel, je parcours bien 100 mm.
Comment puis je faire facilement le calcul de ma vitesse pour toutes les valeurs de stepTime?
Au final, je voudrais que l'utilisateur avec des potentiomètres puissent choisir la vitesse (entre Vmax et 1mm/heure) et la distance (entre 0 et 50 cm)
Merci
[edit] Le programme et l'interrupteur fonctionne parfaitement, merci!
Pour la vitesse, je ne peux pas me servir de la fonction setSpeed de mon driver EasyStepper1000 car au max j'ai 34 RPM ce qui fait environ 1 mm/s et au min 0.04 mm/s
Je suis donc loin de la valeur de 1mm/heure...
Je pensais donc avancer par pas de 1 avec un délai entre chaque pas.
Et de calculer ensuite la vitesse en fonction du temps d’exécution de la boucle de rotation de mon moteur, connaissant la vitesse max avec un délai nul...
Est ce possible?
Voila ce que j'ai fait. Les premiers essais me paraissent bons.
#include <Stepper.h>
const int stepsPerRevolution = 200;
Stepper myStepper(stepsPerRevolution, 8,9,10,11);
//Variable qui ne change pas
const int buttonPin = 7; // pin du bouton qui lance le moteur
const int ledPin = 13; // pin led
unsigned long btnTime = 20ul; // temporisation relachement bouton
//Variable qui change
unsigned long turnTime; // temporisation rotation moteur
unsigned long stepTime; // temporisation pas moteur
char phase;
unsigned long tTurn, tStep, tBtn;
int speedMoteurFine =0;
float speedMoteurScreen;
void setup() {
phase = 0;
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
unsigned long t = millis();
// read the sensorSpeedLarge value:
int sensorSpeedLarge = analogRead(A0);
// map it to a range from 0 to 1000:
double speedMoteurLarge = map(sensorSpeedLarge, 0, 1023, 28, 125000);
// read the sensorSpeedLarge value:
//int sensorSpeedFine = analogRead(A1);
// map it to a range from 0 to 1000:
//int speedMoteurFine = map(sensorSpeedFine, 0, 1023, -50, 50);
// read the sensorShortening value:
int sensorShortening = analogRead(A1);
// map it to a range from 0 to 1000:
int disTance = map(sensorShortening, 0, 1023, 0, 500);
double speedMoteur = speedMoteurLarge + speedMoteurFine;
speedMoteurScreen=speedMoteur/100000; //100000 pour affichage en mm/s
turnTime = (0.0125/speedMoteurScreen)*1000; //*1000 car secondes en entree
stepTime = (disTance/speedMoteurScreen)*1000; //*1000 car secondes en entree
Serial.print("speedMoteurScreen");
Serial.println(speedMoteurScreen);
Serial.print("disTance");
Serial.println(disTance);
if (phase == 0) { // attente d'appui sur le bouton ?
if (digitalRead(buttonPin)==HIGH) { // bouton appuyÈ ?
digitalWrite(ledPin, HIGH); // allume la led
phase = 1; // -> rotation du moteur
myStepper.step(-1); // premier pas moteur
tTurn = tStep = tBtn = t; // dÈbut des temporisations
}
} else {
if (digitalRead(buttonPin)==HIGH) // bouton toujours appuyÈ ?
tBtn = t; // reprend au dÈbut la temporisation bouton
else
if (t - tBtn >= btnTime) { // fin temporisation aprËs bouton rel‚chÈ ?
phase = 0; // -> attente d'appui sur le bouton
digitalWrite(ledPin, LOW); // Èteindre la led
Serial.print("time:" ); // envoi message d'info
t -= tTurn;
Serial.print(t);
Serial.println(" interrompu");
}
if (phase == 1) { // moteur en rotation
if (t - tTurn >= turnTime) {// temporisation rotation moteur terminÈe ?
digitalWrite(ledPin, LOW);// Èteindre la led
phase = 2; // -> attente de rel‚chement du bouton
Serial.print("time:" ); // envoi message d'info
t -= tTurn;
Serial.print(t);
Serial.println(" fin");
} else
if (t - tStep >= stepTime) {// temporisation pas moteur terminÈe ?
myStepper.step(-1); // pas moteur suivant
tStep = t; // dÈbut temporisation pas moteur
Serial.print("time:" ); // envoi message d'info
t -= tTurn;
Serial.println(t);
}
}
}
// taches a rajouter ...
}
Merci pepe des conseils.
Je vais mieux définir ce que je souhaite.
J'ai un moteur pas à pas (1 pas = 0.0125 mm) qui va devoir:
- tourner à une vitesse définie par l'utilisateur entre 0.00028 mm/s et 1.25 mm/s
- et faire un certain nombre de tours pour déplacer un chariot fixé sur une vis sans fin sur une distance (entre 0 et 500 mm) également définie par l’utilisateur.
Le réglage s'effectue sur un écran LCD et à l'aide de 3 potentiomètres:
- 2 pour le réglage de la vitesse un large et un plus fin pour ajuster. L'affichage devra etre en mm/s.
- 1 pour la distance, l'affichage devra être en mm.
Lorsque le bouton est sur OFF, on peut régler la vitesse et la distance.
Lorsque le bouton est sur ON, le moteur tourne suivant les paramètres précédents.
Durant le fonctionnement du moteur, on doit pouvoir l’arrêter sans attendre la fin de la temporisation en remettant le bouton sur OFF.
J'espère que ca sera plus clair. Dis moi si j'ai oublié des détails. Merci beaucoup.
Est ce que c'est assez détaillé pour toi, pepe? Est ce réalisable ?
Merci encore