Utilisation fonction millis

Bonjour à tous, j'utilise un pont en H pour piloter un moteur cc. Jusque là j'utilisais des delay et tout fonctionnait bienmais les delay étant des fonctions bloquantes, je désire maintenant utiliser la fonction millis().
Je veux que le moteur tourne dans le sens horaire durant 10 secondes, s'arrête durant 15 secondes, tourne dans le sens anti horaire durant 10 secondes et enfin s'arrête durant 30 secondes avant de recommencer.

J'ai fait le code suivant (en m'aidant de chat gpt j'avoue).

const long movement = 10000;
unsigned long littlePause = 15000;
unsigned long bigPause = 30000;
unsigned long previousMillis = 0;

int DIR = 11; // broche de direction IN1
int PWM = 12; // broche de direction IN2, vitesse moteur
int EN = 13; // broche d'activation ENA

void setup() {
 pinMode(DIR, OUTPUT);
  pinMode(PWM, OUTPUT);
  pinMode(EN, OUTPUT);
}

void loop() {
  digitalWrite(EN, HIGH);
  unsigned long currentMillis = millis();

    if(currentMillis - previousMillis >= movement) {
      digitalWrite(DIR, LOW); 
      analogWrite(PWM, 255); //à régler pour atteindre 10 secondes
      previousMillis = currentMillis;
    }

    else if(currentMillis - previousMillis >= littlePause) {
      analogWrite(PWM, 0);
      previousMillis = currentMillis;
      //delay(15000);
    }

    else if(currentMillis - previousMillis >= movement) {
      digitalWrite(DIR, HIGH); 
      analogWrite(PWM, -255);
      previousMillis = currentMillis;
    //delay(10000); à déterminer pour descente
    }

    else if(currentMillis - previousMillis >= bigPause) {
      digitalWrite(DIR, LOW);
      analogWrite(PWM, 0);
      previousMillis = currentMillis;
      //delay(30000);
    }
}

Il ne fonctionne hélas pas. Pourriez-vous m'aider s'il vous plaît ?

Bonjour siete2000

Il manque un bout de ta description :woozy_face:

A+
jpbbricole

Hello, merci pour ta réponse, c'est corrigé :stuck_out_tongue_winking_eye:

c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

un truc du genre peut-être (tapé ici, non testé)

const byte dirPin = 11;     // broche de direction IN1
const byte pwmPin = 12;     // broche de direction IN2, vitesse moteur
const byte enablePin = 13;  // broche d'activation ENA

const unsigned long dureeEnMouvement    = 10000ul;
const unsigned long petitePause         = 15000ul;
const unsigned long grandePause         = 30000ul;

enum {DEBUT, ETAPE1, ETAPE2, ETAPE3, ETAPE4} etapeEnCours = DEBUT;
unsigned long previousMillis;

void avant(const byte pwm) {
  digitalWrite(enablePin, HIGH);
  digitalWrite(dirPin, LOW);
  analogWrite(pwmPin, pwm);
  previousMillis = millis();
}

void arriere(const byte pwm) {
  digitalWrite(enablePin, HIGH);
  digitalWrite(dirPin, HIGH);
  analogWrite(pwmPin, pwm);
  previousMillis = millis();
}

void stop() {
  digitalWrite(pwmPin, LOW);
  digitalWrite(enablePin, LOW);
  previousMillis = millis();
}

void setup() {
  pinMode(dirPin, OUTPUT);
  pinMode(pwmPin, OUTPUT);
  pinMode(enablePin, OUTPUT);
}

void loop() {
  switch (etapeEnCours) {
    case DEBUT:
      avant(255);
      etapeEnCours = ETAPE1;
      break;

    case ETAPE1:
      if (millis() - previousMillis >= dureeEnMouvement) {
        stop();
        etapeEnCours = ETAPE2;
      }
      break;

    case ETAPE2:
      if (millis() - previousMillis >= petitePause) {
        arriere(255);
        etapeEnCours = ETAPE3;
      }
      break;

    case ETAPE3:
      if (millis() - previousMillis >= dureeEnMouvement) {
        stop();
        etapeEnCours = ETAPE4;
      }
      break;

    case ETAPE4:
      if (millis() - previousMillis >= grandePause) {
        avant(255);
        etapeEnCours = ETAPE1;
      }
      break;
  }
}

j'ai fait exprès d'être très "verbeux" pour détailler les 5 étapes on pourrait faire plus condensé mais peut être moins lisible.

Bonsoir siete2000

Je te propose une autre approche, toujours sous le signe des millis(), c'est à dire non bloquante, mais en créant une sorte de programmation.
Ainsi,

devient:

const String motProgr[] = {"H10", "S15", "A10", "S30"};

où H est le sens horaire (CW), A est le sens anti horaire (CCW), S pour STOP.
Avec cette "mécanique, tu peux changer ton programme facilement, tu pourrais même créer de nouvelles instructions. Pour en ajouter une, il suffit de la mettre à la suite, ou l'insérer entre deux autres, c'est tout.

Ce programme n'agit pas sur tes moteurs mais indique uniquement le mouvement dans la console à 115200.
La variable millisFacteur permet raccourcir les temporisations afin d'accélérer le programme, ainsi si millisFacteur = 5, les temps sont 5 x plus courts.

J'ai mis un maximum de remarques dans le programme, mais n'hésites pas à poser des questions :wink:

Le programme:

/*
    Name:       ARDFR_MoteurProgMillis.ino
    Created:	15.12.2023
    Author:     jpbbricole
				#5
	https://forum.arduino.cc/t/utilisation-fonction-millis/1200728
*/
const String motProgr[] = {"H10", "S15", "A10", "S30"};
const int motProgrSteps = 4;     // Nombre de pas de programme 0-3
int motProgrNum;     // Pas du programme en cours
bool motPrgEnCours = false;

unsigned long progrStepTempo = 0;     // Temporisation du pas de programme
unsigned long progrStepMillis = 0;     // Temporisation du pas de programme, chrono

const int millisFacteur = 1;     // Pour accélérer les essais, temps normal = 1

void setup()
{
	Serial.begin(115200);

	motProgrNum = -1;
	motPrgEnCours = false;     // Rien en cours
}

void loop()
{
	if (!motPrgEnCours)     // Si plus rien en cours
	{
		if (motProgrNum == motProgrSteps -1)     // Si dernier pas d'un cycle
		{
			Serial.println(F("Fin d'un cycle"));
		}

		motProgrNum ++;
		motProgrNum = (motProgrNum == motProgrSteps) ? 0 : motProgrNum;     // Pas de programme suivant

		motProgExecute(motProgrNum);
		motPrgEnCours = true;     // Un pas de programme est en cours
	}

	//--------------------------------- Temporisation du mouvement du moteur
	if (motPrgEnCours && (millis() - progrStepMillis >= progrStepTempo))     // Si fin du pas de programme
	{
		motPrgEnCours = false;
	}
}

//------------------------------------- Exécution d'un pas de programme
void motProgExecute(int stepIndex)
{
	String progrDir = motProgr[stepIndex].substring(0,1);     // Extraction de la direction du moteur H, A ou S
	int progTime = motProgr[stepIndex].substring(1).toInt();     // Extraire le peramètre de temps

	if (progrDir == "H") {motCW();}    // Sens horaire
	else if (progrDir == "A") {motCCW();}    // Sens anti horaire
	else if (progrDir == "S") {motStop();}    // STOP

	Serial.println("\t" + String(progTime) + " secondes");

	progrStepTempo = progTime * (1000 / millisFacteur);     // Temps d'éxecution
	progrStepMillis = millis();     // Démarrage du chrono
}

//------------------------------------- Mouvements du moteur
void motCW()
{
	Serial.print(F("Moteur CW"));
}

void motCCW()
{
	Serial.print(F("Moteur CCW"));
}
void motStop()
{
	Serial.print(F("Moteur STOP"));
}

A+
Cordialement
jpbbricole

Bonjour à tous, merci pour vos réponses ! Je vais prendre le temps de bien analyser vos codes pour les comprendre au mieux ! Je pense que ce sont des notions très importantes à avoir :grin:
Merci encore et à + !