Demarrage machine avec poussoir

Bonjour à tous,
je commence en arduino et ai un niveau plutôt bas mais ai quelques idées de choses à faire pour mettre en application les circuits.

Première étape avec le tuto “Debounce” j’arrive bien à actionner mon relai.

Par contre pour la suite je sèche : je souhaiterais faire le démarrage de deux moteurs à l’aide d’un poussoir.
Le démarrage est consécutif à x seconde intervalle suite à la pression d’un bouton poussoir trois fois de suite “rapidement”(comme ça pas d’erreur).

Enfin si je ré appui une fois le premier moteur s’éteint mais pas le deuxième.
Pour tout éteindre j’appuie sur arrêt d’urgence et coupe tout y compris l’arduino.

Autre souci
Par contre question, en démarrant je me suis rendu compte que les relais collaient et décollaient comme s’il y avait une phase d’initialisation…
Dans mon cas, c’est mal car lors de la mise sous tension je ne veux pas que mes moteurs démarrent inopinément, voyez-vous de quoi je parle ?

Pour l’heur voici ce que j’ai « écrit » et rien ne se passe?

const int buttonPin = 4;    
const int ledPin1 = 3;     
const int ledPin2 = 2;


// Variables will change:
int ledState1= LOW;        
int ledState2 = LOW;       

int ButtonState;             
int lastButtonState = LOW;  
int buttonPushCounter = 0;

long lastDebounceTime = 0;  
long debounceDelay = 50;    
long limitDelay = 10000;  
long interDelay = 5000;    


void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
    
  digitalWrite(ledPin1, ledState1);
  digitalWrite(ledPin2, ledState2);
}




void loop() {
  int buttonState = digitalRead(buttonPin);

  if (buttonState != lastButtonState) {
     lastDebounceTime = millis();
  }
  
  
  if ((millis() - lastDebounceTime) > limitDelay)  {
    buttonPushCounter = 0;
      }

if ( (millis() - lastDebounceTime) > debounceDelay && (millis() - lastDebounceTime) < limitDelay  ) {
    
if (ledState2 = LOW){
  
  
    if (buttonState != lastButtonState) {  
      buttonPushCounter++;
      
      if (buttonPushCounter >= 3 ) {
        ledState1 = HIGH; //aspi
         ledState2 = HIGH; //machine outil
                                    }
                                          }
                      }
if ( ledState2 = HIGH)  {
  ledState1 = HIGH; //aspi 
  ledState2 = LOW; //machine outil
                          }
}

   
if (buttonPushCounter >= 3 ) {
           buttonPushCounter = 0;
                                   }  
  digitalWrite(ledPin1, ledState1);//aspi 
      delay(interDelay);
  digitalWrite(ledPin2, ledState2);//machine outil
  
  lastButtonState = ButtonState;
}

Bonjour,

Tu écris

   if (ledState2 = LOW) {

ce devrait être

   if (ledState2 == LOW) {

Même chose pour le test HIGH

Dans ta boucle tu as une tempo de 5s, le test de l'appui sur le bouton ne peut pas fonctionner car il faut appuyer pendant plus de 5s pour être sur qu'il soit pris en compte.

Merci, cela m'a remis sur le chemin, il n'y a plus de souci d’initialisation ce qui me rassure, j'arrive a faire fonctionner le comptage. Je cale sur la limite de temps maxi mais n'y ai pas encore passé suffisamment de temps, je vous redis.

Cdlt.

Je viens de terminer cela fonctionne.

Merci pour votre aide.

const int buttonPin = 4;    // the number of the pushbutton pin
const int ledPin1 = 3;      // the number of the LED pin
const int ledPin2 = 2;

// Variables will change:
int ledState1 = LOW;         // the current state of the output pin
int ledState2 = LOW;         // the current state of the output pin
int buttonState;             // the current reading from the input pin
int fonctionnement;
int lastButtonState = LOW;   // the previous reading from the input pin

// the following variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long lastDebounceTime = 0;  // the last time the output pin was toggled
long lastactiontime = 0;  // the last time the output pin was toggled
long debounceDelay = 50;    // the debounce time; increase if the output flickers
long limitDelay = 1500;    // the time limit 

int buttonPushCounter = 0;

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  fonctionnement==0;
  
  digitalWrite(ledPin1, ledState1);
  digitalWrite(ledPin2, ledState2);
}

void loop() {
  int reading = digitalRead(buttonPin);
//_________________________________________________________
  if (reading != lastButtonState) {
     lastDebounceTime = millis();
    
   if (buttonPushCounter == 0)                    {
       lastactiontime = millis(); 
                                                   }
    if (buttonPushCounter != 0)                    {
    if ((millis() - lastactiontime) > limitDelay ) {  
      buttonPushCounter=0;
                                                    } 
                                                    }
                                  } 
//________________________________________________________
  
  if ((millis() - lastDebounceTime) > debounceDelay ) {
    if (reading != buttonState)                       {
       buttonState = reading;
              
    if (buttonState == HIGH)                    {
        buttonPushCounter++;
//________________________________________________________        
if (fonctionnement==1)                       {
        ledState1 = !ledState1;
        digitalWrite(ledPin1, ledState1);  //moteur
        //ledPin2 inchangé
        buttonPushCounter=0;
        
                                             }
//________________________________________________________                                             
if (fonctionnement==0)                       {
        if (buttonPushCounter >= 3 )         {
        ledState1 = !ledState1;
        ledState2 = !ledState2;
        fonctionnement=1;
        digitalWrite(ledPin1, ledState1);  //moteur
        delay(3000);
        digitalWrite(ledPin2, ledState2);  //aspi
        buttonPushCounter=0;
                                              }
                                              }                                          
//________________________________________________________                                                      
                                                 }
                                                    }
                                                    }



  lastButtonState = reading;
}

Bonjour,

Petite précision: en utilisant un module 2 relais il faut initialiser les niveau des pattes à "Haut" car les relais collent sur niveau bas. -> cela fonctionne plus qu'à souder les composants et câbler les contacteurs.

[u]Par contre[/u] si quelqu'un a une idée pour ne pas commander la partie puissance sur un manque de tension je suis preneur car je n'aime pas cela -> si on enleve l'arduino, la commande des relais passe à 0, ce qui colle les relais et déclenche la partie puissance= les moteurs démarrent ce qui me parait être la pire des C****** dans ces circonstances.

Je vais ajouter un relai 5V/230V sur l'alim de l'arduino pour couper le circuit intermédiaire de puissance en même temps que l'alim de l'arduino en guise de sécurité. L'idéal serait de commander ce relais de securité avec une autre patte de l'arduino sur niveau haut via un transistor mais cela revient à jeter les module relais...

Dans les faits je commande des moteurs de 1 à 3 CV d'ou l'utilisation de contateurs 40A 230V/230V eux même commandé par des relais 5V/230V piloté par l'arduino...

Il n'y a pas vraiment besoin d'arduino mais c’était l'occasion de faire un projet avec et puis je voulais mettre des tempo, appuyer plusieurs fois sur marche etc...

Est ce que quelqu'un sait comment on ferait suivant les "règles de l'art"?Comment utilise t-on ces modules relais? (à part utiliser un module de relais que déclenche sur niveau haut)

MH

MNH54: Petite précision: en utilisant un module 2 relais il faut initialiser les niveau des pattes à "Haut" car les relais collent sur niveau bas. -> cela fonctionne plus qu'à souder les composants et câbler les contacteurs.

[u]Par contre[/u] si quelqu'un a une idée pour ne pas commander la partie puissance sur un manque de tension je suis preneur car je n'aime pas cela -> si on enleve l'arduino, la commande des relais passe à 0, ce qui colle les relais et déclenche la partie puissance= les moteurs démarrent ce qui me parait être la pire des C****** dans ces circonstances.

Attention, les relais sont excités effectivement sur un niveau bas mais bien parce que la carte est alimenté en 5volts donc tout les relais sont mis au positif d'un côté et donc pour les activer, il reste plus qu'à fermer le circuit en les mettant au négatif. Techniquement les optocoupleurs sont à Anode communes. Donc sur perte de tension il n'y a pas commutation, laisse une pâte "en l'air" le relais ne commutera pas. C'est comme ça qu'il faut le voir.

A la limite tu peux commander juste l'alim de la carte relais avec un transistor type 2n2222 et une pin de l'arduino mise à l'état haut.

Pour finir, normalement les relais sont inverseurs sur ces modules, donc tu as des contacts NC et NO, à toi de câbler en conséquence afin de piloter ton relais avec un état haut, c'est possible.