SCL Syntax Skill

Assistenza sintassi SCL per programmazione PLC Siemens TIA Portal V20+. SCL syntax assistance for Siemens TIA Portal V20+ PLC programming.

🚨 REGOLE CRITICHE NON NEGOZIABILI / CRITICAL NON-NEGOTIABLE RULES

R1: Parametri Nominati SEMPRE / Named Parameters ALWAYS

IT: Tutti i parametri di funzioni native DEVONO usare sintassi nominata con := per input e => per output.

EN: All native function parameters MUST use named parameter syntax with := for inputs and => for outputs.

// ✅ CORRETTO / CORRECT
result := LIMIT(MN := 0, IN := value, MX := 100);
#Motor1(Start := signal, Running => output);

// ❌ SBAGLIATO / WRONG - ERRORE COMPILAZIONE!
result := LIMIT(0, value, 100);
#Motor1(signal, output);

R2: Istanze Statiche per Timer/Counter/Trigger / Persistent Storage

IT: Timer, Counter, Trigger DEVONO essere dichiarati in VAR (FB) o VAR_STAT, MAI in VAR_TEMP. VAR_TEMP si resetta ogni ciclo PLC!

EN: Timer, Counter, Trigger MUST be declared in VAR (FB) or VAR_STAT, NEVER in VAR_TEMP. VAR_TEMP resets every PLC cycle!

// ❌ SBAGLIATO / WRONG
VAR_TEMP
    myTimer : TON;  // ERRORE: timer si resetta ogni ciclo!
END_VAR

// ✅ CORRETTO / CORRECT
VAR
    myTimer : TON;  // OK: memoria persistente tra cicli
END_VAR

R3: ELSIF non ELSEIF / Use ELSIF Not ELSEIF

IT: In SCL si usa ELSIF, non ELSEIF come in altri linguaggi.

EN: In SCL use ELSIF, not ELSEIF.

// ✅ CORRETTO / CORRECT
IF temp < 0 THEN
    state := 'FROZEN';
ELSIF temp < 100 THEN    // ELSIF!
    state := 'LIQUID';
ELSE
    state := 'GAS';
END_IF;

R4: Assegnazione := vs Output =>

IT: Usa := per input, => per output quando chiami Function Block.

EN: Use := for inputs, => for outputs when calling Function Block.

// ✅ CORRETTO / CORRECT
#Motor1(
    Start := startButton,      // IN: usa :=
    Speed := speedValue,       // IN: usa :=
    Running => motorStatus,    // OUT: usa =>
    Error => errorFlag         // OUT: usa =>
);

R5: FC vs FB / Functions vs Function Blocks

IT:

• FC (Function): Per logica stateless (calcoli, trasformazioni)
• FB (Function Block): Per logica stateful con memoria persistente (motori, valvole, sequenze)

EN:

• FC (Function): For stateless logic (calculations, transformations)
• FB (Function Block): For stateful logic with persistent memory (motors, valves, sequences)

Decision Tree: FC vs FB

Hai bisogno di memoria persistente? / Need persistent memory?
├─ NO → Usa FC / Use FC
│  └─ Esempi: calcoli, conversioni, media, controlli
│     Examples: calculations, conversions, averaging, validations
│
└─ SI → Usa FB / Use FB
   └─ Esempi: motori, timer, sequenze, state machine
      Examples: motors, timers, sequences, state machines

Workflow in 3 Passi / 3-Step Workflow

STEP 1: Identifica tipo blocco / Identify block type

• Logica ciclica senza stato → FC (Function) / Stateless logic → FC
• Controllo con memoria (motori, valvole, sequenze) → FB (Function Block) / Stateful control → FB
• Dati globali → DB (Data Block) o PLC Tags

STEP 2: Consulta funzioni native / Check native functions

• Core Functions: Per funzioni comuni (LIMIT, MIN, MAX, TON, CONCAT, ecc.), consulta scl-reference/core-functions.md
• Extended Functions: Per 192 funzioni aggiuntive, Claude legge automaticamente JSON database in scl-reference/functions/
• Usage Examples: Vedi scl-reference/USAGE_EXAMPLE.md per esempi pratici

STEP 3: Valida con checklist / Validate with checklist

• Parametri nominati ✓
• Timer in VAR (non VAR_TEMP) ✓
• ELSIF (non ELSEIF) ✓
• Consulta scl-reference/anti-patterns.md per errori comuni da evitare

📋 Template Blocchi Standard / Standard Block Templates

Template FC (Function)

FUNCTION "Calculate_Average" : REAL
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1

VAR_INPUT
    values : Array[0..9] of Real;    // Array di valori
    count : Int;                      // Numero elementi
END_VAR

VAR_TEMP
    sum : Real;                       // Somma temporanea
    i : Int;                          // Indice loop
END_VAR

BEGIN
    // Validazione input / Input validation
    IF count <= 0 OR count > 10 THEN
        #Calculate_Average := 0.0;
        RETURN;
    END_IF;

    // Calcolo media / Calculate average
    sum := 0.0;
    FOR i := 0 TO count - 1 DO
        sum := sum + values[i];
    END_FOR;

    // Ritorna risultato / Return result
    #Calculate_Average := sum / TO_REAL(count);
END_FUNCTION

Template FB (Function Block – State Machine)

FUNCTION_BLOCK "Motor_Control"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1

VAR_INPUT
    Start : Bool;           // Segnale avvio
    Stop : Bool;            // Segnale stop
    SpeedSetpoint : Real;   // Velocità richiesta
END_VAR

VAR_OUTPUT
    Running : Bool;         // Motore in marcia
    ActualSpeed : Real;     // Velocità attuale
    Alarm : Bool;           // Flag allarme
END_VAR

VAR
    State : Int;            // 0=Idle, 1=Starting, 2=Running
    StartTimer : TON;       // Timer avvio (DEVE essere in VAR!)
    ErrorCount : Int;
END_VAR

VAR_TEMP
    tempSpeed : Real;       // Variabile di lavoro temporanea
END_VAR

BEGIN
    // State machine
    CASE State OF
        0: // Idle
            IF Start AND NOT Stop THEN
                State := 1;
                #StartTimer(IN := FALSE, PT := T#0ms);  // Reset timer
            END_IF;
            Running := FALSE;

        1: // Starting
            #StartTimer(IN := TRUE, PT := T#2s);
            IF #StartTimer.Q THEN
                State := 2;
                Running := TRUE;
            END_IF;
            IF Stop THEN
                State := 0;
            END_IF;

        2: // Running
            Running := TRUE;
            // Limita velocità tra 0 e 3000 RPM
            ActualSpeed := LIMIT(
                MN := 0.0,
                IN := SpeedSetpoint,
                MX := 3000.0
            );
            IF Stop THEN
                State := 0;
                Running := FALSE;
            END_IF;
    END_CASE;

    // Gestione allarmi / Alarm handling
    IF ActualSpeed > 3000.0 * 1.1 THEN
        Alarm := TRUE;
        ErrorCount := ErrorCount + 1;
    END_IF;
END_FUNCTION_BLOCK

🔄 Control Structures / Strutture di Controllo

IF-ELSIF-ELSE Conditional

// Condizionale semplice / Simple conditional
IF temperature > 100.0 THEN
    alarm := TRUE;
    shutdownHeater();
END_IF;

// Condizionale completo / Full conditional
IF pressure < 1.0 THEN
    status := 'LOW';
ELSIF pressure > 10.0 THEN
    status := 'HIGH';
ELSE
    status := 'NORMAL';
END_IF;

// Condizioni combinate / Combined conditions
IF (temp > 80.0) AND (pressure > 5.0) OR emergencyStop THEN
    shutdown := TRUE;
END_IF;

CASE Statement (per State Machine)

// Ottimo per state machine e selezione multi-valore
CASE state OF
    0: // Idle
        Running := FALSE;
        IF StartCommand THEN
            state := 1;
        END_IF;

    1: // Starting
        Running := TRUE;
        IF startupComplete THEN
            state := 2;
        END_IF;

    2: // Running
        processControl();
        IF StopCommand THEN
            state := 3;
        END_IF;

    3: // Stopping
        IF shutdownComplete THEN
            state := 0;
        END_IF;

    ELSE
        // Stato invalido - vai in error
        state := 99;
        errorFlag := TRUE;
END_CASE;

FOR Loop

// Loop con contatore crescente / Ascending counter loop
FOR i := 0 TO 9 DO
    temperatures[i] := readSensor(i);
END_FOR;

// Loop con contatore decrescente / Descending counter loop
FOR i := 10 DOWNTO 0 DO
    buffer[i] := 0;
END_FOR;

// Loop con incremento custom / Custom increment
FOR i := 0 TO 100 BY 5 DO
    // i = 0, 5, 10, 15, ..., 100
    processValue(i);
END_FOR;

// EXIT per uscita anticipata / Early exit
FOR i := 0 TO 99 DO
    IF data[i] = targetValue THEN
        foundIndex := i;
        EXIT;  // Esce dal loop
    END_IF;
END_FOR;

// CONTINUE per saltare iterazione / Skip iteration
FOR i := 0 TO 99 DO
    IF data[i] < 0 THEN
        CONTINUE;  // Salta al prossimo i
    END_IF;
    processPositiveValue(data[i]);
END_FOR;

WHILE Loop

// Pre-test (condizione prima esecuzione)
WHILE counter < 100 DO
    counter := counter + 1;
    process(counter);
END_WHILE;

// Con EXIT
WHILE TRUE DO
    data := readData();
    IF data = STOP_MARKER THEN
        EXIT;
    END_IF;
    processData(data);
END_WHILE;

REPEAT Loop

// Post-test (esegue almeno una volta)
REPEAT
    counter := counter + 1;
    value := readSensor();
UNTIL (value > threshold) OR (counter >= maxRetries)
END_REPEAT;

// ⚠️ ATTENZIONE / WARNING: REPEAT termina quando condizione è TRUE
// (opposto di WHILE che continua quando TRUE)

📚 Reference Files / File di Riferimento

Quando Consultare i File / When to Consult Files

Per funzioni native comuni (LIMIT, MIN, MAX, TON, CONCAT, ecc.): → Leggi scl-reference/core-functions.md

• Contiene le 30 funzioni più usate con esempi pratici
• Firme complete, parametri, use cases

Per errori comuni da evitare: → Leggi scl-reference/anti-patterns.md

• Catalogo di 15+ anti-pattern con soluzioni
• Errori di performance e correttezza
• Comparazioni corretto vs sbagliato

Per tipi di dati (Int, Real, String, Array, Struct, ecc.): → Leggi scl-reference/data-types.md

• Reference completa tipi elementari e complessi
• Conversioni di tipo
• Best practices allocazione memoria

Per funzioni oltre le Core 30: → Claude consulta automaticamente i JSON database in scl-reference/functions/

• 192 funzioni aggiuntive organizzate per categoria
• Math, Comparison, Conversion, String, Move, Bitwise, Timers, Counters, Triggers
• Lookup automatico via index.json

Per esempi pratici d’uso: → Leggi scl-reference/USAGE_EXAMPLE.md

• Esempi completi di FC e FB
• Pattern comuni implementati correttamente

Database Funzioni / Function Database

Struttura Database:

scl-reference/functions/
├── index.json           # Indice completo 222 funzioni
├── math.json           # Funzioni matematiche avanzate
├── comparison.json     # Comparazioni e selezioni
├── conversion.json     # Conversioni di tipo
├── string.json         # Manipolazione stringhe
├── move.json           # Trasferimento dati
├── bitwise.json        # Operazioni bitwise
├── timers.json         # Timer avanzati
├── counters.json       # Contatori
└── triggers.json       # Trigger eventi

Processo Lookup Automatico:

1. Claude legge index.json per identificare categoria funzione
2. Legge il file JSON specifico della categoria
3. Estrae definizione completa con parametri ed esempi
4. Formatta risposta seguendo stile Core Functions

✅ Self-Check Pre-Commit / Checklist Validazione

Prima di finalizzare il codice SCL, verifica tutti questi punti:

• Parametri Nominati: Tutti i parametri funzioni native usano := (IN) e => (OUT)
• Storage Timer: Timer/Counter/Trigger sono in VAR (FB) o VAR_STAT, MAI in VAR_TEMP
• ELSIF Syntax: Usato ELSIF (non ELSEIF) nelle condizioni
• Funzioni Native: Consultate core-functions.md, nessuna reimplementazione di LIMIT, MIN, MAX, ecc.
• Edge Detection: Usato R_TRIG/F_TRIG (non fronte manuale)
• Array Operations: Usato MOVE_BLK/FILL_BLK (non loop FOR per copia/riempimento)
• String Operations: Usato CONCAT (non operatore +)
• Input Validation: Controlli su range input e valori validi
• Error Handling: Gestione allarmi/errori appropriata
• Naming: Variabili con nomi descrittivi (non i, x, temp come nomi finali)
• Comments: Commenti su logica complessa o non ovvia
• Block Type: FC per logica stateless, FB per logica stateful
• Anti-Patterns: Controllato anti-patterns.md per evitare errori comuni

📝 Quick Reference / Riferimento Rapido

Keywords SCL:

• FUNCTION / FUNCTION_BLOCK – Definisci blocco
• VAR / VAR_INPUT / VAR_OUTPUT / VAR_TEMP – Sezioni dichiarazione
• BEGIN / END_FUNCTION / END_FUNCTION_BLOCK – Delimitatori
• IF / ELSIF / ELSE / END_IF – Condizionali
• CASE / OF / END_CASE – Switch statement
• FOR / TO / DOWNTO / BY / END_FOR – Loop enumerativo
• WHILE / END_WHILE – Loop pre-test
• REPEAT / UNTIL / END_REPEAT – Loop post-test
• EXIT / CONTINUE – Controllo loop
• RETURN – Uscita funzione

Operators:

• := – Assignment / Assegnazione input
• => – Output parameter / Parametro output
• = – Comparison / Confronto
• <> – Not equal / Diverso
• AND / OR / NOT – Logical operators
• & / | / XOR – Bitwise operators

Versione Skill / Skill Version: 2.0
Target: TIA Portal V20+ / S7-1500 / S7-1200
Standard: IEC 61131-3 SCL
Linguaggio / Language: Bilingual (Italian + English)
Architettura / Architecture: Progressive Disclosure (Core in SKILL.md, Details in references/)