probleme code, variable, etat de sortie

bonjour,

je n'ai pas un gros niveau, je travail par copier coller en essayant de comprendre ce que je copie et en l'incluant dans mon code... en gros je fais ce que je peux avec ce que j'ai....

mon projet:

je suis en train de fabriquer une petite machine permettant de dérouler un tissu, de lui dire quelle longueur on souhaite, et lorsque la mesure est atteinte, le moteur s'arrête, on coupe le tissu, et on RESET la mesure... et on recommence,

la mesure devrait être effectuée par une roue avec des aimants et un compteur d'effet hall, je ne l'ai pas encore reçu donc j'ai remplacé ce dernier pour un poussoir et j'appuis dessus pour faire grimper mon compteur de mesure, ça me permet de teste mon code...

mon problème:

tout va bien jusqu'a l'arrêt moteur, un fois que j'appuis sur RESET, mon relay se remet en contact, car la valeur étant réinitialisée et donc inférieur, et bien-sur je ne veux pas que mon moteur redémarre tant que je n'ai pas appuyé a nouveau sur mon poussoir moteur.

j'ai essayé pas mal de chose mais étant donné que c'est la première fois que j'utilise autant de variable, j'ai du rater quelque chose

j'ai commenté mon code le plus possible pour vous aidez à comprendre ma logique...

#include <Wire.h>
#include <LiquidCrystal_I2C.h>


//LiquidCrystal_I2C lcd(0x27, 20, 4);
LiquidCrystal_I2C lcd(0x3F, 20, 4);

#define bp_plus_1 2 // augmente la taille de 1M
#define bp_plus_10 3  // augmente la tail de 10 CM
#define bp_moins_1 4  // augmente la tail de 10 CM
#define bp_moins_10 5  // diminu la taille de 10 cm
#define bp_roue 6 // BP simulant la roue effet hall
#define bp_reset 7 // permet de remetre la valeur mesuré par la roue a 0
#define bp_relay 8 // BP activation relay moteur
#define relay 9 // relay moteur
#define led 13 // led test


float t = 0; //taille (longueur souhaiter réglé par utilisateur)
float m = 0; //mesure defini par appuis sur bouton poussoir en attendant de metre une roue avec capter effet hall
bool bp_plus_1_etat = false; 
bool bp_plus_10_etat = false; 
bool bp_moins_1_etat = false; 
bool bp_moins_10_etat = false; 
bool bp_reset_etat = false;
bool bp_roue_etat = false;
bool bp_relay_etat = HIGH;
bool relay_etat = LOW;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode (bp_plus_1, INPUT_PULLUP);
  pinMode (bp_plus_10, INPUT_PULLUP);
  pinMode (bp_moins_1, INPUT_PULLUP);
  pinMode (bp_moins_10, INPUT_PULLUP);
  pinMode (bp_roue, INPUT_PULLUP);
  pinMode (bp_reset, INPUT_PULLUP);
  pinMode (bp_relay, INPUT);
  pinMode (relay, OUTPUT);
  pinMode (led, OUTPUT);
  
  
  lcd.init(); // initialisation de l'afficheur
  lcd.backlight(); //allume l'eclairage de lcd_display
  lcd.setCursor(0, 0);
  lcd.print("   M_Workshop");
  lcd.setCursor(0, 1);
  lcd.print("  Bubbles Tool");
  delay(1000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("    Logiciel");
  lcd.setCursor(0, 1);
  lcd.print("      V1.0");
  delay(1000);
  lcd.clear();

}

void loop() {
  // put your main code here, to run repeatedly:


  //*******************************partie moteur************************************************

  
  //                     **********demarage moteur***********
   if (t > m) {                           // si la taille est superieur a la mesure,
    if (bp_relay_etat == 1) {             //  demarre le moteur lors de l'appui sur BP_relay, (pour eviter a l'utilisateur 
      if (digitalRead(bp_relay) == 1){    //  de demarrer la machnie non regléé), si nouvel appui etein le moteur.
        delay(100);

        relay_etat = !relay_etat;
        bp_relay_etat = 0;
      }
    }
    else if (digitalRead(bp_relay) == 0) {
      delay(100);
      bp_relay_etat = 1;
    }

    digitalWrite(relay, relay_etat);
  
   }

   
  //                     **********arret auto moteur***********

 if (m  >= t) {                           // lorsque la mesure atteind la taille, coupe le moteur
  if (digitalRead(relay_etat) == HIGH)
    {
      digitalWrite(relay,LOW);
    }
    
  }



  //*******************************partie reglage affichage************************************************

  bp_plus_1_etat = digitalRead(bp_plus_1);
  if (bp_plus_1_etat == true) {
    delay(200);
    t += 1;
    digitalWrite (led, HIGH);
    delay(10);
    digitalWrite (led, LOW);
  }


  bp_plus_10_etat = digitalRead(bp_plus_10);
  if (bp_plus_10_etat == true) {
    delay(200);
    t += 0.10;
    digitalWrite (led, HIGH);
    delay(10);
    digitalWrite (led, LOW);
  }


  bp_moins_1_etat = digitalRead(bp_moins_1);
  if (bp_moins_1_etat == true) {
    delay(200);
    t -= 1;
    digitalWrite (led, HIGH);
    delay(10);
    digitalWrite (led, LOW);
  }


  bp_moins_10_etat = digitalRead(bp_moins_10);
  if (bp_moins_10_etat == true) {
    delay(200);
    t -= 0.1;
    digitalWrite (led, HIGH);
    delay(10);
    digitalWrite (led, LOW);

  }


  //*******************************partie mesure************************************************

  bp_roue_etat = digitalRead(bp_roue);
  if (bp_roue_etat == true) {
    delay(200);
    m += 1;
  }



  //*******************************partie RESET************************************************


  bp_reset_etat = digitalRead(bp_reset);    //BP_reset permet a l'utilisateur de remetre a Zero la mesure pour une nouvelle piece.
  if (bp_reset_etat == true) {
    delay(200);
    m = 0.0;
    digitalWrite (led, HIGH);
    delay(10);
    digitalWrite (led, LOW);
    lcd.setCursor(10, 1);
    lcd.print("       ");

  }


  //***********************************partie AFFICHAGE****************************************

  lcd.setCursor(0, 0);
  lcd.print("TAILLE         M");
  lcd.setCursor(10, 0);
  lcd.print(t);
  lcd.setCursor(0, 1);
  lcd.print("MESURE         M");
  lcd.setCursor(10, 1);
  lcd.print(m);
}

merci,

Tu as un petit schéma, c'est difficile de suivre tous ton code.

// demarage moteur*
if (t > m) { // si la taille est superieur a la mesure,
if (bp_relay_etat == 1) { // demarre le moteur lors de l'appui sur BP_relay, (pour eviter a l'utilisateur
if (digitalRead(bp_relay) == 1){ // de demarrer la machnie non regléé), si nouvel appui etein le moteur.
delay(100);

relay_etat = !relay_etat;
bp_relay_etat = 0;
}
}
else if (digitalRead(bp_relay) == 0) {
delay(100);
bp_relay_etat = 1;
}

digitalWrite(relay, relay_etat);

}

// arret auto moteur*

if (m >= t) { // lorsque la mesure atteind la taille, coupe le moteur
if (digitalRead(relay_etat) == HIGH)
{
// MODIFIE ICI POUR VOIR
relay_etat = LOW;
digitalWrite(relay, relay_etat);
}

}

En replaçant ta variable relay_etat à LOW, même si t est strictement supérieur à m, relay_etat ayant été mis a LOW, le moteur ne démarrera pas. Il faudra l'appui sur le bouton.
Ton code peux être vachement optimisé.

de plus au niveau de ton reset, tu peux ajouter la variable t et la mettre a zéro.
//partie RESET*****************

bp_reset_etat = digitalRead(bp_reset); //BP_reset permet a l'utilisateur de remetre a Zero la mesure pour une nouvelle piece.
if (bp_reset_etat == true) {
delay(200);
m = 0.0;
// MODIFIE ICI LE CODE ********************************
t = 0.0;
digitalWrite (led, HIGH);
delay(10);
digitalWrite (led, LOW);
lcd.setCursor(10, 1);
lcd.print(" ");

}

La partie démarrage du moteur ne remplie plus les conditions que tu as fixé puisque t n'est pas strictement supérieur à m.

Bonjour;

C'est pas mal comme boulot cas ressemble pas a du copier coller !

Voici ce que je constate.

if (t > m) { // si la taille est superieur a la mesure,
if (bp_relay_etat == 1) { // demarre le moteur lors de l'appui sur BP_relay, (pour eviter a l'utilisateur
if (digitalRead(bp_relay) == 1) { // de demarrer la machnie non regléé), si nouvel appui etein le moteur.
delay(100);

Tu a deux conditions if() qui ce succèdent. (pas la seul dans le programme)
Valider la mise en fonctionnement lors d'un appuie sur le bouton et une mesure cohérente.
Cela donne en "équation logique"

if (bp_relay_etat == 1 && digitalRead(bp_relay) == 1) { }

Il te faut ces deux conditions réunis.

Mais la aussi se trouve une autre "erreur".
Ton système est soumis à réagir à des actions sur boutons. Leurs états est donc constamment contrôlés.

je te propose de réaliser l'acquisition de tes boutons en une seul étape dans "loop()". Du genre.. ci dessous.

//Lecture d'état des boutons.
bool etat_bouton_0 = digitalRead(bouton_0);
et ainsi de suite pour les autres...

//***** Bouton 0.
if (peced_bouton_0 != etat_bouton_0) { //Contrôle état actuelle.
peced_bouton_0 = etat_bouton_0; //Actualisation de l'état actuelle.
if (etat_bouton_0 == LOW) { //Contrôle état logique.
ret_boutons = 1; //Retour d'état bouton validé.
}
}
et ainsi de suite pour les autres...

Note: "ret_boutons" déclaré et initialisé à zéro dans loop()
"peced_bouton_0" déclaration globale.

Une variable d'état de tes boutons "ret_boutons " te permettra d’exécuter les actions programmes utiles en fonction de sa valeur. (correspondant au bouton)
De cette façon tu n'a plus à rappeler constamment la méthode digitalRead();

Suite à cela en fonction de l'état de "ret_boutons" tu pourrais utiliser switch(ret_boutons){} pour les cas défini que tu a et exécuter tes opérations.
Cela évite de faire des appels successif de "if()".
(Perso: je préfère pour des cas bien défini sur comparatif d'une variable.)

Pour les boutons tu devrais aussi regarder dans la partie TUTORIEL du Forum et voire la bibliothèque "simpleBouton.h". Cela t'aidera beaucoup pour la gestion de tes boutons si tu ne souhaite pas te casser la tête avec les lignes ci dessus.

Et pour le démarrage de ton moteur... Si il démarre c'est qu'il y a une condition validé à ce moment.
Place des "Serial.print()" avec les variables des conditions pour trouver la quelle te fait défaut !!

Salutations.

bonjour,

merci a vous deux deja pour ces deux reponses tres complétes,

mais j'ai bien peur de ne pas tout comprendre, donc je vous propose que je fasse quelques exercices simples avec vous proposition le temps maitriser ces differentes logique et de pouvoir les incorporer a mon code par la suite,

en tout cas cela me semble etre un probleme de condition, ou (et) de variable donc vous devriez avoir viser juste avec vos reponces,

merci en tout cas pour le temps et l'envie... :slight_smile:

je reviendrai sur ce poste d'ici peu pour vous redire ce qu'il en est.

coordialement.
Freerider90

Le tissu est il enroulé sur un gros rouleau ? Si oui, pour mesurer la longueur déroulée, compter les tours ne suffit pas, car le diamètre externe du rouleau change au fur et à mesure du déroulage..

bonsoir Lesept,

non effectivement cela ne suffi pas mais jai prevu un systeme de roue qui est entrainée par le tissu lors de son passage dans le regle de coupe, avec les aimant sur cette roue qui le donne un metrage precis de tissu deroulé.

jai revu mon code en utilisant simpleBouton.h comme me l'a conseillé manumanu

Pour les boutons tu devrais aussi regarder dans la partie TUTORIEL du Forum et voire la bibliothèque "simpleBouton.h". Cela t'aidera beaucoup pour la gestion de tes boutons si tu ne souhaite pas te casser la tête avec les lignes ci dessus.

j'ai une config fonctionnent nettement mieux comme ca et je me perd moins dans le code, c'est super merci Manumanu!
mais j'ai encore un petit souci avec cette nouvelle librairie,

je souhaiterai dans la boucle mette un anti démarrage (partie commenté anti démarrage dans le code)

genre:

si la mesure et égale à la taille (en gros la taille n'a pas été configurée),
empêche le relai de s'activer meme si on appuis sur le boutonRelai.

mais je sais pas comment formuler ca.

quelqu'un aurai une piste de ce coté la?

merci merci

#include "simpleBouton.h"

// LCD
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
//LiquidCrystal_I2C lcd(0x27, 20, 4);
LiquidCrystal_I2C lcd(0x3F, 20, 4);



const uint8_t pin_bouton_plus_1 = 2;//cablage pin---BP---GND
const uint8_t pin_bouton_plus_10 = 3;//cablage pin---BP---GND
const uint8_t pin_bouton_moins_1 = 4;//cablage pin---BP---GND
const uint8_t pin_bouton_moins_10 = 5;//cablage pin---BP---GND
const uint8_t pin_bouton_roue = 6;//cablage pin---BP---GND
const uint8_t pin_bouton_reset = 7;//cablage pin---BP---GND
const uint8_t pin_bouton_relai = 8;
const uint8_t pin_relai = 9;

//definition des variables
bool relai_allumee = true; // variable etat relai
float t = 0.0; //taille (longueur souhaiter réglé par utilisateur)
float m = 0.0; //mesure defini par appuis sur bouton poussoir en attendant de metre une roue avec capter effet hall

// attachement vocabulaire vers pin arduino
simpleBouton boutonRelai(pin_bouton_relai);
boutonAction boutonPlus1(pin_bouton_plus_1);
boutonAction boutonPlus10(pin_bouton_plus_10);
boutonAction boutonMoins1(pin_bouton_moins_1);
boutonAction boutonMoins10(pin_bouton_moins_10);
simpleBouton boutonReset(pin_bouton_reset);
boutonAction boutonRoue(pin_bouton_roue);


void clicplus1() {
  t += 1;
}
void clicplus10() {
  t += 0.1;
}
void clicmoins1() {
  t -= 1;
}
void clicmoins10() {
  t -= 0.1;
}

void clicroue() {
  m += 1;
}


void setup() {

  //Initialisation du relai
  pinMode(pin_relai, OUTPUT);
  digitalWrite(pin_relai, LOW);

  // control en serie pour les test
  Serial.begin(9600);
  Serial.print("taille :");
  Serial.println(t);
  Serial.print("mesure :");
  Serial.println(m);


  // declaration des corespondence bouton clic
  boutonPlus1 .attacher(clicplus1);
  boutonPlus10 .attacher(clicplus10);
  boutonMoins1 .attacher(clicmoins1);
  boutonMoins10 .attacher(clicmoins10);
  boutonRoue .attacher(clicroue);

  //sequence de demarage sur afficheur lcd 16X2
  lcd.init(); // initialisation de l'afficheur
  lcd.backlight(); //allume l'eclairage de lcd_display
  lcd.setCursor(0, 0);
  lcd.print("   M_Workshop");
  lcd.setCursor(0, 1);
  lcd.print("  Bubbles Tool");
  delay(1000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("    Logiciel");
  lcd.setCursor(0, 1);
  lcd.print("      V2.1");
  delay(1000);
  lcd.clear();

  }

 
void loop() {

  //************ ****************REGLAGE MESURE**************************
  boutonPlus1 .actualiser();
  boutonPlus10 .actualiser();
  boutonMoins1 .actualiser();
  boutonMoins10 .actualiser();

  //**************************** MESURE CAPTEUR EFFET HALL **************


  boutonRoue .actualiser(); // remplacer par un bouton poussoir pour les tests


  //**************************** DEMARRAGE MOTEUR ***********************
  boutonRelai.actualiser();
  if (boutonRelai.vientDEtreEnfonce())
  {
    relai_allumee = !relai_allumee; //inversion du bouléen
    digitalWrite(pin_relai, relai_allumee ? HIGH : LOW);
  }

  //**************************** reset **********************************
  boutonReset.actualiser();
  if (boutonReset.vientDEtreEnfonce())
  {
    m = 0.0;
  }

  //**************************** arret automatique***********************

  if (m >= t)
  {
    digitalWrite(pin_relai, LOW);
  }

  //**************************** anti demarrage**************************
  /*lorsque la valeur mesuree est egale a la taille, donc au demarrage de la machine
   * empeche l'utillisateur de demarer le relai
   */



  //***************************** partie AFFICHAGE***********************

  lcd.setCursor(0, 0);
  lcd.print("TAILLE         M");
  lcd.setCursor(10, 0);
  lcd.print(t);
  lcd.setCursor(0, 1);
  lcd.print("MESURE         M");
  lcd.setCursor(10, 1);
  lcd.print(m);
}

Bonjour;
Désolé pour le retard !

beau travail!

Trouve mes remarques dans ton programme ci dessous. (plus simple pour moi et toi)
en 3 parties.
1 - init

/*NOTE DE TRAVAIL

  1) Réaliser l'acquisition des entrées.
  2) Traitement des données sytème utiles => Longueure souhaiteé.
  3) Activation du système => Pilotage moteur.
  4) Affichage données sur afficheur LCD.
  5)

  Petits conseils:
  - Pour plus de lisibilité programme tu peux raccourcir tes variables "boutonPlus10" peut être écris "plus10"
  Tu sais que c'est des boutons de plus tu le spécifie dans les déclaration de broches.
  "m" et "t" par contre ne sont pas assez claire. Les mots tailles et mesures sont très proches en signification.
        => "t" Est ta consigne donc je te propose "consigne"
        => "m" Est ta mesure donc je te propose "mesure"
   Remplace les dans ton programme tu y véra encore plus claire.

  - Tu n'est pas obligé de créer des fonctions pour tes boutons. Tu les actualise à chaques tour de boucle avec ".actualiser()".

  - Dans le principe de ton système il vas te falloir ajouter la validation de la saisi de ta consigne par l'ajout d'un boutons "ENTRÉE"
  Sans cela tu pourra démarrer sous une consigne non vérifié ou contrôlé.
  Pour info ne jamais utiliser les broches 0 et 1 en sorties ou entrées.

  - Pour une précision au millimètre de ta coupe tu devrais utiliser un codeur couplé à ta roue de mesures. A voir plus tard. Car plus complexe.
  Avec ton capteur ca ira et plus simple ensuite de passer vers un codeur.
*/
//***** BIBLIOTHEQUES. *****//
//BOUTONS.
#include "simpleBouton.h" //Gestions des boutons.

// LCD
//#include <Wire.h>
//#include <LiquidCrystal_I2C.h>
/*Placé dans la partie configuration du seturp()
  //LiquidCrystal_I2C lcd(0x27, 20, 4);
  LiquidCrystal_I2C lcd(0x3F, 20, 4);*/

/*Étape superflux cela peut etre fait directement grace à la méthode de simpleBouton()
   Sans passer par une variable transitoire.
   VOIR CI DESSOUS.
  //***** Déclarations des broches d'ENTREE *****
  // cablage pin---BP---GND.
  const uint8_t pin_bouton_plus_1 = 2;
  const uint8_t pin_bouton_plus_10 = 3;
  const uint8_t pin_bouton_moins_1 = 4;
  const uint8_t pin_bouton_moins_10 = 5;
  const uint8_t pin_bouton_roue = 6;  // =>Tu devrais renommer => pin_bouton_pulsTour.
  const uint8_t pin_bouton_reset = 7;
  const uint8_t pin_bouton_relai = 8; // =>Tu devrais renommer => pin_bouton_pilotMoteur.*/

//***** Déclarations des broches de SORTIE *****
const uint8_t pin_relai = 9;        // => Tu devrais renommer => pin_bouton_moteur.*/

//***** Déclarations des variables globales *****//
/*bool relai_allumee = true; // variable etat relai => Dans cette état démmarrage systématique;
  Peut etre fait par la lecture de l'état de la broche.*/
float t = 0.0;      //taille (longueur souhaiter réglé par utilisateur)
float m = 0.0;      //mesure defini par appuis sur bouton poussoir en attendant de metre une roue avec capter effet hall
int ret_puls = 0;   //Variable de comptage tour.
int perimetre = 15; //Perimetre de la roue de mesure (Donnée physique système).

/***** Déclarations des broches *****
    CORRECTION CI DESSOUS
  simpleBouton boutonRelai(pin_bouton_relai);
  boutonAction boutonPlus1(pin_bouton_plus_1);
  boutonAction boutonPlus10(pin_bouton_plus_10);
  boutonAction boutonMoins1(pin_bouton_moins_1);
  boutonAction boutonMoins10(pin_bouton_moins_10);
  simpleBouton boutonReset(pin_bouton_reset);
  boutonAction boutonRoue(pin_bouton_roue);*/

//***** Déclarations des OBJETS aux broches *****//
//simpleBouton suffis pour ton application.

simpleBouton boutonPlus1(2);    //Boutons +1.
simpleBouton boutonPlus10(3);   //Boutons +10.
simpleBouton boutonMoins1(4);   //Boutons -1.
simpleBouton boutonMoins10(5);  //Boutons -10.
simpleBouton pulsTour(6);       //Catpeur rotation.
simpleBouton boutonReset(7);    //Boutons RESET
simpleBouton boutonRelai(8);    //commande moteur.


/* Pas utiles => Voire la partie Acquisition dans LOOP().

  void clicplus1() {
  t += 1;
  }
  void clicplus10() {
  t += 0.1;
  }
  void clicmoins1() {
  t -= 1;
  }
  void clicmoins10() {
  t -= 0.1;
  }

  void clicroue() {
  m += 1;
  }*/
/*La seul fonction utile serra la lecture de ton capteur de tour
  durant l'activation de ton moteur.
  Vois en fin de programme la fonction "puls()".*/

2 - Setup()

void setup() {
  //Initialisations = Affectation de valeurs aux données lors d'un lancement programme.
  /*Exemple: Int Variable = 2598; //Variable initialisé à la valeur 2598.*/
  //Configurations = Affectation de valeurs aux données de paramettrage. Définit un rôle ou des caractéristiques lors d'un lancement programme.
  /*Exemple:  Serial.begin(9600); //Port série definis pour executer sa tâche à une vitesse défini de 9600baud => sa caractéristique.
    ou pinMode(sortie1, OUTPUT); //Broches "sortie1" définie pour être en mode sortie => Son rôle*/

  //***** CONFIGURATIONS *****//
  /*Initialisation du relai => Ce n'est pas une initialisation.*/
  //***** Configuration broche de sortie
  pinMode(pin_relai, OUTPUT);
  //digitalWrite(pin_relai, LOW);//Pas utile en tant que sortie elle serra à létat 0 par défaut.
  /*Tu as du certainement faire cela suite à ta déclaration => "bool relai_allumee = true;".*/

  //***** Configuration Moniteur série.
  Serial.begin(9600);

  //***** Configuration afficheur LCD.
  //LiquidCrystal_I2C lcd(0x27, 20, 4);
  //LiquidCrystal_I2C lcd(0x3F, 20, 4);

  //***** TEST *****//
  //Moniteur série.
  Serial.println("***** Moniteur Pret *****");
  Serial.println();                               //Saut de ligne vierge.
  Serial.print("Consigne :");  Serial.println(t);
  Serial.print("mesure :");  Serial.println(m);

  /*Pas utile tu peux supprimer cette partie
    // declaration des corespondence bouton clic
    boutonPlus1 .attacher(clicplus1);
    boutonPlus10 .attacher(clicplus10);
    boutonMoins1 .attacher(clicmoins1);
    boutonMoins10 .attacher(clicmoins10);
    boutonRoue .attacher(clicroue);*/

  /*J'ai âs traité cette partie
    //sequence de demarage sur afficheur lcd 16X2
    lcd.init(); // initialisation de l'afficheur
    lcd.backlight(); //allume l'eclairage de lcd_display
    lcd.setCursor(0, 0);
    lcd.print("   M_Workshop");
    lcd.setCursor(0, 1);
    lcd.print("  Bubbles Tool");
    delay(1000);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("    Logiciel");
    lcd.setCursor(0, 1);
    lcd.print("      V2.1");
    delay(1000);
    lcd.clear();*/
}// Fin de setup().

A suivre => POSTE suivant.

loop()

void loop() {

  //***** Déclarations de variables locales *****//


  //1 - ***** Acquisition des entrées. *****//
  /*Pour chaque activations de boutons tu dois définir un état
     Reprends ce que tu a fait pour le boutons RESET ou
     reprends l'exemple 01 fournis avec la librairie.
    Fichier => Exemples => simpleBouton => Exemple 01 état bouton  */

  //Bouton +1.
  boutonPlus1.actualiser();      //Ajoute 1 à la mesure souhaité.
  /*Que ce passe t'il SI le bouton est activé.
    Ici tu souhaite définir la longueure de fil à dérouler => Soit ta consigne
    Ce qui reviens à exécuter en référence à ton programme "t += 1"*/

  //Bouton +10.
  boutonPlus10.actualiser();     //Ajoute 10 à la mesure souhaité.
  /*Que ce passe t'il SI le bouton est activé.
    Ici tu souhaite définir la longueure de fil à dérouler => Soit ta consigne
    idem dessus mais suivant bouton*/

  //Bouton -1.
  boutonMoins1.actualiser();     //Retire 1 à la mesure souhaité.
  /*Que ce passe t'il SI le bouton est activé.
    Ici tu souhaite définir la longueure de fil à dérouler => Soit ta consigne
    idem dessus mais suivant bouton*/

  //Bouton -10.
  boutonMoins10.actualiser();    //Retire 10 à la mesure souhaité.
  /*Que ce passe t'il SI le bouton est activé.
    Ici tu souhaite définir la longueure de fil à dérouler => Soit ta consigne
    idem dessus mais suivant bouton*/

  //Bouton RESET.
  boutonReset.actualiser();
  /*Que ce passe t'il SI le bouton est activé.
    Ici tu souhaite faire une remise à zéro de ta consigne
    RESET => J'ai repris ce que tu avais fait plus bas*/
  if (boutonReset.vientDEtreEnfonce()) {
    m = 0.0;
  }

  //2 - ****** Traitements des données. ******//
  /*Ici tu souhaite conditionner le démarrage de ton système en fonction des données actualisées.*/
  /*lorsque la valeur mesuree est egale a la taille, donc au demarrage de la machine
     empeche l'utillisateur de demarer le relai   */

  /* (Dans l'attente de la validation pour bouton).
     Soit... si la mesure est différente de la consigne = Demarrage moteur.
    Crée cette condition if() et englobe y ce qui suit*/

  //3 - ***** Pilotage MOTEUR.
  //Si les conditions ci dessus sont fausse le moteur est en marche.
  //Tant que la mesure n'atteint pas la consigne => Utilise "while()" => http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.While
  //Appel de la fonction puls() dans la boucle.
  //Une fois la boucle executé tu réalise => Arret du moteur + raz mesure.
  //NOTE en executant une boucle while() un raz en cours de cycle n'est pas possible et ne serra pas pris en compte.
  //Un appui sur les boutons aussi ne sera plus possible. Ce qui te garanti de garder ta valeur initiale.

  /*boutonRelai.actualiser();                               => Supprimé car réalisé plus haut.*/

  /*if (boutonRelai.vientDEtreEnfonce())
    {
    relai_allumee = !relai_allumee; //inversion du bouléen
    digitalWrite(pin_relai, relai_allumee ? HIGH : LOW);
    }                                                         => Supprimé car réalisé plus haut. */

  //**************************** reset **********************************
  //Partie placée en acquisition
  /*tu peux la supprimer en gardant les ligne au dessus.
    boutonReset.actualiser();
    if (boutonReset.vientDEtreEnfonce())
    {
    m = 0.0;
    }*/

  //**************************** arret automatique***********************
  //Traité dans la partie ci dessus.Traitements des données
  /*
    if (m >= t)
    {
      digitalWrite(pin_relai, LOW);
    }*/

  //**************************** anti demarrage**************************
  //Traité dans la partie ci dessus. Traitements des données
  /*lorsque la valeur mesuree est egale a la taille, donc au demarrage de la machine
     empeche l'utillisateur de demarer le relai   */


  //***************************** partie AFFICHAGE***********************
  /*PArtie pas traité;
    lcd.setCursor(0, 0);
    lcd.print("TAILLE         M");
    lcd.setCursor(10, 0);
    lcd.print(t);
    lcd.setCursor(0, 1);
    lcd.print("MESURE         M");
    lcd.setCursor(10, 1);
    lcd.print(m);*/
}// Fin de loop//

fonction

//***** FONCTIONS *****//

void puls() {

  //Capteur de rotation.
  pulsTour.actualiser(); // remplacer par un bouton poussoir pour les tests
  /*Que ce passe t'il SI le capteur est activé.
    Ici tu souhaite exécuter une opération de calcul => Calcul longueure de fil
    Soit un perimètre par tour de roue => ce qui reviens à incrémenté ta mesure*/
  //Crées ton comptage de tour.
  ret_puls += perimetre;
}

en plus des remarques déjà faites, j'ajouterai que ce type de projet se prète bien à la programmation par machines à états
Je te conseillerai donc de jeter un oeil ici
et encore ici