manipolatore con SFC

[lorrendo]

Vorrei gestire un manipolatore scrivendo un programma in ladder sviluppato a partire da un diagramma SFC.

 

 Il manipolatore è un robot didattico con quattro gradi di libertà (rotazione asse z, avanzamento, discesa e pinza) azionato da motori DC con encoder e finecorsa. Il movimento è quello di carico/scarico:

• partendo da una posizione home
• ruota, scende e prende un pezzo
• lo solleva, ruota ancora poi scende e scarica il pezzo
• torna in home

 

L'implementazione può essere fatta in tanti modi diversi ma mi piacerebbe partire da un diagramma SFC  - con gli stati e le azioni associate - da tradurre in ladder con la tecnica batch.

 

La soluzione con SFC - posto che sia indicata per questo tipo di automatismi - pone qualche problema:

• come gestire movimenti concorrenti (ad esempio rotazione e avanzamento) che terminano in momenti diversi?
• come gestisco l'homing (ritorno alla posizione iniziale)?

 

Nel primo caso posso usare il parallelismo - più stati concorrenti che gestiscono movimenti diversi - o inserire delle condizioni relative al posizionamento (encoder e finecorsa) nella gestione del motore. Per l'homing questa seconda soluzione sembra più indicata.

 

Mi date un consiglio?

 

Grazie!

 

 

[Roberto Gioachin]

Hai già spiegato tu come si deve fare.

SFC è secondo me il metodo più adatto per fare quello che chiedi, nei miei programmi faccio largo uso di SFC per movimenti simili compreso le operazioni di homing.

Il tuo approccio però mi sembra quello di realizzare una sequenza SFC su carta e trasformarla poi in un programma completamente ladder, questo modo di operare ti fa perdere il vantaggio della visibilità delle sequenze direttamente sul programma, ti devi quindi riferire sempre alla rappresentazione che preventivamente hai realizzato su carta.

Se vuoi usare SFC allora scrivi direttamente il tuo programma in SFC, utilizzando il ladder per inserire azioni e transizioni.

 

Come gestire i movimenti concorrenti:  con l'apertura di processi paralleli, risulta estremamente semplice ed affidabile. Se ben fatto risulta molto difficile perderne il controllo.

come gestisco l'homing (ritorno alla posizione iniziale)? :  realizzando delle apposite sequenze che vengono richiamate ad o ogni operazione nel momento in cui un asse ha la necessità di essere azzerato.

 

Un consiglio: Molto spesso si considera poco utile questo linguaggio (o metodo) in quanto si pensa che tutto il programma debba essere eseguito in SFC.

Nulla di più sbagliato. Se prendiamo il tuo caso, dove devi muovere 4 assi, non devi delegare alla programmazione SFC tutto il lavoro di controllo degli assi, ma da questo devono uscire solo poche informazioni come "Quota destinazione" "Velocità" "Run", tutto il resto di lavoro lo deve fare un PB adeguato allo scopo e predisposto per accettare questi comandi.

Devi considerare SFC come un direttore d'orchestra, lui dirige solamente, ma il lavoro viene eseguito da altri.

 

Roberto

 

[lorrendo]

2 ore fa, Roberto Gioachin scrisse:

Il tuo approccio però mi sembra quello di realizzare una sequenza SFC su carta e trasformarla poi in un programma completamente ladder, questo modo di operare ti fa perdere il vantaggio della visibilità delle sequenze direttamente sul programma, ti devi quindi riferire sempre alla rappresentazione che preventivamente hai realizzato su carta.

 

Il problema è che uso dei PLC Siemens S7-1200 che non sono programmabili direttamente nel linguaggio SFC. Di solito scrivo su carta il diagramma SFC partendo da un diagramma temporale o una descrizione dell'automatismo poi traduco in ladder usando tre sottoprogrammi:

• uno che imposta lo stato iniziale
• uno che gestisce l'evoluzione del sistema da uno stato all'altro
• uno che attiva le uscite in base allo stato

La sequenza la gestisco con segmenti molto simili del tipo:

 

|------| |------| |------+------(S)
      stato   condiz.    |     stato 
     attuale             |     succ.
                         |
                         +------(R)
                               stato
                              attuale

Mentre le uscite le gestisco con una solo bobina per uscita con in OR tutti gli stati in cui è attiva, tipo:

|------| |-----+------------( )
     stato 1   |          motore 1 
               |        
|------| |-----+
     stato 4 

Questa soluzione mi piace perché è robusta (un solo stato attivo, ogni uscita è comandata in un solo punto) però diventa macchinosa quando la stessa uscita è comandata in più passi ma con condizioni diverse (ad esempio fino a finecorsa, fino alla posizione 1, fino alla posizione 2) e quando si pilotano più uscite contemporaneamente ma in maniera indipendente (ad esempio assi x e z che partono insieme ma si arrestano in base alla posizione).

 

In pratica non so se gestire l'arresto dei motori inserendo delle condizioni nel sottoprogramma delle uscite, tipo:

|------| |-------|/|------+------------( )
     stato 1  finecorsa   |          motore 1 
                          |        
|------| |-------| |------+
     stato 4   raggiunta
               posiz. 1

che funziona ma snatura un po' l'implementazione SFC (le condizioni andrebbero nel sottoprogramma che gestisce l'evoluzione tra uno stato e un altro) o se aggiungere molti stati e gestire l'arresto con parallelismo, stati concorrenti, stati di attesa e in generale complicando la sequenza.

 

Per l'homing il problema è lo stesso ma complicato dal fatto che devo muovere tre assi e la pinza in maniera indipendente: un solo stato e tutti i motori attivi fino al finecorsa per i quattro movimenti o una soluzione più corretta ma più complicata con un parallelismo che gestisca separatamente i movimenti?

 

3 ore fa, Roberto Gioachin scrisse:

come gestisco l'homing (ritorno alla posizione iniziale)? :  realizzando delle apposite sequenze che vengono richiamate ad o ogni operazione nel momento in cui un asse ha la necessità di essere azzerato.

Qui cosa si intende per "sequenze"? Una successione di stati in un parallelismo o un blocco di istruzioni?

 

3 ore fa, Roberto Gioachin scrisse:

Se prendiamo il tuo caso, dove devi muovere 4 assi, non devi delegare alla programmazione SFC tutto il lavoro di controllo degli assi, ma da questo devono uscire solo poche informazioni come "Quota destinazione" "Velocità" "Run", tutto il resto di lavoro lo deve fare un PB adeguato allo scopo e predisposto per accettare questi comandi.

Dal momento che non posso usare direttamente l'SFC come posso realizzare la stessa cosa in ladder?

 

Grazie per i consigli!

[Roberto Gioachin]

4 ore fa, lorrendo scrisse:

Il problema è che uso dei PLC Siemens S7-1200 che non sono programmabili direttamente nel linguaggio SFC

Purtroppo uno dei pochi a non disporre di SFC con rappresentazione grafica.

Quindi quello che hai proposto tu va più che bene.

 

4 ore fa, lorrendo scrisse:

Questa soluzione mi piace perché è robusta (un solo stato attivo, ogni uscita è comandata in un solo punto) però diventa macchinosa quando la stessa uscita è comandata in più passi ma con condizioni diverse (ad esempio fino a finecorsa, fino alla posizione 1, fino alla posizione 2) e quando si pilotano più uscite contemporaneamente ma in maniera indipendente (ad esempio assi x e z che partono insieme ma si arrestano in base alla posizione).

Non trovo che sia un problema comandare più motori contemporaneamente, la soluzione è quella di aprire più processi paralleli, ognuno termina con il proprio sensore o la propria informazione di fine operazione, ogni passo che termina con la propria transizione apre un passo vuoto il quale attende il termine degli altri passi, quando tutti hanno terminato il proprio percorso vengono chiusi contemporaneamente tutti i passi.

 

4 ore fa, lorrendo scrisse:

Qui cosa si intende per "sequenze"? Una successione di stati in un parallelismo o un blocco di istruzioni?

SFC serve per realizzare sequenze, quindi intendo una serie di passi e transizioni coerenti con il funzionamento che deve avere la macchina.

 

4 ore fa, lorrendo scrisse:

Dal momento che non posso usare direttamente l'SFC come posso realizzare la stessa cosa in ladder?

Esattamente nello stesso modo che si fa con SFC disponibile sul PLC, strutturando il programma in modo da avere un PB (Blocco Programma) per realizzare passi e transizioni e simulare un SFC, e altri PB uno per ogni motore, sui quali metterai tutto il funzionamento manuale e automatico, metterai comandi e finecorsa, protezioni quali termici o allarmi vari. Questi PB verranno poi pilotati dalla sequenza realizzata in SFC.