Guia SCL S7-1200

1. Crie ou Abra um Projeto

No TIA Portal, crie um novo projeto (`Project → New`) ou abra um existente.

2. Adicione um Dispositivo (S7-1200)

Vá em `Add new device`, selecione `Controllers` e escolha sua CPU S7-1200 específica (ex: 1214C). A versão de firmware deve bater com o hardware real.

3. Crie um Bloco de Programa em SCL

Expanda `Program blocks`, clique duas vezes em `Add new block`. Escolha `Function (FC)` ou `Function block (FB)`. Importante: Em `Language`, selecione SCL.

4. Defina a Interface do Bloco (Parâmetros)

Use a área superior do editor para definir `Input`, `Output`, `InOut` e `Static` (variáveis com memória para FBs).

VAR_INPUT
    EnableProcess : BOOL;
    SetpointValue : REAL;
END_VAR

5. Escreva seu Código SCL

Escreva sua lógica entre `BEGIN` e `END_FUNCTION`.

IF #EnableProcess THEN
    #ProcessActive := TRUE;
ELSE
    #ProcessActive := FALSE;
END_IF;

6. Chame seu Bloco SCL (Ex: do OB1)

Arraste seu bloco SCL para dentro do OB1 (Main). Se for um FB, o TIA Portal pedirá para criar um iDB (Instance Data Block).

7. Compile e Faça o Download

Clique com botão direito no PLC → `Compile` → `Download to device`.

8. Monitore e Depure

Clique no ícone de "óculos" (Monitor on/off) para ver os valores das variáveis em tempo real enquanto o código executa.

Visualizador Interativo de Fluxo de Controle

Veja `IF` e `FOR` em ação. Clique nos botões para animar o fluxo. O ponto laranja (🟠) mostra a execução.

Estrutura de Blocos: Organização do Código

Tipos de Dados: SCL vs. C

Estruturas de Controle: Exemplos Comparativos

IF / THEN / ELSIF / ELSE

// SCL
IF #Temp > 30.0 THEN ... ELSIF ... ELSE ... END_IF;

// C
if (...) { ... } else if (...) { ... } else { ... }

CASE / OF / ELSE (Switch)

// SCL
CASE #Modo OF
    1: ... ;
    2,3: ... ;
    10..20: ... ;
ELSE ... ;
END_CASE;

// C
switch (Modo) {
    case 1: ... break;
    case 2: case 3: ... break;
    default: ... break;
}

Simulador Interativo

Acesso a Entradas e Saídas (I/O) - Detalhado

Interagir com o mundo real é a função primária do CLP. Existem duas maneiras principais:

• Tags Simbólicas (Recomendado): Nomes como "SensorNivel" associados a endereços (%I0.1). Facilita leitura e manutenção.
• Endereços Absolutos: Acesso direto como %Q0.0. Evite se possível.

// Acesso Padrão (Imagem de Processo - Rápido)
#Val := "Sensor_Pressao"; 

// Acesso Direto à Periferia (Lento, mas imediato)
#Val_Instantaneo := "Sensor_Pressao":P;

Normalização e Escalonamento (Analógicas)

Módulos analógicos convertem um sinal elétrico (ex: 4-20mA, 0-10V) em um número inteiro dentro do CLP. Para o S7-1200, essa faixa é tipicamente 0 a 27648 para sinais unipolares. Esse número bruto (INT) não significa muito diretamente (o que é 13824?). Precisamos convertê-lo para a unidade que faz sentido na aplicação (ex: °C, Bar, m).

Normalização (NORM_X): Pega o valor bruto e o mapeia para uma escala padrão de 0.0 a 1.0 (REAL). Pense nisso como calcular a "porcentagem" do valor dentro da sua faixa bruta.

• Se o bruto é 0, o normalizado é 0.0.
• Se o bruto é 27648, o normalizado é 1.0.
• Se o bruto é 13824 (metade), o normalizado é 0.5.

Escalonamento (SCALE_X): Pega o valor normalizado (0.0 a 1.0) e o mapeia para a faixa desejada em unidades de engenharia (ex: 0 a 150 °C).

• Se normalizado é 0.0, escalonado será o MÍNIMO da engenharia (ex: 0 °C).
• Se normalizado é 1.0, escalonado será o MÁXIMO da engenharia (ex: 150 °C).
• Se normalizado é 0.5, escalonado será a metade da faixa de engenharia (ex: 75 °C).

VAR
    "SensorNivel_Raw" AT %IW64 : INT; // Entrada bruta 0..27648
    Nivel_Normalizado : REAL;        // Resultado intermediário 0.0..1.0
    Nivel_Metros : REAL;           // Resultado final 0.0..12.0 m
END_VAR

// 1. Normalizar (INT -> REAL 0.0..1.0)
#Nivel_Norm := NORM_X(MIN := 0, VALUE := #Input_Raw, MAX := 27648);

// 2. Escalonar (REAL 0.0..1.0 -> Engenharia)
#Nivel_Metros := SCALE_X(MIN := 0.0, VALUE := #Nivel_Norm, MAX := 10.0);

Simulador de Temporizador TON

Uso de Blocos de Sistema (TON/CTU) e iDBs

Blocos como TON (Timer) e CTU (Contador) são FBs. Eles precisam de memória (iDB) para lembrar quanto tempo passou ou quantas contagens ocorreram.

VAR_STATIC 
    Timer1 : TON; // Instância do Timer
END_VAR

#Timer1(IN := #Start, PT := T#5s);
#Motor := #Timer1.Q;

Manipulação de Strings em SCL (Acordeão)

Funções para trabalhar com texto. Mais seguro que strings em C.

len := LEN('Teste'); // 5

res := CONCAT('Ola ', 'Mundo'); // 'Ola Mundo'

s := LEFT('ABCDE', 2); // 'AB'
s := MID('ABCDE', 2, 2); // 'BC' (Length, Start)

pos := FIND('SensorA', 'A'); // 7