Shift

[cliche1995]

salve vorrei chiedervi un aiuto (non solo per il 300 ma anche per il 200);

riuscireste a mostrarmi o spiegarmi in maniera dettagliata un esempio di uno shift register che:

quando rileva un fronte di ingresso da un sensore, alla fine della linea mi deve scartare il pezzo che mi ha dato il fronte. (per esempio un pezzo rilevato difettoso dal sensore, alla fine della linea che magari contiene 15 posizioni, me lo scarta) vi ringrazio e scusate se non sono stato molto chiaro.

[JumpMan]

Boh? mi invento qualcosa...

Oggetti che passano su un nastro, fotocellula che rileva un difetto, espulsore posto più avanti

32 bit di una doubleword: 00000000000000000000000000000000 memorizzano lo stato ok(0), difettoso(1) di altrettanti oggetti.

La fotocellula attiva il primo bit della doubleword se vede passare un oggetto difettoso:

10000000000000000000000000000000

Il nastro avanza di uno step, e il programma fa avanzare lo shift:

01000000000000000000000000000000

Il nastro avanza di uno step, e il programma fa avanzare lo shift:

00100000000000000000000000000000

.....

.....

.....

Quando il nastro è avanzato di 32 step l'espulsore (comandato dal 32° bit) espelle l'oggetto difettoso:

00000000000000000000000000000001

nel tuo caso l'espulsore è comandato dal 15° bit

Modificato: 19 aprile 2014 da JumpMan

[cliche1995]

Ma come fai a fargli fare lo shirt quando il nastro prosegue?

[drugo66]

Devi avere due "sensori"; il primo serve a caricare il dato sullo shift e devi farlo sempre quando il sistema non sta "shiftando", quindi con il secondo sensore attivo (o disattivo, a seconda della logica che scegli, ma comunque sempre nello stato che indica lo shift a riposo).

Con il secondo "shifti" i dati, utilizzando sempre un fronte.

Infine li utilizzi, sempre con lo shift fermo, dove più ti servono.

Con un nastro è un pò più delicato: i pezzi non stanno fermi e non basta un semplice sensore; l'ho fatto, ma con una aspirazione sul nastro e un encoder che mi restituiva la posizione dei pezzi sul nastro.

Se è solo un esercizio, è più semplice che cominci con una tavola con N posizioni; nella prima carichi il pezzo (in maniera automatica o a mano, ma comunque scriverai nello shift che il pezzo è presente), le altre lavorano o collaudano i pezzi (se collaudano devi scrivere nello shift l'esito del collaudo), l'ultima scarica i pezzi dalla tavola; quando parte la tavola, ecco che devi shiftare i tuoi dati, quanti essi siano.

Puoi utilizzare le funzioni di shift del PLC con dati semplici o, se sono dati complessi, creare un UDT (=tipo di dati utente) e scrivere tu una funzione di shift.

[cliche1995]

grazie mille drugo, forse per me che sono un principiante è un po difficile da fare!

[ken]

quello che devi fare si chiama FIFO, first in First out

praticamente devi eseguire due operazioni:

scrittura FIFO con il sensore di ingresso e assegnerai ad un byte o word un codice esempio 1 buono, 2 difettoso 0 niente. ad ogni scrittura incrementi un puntatore per inserire il nuovo pezzo subito dopo quello già scritto

lettura FIFO che leggerà il codice e agirà di conseguenza. eseguirà lo shift in avanti del registro e decrementerà il puntatore.

sembra complicato ma con un poco di ragionamento lo si fa.

Modificato: 20 aprile 2014 da ken

[drugo66]

Allora torniamo alla tua richiesta (si tratta di studio, vero ?):

1 - Definisci la tua variabile di shift, che so DB1.DBW0; quando il bit interessato è 1 il pezzo è scarto.

2 - Carichi il primo dato dello shift allo scatenarsi dello scarto e con il tuo "mezzo" dello shift fermo e a riposo, quindi U FINECOLL U SCARTO U HOME SET DB1.DBX0.0

3 - A fine collaudo fai partire il tuo "mezzo" dello shift (tavola o quello che vuoi): U FINECOLL U HOME SET A0.0

4 - Verifichi che sia partito e shifti di un bit: U A0.0 UN HOME SHIFT DB1.DBW0 (qui dovresti metterci la rilevazione di un fronte di salita prima dell'istruzione di shift)

5 - Quando raggiunge di nuovo HOME, lo fermi: U A0.0 U FERMO RES A0.0

6 - Adesso devi solo usare lo shift, quindi se interessa il secondo bit (il gruppo di scarico è due pezzi in là): U HOME U DB1.DBX0.2 <fai qualcosa>

L'ho fatta molto semplice, ma il concetto è quello: devi solo tradurre il linguaggio che mi sono appena inventato ( -al momento non mi ricordo un acca dell'AWL del 300) in ladder o AWL Siemens, inserire i tuoi ingressi e uscite, aggiungere magari un po' di sicurezza (che male non fa mai) ed il gioco è fatto.

U=Contatto NO in serie - SET=set del bit - RES=reset del bit - SHIFT = istruzione di shift di un bit

Tieni conto anche che Siemens inverte i byte di una word o dword che sia ...

Buon divertimento

Modificato: 20 aprile 2014 da drugo66

[cliche1995]

io vi ringrazio molto ma faccio veramente fatica a capire come metterlo in pratica caspita

[JumpMan]

Se fai fatica ad associare lo shift al movimento del nastro prova ad immaginare a uno spintore meccanico fatto con un cilindro pneumatico il cilindro spinge avanti di uno step i pezzi su una corsia, con il fronte del finecorsa cilindro avanti fai avanzare lo shift, quando il cilindro arretra viene inserito un nuovo pezzo all'inizio della corsia, il pezzo viene esaminato da un apposito dispositivo, se il pezzo é scarto viene imp8stato il primo bit della dword, poi il ciclo si ripete, spintorr spinge e shifti la dword ecc ecc.

Questo è lo shift piu semplice, lo shift a bit, poi si può fare anche lo shift di byte o word, io una volta ho fatto anche lo shift di una intera struttura con più dati in un array di struct, il principio è lo stessok è solo la quantità di dati che è diversa, comunque per memorizzare pezzo buono/scarto bastabun bit.

[cliche1995]

ma uso l'operazione di SET per settare il bit, e shiftando si sposta di una posizione giusto?

[drugo66]

Si, è proprio così: anche perchè, se non setti il bit, shifti una serie di bit a zero e non vedi nulla.

Secondo me, se hai la possibilità di avere lo Step 7 con il simulatore, fai prima a simularlo: in un attimo capisci tutto.

[cliche1995]

Ciao e scusa per il ritardo alla risposta. cosi potrebbe andare bene?

[drugo66]

1 - Perchè usi due diverse word ? Lo shift è uno solo, quindi carichi 1 in MW0 e shifti MW0

2 - L'istruzione di shift dovrebbe essere SHR_W MW0, 1, MW0 dove 1 è il numero di bit da shiftare (vuoi shiftare più di un bit ? credo di no ...)

3 - Manca la rilevazione del fronte di salita sullo shift

4 - Non finirò mai di dirlo: usate simboli e commenti, altrimenti, dopo aver fatto altri 2 lavori, non capite neanche voi cosa avete fatto

Se hai il simulatore, usa i merker (altri, non quelli già usati) al posto di ingressi e uscite: carichi tutto nel simulatore, lo avvii, poi forzi i merker e vedi come funziona.

Buon divertimento

[cliche1995]

ah io ho usato un'altra word nella quale carico 1, cioè i bit da shiftare, perchè come ingresso 2 non puoi mettere direttamente 1.

E per il fronte, sisi lo so che ci va ma me lo sono ricordato quando ormai avevo postato la foto.

[drugo66]

Come non si può ?!? Devi leggere meglio i manuali:

1, per una word diventa W#16#1

Io pensavo che volevi caricare il dato nello shift ...

Vedi che i commenti servono, così almeno si capisce qualcosa ...

Infine, la domanda ora sorge spontanea: usando SHIFT RIGHT dove finisce il bit che carichi ?

Modificato: 22 aprile 2014 da drugo66

[cliche1995]

ah ecco perchè, io inserivo direttamente l'1, non w#16#1 grazie! bella domanda non saprei risponderti! comunque quello che non ho capito è come fa la db9 a fare lo shift! scusa ma sono duro di comprendonio ahahah

[drugo66]

DB9 ? e chi ha usato DB9 ?

Poi la DB9 non "fa lo shift", semmai è l'istruzione che effettua lo shift, o no ?

Questo è un byte: 00000000

Carico il primo bit e diventa: 00000001

Effettuo shift left 1 bit e diventa: 00000010

Effettua shift right 1 bit e diventa: 00000001

Se non hai capito così, non so proprio come altro spiegartelo ...

[cliche1995]

sisi ho capito ma tu come ingresso gli hai messo DB9.DBX0.2 quello non ho capito!

se fai lo shift a destra non avevo letto bene la domanda, ma lo so che se shifti a sinistra si sposta di 1 a sinistra e destra viceversa!

[drugo66]

2 - Carichi il primo dato dello shift allo scatenarsi dello scarto e con il tuo "mezzo" dello shift fermo e a riposo, quindi U FINECOLL U SCARTO U HOME SET DB1.DBX0.0

Qui avevo scritto DB1.DBX0.0.

Nella foto c'è solo l'istruzione di shift, comandata dal terzo passo della tavola (il ciclo della tavola l'ho scritto a passi), che è DB9.DBX0.2: in questo passo sono con la tavola in rotazione e non a riposo; non sto caricando il dato nello shift.

SONO e DEVONO essere 2 operazioni diverse: il caricamento dello shift lo faccio quando la stazione di carico mi mette il pezzo nella prima posizione della tavola e, ovviamente come ti ho già scritto, se devo caricare il pezzo, la tavola non può ruotare.

Tra l'altro, se leggi il simbolo di DB9.DBX0.2 (che io ho inserito), il tutto è anche abbastanza comprensibile ...

Modificato: 22 aprile 2014 da drugo66

[luca_82]

Scusate se mi intrometto ma **********

Ciao e grazie a tutti quelli che perderanno parte nel loro tempo per schiarirmi un po' le idee!!

*********** N.d.M.

Accodarsi ad una discussione, anche se l'argomento è il medesimo, crea confusione nelle risposte. Per questa ragione il regolamento lo vieta.

Apri una tua discussione apposita sull'argomento di tuo interesse.

Modificato: 27 dicembre 2014 da Livio Orsini

[luca_82]

Ok scusami, non vado spesso nel forum e non avevo preso atto di questo aspetto del regolamento.... :worthy: