transformer delay en millis()

Bonjour à toutes et à tous.

Le sujet a dû être traité une bonne centaine fois mais je ne trouve pas de topic qui puisse m'aider. J'ai passé du temps beauuuuuucoup de temps à essayer de comprendre sans succès .

Alors voilà: dans la maquette du faucon millenium, un appui sur le bouton fait descendre la trappe et allume l'éclairage. Un autre appui sur le bouton remonte la trappe et la lumière s’éteint.
Le programme avec du delay marche à merveille mais lorsque je veux le remplacer par du millis() ... ça marche pas.

"Au secours les Obi wan Kenobi du forum, vous êtes mon seul espoir"

Le programme à base de delay

/* ------------------- DECLARATIONS DES VARIABLES ---------*/
// Rampe
int etat_bouton;
int leds_rampe;
int moteur_descente;
int moteur_montee;
int moteur_validation;
// Variable qui stocke la mesure du temps.
long temps;
// Variable etat_leds à 0 (boolean ne prend que 2 valeurs: 0 ou 1
boolean etat_leds = false;



/*------------------------------------ INITIALISATION ------------*/

void setup()
{



  // Initialisation des pins pour le moteur.
  // moteur_descente sur pin4 en sortie
  pinMode(moteur_descente = 4, OUTPUT);
  // Moteur_Montée sur pin5 en sortie
  pinMode(moteur_montee = 5, OUTPUT);
  // moteur_validation sur pin6 en sortie
  pinMode(moteur_validation = 6, OUTPUT);
  // déclaration du bouton en entrée avec la résistance pullup  interne
  pinMode(etat_bouton = 3, INPUT_PULLUP);
  // Led_rampe sur pin7 en sortie
  pinMode(leds_rampe = 7, OUTPUT);
  // Initialisation du temps
  temps = millis();
}

/*-----------------------------  EXECUTION  -------------------------------- */
void loop()
{

  //telecommande();
  rampe();
  //rampeIR();

}

/*----------------------------- SOUS PROGRAMME -------------------*/
/*--------------------------  Sous Programme pour la rampe -------------------------------*/
void rampe()
{
  //Lire la pin3 et stocker dans etat_bouton
  etat_bouton = digitalRead(3);

  // SI Bouton pressé ET Leds éteintes 
  if (etat_bouton == LOW && etat_leds == false)
  {
    //  Activer Moteur en desccente pendant 3s
    digitalWrite(moteur_descente, HIGH);
    digitalWrite(moteur_validation, HIGH);
    // Activer leds_rampe
    digitalWrite(leds_rampe, HIGH);
    // Mémorisation état LEDS Rampe( allumées )
    etat_leds = true;
    // Moteur fonctionne pendant 3000ms
    delay(3000);
    // Arret Moteur
    digitalWrite(moteur_validation, LOW);
    digitalWrite(moteur_descente, LOW);
  }

  // SiNON SI Bouton pressé ET leds allumées 
  else if (etat_bouton == LOW && etat_leds == true)
  {
    //  Activation Moteur en monté
    digitalWrite(moteur_validation, HIGH);
    digitalWrite(moteur_montee, HIGH);
    // Moteur fonctionne pendant 3000ms
    delay(3000);
    // Arret Moteur
    digitalWrite(moteur_validation, LOW);
    digitalWrite(moteur_montee, LOW);
    // Extinction Leds Rampe
    digitalWrite(leds_rampe, LOW);
    //Mémorisation état LEDS Rampe (éteintes)
    etat_leds = false;
  }
}

Et voici le programme à base de millis() qui ne fonctionne pas et où je me perds en comprehension et essais.

/*------------------------------ DECLARATIONS DES VARIABLES --------------- */
// Rampe
int etat_bouton;
int leds_rampe;
int moteur_descente;
int moteur_montee;
int moteur_validation;
// Variable qui stocke la mesure du temps.
unsigned long temps;
// Variable etat_leds à 0 (boolean prend que 2 valeurs: 0 ou 1
boolean etat_leds = false;



/*------------------------------------ INITIALISATION --------------------*/

void setup()
{
  // Initialisation des pins pour le moteur.
  // moteur_descente sur pin4 en sortie
  pinMode(moteur_descente = 4, OUTPUT);
  // Moteur_Montée sur pin5 en sortie
  pinMode(moteur_montee = 5, OUTPUT);
  // moteur_validation sur pin6 en sortie
  pinMode(moteur_validation = 6, OUTPUT);
  // déclaration du bouton en entrée avec la résistance pullup  interne
  pinMode(etat_bouton = 3, INPUT_PULLUP);
  // Led_rampe sur pin7 en sortie
  pinMode(leds_rampe = 7, OUTPUT);
  // stockage millis() dans temps
  temps = millis();
}

/*-------------------------------------  EXECUTION  -------------*/
void loop()
{
  rampe();
}

/*--------------------------  Sous Programme pour la rampe --------------*/
void rampe()
{
  //Lire la pin3 et stocker dans etat_bouton
  etat_bouton = digitalRead(3);

  // SI Bouton pressé ET Leds éteintes alors
  if ( etat_bouton == LOW && etat_leds == false)
  {
    // Tempo de 3 secondes

    // Activer Moteur en desccente pendant 3s
    // Stockage valeur millis() dans temps
    temps = millis();
    // Activation des leds de la rampe
    digitalWrite(leds_rampe, HIGH);
    // Activation du moteur
    digitalWrite(moteur_validation, HIGH);
    // Le moteur descend
    digitalWrite(moteur_descente, HIGH);
    // Les leds_rampe sont allumées
    etat_leds = true;

    // Tempo de 3 sec puis arret moteur
    if (millis() - temps > 3000)
    {
      // Arret moteur
      digitalWrite(moteur_descente, LOW);
      digitalWrite(moteur_validation, LOW);
      temps = millis();
    }
  }
  
  
  // SiNON SI Bouton pressé ET leds allumées
  else if ( etat_bouton == LOW && etat_leds == true)
  {
    temps = millis(); // on demarre le comptage
    //  Activation Moteur en monté
    digitalWrite(moteur_montee, HIGH);
    digitalWrite(moteur_validation, HIGH);

    if (millis() - temps > 3000)
    {
      // Arret moteur
      digitalWrite(moteur_montee, LOW);
      digitalWrite(moteur_validation, LOW);
      // Extinction leds
      etat_leds = false;
      temps = millis();
    }
  }
}

Merci infiniment pour votre aide.

Pourquoi veux-tu faire un programme avec millis si delui avec delay fonctionne ?
L'intérêt de millis est de permettre de faire plusieurs choses "à la fois", c'est à dire ne pas bloquer l'exécution du programme pendant l'attente du delay. As-tu besoin de ça ?

Tu peux trouver des tutos un peu partout, notamment ici

Le problème est dans la question : comment transformer delay en millis() ?

On ne peut pas transformer delay() en millis(). Ca n'a pas de sens.

Appeler delay(), c'est prendre un somnifère. Tu le prends, tu dors 30 secondes. Tu roupilles.

Appeler millis(), c'est regarder l'heure. Quelle heure est-il ? 40000 ms après le BIG BANG. Tu ne dors pas, tu sais l'heure qu'il est.

Dans ta vie, tu ne remplaces pas une sieste par un regard à ta montre ?

Donc, pour n'être jamais bloqué, on vire tous les appels à delay().
Et du coup - bad news - il faut réorganiser complètement son code.
En pensant constamment : tout ce que j'ai pour m'occuper du temps qui passe, c'est la possibilité de demander l'heure.

hello
par exemple
moniteur en 115200 bauds

/*------------------------------ DECLARATIONS DES VARIABLES --------------- */
#define appuye  false
#define relache true
const byte etat_bouton         = 3;
const byte moteur_descente     = 4;
const byte moteur_montee       = 5;
const byte moteur_validation   = 6;
const byte leds_rampe          = 7;
boolean memo_etat_bouton = relache;
boolean mouvement        =   false;
boolean rampe_basse      =   false;
boolean rampe_haute      =    true;
unsigned long tempo            = 0;
/*------------------------------------ INITIALISATION --------------------*/

void setup()
{
  Serial.begin(115200);
  pinMode(moteur_descente, OUTPUT); digitalWrite(moteur_descente, LOW);
  pinMode(moteur_montee, OUTPUT); digitalWrite(moteur_montee, LOW);
  pinMode(moteur_validation, OUTPUT); digitalWrite(moteur_validation, LOW);
  pinMode(etat_bouton, INPUT_PULLUP);
  pinMode(leds_rampe, OUTPUT); digitalWrite(leds_rampe, LOW);
}

/*-------------------------------------  EXECUTION  -------------*/
void loop()
{
  rampe();
  //ici, ton code n'étant pas bloquant, tu fais peux faire ................
}

/*--------------------------  Sous Programme pour la rampe --------------*/
void rampe()
{
  if (digitalRead(3) == appuye)                 //on surveille le BP et s'il est appuyé
  {
    delay(30); while (digitalRead(3) == appuye) //on attent son relachement
    {
      memo_etat_bouton = appuye;                //on mémorise l'appui sur le BP
    }
  }

  if (memo_etat_bouton == appuye)               //si le BP à été appuyé
  {
    if (mouvement == false)                     //si la rampe n'est pas en mouvement
    {
      tempo = millis();                         //on arme la tempo
      if ((rampe_basse == false)                //si la rampe est en haut
          &&  (rampe_haute == true))            //on va la descendre
      {
        digitalWrite(leds_rampe, HIGH);         // on allume la rampe avant la descente
        Serial.println (F("allumage rampe"));
        digitalWrite(moteur_validation, HIGH);  // Activation du driver moteur
        digitalWrite(moteur_montee, HIGH);
        digitalWrite(moteur_descente, HIGH);    // Le moteur descend
        Serial.println (F("debut descente rampe"));
      }
      else                                      //sinon, la rampe est en bas
      {
        if ((rampe_basse == true)               //on va la remonter
            && (rampe_haute == false))
        {
          digitalWrite(moteur_montee, HIGH);    // Le moteur monte
          digitalWrite(moteur_descente, LOW);
          digitalWrite(moteur_validation, HIGH);// Activation du driver moteur
          Serial.println (F("debut montee rampe"));
        }
      }
      mouvement = true;                         //temoin de mouvement en cours est valide
    }
    memo_etat_bouton = relache;
  }

  if (mouvement == true)                        //si la rampe est en mouvement
  {
    if ((millis() - tempo ) > 3000)             //depuis plus de 3 secondes
    {
      digitalWrite(moteur_descente, LOW);       //on arrete le moteur
      digitalWrite(moteur_validation, LOW);
      Serial.println (F("arret mouvement rampe"));
      mouvement = false;
      rampe_basse = !rampe_basse;
      rampe_haute = !rampe_haute;
      if (rampe_haute == true)
      {
        digitalWrite(leds_rampe, LOW);         // on eteint la rampe après la remontee
        Serial.println (F("extinction rampe"));
      }
    }
  }
}