Forum automatisme

Bonjour,

Je dois centraliser plusieurs entrées pour faire sortir des "sous-alarmes" qui doivent à leur tour faire apparaître une alarme regroupée.
Cette alarme regroupée doit être à ré-apparition, c'est à dire que sur un front montant, elle se met à clignoter. Après avoir pris en compte le défaut en appuyant sur un bouton, elle s'allume en fixe jusqu'à ce que le défaut soit réglé puis acquitté en local.

J'ai filtré mes entrées, de façon à éviter les intempestifs.

J'ai voulu réaliser une détection de front montant, mais je me suis aperçu que tant que ma variables de sous-alarme est à 1 (si une autre entrée passe à 1 entre temps), mon alarme restait fixe et ne se mettait pas à reclignoter.
J'ai essayé de faire un RESET puis SET de mon alarme, histoire de relancer un clignotement.
Mais j'ai raisonné comme un informaticien, du coup, l'automate RESET puis SET dans un même cycle, donc ma sortie ne bouge pas.

J'aimerais donc savoir s'il exister un mot interne mesurant le nombre de cycle, histoire de pouvoir tester si on était dans le même cycle (on RESET) puis le cycle suivant (on SET).

Je suppose qu'il existe des solutions toutes faites pour faire ce genre de chose, mais bon.

Si vous avez des débuts de piste, je suis preneur.

Merci d'avance.

Salut !


pour résumer tu as :

Alarme 1--|-- Sous Alarme 1 ----- Voyant défaut (ce voyant doit clignoter quand un alarme apparait même si d'autre alarmes sont déjà à 1 ? )
Alarme 2--|
Alarme 3--|

tu veux faire cela au niveau :
de l'automate (quelle marque / modele) ?
de l'IHM (quelle marque / modèle) ?

slts,
J’avais fais un truc de ce genre pour la commande du voyant défauts, à tester
----clic pour zoom ---- ----

re !

si on a des bit de mots (on teste l'apparition de 16 défauts d'un coup):

/* A FAIRE une FOIS au début
Reset apparition d'un défaut

/* Mot défaut N° 1
Mot def_1
XOR
Mémoire Mot Def_1
AND
Mot_Def_1
Set apparition d'un défaut si résultat = <> 0
Mémoire Mot Def_1 = Mot Def_1

/* Mot défaut N° 2
Mot def_2
XOR
Mémoire Mot Def_2
AND
Mot_Def_2
Set apparition d'un défaut si résultat = <> 0
Mémoire Mot Def_2 = Mot Def_2

.... Faire pareil pour les mots de défauts suivants

de cette manière, Apparition d'un défaut est à 1 pour un tour de cycle si un défaut apparait dans un des mots de défauts.
Edit : Modifié pour avoir uniquement l'apparition des défauts

Bonjour à tous et merci pour vos retour.

philou77 a écrit : ↑21 avr. 2022, 17:58 Salut !


pour résumer tu as :

Alarme 1--|-- Sous Alarme 1 ----- Voyant défaut (ce voyant doit clignoter quand un alarme apparait même si d'autre alarmes sont déjà à 1 ? )
Alarme 2--|
Alarme 3--|

tu veux faire cela au niveau :
de l'automate (quelle marque / modele) ?
de l'IHM (quelle marque / modèle) ?

J'ai plutôt :

Entrée01 --|--Sous Alarme1 --|-- Alarme Générale à réapparition --> Voyant.
Entrée02 --|.....................|
Entrée03 --|.....................|
EntréeXX --|.....................|
....................................|
Entrée11 --|--Sous Alarme2 --|
Entrée12 --|
Entrée13 --|
EntréeXX --|

L'alarme clignote jusqu'à ce qu'elle soit fixée par un bouton (prise en compte de l'alarme) en salle de commande.
Ensuite, elle passe en fixe.
Le défaut est ensuite acquitté en local quand le problème est réglé (voyant éteint).
L'API est un Schneider M580, l'IHM un Schneider HMIDT642.

En fait, la gestion du clignotement et de l'acquittement du voyant est géré par du relayage (ancienne installation).

Mon rôle avec l'automate est de gérer la réapparition de l'alarme.
Sur apparition d'un défaut sur une des 130 entrées, une des 2 sous alarmes s'active (ou se réactive) et doit pouvoir relancer le clignotement de l'alarme regroupée pour que le nouveau défaut soit pris en compte (est non caché par le 1er défaut).
Je pensais que sur un front montant (un simple RE de la variable), un simple RESET/SET de la sortie est suffisant.
Mais ce qui me pose problème, c'est de réussir à attendre un cycle entre le RESET et le SET.

Ca me donnerait un truc de ce style :
IF RE(entrée1) OR RE(entrée2)
THEN
RESET(sous_alarme1) ;
SET(sous_alarme1) ;
END_IF

IF RE(sous_alarme1) OR RE(sous_alarme2)
THEN
RESET(sortie) ;
SET(sortie) ;
END_IF

Mais ça à l'air un poil plus compliqué.

Je dois avouer que les solutions que vous m'avez proposée sont assez ardues à comprendre pour moi.
J'ai pas joué avec les masques de bits comme vous le faites depuis une presque 20ans, du coup, je comprend un peu le principe, mais de là à retranscrire ça par moi-même, il y a un monde

Dans mon cas précis, je pense que si j'arrive à faire le RESET durant le cycle, puis le SET durant le cycle+1, ça devrait fonctionner, non ?

Re !
Je me doutais bien que tu avais plusieurs sous alarmes

Itasoft et moi t'avons donné une solution..

encore une fois, il te reste un travail a faire, adapter les solutions à ton cas.

Un XOR est un ou exclusif (c'est soit l'un, soit l'autre, mais pas les deux)
L'astuce de refaire un AND avec le mot de défaut et le résultat du XOR est pour ne prendre QUE les défauts présents !
sinon, tu aurais aussi les disparitions des défauts, et ce n'est pas le but.

c'est quoi Entree01 ?? une entree TOR, un bit , un bitr de mot ?

C'est une entrée TOR que j'ai filtré.
TON_1(entrée_TOR_1, TEMPO_COURTE, entrée1_filtrée) ;

Du coup, faut-il que je les regroupe en mot ?
Ca risque d'être risqué au niveau de la lisibilité, non ?

A ton avis, ma solution vaut-elle le coup d'être creusée, ou il faut mieux que j'essaie d'adapter votre solution ?

Et du coup, si ma solution peut être viable, juste pour savoir, il n'existe pas un mot système qui compte le nombre de cycle depuis le lancement du programme, ou un bit qui se met à 1 à chaque cycle, qui nous permettrait de les compter ?

@Phil
j'ai integré ta simplification, bien vu, fais toi rembourser une ligne de prog. lol
------- ----------qu'il commence déjà par copier et tester l'exemple-----clic dessus pour zoom----- ---

@itasoft

J'ai essayé ta méthode avec 16 variables, je pense que ça fonctionnerait, mais ça m'oblige à partir sur une gestion en mot et j'ai peur que ça finisse par me poser problème.

Comme je l'ai dit plus haut, la gestion du clignotement, de la fixation et de l'acquittement du défaut est déjà gérée par du relayage.

En revanche, j'ai une question toute bête : comment on gère les fronts montants ?

J'ai essayé un truc de ce style là : Mais j'ai l'impression que mon front montant n'est pas détecté (la variable front reste à 1 en permanence).
la variable front est un BOOL, et les variables entrée 1 et 2 sont des EBOOL.

J'ai rien paramétré d'autres. Il y a sûrement un e option quelconque qui m'échappe.

kalimeth a écrit : ↑22 avr. 2022, 00:23 Du coup, faut-il que je les regroupe en mot ?
Ca risque d'être risqué au niveau de la lisibilité, non ?

Oui pour la première, non pour la deuxième !


Tu fais un bloc qui ne gère que le regroupement et les test D'apparition des défauts
0 -> Tu appelles le bloc
1 -> tu regroupes tes bits de défauts sur des mots
2 -> tu fais les tests pour chaque mot de défaut.
4 -> tu sors du bloc

Si le bit Apparition de défaut est à 1 alors tu fais clignoter ton voyant
si ton bouton acquitement clignotement est à 1 alors tu RESET le bit Apparition de défaut dans ta programmation
Aucun changement dans la programmation de tes défauts, le nouveau bloc est juste de l'information, seul :
- l'acquittement du clignotement est à faire (Reset Bit Apparition défaut)
- Le clignotement si Bit Apparition défaut = 1

Je vois pas ce qui est compliqué.

Regarde dans l'aide ou sur le net, ou sur le forum.
Sujet déjà traité maintes et maintes fois sur les fronts BOOL et EBOOL, et la différence entre RE et R_TRIG.


Et si tu es fâché avec les masques..