Diagrammi Ladder di FSM

[s_ricc]

Ciao a tutti, sono nuovo in questo forum, ma credo di poter trovare persone competenti e in grado di spiegarmi cosa sto sbagliando nel mio ragionamento.

Sto cercando di avvicinarmi al mondo PLC per esigenze lavorative, in particolare mi sto concentrando sui diagrammi Ladder.

Se volessi implementare una macchina a stati con 3 stati - chiamiamoli per comodità S0, S1, S2 - in modo che alla pressione del pulsante I0.0 si passi in sequenza da uno stato all'altro, per poi ricominciare dallo stato iniziale S0 (quindi sequenza S0-->S1-->S2-->S0-->S1-->... con cambio di stato ad ogni pressione del pulsante NA), se la logica non mi inganna, mi verrebbe da dire che:

1) codifico i tre stati con i 3 bit M0.0, M0.1, M0.2 in modo che quando mi trovo in uno stato (es.S1) solo il corrispondente bit (es.M0.1) è a "1" mentre gli altri due bit (es.M0.0 e M0.2) sono a "0"

2) siccome ho tre stati prevedo 3 Rung nel mio diagramma (non aggiungo Rung per comandare uscite)

3) ciascun Rung che rappresenta uno stato sarà di fatto l'assegnazione al relativo bit M0.x di una funzione logica che prevede una serie (AND) di:

   - parallelo (OR) tra:

        - stato precedente M0.z AND chiusura I0.0 (implemento la transizione di ingresso nello stato M0.x venendo da M0.z)

        - autoritenuta stato attuale M0.x

   - stato futuro come contatto NC (in modo che quando passo allo stato M0.y esco dallo stato M0.x, implemento la transizione di uscita dallo stato M0.x)

4) per dare alla FSM come stato iniziale lo stato M0.0 nell'OR per questo particolare bit inserisco anche la serie di M0.0, M0.1, M0.2 come contatto NC.

 

Se a parole non è chiaro, la figura allegata dovrebbe chiarire (tralasciando i colori e il fatto che invece di M0.x abbiamo RAM0x, e I0.0 = ENT00.

 

Il problema è che se provo a implementare il Ladder su un simulatore online tipo quello della figura, appena aziono il pulsante di Input ENT00 la FSM diventa instabile e inizia a passare da uno stato all'altro. Poi appena riporto il pulsante sullo 0 la FSM ricade su uno stato pressoché casuale (dipende da dove si trovava al momento, suppongo) invece di presentare il comportamento che desideravo.

 

Quale errore commetto nel mio ragionamento?

grazie

[batta]

Dunque, partendo con tutti i bit a zero, il primo ramo imposta RAM00 = TRUE.

E fin qui ci siamo.

Poi premi il pulsante (ENT00) e diventano subito vere le condizioni per attivare RAM01 (riga 2).

A questo punto ti trovi con RAM00 = 1 e c'è ancora ENT00 = 1 (pulsante premuto).
Diventano quindi subito vere le condizioni della riga 4, e si attiva RAM01.

In questo momento ti trovi quindi con RAM00 = 1 e RAM01 = 1.

Anche ENT00 è sempre ON ma, nella riga 6, RAM00 = 1 impedisce l'attivazione di RAM02.

Inizi quindi la nuova scansione ancora con RAM00 = 1 e RAM01 = 1.

Viene quindi disattivato RAM00 (vedi riga 1, contatto negato di RAM01).

Procedendo, RAM01 rimane attivo (autoritenuta alla riga 5).
Alla riga 6, con RAM01 = 1, ENT00 = 1 e RAM00 = 0, viene attivato RAM02.

Successivamente RAM02 = 1 causerà la disattivazione di RAM01, e ripeterai il ciclo all'infinito.

Quando si rilascia il pulsante, ti troverai in una situazione casuale.

Per risolvere, devi prima di tutto rilevare il fronte di salita del pulsante, ed usare questo fronte per far avanzare i passi.

Poi, devi invertire l'ordine delle uscite, mettendo prima il ramo che attiva RAM02, poi il ramo di RAM01, e per ultimo il ramo di RAM00.

[s_ricc]

grazie batta,

 

quando dici:

17 minuti fa, batta scrisse:

Poi premi il pulsante (ENT00) e diventano subito vere le condizioni per attivare RAM01 (riga 2).

in realtà intendi riga 4 suppongo.

 

Quindi fondamentalmente il "problema" principale è che una volta arrivati a riga 7 si ricomincia a valutare da riga 1 anche se l'ingresso non è cambiato. Facendo una "simulazione su carta" credevo che la FSM funzionasse bene perché commettevo l'errore di fermarmi a riga 7 e non ricalcolavo tutto quanto.

Effettivamente come dici tu (con aggiornamento dei bit di stato solo in corrispondenza del fronte di ingresso) si capisce che una volta che uno stato (ad es RAM02) è stato aggiornato, anche se l'esecuzione riparte dalla prima riga non c'è possibilità di settare indebitamente RAM00 e RAM01 a riga 2 e 4 perché il rilevatore di fronte blocca il passaggio della corrente già dal ciclo successivo al primo dopo la "pigiata".

Una cosa però faccio fatica a capire: perché dici di cambiare l'ordine delle tre righe?

 

Inoltre: non ci sarebbe proprio alcun modo di implementare questa FSM a 3 stati soltanto con contatti NC e NA? (evitando l'uso dei rilevatori di fronte)

 

grazie

[Blackice]

Io trovo molto più comodo usare un contatore(si può inoltre salvare facilmente lo stato attuale in caso di mancanza corrente) e fare confronti tra il valore attuale di questo e delle costanti.

Ti metto un esempio in KOP:

                                                                                            

[batta]

Quote

Inoltre: non ci sarebbe proprio alcun modo di implementare questa FSM a 3 stati soltanto con contatti NC e NA? (evitando l'uso dei rilevatori di fronte)

Perché ti dà tanto fastidio il rilevamento del fronte? Guarda che è una cosa normalissima nella programmazione dei PLC.
Ti basta inserire una riga all'inizio, rilevare il fronte di salita di ENT000 e appoggiarlo a una memoria interna del PLC. Poi usi questa memoria al posto di ENT00.

 

Quote

Una cosa però faccio fatica a capire: perché dici di cambiare l'ordine delle tre righe?

Devi considerare che il PLC esegue le istruzioni, una alla volta, dall'alto verso il basso e, quando arriva alla fine, riparte dall'inizio.

Lasciando le istruzioni in questo ordine, nei passaggi da RAM00 --> RAM01 e RAM01 --> RAM02, per una scansione ti trovi con due stati ON contemporaneamente.

In realtà, il solo cambio di ordine dei segmenti non risolve il problema, perché ci troveremmo con due stati ON per una scansione nel passaggio RAM02 --> RAM00.
Ci sarebbe quindi da cambiare qualcos'altro.
Qualche suggerimento: l'attivazione di RAM00 potrebbe essere fatta solo valutando lo stato di RAM01 e RAM02.
Il passaggio RAM02 --> RAM00 potrebbe essere fatto solo resettando RAM02.

 

Tutto questo comunque vale solo come esercizio. È scomodo usare le autoritenute per questo tipo di compito. Già utilizzare SET e RESET faciliterebbe le cose.

 

Oppure, come suggerito da Blackice, si cambia completamente sistema.

[s_ricc]

Non mi dà nessun fastidio il rilevamento del fronte. Il mio dubbio nasceva dal fatto che ho trovato questo esercizio proprio alla fine del primissimo capitolo di un libro su PLC, capitolo nel quale sono introdotti soltanto i concetti di contatto NA, NC, Bobina, (Merker) e Autoritenuta. Già l'odea di implementarlo pensando a una FSM mi è derivato dal mio background elettronico, il libro non fa alcuna menzione di FSM in questa prima parte.

 

Voi come risolvereste questo esercizio con i soli 4/5 elementi che ho elencato?

Vi sembra un approccio sbagliato quello della FSM?

C'è un approccio più semplice ma comunque strutturato (=non lasciato all'esperienza del programmatore) per risolvere l'esercizio, senza utilizzare contatori, rilevatore di fronte o altro che non siano i semplici contatti NA ed NC ?

Mi chiedo se mi sono complicato il progetto, oppure con questi elementi l'approccio a FSM è il migliore che si possa adottare per questo tipo di esercizio.

 

grazie mille

 

[batta]

Se non vuoi utilizzare funzioni del PLC per il rilevamento del fronte, puoi rilevare il fronte usando solo contatti NO e NC.

Vedi esempio::

     Pulsante     MemPulsanteOff   FS_Pulsante
--------| |------------| |------------( )

     Pulsante                    MemPulsanteOff
--------|/|---------------------------( )

Si possono trovare anche altri sistemi, senza utilizzo del fronte di salita, ma sono sicuramente più complicati.

[step-80]

Io farei cosi: