Gestione Del Timer

[Lord]

Ciao a tutti

Mi è stato consigliato questo forum, io stavo cercando manuli, dove si spiegava il funzionamento del plc,timer counter....

A scopo didattico volevo realizzare tramire la premuta ed il successivo rilascio di un pulsante l' accesione di una lampadina per un tempo es di 5 minuti

avrebbe un senso http://i25.tinypic.com/icnvdk.jpg oppure appena rilascio il mio pulsante uscita va a zero,

Forse la premuta del mio pulsante la devo registrare tramite un flag di premuto in questo caso il Xo usato , ma questo flag in che zona lo resetto ??

grazie ancora.

ps ( esiste un simulatore a scopo didattico dove posso provare i ladder, con relativa simulazione dell uscita )

Modificato: 20 febbraio 2008 da Lord

[alfa84]

non si vede bene la figura

appena rilascio il mio pulsante uscita va a zero,

se non metti un contatto di autoritenuta in parallelo al pulsante il temporizzatore non può effettuare il conteggio e di conseguenza attivare il bit di temp.dopo 5 secondi ed ecc

per disattivare l'uscita oppure escludere l'autoritenuta dovresti mettere un contatto n.c...secondo la logica del la tua applicazione che non riesco a capire dalla figura

ciao

[Lord]

Quello che voglio realizzare è premuto e rilasciato un pulsante mi si accende instantaneamente una lampadina per es 5 minuti ha senso questo http://i29.tinypic.com/24pgkjr.jpg, ma dove resetto il flag del tasto premuto ?

[alfa84]

adesso mi è chiaro

quindi per fare quello che intendi devi mettere un flag ir203 come lo chiami in paralello al contatto normalmente aperto ir001...

per disattivare la funzione potresti mettre ad esempio un contattoi n.c del temp.in serie al primo segmento...e lo devi ,mettere in maniera tale da disattivare il tutto giusto?

[jake]

Ciao, allo stesso modo di come accendi la lampadina mentre il timer non ha finito di contare, resetti il flag di tasto premuto dopo che il timer ha contato, ovvero:

TIMER Tasto Premuto

--| |-----------(Reset)

Good Luck, Jake

[alfa84]

Ciao, allo stesso modo di come accendi la lampadina mentre il timer non ha finito di contare, resetti il flag di tasto premuto dopo che il timer ha contato, ovvero:

TIMER Tasto Premuto

--| |-----------(Reset)

non mie ro accorto che era una bobina di set mi era sembrata una bobina normale comunque è giusto come dice jake

[rddiego]

E0.1

--||--------------------------------------[ T1 ]-

A1.2 | T1

--||-------------|/|---------------------( A1.2 )-

Avresti bisogno di un flag, ma se analizzi bene vedrai in realtà che il flag ce l'hai già ed è la tua uscita A1.2.

Quindi ti basta metterla in OR al pulsante ed in AND alla sua stessa attivazione ed il programmino è a posto.

Premi il pulsante parte il timer e si accende la lampada.

Rilasci il pulsante ma il timer continua a contare perchè attivato dall'uscita stessa.

Allo scadere del timer T1 va a "1" e l'uscita si azzera.

Così com'è la logica non puoi spegnere l'uscita una volta premuto il pulsante e si spegnerà solo allo scadere del timer... ma per l'esempio che è non ti dovrebbe interessare..

[Lord]

In definitiva ho due soluzioni la prima, dove premo il pulsante 1 And T1nC mi attiva la lampadina A1.2, questa uscita A1,2 And T1 NC mi tiene alta quando rilascio il pulsante

E0.1

--||--------------------------------------[ T1 ]-

A1.2 | T1

--||-------------|/|---------------------( A1.2 )-

oppure la seconda con

http://i30.tinypic.com/23mg7a.jpg

Giusto ?

E se per ipotesi io dovessi gestire 5 lampadine ognuna collegata a 5 pulsanti diversi ma posso accenderne solo 4 alla volta contemporaneamente, mi devo creare una specie di contatore che mi indichi quante lampadine utilizzo es 1..4 questo lo devo decrementa solo una volta che la lampadina accesa si spegna giusto ? (o ci sono soluzioni piu semplici.) ma come rilevo che la lampadina passa dallo stato acceso allo stato spento ?

[alfa84]

n definitiva ho due soluzioni la prima, dove premo il pulsante 1 And T1nC mi attiva la lampadina A1.2, questa uscita A1,2 And T1 NC mi tiene alta quando rilascio il pulsante

E0.1

--||--------------------------------------[ T1 ]-

A1.2 | T1

--||-------------|/|---------------------( A1.2 )-

manca qualcosa se guardi bene infatti rdiego dice che dovresti mettere:

Quindi ti basta metterla in OR al pulsante ed in AND alla sua stessa attivazione ed il programmino è a posto.

la seconda ipotesi è corretta

E se per ipotesi io dovessi gestire 5 lampadine ognuna collegata a 5 pulsanti diversi ma posso accenderne solo 4 alla volta contemporaneamente, mi devo creare una specie di contatore che mi indichi quante lampadine utilizzo es 1..4 questo lo devo decrementa solo una volta che la lampadina accesa si spegna giusto ? (o ci sono soluzioni piu semplici.) ma come rilevo che la lampadina passa dallo stato acceso allo stato spento ?

no!non c'entra niente il contatore,con esso conteggi ad esempio il numero di pezzi che vengono rilevati da un sensore mentre scorrono su di un nastro...

oppure con count up-down sullo stesso nastro conteggi le bottiglie perfette(incrementano il conteggio),mentre quando passano le bottiglie da abolire fai count down(cioè decremento)

comunque tornando alla tua ipotesi ti chiedo conosci ad esempio lo schema elettrico di accensione di lampadae mediante relè?

convertilo in ladder secondo la tua logica è giusto un modo per farti capire meglio magari sbattendo la testa se hai probelmi posta pure le immagini

verificheremo ciao

[jake]

E se per ipotesi io dovessi gestire 5 lampadine ognuna collegata a 5 pulsanti diversi ma posso accenderne solo 4 alla volta contemporaneamente, mi devo creare una specie di contatore che mi indichi quante lampadine utilizzo es 1..4 questo lo devo decrementa solo una volta che la lampadina accesa si spegna giusto ? (o ci sono soluzioni piu semplici.) ma come rilevo che la lampadina passa dallo stato acceso allo stato spento ?

A quanto sembra sei molto alle prime armi!

Per accorgerti che una lampadina è accesa o spenta ti basta soltanto mettere il suo contatto aperto all'interno del tuo codice.

A1.2 T1

--||-------------|/|---------------------( A1.2 )-

Come si può notare da questo semplice esempio (anche se così com'è non funzionera mai!), ci sono 2 simboli che si rivolgono allo stesso elemento:

1. --||--, che serve per controllare lo stato di un singolo bit (0, 1)
2. --( )--, che serve ad tenere attivo un singolo bit fino a quando la condizione che sta alla sua sinistra è attiva

quindi se tu vuoi controllare che la tua uscita (A1.2) è attiva ti basta scrivere --|A1.2|--, quando A1.2=1 il tuo contatto cambierà colore o comunque sarai in grado di vedere un'animazione.

Per accendere 4 su 5 lampadine contemporaneamente potresti costruire una logica simile:

L1 L2 L3 L4 Lx1..4

--||-----||-----||----||----( )

L1 L2 L3 L5 Lx1..5

--||-----||-----||----||----( )

L2 L3 L4 L5 Lx2..5

--||-----||-----||----||----( )

L3 L4 L5 L1 Lx3..1

--||-----||-----||----||----( )

L4 L5 L1 L2 Lx4..2

--||-----||-----||----||----( )

L5 L1 L2 L3 Lx5..3

--||-----||-----||----||----( )

Adesso potrai mettere come interblocco sull'attivazione della lampadina che ti serve uno di quelli sopra elencati

T1 Lx2..5 L1

--||-----|/|-------( ) ovvero metti quella condizione nella quale L1 non agisce alla sua attivazione;

continua così anche per le altre facendo bene attenzione a quale interblocco inserire.

T2 Lx3..1 L2

--||-----|/|-------( )

Spero che sia chiaro!

Good Luck, Jake

[Lord]

A quanto sembra sei molto alle prime armi!

Si si, in questo tipo di programmazione sono un novellino, arrivo dal c

Io per contatore intendevo un flag fittizio che incrementavo e decrementavo a seconda delle lampadine usate (mea culpa mi sono spiegato male),

cerco di spiegarmi meglio se io devo gestire non 5 lampadine ma ben 20,30,50 o 100 e posso averne accese solo 5 o 10 alla volta, forse non mi conviene far una combinazione tipo quella mostrata jake, ma cosa mi conviene utilizzar ?

Io avevo pensato di usare un Flag che si incrementa ogni volta che uso una lampadina e quando arriva al valore X= max lampadine accese contemporaneamnete non possa piu accenderne altre finche non si spegne una di queste, tutto cio avrebbe un senso?

o ci sono soluzioni piu semplici ed intuitive

e grazie ancora per l'aiuto che mi state dando

Modificato: 21 febbraio 2008 da Lord

[jake]

Quella del contatore, secondo me, è un'idea valida quando si tratta di numeri cosi grossi di uscite da gestire.

Secondo me per incrementare e decrementare il contatore dovresti usare i fronti di salita e di discesa, altrimenti ad ogni ciclo - dal momento in cui l'uscita è stata attivata - il contatore si incrementa o al contrario, se spenta, si decrementa.

Non sò il tipo di plc che stai utilizzando - ognuno ha la propria istruzione - ma puoi scrivere un codice che va bene per qualsiasi plc:

A B C

--||----|/|----( )

A B

--||----( )

L'esempio scritto sopra fa in modo che C venga attivato soltanto in un ciclo macchina dal momento in cui A è attivo, al ciclo successivo, con l'attivazione di B, C verrà disattivato. (fronte di salita).

La stessa cosa la fai per il cronte di discesa, ma questa volta A è negato, in questo modo, dal momento in cui A viene spento, C rimane attivo per un ciclo macchina e dopo si disattiva.

A B C

--|/|----|/|----( )

A B

--|/|----( )

Good Luck, Jake

[Lord]

Si ottimo spunto, me venuto in mente che siccome il fronte di salita lo creo col timer ( lo dispongo gia) mi chiedevo se riuscivo a sfruttarlo a mio vantaggio ,

mi sembra che in alcuni plc il fronte di salita si rilevi con una [at]davanti all istruzione, (cioe ti esegue istruzione una volta sola dopo il passaggio da 0 a 1 della mia uscita)

quindi avrebbe senso ora il circuto http://i25.tinypic.com/w82rky.jpg, cioe quando la mia uscita si attiva dopo aver premuto il pulsante incremento di uno il mio contatore, quando il timer ha finito cioe quando la mia uscita si è spenta decremento il contatore ?

[jake]

Esatto, ma attenzione che anche per decrementare devi usare un fronte, ma questa volta di discesa, altrimenti continuerai ad decrementare ad ogni ciclo macchina!!!!

Good Luck, Jake

Modificato: 21 febbraio 2008 da jake

[rddiego]

ma attenzione che anche per decrementare devi usare un fronte, ma questa volta di discesa

non è esatto dire che DEVI usare il fronte di discesa:

dipende quando si vuole decrementare il contatore e quindi si sceglie quale bit testare per il fronte e come testarlo.

Nell'esempio postato da jake il fronte:

se fosse positivo farebbe sì che il contatore si azzeri appena scade il timer e quindi insieme allo spegnimento dell'uscita

se fosse negativo farebbe sì che il contatore si azzeri appena il timer si disattiva e quindi il ciclo successivo allo spegnimento dell'uscita

[Lord]

non è esatto dire che DEVI usare il fronte di discesa:

dipende quando si vuole decrementare il contatore e quindi si sceglie quale bit testare per il fronte e come testarlo.

Nell'esempio postato da jake il fronte:

se fosse positivo farebbe sì che il contatore si azzeri appena scade il timer e quindi insieme allo spegnimento dell'uscita

se fosse negativo farebbe sì che il contatore si azzeri appena il timer si disattiva e quindi il ciclo successivo allo spegnimento dell'uscita

la mia intenzione è quella che si decremnti appena la lampadina si spenga, quindi penso che in questo caso si decrementa sul fronte di salita del timer insieme allo spegnimento dell uscita.

[jake]

Quello che intendevo io era questo:

sul fronte di salita dell'attivazione della lampadina, incrementi il contatore;

sul fronte di discesa alla disattivazione della lampadina, decrementi il contatore.

In questo modo quando una lampadina si accende il tuo contatore viene incrementato di una unità, mentre al contrario, quando una lampadina si spegne, il contatore viene decrementato di una unità.

Good Luck, Jake

[rddiego]

perdonatemi, ma ho il dubbio che non è chiara una cosa sui fronti.

i fronti sono rilevati sull'RLC e non sullo stato del bit:

il fronte di salita di un bit testato =1 si attiverà al passaggio del bit da 0 a 1

il fronte di salita di un bit testato =0 si attiverà al passaggio del bit da 1 a 0

il fronte di discesa di un bit testato =1 si attiverà al passaggio del bit da 1 a 0

il fronte di discesa di un bit testato =0 si attiverà al passaggio del bit da 0 a 1

quindi nel tuo caso penso sia più indicato fare un fronte di salita sul bit di timer terminato oppure se vuoi anche sul fronte di salita dell'uscita della lampada =0 oppure ancora sul fronte di discesa dell'uscita della lampada testata =1 (tutti gli esempi sono equivalenti)

sul fronte di discesa alla disattivazione della lampadina

vorrebbe dire che il contatore decrementa non appena si accende la lampada!!

[Lord]

quindi nel tuo caso penso sia più indicato fare un fronte di salita sul bit di timer terminato oppure se vuoi anche sul fronte di salita dell'uscita della lampada =0 oppure ancora sul fronte di discesa dell'uscita della lampada testata =1 (tutti gli esempi sono equivalenti)

in questo caso, il fronte di salita non è quando il TML1 si attiva ultima riga ? http://i25.tinypic.com/w82rky.jpg, e quindi la lampadina si spegne e posso decrementare il mio contatore ?

[jake]

Esatto!!!!

Ho parlato di fronte di salita e fronte di discesa perchè ho fatto l'esempio sul contatto aperto del timer, quindi, per come la vedo io, quando il contatto è a 0 e passa ad 1 ho un fornte di salita, al contrario, quando è a 1 e passa a 0 ho un fronte di discesa

E' vero che poi si può avere il fronte di salita sul contatto negato e che quindi il fronte di salita avviene al passaggio 1..0 e quello di discesa da 0..1, ma io volevo fare in modo che quello che stessi spiegando fosse di facile comprensione per il nostro amico.

Buona giornata a tutti!!!!!

Good Luck, Jake

[Lord]

Se io volessi memorizzare ordine di accensione delle lampadina es

Si accende lampadina es si accende la prima lampadina la 4 poi la 5 poi la 1 poi la 3

4513, ricevo una richiesta di accensione es la 8 e di conseguenza spengo la prima accesa per lasciare il posto alla nuova.

Questo come potrei gestirlo con un puntatore ?

[jake]

Ipotizzando che le tue lampadine siano 16 e che stiano su una word unica (L1, Bit 0 ... L16, Bit15), da un AND a Word con dei valori prestabiliti potresti sapere quali lampadine sono accese; ti faccio l'esempio in Siemens S7 dato che non so il tipo di PLC che tu stai usando:

L WordLampade //Questa è la word che contiene lo stato delle 16 lampade

L W#16#300 //in binario 2#0000.0011.0000.0000

==I //Se sono uguali sai che L1 e L2 sono accese!!!

Per l'ordine di accensione penso dovresti usare una memoria di appoggio dove all'accensione della Lampada la confronti con il contatore, dopodichè copi su quest'area il valore del contatore+1.

Esempio:

Contatore=2 perchè già 2 lampade sono accese (es. L1 e L3)

se L5 viene accesa prendi il contatore lo incrementi e dopo copi il suo valore su un buffer chiamato PosizioneL5, in questo modo puoi sapere in che posizione è stata accesa.

/Good Luck, Jake

[Lord]

Allora se es dovessi gestirne piu di 16 uso una double word es che va da 0 a 31 right?

Forse non ho ben capito

la posizione non la conosco a priori cioe se di accende la lampadina 5 attivo il 5°bit etc se accendo la 2° alzo il secondo

come nell esempio?

0000.0000.0000.0001.0010

Ipotesi io ho una sequenza del genere

W1 =0000.0000.0000.0000.0000 tutte spente

W2 =0000.0000.0000.0000.0010 accendo la 2

W3 =0000.0000.0000.0001.0010 accendo la 5

W4 =0000.0010.0000.0001.0010

W5 =0000.0010.0000.0001.0010

Wx = 0001.0010.0000.0001.0010

W6 =0001.0010.0000.0001.0000 quindi qui accendo la 17° e dovrei spegnere la 2 cioe la prima accesa

W7 =0001.0010.1000.0000.0000 accendo la 12° e spengo la 5 etc etc

Quindi ogni volta mi salvo una word in un buffer che possa contenerla, e poi dovrei confrontarlo con il caso W6 con w1? cioe dovrei far una maschera tra Wx e W1 e scopro la lampadina 2 accesa

[jake]

La word o la double word è 1 sola, questa contiene l'attivazione di tutte le lampadine (max 31 per la DWord) e la confronti con un valore fisso o valori fissi che scegli tu (solo che il codice diventa lunghissimo da scrivere a meno che non usi un puntatore).

Per il puntatore dovresti usare un valore di tipo intero che indica la posizione del bit nella word; per un valore pari a 0 indicherà il primo bit, mentre per un valore pari a 31 indicherà l'ultimo bit della double word. Questo confronto dovrai farlo fare in un ciclo FOR che va chiaramente da 0 a 31 e che ad ogni giro incrementa il valore del puntatore di 1.

Così facendo fai un confronto bit a bit.

Spero di essere stato chiaro.

Good Luck, Jake