L'SFC (Sequential Function Chart) è un linguaggio di programmazione grafico per PLC¹⁾ derivato dal Grafcet²⁾, un formalismo utilizzato per descrivere processi sequenziali nella progettazione e analisi di automatismi.

L'SFC/Grafcet - useremo i due termini come sinonimi - non è solo un linguaggio di programmazione ma anche un modo per rappresentare il funzionamento di un sistema automatico mettendone in evidenza il comportamento sequenziale. Molti automatismi infatti si prestano ad essere scomposti in una serie di fasi (passi, stati, ecc.) che si susseguono secondo una determinata logica. Con i diagrammi SFC è possibile descrivere l'evoluzione del sistema che, al verificarsi di determinati eventi, passa da una fase a quella successiva attivando le uscite corrispondenti.

La progettazione di un automatismo tramite SFC è detta programmazione per passi ed è particolarmente efficace perché, consentendo l'attivazione di un passo solo per volta, garantisce che il PLC esegua solo le azioni associate al passo attivo evitando conflitti e anomalie che si possono verificare utilizzando altre tecniche. Inoltre con la programmazione per passi è sempre possibile sapere in quale stato si trova il sistema e seguire l'evoluzione dell'automatismo.

I vantaggi principali dell'SFC sono:

• espressività e leggibilità: è un linguaggio grafico quindi sintetico e non ambiguo
• portabilità: progettazione e implementazione sono slegate tra loro e possono essere realizzate da persone diverse, in tempi diversi, con linguaggi diversi su PLC di produttori diversi
• manutenibilità: è possibile modificare i passi singolarmente senza alterare il resto dell'automatismo

Con alcuni modelli di PLC si puà usare l'SFC direttamente nell'ambiente di programmazione³⁾ ma con le CPU S7-1200 questo non è possibile ed occorre tradurre l'SFC in ladder con la tecnica batch.

Gli elementi di un diagramma SFC sono:

• i quadrati, che rappresentano i passi (fasi, stati, tappe) del sistema; quello con due cornici è il passo iniziale
• il pallino nero - detto token o marcatore - che individua il passo attivo (non lo disegneremo)
• i rettangoli, collegati con una linea ai quadrati, che rappresentano le azioni associate ad un passo
• le linee, che indicano la successione tra un passo e quello successivo
• i trattini, che rappresentano le transizioni che abilitano il passaggio da un passo a quello successivo

L'evoluzione del sistema avviene in questo modo:

• in ogni momento c'è un solo passo attivo⁴⁾ e l'evoluzione avviene secondo il percorso delle linee (dall'alto verso il basso, la freccia si mette solo nel caso in cui si vada dal basso all'alto)
• il sistema parte sempre da un passo iniziale
• quando un passo è attivo vengono abilitate
  • le azioni associate al passo
  • le transizioni a valle (immediatamente sotto il passo)
• ad ogni transizione è associata una condizione che, se verificata, attiva la transizione permettendo il passaggio al passo successivo

Un esempio di SFC è riportato nella figura seguente:

Qualche osservazione:

• passi e transizioni sono identificati con una sigla (ad esempio P0 per il passo iniziale, T2 per la seconda transizione)
• un passo può avere più azioni associate (eseguite contemporaneamente) o nessuna; le azioni possono avere un qualificatore che indichi particolare caratteristiche (ad esempio azione impulsiva, intermittente, ritardata)
• le condizioni che attivano le transizioni sono espressioni logico-combinatorie (si esprimono utilizzando operatori logici AND, OR, NOT) che possono essere vere o false (0 o 1)
• l'evoluzione del sistema avviene disabilitando tutti i passi a monte e attivando tutti quelli a valle⁵⁾
• eventuali situazioni di emergenza (pulsante STOP, protezioni termiche, ecc.) che alterano la normale evoluzione dell'automatismo, si indicano mettendo una freccia a sinistra dello stato in cui deve essere posto il sistema specificando le condizioni che abilitano questa transizione di emergenza (abilitata e quindi possibile in qualunque passo si trovi l'automatismo)
• il Grafcet, come gli altri linguaggi di programmazione, dispone di strutture di controllo per:
  • la realizzazione di cicli
  • la scelte tra più opzioni (scelta e convergenza); in questo caso si ha una diramazione tra transizioni con condizioni mutuamente esclusive
  • l'esecuzione simultanea di più processi (parallelismo e sincronizzazione); in questo caso si usano i nodi diramatori e i nodi di concorrenza, indicati con due linee orizzontali parallele

In figura un esempi di scelta/convergenza e di parallelismo/sincronizzazione:

I qualificatori possono essere usati per caratterizzare un'azione. I più comuni sono:

• N (non stored), l'uscita è attiva finché il passo è attivo (si può omettere)
• D (time delayed), l'azione è ritardata di un tempo prestabilito rispetto all'attivazione del passo
• L (time limited), l'azione si interrompe dopo un tempo prestabilito
• P (pulse), l'azione si attiva una sola volta in modo impulsivo quando il passo è attivo
• S (set/stored), l'uscita resta attiva anche quando il passo si disattiva
• R (reset), l'uscita viene resettata quando il passo è attivo
• C (condizionato), l'uscita è attiva ma condizionata da altri segnali (ad. esempio finecorsa)

L'uso dei qualificatori semplifica la scrittura del diagramma SFC (ad esempio sostituendo la funzione svolta dai temporizzatori).

La tecnica batch (a lotti) serve ad implementare un automatismo descritto da un diagramma SFC nel linguaggio KOP/ladder. E' buona pratica ricorrere alla programmazione strutturata, creando diverse funzioni/sottoprogrammi per gestire:

• inizializzazione del sistema, dove si imposta il passo iniziale
• evoluzione dell'automatismo da un passo all'altro (motore del Grafcet, ciclo macchina, sequenza stati)
• attivazione delle uscite in base al passo attivo
• emergenze, anomalie e allarmi

La tecnica batch prevede di associare ad ogni passo della sequenza un merker di passo e gestire l'evoluzione del sistema settando il merker successivo e resettando quello attuale ad ogni transizione. In questo modo in ogni momento sarà attivo un solo merker e lo stato del sistema sarà sempre definito. L'evoluzione del sistema e l'attivazione delle uscite vengono gestiti separatamente; le uscite vengono attivate solo in base al merker di passo attivo in un determinato momento. Il programma, così strutturato, è più affidabile, più semplice da gestire e da modificare. Anche il debugging è facilitato perché quando il programma si blocca il passo che contiene l'errore viene messo in evidenza.

Per l'inizializzazione dell'automatismo si può usare il merker di sistema First Scan, attivo solo nel primo ciclo di scansione quando la CPU passa da STOP a RUN, o un blocco organizzativo di avvio. Nel primo caso basterà scrivere una funzione che setti il merker corrispondente al passo iniziale, resettando tutti gli altri merker di passo. Di solito questa funzione si occupa anche di resettare contatori e temporizzatori e mettere la macchina in una condizione nota (di riposo o di sicurezza).

L'evoluzione del sistema si realizza in maniera molto semplice:

• ogni merker di passo ha il suo segmento
• quando un merker di passo è attivo se risulta verifica la condizione che attiva le transizioni si setta il merker successivo e si resetta quello attuale

L'esempio seguente mostra una transizione tra due stati:

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

Il segmento è così interpretabile:

• se un passo è attivo (passo attuale) la transizione è abilitata
• se la condizione che attiva la transizione è verificata
• si resetta il passo attuale e si setta quello successivo

L'attivazione delle uscite si realizza scrivendo un solo segmento per uscita dove:

• le uscite vanno attivate con delle bobine semplici
• le uscite si attivano mettendo in OR (parallelo) tanti contatti comandati dai merker di passo che prevedono l'attivazione dell'uscita
• timer e contatori vengono trattati come uscite

Questa soluzione comanda ogni uscita in un solo punto del programma e mette in evidenzi gli stati che ne prevedono l'attivazione.

Nel funzionamento di un automatismo bisogna considerare come gestire eventuali emergenze o anomalie come:

• tempo di ciclo massimo superato
• finecorsa avanti e indietro attivi contemporaneamente o non attivi quando il movimento dovrebbe essere terminato
• pressione del pulsante emergenza
• rimozione di protezioni di sicurezza, ecc.

In questo caso si prevederanno una serie di misure quali l'arresto della macchina (o il riposizionamento in uno stato di riposo/sicurezza) e la segnalazione dell'errore/anomalia/guasto. Nell'SFC si indica con una freccia (o un trattino) a sinistra il passo che deve essere abilitato in caso di emergenza. Questo segno corrisponde ad una transizione che è sempre abilitata qualunque sia il passo attivo in quel momento. Per implementare questo tipo di logica si può scrivere una funzione che controlla le varie anomalie ad ogni ciclo e in caso di guasto setti il merker di passo in cui portare il sistema in caso di guasto ed eventualmente usare usa un merker di abilitazione posto in serie a tutte le uscite che si resetta in caso di emergenza.

Per un esempio concreto di un automatismo complesso realizzato con SFC e la relativa implementazione in ladder si veda la pagina sul manipolatore.

La soluzione del problema del cancello automatico con il Grafcet è riportata sotto.

Traducendo il diagramma SFC nel linguaggio ladder con la tecnica batch si realizza un programma come questo:

che contiene una funzione che imposta il passo iniziale:

una che gestire la successione tra i passi dell'automatismo:

e una che attiva le uscite:

Torna all'indice.