AUTOMATE ARDUINO ET PROGRAMMATION "GESTION D'UN SECHOIR"

Salut à la communauté !!

Voilà mon projet :

Je dois gérer trois séchoirs équipés de matériels commandés par relais (3*4 ventilateurs,3 extracteurs, 3 chauffages, et 3 capteurs de temp/humidité)
Le tout est piloté par une carte à 16 relais (sainsmart) et un arduino mega + 3 capteurs DHT22
Une interface PC en C# sur visual studio finalisera le projet...

J'ai du mal à construire l'architecture du prog et je me demande s'il ne me faudrait pas plutôt trois ou quatres arduino..(1 maitre trois esclaves)

En effet, je dois pouvoir piloter les 3 séchoirs indépendamment, soit :

  • enclencher chaque relais à la demande
  • ou lancer un cycle de fonctionnement "automatique" sur chacun des trois séchoirs
    Commander chaque relais, ok, mais lorsque je lance un cycle "automatique" sur un séchoir (mesures/commande relais), je ne vois pas comment je pourrais interagir avec les deux autres séchoirs en stand by, lancer éventuellement un cycle sur les 2 restant ou piloter les relais individuellement (mode manuel) car le programme bouclerait sur une fonction acquisition de mesure/pilotage relais et ne pourrait sortir de cette boucle que lorsque le cycle de séchage serait terminé...

Quelqu'un pourrait il m'éclairer de ses lumières ?

Merci à tous ::-)))

je me demande s'il ne me faudrait pas plutôt trois ou quatres arduino

La gestion de 3 séchoirs n'exige pas des temps de réponse très rapide et peut parfaitement être géré par un seul arduino.

Commander chaque relais, ok, mais lorsque je lance un cycle "automatique" sur un séchoir (mesures/commande relais), je ne vois pas comment je pourrais interagir avec les deux autres séchoirs en stand by, lancer éventuellement un cycle sur les 2 restant ou piloter les relais individuellement (mode manuel) car le programme bouclerait sur une fonction acquisition de mesure/pilotage relais et ne pourrait sortir de cette boucle que lorsque le cycle de séchage serait terminé...

Mets toi à la place de ton arduino. Qu'est-ce que tu ferais si tu devais le faire à la main.

Début du processus
  regarder les paramètres du 1er équipement:
    - il est en stand by je passe
    - il est actif:
         - acquérir les paramètres (température, humidité, ...
         - agir en conséquence (allumer/couper le chauffage, la ventilation, ....)
  regarder les paramètres du 2ème équipement:
    - il est en stand by je passe
    - il est actif:
         - acquérir les paramètres (température, humidité, ...
         - agir en conséquence (allumer/couper le chauffage, la ventilation, ....)
  regarder les paramètres du 3ème équipement:
    - il est en stand by je passe
    - il est actif:
         - acquérir les paramètres (température, humidité, ...
         - agir en conséquence (allumer/couper le chauffage, la ventilation, ....)
retour au début

la paire "début de cycle / retour au début" c'est la fonction loop() de l'arduino
Il faut donc traiter chacun à son tour mais ne pas rester bloqué dans une fonction. Si tu dois gérer des temporisations, il ne faut pas utiliser delay() qui est bloquant mais gérer le temps avec des variables et la fonction millis() et à chaque itération de la boucle vérifier si le "délais" est écoulé.

Gatizne:
Je dois gérer trois séchoirs équipés de matériels commandés par relais (3*4 ventilateurs,3 extracteurs, 3 chauffages, et 3 capteurs de temp/humidité)
Le tout est piloté par une carte à 16 relais (sainsmart) et un arduino mega + 3 capteurs DHT22
Une interface PC en C# sur visual studio finalisera le projet...

J'ai du mal à construire l'architecture du prog et je me demande s'il ne me faudrait pas plutôt trois ou quatres arduino..(1 maitre trois esclaves)

...

bonjour
le choix de l'architecture depend aussi de contraintes comme :

  • la disponibilité des sechoirs = est ce critique si plus rien ne fonctionne à cause de l'arduino HS ?
  • où ce fera la prise de decision en fonction des capteurs ? sur l'arduino ou sur le PC en C# ?
    l'arduino ne faisant qu'integrer les mesures, les transmettre au PC et receptionner les ordres ?

si c'est pour une utilisation pro, j'aurais d'instinct tendance à modulariser donc plusieurs arduino, mais ça se discute
un peu plus d'info sur le dimensionnement du projet serait pas mal : le probleme n'est pas exactement le meme si les sechoirs ont un volume de qq litres ou metres cubes, l'eloignement des sechoirs, et autres ....

si c'est pour une utilisation pro, j'aurais d'instinct tendance à modulariser donc plusieurs arduino, mais ça se discute

Je suis du même avis qu'Artouste pour ce point, l'utilisation de plusieurs Arduino indépendants est plus onéreuse mais moins risquée quant aux éventuelles mise en défaut de chaque appareil en cas de problème. Vaut mieux un seul appareil en panne que tous ...

Parallèlement ça me semble plus simple à mettre en oeuvre, moins de cablage, programmes plus léger mais après achat de composants annexes en triple etc ... (avis vu d'en bas depuis les premiers barreaux de l'échelle d'utilisateurs de l'Arduino :grin:).

Je suis également curieux d'en savoir plus sur ce projet ;).

Bon aprem.

Nico.

Re !

Merci de tes infos fdufnews :slight_smile: !!
Je vais plancher à nouveau sur mon organigramme...

Artouste:
bonjour
le choix de l'architecture depend aussi de contraintes comme :

  • la disponibilité des sechoirs = est ce critique si plus rien ne fonctionne à cause de l'arduino HS ?
  • où ce fera la prise de decision en fonction des capteurs ? sur l'arduino ou sur le PC en C# ?
    l'arduino ne faisant qu'integrer les mesures, les transmettre au PC et receptionner les ordres ?

si c'est pour une utilisation pro, j'aurais d'instinct tendance à modulariser donc plusieurs arduino, mais ça se discute
un peu plus d'info sur le dimensionnement du projet serait pas mal : le probleme n'est pas exactement le meme si les sechoirs ont un volume de qq litres ou metres cubes, l'eloignement des sechoirs, et autres ....

Pour info, la dimension des séchoirs rectangulairse est de 30m3 environ et il sont côte à côte...La gestion complète serait faite par Mr Arduino, alors que Mr PC ne serait qu'une interface "boutons", Graph, et saisie des valeurs de séchage...
En ce qui concerne une éventuelle panne du système, j'avais pensé à relier mon automate à mes différents éléments (ventilos, extracteur...) par un connecteur à broche, et construire un module basique avec des sélecteurs équipé de la même broche.
Ce module me permettrait de commander manuellement mes séchoirs (on/off) sans automatiser les cycles, le temps du depannage... et/ou alors, avoir un arduino de Spare

Merci pour vos remarques !

Bonjour à tous,

D’après ce que j’ai compris il y a 6 valeurs analogiques en entrées Température et Humidité venant de 3 points différents. Selon ces valeurs on actionne des ventilos, extracteurs ou chauffage via 9 relais. Un simple UNO suffit. Tournant à 16Mhz une conversion analogique s’effectuant en 100 microsecondes donc largement le temps de gérer 1000 séchoirs durant le temps d’un loop()…

Pas de boucles while() ! 3 boucles if() suffisent :

if ( temp1 > TEMP_MAXI ) {
ventilo1=true;
extract1=true;
chauffage1=false;
}
else if ( temp1 < TEMP_MINI ) {
ventilo1=false;
extract1=false;
chauffage1=true;
}
else {
ventilo1=false;
extract1=false;
chauffage1=false;
}

Gatizne:
Pour info, la dimension des séchoirs rectangulairse est de 30m3 environ et il sont côte à côte...La gestion complète serait faite par Mr Arduino, alors que Mr PC ne serait qu'une interface "boutons", Graph, et saisie des valeurs de séchage...
En ce qui concerne une éventuelle panne du système, j'avais pensé à relier mon automate à mes différents éléments (ventilos, extracteur...) par un connecteur à broche, et construire un module basique avec des sélecteurs équipé de la même broche.
Ce module me permettrait de commander manuellement mes séchoirs (on/off) sans automatiser les cycles, le temps du depannage... et/ou alors, avoir un arduino de Spare

Merci pour vos remarques !

ok donc arduino en autonome pour les decisions, mais injection de "scenario" (valeurs de seuils et autres) a partir d'un pc ?

Tout a fait artouste

Gatizne:
Tout a fait artouste

bonjour
ok
Alors ton vrai premier gros probleme/soucis est de bien reflechir à l'enregistrement des scenarios
l'idée premiere est d'utiliser l'eeprom de l'arduino pour stocker ces scenarios

une bonne attitude de reflexion serai déjà que tu pose sur papier un/des scenarios que tu pense le plus complexe.
ça permettra d'en tirer les impératifs

Salut !

Voilà un premier jet …

J’ai posté deux fichiers images :

  • La fonction loop() de l’arduino
  • La fonction Consigne1() gérant mon sechoir n°1
    J’ai un probleme sur la consigne et sur le scénario a utiliser. Dans mon organigramme le programme boucle sur chaque mesure d’humidité en attendant que la valeur lue nous fasse sortir de celle ci pour enchaîner.
    Je n’arrive pas a utiliser la notion de temps pour éviter d’être bloquer dans ces boucles.
    Ce que je dois faire:
  • Je suis en quel mode (Auto ou manuel)
  • Je suis en mode Auto, je regarde où j’en suis au niveau du cycle et j’adapte les consignes
  • Je reviens dans ma Loop() pour regarder les autres séchoirs…

Merci pour vos infos

Gatizne:
Salut !

Voilà un premier jet ...

J'ai posté deux fichiers images :

  • La fonction loop() de l'arduino
  • La fonction Consigne1() gérant mon sechoir n°1
    J'ai un probleme sur la consigne et sur le scénario a utiliser. Dans mon organigramme le programme boucle sur chaque mesure d'humidité en attendant que la valeur lue nous fasse sortir de celle ci pour enchaîner.
    Je n’arrive pas a utiliser la notion de temps pour éviter d'être bloquer dans ces boucles.
    Ce que je dois faire:
  • Je suis en quel mode (Auto ou manuel)
  • Je suis en mode Auto, je regarde où j'en suis au niveau du cycle et j'adapte les consignes
  • Je reviens dans ma Loop() pour regarder les autres séchoirs..

Merci pour vos infos

documente toi sur le principe des machines à états
ici tu n'est pas tributaire du temps mais des mesures
déjà il faut penser à faire de la moyenne filtrée et ne pas se precipiter
Ce sont des processus à evolution lente
ça ne sert pas à grand chose à faire du changement d'etat moteur à l'echelle de la ms
le principe est de faire de l'acquisition de capteurs et sortir une moyenne "filtrée"
et d'en tirer les etats à suivre toutes les secondes ou +

J'ai regardé les machines à état et leur diagrammes.
J'essaye de tracer le diagramme de mon projet mais j'ai beaucoup trop d'états...
Par contre, artouste, qu'entend tu par moyenne filtrée ?
Merci

J'essaye de tracer le diagramme de mon projet mais j'ai beaucoup trop d'états...

Tôt ou tard, il faudra le coder. Quelque soit le moyen utilisé machine à état ou gros sac de if then .. else ... Donc il faudra bien que tu décrives tes états et leurs transitions (sinon tu vas en oublier). Autant le faire bien tout de suite.
Le fait de l'écrire va peut être d'ailleurs te faire entrevoir qu'il y a des simplifications possibles ou des attendus peu clairs.

Je suis entrain d’essayer d’appliquer la logique d’une machine à état sur mon automate.
Je visualise d’abord les états dans lesquelles mes séchoirs peuvent se trouver, avant d’aller plus en détail dans les “sous” états de chaque mode (manuel, stand by ou automatique).
Vais-je dans la bonne direction ? j’ai commencé par lister toutes les positions que peuvent prendre les séchoirs (27 en tout)
J’ai posté un fichier tableur nommé “Etats”

Etats.xlsx (9.05 KB)

Les 3 séchoirs sont indépendants ?

Physiquement indépendants mais tous gérés par un seul automate et une même interface

Gatizne:
Physiquement indépendants mais tous gérés par un seul automate et une même interface

S’ils sont indépendants, la machine à états est la même pour tous. Elle est simplement dupliquée trois fois.
Donc au bout du compte, il n’y a que 3 états.
Ce qui fait que tu te retrouves avec machine à états qui a trois états possibles (avec éventuellement des sous-états).
Pour gérer 3 séchoirs, tu as 2 stratégies possibles:

  • recopier 3 fois la machines à états et ses variables
  • n’utiliser qu’une machine à états et avoir 3 jeux de variables (dans un tableau) et traiter les 3 séchoirs séquentiellement.

Personnellement, j’aurais une préférence pour la seconde solution. La gestion des séchoirs mets en oeuvre des processus relativement lents qui s’accommodent bien de ce mode de fonctionnement.
La première solution qui de prime abord peut sembler plus simple est en fait très sournoise car lors de la recopie de la machine il faut penser à indicer toutes les variables pour que chaque machine dispose des ses propres variables. La moindre erreur lors de la recopie peut être assez longue à débusquer. Pour la même raison le code est moins facile à maintenir car on peut facilement oublier de mettre à jour l’une des occurrences de la machines en faisant des correctifs.

fdufnews:
...
Donc au bout du compte, il n'y a que 3 états.
Ce qui fait que tu te retrouves avec machine à états qui a trois états possibles (avec éventuellement des sous-états).
Pour gérer 3 séchoirs, tu as 2 stratégies possibles:

  • recopier 3 fois la machines à états et ses variables
  • n'utiliser qu'une machine à états et avoir 3 jeux de variables (dans un tableau) et traiter les 3 séchoirs séquentiellement.

Personnellement, j'aurais une préférence pour la seconde solution.

bonsoir
je ne sais pas pourquoi ? mais moi aussi :grin:

Bonsoir,

Après quelques heures passées sur des feuilles de papier brouillon, je me suis lancé dans un premier temps sur le code de Mr arduino… :roll_eyes:
Je sais, j’aurais dû commencer par coder le plus difficile, mais je voulais être sûr du “fonctionnement” pricncipal …
J’ai donc essayé de coder la boucle principale en travaillant d’abord sur un séchoir et je voulais avoir votre avis (pour les plus courageux :P), n’hésitez pas à me poser des questions, je dois pouvoir surement l’améliorer, l’alléger, le simplifier…
A vos commentaires ( mais pas trop virulents non plus…je suis un newbie :D)

Je vous expliquerai si vous voulez le mode “AUTO” du séchoir ou je bataille sur les tableaux dynamiques, les pointeurs…

#include <Arduino.h>
#include <DHT.h">
#include <SoftwareSerial.h>

#define DHTPIN1 11 //DHT1 SUR PIN DIGITAL 11
#define DHTPIN2 12 //DHT2 SUR PIN DIGITAL 12
#define DHTPIN3 13 //DHT3 SUR PIN DIGITAL 13

#define DHTTYPE DHT22   // DHT 22  (AM2302)
DHT dht1(DHTPIN1, DHTTYPE);
DHT dht2(DHTPIN2, DHTTYPE);
DHT dht3(DHTPIN3, DHTTYPE);

int Palier_S1[10] = {0,0,0,0,0,0,0,0,0,0}; // tableau des valeurs d'HR% des palier du mode auto
int MODE_S1 = 0;                        // variable du mode du sechoir n_1
float HR [3] = {0,0,0};                 // Tableau des mesures d'humidite relative
float TEMP [3] = {0,0,0};               // Tableau des mesures de temperatures
boolean Xon [3] = {0,0,0};              // Tableau action sur extracteurs
boolean Von [3] = {0,0,0};              // Tableau action sur ventilateurs
boolean Con  [3] = {0,0,0};             // Tableau action sur chauffages
float CONS_T [3] = {0,0,0};             // Tableau des consignes de temperatures
int DONSERIE;                           // Variable servant à récupérer
                                        // les données reçues sur le port serie
int PINRELAISCH [3];                    //Création tableau pin arduino/type de relais
int PINRELAISEX [3];
int PINRELAISVEN [3] ;

void setup()
{
Serial.begin(9600);
dht.begin();

int v = 0 ;
for (v = 0; v < 3; v = v+1)         //initialisation du tableau pin arduino/type de relais
    {                               // et passage des pins en sortie
    PINRELAISCH [v] = v + 2 ;
    PINRELAISEX [v] = v + 5 ;
    PINRELAISVEN [v] = v + 8 ;
    pinMode(PINRELAISCH[v],OUTPUT);     //Pinrelais 0 = Pin 2 (relais Chauffage 1)
    pinMode (PINRELAISEX[v],OUTPUT);    //Pinrelais 1 = Pin 3 (relais Chauffage 2)
    pinMode(PINRELAISVEN[v],OUTPUT);    //Pinrelais 2 = Pin 4 (relais Chauffage 3)
    }                                   //Pinrelais 3 = Pin 5 (relais Extracteur 1)
                                        //Pinrelais 4 = Pin 6 (relais Extracteur 2)
                                        //Pinrelais 5 = Pin 7 (relais Extracteur 3)
                                        //Pinrelais 6 = Pin 8 (relais Ventilos 1)
                                        //Pinrelais 7 = Pin 9 (relais Ventilos 2)
                                        //Pinrelais 8 = Pin 10 (relais Ventilos 3)
}

void loop()
{

    HR [0] = dht1.readHumidity();           //Acquisition données capteur HR et temp
    TEMP [0] = dht1.readTemperature();      //.(...).
    HR [1] = dht2.readHumidity();
    TEMP [1] = dht2.readTemperature();
    HR [2] = dht3.readHumidity();
    TEMP [2] = dht3.readTemperature();

    int i=0;
    for (i=0;i<3;i=i+1)                     //traitement mesures HR et TEMP des 3 sechoirs
    {
        if (isnan(TEMP[i]) || isnan(HR[i])) //test erreur mesure des 3 capteurs DHT
        {
            Serial.println("ERREUR DHT22");
        }

        else                                // Essai Affichage données des 3 capteurs sur moniteur
        {
        Serial.print(i+1);
        Serial.print(": Humidite : ");
        Serial.print(HR[i]);
        Serial.print(" %\t");
        Serial.print("Temperature : ");
        Serial.print(TEMP[i]);
        Serial.println(" *C");
        }
    }

    switch (MODE_S1)                        // test du mode du séchoir 1 (Stand by, manuel ou auto)
        {
        case 1:               //Mode Manuel
            if (Serial.available()>0)       // Si des données sont disponibles sur le port série
            {
            DONSERIE = Serial.read();       // On les récupère dans DONSERIE
                switch (DONSERIE)           //Traitement des données reçues
                {
                        case '1':        // Si "V1ON" est reçu
                        Von [1] = 1 ;       // On stock la commande
                        case '2':       // (...)
                        Von [1] = 0 ;
                        case '3':
                        Con [1] = 1 ;
                        case '4':
                        Con [1] = 0 ;
                        case '5':
                        Xon [1] = 1 ;
                        case '6':
                        Xon [1] = 0 ;


                        break;
                }
            }

            break;


        case 2:             // Mode Auto
            break;
        }
                            // Mode Stand by
ContactRelais();
 //switch (MODE_S2)                        // test du mode du séchoir 2 (Stand by, manuel ou auto)
 //switch (MODE_S3)                        // test du mode du séchoir 3 (Stand by, manuel ou auto)
}
void ContactRelais()                //Fonction commande des relais suivant etat des variables
    {
    for (int i=0;i<3;i++)
        {
     if (Xon[i] = 1 )
        {
         digitalWrite(PINRELAISEX[i],HIGH);
        }
        else{
            digitalWrite(PINRELAISEX[i],LOW);
            }
     if (Con[i] = 1 )
        {
         digitalWrite(PINRELAISCH[i],HIGH);
        }
        else{
            digitalWrite(PINRELAISCH[i],LOW);
            }
    if (Von[i] = 1 )
        {
         digitalWrite(PINRELAISVEN[i],HIGH);
        }
        else{
            digitalWrite(PINRELAISVEN[i],LOW);
            }
        }
    }

Pardon pour le post précédent pour la lecture du code..ya peut mieux....... :roll_eyes: