S7 CC Lezione 10
🎓 S7 PLC Crash Course · Lezione 10
Comparatori ⚖️
[==] [<>] [>] [<] [>=] [<=]
Sei operatori per confrontare qualsiasi valore numerico nel Ladder.
🎯 Cosa impari in questa lezione
- I 6 operatori di confronto nel simulatore
- I 4 tipi di operando: Costante, Counter CV, Timer ET, MW
- Come configurare un comparatore nel simulatore
- Pattern: allarmi multi-livello, finestre di valori, visualizzazione conteggio
- Combinare comparatori con timer, counter e analogico
📋 Scheda lezione
| Modulo | 10 — Confronto Valori |
| Lezione | 10 di 15 |
| Livello | ⭐⭐⭐ Avanzato |
| Tempo | ~30 minuti |
| Elementi nuovi | 6 comparatori |
| Prerequisiti | Lezione 09 |
🧠 Perché servono i comparatori
I contatti (NA, NC, P, N) lavorano con i bit: una variabile è 0 o 1, e il contatto conduce o non conduce. Ma nel mondo reale servono decisioni basate su valori numerici: "la temperatura è sopra 80°C?", "il contatore ha raggiunto 15?", "il timer è trascorso per più di 3 secondi?".
I comparatori rispondono a queste domande. Prendono due valori numerici, li confrontano con un operatore (uguale, maggiore, minore…) e producono un risultato booleano: vero (1) o falso (0). Quel risultato diventa la "corrente logica" per il resto del Network — esattamente come un contatto.
📊 I 6 operatori di confronto
| Simbolo | Toolbox | Operazione | Q = 1 quando | Esempio |
|---|---|---|---|---|
[==] | Uguale | Uguale a | Op1 = Op2 | C0.CV == 10 → "esattamente 10 pezzi" |
[<>] | Diverso | Diverso da | Op1 ≠ Op2 | MW0 <> 0 → "valore non zero" |
[>] | Maggiore | Maggiore di | Op1 > Op2 | T0.ET > 5000 → "timer oltre 5 secondi" |
[<] | Minore | Minore di | Op1 < Op2 | C0.CV < 3 → "meno di 3 pezzi" |
[>=] | Maggiore/Uguale | Maggiore o uguale | Op1 ≥ Op2 | MW0 >= 20000 → "soglia analogica" |
[<=] | Minore/Uguale | Minore o uguale | Op1 ≤ Op2 | C0.CV <= 0 → "contatore a zero" |
I comparatori si posizionano nella sezione ingressi del Network, come i contatti. Il risultato (vero/falso) determina se la corrente logica prosegue verso le bobine a destra.
🔩 I 4 tipi di operando
Ogni comparatore ha due "lati" — Operando 1 e Operando 2. Ciascuno può essere uno di questi tipi:
Puoi combinare qualsiasi tipo su ciascun lato. Confronti tipici: Counter CV vs Costante ("ho contato abbastanza?"), Timer ET vs Costante ("è passato abbastanza tempo?"), MW vs MW ("il livello è sopra il setpoint?").
🖥️ Configurare un comparatore nel simulatore
- Trascina un comparatore (es: [>=]) dalla Toolbox nella sezione ingressi del Network
- Clicca sull'elemento per aprire la configurazione
- Imposta Operando 1: seleziona il tipo (Costante, Counter CV, Timer ET, MW) e il valore/indice
- Imposta Operando 2: stessa cosa
- Conferma. Il comparatore mostra l'operazione nel Network (es:
C0.CV >= 10) - Aggiungi la bobina nella sezione uscite
💡 Il comparatore funziona SOLO se riceve corrente. Se c'è un contatto NA a sinistra del comparatore e quel contatto è aperto (variabile = 0), il comparatore non viene nemmeno valutato — il risultato è sempre 0. Il comparatore è "in serie" con il resto della catena logica.
🔧 Pattern pratici
Pattern 1 — Allarmi multi-livello
Un contatore C0 conta i cicli di una macchina. Tre livelli di segnalazione:
Network 1 // Manutenzione preventiva (500 cicli)
[CMP>= C0.CV >= 500] ────── ─( )─ Q0.0 // lampada gialla
Network 2 // Manutenzione urgente (900 cicli)
[CMP>= C0.CV >= 900] ────── ─( )─ Q0.1 // lampada rossa
Network 3 // Blocco macchina (1000 cicli — limite!)
[CMP>= C0.CV >= 1000] ───── ─(R)─ M0.0 // blocca "abilitazione marcia"
Le soglie sono cumulative: a 500 cicli si accende il giallo (ma la macchina continua), a 900 si aggiunge il rosso, a 1000 la macchina si blocca. Dopo la manutenzione, il tecnico resetta il contatore C0.
Pattern 2 — Finestra di valori (range check)
Un valore è "in range" solo se è compreso tra un minimo e un massimo. Per controllarlo servono due comparatori in serie (AND logico):
Network 1 // Valore MW0 nel range 100–200? → "OK"
[CMP>= MW0 >= 100] ─ [CMP<= MW0 <= 200] ── ─( )─ Q0.0 // in range
Network 2 // Fuori range → allarme
NOT Q0.0 ─┤/├─ ───────────────── ─( )─ Q0.1 // fuori range
Il Network 1 mette due comparatori in serie: MW0 >= 100 AND MW0 <= 200. Solo se entrambi sono veri (valore tra 100 e 200), Q0.0 si accende. Il Network 2 usa NOT Q0.0 per l'allarme "fuori range".
Pattern 3 — Azioni progressive con Timer ET
Usare il tempo trascorso (ET) di un timer per azioni progressive — come un semaforo basato su un solo timer:
// Un timer che conta continuamente (reset ciclico a 12000ms = 12s)
N1 M0.0 ─┤ ├─ [TON T0, PT=12000] ── ─(R)─ M0.0 // reset a fine ciclo
N2 NOT M0.0 ─┤/├─ ────────────────── ─(S)─ M0.0 // avvio automatico
// Uscite basate su ET — un solo timer, tre uscite
N3 [CMP< T0.ET < 5000] ────── ─( )─ Q0.0 // Verde: 0–5s
N4 [CMP>= T0.ET >= 5000] ─ [CMP< T0.ET < 7000] ── ─( )─ Q0.1 // Giallo: 5–7s
N5 [CMP>= T0.ET >= 7000] ───── ─( )─ Q0.2 // Rosso: 7–12s
Questo è un approccio alternativo al semaforo della lezione 06: invece di usare 3 Merker e 3 timer, usiamo un solo timer e leggiamo il suo ET con i comparatori. Più compatto, ma meno flessibile per sequenze complesse.
🔍 Due approcci, stessa funzione. Il semaforo a Merker (lezione 06) è più "industriale" — ogni passo ha la sua logica indipendente, facile da modificare. Il semaforo a comparatori è più "compatto" — un solo timer e le soglie definiscono tutto. In pratica si usano entrambi: i Merker per le sequenze, i comparatori per le soglie e i valori continui.
📊 Riepilogo — tutti gli elementi Ladder a confronto
Con i comparatori completi tutti gli elementi della sezione ingressi del Ladder:
| Categoria | Elementi | Lavora con | Risultato |
|---|---|---|---|
| Contatti | NA, NC, P, N | Bit (0/1) | Conduce o non conduce |
| Timer | TON, TOF, TP | Tempo (ms) | Q = 1 dopo il ritardo/impulso |
| Counter | CTU, CTD, CTUD | Fronti (conteggio) | Q = 1 al raggiungimento di PV |
| Comparatori | ==, <>, >, <, >=, <= | Valori numerici | 1 se confronto vero, 0 se falso |
E per la sezione uscite: Bobina standard ─( )─, Set ─(S)─ e Reset ─(R)─. Con questi 19 elementi puoi costruire qualsiasi logica di automazione nel Ladder.
🏋️ Esercizi pratici
Esercizio 10.1 — Contapezzi con soglie
Un contatore CTU conta impulsi da I0.0. Crea 3 Network con comparatori:
- C0.CV >= 5 → Q0.0 (lampada verde — "a metà")
- C0.CV >= 10 → Q0.1 (lampada gialla — "quasi pieno")
- C0.CV == 15 → Q0.2 (lampada rossa — "batch completo")
- I0.1 resetta C0
- RUN → clicca I0.0 e osserva le lampade accendersi progressivamente
Esercizio 10.2 — Finestra di valori
Crea un circuito che verifica se MW0 è nel range 1000–2000:
- Network 1: MW0 >= 1000 AND MW0 <= 2000 → Q0.0 ("in range")
- Network 2: NOT Q0.0 → Q0.1 ("fuori range")
- Per testare: nel pannello I/O non puoi modificare MW direttamente, ma puoi collegare un HMI slider a MW0 (lo vedremo nella lezione 11) oppure osservare il concetto sulla carta
Esercizio 10.3 — Timer progressivo
Quando premi I0.0, un timer TON parte. Usa comparatori su T0.ET per creare un effetto "barra di caricamento":
- T0.ET >= 0 → Q0.0 (LED 1 — subito)
- T0.ET >= 1000 → Q0.1 (LED 2 — dopo 1 secondo)
- T0.ET >= 2000 → Q0.2 (LED 3 — dopo 2 secondi)
- T0.ET >= 3000 → Q0.3 (LED 4 — dopo 3 secondi, timer completo)
Rilascia I0.0 → tutto si spegne (il TON si resetta).
Esercizio 10.4 — Sfida: semaforo con un solo timer
Sfida: implementa il semaforo (Verde 5s, Giallo 2s, Rosso 5s) usando un solo timer e i comparatori, come nel Pattern 3. Aggiungi il reset ciclico.
Suggerimento
Un Merker M0.0 si auto-avvia e pilota un TON con PT=12000ms (ciclo totale). Quando ET raggiunge 12000, resetta M0.0. Al ciclo dopo, M0.0 si ri-setta e il timer riparte da 0. Le uscite: ET < 5000 → Verde, ET >= 5000 AND ET < 7000 → Giallo, ET >= 7000 → Rosso.
Esercizio 10.5 — Sfida: timeout di sicurezza
Sfida avanzata: un cilindro parte quando premi I0.0 (Q0.0 = avanti). Il finecorsa I0.1 deve attivarsi entro 5 secondi. Se dopo 5 secondi I0.1 non si è attivato, genera un allarme "timeout" su Q0.2 e ferma il cilindro.
Suggerimento
Quando Q0.0 è attivo, un TON (PT=5000) conta. Se il timer arriva a 5000ms senza che I0.1 si attivi, usa il comparatore T0.ET >= 5000 AND NOT I0.1 → Set Q0.2 (allarme) + Reset Q0.0 (ferma cilindro). Se I0.1 arriva in tempo, il cilindro si ferma normalmente e il timer si resetta.
❓ Quiz rapido
1. Un comparatore [>= C0.CV >= 10] è in serie con un contatto NA di I0.0 (che è a 0). Il contatore C0 ha CV=15. Qual è il risultato del Network?
Mostra risposta
0 (falso). Anche se il confronto C0.CV >= 10 sarebbe vero (15 >= 10), il comparatore non riceve corrente perché il contatto NA di I0.0 è aperto (I0.0=0). In serie, se un elemento blocca il flusso, tutto quello che segue riceve 0.
2. Qual è la differenza tra [==] e [>=] per controllare un contapezzi con PV=10?
Mostra risposta
[== C0.CV == 10] è vero solo quando CV è esattamente 10. Se CV va a 11 (il contatore continua a contare), il comparatore torna a falso. [>= C0.CV >= 10] è vero da 10 in poi — resta vero anche se CV supera 10. Per le soglie di allarme, usa >=. Per azioni "una tantum" al valore esatto, usa == (ma combinalo con un fronte P per evitare che l'azione si ripeta ad ogni ciclo).
3. Come faccio a controllare se un valore è compreso tra 50 e 100?
Mostra risposta
Due comparatori in serie nello stesso Network: [>= MW0 >= 50] seguito da [<= MW0 <= 100]. Poiché sono in serie, entrambi devono essere veri (AND logico). Se MW0 = 75, entrambi sono veri → corrente passa. Se MW0 = 120, il secondo è falso → corrente bloccata.
4. Posso usare un comparatore senza contatti prima? Cioè, come primo elemento del Network?
Mostra risposta
Sì! Il comparatore riceve automaticamente "corrente" dalla sbarra sinistra (come un contatto). Se il confronto è vero, la corrente passa al prossimo elemento. Non è obbligatorio avere un contatto prima. L'esempio degli allarmi multi-livello (Pattern 1) lo dimostra: il comparatore è il primo e unico elemento della catena di ingressi.
5. Che tipi di operando supporta il comparatore nel simulatore?
Mostra risposta
Quattro tipi: Costante (un numero fisso), Counter CV (valore corrente di un contatore, specificato per indice), Timer ET (tempo trascorso di un timer, in ms), e Memory Word MW (registro a 16 bit). Puoi combinare qualsiasi tipo su ciascun lato del confronto, ad esempio: MW0 >= C0.CV ("la word è più grande del conteggio?").
Prossima lezione →
Lezione 11 — HMI (Human Machine Interface)KTP700 Button Gauge Tank
L'interfaccia operatore — pulsanti, indicatori, serbatoi animati
e 8 modelli di pannello Siemens.
© Prof. D. Bertolino · S7 PLC Crash Course · Unofficial S7-1200 Simulator · Lezione 10