Cenni di ladder: contatti, bobine e autoritenuta

Il ladder — letteralmente scala — è il linguaggio con cui si programmano i PLC, i calcolatori che comandano gli impianti. Non è nato come linguaggio: è il disegno degli schemi a relè, quelli fatti di bobine e contatti veri, sopravvissuto al passaggio all’elettronica perché chi cablava i quadri lo sapeva già leggere.

Il risultato è che una funzione booleana, in ladder, si disegna invece di scriverla.

Come si legge

Due linee verticali, i montanti, e in mezzo i rami orizzontali, uno sotto l’altro come i pioli di una scala. Si immagina una corrente che scorre da sinistra a destra: se arriva in fondo, la bobina di quel ramo eccita e la sua uscita va a 1.

Due rami ladder: nel primo un contatto normalmente aperto e uno normalmente chiuso in serie comandano una bobina, nel secondo due contatti in parallelo

Tre soli segni, e la traduzione è meccanica:

segno	nome	vale 1 quando	in booleana
$\dashv\ \vdash$	contatto NA (normalmente aperto)	il segnale è 1	$A$
$\dashv\!/\!\vdash$	contatto NC (normalmente chiuso)	il segnale è 0	$\overline{A}$
$-(\ )-$	bobina	— è l’uscita del ramo	$Y =\ \dots$

E le due topologie:

\underbrace{\text{contatti in serie}}_{\text{prodotto: } A \cdot B} \qquad\qquad \underbrace{\text{contatti in parallelo}}_{\text{somma: } C + D}

Un ramo è quindi un’espressione booleana in somma di prodotti, disegnata: i rami paralleli sono gli addendi, i contatti in serie dentro ciascun ramo sono i fattori.

Più vie in parallelo dentro lo stesso ramo, convergenti sulla stessa bobina, sono in OR fra loro: basta che una sola porti corrente perché l’uscita vada a 1. È il modo naturale di disegnare una somma di prodotti quando i termini sono tanti — un termine per via.

La scansione ciclica

Il PLC non “è” il circuito: lo simula, in ciclo continuo. Ogni giro fa tre cose:

legge tutti gli ingressi e ne congela una copia;
esegue i rami dall’alto verso il basso, uno alla volta;
scrive le uscite.

Poi ricomincia. Un giro dura tipicamente pochi millisecondi, e questo basta a rendere l’impianto istantaneo rispetto a una pompa o a un nastro.

Due conseguenze della scansione che nel disegno non si vedono.

L’ordine dei rami conta. Se un ramo usa come contatto un’uscita calcolata da un ramo precedente, legge il valore appena aggiornato; se il ramo che la calcola sta più in basso, legge quello del giro prima. Stessi rami, ordine diverso, comportamento diverso.

La stessa bobina non si scrive due volte. Due rami che pilotano la stessa uscita in punti diversi del programma non si combinano: vince l’ultimo eseguito, e il primo diventa codice morto. Se una bobina va comandata da più condizioni, le condizioni vanno messe in parallelo nello stesso ramo.

L’autoritenuta

Torniamo al serbatoio, che nessuna rete combinatoria sapeva risolvere. In ladder la soluzione è un ramo solo, con due vie in parallelo che convergono sulla bobina della pompa — la forma che il blocco sulla scansione impone: più condizioni per la stessa uscita stanno in parallelo nello stesso ramo, non in rami separati.

Schema ladder del serbatoio: un ramo solo con due vie in parallelo — la prima con i contatti NC di A e B, la seconda che rilegge la pompa insieme ad A e al contatto NC di B — convergenti sulla bobina della pompa

Prima via — $\overline{A} \cdot \overline{B}$ : se nessuno dei due sensori è immerso il serbatoio è vuoto, e la pompa parte.

Seconda via — $P \cdot A \cdot \overline{B}$ : se la pompa sta già girando e il liquido è arrivato a metà ma non ancora in cima, si continua.

Il contatto $P$ della seconda via non è un sensore: è l’uscita che rientra come ingresso. Si chiama autoritenuta, ed è la memoria di cui la lezione precedente aveva dimostrato la necessità.

P = \underbrace{\overline{A}\cdot\overline{B}}_{\text{parti}} \;+\; \underbrace{P\cdot A\cdot\overline{B}}_{\text{continua}}

Che cosa dice davvero questa rete

L’espressione si semplifica, e semplificandola dice una cosa più chiara di com’era scritta. Si raccoglie $\overline{B}$ :

P = \overline{B}\,\bigl(\overline{A} + P\cdot A\bigr)

Il termine fra parentesi si sistema con la distributiva della somma rispetto al prodotto:

\overline{A} + P\cdot A = (\overline{A} + P)\cdot(\overline{A} + A) = (\overline{A} + P)\cdot 1 = \overline{A} + P

e resta

\boxed{\,P = \overline{B}\,\bigl(\overline{A} + P\bigr)\,}

che si legge in italiano quasi parola per parola: se è pieno fermati; altrimenti parti se è vuoto, oppure resta come sei. Le tre righe della specifica, in tre pezzi di formula.

Questa forma — una condizione che accende, una che spegne, e per tutto il resto si conserva — è lo schema di ogni memoria elementare, e ha un nome: set–reset. Qui il set è $\overline{A}$ (vuoto), il reset è $B$ (pieno), e il reset prevale, perché $\overline{B}$ moltiplica tutto: se il serbatoio è pieno la pompa si ferma comunque, qualunque cosa dicano gli altri termini.

Quale dei due comandi prevale non è un dettaglio: è una scelta di progetto, e su un impianto vero è una scelta di sicurezza.

All’accensione

Vale la pena chiedersi cosa fa questa rete quando il PLC si accende con il serbatoio a metà. Le uscite partono a 0, quindi $P = 0$ ; con $A = 1$ e $B = 0$ la formula dà

P = \overline{B}\,(\overline{A} + P) = 1 \cdot (0 + 0) = 0

la pompa resta ferma. L’impianto si sveglia in svuotamento e aspetta che il livello scenda sotto $A$ prima di riempire di nuovo. Non è un caso fortunato: è la conseguenza dello stato iniziale, ed è il comportamento prudente fra i due possibili.

Il contatto NC nel programma non è il pulsante NC nel quadro.

Un pulsante di arresto si cabla normalmente chiuso: a riposo lascia passare corrente, e premendolo la interrompe. Il motivo è che se il filo si taglia o il contatto si ossida, l’ingresso va a 0 da solo — e la macchina si ferma. Con un pulsante normalmente aperto lo stesso guasto renderebbe l’arresto inefficace, senza che nessuno se ne accorga finché non serve.

Ma allora, nel programma, quel segnale va letto con un contatto NA: l’ingresso vale già 1 a riposo e 0 quando si preme.

\underbrace{\text{NC nel cablaggio}}_{\text{scelta di sicurezza}} \qquad\neq\qquad \underbrace{\text{NC nel programma}}_{\text{la negazione logica}}

Metterlo NC anche nel programma nega due volte: la macchina parte già fermata e non si ferma più quando si preme. È l’errore classico di chi impara il ladder sul simulatore, dove il cablaggio non c’è.

Esercizio.

Scrivi il ramo ladder di una marcia/arresto: un pulsante $M$ avvia un nastro, un pulsante $S$ lo ferma, ed entrambi tornano a riposo appena rilasciati.
Nel serbatoio, il primo ramo è $\overline{A}\cdot\overline{B}$ . Il contatto $\overline{B}$ è necessario?
Scrivi il comando della valvola di scarico $V$ : si apre alla pressione del pulsante dell’operatore $C$ , solo a pompa ferma, e resta aperta finché c’è liquido sopra il sensore $A$ — anche dopo che il pulsante è stato rilasciato.
Che cosa succede all’impianto se nel secondo ramo si dimentica il contatto $\overline{B}$ ?

Mostra la soluzione

1. Un ramo solo, con l’autoritenuta in parallelo al pulsante di marcia e il contatto di arresto in serie a valle:

Q = (M + Q)\cdot \overline{S}

I due contatti $M$ e $Q$ stanno in parallelo — parti se premo, oppure se stavi già andando — e il gruppo è in serie con $\overline{S}$ , che taglia tutto. È la stessa struttura set–reset del serbatoio, con $M$ al posto di $\overline{A}$ e $S$ al posto di $B$ : l’arresto prevale sulla marcia anche a pulsanti premuti insieme.

E il $\overline{S}$ non contraddice il blocco sul pulsante NC: qui $S$ è il segnale logico “premuto = 1”, com’è su un simulatore. Nel quadro vero, con l’arresto cablato NC, l’ingresso vale già 1 a riposo e quel contatto nel programma diventa NA — è esattamente il caso del blocco qui sopra.

2. No, è ridondante. Poiché $A$ sta sotto $B$ , il liquido copre sempre prima $A$ : la condizione $B = 1$ implica $A = 1$ , quindi $A = 0$ implica già $B = 0$ e

\overline{A}\cdot\overline{B} = \overline{A}

Non è un errore tenerlo — costa un contatto e rende esplicita la condizione “vuoto” — ma è utile accorgersene: le impossibilità fisiche semplificano la rete, esattamente come le condizioni di indifferenza semplificano una mappa di Karnaugh.

3. «Si apre alla pressione e resta aperta dopo il rilascio» è la parola d’ordine dell’autoritenuta: $C$ da solo non basta, serve che $V$ rilegga sé stessa.

V = \bigl(C + V\bigr)\cdot \overline{P} \cdot A

Stessa struttura dell’esercizio 1: $C$ e $V$ in parallelo — apri se premo, oppure se eri già aperta — e il gruppo in serie con le due condizioni che possono chiuderla.

Il contatto $\overline{P}$ è un interblocco: impedisce di scaricare mentre si riempie, cioè proprio la situazione che l’ipotesi del problema aveva escluso. Il contatto $A$ chiude la valvola da sola quando il serbatoio si è svuotato — e siccome è in serie, taglia anche l’autoritenuta: non serve nessun comando di arresto, se ne occupa il livello.

Senza l’autoritenuta, cioè con $V = C \cdot \overline{P} \cdot A$ , la valvola si richiude nell’istante in cui l’operatore molla il pulsante. Funzionerebbe solo se $C$ fosse un selettore mantenuto invece di un pulsante — ed è una domanda da fare sempre davanti a una specifica: quel comando resta premuto o è un impulso? Le due risposte danno due reti diverse.

4. Il secondo ramo diventerebbe $P \cdot A$ : una volta partita, la pompa si autoalimenta finché $A = 1$ — e $A$ resta immerso anche a serbatoio pieno. La pompa non si fermerebbe più, e il serbatoio traboccherebbe.

Verifica. Il modo di controllare una rete sequenziale non è provare le combinazioni di ingresso, ma percorrere un ciclo completo aggiornando lo stato a ogni passo. Sul risultato del punto 3, partendo da serbatoio pieno e premendo $C$ una volta sola:

passo	$A$	$B$	$C$	$P$	$V$
pieno, l’operatore preme $C$	1	1	1	0	1
$C$ rilasciato, il livello scende sotto $B$	1	0	0	0	1
il livello scende sotto $A$	0	0	0	1	0
risale sopra $A$	1	0	0	1	0
risale sopra $B$ : pieno	1	1	0	0	0

La riga 2 è l’autoritenuta al lavoro: $C$ è già tornato a 0 e la valvola resta aperta lo stesso.

L’impianto torna al livello di partenza ma non allo stato di partenza: la valvola è chiusa e aspetta un nuovo comando. È giusto così — una valvola di scarico che si riapre da sola sarebbe un difetto, non una comodità.

Nota infine che le righe 2 e 4 hanno gli stessi ingressi ( $A=1$ , $B=0$ , $C=0$ ) e entrambe le uscite scambiate: se il tuo controllo non produce una coppia di righe così, non stai verificando una rete sequenziale — stai verificando una combinatoria.