Relè Passo Passo Con Plc

[form]

Salve a tutti, ho appena finito un corso di plc sull's7 300, pensavo di essere diventato bravino nel realizzare piccole applicazioni,fino a tre giorni fa, quando ho avuto la necessità di accendere e spegnere una lampada sempre dallo stesso pulsante.

Non riesco a trovare una soluzione e sinceramente mi sono molto scoraggiato, mi sembra di aver fatto tre passi indietro.

Spero che ci sia qualcuno che mi aiuti con questo piccolo problema che per me è diventato mastodontico.

Ho cercato questa soluzione in giro per il forum ma non sono riuscito a trovarla, spero che non sia stata gia trattata.

Grazie atutti e buona giornata.

[Livio Orsini]

Ti do l'idea base.

Riconosci il fronte del pulsante con l'apposita istruzione. Sul fronte inverti lo stato di un merker (Step7 ha l'istruzione "nega"). Copia lo stato del merker sull'uscita che comanda la lampada. Puoi anche evitare di usare il merker: è sufficiente fare le operazioni direttamente sull'uscita.

Modificato: 9 marzo 2007 da Livio Orsini

[form]

La ringrazio per l'attenzione che mi ha prestato, ho provato a fare qualche prova, ma non sono riuscito a trarre alcun risultato, forse perche non conosco la funzione "nega", 0 forse perche ho interpreteto male la sua risposta.

Potrebbe gentilmente darmi qualche altra delucidazione in merito?

Grazie e buona serata.

[Savino]

Ciao,

accendere e spegnere una lampada sempre dallo stesso pulsante.

Una delle tante possibili soluzioni

E   0.0  : Pulsante
A   0.0  : Lampada 
M   0.1  : Merker ausiliare
M   0.2  : Merker ausiliare

AWL:
U     E      0.0
UN    M      0.0
S     A      0.0
U     A      0.0
U     M      0.1
R     A      0.0
NOP   0


***

UN    E      0.0
U     A      0.0
S     M      0.0
U     E      0.0
U     M      0.1
R     M      0.0
NOP   0


***

U     E      0.0
U     M      0.0
S     M      0.1
UN    E      0.0
UN    A      0.0
R     M      0.1
NOP   0


***
/////////////////////////


KOP:
                   
         
|Network 1
|                         
|                        A 0.0
|  E 0.0    M 0.0    +-----------+
|                    |    SR     |
+--[ ]------[/]------+S         Q+------------
|                    |           |
|                    |           |
|  A 0.0    M 0.1    |           |
+--[ ]------[ ]------+R          |
|                    |           |
|                    |           |
|                    +-----------+
|
|
|Network 2
|                         
|                        M 0.0
|  E 0.0    A 0.0    +-----------+
|                    |    SR     |
+--[/]------[ ]------+S         Q+------------
|                    |           |
|                    |           |
|  E 0.0    M 0.1    |           |
+--[ ]------[ ]------+R          |
|                    |           |
|                    |           |
|                    +-----------+
|                    
|Network 3
|                         
|                        M 0.1
|  E 0.0    M 0.0    +-----------+
|                    |    SR     |
+--[ ]------[ ]------+S         Q+------------
|                    |           |
|                    |           |
|  E 0.0    A 0.1    |           |
+--[/]------[/]------+R          |
|                    |           |
|                    |           |
|                    +-----------+   
|                
|                
|         
Tabella variabili 
--------------------------------------------------------------------------------
EB     0        BIN    2#0000_0000    2#0000_0000      pulsante a riposo
AB     0        BIN    2#0000_0000     
MB     0        BIN    2#0000_0000     
--------------------------------------------------------------------------------
EB     0        BIN    2#0000_0001    2#0000_0001      primo impulso
AB     0        BIN    2#0000_0001     
MB     0        BIN    2#0000_0000
--------------------------------------------------------------------------------     
EB     0        BIN    2#0000_0000    2#0000_0000      rilascia pulsante
AB     0        BIN    2#0000_0001     
MB     0        BIN    2#0000_0001
--------------------------------------------------------------------------------    
EB     0        BIN    2#0000_0001    2#0000_0001      secondo impulso
AB     0        BIN    2#0000_0000     
MB     0        BIN    2#0000_0010     
--------------------------------------------------------------------------------     
EB     0        BIN    2#0000_0000    2#0000_0000      rilascia pulsante
AB     0        BIN    2#0000_0000     
MB     0        BIN    2#0000_0000

[ixa]

U E0.0 : pulsante

Un A1.0 : lampada

Un M0.0

= M0.1 : fronte di salita per lampada ON

U E0.0

= M0.0

--------------

U E0.0 : pulsante

U A1.0 : lampada

Un M0.2

= M0.3 : fronte di salita per lampada OFF

U E0.0

= M0.2

--------------

U M0.1 : fronte di salita per lampada ON

S A 1.0 : lampada

--------------

U M0.3 : fronte di salita per lampada OFF

R A1.0 : lampada

--------------

[Matteo Montanari]

io ho sempre utilizzato questo (sia con Step5 sia con Step7 in Mondo Siemens, ed anche con altri tipologie di PLC):

E   0.0  : Pulsante
A   0.0  : Lampada 
M   0.0  : Appoggio

AWL:
U     E      0.0
UN    M      0.0
S     A      0.0
U     E      0.0
U     M      0.0
R     A      0.0
NOP   0


***

UN    E      0.0
U     A      0.0
S     M      0.0
UN    E      0.0
UN    A      0.0
R     M      0.0
NOP   0

KOP:
                   
         
|Network 1
|                         
|                        A 0.0
|  E 0.0    M 0.0    +-----------+
|                    |    SR     |
+--[ ]------[/]------+S         Q+------------
|                    |           |
|                    |           |
|  E 0.0    M 0.0    |           |
+--[ ]------[ ]------+R          |
|                    |           |
|                    |           |
|                    +-----------+
|
|
|Network 2
|                         
|                        M 0.0
|  E 0.0    A 0.0    +-----------+
|                    |    SR     |
+--[/]------[ ]------+S         Q+------------
|                    |           |
|                    |           |
|  E 0.0    A 0.0    |           |
+--[/]------[/]------+R          |
|                    |           |
|                    |           |
|                    +-----------+
|

[batta]

Mi pare che se ne sia già parlato, comunque io suggerirei le seguenti soluzioni:

//Ricavo Fronte Salita Pulsante
U "Pulsante"
FP "AuxFronteSalita"
= "FronteSalita"

//Eseguo XOR tra stato uscita comando lampada e fronte salita pulsante.
//Il risultato dell'operazione XOR viene assegnato al comando lampada
X "FronteSalitaPulsante"
X "Lampada"
= "Lampada"

Problema risolto con 6 righe di codice e 2 merker (Fronte Salita e ausiliario Fronte Salita) Ragioniamo sul funzionamento: Partiamo con lampada spenta. Abbiamo: "FronteSalitaPulsante" = FALSE "Lampada" = FALSE Il risultato dell'operazione è quindi FALSE: la lampada rimane spenta. Premendo il pulsante avremo per una scansione: "FronteSaliaPulsante" = TRUE "Lampada" = FALSE Il risultato dell'operazione XOR sarà quindi TRUE, e tale risultato verrà assegnato a "Lampada". La lampada si accende. Dalla successiva scansione quindi ci troveremo con: "FronteSalitaPulsante" = FALSE "Lampada" = TRUE Il risultato di XOR sarà quindi TRUE e "Lampada" rimane quindi accesa. Se ora, con lampada accesa, premiamo ancora il pulsante, per una scansione avremo: "FronteSalitaPulsante" = TRUE "Lampada" = TRUE Il risultato dell'operazione XOR sarà quindi FALSE, e tale risultato verrà assegnato a "Lampada". La lampada si spegne. Utilizzando questa sintassi non si può visualizzare il segmento in KOP. Una soluzione valida anche in KOP è la seguente:

//Ricavo Fronte Salita Pulsante
U Pulsante
FP AuxFronteSalita
= FronteSalita

//Se la lampada è spenta, con fronte salita accendo lampada. La lampada rimane accesa con autoritenuta.
//L'autoritenuta viene annullata dal prossimo fronte di salita del pulsante.
UN "Lampada
U "FronteSalitaPulsante"
O
U "Lampada"
UN "FronteSalitaPulsante"
= "Lampada"

Problema risolto con 9 righe di codice e due merker.

[form]

Grazie a tutti delle vostre risposte, ho preso in considerazione solo quelle in kop perchè è l'unico linguaggio che conosco, ma nessuno dei vostri suggerimenti funziona.

Secondo voi potrebbe essere colpa del simulatore?

Eppure con le altre applicazioni non mi ha dato mai problemi.

Spero ancora in un vostro aiuto.

[ixa]

....onestamente non ho testato la sequenza di istruzioni che ti ho suggerito;........nel dubbio le ho rilette,….certo non sono un granché…lo devo ammettere!…ma FUNZIONANO!

Ciao!

[Savino]

nessuno dei vostri suggerimenti funziona

.Impossibile... li ho provato tutte con una CPU 314... tutto ok.

Ma ne sei sicuro che il codice sta' girando..

[marco.28]

Modificato: 11 marzo 2007 da marco.28

[rguaresc]

Questo e' in kop gia' pronto. Ma se vuoi fare progressi devi ragionare sui suggerimenti.

[batta]

La seconda soluzione da me suggerita è convertibile in KOP e ti posso assicurare che funziona!

Ovviamente, per poterla convertire in KOP, devi scrivere le istruzioni in 2 segmenti: il primo per ricavare il fronte di salita, ed il secondo per il flip-flop.

In kop risulta come segue:

Segmento 1
   Pulsante       AuxFronte     FronteSalita
------| |------------|P|------------( )


Segmento 2

  Lampada      FronteSalita                   Lampada
-----|/|------------| |------------+------------( )
                                   |
  Lampada      FronteSalita        |
------| |------------|/|-----------+

[Livio Orsini]

la soluzione che ho descritto a parole nel post #2 è stata esemplificata da Batta. Osservando il KOP però, a mio giudizio c'è qulache cosa che non va nel reset della lampada.

[batta]

Il sistema è collaudato.

Rivediamolo scritto, per comodità, in AWL (tralasciando la generazione del fronte):

UN "Lampada"

U "FrontePulsante"

O

U "Lampada"

UN "FrontePulsante"

= "Lampada"

Se la lampada è spenta, senza pressione pulsante le condizioni

UN "Lampada"

U "FrontePulsante"

U "Lampada"

UN "FrontePulsante"

sono entrambe false, quindi la lampada rimane spenta.

Con fronte salita diventa vera la condizione

UN "Lampada"

U "FrontePulsante"

quindi la lampada si accende.

Dalla successiva scansione troveremo vera invece la condizione

U "Lampada"

UN "FrontePulsante"

che mantiene la lampada accesa.

Premendo ancora il pulsante ci troveremo ad avere le condizioni

UN "Lampada"

U "FrontePulsante"

U "Lampada"

UN "FrontePulsante"

entrambe false.

Infatti

UN "Lampada"

U "FrontePulsante"

è falsa perché "Lampada" è ON. mentre

U "Lampada"

UN "FrontePulsante"

è falsa perché è ON "FrontePulsante".

La lampada quindi si spegne.

[Livio Orsini]

In AWL le cose mi sembra funzionino, probabilmente sarà perchè il KOP proprio non lo uso.

[batta]

Livio, le descrizioni dettagliate, ovviamente, non erano per te, ma solo per fare un pò di didattica.

La traduzione in AWL di quanto da te suggerito nel post #2, sistema molto valido e che richiede poche righe di codice, è la seguente:

//Genero fronte salita pulsante
U "Pulsante"
FP "AuxFronteSalita"
= "FronteSalita"

//Con fronte salita FALSE salto, qundi non effettuo nessuna variazione di stato dell'uscita "Lampada"
UN "FronteSalita"
SPB M000
//Con fronte salita TRUE effettuo l'inversione dello stato dell'uscita "Lampada"
UN "Lampada"
= "Lampada"
M000: NOP 0

La mia opinione? Se si programma in AWL credo che le soluzioni migliori siano quella che sfrutta l'istruzione XOR (post #7) e quella proposta da Livio e qui esposta.

Per la programmazione in KOP quella esposta nel post #13

Se devo essere sincero, tutte le altre soluzioni mi sembrano inutilmente macchinose.

[Savino]

Se devo essere sincero, tutte le altre soluzioni mi sembrano inutilmente macchinose.

Beh non direi..

Il Ladder postato da Mateo che sarebbe fatto con un rele' in meno di quello postato da me sarebbe alla fine il circuito elettromeccanico base universalmente portabile su tutte i Ladder PLC, qiundi niente di particolare.

La forma postata da batta, che funziona ergregiamente, sarebbe la piu' semplificata su tutte e per S7300 andrebbe benissimo ma che a me personalmente non piace utilizzarla (FP)

Modificato: 12 marzo 2007 da Savino

[Luca Bab]

Visto che ci siamo , posto anche quello che io uso di solito ( non mi sembra citato )

e quella che mi piace di piu' ( comunque tutte funziano ) come gusto personalissimo è quella di Batta

( che potrei cominciare ad usarla , se Batta acconsente )

Seg 1

A Pulsante

AN Lampada

AN Mem Appoggio

S Mem Appoggio

S Lampada

Seg 2

A Pulsante

A Lampada

AN Mem Appoggio

S Mem Appoggio

R Lampada

Seg 3

AN Pulsante

R Mem Appoggio

Saluti

Luca

[Livio Orsini]

Livio, le descrizioni dettagliate, ovviamente, non erano per te, ma solo per fare un pò di didattica.

No Batta vanno bene anche per me Sono anni che non uso il KOP e anche il 300 è parecchio che non lo uso! Poi è molto giusto dare informazioni propedeutiche, questa è proprio la sezione didattica del forum sui PLC. Anche a me piace molto l'uso dello XOR per questo tipo di problematiche.

Io sono del parere che qualsiasi sia la funzione, la soluzione più ottimizzata è sempre la più affidabile e la più facile da manutenere.

Modificato: 12 marzo 2007 da Livio Orsini

[batta]

Per Luca:

Mi fa piacere che ti piaccia la mia soluzione.

E ti pare che per usarla mi devi chiedere il permesso?

Se non volessi farla usare agli altri non l'avrei certo messa sul forum

Io non ho mai messo protezioni sui miei programmi. Figurati se impedisco l'uso di un banalissimo flip-flop.

Per Livio:

grazie

Modificato: 12 marzo 2007 da batta

[form]

Buoma sera a tutti, non riesco a capire perche ho provato le varie vostre soluzioni che gentilmente mi havete proposto con lo step 7, ma nessuna funziona.

Però in alcune, tipo la seconda soluzione del post 6 di Matteo Montanari (cito questa perchè è l'ultima che ho preso in considerazione), secondo me non potra mai funzionare perche il flip flop non potra mai settarsi inquanto il contatto A0.0 non potra mai far passare corrente da sinistra a destra perche non cè nessun comando che lo abilita.

Comunque appena posso mi procuro una cpu e provo con una macchina reale.

Grazie a tutti.

[batta]

Io ho provato, col simulatore, le mie soluzioni e quella di Montanari che è quella che mi piace di più (dopo le mie, ovviamente ): come mi aspettavo, funzionano tutte anche col simulatore.

Del resto se un simulatore non simulasse correttamente queste banali istruzioni, che simulatore sarebbe?

Sei sicuro di usare il simulatore nel modo corretto?

Parli della seconda soluzione proposta da Matteo, ma Matteo ha proposto una sola soluzione (ripeto, perfettamente funzionante) scritta prima in AWL e poi in KOP.

So che per chi non è abituato passare da KOP ad AWL non è facilissimo, ma se programmi spesso S7-300/400 ti consiglio di iniziare, prima con le cose più facili, ad utilizzare l'AWL. Ti accorgerai presto di quante cose si possono fare in modo molto più semplice.

Nota bene: non dico assolutamente di non usare il KOP, che è imbattibile come comprensione se si hanno segmenti con logica booleana un pò complessi, ma prendi seriamente in considerazione la possibilità di fare programmi misti KOP/AWL.

[marco.28]

Salve a tutti. Una possibile soluzione al problema di form potrebbe essere la seguente:

  E0.0      M0.0              M0.1  
--| |------( P )--------------( S )--
                 |
                 |  A0.0      M0.1
                 +--| |-------( R )--


  M0.1                        A0.0  
--| |-------------------------(   )--





      

[Matteo Montanari]

la soluzione da me proposta è funzionante su circa un centinaio di macchine sia con Step5 sia con Step7, se non funziona con il simulatore non saprei cosa rispondere...

io utilizzo la funzione con memoria di appoggio, non utilizzando la "funzione XOR" semplicemente per il fatto che, nel programma originale questo è il comando di una valvola di un arresto (can-stop). la valovla in questione può essere comandata in Manuale ed in Automatico.

in pratica la condizione di "apertura" in ciclo automatico è inserita in parallelo al ramo pulsante (ingresso) + memoria ausiliria. (la condizione di "chiusura" sul ramo che esegue il Reset dell'uscita).

con questo sistema la valovla assume lo stato dell'ultimo comando automatico, ad ogni passaggio in "manuale" evitando di "perdere" il vasetto (o altro) presente sul nastro (o altra applicazione).

oltre tutto occorre valutare anche quante "risorse" (memorie in questo caso) occorre utilizzare per realizzare quanto richiesto.