Chargeur de wagons automatique

[peyo]

Messieurs,
Voici mon nouveau projet pour mon réseau de jardin au 7/8n2
Je souhaiterais faire une entreprise de chargement de produit chimique (en vrai de l'eau pour arroser les plantes du réseau)

En gros : le feu est au vert, le train arrive sous le chargeur, une pédale de voie est activée, au bout de deux secondes (pédale enfoncée), le feux passe au rouge, le chargeur rempli le wagon de produit pendant un temps donné, puis une fois la tempo écoulé, le feu repasse au vert, le train repart.

j'ai essayé des programmes toutes l'aprem en vain (je suis en vacances!) j'ai testé machine à états, delay, millis...
mais rien ne fonctionne!!

Le remplissage est assuré par un relais qui actionne une pompe à eau.

Je n'arrive pas à faire en sorte que l'action ne se fasse, que lorsque la pédale reste 2 secondes, (comme ça si le train ne fait que passer le remplissage ne ce fait pas!) je reviens toujours à mon programme de base :

Code: [Sélectionner]

//déclaration des variables
int pinBouton;
int pinLed1, pinLed2;

void setup() {
// definition mode relais
  pinMode(13, OUTPUT);

    //initialisation des variables
  pinBouton = 2;
  pinLed1 = 4;
  pinLed2 = 6;
 
  //définition des modes
  pinMode(pinBouton, INPUT); //mode lecture pour le bouton
  pinMode(pinLed1, OUTPUT); //mode écriture pour led1
  pinMode(pinLed2, OUTPUT); //mode écriture pour led2
 
}
void loop() {
   //lecture de l'état du bouton et stockage dans etatBouton
  boolean etatBouton = digitalRead(pinBouton);
  //test des conditions
  if (etatBouton==HIGH && ????)//test si bouton appuyé
  {
remplissage ();

  }
  if (etatBouton==LOW)//test si bouton levé
  {
    digitalWrite(pinLed1,HIGH); //Led1 allumée
    digitalWrite(pinLed2,LOW); //led2 éteinte
    digitalWrite(13, HIGH); //Relais sur OFF
  }
  delay(100); //petite attente
 
 
 
       
}

void remplissage ()
{
  digitalWrite(pinLed1,LOW); //led1 éteinte
    digitalWrite(pinLed2,HIGH); //led2 allumée
    delay (2000); //atternte de 2 secondes pour etre sur que le train ne bouge plus
    digitalWrite(13, LOW);//relais sur ON
    delay (10000);
    digitalWrite(pinLed1,HIGH); //Led1 allumée
    digitalWrite(pinLed2,LOW); //led2 éteinte

}

  //digitalWrite(13, HIGH);   
 
Pour le temps d'attente, j'ai trouvé ça qui fonctionne et que je pourrais intégrer à mon code mais je pense pouvoir faire plus simple..

Code: [Sélectionner]

int temps_defini = 2000;   
int ledPin     = 4;       
int boutonPin  = 2;     

unsigned long debut_appui;
boolean variable = false;
int etat_bouton;
int dernier_etat_bouton = LOW;
int etat_led = LOW;

void setup() {
pinMode(ledPin, OUTPUT);     
pinMode(boutonPin, INPUT);   
}



void loop(){
 
   etat_bouton = digitalRead(boutonPin);           
 
   
   
   if (etat_bouton == HIGH && dernier_etat_bouton == LOW){     
   debut_appui = millis();                                     
   variable = true;                                           
   }
   
   
   if ( variable == true && etat_bouton == HIGH &&  dernier_etat_bouton == HIGH){   
                                                                                 
     if ((millis() - debut_appui) >= temps_defini){                                             
     etat_led = HIGH;                                                         
     
     if(etat_bouton == LOW && etat_led == HIGH && dernier_etat_bouton == HIGH){
     etat_led = LOW;
     variable = true;}}
                         
}
dernier_etat_bouton = etat_bouton; 
digitalWrite(ledPin, etat_led);
}
Le summum serait d'arrêter le remplissage si le train part avant la fin, mais c'est pas ma priorité...

Des pistes, un conseil? d'avance merci à vous et bonne soirée.

Peyo

[peyo]

Voici mon grafcet :

[Thierry]

Clairement, on voit bien une petite machine à états, trois vrais états plus trois tempos en l'occurrence, avec des temps d'attente gérés pas millis() entre les états. Ca ne me semble pas insurmontable. Le mieux est de (re)lire l'article de Jean Luc sur la création d'un projet simple dans son dernier article (http://locoduino.org/spip.php?article25).

[peyo]

Après pas mal d'aides sur les forums, voici la solution pour réaliser un exemple de chargeur automatique de produits lors de l'appui long sur un bouton

Dans mon cas, une pédale de voie pour un train, afin de remplir automatiquement les wagons.

Pour le fonctionnement, CF grafcet fonctionnel.

Le code :

Code: [Sélectionner]


//broches de l'arduino utilisées
#define pinPedale   2
#define pinLedRouge 4
#define pinLedOrange 5
#define pinLedVerte 6
#define pinRelais   13

//délais (en ms)
#define tempoActive       2000
#define tempoRemplissage  10000

//inclusion de la librairies de machines à états YASM
#include <yasm.h>

//déclaration de la machines à états "pompe"
YASM pompe;

void setup()
{
  // paramétrage des broches d'entrées
  pinMode(pinPedale, INPUT);

  // paramétrage des broches de sorties
  pinMode(pinRelais, OUTPUT);
  pinMode(pinLedRouge, OUTPUT);
  pinMode(pinLedOrange, OUTPUT);
  pinMode(pinLedVerte, OUTPUT);

  //lancement de la machine à états : definition de l'état initial
  pompe.next(pompeAttente);
}

void loop()
{
  //execution de la machine à états
  pompe.run();
}

/////////////états de la machine "pompe" /////////////////////

void pompeAttente()
{
  //on attends le train (meuhhh ! )
 
  digitalWrite(pinLedRouge, LOW);
  digitalWrite(pinLedVerte, HIGH);
  digitalWrite(pinLedOrange, LOW);
  digitalWrite(pinRelais, HIGH);

  //si le train est sur la pédale, on passe à l'étape suivante
  if (digitalRead(pinPedale) == HIGH)
    pompe.next(pompeTempoActivation);
}

void pompeTempoActivation()
{
  //ici le train est sur la pédale
 
  digitalWrite(pinLedRouge, HIGH);
  digitalWrite(pinLedVerte, LOW);
  digitalWrite(pinLedOrange, LOW);
  digitalWrite(pinRelais, HIGH);

  //si le train quitte la pédale, on retourne en attente
  if (digitalRead(pinPedale) == LOW)
    pompe.next(pompeAttente);

  //et si le temps d'activation est écoulé, on passe à l'état suivant (remplissage)
  if (pompe.elapsed(tempoActive))
    pompe.next(pompeRemplissage);
}

void pompeRemplissage()
{
  //ici on remplit la citerne
 
  digitalWrite(pinLedRouge, HIGH);
  digitalWrite(pinLedVerte, LOW);
  digitalWrite(pinRelais, LOW);

  //si le train quitte la pédale, on retourne en attente
  if (digitalRead(pinPedale) == LOW)
    pompe.next(pompeAttente);

  //et si le temps de remplissage est écoulé, on passe à l'état suivant (attente départ train)
  if (pompe.elapsed(tempoRemplissage))
    pompe.next(pompeAttenteDepart);
}

void pompeAttenteDepart()
{
  //la citerne est pleine, on attends le départ du train
 
  digitalWrite(pinLedRouge, LOW);
  digitalWrite(pinLedOrange, HIGH);
  digitalWrite(pinLedVerte, LOW);
  digitalWrite(pinRelais, HIGH);

  //si le train quitte la pédale, on retourne en attente
  if (digitalRead(pinPedale) == LOW)
    pompe.next(pompeAttente);
}
Voilà :-)

[peyo]

Le grafcet :

[peyo]

Le montage :

[msport]

Bonsoir,
vous pouvez essayer ça ...