Você está na página 1de 145

ÍNDICE

1 Introdução ao S7 300 .................................................................................................. 3


1.1 Conceitos de memória para S7 300............................................................................ 10
1.2 Estrutura de Hardware................................................................................................ 12
1.3 Endereçamento .......................................................................................................... 15
1.3.1 Entradas e saídas Digitais – DI/DO (Digital Input/Digital Output) ................................ 15
1.3.2 Entradas e saídas Analógicas – AI/AO (Analogic Input/Analogic Output) ................... 17
1.3.3 Memórias .................................................................................................................... 19
1.4 Tipo de dados ............................................................................................................. 23
1.5 Endereçamento indireto e Ponteiros ........................................................................... 24
1.5.1 Tipo de dado ANY ...................................................................................................... 27
2 Criando um novo projeto no SIMATIC Manager ........................................................ 28
2.1 Trabalhando com Multiproject ..................................................................................... 35
3 Linguagens de Programação para STEP7 300 .......................................................... 38
3.1 Instruções Booleanas ................................................................................................. 38
3.1.1 Ladder ........................................................................................................................ 38
3.1.2 Statement List (STL) ................................................................................................... 39
3.1.3 Function Blocks Diagram (FBD).................................................................................. 39
3.1.4 Exemplos de aplicação das linguagens Ladder, STL e FBD ....................................... 40
3.1.5 Memória elétrica ......................................................................................................... 41
3.1.6 Saídas Retentivas ...................................................................................................... 42
3.1.7 Contatos Impulsionais ................................................................................................ 43
3.1.8 Flanco Positivo ........................................................................................................... 44
3.1.9 Flanco Negativo .......................................................................................................... 45
3.2 Instruções de Temporização....................................................................................... 46
3.2.1 Temporizador com retardo na ativação S_ODT .......................................................... 49
3.2.2 Temporizador retentivo com retardo na ativação S_ODTS ......................................... 50
3.2.3 Temporizador com retardo na desativação S_OFFDT ................................................ 51
3.2.4 Temporizador de pulso estendido S_PEXT ................................................................ 53
3.3 Instruções de Contagem de Pulsos ............................................................................ 53
3.3.1 Contador Crescente e Decrescente S_CUD ............................................................... 54
3.3.2 Contador Crescente S_CU ......................................................................................... 55
3.3.3 Contador Decrescente S_CD ..................................................................................... 56
3.3.4 Counters em STL ....................................................................................................... 57
3.4 Instruções de Comparação ......................................................................................... 58
2
Programação avançada com CLP Siemens S7 300

3.4.1 Instruções de comparação em STL ............................................................................ 60


3.5 Instrução de Transferência de dados .......................................................................... 61
3.6 Instrução de Transferência de dados em STL ............................................................ 62
3.7 Instruções Matemáticas com números inteiros (INT) e reais (REAL) .......................... 62
3.7.1 Integer function ........................................................................................................... 62
3.7.2 Floating point function................................................................................................. 64
3.7.3 Instruções matemáticas em STL................................................................................. 67
3.8 Instruções lógicas – operações booleanas ................................................................. 67
3.8.1 Operações booleanas em STL ................................................................................... 69
4 Estruturas de Programa............................................................................................. 70
4.1 Organization Blocks – OB’s ........................................................................................ 70
4.2 Data Blocks – Blocos de Dados (DB) ......................................................................... 70
4.3 Criando um Data Block Shared .................................................................................. 71
4.4 Programação Orientada – Blocos de Programa.......................................................... 75
4.5 Criando uma FC – Function ........................................................................................ 76
4.6 Criando um FB – Function Block ................................................................................ 90
4.6.1 Instance FB ................................................................................................................ 90
4.6.2 Multi-Instance FB...................................................................................................... 102
4.6.3 Criando uma FB em Statement List – STL................................................................ 109
5 Introdução à linguagem de programação GRAPH para S7 300 ............................... 114
5.1 Criando um bloco de programa em linguagem grafcet - GRAPH .............................. 116
5.2 Instruções básicas para S7 GRAPH ......................................................................... 123
5.3 Exemplo de aplicação............................................................................................... 123
6 Source File – Utilizando atributos para proteger um bloco de programa .................. 131
7 Referencia Cruzada no S7 300 – Cross References ............................................... 138
8 Forçando Variáveis .................................................................................................. 144

Festo Didactic • E320S


3
Programação avançada com CLP Siemens S7 300

PROGRAMANDO COM SIEMENS S7-300

1 Introdução ao S7 300

O CLP S7-300 da Siemens é um controlador modular utilizado em aplicações


centralizadas ou distribuídas, interligando os mais variados dispositivos de campo através
de seus módulos de entrada e saída, digitais ou analógicas. Pode ainda ser integrado a
outros dispositivos de controle através de rede industriais, com ampla gama de
protocolos disponíveis.

Figura 1.1 – Controle centralizado com S7 300 Siemens.

Festo Didactic • E320S


4
Programação avançada com CLP Siemens S7 300

Figura 1.2 – Controle descentralizado por meio de rede industrial com S7 300.

O S7 300 possui interface com os seguintes softwares:

Step 7 Lite – trata-se de uma ferramenta mais simples para implementação de


programas em aplicações centralizadas. Esta ferramenta não é mais usual na atualidade.

Figura 1.3: Ambiente de programação do Step 7 Lite

Festo Didactic • E320S


5
Programação avançada com CLP Siemens S7 300

Step 7 Manager – É uma ferramenta mais completa para gerenciamento de


projetos em automação, permitindo a integração de todos os dispositivos programáveis
em um único ambiente, assim como a estruturação de projetos com redes industriais.

Figura 1.4 - Ambiente de programação do Step 7 Manager

A comunicação entre o meio de programação usando um computador pessoal


(PC) e o CLP ocorre por meio de um conversor serial de RS 232 para RS 485
denominado PC adapter, que se comunica por meio de um protocolo proprietário da
Siemens denominado MPI (Multi-Point Interface), conforme Figura 1.5. Esta comunicação
também pode ocorrer via rede Profibus (conforme Figura 1.7) ou Ethernet através da
placa de rede do computador (conforme Figura 1.8). O programa de usuário, com todos
os blocos de programa e blocos dados, quando transferido para o CLP é gravado num
cartão de memória denominado MMC (Micro Memory Card). Os LED’s na parte lateral do
cabo indicam o estado de comunicação entre o dispositivo programador e o CLP.

Festo Didactic • E320S


6
Programação avançada com CLP Siemens S7 300

Figura 1.5 – PC adapter MPI.

Figura 1.6 – Programação via protocolo MPI.

Festo Didactic • E320S


7
Programação avançada com CLP Siemens S7 300

Figura 1.7 - Programação via rede DP.

Figura 1.8 - Programação via rede Ethernet.

Festo Didactic • E320S


8
Programação avançada com CLP Siemens S7 300

Os recursos e especificações técnicas do CLP, como quantidade de entradas e


saídas, interfaces de operação, interfaces de comunicação, quantidade de endereços
para temporizadores e contadores, tamanho da imagem de entradas e saídas, dentre
outras, variam de acordo com o modelo da CPU.

As CPU’s Siemens S7 300 são definidas como Compactas ou Standard. Uma


CPU compacta possui entradas e saídas digitais ou analógicas integradas, enquanto uma
CPU standard não possui entradas e saídas integradas, necessitando de cartões
adicionais, módulos de I/O, para fazer interface com os dispositivos do meio externo. A
Figura 1.9 mostra duas CPU’s Siemens S7 300.

Figura 1.9 – Modelos de CPU Siemens.

Os LED’s na parte superior frontal da CPU indicam o estado do CLP, ou seja, o


modo de operação da CPU. Abaixo segue a descrição das funções de cada LED.

SF – System Fault: indica falha de software ou hardware;


BF – Bus Fault: indica falha na rede DP;
DC5V – Alimentação 5 volts: indica que a alimentação de 5 volts da CPU e dos
módulos está ok.

Festo Didactic • E320S


9
Programação avançada com CLP Siemens S7 300

FRCE – Force: indica modo de trabalho forçado de uma variável.


RUN – indica que o programa está em execução.
STOP – quando ligada constantemente indica a parada de execução do
programa. Quando está piscando numa frequência de 0,5Hz indica que a CPU necessita
de um reset em sua memória devido a algum erro ou falha do sistema.

Se a CPU solicitar um reset de memória, fazendo o STOP LED piscar lentamente,


pode-se resetar o MMC através da chave seletora de modo, como segue:

1. Posicione a chave para posição MRES e mantenha pressionada nesta posição


até o STOP LED parar de piscar (ficar aceso constantemente – isto deverá levar alguns
segundos);
2. Após o LED STOP acender e permanecer aceso, aguarde 3 segundos, solte a
chave e volte a pressioná-la para a posição MRES. O LED de STOP pisca para indicar
que a formatação está em processo.

Figura 1.10 – CPU Siemens S7 300.

Festo Didactic • E320S


10
Programação avançada com CLP Siemens S7 300

Por meio da chave seletora é possível alterar o modo de funcionamento do CLP


para RUN (executa o programa), STOP (para a execução do programa) ou MRES (reseta
as variáveis da memória do controlador).

1.1 Conceitos de memória para S7 300

A Figura 1.11 mostra a divisão das áreas de memória existentes no controlador,


contendo três áreas de memórias distintas.

Figura 1.11 – Estrutura do MMC.

Load Memory (Memória de Carga): Está localizada no MMC (Micro Memory


Card). Ela armazena o programa de usuário com seus blocos de programa (OBs, DBs,
FCs, etc) assim como a configuração de hardware. O conteúdo desta memória influencia
diretamente no funcionamento da CPU.

System Memory (Memória do Sistema): Contém os endereços dos Bit Memories,


Timers e Counters; da imagem de processo (PI - process image) das inputs e outputs;
assim como do Local Data (variáveis temporárias da pilha local, tipo TEMP). A imagem
de processo das entradas e saídas do controlador é acessada através da memória de
sistema da CPU.

Festo Didactic • E320S


11
Programação avançada com CLP Siemens S7 300

Main Memory (Memória Principal): É usada para execução do código de


programa de usuário. O programa somente roda na Memória Principal, memória RAM
integrada à CPU.

O MMC (Micro Memory Card) é um memory card que contém a memória de carga
(Load Memory) da CPU, onde é armazenado o programa de usuário com todos os
blocos de programa necessários para sua execução, como FCs, FBs, SFCs, etc.

Após o download o programa de usuário é armazenado permanentemente na


load memory. Porém, as partes relevantes do programa são executadas em outra área
de memória, denominada Work Memory, que se trata da Main Memory, memória RAM
integrada a CPU.

A Figura 1.12 mostra os destinos dos dados transferidos após um download para
o controlador.

Figura 1.12 – Dados que são gravados no MMC.

Festo Didactic • E320S


12
Programação avançada com CLP Siemens S7 300

1.2 Estrutura de Hardware

Os módulos Siemens para S7 300 são montados numa estrutura perfilada de aço
denominada Rack, e interligados através de um conector de barramento (Bus Conector)
para comunicação entre eles e com a CPU, conforme Figura 1.13.

A montagem dos módulos também pode ser feitas num rack com barramento
ativo, onde o bus conector é substituído por um rack que interliga os módulos
paralelamente para fins de alimentação (Power supply) e comunicação, permitindo a
“troca a quente” dos módulos.

Figura 1.13 – Montagem dos módulos no rack.

Festo Didactic • E320S


13
Programação avançada com CLP Siemens S7 300

Os cartões Siemens para o S7 300 são divididos em três grupos:

SM (Signal Modules) – Compreendem os módulos de entradas e saídas digitais


(DI/DO) ou analógicas (AI/AO).

CP (Communication Processor) – Compreendem os módulos de comunicação


para rede ASi, Profibus (DP, PA, FMS), Ethernet Industrial e PtP (rede ponto-a-ponto).

FM (Function Module) – Compreendem os módulos de entrada e saída com


funções especiais para dispositivos de controle de posição, entradas e saídas rápidas de
freqüência, etc.

Figura 1.14 – Estrutura do rack Siemens.

Um exemplo de configuração de rack é mostrado na Figura 1.15.

Figura 1.15 – Exemplo de configuração do rack.

Festo Didactic • E320S


14
Programação avançada com CLP Siemens S7 300

Uma CPU suporta até quatro racks com até oito módulos cada, como mostra a
Figura 1.16.

Figura 1.16 – CPU controlando até 4 racks.

A comunicação entre os racks é feita por meio de um módulo denominado IM


(interface module). Esta montagem utiliza uma fonte por rack.

Festo Didactic • E320S


15
Programação avançada com CLP Siemens S7 300

1.3 Endereçamento

1.3.1 Entradas e saídas Digitais – DI/DO (Digital Input/Digital Output)

As entradas digitais são capazes de detectar uma variação de estado lógico


correspondente a uma variação de tensão “discreta”, proveniente de dispositivos de
sinais como botoeiras, sensores de proximidade, chaves fim-de-curso, dentre outros. Da
mesma forma, as saída digitais enviam sinais discretos de tensão para os dispositivos
que deverão ser acionados, como sinalizadores luminosos ou sonoros, relés, solenóides,
etc. A variação de estado lógico entre os níveis “0” e “1” neste texto será representada
pela sigla RLO, cujo significado é Resultado Lógico do Operador.

Figura 1.17 – Sinais digitais

Para endereçar pontos de entrada e saídas digitais o S7 300 usa o modelo


“Byte.Bit”, onde cada módulo é dividido em 1 Byte de dados e endereçado bit-a-bit,
conforme Figura 1.18. As interfaces de entrada são identificadas pela letra I (input),
enquanto as interfaces de saída são identificadas pela letra Q (output). Fisicamente, elas
são distribuídas nos módulos conforme Figura 1.20.

Figura 1.18 – Endereçamento de entradas digitais.

Festo Didactic • E320S


16
Programação avançada com CLP Siemens S7 300

Uma representação mais completa de endereços de I/O é mostrada na Figura


1.19.

Figura 1.19 – Endereçamento de entradas e saídas digitais.

Figura 1.20 – Endereçamento de entradas e saídas digitais nos cartões Siemens.

O acesso aos endereços de entrada e saída ocorre numa área da memória de


sistema denominada Imagem de Processo (PI – Process Image) do CLP, corresponde
a uma região na memória do controlador onde a escrita e a leitura dessas interfaces

Festo Didactic • E320S


17
Programação avançada com CLP Siemens S7 300

ocorre dentro do cycle scan (ciclo de varredura) do CPU. Cada modelo de CPU possui
um limite de tamanho de imagem. As CPU’s da família S7-300 normalmente reservam
128 bytes de imagem, ou seja, os endereços de input e output podem ser endereçados
neste caso de IB0 a IB127 no caso de entradas e de QB0 a QB127 no caso de saídas.
Fora da imagem de processo da CPU os endereços são lidos na área periférica (PI -
peripheral input e PQ - peripheral output) consumindo um tempo maior de varredura. O
acesso à periferia do CLP é feito somente em unidades de Byte e Word, por exemplo:
PIB256, PQW268.

1.3.2 Entradas e saídas Analógicas – AI/AO (Analogic Input/Analogic


Output)

As entradas analógicas são capazes de detectar uma variação de sinal contínuo


de tensão nas faixas de -10V a +10V e de 0V a 10V, ou de corrente nas faixas de 0mA a
20mA ou 4mA a 20mA, em função da variação de uma grandeza física medida por meio
de um transdutor, como termopares, sensores analógicos de pressão, células de carga,
etc. As saídas analógicas são capazes de gerar uma variação de tensão de 0V a 10V ou
de corrente de 0mA a 20mA para controlar dispositivos externos como drives de potência,
por exemplo.

Figura 1.21 – Sinal analógico

O endereçamento das entradas e saídas analógicas no S7 300 é feito através das


variáveis periféricas, ou seja, fora da imagem de entradas e saídas do controlador. PIW
(Peripheral Input Word) para entradas analógicas e PQW (Peripheral Output Word) para

Festo Didactic • E320S


18
Programação avançada com CLP Siemens S7 300

saídas analógicas. Essas variáveis têm o tamanho de uma Word e trabalham com
valores inteiros (INT) de 16 bits. As variáveis analógicas normalmente começam a ser
endereçadas a partir do endereço 256 para entradas e saídas, conforme Figura 1.22.

Figura 1.22 – Entradas e saídas analógicas.

Um mapa completo com os endereços de entradas e saídas digitais e analógicas


sugeridos é mostrado na Figura 1.23.

Figura 1.23 – Mapeamento de entradas e saídas digitais nos racks.

Festo Didactic • E320S


19
Programação avançada com CLP Siemens S7 300

1.3.3 Memórias

Conforme mostrado no item 1.1, a CPU do S7 300 trabalha com três áreas de
memória: Load Memory (MMC), System Memory e Main Memory.

Mas podemos simplificar descrevendo apenas duas áreas de memória para o


controle das informações na CPU: Work Memory e Load Memory, conforme Figura 1.24.

Figura 1.24 – Simplificação das áreas de memória da CPU.

• Work Memory: corresponde à memória RAM do controlador, para


armazenamento das variáveis não-retentivas.
• Load Memory: corresponde à memória EEPROM (MMC) do controlador,
para armazenar o programa de usuário e também as variáveis retentivas.

O S7 300 possui ainda três variáveis de memórias distintas: M (bit Memories), D


(Data Block) e L (Variáveis temporárias, Local Data – pilha local) para leitura e escrita
de dados do programa de usuário, além dos acumuladores ACCU1 e ACCU2 (área de
transferência de dados usada pelo programa para o fluxo de informações) e Area
Registers AR1 e AR2 (registradores de endereço para ponteiros).

Festo Didactic • E320S


20
Programação avançada com CLP Siemens S7 300

As memórias do tipo M (Bit Memories) são memórias de uso geral, para


armazenamento de dados do programa de usuário. Elas podem ser acessadas por
qualquer bloco de programa, para escrita ou para leitura de dados. Essas memórias
podem ser retentivas ou não. Esta condição pode ser estabelecida durante a
configuração do hardware.

As variáveis do tipo L são definidas como temporárias no programa (variáveis


temporárias, tipo TEMP) e são variáveis não-retentivas, portanto, os valores
armazenados nessas variáveis são apagados no ato da saída do bloco de programa.

No S7 300 essas memórias são alocadas em áreas de 8 bits, ou seja, cada


alocação de memória do tipo M possui tamanho de um 1 Byte, e são denominadas como
MB (Memory Byte) conforme Figura 1.25.

Figura 1.25 – Alocações de memórias no S7 300.

Os MB’s podem ser endereçados por Byte (8 bits), Word (16 bits), Double Word
(32 bits) ou bit-a-bit, como mostra a Figura 1.26.

Festo Didactic • E320S


21
Programação avançada com CLP Siemens S7 300

Figura 1.26 – Formatos das memórias.

Quando endereçadas bit-a-bit elas poder ser utilizadas como “flags” ou “saídas
auxiliares” nos blocos de programa, como mostra o exemplo de programa da Figura 1.27.

Figura 1.27 – Exemplo de aplicação das memórias como “Flags”.

É possível a ocorrência de conflito de dados quando o usuário utiliza no mesmo


programa memórias com tamanhos e endereços diferentes, mas que possuem bits em
comum entre elas, como mostra a Figura 1.28.

Festo Didactic • E320S


22
Programação avançada com CLP Siemens S7 300

Figura 1.28 – Conflito de dados.

É recomendável, para o exemplo acima, que o usuário enderece essas memórias


com números pares, ou seja, a cada dois bytes: MW0, MW2, MW4...Afim de evitar
conflito de dados.

As memórias do tipo L (Stack) são destinadas ao armazenamento temporário de


variáveis. No S7 300 essas áreas de memória são denominadas TEMP. Variáveis do tipo
TEMP podem ser declaradas no programa de usuário, dentro de OB’s, FC’s e FB’s, como
será mostrado adiante.

Existem ainda áreas de memórias denominadas ACC1 e ACC2 (acumuladores),


onde os resultados de operações lógicas são armazenados provisoriamente.

É possível carregar essas memórias por meio dos comandos L (Load) e T


(Transfer), comuns na linguagem STL de programação, como será abordado nos tópicos
seguintes. O conteúdo desses registros pode ser visualizado através do comando View
PLC Register na barra de menus, conforme Figura 1.29.

Festo Didactic • E320S


23
Programação avançada com CLP Siemens S7 300

Figura 1.29 – Memória L temporária (stack).

As memórias do tipo D (Data Blocks) são áreas de memória utilizadas para o


armazenamento de dados que são processados dentro de blocos de programas, aos
quais elas são vinculadas quando criadas. Mas também podem ser utilizadas para
armazenamento de dados de qualquer outro bloco de programa, como as memórias de
uso geral. Mais detalhes sobre essas memórias, os Data Blocks, serão abordados no
item 4.2.

1.4 Tipos de dados

Todos os dados e variáveis declaradas no programa de usuário devem ser


identificados por um tipo de dado específico. O S7 300 possui uma grande gama de tipo
de dados sendo eles divididos em três grupos distintos:

Elementares – são tipos de dados mais básicos utilizados para a declaração de


constantes e variáveis simples. A tabela a seguir mostra os tipos de dados elementares
mais usuais no S7 300.

Complexas – Consistem da combinação dos tipos de dados elementares em


estruturas mais complexa de dados. Variáveis complexas são normalmente declaradas
em Data Blocks (DB’s). Compreende as seguintes estruturas de dados:

Festo Didactic • E320S


24
Programação avançada com CLP Siemens S7 300

Parâmetros – Compreendem as variáveis locais criadas para transferência de dados


em FC’c e FB’s.

• DATE_AND_TIME – Variáveis tipo tempo e data.

Exemplo: DT#1993-12-25-8:12:34.567

• STRING[n] - Variáveis tipo ASCII (caracteres)

Exemplo: STRING[7] ‘SIMATIC’

• ARRAY – Estrutura tipo matriz de dados

Exemplo: ARRAY[1..10]

As variáveis complexas podem ainda ser do tipo:

• STRUCT
• UDT (user-defined data types)
• FBs and SFBs

1.5 Endereçamento indireto e Ponteiros

O endereçamento indireto de variáveis é feito através de ponteiros. Um ponteiro é


utilizado para apontar o endereço de uma variável, permitindo que a mesma variável seja
acessa com endereços diferentes repetidas vezes a cada varredura de programa.

Festo Didactic • E320S


25
Programação avançada com CLP Siemens S7 300

No Step7 os ponteiros são descritos pela letra “P” seguida de “#”, conforme
mostra a Figura 1.30.

Exemplo: P#23.7 – Este ponteiro aponta para o endereço Byte=23 e Bit=7 de uma
variável qualquer.

Quando uma variável é carregada com um ponteiro ela recebe o conteúdo


daquele endereço, apontado pelo ponteiro. O ponteiro pode ser incrementado e
decrementado no programa, permitindo acessar o conteúdo de outras variáveis. A Figura
1.31 mostra um diagrama com as possibilidades de endereçamento indireto que são
possíveis de ser efetuados no SIMATIC Step7.

Os tipos de ponteiro para o Step7 são:

• Ponteiro 16-bit para Endereçamento Indireto de Memória


Para acesso indireto de memória de temporizadores, contadores e DBs abertos.

• Ponteiro 32-bit p/ Endereçamento Indireto de Memória e Registrador


Ponteiro 32 bit de área interna para acesso indireto de memória e registrador de
endereços em PI, PQ, I, Q, M, DB, DI e L (pilha local).
Ponteiro 32 bit de área cruzada para acesso indireto do registrador de endereços
PI, PQ, I, Q, M, DB, DI, L e V (Pilha de dados locais do bloco chamado).

• Ponteiro 48-bit (Tipo de Dado POINTER)


Tipo de dado próprio para passagem de parâmetros para blocos (FBs e FCs)
Contém, em adição ao ponteiro 32-bit de área-cruzada, a declaração do número do DB.

• Ponteiro 80-bit (Tipo de Dado ANY)


Tipo de dado próprio para passagem de parâmetros para blocos (FBs e FCs).
Contém, em adição ao ponteiro 32-bit de área-cruzada, a declaração do número do DB,
tipo de dado e fator de repetição.

A Figura 1.30 mostra a estrutura de um ponteiro de 16 bit e 32 bit. A Figura 1.31


mostra todas as possibilidades de acesso direto e indireto à memória do controlador.

Festo Didactic • E320S


26
Programação avançada com CLP Siemens S7 300

Figura 1.30 – Estrutura do ponteiro

Figura 1.31 – Tipos de endereçamento: Direto e Indireto.

Festo Didactic • E320S


27
Programação avançada com CLP Siemens S7 300

Exemplo de aplicação de endereçamento indireto e ponteiros:

1.5.1 Tipo de dado ANY

Os data types tipo ANY são ponteiros de 80 bits utilizados para passagem de
parâmetros para blocos de programas, como FCs e FBs.

As variáveis do tipo ANY podem assumir qualquer formato de variável e são


endereçadas com ponteiros que permitem o acesso indireto a memórias, para fins de
escrita e leitura.

Exemplo:
P#M40.0 BYTE 10

Neste exemplo deseja-se acessar uma área de memória com extensão de 10


Bytes que vai de MB40 até MB49.

Festo Didactic • E320S


28
Programação avançada com CLP Siemens S7 300

2 Criando um novo projeto no SIMATIC Manager

Como foi dito anteriormente, o software SIMATIC Manager trata-se de um


ambiente integrado para criação de projetos em automação. Ele permite a integração de
todos os dispositivos e softwares da Siemens em um único ambiente de programação. O
ambiente inicial do software é mostrado na Figura 2.1.
Na estrutura do SIMATIC Manager, todos os blocos de programas são criados
dentro de um projeto. Portanto, para criar um programa é necessário antes criar um
projeto novo, conforme Figura 2.2.

Figura 2.1 – Tela inicial do SIMATIC Manager

Festo Didactic • E320S


29
Programação avançada com CLP Siemens S7 300

Figura 2.2 – Criando um novo projeto no S7 300.

Uma janela se abrirá solicitando o nome do projeto a ser criado (Figura 2.3. Deve-
se inserir o nome do projeto e clicar em ok.

Figura 2.3 – Inserindo o nome do projeto.

Festo Didactic • E320S


30
Programação avançada com CLP Siemens S7 300

O projeto com o nome escolhido é então criado e mostrado, conforme Figura 2.4.

Figura 2.4 – Criando um novo projeto.

Dentro desse projeto será criado um programa baseado numa CPU modelo S7
300. É necessário inserir o modelo CPU, através do comando:
Insert Station 2 SIMATIC 300 Station
Conforme Figura 2.5 ou clicando com o botão direito sobre o ícone do projeto,
conforme Figura 2.6.

Figura 2.5 – Inserindo uma Estação da família 300.

Festo Didactic • E320S


31
Programação avançada com CLP Siemens S7 300

Figura 2.6 - Inserindo uma Estação da família 300.

Uma vez inserido o modelo da estação com a qual se vai trabalhar deve-se
configurar o hardware para ela, ou seja, informar ao programa o modelo da CPU e os
módulos existentes no rack fisicamente. Para isso deve-se abrir o ícone com o nome do
projeto onde foi inserido o tipo de estação (Figura 2.7) e abrir a janela de configuração de
hardware (Hardware Configuration, Figura 2.8) com um duplo click sobre o ícone
mostrado na Figura 2.7.

Figura 2.7 – Abrindo o configurador de hardware.

Festo Didactic • E320S


32
Programação avançada com CLP Siemens S7 300

Dentro da janela de configuração de hardware deve-se primeiramente inserir o


rack, conforme Figura 2.8.

Uma vez inserido o rack, basta selecionar cada módulo correspondente ao


hardware físico e “arrastar” até o seu respectivo slot conforme a Figura 2.8 e Figura 2.9,
seguindo a ordem mostrada no item 1 e na Figura 1.14. O hardware completo
configurado é mostrado na Figura 2.10 com 1 e com 2 racks.

Figura 2.8 – Inserindo o rack.

Figura 2.9 – Inserindo a CPU no rack.

Festo Didactic • E320S


33
Programação avançada com CLP Siemens S7 300

Figura 2.10 – Hardware configurado com 1 rack sem fonte Siemens (a) e com 2
racks interligados por meio do IM e com fonte Siemens (b).

As CPU’s compactas trazem como configuração padrão (default) os endereços de


entrada e saídas com valor inicial referente ao último slot do último rack.

É possível alterar os endereços das entradas e saídas do CLP clicando duas


vezes sobre o ícone DI/DO no slot onde está a CPU para o respectivo rack. Uma janela
deverá abrir e o usuário poderá alterar o inicio dos endereços das entradas e saídas,
desmarcando a opção System default da CPU compacta conforme mostra a Figura 2.11.

Festo Didactic • E320S


34
Programação avançada com CLP Siemens S7 300

Figura 2.11 – Alterando os endereços de entradas e saídas.

As alterações feitas deverão ser salvas e o hardware deve ser compilado, para
isto basta clicar sobre o ícone Salvar, como mostra a Figura 2.12.

Figura 2.12 – Salvando e compilando o hardware.

Após salvar e compilar a configuração de hardware uma nova pasta contendo os


blocos de programa fica disponível, com o primeiro bloco de programa de usuário, OB1
(Organization Block 1), que é o Main Program do S7 300, como mostra a Figura 2.13.

Festo Didactic • E320S


35
Programação avançada com CLP Siemens S7 300

Figura 2.13 – Estrutura de um projeto criado para S7 300.

2.1 Trabalhando com Multiproject

Usando o conceito Multiproject do SIMATIC STEP 7 Professional é possível criar


vários projetos dentro de uma única pasta, ajudando na organização dos programas de
usuário.

Após criar um novo arquivo, na janela “New File” clique sobre a aba Multiproject,
conforme figura Figura 2.14. Insira um nome no campo “Name” e clique em “OK”

Festo Didactic • E320S


36
Programação avançada com CLP Siemens S7 300

Figura 2.14 – Criando um “Multiproject”

Clique com o botão direito sobre a pasta com o nome do projeto e escolha a
opção “Creat in Multiproject” para inserir um novo projeto dentro desta pasta, conforme
Figura 2.15.

Figura 2.15 – Inserindo um projeto.

Festo Didactic • E320S


37
Programação avançada com CLP Siemens S7 300

Insira um nome ao projeto e clique em “OK”, conforme mostra a Figura 2.16

Figura 2.16 – Inserindo um projeto.

A Figura 2.17 mostra como fica estrutura Multiproject criada. A partir deste ponto
deve-se configurar o hardware conforme mostrado nos itens anteriores, a partir da Figura
2.5.

Figura 2.17 – Estrutura na forma de Multiproject.

Festo Didactic • E320S


38
Programação avançada com CLP Siemens S7 300

3 Linguagens de Programação para STEP7 300

O Step7 300 permite a criação de programas em quatro linguagens: LADDER,


FBD (Function Blocks Diagram), STL (Statement List) e GRAPH (Grafcet).

O set de instruções básicas do Step7 300 é dividido nos seguintes grupos:

• Bit logic - instruções Booleanas, cujo o tratamento das informações bit a bit
• Comparator – instruções de comparação para variáveis no formato INT (16 bits),
DWORD (32 bits) e REAL (32 bits)
• Converter – Instruções de conversão de formato de dados
• Counter – Instruções de contagem de pulsos
• DB call – Instruções de chamada de Data Blocks
• Jumps – instruções de salto de programa
• Integer function – instruçõoes matemáticas com números inteiros de 16 bits
• Floating point function – instruções matemáticas com números reais de 32 bits
• Move – instrução de transferência de dados
• Program control – instruções de controle de programa
• Shift/Rotate – instruções para “rotacionar” dados
• Status bit – bits com funções especiais do registro status
• Timers – instruções de temporização
• Word logic – instruções para operações booleanas entre dados do tipo Word e
DWord.

3.1 Instruções Booleanas

3.1.1 Ladder

Linguagem de programação baseada em lógica de comando elétrico.

Festo Didactic • E320S


39
Programação avançada com CLP Siemens S7 300

Instrução NA – o contato normal aberto será fechado quando o valor do bit


<address> for igual a “1” (RLO=1).

Instrução NF – o contato normal fechado será aberto quando o valor do bit


<address> for igual a “1” (RLO=1).

3.1.2 Statement List (STL)

Linguagem de programação baseada em texto estruturado.

A <Bit, Word, DWord> - Operação lógica AND


AN <Bit, Word, DWord> - Operação lógica AND NOT
O <Bit, Word, DWord> - Operação lógica OR
ON <Bit, Word, DWord> - Operação lógica OR NOT
= <Output Bit> - Saída booleana
L <Bit, Word, DWord> - Carrega valor em ACC1
T <Bit, Word, DWord> - Transfere de ACC1 para uma memória
JU <Label> - Salto incondicional para outra linha de programa definida por um
Label.
JC <Label> - Salto condicional se o resultado de uma operação lógica resultar
em 1.
JCN <Label> - Salto condicional se o resultado de uma operação lógica resultar
em 0.

3.1.3 Function Blocks Diagram (FBD)

Linguagem de programação baseada em lógica digital booleana. Sua estrutura é


baseada em blocos lógicos, como mostrado a seguir:

Festo Didactic • E320S


40
Programação avançada com CLP Siemens S7 300

3.1.4 Exemplos de aplicação das linguagens Ladder, STL e FBD

Para inserir uma instrução em linguagem Ladder ou FBD, basta clicar sobre a
instrução no catálogo à esquerda e arrastar até o ambiente de programação, como
mostrado na Figura 3.1.

Figura 3.1 – Instruções booleanas.

Festo Didactic • E320S


41
Programação avançada com CLP Siemens S7 300

Neste exemplo, o RLO da saída Q0.0 será igual a “1” quando o RLO da entrada
I0.0 também for igual a “1”.

3.1.5 Memória elétrica

Neste exemplo é mostrado como colocar contatos NA e NF em paralelo na


linguagem Ladder, conforme Figura 3.2.

Figura 3.2 – Memórias elétricas.

Festo Didactic • E320S


42
Programação avançada com CLP Siemens S7 300

Neste exemplo, o RLO da saída Q0.0 será igual a “1” quando o RLO das duas
entradas I0.0 e I0.1 forem iguais a “1”, simultaneamente. A saída permanece ligada
mesmo quando os contatos endereçados em I0.0 e I0.1 seja abertos, devido o contato de
“selo” de Q0.0 em paralelo com os dois contatos NA. O contato NF I0.2 abre quando seu
RLO é igual a “1”, interrompendo a passagem do sinal e desenergizando a saída Q0.0,
que permanece desacionada.

3.1.6 Saídas Retentivas

Outra solução possível para o circuito mostrado no exemplo anterior é mostrado


neste exemplo, usando as saídas retentivas, S (set) e R (reset).

A Figura 3.3 mostra a aplicação das saídas retentivas em um circuito.

Quando o RLO de I0.0 é igual a “1” a saída Q0.0 é setada e permanece ligada
(RLO=1).
Quando o RLO de I0.1 é igual a “1” a saída Q0.0 é resetada e permanece
desligada (RLO=0).

Festo Didactic • E320S


43
Programação avançada com CLP Siemens S7 300

Figura 3.3 – Saídas retentivas.

3.1.7 Contatos Impulsionais

Também denominados como flancos, estes contatos são instruções capazes de


detectar a borda de subida ou a borda de descida de um sinal, na mudança do RLO de
um operando booleano, como uma instrução NA ou NF, transferindo para a saída um
pulso com período de duração muito curto, igual a um scan (período de uma varredura)
do CLP.

Festo Didactic • E320S


44
Programação avançada com CLP Siemens S7 300

É necessário um memory bit (MByte.bit) para registrar o estado anterior do RLO


da entrada.

3.1.8 Flanco Positivo

Em STL:

A I0.0 //Testa se RLO de I0.0 = 1


FP M0.0 //Flanco positivo, detecta borda de subida
= Q0.0 //RLO de Q0.0 = 1 por um período de um scan.

Festo Didactic • E320S


45
Programação avançada com CLP Siemens S7 300

3.1.9 Flanco Negativo

Em STL:

A I0.0 //Testa se RLO de I0.0 = 1


FN M0.0 //Flanco negativo, detecta borda de descida
= Q0.0 //RLO de Q0.0 = 1 por um período de um scan.

Festo Didactic • E320S


46
Programação avançada com CLP Siemens S7 300

3.2 Instruções de Temporização

As instruções de temporização têm a função gerar um retardo na ativação ou


desativação de um determinado dispositivo.
Elas são divididas em cinco tipos para os controladores da família S7 300 da
Siemens, são eles:

S_ODT: Siemens On Delay Timer – Temporizador com retardo na ativação.


S_OFFDT: Siemens OFF Delay Timer – Temporizador com retardo na
desativação.
S_PULSE: Siemens Pulse – Temporizador de pulso
S_PEXT: Siemens Extended Pulse – Temporizador de pulso estendido
S_ODTS: Siemens Retentive On Delay Timer – Temporizador retentivo com
retardo na ativação.

Os temporizadores têm uma área de memória reservada na CPU de 16 bits, ou


seja, uma WORD para cada endereço de temporizador. A quantidade de endereços
disponíveis para temporizadores depende da CPU utilizada, para a maioria delas são 256
endereços disponíveis, de T0 a T255.

A Figura 3.4 mostra a configuração de um bloco temporização em linguagem


Ladder.

Figura 3.4 – Parâmetros de um temporizador em linguagem ladder.

Festo Didactic • E320S


47
Programação avançada com CLP Siemens S7 300

Na parte superior do bloco é atribuído o seu endereço (Timer Address), à


esquerda do bloco estão suas entradas e à direita estão suas saídas.

A entrada S é uma entrada do tipo booleana para o acionamento do temporizador,


quando o RLO de S sofre uma mudança de 0 para 1 o temporizador é iniciado.
A entrada TV (timer Value) armazena o valor de tempo a ser contado. O
parâmetro de tempo para o S7 300 tem a seguinte sintaxe,

S5T#aH_bM_cS_dMS

onde:
a, b, c, d são constantes definidas pelo usuário;
H = horas, M = minutos, S = segundos, MS = milisegundos.

O valor de tempo máximo que pode ser atribuído ao temporizador é 9990


segundos, ou 2H_46M_30S.

A base de tempo é selecionada automaticamente em função do valor de tempo


atribuído. A divisão dos bit’s da memória dos temporizadores é mostrada na Figura 3.5.

Figura 3.5 – Registro de armazenamento dos valores de tempo.

Festo Didactic • E320S


48
Programação avançada com CLP Siemens S7 300

O parâmetro de tempo em TV pode também ser atribuído conforme a sintaxe


abaixo:

W#16#<tbcd>

Onde:
t é a base de tempo;
b, c, d = valor de tempo em BCD (HEX).

Exemplo: W#16#13FF

3FFHEX = 1023DEC

Base tempo x valor = 0.1 segundo x 1023 = 102,3 segundos

Festo Didactic • E320S


49
Programação avançada com CLP Siemens S7 300

3.2.1 Temporizador com retardo na ativação S_ODT

A saída Q do temporizador será acionada (RLO=1) depois de decorrido o tempo


parametrizado em TV (S5T#...), a partir do instante em que a entrada S do bloco for
ativada (RLO=1). A entrada deve permanecer ativa para que o bloco conte o tempo
programado e ligue a saída. Ao desacionar sua entrada (RLO=0) a saída será resetada
também (RLO=0).

Um exemplo de aplicação deste temporizador é mostrado na Figura 3.6.

Festo Didactic • E320S


50
Programação avançada com CLP Siemens S7 300

Figura 3.6 – Exemplo de temporizadores em linguagem Ladder, STL e FBD.

3.2.2 Temporizador retentivo com retardo na ativação S_ODTS

Festo Didactic • E320S


51
Programação avançada com CLP Siemens S7 300

A saída Q do temporizador será acionada (RLO=1) depois de decorrido o tempo


parametrizado em TV a partir do instante em que o RLO da entrada S do bloco for “1”. A
saída permanecerá ativa mesmo se a entrada S for desacionada, e será desligada
somente no instante em que o RLO da entrada R (reset) for “1”.

3.2.3 Temporizador com retardo na desativação S_OFFDT

Festo Didactic • E320S


52
Programação avançada com CLP Siemens S7 300

Quando o RLO da entrada S for “1” a saída Q do temporizador será acionada


(RLO=1). Enquanto o RLO da entrada S permanecer em “1” o temporizador não inicia a
contagem. A saída Q só será desligada depois de decorrido o tempo parametrizado em
TV, a partir do instante em que o RLO da entrada S mudar de “1” para “0”.

Temporizador de pulso S_PULSE

Quando o RLO da entrada S for “1” a saída Q do temporizador será acionada


(RLO=1) e a contagem de tempo iniciada. Enquanto o RLO da entrada S permanecer em
1 o temporizador continua contando até que se atinja o tempo programado em TV, e
então a saída Q será desligada. A saída também será resetada caso quando o RLO da
entrada for “0”.

Festo Didactic • E320S


53
Programação avançada com CLP Siemens S7 300

3.2.4 Temporizador de pulso estendido S_PEXT

Quando o RLO da entrada S for “1” o bloco liga a saída (RLO=1) e inicia a
contagem de tempo. Mesmo que o RLO da entrada mude de “0” para “1” o bloco continua
a contagem. A saída será desligada depois de decorrido o tempo programado em TV.

3.3 Instruções de Contagem de Pulsos

Os blocos contadores são utilizados para registrar pulsos elétricos.

São três os tipos de contadores para o S7 300 da Siemens:

S_CU: Siemens Counter Up – Contador Crescente


S_CD: Siemens Counter Down – Contador Decrescente
S_CUD: Siemens Counter Up and Down – Contador Crescente e Decrescente

Festo Didactic • E320S


54
Programação avançada com CLP Siemens S7 300

Os contadores têm uma área de memória reservada na CPU de 16 bits, assim


como os temporizadores, ou seja, uma WORD para cada endereço de contador. A
quantidade de endereços disponíveis para contadores depende da CPU utilizada, para a
maioria delas são 256 endereços disponíveis, de C0 a C255.

3.3.1 Contador Crescente e Decrescente S_CUD

O valor de contagem em PV tem a seguinte sintaxe: C# <Nº Inteiro>.

As entradas CU e CD recebem e registram os pulsos para contagem crescente e


decrescente respectivamente.

A entrada S (set) carrega o valor de contagem armazenado em PV no registro do


contador C0. Ao receber um pulso na entrada CD o contador decrementa uma unidade
no valor de contagem e ao receber um pulso na entrada CU o contador incrementa uma

Festo Didactic • E320S


55
Programação avançada com CLP Siemens S7 300

unidade no valor de contagem. O limite superior de contagem é 999 e o limite inferior é


zero.

O RLO da saída Q será igual a 1 sempre que o valor de contagem for maior que
zero. A saída do contador só será resetada quando o valor da contagem for igual a zero.

O valor de contagem será atualizado em memórias através das saídas CV e


CV_BCD.

O contador será resetado quando o RLO da entrada R for igual a 1. O valor de


contagem é zerado e a saída terá seu RLO = 0.

3.3.2 Contador Crescente S_CU

A entrada S (set) carrega o valor de contagem armazenado em PV no registro do


contador C0. Ao receber um pulso na entrada CU o contador incrementa uma unidade no
valor de contagem, a partir do valor pressetado em PV, até o limite superior de contagem
(999). O RLO da saída Q será igual a 1 sempre que o valor de contagem for maior que
zero. A saída do contador só será resetada quando o valor da contagem for igual a zero.

O valor de contagem será atualizado em memórias através das saídas CV e


CV_BCD.

Festo Didactic • E320S


56
Programação avançada com CLP Siemens S7 300

O contador será resetado quando o RLO da entrada R for igual a 1. O valor de


contagem é zerado e a saída terá seu RLO = 0.

3.3.3 Contador Decrescente S_CD

A entrada S (set) carrega o valor de contagem armazenado em PV no registro do


contador C0. Ao receber um pulso na entrada CD o contador decrementa uma unidade
no valor de contagem a partir do valor presetado até zero. O RLO da saída Q será igual a
1 sempre que o valor de contagem for maior que zero. A saída do contador só será
resetada quando o valor da contagem for igual a zero.

O valor de contagem será atualizado em memórias através das saídas CV e


CV_BCD.

O contador será resetado quando o RLO da entrada R for igual a 1. O valor de


contagem é zerado e a saída terá seu RLO = 0.

Um exemplo de programa utilizando contadores é mostrado na Figura 3.7.

Festo Didactic • E320S


57
Programação avançada com CLP Siemens S7 300

Figura 3.7 – Exemplo de programa com contador decrescente.

3.3.4 Counters em STL

Em STL os contadores são representados por CU (counter up) e CD (Counter


Down). Outras instruções como L, R e S são utilizadas para o controles dos contadores.
L – carrega os valores em ACCU1.
R – Reseta o contador.
S – Seta o contador com o valor carregado em ACCU1.

Festo Didactic • E320S


58
Programação avançada com CLP Siemens S7 300

Exemplo:

L C#14 //Carrega o valor C#14 em ACCU1;


A I 0.1 //Checa o RLO de I0.1, se RLO = 1, então;
S C1 //Carrega o contador C1 com o valor de ACCU1;

A I 0.0 //Checa o RLO de I0.0, se RLO = 1, então


CD C1 //Decrementa o contador C1

AN C1 //Quando C1=0, então;


= Q 0.0 //O RLO de Q0.0 será igual a 1

3.4 Instruções de Comparação

Essas instruções realizam uma comparação matemática entre o conteúdo de


registros e valores constantes quando o RLO de sua entrada é “1”. Se o resultado da
comparação matemática retornar verdadeiro, uma saída será acionada (RLO=1).

No catálogo de instruções os comparadores aparecem divididos em tres grupos,


que são os comparadores para valores inteiros de dezesseis bits (INT), para valores
inteiros de 32 bits (DINT) e para valores reais (REAL) também de 32 bits, conforme
mostra a Figura 3.8.

Figura 3.8 – Instruções de comparação.

Festo Didactic • E320S


59
Programação avançada com CLP Siemens S7 300

Exemplos de aplicação:

Quando o RLO da entrada for “1” a comparação será realizada. O bloco compara
se o conteúdo de MW0 é maior ou igual ao conteúdo de MW2, se o resultado da
comparação matemática retornar verdadeiro a saída Q4.0 será setada.

Quando o RLO da entrada for “1” a comparação será realizada. O bloco compara
se o conteúdo de MD0 é maior ou igual ao conteúdo de MD4, se o resultado da
comparação matemática retornar verdadeiro a saída Q4.0 será setada.

Festo Didactic • E320S


60
Programação avançada com CLP Siemens S7 300

Quando o RLO da entrada for “1” a comparação será realizada. O bloco compara
se o conteúdo de MD0 é maior ou igual ao conteúdo de MD4, se o resultado da
comparação matemática retornar verdadeiro e o RLO da entrada for igual a “1” a saída
Q4.0 será setada.

3.4.1 Instruções de comparação em STL

Em STL as comparações também são feitas entre variáveis do tipo INT, DINT e
REAL. Os valores a serem comparados são carregados temporariamente dentro dos
acumuladores ACCU1 e ACCU2 por meio das instrução L (Load).
As comparações matemáticas possíveis são:

== igual
<> ACCU1 diferente de ACCU2
> ACCU1 maior que ACCU2
< ACCU1 menor que ACCU2
>= ACCU1 maior ou igual a ACCU2
<= ACCU1 menor ou igual a ACCU2

Em STL pode-se carregar valores do tipo HEX para comparação com números
inteiros tipo INT.

Exemplo de comparação do tipo INT:


L MW10 //Carrega o conteúdo de MW10 (16-bit)
L W#16#FF //Carrega o valor FF Hexa (16-bit)
>I //Compara se ACCU2 (MW10) é maior (>) que ACCU1 (W#16#FF)
= M 2.0 //RLO = 1 se MW10 > W#16#FF

Festo Didactic • E320S


61
Programação avançada com CLP Siemens S7 300

Exemplo de comparação do tipo DINT:


L MD10 //Carrega o conteúdo de MD10 (32-bit)
L MD14 //Carrega o conteúdo de MD14 (32-bit)
>D //Compara se ACCU2 (MD10) é maior (>) que ACCU1 (MD14)
= M 2.0 //RLO = 1 se MD10 > MD14

Exemplo de comparação do tipo REAL:


L MD10 //Carrega o conteúdo de MD10
L 1.36E+02 //Carrega a constante 1.36E+02
>R //Compara se ACCU2 (MD10) é maior (>) que ACCU1 (1.36E+02)
= M 2.0 //RLO = 1 se MD10 > 1.36E+02

3.5 Instrução de Transferência de dados

Esta instrução é utilizada para transferir valores constantes ou conteúdo de


registros para outros registros.

Exemplo de aplicação:

Festo Didactic • E320S


62
Programação avançada com CLP Siemens S7 300

Quando o RLO da entrada I0.0 for igual a “1” o conteúdo de MW10 é transferido
para DW12 e a saída Q4.0 é igual a “1” para confirmar a execução da operação.

3.6 Instrução de Transferência de dados em STL

A tranferência de dados em STL PE realizada por meio das instruções L (Load) e


T (Transfer). A instrução L carrega o valor em ACCU1 e a instrução T transfere o
conteúdo de ACCU1 para uma memória.

Exemplo:
L B#16#3F //Carrega o valor B#16#3F HEXA em ACCU1;
T MB10 //Transfere o conteúdo de ACCU1 (B#16#3F) para MB10.

3.7 Instruções Matemáticas com números inteiros (INT) e reais (REAL)

As operações matemáticas no S7 300 são divididas em dois grupos:

Integer function – Operações matemáticas com números inteiros: correspondem


as operações aritméticas básicas para números inteiros de 16 bits ou 32 bits.

Floating point function – Operações matemáticas com valores reais: além das
operações básicas são incluídas também as operações logarítimicas, trigonométricas,
dentre outras.

3.7.1 Integer function

Festo Didactic • E320S


63
Programação avançada com CLP Siemens S7 300

Os blocos matemáticos para operações com números inteiros possuem três


entradas e duas saídas. A entrada EN quando acionada (RLO=1) permite a execução da
operação, realizando a respectiva operação entre as entradas IN1 e IN2. O resultado da
operação é transferido para um registro declarado em OUT. Quando a operação é
realizada a saída ENO é acionada (RLO=1).

Operações Básicas:

Exemplo de aplicação:

Quando o RLO de I0.0 for “1” o conteúdo da memória MW0 é somado ao


conteúdo de MW2. O resultado desta operação é armazenado em MW10 e a saída Q4.0
será setada.

Festo Didactic • E320S


64
Programação avançada com CLP Siemens S7 300

Como essas operações trabalham apenas com valores inteiros, existe uma função
complementar à função de divisão denominada MOD_DI, capaz de recuperar o valor
“restante” de uma divisão entre dois números inteiros de 32 bits e armazenar numa
memória.

Quando I0.0 é acionado, o valor restante da divisão entre MD0 e MD4 (MD0/MD4)
será armazenado em MD10.

3.7.2 Floating point function

Festo Didactic • E320S


65
Programação avançada com CLP Siemens S7 300

As funções matemáticas com ponto flutuante executam operações com números


reais de 32 bits.

Operações Básicas:

Exemplo:

Quando o RLO de I0.0 for “1” o conteúdo da memória MD0 é somado ao conteúdo
de MD2. O resultado desta operação é armazenado em MD10 e a saída Q4.0 será
setada.

Festo Didactic • E320S


66
Programação avançada com CLP Siemens S7 300

Operações Trigonométricas:

Demais Operações:

Festo Didactic • E320S


67
Programação avançada com CLP Siemens S7 300

3.7.3 Instruções matemáticas em STL

As operações matemáticas podem ser realizadas entre números inteiros e reais.


Para números inteiros (INT) usa-se a sintaxe: +I, -I, *I, /I
Para números Reais (REAL): +R, -R, *R, /R

Neste exemplo será realizada a soma entre dois valores inteiros.

L IW10 //Carrega o valor de IW10 em ACCU1


L MW14 //Carrega o valor de ACCU1 em ACCU2 e o valor de MW14 em ACCU1.

+I //Soma o valor de ACCU2 com ACCU1 e armazena o resultado em ACCU1

T MW20 //Armazena o valor de ACCU1 em MW20.

3.8 Instruções lógicas – operações booleanas

Estas instruções realizam a comparação de um par de words (16 bits) ou Double


Word (32 bits) bit a bit de acordo com a lógica booleana do bloco.

As instruções lógicas são divididas em dois grupos de acordo com o tamanho da


informação: W – WORD (16 bits) e DW – DWORD (32 bits).

Até três tipos de operações lógicas podem ser realizadas: AND, OR e XOR.

Festo Didactic • E320S


68
Programação avançada com CLP Siemens S7 300

Exemplo:

Quando o RLO de I0.0 for “1” o bloco efetua a operação lógica AND entre o
conteúdo de MW0 e o valor FFHEX. O resultado desta operação é armazenado em MW2 e
a saída Q4.0 será setada.

MW2 = (MW0) AND (FFHEX)

Festo Didactic • E320S


69
Programação avançada com CLP Siemens S7 300

Esta operação, em particular, é denominada “mascara” e é bastante comum e


usual em programação quando se deseja “filtrar” uma informação a fim de coletar apenas
os bits que são relevantes para uma determinada operação. Neste exemplo foram
aproveitados apenas os oito primeiros bits da Word MW0.

3.8.1 Operações booleanas em STL

O exemplo à seguir demonstra como é realizado a lógica AND entre dois


registros. O mesmo conceito pode ser aplicado às demais operações lógicas.

L IW20 //Carrega o conteúdo de IW20 em ACCU1.


L IW22 //Carrega o conteúdo de ACCU1 em ACCU2 e IW22 em ACCU1.

AW //ACCU2 AND ACCU1 = ACCU1

T MW 8 //Armazena o resultado de ACCU1 em MW8.

Festo Didactic • E320S


70
Programação avançada com CLP Siemens S7 300

4 Estruturas de Programa

4.1 Organization Blocks – OB’s

Os Organizations Blocks (Blocos de Organização) são a interface entre o sistema


operacional da CPU e o programa de usuário. OB's são utilizados para organizar o
programa de usuário.

Os OB’s são executados de forma cíclica seguindo uma ordem de prioridade.

No Step7 300 cada OB tem uma função específica, sendo o OB1 o Main Program
e portanto o primeiro na lista de prioridade de execução. O OB1 é executado ciclicamente
pela CPU. Através do OB1 podem-se chamar outros blocos de programa, como as
Functions – FC’s e os Functions Block’s – FB’s, como subrotinas dentro de OB1.

Além de OB1 existem outras OB’s com funções específicas na CPU 31x. Elas são
divididas de acordo com suas funções: OB’s de inicialização (OB100, 101, 102), OB’s de
interrupção de tempo e data (OB10 a OB17), OB’s de interrupção cíclicas programadas
(OB30 a OB38), OB’s de interrupção de hardware (OB40 a OB47), OB’s de diagnóstico
de falhas (OB80 a OB87), dentre outras.

4.2 Data Blocks – Blocos de Dados (DB)

Os data blocks (DB’s) ou blocos de dados são blocos utilizados apenas para
armazenar dados, como memórias. Diferentemente dos blocos de programas, como os
que serão apresentados a seguir, os blocos de dados não possuem instruções e portanto
não executam rotinas de programa, eles apenas armazenam dados das variáveis dos
blocos de programas, como OB’s, FC’s e FB’s.

Os data blocks podem ser criados em dois formatos: Instance Data Blocks (DB
instance) ou Shared Data Blocks (DB Shared).

Festo Didactic • E320S


71
Programação avançada com CLP Siemens S7 300

Uma DB shared é um DB que pode ser acessado e compartilhado por qualquer


bloco de programa criado pelo usuário. Qualquer bloco de programa pode ler e escrever
dados nas variáveis da DB shared. Esta DB é também denominada como DB Global.

Uma DB instance é um DB dedicado a um Function Block FB. Todos os dados


e parâmetros das variáveis locais do FB são armazenados no seu DB instance, que
passa a ser uma “memória particular” deste FB. A denominação ‘instance’ representa um
bloco FB chamado, por exemplo, se um bloco FB10 for chamado 3 vezes haverá 3
instâncias deste bloco, cada uma com um Data Block.

A Figura 4.1 mostra as duas estruturas aplicadas. No exemplo da figura [] foi


criada um DB Shared (DB 20) que é compartilhada por três blocos de programas: FC10,
FC11 e FB12. Uma outra DB foi criada (DB 112) como Instance de FB12, essa DB é
acessada apenas por FB12, que escreve dados nela.

Figura 4.1 – Diferentes estruturas de um Data Block.

4.3 Criando um Data Block Shared

Um DB Shared pode ser criado através da barra de menus em Insert S7


Block Data Block, conforme Figura 4.2, ou clicando com o botão direito em
Blocks Insert New Object Data Block, conforme Figura 4.3.

Festo Didactic • E320S


72
Programação avançada com CLP Siemens S7 300

Figura 4.2 – Inserindo um Data Block.

Figura 4.3 - Inserindo um Data Block.

Uma janela deverá abrir, onde será configurado o tipo do Data Block a ser criado,
conforme mostra a Figura 4.4. Neste exemplo será mostrado como criar um DB shared
para ser usada por qualquer bloco de programa.

Festo Didactic • E320S


73
Programação avançada com CLP Siemens S7 300

Figura 4.4 – Escolhendo o formato de um Data Block.

As informações que devem ser atribuídas a DB, conforme a Figura 4.5, são:

Figura 4.5 – Configurando variáveis em um DB.

No exemplo mostrado na Figura 4.6 foram criadas 6 variáveis de tipos


diferentes, consequentemente com tamanhos diferentes dentro da DB, cada uma alocada
num endereço próprio criado automaticamente no momento da criação da variável.

Festo Didactic • E320S


74
Programação avançada com CLP Siemens S7 300

Figura 4.6 - Configurando variáveis em um DB.

Para acessar estas variáveis e ler o seu conteúdo ou escrever um dado deve-se
utilizar a seguinte sintaxe:

Exemplo: ler os dados das variáveis criadas na DB da Figura 4.6.

Para ler 1 BIT: DB1.DBX0.0 Acessa os dados de VAR_1 (BIT = 1)


Para ler 1 BYTE: DB1.DBB1 Acessa os dados de VAR_2 (39 HEX)
Para ler 1 WORD: DB1.DBW2 Acessa os dados de VAR_3 (C4 HEX)
Para ler 1 DWORD: DB1.DBD4 Acessa os dados de VAR_4 (FF HEX)
Número Inteiro (16 bits) : DB1.DBW8 Acessa os dados de VAR_5 (10)
Número Real (32 bits): DB1.DBD10 Acessa os dados de VAR_6 (5,6)

Exemplo de Programa para ler e escrever dados numa DB:

Festo Didactic • E320S


75
Programação avançada com CLP Siemens S7 300

Figura 4.7 – Acessando as informações de um DB.

4.4 Programação Orientada – Blocos de Programa

O Step7 300 permite a criação de blocos de programas orientados como


subrotinas de um programa principal. Eles estão abaixo dos organization blocks (OB’s) na
hierarquia de programa e podem ser chamados como subrotinas de OB1 quantas vezes
for necessário.

A utilização de subrotinas torna o programa de usuário mais organizado evitando


a repetição de lógicas de controle dentro do programa principal, facilitando sua criação
bem como sua interpretação.

No Step7 300 existem duas estruturas distintas de blocos de programas,


denominadas como Functions (FC’s) e Functions Blocks (FB’s). Ambas estão abaixo
das OB’s na hierarquia de programa e devem ser acessadas por meio uma instrução de
chamada dentro de OB1, por exemplo.

Festo Didactic • E320S


76
Programação avançada com CLP Siemens S7 300

As Functions ou FC’s são blocos de programas que não possuem uma área de
memória própria designada para ela. Os dados de suas variáveis são armazenados na
pilha (L stack) do controlador e são perdidos ao fim de sua execução.

Os Functions Blocks ou FB’s são blocos de programas que possuem uma área de
memória dedicada do tipo Data Block ou DB designado para armazenar
permanentemente os dados de suas variáveis durante e após a sua execução. Essas
memórias são do tipo Instance Data Block, pois são dedicadas ao bloco de programa a
que estão associadas.

4.5 Criando uma FC – Function

Neste exemplo será mostrado como implementar um bloco de programa do tipo


FC como rotina padrão para partida de motores. O bloco deverá ser criado e chamado
quantas vezes forem necessárias dentro de OB1 possibilitando o acionamento de vários
motores diferentes usando a mesma rotina.

Para isto o bloco deverá ser criado com variáveis locais, que permitem a
transferência dos sinais dos endereços absolutos de OB1 para o bloco, assim como do
bloco para OB1.

As variáveis locais das FC’s podem ser do tipo IN, OUT, IN/OUT ou TEMP. Essas
variáveis podem ainda ter o formato BOOL (booleanas, variáveis discretas 0 ou 1),
informações do tipo BYTE, WORD, DWORD (Double Word), INT (números inteiros),
REAL (números reais com ponto flutuante), S5TIME (variáveis de tempo no formato
Siemens), dentre outras, conforme Figura 4.8.

Festo Didactic • E320S


77
Programação avançada com CLP Siemens S7 300

Figura 4.8 – Criando as variáveis locais de um bloco de programa FC.

As variáveis do tipo IN permitem a entrada de sinais que serão processadas


dentro do bloco. OUT são variáveis de saída utilizadas para retornar o valor processado
pelo bloco. Variáveis do tipo IN/OUT são usadas para passar informações para o bloco,
processá-las e armazenar o resultado na mesma variável.

As variáveis do tipo TEMP são variáveis temporárias armazenadas na pilha (L –


stack) da CPU apenas durante a execução do bloco.

RETURN permite o retorno de um valor (RET_VAL) ao término da execução do


bloco.

No exemplo sugerido o bloco de programa será criado usando uma FC. Foram
criadas para este bloco três variáveis do tipo IN, sendo S1 para ligar o motor, S0 para
desligar o motor e RT como contato do relé térmico de segurança em caso de
superaquecimento do motor. Como variável do tipo OUT foi criada apenas uma saída K
para o acionamento do contator de potencia, conforme mostra a Figura 4.9.

Festo Didactic • E320S


78
Programação avançada com CLP Siemens S7 300

A entrada EN é utilizada para habilitar o bloco e a saída ENO é setada quando o


bloco chega ao término de sua execução, podendo ser utilizada para habilitar outra
instrução ou outro bloco de programa na sequência.

Figura 4.9 – Bloco de programa para partida direta de motores.

Pode-se inserir uma FC através da barra de menus em Insert S7


Block Function, como mostra a Figura 4.10 ou clicando com o botão direito do mouse
sobre a pasta Blocks na árvore do projeto e seguindo os passos da Figura 4.11 para
inserir uma FC.

Figura 4.10 – Inserindo uma FC.

Festo Didactic • E320S


79
Programação avançada com CLP Siemens S7 300

Figura 4.11 - Inserindo uma FC.

Uma vez inserido um FC, como mostrado na Figura 4.11, deve-se selecionar a
linguagem de programação desejada para implementar a rotina de programa, neste
exemplo será usada a linguagem Ladder de programação, conforme Figura 4.12.

Ao criar o bloco pode-se inserir um nome simbólico (Symbolic Name) e


comentários para este, porém não é possível alterar a identificação do bloco de FC1 para
outro nome simbólico.

Na aba General – Part 2 podem-se inserir informações do criador do bloco e


versão do mesmo. O espaço mínimo ocupado pelo bloco na memória do controlador é
mostrado conforme Figura 4.13.

Festo Didactic • E320S


80
Programação avançada com CLP Siemens S7 300

Figura 4.12 – Selecionando a linguagem do bloco de programa.

Figura 4.13 – Propriedades do bloco de programa.

Festo Didactic • E320S


81
Programação avançada com CLP Siemens S7 300

Na aba Calls é mostrado se outros blocos de programas foram chamados dentro


deste como subprogramas, conforme mostra a Figura 4.14, neste exemplo, um function
block FB1 foi declarado como variável multiple instance dentro de um function block
FB10. Este método de estruturação de programa será mais bem detalhado
posteriormente neste texto.

Figura 4.14 – Descrição da estrutura dos blocos de programa criados num projeto.

Por fim, na aba attributes, Figura 4.15, podem ser inseridos atributos específicos
de controle dos blocos de programa, como por exemplo a ferramenta S7-pdiag, para que
o bloco seja capaz de processar diagnóstico de erros.

Festo Didactic • E320S


82
Programação avançada com CLP Siemens S7 300

Figura 4.15 – Configuração dos atributos de um bloco de programa.

Ao abrir o bloco devem-se declarar as variáveis locais conforme mostram as


Figura 4.16 até Figura 4.19. Em seguida basta inserir uma network e fazer o programa
que deverá executar a rotina proposta, Figura 4.20. Neste exemplo, a rotina proposta
deverá executar a função de partida direta de motores, com um botão para ligar o motor
(S1), um para desligar (S0) e o contato de um rele térmico de segurança e uma saída
para o acionamento do contator (RT), todas estas variáveis deverão ser declaradas como
booleanas (BOOL). As variáveis locais criadas dentro de uma FC ficam limitadas a 127
endereços no total.

Festo Didactic • E320S


83
Programação avançada com CLP Siemens S7 300

Figura 4.16 – variáveis locais de entrada do bloco.

Figura 4.17 – variáveis locais de saída do bloco.

Figura 4.18 – inserindo as instruções.

Festo Didactic • E320S


84
Programação avançada com CLP Siemens S7 300

Figura 4.19 – inserindo as variáveis locais.

O programa finalizado em FC1 é mostrado na Figura 4.20 com todas as suas


variáveis declaradas. A sintaxe “#” indica uma variável do bloco, e indica que esta
variável não se trata de um endereço absoluto.

Figura 4.20 – Programa para partida direta de motores.

Festo Didactic • E320S


85
Programação avançada com CLP Siemens S7 300

Após finalizar o programa, o mesmo deverá ser salvo e compilado, para isto,
basta clicar no ícone salvar, conforme Figura 4.21, e fechar o bloco.

Figura 4.21 – Salvando e compilando um FC.

O bloco de programa criado deverá ser chamado dentro de OB1 como rotina
padrão. Para isto, basta abrir o conteúdo de FC blocks dentro de OB1 e “arrastá-lo” para
a network criada, como mostram a Figura 4.22.

Figura 4.22 – Chamando o bloco FC criado em OB1.

Os dados a serem processados pelo bloco serão fornecidos através de endereços


absolutos em OB1. Os endereços absolutos podem ser relacionados a “nomes
simbólicos” por meio do Symbol Table. Para acessar o Symbol Table basta clicar sobre

Festo Didactic • E320S


86
Programação avançada com CLP Siemens S7 300

a pasta S7 Program na árvore de projeto, conforme Figura 4.23 ou na barra de menus


em Options Symbol Table dentro de qualquer bloco de programa do projeto, conforme
Figura 4.24.

As variáveis declaradas são endereços absolutos do CLP, ou seja, são endereços


de entradas e saídas físicas do equipamento, conforme mostra a Figura 4.25.

Figura 4.23 – Criando tabela de variáveis.

Figura 4.24 - Criando tabela de variáveis.

Festo Didactic • E320S


87
Programação avançada com CLP Siemens S7 300

Figura 4.25 – Symbol Table: lista de alocação de variáveis.

Uma vez declaradas as variáveis no Symbol Table, deve-se relacionar


cada uma a sua respectiva entrada ou saída no bloco, conforme Figura 4.26.

Figura 4.26 – Relacionando as variáveis locais com as variáveis absolutas.

Festo Didactic • E320S


88
Programação avançada com CLP Siemens S7 300

Figura 4.27 – Bloco de programa para partida de motores criado.

Uma vez criada, a Function FC1 pode ser chamada quantas vezes forem
necessárias dentro de OB1, conforme o programa da Figura 4.28.

Festo Didactic • E320S


89
Programação avançada com CLP Siemens S7 300

Figura 4.28 – Programa final usando a rotina criada em FC1.

Festo Didactic • E320S


90
Programação avançada com CLP Siemens S7 300

4.6 Criando um FB – Function Block

4.6.1 Instance FB

Assim como os Functions (FC), os FB’s são blocos de programa criados como
subrotinas de OB1 ou de outros blocos. Cada Instance Function
ons Block criado e
“chamado” dentro de OB1, por exemplo, necessita de um Data Block (DB) para o
armazenamento temporário ou permanente dos dados processados pelo bloco.
bloco Em
resumo, nessa estrutura cada FB tem uma área de memória do tipo Data Block reservada
e dedicada a ele, conforme mostram a Figura 4.29 e Figura 4.30.

Figura 4.29 – Estrutura Instance FB no S7 300.

Figura 4.30 – Estrutura Instance FB.

Festo Didactic • E320S


91
Programação avançada com CLP Siemens S7 300

Como exemplo de aplicação será criado um bloco de programa com a função de


contagem de pulsos externos para ligar uma saída qualquer do CLP, um contador do tipo
crescente, que será denominado Counter Up, conforme mostra a Figura 4.31.

Como padrão, estes blocos devem ter uma entrada para receber os pulsos
externos, denominada C_UP e declarada como variável BOOL, uma entrada SET
(BOOL) para carregar o valor de contagem registrado em PRESET (INT) na memória
interna do contador, uma entrada RESET (BOOL) para resetar a saída Q (BOOL) do
contador e zerar sua memória interna de registros de pulsos e uma saída para
monitoramento do valor da contagem atual VALOR (INT), além da entrada EN para
habilitar o bloco e uma saída ENO, padrões do bloco.

Figura 4.31 – Bloco de programa do contador crescente criado como Function


Block.

Os procedimentos para inserir um FB são os mesmos para inserir uma FC,


conforme mostrado na Figura 4.32 e Figura 4.33

Festo Didactic • E320S


92
Programação avançada com CLP Siemens S7 300

Figura 4.32 – Inserindo um FB.

Figura 4.33 – Inserindo um FB.

Ao criar a FB deve-se escolher a linguagem na qual o programa será


implementado e escolher se essa FB será do tipo Instance ou Multi-instance, marcando
ou desmarcando a opção indicada na Figura 4.34.

Festo Didactic • E320S


93
Programação avançada com CLP Siemens S7 300

Figura 4.34 – Configurando uma FB.

As variáveis locais de entrada e saída do bloco são declaradas conforme mostra


Figura 4.35 e Figura 4.36. Uma diferença que pode ser observada em relação ao bloco
do tipo FC é que as variáveis declaradas são automaticamente alocadas num endereço
do Data Block (DB) da FB.

Figura 4.35 – Declarando variáveis locais de um bloco FB.

Festo Didactic • E320S


94
Programação avançada com CLP Siemens S7 300

Figura 4.36 - Declarando variáveis locais de um bloco FB.

Além das variáveis de entrada IN e saída OUT, as FB’s possuem também


variáveis do tipo estáticas, STATIC VARIABLES, que são variáveis locais restritas
apenas para processamento de dados internos ao bloco e que possuem espaço
reservado dentro do seu Data Block (DB).

Para esta aplicação existem três variáveis estáticas, uma denominada MEMORIA
(INT), onde é registrada a contagem de pulsos, essa memória é incrementada conforme
o contador recebe os sinais em sua entrada C_UP. Há também uma variável denominada
REF (INT) que recebe o valor de referencia limite da contagem por meio da variável de
entrada PRESET (INT). Por último há uma variável denominada FLAG (BOOL) para
registro da borda de subida do sinal no flanco positivo (P) utilizado neste programa. A
declaração destas variáveis é mostrada na Figura 4.37.

Estas variáveis internas do bloco poderiam também ser declaradas como


variáveis do tipo TEMP (Temporary Data), porém elas não teriam uma área reservada
dentro da DB deste bloco e seus dados seriam então armazenados temporariamente na
pilha (L stack) apenas durante a execução do Function Block.

Festo Didactic • E320S


95
Programação avançada com CLP Siemens S7 300

Figura 4.37 – Variáveis locais declaradas como STAT.

A seguir, será mostrado o programa detalhado com a rotina de contagem de


pulsos implementada para este bloco.

Festo Didactic • E320S


96
Programação avançada com CLP Siemens S7 300

Na network 1 ao acionar a entrada #set do bloco o valor armazenado em #preset


é transferido para a variável interna #ref do bloco.

Na network 2, através da entrada #c_up o bloco recebe os pulsos. Ao ser


acionada a entrada #c_up a variável #memoria é comparada com o valor de referencia
(limite da contagem). Enquanto #memoria for menor que #ref o resultado da comparação
retorna verdadeiro e a saída da instrução de comparação retorna verdadeiro, gerando um
pulso na entrada da instrução de soma ADD, que soma 1 ao conteúdo do registro
#memoria e armazena no mesmo registro #memoria (variável tipo STAT). Toda vez que
que #c_up é acionado o registro memória é incrementado em uma unidade. O flanco
positivo antes da instrução ADD permite a passagem de apenas um pulso na borda de

Festo Didactic • E320S


97
Programação avançada com CLP Siemens S7 300

subida do sinal, não permitindo que o registro memória seja incrementado em mais de
uma unidade.

A variável #memória é incrementada e logo na sequência transferida para a


variável #valor do tipo OUT, que poderá ser lida pelo usuário.

Conforme ocorrem os incrementos, o registro #memoria torna-se igual a #ref,


portanto o resultado da comparação retorna falso na network 2, e o registro #memoria
deixa de ser incrementado. Na network 3 o resultado da comparação retorna verdadeiro
para igual (#memoria = #ref) e desta forma a saída #Q do bloco é setada e assim
permanece, até que a entrada #reset seja acionada na network 4, resetando #Q e
transferindo o valor 0 (zero) para os registros #memoria e #valor simultaneamente. Desta
forma, uma nova contagem poderá ser iniciada.

A rotina do bloco de programa FB1 deverá ser salvar afim de compilar o bloco.

Por se tratar de um Function Block é necessário associar a ele uma memória do


tipo DB (Data Block) que irá armazenar os dados de suas variáveis. Para inserir uma DB
basta selecionar a pasta blocks na árvore de projeto abrir a guia Insert S7 Block 4
Data Block na barra de menus, conforme mostra Figura 4.38.

Figura 4.38 – Criando um DB para o FB1.

Festo Didactic • E320S


98
Programação avançada com CLP Siemens S7 300

Para associar esta DB a um Instance FB selecione esta opção conforme Figura


4.39 e escolha o bloco ao qual a DB será associada, em seguida clique em OK.

Figura 4.39 – Vinculando o DB ao FB1.

O procedimento para criar uma DB instance de um FB pode também ser realizado


dentro de OB1 após o bloco ter sido chamado, para isto basta escrever o nome da DB no
cabeçalho do bloco, e se esta ainda não foi criada o programa o fará, conforme Figura
4.40.
Uma janela aparecerá afirmando que esta DB ainda não existe e perguntando se
o usuário deseja criá-la.

Festo Didactic • E320S


99
Programação avançada com CLP Siemens S7 300

Figura 4.40 – Criando o DB dentro de OB1.

Abra a pasta FB Blocks no catálogo de instruções, selecione o bloco e “arraste-o”


até a network criada, conforme Figura 4.41.

Figura 4.41 – Chamando o FB1 dentro de OB1.

No Symbol Table atribua os nomes simbólicos das variáveis aos endereços


absolutos que irão fazer interface com o bloco, conforme Figura 4.42, salve e feche a
aplicativo.

Festo Didactic • E320S


100
Programação avançada com CLP Siemens S7 300

Figura 4.42 – Tabela de variáveis criada para o bloco FB.

Associe a DB instance criada ao bloco e relacione as variáveis locais do


bloco aos endereços absolutos, conforme Figura 4.43.

A Figura 4.44 mostra o programa finalizado com o FB1 implementado


como rotina de programa de OB1. Este bloco poderá ser chamado quantas vezes o
usuário desejar dentro de OB1 ou dentro de outros blocos de programas.

Figura 4.43 – Parametrizando o bloco FB criado.

Festo Didactic • E320S


101
Programação avançada com CLP Siemens S7 300

Figura 4.44 – Programa final.

Conforme a rotina de programa implementada, este bloco de programa deverá


contar uma quantidade de 10 pulsos aplicados na entrada C_UP, isso deverá ocorrer
após o acionamento da entrada SET, que carrega a memória interna do bloco com o
valor de PRESET. Após serem registrados 10 pulsos na entrada C_UP do contador sua
saída Q é setada e permanece nesse estado indefinidamente, até que a entrada RESET
seja acionada desligando a saída e possibilitando uma nova contagem. Durante a
contagem o valor da contagem será atualizado na saída VALOR do contador e poderá
ser lido em MW12.

Festo Didactic • E320S


102
Programação avançada com CLP Siemens S7 300

4.6.2 Multi-Instance
Instance FB

A estrutura de Multiplas instancias (Multi-Instance) permite


ermite que vários blocos
bloco de
programa FB compartilhem o mesmo Data Block dentro de outro FB criado,
criado otimizando a
estrutura de programa criado apenas como instance, mostrada anteriormente.
Apesar de compartilharem
artilharem o mesmo DB, os blocos de programa possuem
diferentes áreas de memória dentro desta DB. Como cada variável de cada bloco possui
uma alocação diferente dentro do mesmo data block, portanto não há o risco de conflito
de informações.

A estrutura multi-instance
instance (Figura 4.45) consiste em chamar um bloco de
programa FB (FB1 por exemplo) dentro de outro FB (FB10 por exemplo) como variável
estática deste. Desta forma,
forma cada FB1 passa a ser uma variável interna de FB10
FB1 e ocupa
uma área específica dentro do data block que será criado apenas para FB10 e
compartilhado com cada bloco FB1 chamado.
chamado

Festo Didactic • E320S


103
Programação avançada com CLP Siemens S7 300

Figura 4.45 – Estrutura Multi-Instance FB.

Para criar uma FB multi-instance insira


a uma nova FB, conforme Figura 4.46, e
marque a opção “Mul.
Mul. Inst. Cap.”
Cap. ao lado da identificação
ão do bloco, conforme Figura
4.47.

A primeira FB criada será chamada de FB10 e dentro dela serão chamados os


blocos FB1 como variáveis estáticas. Ambas as FB’s criadas devem ser multi-instance.
multi

Festo Didactic • E320S


104
Programação avançada com CLP Siemens S7 300

Figura 4.46 – Inserindo uma FB.

Figura 4.47 – Criando um FB Multi-instance.

Festo Didactic • E320S


105
Programação avançada com CLP Siemens S7 300

A rotina de programa que será implementada dentro de FB1 será a mesma usada
no exemplo dado para a criação da FC, um programa criado para comando de partida
direta de motores. A Figura 4.48 mostra o programa implementado.

Figura 4.48 – Bloco de programa para partida direta de motores criado em FB1.

Dentro de FB10, em interface, crie uma variável tipo STAT com o nome de
motor_1 e no Data Type digite FB1, desta forma, o bloco de programa FB1 será uma
variável estática dentro de FB10 e ocupará uma área dentro da DB que será criada para
este bloco, conforme Figura 4.49.

Festo Didactic • E320S


106
Programação avançada com CLP Siemens S7 300

Figura 4.49 – FB1 como variável estática de FB10.

No catálogo de instruções, os dois blocos FB1 mult-instance criados aparecem


dentro da pasta Multiple instances. Para chamar estas rotinas de programa basta clicar e
“arrastá-las” para as networks criadas em FB10, conforme Figura 4.50.

Figura 4.50 – FB1 como variável Multi Instance de FB10.

Festo Didactic • E320S


107
Programação avançada com CLP Siemens S7 300

Pode-se criar a tabela de variáveis (Symbol Table) para alocar os endereços


absolutos do CLP às variáveis locais do bloco criado, como mostra a Figura 4.51

Figura 4.51 – Criando uma tabela de variáveis para o bloco de programa multi-
instace.

O programa final dentro de FB10 é mostrado na Figura 4.52.

Festo Didactic • E320S


108
Programação avançada com CLP Siemens S7 300

Figura 4.52 – Bloco de programa FB10 criado com a estrutura multi-instance.

Depois de criado, o bloco de programa FB10 pode então ser chamado dentro de
OB1 e um Data Block deverá ser criado para ele, conforme Figura 4.53.

Figura 4.53 – Chamando o bloco de programa FB10 Multi-instance em OB1.

Festo Didactic • E320S


109
Programação avançada com CLP Siemens S7 300

4.6.3 Criando uma FB em Statement List – STL

Além da linguagem Ladder os Function Blocks podem ser criados também em


liguagem STL (Statement List), FBD (Function Block Diagram), e GRAPH (Graficet).

Os procedimentos a seguir mostram como implementar um bloco de programa FB


em linguagem STL.

No momento da criação do bloco escolha a opção STL para implementação do


bloco, conforme Figura 4.54.

Figura 4.54 – Criando um bloco de programa FB em linguagem STL.

Para o comando de partida de motores deve-se criar as mesmas variáveis locais


conforme mostrado no 4.5, como mostra a Figura 4.55. O program em linguagem STL é
mostrado na Figura 4.56.

Festo Didactic • E320S


110
Programação avançada com CLP Siemens S7 300

Figura 4.55 – Criando as variáveis locais do bloco.

Figura 4.56 – Rotina do bloco criada na linguagem STL.

Festo Didactic • E320S


111
Programação avançada com CLP Siemens S7 300

Figura 4.57 – Relação entre as linguagens Ladder e STL.

Uma vez criado o bloco de programa ele deverá ser chamado como subrotina de
OB1, que também será implementado em linguagem STL, conforme mostrado na Figura
4.58.

Figura 4.58 – Criando OB1 também em linguagem LADDER.

Festo Didactic • E320S


112
Programação avançada com CLP Siemens S7 300

Para chamar uma FB ou FC em linguagem STL deve-se utilizar a instrução CALL


e inserir o nome do bloco seguido de ‘,’ (vírgula) e do seu respectivo Data Block,
pressionando Enter em seguida, conforme mostra a Figura 4.59. Uma janela solicitando
a criação da DB deverá aparecer (caso o usuário não tenha criado uma DB instance
previamente para o bloco).

Figura 4.59

As variáveis locais criadas para este FB deverão aparecer como segue e o


usuário deverá relaciona-la a endereços absolutos, conforme Figura 4.60

Figura 4.60 – Relacionando as variáveis locais e as variáveis absolutas.

Festo Didactic • E320S


113
Programação avançada com CLP Siemens S7 300

O programa finalizado é mostrado na Figura 4.61. A rotina implementada em FB1


foi chamada por duas vezes em OB1, cada bloco chamado com o seu respectivo
Instance Data Block, para o acionamento de dois motores distintos.

Figura 4.61 – Rotina de partida de motores implementada em linguagem STL.

Festo Didactic • E320S


114
Programação avançada com CLP Siemens S7 300

5 Introdução à linguagem de programação GRAPH para S7 300

A linguagem de programação GRAPH ou Grafcet está disponível em toda linha de


controladores S7 300 e 400.

O grafcet da Siemens é desenvolvido dentro de um bloco de programa FB, que


será executado em OB1 como subprograma.

O grafcet foi desenvolvido para o controle de comandos sequenciais. A linguagem


é baseada na execução sequencial de blocos com tarefas predefinidas, ao contrário da
execução cíclica da linguagem Ladder ou STL, permitindo que os blocos sejam
executados um por vez, etapa por etapa do processo, tornando a estrutura de programa
mais simples e eficiente.

A estrutura de programa em grafcet é constituída de três elementos básicos:

• Etapa
• Ação
• Transição

Figura 5.1 – Estrutura básica da linguagem GRAPH.

Dentro de cada etapa serão executadas as ações, que representam o


acionamento ou desacionamento de dispositivos, temporização, etc. O programa só
muda de uma etapa para outra quando houver uma condição de transição, que pode ser

Festo Didactic • E320S


115
Programação avançada com CLP Siemens S7 300

representada por uma operação lógica booleana, o resultado de uma comparação


matemática ou uma condição de tempo.

O exemplo da figura [] mostra uma aplicação simples da linguagem grafcet para


ligar e desligar uma saída Q0.0 através de duas entradas. O endereço de entrada I0.0
liga Q0.0, enquanto I0.1 desliga Q0.0.

Figura 5.2

No exemplo mostrado o programa começa executando a etapa inicial e


permanece nesta etapa até que a condição de transição T1 seja verdadeira, ou seja,
quando o RLO de I0.0 for “1”. Se a condição de transição T1 for verdadeira, o programa
deixa a etapa inicial e executa a etapa 1 E1, setando a saída Q0.0. O programa
novamente permanece nesta etapa até que a condição de transição T2 seja verdadeira.
Quando o RLO de I0.1 for “1” o programa sai da etapa E1 e executa a etapa E2,
resetando a saída Q0.0.

Festo Didactic • E320S


116
Programação avançada com CLP Siemens S7 300

5.1 Criando um bloco de programa em linguagem grafcet - GRAPH

Para criar um programa em grafcet primeiros deve-se criar um novo FB e escolher


a na opção de linguagens GRAPH, conforme Figura 5.3.

Figura 5.3 – Criando um programa em graph.

O ambiente para a criação do programa em GRAPH é mostrado na Figura 5.4.

Festo Didactic • E320S


117
Programação avançada com CLP Siemens S7 300

Figura 5.4 – Ambiente de programação em GRAPH.

No S7 300 as etapas são denominadas como “Step”. O step1 (S1) normalmente é


o inicial. Para definir que o step1 será a etapa inicial basta clicar sobre o ele com o botão
direito e escolher a opção object properties, conforme Figura 5.5.

Festo Didactic • E320S


118
Programação avançada com CLP Siemens S7 300

Figura 5.5 – Configurando uma etapa inicial.

Podemos atribuir um nome e comentários para este step, assim como defini-lo
como sendo a etapa inicial, conforme Figura 5.6.

Figura 5.6 – Definindo uma etapa inicial.

Festo Didactic • E320S


119
Programação avançada com CLP Siemens S7 300

Figura 5.7 – Definindo uma etapa inicial.

Na barra de ferramentas à esquerda temos todos os elementos necessários para


compor a estrutura do Grafcet. A Figura 5.8 mostra as principais ferramentas utilizadas.

Festo Didactic • E320S


120
Programação avançada com CLP Siemens S7 300

Figura 5.8 – Ferramentas do ambiente GRAPH.

A seleção das instruções também pode ser feita através da barra de menu usando
o comando Insert.

Festo Didactic • E320S


121
Programação avançada com CLP Siemens S7 300

Exemplo de estruturas de programas em linguagem GRAPH:

Figura 5.9 – GRAPH com sequência direta linear com “salto”.

Figura 5.10 – GRAPH com ramo alternativo e ramo simultâneo

Festo Didactic • E320S


122
Programação avançada com CLP Siemens S7 300

Figura 5.11 – GRAPH com duas sequências

Festo Didactic • E320S


123
Programação avançada com CLP Siemens S7 300

5.2 Instruções básicas para S7 GRAPH

N <address: I, Q, M, D> – Non Holding - Enquanto o passo estiver ativo o


endereço é setado em 1
S < address: I, Q, M, D> – Set output - Set: assim que o passo é ativado o
endereço é colocado em 1 e permanece em 1.
R < address: I, Q, M, D> – Reset output - Reset: assim que o passo é ativado o
endereço é colocado em 0 e permanece em 0.
D < address: I, Q, M, D> – On Delay – “n” segundos após o passo ser ativado, o
endereço recebe sinal 1.
L < address I, Q, M, D> – Limited Pulse - Se o passo está ativo, o endereço
recebe 1 por n segundos.
CALL <FC, FB, SFC, SFB> – Chamada de bloco de programa.

5.3 Exemplo de aplicação

Desenvolver um programa em S7 GRAPH para o comando sequencial do


dispositivo pneumático de furação de peças mostrado na figura [] conforme as condições
de processo descritas abaixo.

Figura 5.12 – Dispositivo de furação de peças.

Festo Didactic • E320S


124
Programação avançada com CLP Siemens S7 300

• Condições de processo

1ª Etapa: Etapa inicial E1 (sem ação).


2ª Etapa: Ao acionar o botão START, o cilindro 1A deverá avançar e prender a
peça, desde que seja confirmado sua posição de recuo por meio do fim de curso 1S1.
3ª Etapa: Quando houver a confirmação de avanço de 1A e que a peça está
presa, por meio de 1S2 o cilindro 2A deverá avançar e furar a peça e permanecer por 2
segundos avançado.
4ª Etapa: Cilindro 2A aguarda 2 segundos após a confirmação de avanço por
meio de 2S2, para recuar e sair da peça.
5ª Etapa: Depois de 2 segundos da confirmação de avanço do cilindro 2A, o
mesmo deverá recuar.
6ª Etapa: Quando for confirmada a posição de recuo de 2A por meio de 2S1 o
cilindro 1A deverá recuar soltando a peça.
Caso um botão RESET seja acionado a sequencia deverá retornar para a etapa
inicial E1.

• Sequencia de movimentos

• Representação gráfica dos movimentos

Festo Didactic • E320S


125
Programação avançada com CLP Siemens S7 300

• Circuito Eletropneumático

• Lista de alocação de variáveis:

Festo Didactic • E320S


126
Programação avançada com CLP Siemens S7 300

• Programa

Uma vez finalizado o programa é necessário salvá-lo e compilá-lo para


gerar os arquivos necessários para a execução do S7 GRAPH e o seu respectivo Data

Festo Didactic • E320S


127
Programação avançada com CLP Siemens S7 300

Block DB. Para isso basta clicar no ícone Salvar na barra de menu, conforme mostra a
Figura 5.13.

Figura 5.13 – Salvando e compilando um programa em linguagem GRAPH.

Caso não haja nenhum erro que impeça a execução da rotina do bloco de
programa S7 GRAPH será mostrado conforme Figura 5.14.

Figura 5.14 – Mensagens de compilação.

Festo Didactic • E320S


128
Programação avançada com CLP Siemens S7 300

Figura 5.15 – Blocos criados automaticamente para a execução do


GRAPH.

Depois de criado, o bloco de programa FB1 criado em S7 GRAPH pode então ser
chamado dentro de OB1, conforme Figura 5.16.

Figura 5.16 – Bloco de programa criado em S7 GRAPH.

Festo Didactic • E320S


129
Programação avançada com CLP Siemens S7 300

O bloco de programa em GRAPH traz entradas e saídas default com funções


específicas. Como por exemplo, a entrada OFF_SQ usada para parar a sequência e a
entrada INIT_SQ usada nesta aplicação para reiniciar a sequência no step1, definido
como inicial. É possível reduzir a quantidade de entradas e saídas do bloco através da
barra de menus em options Block settings, selecionando a opção Minimum na caixa
de configurações, conforme a Figura 5.17 e Figura 5.18.

Figura 5.17 – Configurando os recursos do bloco GRAPH.

Figura 5.18 - Configurando os recursos do bloco GRAPH.

Festo Didactic • E320S


130
Programação avançada com CLP Siemens S7 300

O bloco minimizado deve ser atualizado em OB1 conforme mostrado na Figura


5.19. Apenas a entrada INIT_SQ é mostrada.

Figura 5.19 – Bloco de programa GRAPH com entradas e saídas reduzidas.

Festo Didactic • E320S


131
Programação avançada com CLP Siemens S7 300

6 Source File – Utilizando atributos para proteger um bloco de programa

Em alguns casos é necessário proteger os blocos de programa criados a fim de


restringir o acesso de pessoas não autorizadas pelo programador ao código criado. O
objetivo deste procedimento é evitar alterações indevidas no código de programa por
razões de segurança do equipamento controlado e até mesmo de quem está operando.

Para proteger um bloco de programa deve-se atribuir a ele uma espécie de


“chave” ou “senha” na forma de um arquivo referente ao bloco a ser protegido. Esse
“arquivo chave” é denominado Source File.

O Source file é um arquivo criado com o código do bloco de programa a ser


protegido que deverá funcionar como uma “chave” para abrir ou fechar o bloco. Uma vez
protegido, só terá acesso ao bloco quem possuir o seu source file.

A seguir estão os procedimentos para a criação do source file. Abra o bloco criado
(FB1, por exemplo) e vá a File Generate Source, conforme Figura 6.1.

Figura 6.1 – Inserindo um “source file” para um bloco de programa criado.

Festo Didactic • E320S


132
Programação avançada com CLP Siemens S7 300

Uma janela se abrirá, insira o nome do source file que será criado em Object
name e clique em ok, como mostra a Figura 6.2.

Figura 6.2 – Nomeando o source file.

Uma nova janela se abrira para que sejam selecionados os blocos de programa
que deverão ser protegidos pelo source file a ser criado. Selecione os blocos que deseja
proteger e clique em ok, a Figura 6.3.

Figura 6.3 – Escolhendo os blocos de programa a serem protegidos.

Festo Didactic • E320S


133
Programação avançada com CLP Siemens S7 300

O Source file será criado, conforme Figura 6.4.

Figura 6.4 – Arquivo gerado.

Abra o source file e digite a chave de proteção do bloco


“KNOW_HOW_PROTECT” na última linha do cabeçalho, logo antes do código fonte do
programa, como mostrado na Figura 6.5. Feito isso, vá em File Compile para compilar
o arquivo e salve logo em seguida. Agora o bloco FB1 está protegido. O arquivo fonte
(source file) fica gravado na guia souce.

Figura 6.5 – Inserindo “KNOW_HOW_PROTECT”

Festo Didactic • E320S


134
Programação avançada com CLP Siemens S7 300

Figura 6.6 – Representação do bloco de programa protegido.

Para desproteger o bloco novamente, abra o source file e modifique


“KNOW_HOW_PROTECT” para comentários, adicionando duas barras à esquerda do
nome, como mostra a Figura 6.7. Compile e salve o arquivo. O bloco será então
desprotegido.

Figura 6.7 – Removendo a proteção do bloco.

Festo Didactic • E320S


135
Programação avançada com CLP Siemens S7 300

É possível salvar o source file em outro lugar para poder deletá-la da guia source
do projeto e garantir que ninguém tenha acesso ao programa. Para isto basta clicar com
o botão direito sobre o bloco e mandar exportá-lo para qualquer outra unidade de disco,
conforme Figura 6.8.

Figura 6.8 – Exportando o source file para outra unidade de disco.

Para abrir o bloco novamente é necessário importar o source file. Para isso vá em
source e clique com o botão direito. Clique em Insert new object External Source e
busque o arquivo fonte na unidade de disco onde ela foi gravada, conforme Figura 6.9 e
Figura 6.10.

Festo Didactic • E320S


136
Programação avançada com CLP Siemens S7 300

Figura 6.9 – Importando o Source File.

Abra o arquivo fonte e siga os procedimentos mostrados anteriormente.

Figura 6.10 – Importando o Source File.

Festo Didactic • E320S


137
Programação avançada com CLP Siemens S7 300

Figura 6.11 - Importando o Source File.

Festo Didactic • E320S


138
Programação avançada com CLP Siemens S7 300

7 Referencia Cruzada no S7 300 – Cross References

A referência cruzada é um recurso do CLP que permite o detalhamento das


variáveis utilizadas no programa. Funciona como uma espécie de mapeamento de
memória.

Torna-se um recurso fundamental para as equipes de manutenção, pois permite a


visualização de todas as variáveis de entrada e saída em uso do CLP, além das
memórias.

Este recurso mostra também a estrutura do programa com todos os blocos e onde
cada variável está alocada.

Este recurso está na barra de menus em Options Reference Data Display


(Figura 7.1Selecione a opção update para gerar uma nova tabela de referencias e em
seguida clique em Yes para confirmar, conforme Figura 7.2.

Figura 7.1 – Criando referências cruzadas.

Festo Didactic • E320S


139
Programação avançada com CLP Siemens S7 300

Figura 7.2 - Criando referências cruzadas.

Selecione a opção Cross-reference e clique em ok.

Figura 7.3 - Criando referências cruzadas.

Festo Didactic • E320S


140
Programação avançada com CLP Siemens S7 300

Clicando no ícone Cross-refences, como mostrado na Figura 7.4. Uma lista com
todas as variáveis utilizadas nos programas e sua localização nos blocos de programa
será mostrada.

Figura 7.4 - Criando referências cruzadas.

No ícone Assignment of inputs/output, bit memory, timers and counters é possível


identificar todos os pontos de ocupação dos endereços de entrada e saída, memórias,
contadores e temporizadores, bit-a-bit ocupados, como mostra a Figura 7.5. Esse recurso
permite ao manutentor identificar todos os endereços utilizados para realizar a
substituição de algum dispositivo de campo sem afetar outros endereços.

Festo Didactic • E320S


141
Programação avançada com CLP Siemens S7 300

Figura 7.5 – mostrando a estrutura de memória do CLP.

Usando o comando Rewire, é possível fazer a realocação imediata de endereços,


afetando todos os blocos de programa simultaneamente. A Figura 7.6 mostra esse
procedimento.

Festo Didactic • E320S


142
Programação avançada com CLP Siemens S7 300

Figura 7.6 – Realocando endereços absolutos.

Uma janela se abrirá mostrando todas as ocorrências de endereços substituídos.

Festo Didactic • E320S


143
Programação avançada com CLP Siemens S7 300

O ícone Program structure mostra a estrutura de programa de usuário com todos


os blocos de programas e seus subprogramas. A Figura 7.7 mostra um exemplo de
estrutura Multi-instance implementada.

Figura 7.7 – Estrutura de programa mostrada no reference data.

Festo Didactic • E320S


144
Programação avançada com CLP Siemens S7 300

8 Forçando Variáveis

Outro recurso muito usado por equipes de manutenção é o Force and Modify
Variables.

Este recurso permite forçar uma variável para um determinado estado lógico a fim
de testar os dispositivos de campo nas entradas e saídas do CLP.

A variável forçada assume o valor desejado pelo usuário sem sofrer interferência
do programa, ela passa a responder apenas ao comando de “Force”.

Este recurso encontra-se na barra de menus em PLC Display Force Values


(Figura 8.1).

Figura 8.1 – Forçando variáveis.

Festo Didactic • E320S


145
Programação avançada com CLP Siemens S7 300

Uma janela se abrirá permitindo que as variáveis que se deseja forçar sejam
inseridas, assim como o estado que ela deve assumir, conforme Figura 8.2.

Figura 8.2 - Forçando variáveis.

Em seguida, na barra de menus, deve-se ir em Variable Force para efetivar a


operação. A variável forçada agora não mais responde ao programa de usuário, mas
apenas a tabela de “Force”.

Para parar o Force, vá em Variable Stop forcing.

Festo Didactic • E320S