Lezione 4 di 15

S7 CC Lezione 04

🎓 S7 PLC Crash Course · Lezione 04

Merker e Organizzazione del Programma 🧩

M0.0 MW0 Sequenze Interblocco
Le variabili interne, le sequenze a passi e i pattern fondamentali.

🎯 Cosa impari in questa lezione

Cos’è un Merker e perché è indispensabile
Differenza tra M (bit) e MW (word a 16 bit)
Tre pattern fondamentali: flag di stato, condizione intermedia, passo di sequenza
Come costruire una sequenza a passi con i Merker
Il pattern di interblocco (interlock) tra due movimenti
Organizzazione del programma: commenti, convenzioni, buone abitudini

📋 Scheda lezione

Modulo	4 — Memoria e Struttura
Lezione	04 di 15
Livello	⭐⭐ Principiante+
Tempo	~40 minuti
Elementi nuovi	Merker M, Memory Word MW
Prerequisiti	Lezione 03

🧠 Cos’è un Merker — la memoria nascosta del PLC

Finora hai usato due tipi di variabili: I (ingressi fisici, collegati a sensori) e Q (uscite fisiche, collegate ad attuatori). Ma spesso serve un posto dove “appoggiare” informazioni che non corrispondono a nessun filo nel quadro elettrico.

Ecco il Merker (M): un bit di memoria interna del PLC. Non è collegato a nessun sensore, nessun motore — vive solo dentro il programma. Puoi leggerlo e scriverlo esattamente come un ingresso o un’uscita, ma il suo valore esiste solo nella RAM del PLC.

Il nome “Merker” viene dal tedesco (Siemens è tedesca) e significa “marcatore” o “segnalino”. In altri ambienti PLC si chiamano “relay interni”, “flag” o “auxiliary bit”.

M (bit) e MW (word) — due formati

M — Merker Bit

Un singolo bit: vale 0 o 1. Formato: M[byte].[bit]

Nel simulatore: M0.0 – M3.7 (32 bit totali, 4 byte).

Uso tipico: flag ON/OFF, passi di sequenza, condizioni intermedie, stato della macchina.

MW — Memory Word

Un valore a 16 bit: da 0 a 65535. Formato: MW[indirizzo]

Nel simulatore: MW0 – MW255 (256 word).

Uso tipico: valori numerici, setpoint, conteggi, valori analogici convertiti, parametri di processo.

⚠️ Attenzione alla sovrapposizione: nel PLC reale, i Merker bit M e le Memory Word MW condividono la stessa area di memoria. MW0 contiene i bit da M0.0 a M1.7 (due byte). Scrivere MW0 sovrascrive tutti i Merker da M0.0 a M1.7. Nel simulatore questa sovrapposizione non è implementata (sono aree separate), ma è un concetto importante da conoscere per quando passerai a TIA Portal.

🎯 Tre pattern di utilizzo dei Merker

I Merker si usano in tre modi principali. Sono i “mattoni” con cui costruirai qualsiasi programma complesso.

Pattern 1 — Flag di stato

Un Merker che rappresenta uno “stato” del sistema: macchina in automatico, ciclo attivo, errore rilevato. Lo setti in un Network e lo leggi in molti altri.

// Network 5: Imposta flag “sistema in automatico”
I0.5 ─┤ ├─ ───────────────── ─(S)─ M0.0 // selettore AUTO

// Network 12: Usa il flag come condizione
M0.0 ─┤ ├─ I0.0 ─┤ ├─ ── ─(S)─ Q0.0 // START solo se AUTO

// Network 20: Usa lo stesso flag altrove
M0.0 ─┤ ├─ I0.2 ─┤ ├─ ── ─(S)─ Q0.1 // valvola solo se AUTO

Il vantaggio: se domani cambi la condizione per “automatico” (magari aggiungi un sensore), la modifichi in un solo Network. Tutti gli altri leggono M0.0 e si aggiornano automaticamente.

Pattern 2 — Condizione intermedia

Quando una combinazione logica complessa viene usata in più Network, salvala in un Merker e riusala. Eviti di riscrivere la stessa logica più volte — meno errori, più leggibilità.

// Network 1: Calcola condizione “pronto a partire”
I0.0 ─┤ ├─ I0.1 ─┤/├─ I0.2 ─┤ ├─ ── ─( )─ M0.0 // “PRONTO”

// Network 2: Usa “PRONTO” per il motore
M0.0 ─┤ ├─ ─────────────── ─( )─ Q0.0 // motore

// Network 3: Usa “PRONTO” per la lampada
M0.0 ─┤ ├─ ─────────────── ─( )─ Q0.1 // lampada verde

Pattern 3 — Passo di sequenza

Il più potente dei tre. Ogni Merker rappresenta un passo di una sequenza: M0.0 = Passo 1, M0.1 = Passo 2, M0.2 = Passo 3… In ogni momento un solo Merker è a 1 (il passo attivo). Le transizioni tra passi sono gestite da Set/Reset.

Questo è il cuore della programmazione sequenziale dei PLC — ed è il modo in cui si controllano processi come “riempi serbatoio → miscela → riscalda → scarica”.

🔄 Sequenza a passi — esempio completo

Costruiamo una sequenza a 3 passi. Il processo è: premi START → Passo 1 (lampada verde) → premi conferma → Passo 2 (lampada gialla) → premi conferma → Passo 3 (lampada rossa) → premi RESET → torna a riposo.

Figura 1 — Diagramma della sequenza a 3 passi. Le frecce indicano le condizioni di transizione.

Traduzione in Ladder — Network per Network

Ogni transizione e ogni azione diventano un Network separato. Ecco il programma completo:

// ═══════════════════════════════════════════
// TRANSIZIONI (gestione passi)
// ═══════════════════════════════════════════

Network 1 // Avvio sequenza: RIPOSO → Passo 1
I0.0 ─┤ ├─ NOT M0.0 ─┤/├─ NOT M0.1 ─┤/├─ NOT M0.2 ─┤/├─ ─(S)─ M0.0

Network 2 // Passo 1 → Passo 2 (conferma)
M0.0 ─┤ ├─ I0.1 ─┤ ├─ ────────── ─(S)─ M0.1

Network 3 // Disattiva Passo 1 quando Passo 2 parte
M0.1 ─┤ ├─ ────────────────────── ─(R)─ M0.0

Network 4 // Passo 2 → Passo 3 (conferma)
M0.1 ─┤ ├─ I0.1 ─┤ ├─ ────────── ─(S)─ M0.2

Network 5 // Disattiva Passo 2 quando Passo 3 parte
M0.2 ─┤ ├─ ────────────────────── ─(R)─ M0.1

// ═══════════════════════════════════════════
// USCITE (azioni per ogni passo)
// ═══════════════════════════════════════════

Network 6 // Lampada verde = Passo 1 attivo
M0.0 ─┤ ├─ ────────────────────── ─( )─ Q0.0

Network 7 // Lampada gialla = Passo 2 attivo
M0.1 ─┤ ├─ ────────────────────── ─( )─ Q0.1

Network 8 // Lampada rossa = Passo 3 attivo
M0.2 ─┤ ├─ ────────────────────── ─( )─ Q0.2

// ═══════════════════════════════════════════
// RESET GENERALE
// ═══════════════════════════════════════════

Network 9 // Pulsante RESET: torna a riposo
I0.2 ─┤ ├─ ────────────────────── ─(R)─ M0.0
Network 10
I0.2 ─┤ ├─ ────────────────────── ─(R)─ M0.1
Network 11
I0.2 ─┤ ├─ ────────────────────── ─(R)─ M0.2

💡 Nota la struttura: prima i Network di transizione (gestiscono i passi), poi i Network di azione (collegano passi alle uscite), infine il reset. Questa organizzazione — transizioni → azioni → reset — è un pattern che userai in tutti i tuoi programmi sequenziali.

🔐 Interblocco (Interlock) — due movimenti incompatibili

Nell’industria ci sono molte situazioni in cui due azioni non devono mai avvenire contemporaneamente: un motore che gira a destra e uno che gira a sinistra (sullo stesso asse), una valvola di carico e una di scarico (sullo stesso serbatoio), un cilindro che sale e che scende (pneumatica).

Il pattern si chiama interblocco: ciascuna uscita ha come condizione “il mio pulsante è premuto E l’altra uscita è spenta“.

Network 1 // Motore DESTRA — bloccato se SINISTRA è attivo
I0.0 ─┤ ├─ NOT Q0.1 ─┤/├─ ────── ─(S)─ Q0.0

Network 2 // Motore SINISTRA — bloccato se DESTRA è attivo
I0.1 ─┤ ├─ NOT Q0.0 ─┤/├─ ────── ─(S)─ Q0.1

Network 3 // STOP — ferma tutto
I0.2 ─┤ ├─ ───────────────────── ─(R)─ Q0.0
Network 4
I0.2 ─┤ ├─ ───────────────────── ─(R)─ Q0.1

Il contatto NC NOT Q0.1 nel Network 1 impedisce di attivare DESTRA se SINISTRA è già attiva (e viceversa). Anche se entrambi i pulsanti vengono premuti, solo il primo ad essere stato attivato resta in funzione.

🛑 L’interblocco è un requisito di sicurezza, non un optional. In un impianto reale, la mancanza di interblocco tra movimenti opposti può causare danni meccanici, rotture e pericolo per le persone. Nel simulatore è solo una logica — in fabbrica è la differenza tra un impianto sicuro e un incidente.

📐 Organizzazione del programma — buone abitudini

Con 11 Network come nella sequenza sopra, il programma inizia a crescere. Ecco le regole per mantenerlo leggibile e manutenibile.

✅ Fai sempre

Commenta ogni Network — scrivi COSA fa, non COME. “Avvio motore nastro” è meglio di “Set Q0.0 se I0.0 AND NOT Q0.1”
Raggruppa per funzione — prima le transizioni, poi le azioni, poi la sicurezza
Un’uscita, un responsabile — evita di scrivere la stessa uscita in Network diversi con bobina standard (usa Set/Reset per le eccezioni)
Dai nomi significativi ai Merker — nel commento scrivi “M0.0 = Passo 1 Riempimento” così sai a cosa serve

❌ Non fare mai

Network senza commento — tra una settimana non ricorderai cosa fa
Doppia assegnazione con bobina standard — se due Network scrivono ─( )─ Q0.0, il secondo cancella il primo ad ogni ciclo
Merker “a caso” — decidi una convenzione (M0.x = passi, M1.x = flag) e rispettala
Tutto in un Network — se un Network ha più di 5-6 elementi, probabilmente va diviso

📊 Riepilogo — le aree di memoria usate finora

Area	Formato	Tipo	Uso principale	Lezione
`I`	I0.0 – I1.7	Bit (input)	Sensori, pulsanti, finecorsa	01
`Q`	Q0.0 – Q1.7	Bit (output)	Motori, lampade, valvole	02
`M`	M0.0 – M3.7	Bit (interno)	Flag, passi sequenza, condizioni	04
`MW`	MW0 – MW255	Word 16 bit	Valori numerici, setpoint	04

🏋️ Esercizi pratici

Esercizio 4.1 — Sequenza a 3 passi

Implementa nel simulatore la sequenza descritta sopra (11 Network). Testa:

Premi I0.0 (START) → Q0.0 si accende (verde). Verifica che M0.0 sia a 1 nel pannello I/O.
Premi I0.1 (CONFERMA) → Q0.0 si spegne, Q0.1 si accende (gialla). Verifica M0.0=0, M0.1=1.
Premi I0.1 di nuovo → Q0.1 si spegne, Q0.2 si accende (rossa). M0.1=0, M0.2=1.
Premi I0.2 (RESET) → tutto si spegne. Tutti i Merker a 0.
Bonus: cosa succede se premi I0.0 durante il Passo 2? (Non dovrebbe succedere nulla — la condizione del Network 1 verifica che tutti i Merker siano a 0)

Esercizio 4.2 — Interblocco motori

Due motori (Q0.0 = DESTRA, Q0.1 = SINISTRA) non devono mai funzionare contemporaneamente:

Network 1: I0.0 AND NOT Q0.1 → Set Q0.0
Network 2: I0.1 AND NOT Q0.0 → Set Q0.1
Network 3: I0.2 → Reset Q0.0
Network 4: I0.2 → Reset Q0.1
Testa: attiva DESTRA, poi prova ad attivare SINISTRA → non deve funzionare
Premi STOP, poi attiva SINISTRA → ora funziona

Esercizio 4.3 — Condizione intermedia

Crea un Merker M1.0 “PRONTO” che vale 1 quando: I0.0 (sensore porta chiusa) AND NOT I0.1 (no allarme) AND I0.2 (selettore AUTO). Poi usa M1.0 come condizione per avviare due uscite diverse:

Network 1: condizione → ─( )─ M1.0
Network 2: M1.0 AND I0.3 → Set Q0.0 (motore)
Network 3: M1.0 → ─( )─ Q0.1 (lampada “pronto”)

Esercizio 4.4 — Sfida: sequenza con interblocco

Sfida: combina i concetti. Un cilindro pneumatico ha due movimenti: AVANTI (Q0.0) e INDIETRO (Q0.1). Crea una sequenza:

I0.0 (START) → il cilindro va AVANTI (Q0.0)
I0.3 (finecorsa avanzato) → il cilindro si ferma e va INDIETRO (Q0.1)
I0.4 (finecorsa arretrato) → il cilindro si ferma. Ciclo completato.
Q0.0 e Q0.1 devono essere interbloccati (mai entrambi attivi)
I0.2 = arresto di emergenza

Suggerimento sulla struttura

Usa M0.0 = “Avanti attivo”, M0.1 = “Indietro attivo”. Le transizioni sono: START → Set M0.0 / finecorsa avanzato → Set M0.1 + Reset M0.0 / finecorsa arretrato → Reset M0.1. Le uscite: M0.0 AND NOT Q0.1 → Q0.0 / M0.1 AND NOT Q0.0 → Q0.1. L’emergenza resetta tutti i Merker.

❓ Quiz rapido

1. Qual è la differenza tra un Merker M e un’uscita Q?

Mostra risposta

Funzionalmente, nel programma Ladder si usano allo stesso modo. La differenza è che Q è collegata a un’uscita fisica (un filo che va a un motore o una lampada), mentre M esiste solo nella memoria del PLC. Scrivere Q0.0 = 1 accende un motore reale. Scrivere M0.0 = 1 non fa niente di fisico — è un appunto interno.

2. In una sequenza a passi, perché solo un Merker alla volta deve essere a 1?

Mostra risposta

Perché ogni Merker rappresenta uno stato della macchina, e la macchina può essere in un solo stato alla volta. Se M0.0 (riempimento) e M0.2 (scarico) fossero entrambi a 1, la macchina starebbe riempiendo e scaricando contemporaneamente — fisicamente impossibile o pericoloso. Le transizioni con Set/Reset garantiscono che il passo precedente venga disattivato prima di attivare il successivo.

3. Ho due Network che scrivono la stessa uscita con bobina standard: Network 5 scrive ─( )─ Q0.0 e Network 10 scrive ─( )─ Q0.0. Quale problema si verifica?

Mostra risposta

Il Network 10 sovrascrive il risultato del Network 5 ad ogni ciclo, perché la bobina standard scrive il suo valore (0 o 1) a ogni scansione. Il Network 5 diventa inutile. Se il Network 10 ha condizione falsa, Q0.0 viene messa a 0 anche se il Network 5 la vorrebbe a 1. Soluzione: usa Set/Reset in Network separati, oppure unifica la logica in un solo Network.

4. Cos’è un interblocco e quando serve?

Mostra risposta

Un interblocco è un circuito logico che impedisce a due azioni incompatibili di avvenire contemporaneamente. Si implementa aggiungendo un contatto NC dell’uscita “opposta” nella condizione di ciascuna uscita. Serve quando due movimenti non possono coesistere: destra/sinistra, su/giù, carico/scarico, apertura/chiusura.

5. Nella sequenza a 3 passi, il Network 1 ha tre contatti NC (NOT M0.0, NOT M0.1, NOT M0.2). Perché?

Mostra risposta

Per garantire che il pulsante START funzioni solo quando la sequenza è a riposo (tutti i passi spenti). Se la sequenza è già in corso (un Merker è a 1), premere START non deve avere effetto. Quei tre contatti NC verificano che M0.0, M0.1 e M0.2 siano tutti a 0 — cioè che nessun passo sia attivo.

🏁 Fine del Livello BASE

Congratulazioni — hai completato i 4 moduli del livello base! Sai cos’è un PLC, come funziona il Ladder Logic, come creare circuiti con memoria e come organizzare una sequenza. Queste competenze sono la base di tutto ciò che segue.

Nel prossimo livello (Intermedio) aggiungeremo il tempo e il conteggio: timer, counter e rilevamento fronti. Il tuo programma inizierà a “ragionare” con il mondo reale.

Prossima lezione →

Lezione 05 — Timer TON (On-Delay)
[TON]
Il ritardo all’eccitazione — anti-rimbalzo, ritardi di avvio,
e il tuo primo circuito lampeggiante.