Programma Stupido Ma Complicato - ho bisogno di aiuto su un programma

[ken]

Descrizione dell'operazione 

RS (Resetta imposta flip flop) viene impostata se lo stato di segnale all'ingresso S è "1" e lo stato all'ingresso R è "0". Invece, se lo stato di segnale all'ingresso R è "0" e all'ingresso S "1", flip flop viene impostato.

Questo è quello che scrive il manuale. Ecco l'ultimo pezzo di programma dove l'ho usato e provato senza problemi

     U     "E10.7"
      U     "M1.7"
      FP    "M7.0"
      U     "A14.6"
      R     "M7.2"
      U     "E10.7"
      U     "M1.7"
      FP    "M7.1"
      UN    "A14.6"
      S     "M7.2"
      U     "M7.2"
      =     "A14.6"

Magari c'è qualche differenza tra quello scriito sopra e quello scritto prima.

So solo che lo uso, nient'altro.

Come fai a dare la precedenza al Set o al Reset non lo so. So che avevo letto da qualche parte, in qualche manuale o in qualche applicazione quella cosa. Se esistono 2 tipi di flip flop (RS e SR) credo sia proprio per quello.

Nient'altro da dire.

[bigalex]

La prevalenza del SET rispetto al RESET e viceversa è data in AWL dalla posizione fisica dell'istrusione S o dell'istruzione R .

Infatti in caso di risultato logico combinatorio 1 per entrambe le logiche (contemporaneamente) legate a SET o RESET prevale la logica che viene elaborata per ultima .

Quindi se R è prima di S prevale S , dicasi SET PREVALENTE .

Viceversa se S è prima di R prevale R , dicasi RESET PREVALENTE .

In KOP vale la stessa cosa poichè sottostante c'è sempre l'AWL in quanto il KOP è una interpretazione grafica di AWL .

Quanto sopra dovrebbe valere anche per PLC di marche diverse , la prevalenza in ladder è data dal fatto di porre a seconda delle necessità prima l'istruzione SET o RESET in rami separati , in modo tale che l'elaborazione dei rami (e quindi delle relative istruzioni) sia sempre non contemporanea .

Ciao .

bigalex

[felix]

Scusate Vi spice se metto anche la mia soluzione, sono stato un po in trasferta ultimamente e mi sono perso molte discussioni, il mio esempio lo uso normalmente su un centinaio di impianti e gira su CNC FANUC,

RD X0.0 ;LEGGO L'INPUT

AND.NOT R0.2 ;E NON HO FLAG2

WRT R0.1 ;SETTO FLAG1

RD X0.0 ;LEGGO L'INPUT

WRT R0.2 ;SCRIVO FLAG2

RD R0.1 ;LEGGO FLAG1

AND.NOT Y0.0 ;E LA MIA USCITA E' A ZERO

;OPPURE

RD.STK.NOT R0.1 ;RITENUTA USCITA A 1 IL GIRO SUCCESSIVO

AND Y0.0 ;USCITA A 1

OR.STK

WRT Y0.0 ;SETTO L'USCITA

[Claudio Monti]

bigalex+14 Nov 2003, 04:58 PM-->

CITAZIONE(bigalex @ 14 Nov 2003, 04:58 PM)

Questo è il discorso generale, del quale ho già dato risposta...

Quello che stanno discutendo Luca e Bigalex riguarda un blocco funzione apposito (da quello che ho capito) che si chiama RS... poi non so dirti altro in quanto non lo conosco e sono anch'io in attesa di veder come va a finire questa discussione

[bigalex]

Claudio , i blocchi RS e SR sono in KOP e non sono altro che funzioni (esistono anche normate IEC61331-3) che all'interno realizzano la prevalenza si S o R nei modi indicati precedentemente ma con un aspetto compatto tipico delle funzioni .

Occorre ricordare che il processore (booleano) contenuto nella cpu elabora la logica comunque dall'alto verso il basso e pertanto l'istruzione S o R relativa al medesimo bit che viene elaborata per ultima , in caso di contemporaneità del risultato logico combinatorio, assume prevalenza .

Ciao

bigalex

[Luca Bab]

OK ken , questo funzia ( M1.7 pero' la devi togliere o deve essere a 1 )

ma e' un po' diverso dall'altro segmento che avevi postato

infatti controlli l'uscita , non la M del blocchettino RS

per il discorso della prevalenza e' tutto uguale al KOP

se sopra fai il reset e sotto il set ovviamente hai la prevalenza del set

i blocchetti che ti mette a disposizione siemens sono 2 ( non puoi impostare te la prevalenza )

uno e' RS l'altro e' SR con 2 rami uno sotto l'altro invertiti in base a quello che usi , quello basso ovviamente ha la prevalenza

io personalmente non ho mai usato quella istruzione SR o RS , preferisco farmi il SET e il RESET separatamente ( ma e' questione di gusti , a volte )

[ken]

si il blocco scritto poco sopra l'ho copiato da un FC che funziona.

M1.7 sta sempre a 1 (emergenza OK)

Il blocco di prima l'ho scritto così, al volo.

L'ultimo scritto è quello che funziona di certo.

Che no si può impostare la prevalenza è vero, volevo solo dire che a seconda del blocchetto che usi un'ingresso ha la preavlenza sull'altro.

Anch'io uso sempre Set E Reset da soli.

Il Blocchetto lo uso solo per quella cosa

[Luca Bab]

Questo funziona proprio perche' vai a controllare l'uscita , non la M

poiche' il siemens aggiorna le M subito ma le uscite a fine programma ( vedi DARIO che qualche differenza a volte c'e' , come dice correttamente "ifachsoftware" su un plc SAIA non avrebbe funzionato neanche la seconda versione di KEN )

quindi nella seconda versione che hai postato funziona perche' l'uscita la aggiorna il ciclo di scansione dopo

mentre la prima versione che controllavi la M veniva aggiornata subito

Ciao

Luca

[bit]

Rispondo solo al problema iniziale:

Ma con la teoria degli automi a stati finiti non si riesce bene a risolvere problemi come questo piuttosto che a occhio? Io ho provato e ho trovato subito la soluzione, con un solo bit di memoria:

A(n+1) = An x (-I) + Bn x I

B(n+1) = (-An) x (-I) + Bn x I

Dove I è l'ingresso, A è l'uscita e B è il bit interno.

Il sistema non è altro che un automa a quattro stati, quindi due bit devono bastare.

Ciao!

[Dario Valeri]

ciao

in TUTTI i plc le istruzioni di uscita e ingresso vengono aggiornate

a fine ciclo (= un ciclo dopo)mentre le assegnazioni alle memorie interne

e' fatta immediatamente!(in tutti a meno di usare istruzioni particolari)

il fronte di salita si basa proprio su questo.

(siemens , hitachi , omron, allen bradley ,TELEMECANIQUE)

ifacht ,ok per i realtime , se ho capito bene il SAIA usa di default quello che in altri plc sarebbe una istruzione "particolare (l'aggiornamento dei in/out in modo asincrono)

ciao

dario

Modificato: 14 novembre 2003 da Dario Valeri

[Zed]

Proprio così!

Con i PLC Saia-burgess si ha la possibilità di accedere direttamente ai segnali di I/O senza passare attraverso l’immagine del processo, con una notevole riduzione dei tempi di reazione!

Ciao

Zed

[Piero Azzoni]

confermo che i plc reagiscono in maniera assolutamente uguale alle istruzioni standard.
per quelche riguarda il set - reset:
-se eseguito con due istruzioni diverse la priorita' e' sempre all'ultima chiamata
- se esegiuto in un'unica istruzione il blocco stesso la definisce
    esisteranno percio'
       set - reset set priority
       set - reset reset priority

comunque questa riga base con la sua ausiliaria non puo' che funzionare con qualsiasi plc

 |
 |
 |  i.1     m.2     q.1     i.1                    q.1
 |--| |-----|/|-----|/|--|--|/|--|-----------------( )-
 |                       |       |
 |                       |       |
 |                       |  m.2  |
 |                       |--| |--|
 |                       |       |
 |                       |       |
 |  q.1                  |  q.1  |
 |--| |------------------|--|/|--|
 |
 |
 |  i.1                                            m.2
 |--| |--------------------------------------------( )-
 |
 |

Modificato: 14 novembre 2003 da Piero Azzoni

[Piero Azzoni]

per i booleandipendenti :

ld i1 and not m2 and not q1

ld q1 or ld

ld not i1 or m2 or q1 and ld

out q1

ld i1 out m2

del tutto identico al precedente

[JumpMan]

Scritto da KEN:

    U     "E10.7"
     U     "M1.7"
     FP    "M7.0"
     U     "A14.6"
     R     "M7.2"
     U     "E10.7"
     U     "M1.7"
     FP    "M7.1"
     UN    "A14.6"
     S     "M7.2"
     U     "M7.2"
     =     "A14.6"

Scritto da LucaBab:

Questo funziona proprio perche' vai a controllare l'uscita , non la M poiche' il siemens aggiorna le M subito ma le uscite a fine programma ( vedi DARIO che qualche differenza a volte c'e' , come dice correttamente "ifachsoftware" su un plc SAIA non avrebbe funzionato neanche la seconda versione di KEN ) quindi nella seconda versione che hai postato funziona perche' l'uscita la aggiorna il ciclo di scansione dopo mentre la prima versione che controllavi la M veniva aggiornata subito

Forse hai postato frettolosamente, ciò che affermi non è esatto, in quanto si potrebbe tranquillamente sostituire la A14.6 con M14.6 e FUNZIONEREBBE LO STESSO ! Non è che funziona perchè A14.6 va a 1 in ritardo, ma funziona perchè qui...

    ...
     U     "A14.6"
     R     "M7.2"

...e qui...

    ...
     U     "A14.6"
     S     "M7.2"

... si interroga A14.6 (o M14.6) del ciclo precedente Poi in seguito...

    U     "M7.2"
     =     "A14.6"

...si pone A14.6 (o M14.6) = al risultato del set reset.

Non so se mi sono spiegato bene...

(p.s. io non avrei fatto così, funziona ma non è molto leggibile)

Modificato: 15 novembre 2003 da JumpMan

[Luca Bab]

per JUMP

ripeto che il secondo codice di ken funziona perche' interroga l'uscita

se interrogasse la M non funzionerebbe poiche' nella prima parte la Resetterebbe

e nella seconda visto che e' a zero la setterebbe nuovamente ( poiche' si e' aggiornata subito )

mentre con l'uscita si aggiorna solo a fine scansione quindi se a inizio ciclo e' a 0 ( l'uscita )

verra' riconosciuta a 0 in tutti i richiami , anche se nel riachiamo sopra e' stata messa a 1

U "E10.7"

U "M1.7"

FP "M7.0"

U "A14.6" in questo punto

R "M7.2"

U "E10.7"

U "M1.7"

FP "M7.1"

UN "A14.6" e in questo punto

S "M7.2"

U "M7.2"

= "A14.6"

chiaro che se usi una M che non centra niente funziona lo stesso ma Ken usava la M che settava e resettava

non la M14.6 che non c'entra niente ma la M7.2

prova a sostituire nell'esempio sopra la A14.6 con la M7.2 poi dimmi come funzia

Ciao

Luca

[JumpMan]

Caro Luca, io non facevo riferimento al 1° esempio di ken ma al 2° (quello funzionante) e da quello che tu scrivevi (Questo funziona proprio perche' vai a controllare l'uscita , non la M poiche' il siemens aggiorna le M subito ma le uscite a fine programma) si capiva che il funzionamento era dovuto all'architettura del plc che attua le uscite a fine scansione, se intendi veramente questo ti ripeto che non è così in quanto le uscite attuate a fine scansione sono quelle fisiche e non quelle del programma, in un ciclo del programma lo stato di un'uscita (come quello di un merker) può cambiare anche 100 volte, è l'uscita fisica a rimanere "congelata" fino a quando non viene elaborata l'immagine delle uscite.

Esempio:

SET               1
 =     A0.0        1
 UN    A0.0        1
 =     A0.0        0
 =     A0.1        0             <---
 UN    A0.0        0
 =     A0.0        1
 UN    A0.0        1
 =     A0.0        0
 UN    A0.0        0
 =     A0.0        1             <---

In questo esempio si dimostra che all'interno del programma l'uscita A0.0 cambia di stato varie volte mentre l'uscita fisica A0.0 rimane costantemente a 1 (questo non si dimostra, bisogna provarlo) A0.1 l'ho inserito per dimostrare che a0.0 cambia durante l'elaborazione.

Naturalmente quando detto non vale per SAIA, su Saia anche l'uscita fisica "vibrerebbe".

Quindi all'interno del programma non vi è alcuna differenza tra usare uscite o merker, invece a volte la differenza la fa il punto in cui si inserisce una bobina (S/R/=).

Torno quindi a ripetere che il 2° esempio di ken funziona perchè per fare il set-reset si interroga un bit che era stato memorizzato il ciclo precedente.

Infatti funziona anche senza usare uscite:

U "E10.7"

FP "M7.0"

U "M14.6"

R "M7.2"

U "E10.7"

FP "M7.1"

UN "M14.6"

S "M7.2"

U "M7.2"

= "M14.6" <---TOGGLE BIT

[code]

(scusate se ho contribuito ad'appesantire questa megadiscussione)

[max72]

salve forse la risposta e questa?

--| |------|/|-------(S)--|
        |
        |
        |---| |-------(R)--|

cosi dovrebbe funzionare, fammi sapere ciao.

max 72

Modificato: 13 gennaio 2004 da NULL

[Claudio Monti]

Max, mi spiace ma non hai letto bene...

... non si possono usare SET/RESET, era gia' stato proposto

[max72]

scusa claudio ho sbagliato a scrivere comunque non sono riuscito a copiare dal programma l'esempio che volevo fare.

quando arrivo a casa sistemo tutto.

scusami a presto

Modificato: 9 gennaio 2004 da max72

[Rossi]

E' un problema che mi sono posto anch'io diversi anni fa. La mia soluzione comunque richiede l'impiego dei fronti di salita:

__I0.0_____M0.0_M0.1

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

__I0.0_____M0.1__M0.0

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

__M0.0___|

---||---------'

In questo modo il marker M0.0 assume valori opposti ad ogni pressione di un pulsante collegato in I0.0...

Spero di essere stato di aiuto...

Modificato: 13 gennaio 2004 da Rossi

[sdrule]

--IiI---------I/m2/I---------------(m1)-

                 
--IiI-----+----Im1I--+------------(m2)-
           |          |
           |          |
           -----Im2I---

--Im1I---------Im5I---------------(m3)-

            
--Im1I---------I/m5/I-------------(m4)-


--Im3I----+-----I/m4/I----+-------(O)-
           I               I
           I               I------(m5)-
--IOI------

Scusate ma non riesco a scriverlo direttamente sulla risposta del post perchè mi vengono cancellati gli spazi bianchi a sinistra. posterò un' immagine.

Legenda (data la mia scarsa attitudine al disegno)

--Im1I-- contatto

--I/m1/I-- contatto negato

Dovrebbe viaggiare bene.

Modificato: 14 gennaio 2004 da Gabriele Riva

[sdrule]

Vi prego di spostare il msg nel trend in PLC&Didattica - Programma stupido ma complicato

Titolo: soluzione

Finalmente ho fatto l'immagine:

Modificato: 14 gennaio 2004 da sdrule

[Rango]

La mia soluzione al problema:

Per comodità è scritta in AWL.

M100.0 = pulsante

M100.1 = Uscita

// INIZIO

U M 100.0

UN M 0.1

= M 0.0

//--

U M 100.0

U(

O M 0.0

O M 0.1

)

= M 0.1

//--

U M 0.0

UN M 100.1

O

UN M 0.0

U M 100.1

= M 100.1

// FINE

Se invece avessi potuto usare tutti i comandi S7:

U M100.0

FP M0.0

X M100.1

= M100.1

Scusa il ritardo ma ho visto la discussione solo oggi!!!

[fangarolo]

IN LADDER.

ciao Dario

---| |------|-------|/|--------------(%Q2.1)

%I1.0 | %M1

|

---| |------|

%Q2.1

---|/|------|-------| |---|----------(%M0)

%I1.0 | %Q2.1 |

| |

---| |------|---| |--------|

%M0 %M1

---| |------|-------| |--------------(%M1)

%I1.0 %M0

Modificato: 9 marzo 2004 da fangarolo

[ken]

U E 0.0 //start

UN M 1.0

= M 1.1

U E 0.0 //start

= M 1.0

O(

U M1.1

UN M1.7

)

O(

UN M1.1

U M1.7

)

= M1.7

Dovrebbe funzionare

Mi è venuto così.

Senza set e reset e FP