Apostila S7-N2

Step-7 / Nível 2
Sumário
Memórias de uma CPU Step7 ....................................................................................................... 6
Registradores ............................................................................................................................ 6
Acumuladores ....................................................................................................................... 6
Registradores de Endereço ................................................................................................... 6
Registradores de Data Blocks ................................................................................................ 6
Status Word (Palavra de Status) ........................................................................................... 6
Áreas de Memórias ................................................................................................................... 7
Memória de Carga (Load Memory) ....................................................................................... 7
Memória de Trabalho (Work Memory)................................................................................. 7
Periferia de IO ....................................................................................................................... 7
Memórias Gerais ................................................................................................................... 7
Status Word (Palavra de Status) ................................................................................................... 8
20 – /FC – First Check............................................................................................................. 8
21 – RLO – Resultado de Operação Lógica ............................................................................ 9
22 – STA –Bit de Status ........................................................................................................ 10
23 – OR –Bit de Status.......................................................................................................... 10
24 – OS – Overflow Retentivo .............................................................................................. 10
25 – OV – Overflow .............................................................................................................. 10
26 – CC0 e 27 – CC1 – Bits de Resultado .............................................................................. 11
28 – BR – Resultado Binário ................................................................................................. 12
Funções de Salto ......................................................................................................................... 16
Orkan Automação Industrial Pág. 1 Step-7 / Nível 2
Salto Incondicional .................................................................................................................. 17
Saltos Condicionais.................................................................................................................. 17
JC/JCN .................................................................................................................................. 18
JCB/JNB................................................................................................................................ 18
JBI/JBNI ................................................................................................................................ 18
JO/JOS ................................................................................................................................. 19
JZ.......................................................................................................................................... 19
JN ......................................................................................................................................... 19
JP/JM ................................................................................................................................... 20
JPZ/JMZ ............................................................................................................................... 20
JUO ...................................................................................................................................... 20
Instruções de Fim de Bloco ..................................................................................................... 22
Instrução de Salto Distribuído ................................................................................................. 24
Instrução de Loop.................................................................................................................... 26
Funções com Acumuladores ....................................................................................................... 30
Operações Matemáticas Fundamentais (Soma, Subtração, Multiplicação e Divisão)........ 31
Operações Booleanas com Word/Dword ........................................................................... 32
TAK ...................................................................................................................................... 32
PUSH .................................................................................................................................... 33
POP ...................................................................................................................................... 33
ENT (Speed7 e S7400 – 4 Acumuladores) ........................................................................... 34
LEAVE (Speed7 e S7400 – 4 Acumuladores) ....................................................................... 34
CAW ..................................................................................................................................... 35
CAD ...................................................................................................................................... 35
INC ....................................................................................................................................... 35
DEC ...................................................................................................................................... 36
INVI / INVD .......................................................................................................................... 36
NEGI / NEGD ........................................................................................................................ 37
NEGR ................................................................................................................................... 37
RLDA / RRDA........................................................................................................................ 38
Números Reais – Ponto Flutuante .............................................................................................. 40
Operações Matemáticas com Números REAIS ....................................................................... 41
Funções Fundamentais ....................................................................................................... 41
Funções Estendidas ............................................................................................................. 41
Funções Trigonométricas .................................................................................................... 42
Endereçamentos com o Step-7 ................................................................................................... 44

Endereçamento Direto ............................................................................................................ 44
Endereçamento Simbólico ...................................................................................................... 45
Endereçamento Direto utilizando Data Block (DB/DI) ........................................................ 45
Instruções com registradores DB e DI ................................................................................. 46
DBNO / DINO ....................................................................................................................... 47
DBLG / DILG ......................................................................................................................... 47
CDB ...................................................................................................................................... 47
Endereçamento Indireto ......................................................................................................... 49
Endereçamento Indireto com Memória – Ponteiro de 16 Bits ........................................... 50
Endereçamento Indireto de Área Interna com Memória – Ponteiro de 32 Bits................. 52
Endereçamento Indireto de Área Interna com Registradores – AR1 e AR2 ....................... 56
Endereçamento Indireto de Área Cruzada com Registradores – AR1 e AR2 ...................... 60
Instruções com Registradores de Endereço ........................................................................ 61
Parâmetro POINTER – 48 Bits ............................................................................................. 64
Parâmetro ANY – 80 Bits – Áreas de Memórias .................................................................. 66
Parâmetro ANY – 80 Bits – FBs, FCs, DBs, SDBs, T e C ........................................................ 68
Dados com Mais de 32 bits – “Complexos” ................................................................................ 71
DATE_AND_TIME .................................................................................................................... 72
ARRAY ...................................................................................................................................... 74
STRUCT .................................................................................................................................... 76
STRING..................................................................................................................................... 80
UDTs ........................................................................................................................................ 84
Utilizando as Bibliotecas ............................................................................................................. 86
System Functions .................................................................................................................... 89
A biblioteca: S5 - S7 Convertendo blocos ............................................................................... 99
A biblioteca : TI - S7 Convertendo blocos (Parte 1)............................................................... 100
FC 80 .................................................................................................................................. 100
FC 81 .................................................................................................................................. 100
FC 82/83 ............................................................................................................................ 100
FC 84-FC92......................................................................................................................... 100
FC 93-FC 99........................................................................................................................ 100
FC 100-FC 101.................................................................................................................... 101
FC 102 ................................................................................................................................ 101
FC 103 ................................................................................................................................ 101
FC 105-FC 106.................................................................................................................... 102
FB 80- FB 86....................................................................................................................... 102

Manipulando Erros no Step7 .................................................................................................... 103
Erros Assíncronos .................................................................................................................. 104
OB80 - Erro de Tempo ....................................................................................................... 104
OB81 - Erro da Fonte de Alimentação............................................................................... 104
OB82 - Interrupção para Diagnóstico ................................................................................ 104
OB83 - Interrupção para Remover/Inserir Módulos ......................................................... 104
OB84 - Erro de Hardware da CPU...................................................................................... 105
OB85 - Erro de Seqüência de Programa ............................................................................ 105
OB86 - Falência de Rack .................................................................................................... 105
OB87 - Erro de Comunicação ............................................................................................ 105
Erros Síncronos...................................................................................................................... 106
OB121 – Erros de Programação ........................................................................................ 106
OB122 – Erros de Acesso a I/O.......................................................................................... 108
Mascarando Erros Síncronos............................................................................................. 109

Anotações:

Memórias de uma CPU Step7
Áreas de Memórias
Load Memory Work Memory Periferia de I/O Memórias Gerais
Memory Code Memory Code Periferia de  Imagem de I/O

 Bit Memory
OB, FC, FB OB, FC, FB Entrada PI  Temporizadores
 Contadores
Memory Data Memory Data Periferia de  Pilha de Dados
Locais
DB, DI DB, DI Saída PQ  Pilha de Interrupção
 Pilha de Blocos
L LAR1 OPN DB A, O, FP
T TAR2 =, S, R
Acumuladores Registradores de Registradores de Status Word

Endereço Data Blocks
ACCU1 – 32Bits swAberto
AR1 – 32 Bits N° DB - 16Bits Bits de Status
ACCU2 – 32Bits
AR2 – 32Bits N° DI – 16Bits
ACCU3 – 32Bits
Speed7
S7-400
ACCU4 – 32Bits Registradores
Figura 1.1: Registradores e Áreas de Memória de uma CPU S7
Registradores
Os registradores são memórias usadas pela CPU na execução de suas tarefas. Através de
instruções do tipo L(Load), T(Transfer), A(AND), O(OR), entre outras, são realizadas as trocas
de valores entre os registradores e as demais Áreas de Memórias:
Acumuladores
São registradores de 32 bits usados pela CPU para funções aritméticas, comparações,
movimentações de valores etc. As CPU´s S7-300 possuem dois acumuladores(ACCU1 e
ACCU2) enquanto as CPU´s S7-400 e as CPU´s Speed 7 da Vipa possuem 4, conforme
Figura 1.1.
Registradores de Endereço
Existem dois registradores de 32 bits utilizados pela CPU (AR1 e AR2) para
endereçamento indireto de memórias no programa.
Registradores de Data Blocks

Os registradores de blocos de dados armazenam os números dos Db´s abertos. São
duas memórias de 16 bits, onde uma armazena o nº do DB aberto e outra o número do
DB instância aberto.
Status Word (Palavra de Status)

Existe um registrador de 16 bits (Word) que reflete o resultado ou o status de
instruções da CPU. São usados nove bits e cada um possui um significado que será
abordado no capítulo a seguir.

Áreas de Memórias
Existem quatro áreas de memórias nas CPU´s S7
Memória de Carga (Load Memory)

É a memória onde fica armazenado o programa do usuário. Entretanto, os comentários
e símbolos pertencem somente ao projeto no computador, e não são baixados para
essa memória no CLP. Dependendo do modelo da CPU, a memória de carga pode ser
RAM ou EEPROM.
Memória de Trabalho (Work Memory)

Representa a porção relevante do programa necessária para a execução da lógica do
CLP. Essa é a memória que deve ser analisada quando se deseja realizar uma
ampliação no programa do CLP. Precisa-se observar que ela está dividida em duas
partes, sendo uma referente ao Código (OB, FC e FB) e outra aos Dados (DB e DI).
Dependendo do modelo da CPU, será representado na Aba “Memory” do “Module
Information” somente o espaço ocupado pelos códigos.
Periferia de IO
Quando a CPU se comunica com os módulos do seu barramento, ela usa as Periferias
de Entrada e Saída para armazenar os valores dessa comunicação. Dessa forma,
quando se quer ler os dados um módulo de entradas digitais, por exemplo, lê-se a
Periferia de Entrada reservada para o mesmo. Por outro lado, para escrever um valor
em um módulo de saída analógica, basta transferir um valor para a Periferia de Saída
destinada ao mesmo. A periferia compreende tanto os módulos conectados ao
barramento da CPU, quanto os módulos conectados a uma remota Profibus-DP.
Memórias Gerais
As Imagens das Entradas (I0.0) e Saídas digitais(Q0.0), Bit Memory(MW200) , Variáveis
Locais(LB0), Temporizadores (T0) e Contadores(C0) são armazenadas na memória RAM
do Sistema e, por “natureza”, não retêm seus valores quando a CPU é desligada. Existe
nas propriedades da CPU uma opção de tornar uma parte dos Bits Memory,
Temporizadores e Contadores em memórias retentivas.

Status Word (Palavra de Status)
Resultado Binário – BR – 28 20 – /FC – First Check
Bit de Resultado 1 – CC1 – 27 21 – RLO – Resultado de

Operação Lógica
Bit de Resultado 0 – CC0 – 26
Overflow – OV – 25 22 – STA – Bit de Status
Overflow Retentivo – OS – 24 23 – OR – Lógica OU
Figura 1.2: Status Word (Palavra de Status)
Os Bits da Status Word (Palavra de Status) são registradores que a CPU usa na execução de
suas lógicas binárias. Quando se trabalha com uma linguagem gráfica, como LADDER ou FBD,
não se percebe a existência desses Bits, pois eles estão representados de forma gráfica
(animações de linhas e contados). Todavia, quando se trabalha em STL o conhecimento desses
bits é fundamental.
Será visto que nem todos os Bits da Status Word possuem instruções que os acessem
diretamente, mas através das instruções “L STW” e “T STW”, esses bits podem ser movidos
para uma memória e vice-versa. Os Bits 9 a 15 da Status Word não são usados pela CPU.
O /FC = 0 indica o fim da lógica, pois foi

encontrada uma instrução do tipo “Ação”
que atribuiu o RLO ao STA do Bit Q0.0
STA – Status
do Bit I0.0
RLO – Resultado
das Operações
Lógicas
Atribui o RLO, naquele momento, ao
STA do Bit Q0.0
Figura 1.3: Análise dos Bits RLO, STA e /FC - STL
20 – /FC – First Check

O primeiro Bit da Status Word (Palavra de Status) identifica o início e o fim de uma
lógica. Para o Step7, uma lógica é composta de: Condição(ões) e Ação(ões). Essa
estrutura está exemplificada na Figura 1.3, onde se percebe que existem duas
condições que checam se o Bit “I0.0” é Verdadeiro e se o “I0.1” é Falso. Se essas

condições forem satisfeitas, o RLO ou Resultado das Operações Lógicas, será
Verdadeiro. Na linha seguinte, o Valor do RLO é atribuído (“= Q0.0”) ao Status do Bit
“Q0.0”, o que constitui uma Ação. Uma instrução do tipo “Ação” pode ser: S, R, Saltos,
Start de Temporizadores, uma chamada de Bloco etc.
Se, na Figura 1.3, existisse na mesma Network, uma próxima instrução do tipo
condição (por exemplo, “A I0.2”), o Step7 iria entender essa instrução como a
primeira de uma nova lógica e o Bit /FC voltaria a ser Verdadeiro. Nesse caso, essa
Network não iria mais possuir representação gráfica, pois o LADDER e o FBD permitem
somente um conjunto de “Condição e Ação” por Network.
Atribui o RLO, naquele

momento, ao STA do Bit
Q0.0
RLO sempre STA – Status

Verdadeiro Negado do Bit I0.1
RLO – Resultado
STA – Status RLO – Resultado da das Operações
do Bit I0.0 primeira Operação Lógica Lógicas
Figura 1.4: Análise Gráfica dos Bits RLO, STA e /FC - LADDER
21 – RLO – Resultado de Operação Lógica

O Step7 usa o segundo Bit da Status Word, o RLO, para acumular o resultado Lógico
das Operações Booleanas. A execução de uma instrução Lógica booleana é realizada
entre o Bit STA (que representa o Status do operando a ser checado) e o RLO (que
representa o Último Resultado Lógico). De acordo com a Figura 1.4, quando se analisa
uma lógica em LADDER, o RLO está representado nas animações das linhas.
Existem instruções que manipulam o RLO diretamente. Através delas é possível forçar
um valor para o RLO que independe de uma condição. São elas:
 SET – Força o valor do RLO para Verdadeiro. Seta o RLO e não possui
representação gráfica;
 CLR – Força o valor do RLO para Falso. Limpa o RLO; e não possui
representação gráfica;
 NOT – Inverte o valor do RLO e possui representação gráfica.
Figura 1.5: Exemplo com SET e CLR

22 – STA –Bit de Status
O STA, ou Bit de Status, mostra o valor do operando declarado na instrução. Por
exemplo, na instrução “A I0.0”, o STA será verdadeiro se o status do I0.0 for
verdadeiro. Em uma instrução de Escrita, “= Q0.0”, o STA representa o Status do Bit
Q0.0 depois de efetuada a Ação. Conforme a Figura 1.4, quando se analisa uma lógica
em LADDER, o STA está representado nas animações dos Contatos.
23 – OR –Bit de Status
O Bit OR é utilizado pela CPU na implementação de uma lógica booleana do tipo OU.
De acordo com a Figura 1.6, o Bit OR armazena a informação de que diante de várias
lógicas OU, uma delas já satisfez a condição sendo verdadeira.
OR = Verdadeiro. Indica que a

primeira condição da lógica “OU”
foi verdadeira.
Figura 1.6: Análise dos Bits OR, RLO, STA e /FC – STL e LADDER
24 – OS – Overflow Retentivo
Quando o Bit OV torna-se verdadeiro, indicando que ouve um overflow, o Bit OS
também é setado para "1". A diferença entre eles é que o Bit OV volta a ser Falso caso
a próxima operação aritmética não gere Overflow, enquanto que o Bit OS não se altera
guardando a informação de erro para posterior uso. Dessa forma, em uma seqüência
de contas, pode-se esperar para checar se houve algum tipo de erro ao final das
operações, não sendo preciso checar a cada uma. Esse Bit somente é resetado após as
seguintes instruções: JOS (salta se OS = 1); chamadas de blocos e instruções de fim de
Bloco (BE, BEC e BEU). Pode-se checar esse bit diretamente através da Instrução “A
OS”.
25 – OV – Overflow
Quando se efetua uma operação matemática ou de comparação de Números Reais, se
houver um erro como divisão por zero e/ou estouro de aérea de memória, entre
outros, o sexto Bit da Status Word, o OV, torna-se verdadeiro. Com isso, quando se
tem uma seqüência de operações matemáticas, pode-se ao final de cada uma checar
se essa gerou um estouro de contagem para que o restante das operações não seja
executado. Isso pode se feito checando o Bit OV como é mostrado na Figura 1.7.

A soma de números Inteiros
(ACCU1 + ACCU2) gerou um
resultado maior que 32767 e por
isso o Bit OV tornou-se
Checa o Status do Bit OV e se Verdadeiro.
Verdadeiro salta para o marcador
FIM, pois nesse caso ir-se-ia
atribuir um valor errado ao
MW200.
Figura 1.7: Análise do Bit OV e uso da instrução “A OV”
26 – CC0 e 27 – CC1 – Bits de Resultado

Os Bits CC0 e CC1 trazem Códigos de Condição, ou seja, códigos de resultados para três
tipos de instruções no Step7: Operações Matemáticas; Comparações e Lógicas
Booleanas de Word/Dword. Para acessar os Bits CC0 e CC1 usam-se, além de
instruções de salto, as listadas abaixo:
Instrução
Verificação
(A, AN, O, ON, X, XN)
A ==0 ((CC 1 = 0) E (CC 0 = 0))
A <>0 (((CC 1 = 1) E (CC 0 = 0)) OU ((CC 1 = 0) E (CC 0 = 1)))
A >0 ((CC 1 = 1) E (CC 0 = 0))
A <0 ((CC 1 = 0) E (CC 0 = 1))
A >=0 (((CC 1 = 1) E (CC 0 = 0)) OU ((CC 1 = 0) E (CC 0 = 0)))
A <=0 (((CC 1 = 0) E (CC 0 = 1)) OU ((CC 1 = 0) AND (CC 0 = 0)))
A UO ((CC 1 = 1) E (CC 0 = 1))
Os códigos para as diferentes situações são:
 Depois de Instruções Matemáticas, sem Overflow
CC1 CC0 Significado

0 0 Resultado = 0
0 1 Resultado < 0
1 0 Resultado > 0
 Depois de Instruções Matemáticas de Números Inteiros, com Overflow
CC1 CC0 Significado

0 0 Overflow Negativo em +I e +D
 Overflow Negativo em *I e *D
0 1
 Overflow Positivo em +I, -I, +D, -D, NEGI, e NEGD
 Overflow Positivo em *I, *D, /I and /D
1 0
 Overflow Negativo em +I, -I, +D, and -D
1 1 Divisão por Zero em /I, /D e MOD

Depois de Instruções Matemáticas de Números Reais, com Overflow
CC1 CC0 Significado
0 0 Overflow Gradual
0 1 Overflow Negativo
1 0 Overflow Positivo
1 1 Número Real inválido
 Depois de Instruções de Comparação
CC1 CC0 Significado

0 0 ACCU 2 = ACCU 1
0 1 ACCU 2 < ACCU 1
1 0 ACCU 2 > ACCU 1
1 1 Número Real inválido
 Depois de Instruções de Shift e Rotate
CC1 CC0 Significado

0 0 Bit deslocado possui valor = 0 (Falso)
1 0 Bit deslocado possui valor = 1 (Verdadeiro)
 Depois de Instruções de Lógicas Booleanas com Word/Dword
CC1 CC0 Significado

0 0 Resultado = 0
1 0 Resultado <>0
28 – BR – Resultado Binário
O Bit BR é um registrador que pode ser usado para salvar um valor de RLO para uso
posterior antes que uma nova instrução o altere. Através da instrução SAVE, o valor do
Bit RLO é copiado para o Bit BR. outra forma de escrever um valor no Bit BR é através
dos saltos JCB e JNB que estão abordados no capítulo de Saltos
Além de poder salvar um Resultado Lógico intermediário, outro uso muito importante
desse Bit é na chamada em “cascata” de blocos/instruções em LADDER e FBD. Nesse
caso, o Bit BR corresponde à saída ENO. Na Figura 1.7, percebe-se que as
representações gráficas de algumas instruções usam o Bit BR automaticamente,
somente sendo possível enxergar a sua existência quando se visualiza a lógica em STL.
Figura 1.8: Uso do Bit BR para Chamada de Blocos de instruções
Já na Figura 1.8, uma instrução aritmética salva no BR a informação de Overflow para

continuar ou não a lógica. Dessa forma quando se trabalha com operações
Matemáticas em LADDER ou FDB, já se checa o overflow automaticamente. Porém,

uma instrução do tipo Move, sempre irá setar o BR para verdadeiro, pois não existe a
necessidade de se checar um erro na execução da tarefa.
Figura 1.7: Uso do Bit BR para Chamada de Blocos de instruções
Já na Figura 1.9, verifica-se uma chamada de bloco desenvolvido pelo usuário. Nesse
caso tem-se que salvar um valor de RLO para o Bit BR dentro do Bloco chamado para
que ao final da Execução do mesmo a lógica continue ou não.
Figura 1.9: Uso do Bit BR para Chamada de Blocos de Função (FC, FB, SFC e SFB)

Anotações:

Anotações:

Funções de Salto
Salta se
RLO = 1
Figura 2.0: Instruções de Salto no Step-7
As funções de salto permitem que se interrompa a execução linear do programa, saltando para
outra posição identificada por um Label ou Marca.
As instruções no Step7 que manipulam os acumuladores, registradores de endereço e de Data

Block são executadas pela CPU mesmo que o estado do RLO naquele instante seja FALSO
(RLO=0). Exemplos dessas instruções são: Load, Transfer, operações booleanas com
Word/Dword, operações matemáticas, comparações etc. Para esses casos, quando não se
deseja executar uma ou mais linhas de código, tem-se que saltar o programa para outra
posição, que será identificada por um Label ou Marca.
Os saltos podem ser para frente ou para trás no programa contanto que seja para o mesmo
bloco.
Label ou Marca
É o identificador de uma posição no programa que é o destino de uma instrução de

salto. Um Label não pode iniciar com números e pode ter no máximo 4 caracteres
(letras ou números). Os Labels são diferenciados entre letra em caixa alta e caixa baixa,
portanto, o Label “Fim” é diferente de “FIM”. Além disso, eles só têm validade no
bloco em que estão inseridos.
Nota
Deve-se prestar atenção no caso de se saltar para trás no programa, para evitar que a
CPU entre em um loop infinito.

Salto Incondicional
A instrução de Salto JU é sempre executada, independentemente do estado do RLO ou dos

outros bits da palavra de Status. Dessa forma, sempre que a execução do programa encontrar
uma instrução JU, o programa salta para o Label especificado, não alterando os bits da Palavra
de Status.
Figura 2.1: Exemplo de salto incondicional
Saltos Condicionais
Existem 15 tipos diferentes de Saltos condicionais no Step7. Eles avaliam os bits da Palavra de
Status para realizar o salto para o Label especificado. Segue abaixo na Tabela 2.1 um resumo
com todos os saltos condicionais e depois o detalhamento de cada um deles.
Resumo
JC Label Salta de o bit "RLO" =1
JCN Label Salta se o bit "RLO" = 0
JCB Label Salta se o bit "RLO" = 1 e salva RLO no Bit BR
JNB Label Salta se o bit "RLO" = 0 e salva RLO no Bit BR
JBI Label Salta se o bit "BR" = 1
JBNI Label Salta se o bit "BR" = 0
JO Label Salta se o bit "OV" na palavra de status =1
JOS Label Salta se o bit "OS" na palavra de status =1
JZ Label Salta se resultado igual a zero
JN Label Salta se resultado diferente de zero
JP Label Salta se resultado maior que zero
JM Label Salta se resultado menor que zero
JPZ Label Salta se resultado maior ou igual a zero
JMZ Label Salta se resultado menor ou igual a zero
JUO Label Salta se: “desordem” - número real inválido ou divisão por zero
Tabela 2.1: Resumo dos Saltos Condicionais

JC/JCN
As funções JC e JCN executam o salto em função do estado do RLO, onde JC salta se o
RLO for verdadeiro e JCN se for falso. Independentemente se foi executado o salto ou
não, essas funções setam os bits RLO e STA e resetam os Bits OR e FC da Palavra de
Status.
Figura 2.2: Exemplo de salto condicional ao RLO
JCB/JNB
Essas são funções também dependem do estado do RLO e funcionam de forma
semelhante às funções JC e JCN, inclusive com relação aos bits de Status. A única
diferença está em salvar o estado do RLO no bit BR. São utilizadas pelo editor do Step 7
quando se está trabalhando em LADDER ou FDB.
Figura 2.3: Exemplo de salto condicional salvando o estado do RLO no BR
JBI/JBNI
Dependem do estado do bit BR da Palavra de Status. Podem ser usados para evitar o
uso de uma instrução “A BR”. Não afetam o estado do RLO nem do próprio BR, mas
setam o Bit STA e resetam os bits OR e FC da Palavra de Status.
Figura 2.4: Exemplo de salto condicional ao bit BR

JO/JOS
As funções de salto JO e JOS dependem dos bits de Overflow e Overflow Retentivo e
não alteram os bits da Palavra de Status. Elas são usadas para verificar se ouve um
“estouro” em uma operação matemática. Os Saltos JO e JOS não alteram os bits da
Palavra de Status.
Figura 2.5: Exemplo de salto condicional ao bit OV
JZ
Essa função salta se CC1=0 e CC0=0, o que dependendo da última instrução pode
informar resultados diferentes. A Figura 2.6 traz um exemplo do JZ após uma instrução
de deslocamento de Bits para a Direita ( SRW). Nesse caso, o salto será efetuado se o
último bit deslocado era igual a zero, ou seja, se a memória MW200 era um número
Par. O capítulo anterior detalha os significados das combinações dos Bits CC1 e CC0. O
Salto JZ não altera os bits da Palavra de Status.
Figura 2.6: Exemplo de salto condicional se resultado = 0
JN
Essa função salta se CC1 é diferente de CC0, o que dependendo da última instrução
pode informar resultados diferentes. A Figura 2.7 traz um exemplo do JN após uma
instrução de “OU Word” (OW). O salto será efetuado se o resultado do OU foi
diferente de zero. O capítulo anterior detalha os significados das combinações dos Bits
CC1 e CC0. O Salto JN não altera os bits da Palavra de Status.
Figura 2.7: Exemplo de salto condicional se resultado <> 0

JP/JM
O salto JP salta se CC1=1 e CC0=0, enquanto o JM salta se CC1=0 e CC0=1, o que
dependendo da última instrução pode informar resultados diferentes. A Figura 2.8 traz
um exemplo do JM após uma operação matemática. O salto será efetuado se o
resultado for menor que zero, ou seja, se o ACUU1 < 0. O capítulo anterior detalha os
significados das combinações dos Bits CC1 e CC0. Os Saltos JM e JP não alteram os bits
da Palavra de Status.
Figura 2.8: Exemplo de salto condicional se resultado < 0
JPZ/JMZ
Funcionam de forma semelhante aos Saltos JP e JM, onde o JPZ salta se CC1=1/CC0=0
ou se CC1=0/CC0=0 e o JMZ salta se CC1=0/CC0=1 ou se CC1=0/CC0=0. A Figura 2.9
traz um exemplo do JMZ após uma operação matemática. O salto será efetuado se o
resultado for menor ou igual a zero, ou seja, se o ACUU1 <= 0. O capítulo anterior
detalha os significados das combinações dos Bits CC1 e CC0. Os Saltos JMZ e JPZ não
alteram os bits da Palavra de Status.
Figura 2.9: Exemplo de salto condicional se resultado “>= 0” ou “<= 0”
JUO
Essa função salta se CC1 e CC0 forem iguais a 1. Isso representa uma divisão por zero,
ou um número real desordenado. O capítulo anterior detalha os significados das
combinações dos Bits CC1 e CC0. O Salto JUO não altera os bits da Palavra de Status.
Figura 2.10: Exemplo de salto condicional se resultado inesperado

Anotações:

Instruções de Fim de Bloco
Existem instruções que permitem encerrar um Bloco antes do final do mesmo. Isso pode ser
feito condicionalmente ao RLO, ou incondicionalmente. Segue abaixo os 3 tipos de instruções
de fim de bloco:
 BE – É a instrução que declara o final de um bloco. No Step5 tinha-se que declarar essa
instrução para informar à CPU que o bloco se encerra naquele ponto. No Step7 ela é
automaticamente criada pelo editor de blocos e não se percebe a sua existência. De
qualquer forma, pode-se usá-la para se encerrar um bloco assim como a Instrução BEU
descrita abaixo. Não possui representação Gráfica
 BEU – No Step7 funciona da mesma forma que o BE. Essa instrução pode ser usada
repetidas vezes dentro de um mesmo bloco, lembrando-se sempre que as linhas de
códigos declaradas depois dessa instrução somente serão executadas se em algum
ponto existir um salto “pulando” o BEU. Não possui representação Gráfica
 BEC – Essa instrução encerra o bloco da mesma forma que as citadas acima, porém ela
depende do valor do RLO. Se ao ser executada essa instrução, o RLO for
Verdadeiro(=1), ela encerra o bloco e o programa volta para a posição da chamada
desse bloco. Se o RLO for Falso o bloco não é encerrado, o RLO passa a ser verdadeiro
e o programa continua a sua execução linear. Essa instrução seta os Bits STA e RLO e
reseta os Bits OR e FC da Status Word. Existe uma representação gráfica para essa
instrução, conforme Figura 2.11, que seria a instrução RET. Ela combina um SAVE e um
BEC. Dessa forma ela ao mesmo tempo em que encerra o bloco, armazena o estado do
RLO no Bit BR para uso no ENO do Bloco.
Figura 2.11: Representação Gráfica do BEC -> RET

Anotações:

Instrução de Salto Distribuído
O salto distribuído JL permite a programação de saltos múltiplos e funciona de forma

semelhante à instrução “Switch-Case”, largamente utilizada em softwares de programação
como Pascal, Visual Basic, C++, etc.
Carrega Índice
do Salto
JL Label_Erro
JU Salto_0
JU Salto_1
JU Salto_2
Salta para Erro se
Índice > Qtd de
Saltos, ou seja, se Lógica de Erro
ACCU1 > Qtd de Label_Erro:
de Índice
JUs entre o JL e o Salta para o Label
“Label_Erro”. correspondente ao
Salto_0: Lógicas Salto_0 Índice. Se Índice =
1, então salta para
Salto_1.
Salto_1: Lógicas Salto_1
Salto_2: Lógicas Salto_2
Fim do Salto
Label_Fim:
Distribuído
Figura 2.12: Estrutura de Saltos Distribuídos
A lista de saltos inicia imediatamente após a instrução JL, podendo possuir um máximo de 255
entradas, e se estende até o Label da instrução JL, conforme figura 2.12. Não pode haver outra
instrução além dos Saltos JU dentro da lista.
Lista de Saltos
Figura 2.13: Exemplo de Saltos Distribuídos

Se ao ser executada a instrução JL o valor do ACCU1 for "0", a primeira instrução de salto JU da
lista é efetuada. Se o valor do ACCU1 for igual a “1”, o segundo JU é realizado e assim por
diante. Se o valor do ACCU1 for maior do que a quantidade de JU´s da lista, então se salta para
o Label declarado na instrução JL. A instrução JL é executada independentemente do estado
do RLO e não altera os bits da Palavra de Status.
Notas
Os Labels declarados nos exemplos acima foram usados para facilitar o entendimento
da instrução JL, todavia podem ser usados quaisquer outros Labels que sigam as regras
especificadas anteriormente neste capitulo.
A distância máxima de salto é -32768 ou +32767 palavras de código de programa. O

número máximo atual de declarações que se pode saltar depende do mix de
declarações que você usou no seu programa (uma, duas ou três palavras declaradas).
Anotações:

Instrução de Loop
A instrução LOOP do Step7 é semelhante a um loop “FOR” que é muito utilizado em softwares
de programação como Pascal, Visual Basic, C++, etc. Ele é usado quando se deseja executar
uma mesma atividade repetidas vezes. A Figura 2.14 mostra a estrutura da instrução no Step7.
Carrega Qtd de
LOOPs no ACCU1
Transfere para
Label_Loop: Memória de
LOOPs
Código a ser
repetido
Carrega Memória
de Loops no
ACCU1
Sim LOOP “Label_Loop”

Decrementa o ACCU1
ACCU1 > 0 ?
Não
Continua
execução linear
do programa
Figura 2.14: Estrutura de uma Instrução de Loop
A instrução Loop subtrai 1 do ACCU1 e salta para o Label especificado se o valor do ACCU1
ainda for maior que zero após a subtração. No exemplo da Figura 2.15, utiliza-se uma memória
Local (Temp - #Qtd_Loop) de 16 bits(INT) para acumular o valor de contagem de Loops
efetuados. Como a instrução LOOP manipula o ACCU1, o valor da memória de contagem deve
ser carregado no ACCU1 antes da instrução “Loop” e devolvido à memória de contagem após a
sua execução. Se o valor do ACCU1, depois da subtração, for igual a zero, a CPU continua a
execução linear do programa, pois já foram efetuados todos os loops. A Figura 2.15 demonstra
como montar a estrutura de um loop.

Figura 2.15: Montando a estrutura de uma Instrução de Loop
Já nas figuras 2.16 e 2.17 se tem exemplos de usos de Loops que foram construídos com base
na estrutura da Figura 2.14. O primeiro traz um exemplo de uma função que eleva uma
memória a qualquer potencia. O código a ser repetido multiplica a memória por ela mesma e
dessa forma a quantidade de Loops a efetuar representa a potencia à qual a memória está
sendo elevada. Embora Existam várias forma de se fazer esse exemplo, foram usadas as
instruções vistas até esse ponto da apostila.
Figura 2.16: Montando a estrutura de uma Instrução de Loop
A figura 2.17 traz um exemplo de uma função para zerar uma seqüência de memórias através
do uso de ponteiros de área interna. Esse assunto será abordado no capítulo de
endereçamento indireto. Pode-se perceber que a estrutura usada é a mesma para diferentes
usos da instrução LOOP.

Figura 2.17: Exemplo de uma Instrução de Loop - Zera uma seqüência de Memórias
Nota
Por utilizar apenas 16 bits do ACCU1, o número máximo de loops que podem ser
efetuados é de 65535 vezes. Deve-se também tomar cuidado para não iniciar um loop
com “0”, pois isso fará com que o loop seja executado 65535 vezes.
Anotações:

Anotações:

Funções com Acumuladores
Conforme capítulo inicial desta apostila, os acumuladores são registradores de 32 Bits que a
CPU usa para o processamento de valores (Bytes, Words e Dwords). Nenhuma operação é
efetuada diretamente nas áreas de memórias (I, Q, L, M, DB, DI), mas sim somente nos
acumuladores (ACCU1, ACCU2, ACCU3 e ACCU4). Dessa forma, toda vez que se deseja realizar
uma operação matemática precisa-se primeiramente carregar para os acumuladores
constantes ou valores que estão nas áreas de memórias. Depois disso pede-se para a CPU
efetuar a instrução matemática. Quando se deseja comparar valores, tem-se que
primeiramente carregá-los nos acumuladores para depois mandar a CPU verificar se o ACCU2 é
maior que o ACCU1, por exemplo.
O step7 trata lógicas de bits e manipulação de valores como duas coisas totalmente distintas, e
é por isso um Load é efetuado mesmo com o RLO sendo Falso. O único ponto em que uma
manipulação de valores cruza com lógicas de bits é quando se efetua uma comparação, onde o
resultado é escrito no RLO.
Quando se programa em LADDER ou FDB não se percebe a existência dos acumuladores, pois
esse é o objetivo das linguagens gráficas. Embora a princípio programar operações
matemáticas em STL possa parecer mais complicado, uma vez que se conheçam as instruções,
isso tornará o programa mais simples e enxuto e tomará menos processamento da CPU. Isso
porque se pode trabalhar diretamente com os acumuladores, recuperando o resultado da
última operação e usando-o para uma próxima instrução, o que em LADDER seria impossível.
As funções a serem descritas nesse capítulo visam a otimização da manipulação dos
acumuladores. Existem instruções que manipulam somente o ACCU1 e outras que precisam de
mais de um acumulador. Segue abaixo na Tabela 3.1 a lista dessas instruções:
Speed
100V/200V/
Funções que usam pelo menos dois Acumuladores 7/
300V/S7300
S7400
 Operações matemáticas e lógicas Booleanas com Word/Dword X X
 TAK Inverte o conteúdo do ACCU1 com o ACCU2 X X
 PUSH “Empurra” os valores dos acumuladores para cima X X
 POP “Puxa” os valores dos acumuladores para baixo X X
“Empurra” os valores dos acumuladores, a partir do
 ENT X
ACCU2, para cima
“Puxa” os valores dos acumuladores para baixo, até
 LEAVE X
o ACCU2
Funções que usam somente o ACCU1

 Instruções de conversão
 INC Incrementa o ACCU1-L-L
 DEC Decrementa o ACCU1-L-L
 CAW Inverte os dois primeiros Bytes do ACCU1-L
 CAD Inverte os quatro Bytes do ACCU1
 INVI / INVD Inverte os Status dos Bits
 NEGI / NEGD / NEGR Faz o complemento de dois e inverte o sinal
 RLDA / RRDA Rotaciona os Bits utilizando o CC1

Operações Matemáticas Fundamentais (Soma, Subtração, Multiplicação e
Divisão)
As operações aritméticas fundamentais no step7 são sempre realizadas entre o ACCU1
e o ACCU2, sendo o resultado guardado no ACCU1.
O que acontece com o ACCU2 depende da CPU que se está usando. Em uma CPU com
dois acumuladores (100V, 200V, 300V e o S7300) o ACCU2 mantém o seu valor
original, conforme Figura 3.1.
O ACCU2 não se
alterou!
ACCU2 30 30 ACCU2
ACCU1 200 230 ACCU1
antes depois
Figura 3.1: Acumuladores após operações matemáticas – 100V, 200V, 300V e S7300
Nas CPUs com 4 acumuladores (Speed7 e S7400) o ACCU2 recebe o valor do ACCU3 e
esse o valor do ACCU4, ou seja, a “pilha” desce, sendo colocado 0 no ACCU4. A Figura
3.2 ilustra essa movimentação.
O ACCU2 recebeu o
ACCU3 que era igual a
zero!
0
ACCU4 0 0 ACCU4
ACCU3 0 0 ACCU3
ACCU2 30 0 ACCU2
ACCU1 200 230 ACCU1
antes depois

Figura 3.2: Acumuladores após operações matemáticas – Speed7 e S7400
Operações Booleanas com Word/Dword

As instruções Lógicas Booleanas com Word / Dword combinam Bit a Bit do ACCU1 com
o ACCU2 ou com uma constante. O resultado fica alocado no ACCU1 e nada acontece
com os demais acumuladores: ACCU2, ACCU3 e ACCU4, que mantêm os seus valores. A
Figura 3.3 mostra um exemplo de uma instrução AW para verificar se existe algum Bit
verdadeiro entre os seis primeiros bits do MW200.
O ACCU2 manteve o
seu valor
ACCU4 0 0 ACCU4
ACCU3 0 0 ACCU3
ACCU2 2 2 ACCU2
ACCU1 63 AW 2 ACCU1
antes depois
Figura 3.2: Acumuladores após operações Booleanas com WORD
TAK
Existem situações no programa em que se deseja inverter os conteúdos do ACCU1 pelo
ACCU2 e para isso existe a instrução TAK. Ela troca os valores dos dois primeiros
acumuladores e, em CPUs com quatro acumuladores, ela não altera o ACCU3 e o
ACCU4 (Figura 3.5). A Figura 3.4 traz um exemplo de uma operação matemática em
que se precisou inverter os ACCUs. Sem essa instrução seria necessário usar uma
memória para receber o valor intermediário do soma: MW200 + MW202. Essa
instrução não altera os bits da Status Word.
ACCU4 0 0 ACCU4
ACCU3 0 0 ACCU3
ACCU2 2 63 ACCU2
ACCU1 63 2 ACCU1
antes depois
Figura 3.5: Função TAK – inverte o ACCU1 pelo ACCU2

Inverteu os ACCUs
Figura 3.4: Função TAK – inverte o ACCU1 pelo ACCU2
PUSH
A instrução PUSH “empurra” o conteúdo dos acumuladores para cima, preservando o
valor do ACCU1. É uma forma de se duplicar o valor do ACCU1 sem perder os valores
do ACCU2 e do ACCU3, em CPUs com 4 acumuladores.
ACCU4 40 30 ACCU4
ACCU3 30 20 ACCU3
ACCU2 20 10 ACCU2
ACCU1 10 10 ACCU1
antes 4 ACCUS depois

Speed7 e S7400
ACCU2 20 10 ACCU2
ACCU1 10 10 ACCU1
2 ACCUS
antes 100V, 200V, 300V e depois
S7300
Figura 3.6: Função PUSH
POP
É o inverso da instrução PUSH, mas nesse caso os valores dos acumuladores são
“puxados” para baixo, preservando o valor do ACCU4 (Speed7 e S7400) ou do ACCU2
(100V, 200V, 300V e S7300). Ela é normalmente usada depois de um Transfer, quando
o valor que estava no ACCU1 não será mais usado e se deseja continuar a execução
com os valores que estão nos demais acumuladores.
ACCU4 40 40 ACCU4
ACCU3 30 40 ACCU3
ACCU2 20 30 ACCU2
ACCU1 10 20 ACCU1
4 ACCUS
antes Speed7 e S7400 depois
ACCU2 20 20 ACCU2
ACCU1 10 20 ACCU1
2 ACCUS
antes 100V, 200V, 300V e depois
S7300

Figura 3.7: Função POP
ENT (Speed7 e S7400 – 4 Acumuladores)

As CPUs Speed7 e S7400 possuem 4 acumuladores divididos em duas pilhas sendo uma
entre o ACCU1 e o ACCU2 e outra entre o ACCU3 e o ACCU4. Enquanto a instrução
Load é a que carrega um novo valor na pilha do ACCU1/ACCU2, ENT (“enter
accumulator stack”) é a instrução que carrega um novo valor na pilha do ACC3/ACCU4
e esse valor vem do ACCU2, conforme Figura 3.8. A função PUSH seria outra forma de
entrar com valores no ACCU3 e ACC4, mas ela altera o conteúdo do ACCU2. O ENT é
normalmente usado antes de uma instrução Load para salvar o valor do ACCU2 para
uso posterior.
ACCU4 40 30 ACCU4
ACCU3 30 20 ACCU3
ACCU2 20 20 ACCU2
ACCU1 10 10 ACCU1
antes depois
Figura 3.8: Função ENT
LEAVE (Speed7 e S7400 – 4 Acumuladores)

A instrução LEAVE “Puxa” os conteúdos do ACCU3 para o ACCU2 e do ACCU4 para o
ACCU3 não alterando os valores do ACCU1 e do ACCU4, conforme Figura 3.9. O que ela
faz é exatamente o que uma instrução Matemática faz após ser executada. Dessa
forma pode-se usar o LEAVE para dar as instruções de lógicas Booleanas com
Word/Dword a mesma funcionalidade das instruções aritméticas.
ACCU4 40 40 ACCU4
ACCU3 30 40 ACCU3
ACCU2 20 30 ACCU2
ACCU1 10 10 ACCU1
antes depois
Figura 3.9: Função LEAVE

CAW
Essa instrução inverte os dois primeiros bytes do ACCU1 não alterando os bytes três e
quatro, conforme Figura 3.10.
ACCU1
Byte 4 - HH Byte 3 - HL Byte 2 - LH Byte 1 - LL
Byte 4 - HH Byte 3 - HL Byte 1 - LL Byte 2 - LH
Figura 3.10: Função CAW
CAD
Essa instrução inverte os quatro bytes do ACCU1, conforme Figura 3.10.
ACCU1
Byte 4 - HH Byte 3 - HL Byte 2 - LH Byte 1 - LL
Byte 1 - LL Byte 2 - LH Byte 3 - HL Byte 4 - HH
Figura 3.11: Função CAD
INC
A instrução INC incrementa o conteúdo do primeiro byte do ACCU1 (ACCU1-LL) com
uma constante no formato inteiro de 8 bits (0 a 255). Ela não altera os demais bytes do
ACCU1(ACCU1-LH, ACCU1-HL e ACCU1-HH) nem os demais acumuladores (ACCU2,
ACCU3 e ACCU4). Porém, como ela considera o ACCU1 com sendo um número inteiro
de 8 bits, deve-se tomar cuidado ao incrementar um número inteiro ou duplo inteiro,
pois o resultado será imprevisível, conforme Figura 3.12.
Resultado inesperado,
Soma com sucesso, pois se somou um INT
pois se trabalhou com de 16 bits com um INT
inteiros de 8 bits de 8 bits

Figura 3.12: Função INC
DEC
A instrução DEC decrementa o conteúdo do primeiro byte do ACCU1 (ACCU1-LL) com
uma constante no formato inteiro de 8 bits (0 a 255). Ela não altera os demais bytes do
ACCU1(ACCU1-LH, ACCU1-HL e ACCU1-HH) nem os demais acumuladores (ACCU2,
ACCU3 e ACCU4). Porém, como ela considera o ACCU1 com sendo um número inteiro
de 8 bits, deve-se tomar cuidado ao decrementar um número inteiro ou duplo inteiro,
pois o resultado será imprevisível. A Figura 3.12 demonstra através de uma instrução
INC a necessidade de se tomar esse cuidado e como as instruções são semelhantes o
exemplo serve para a DEC também.
INVI / INVD
Podem-se usar as instruções INVI e INVD quando se deseja inverter os valores dos bits
do ACCU1 (complemento de um). A INVI inverte todos os 16 bits dos dois primeiros
bytes do ACCU1 (ACCU1-LL e ACCU1-LH) enquanto a INVD inverte os valores dos bits
dos quatro bytes do ACCU1, conforme Figuras 3.13 e 3.14. Depois da execução dessas
instruções, o bit que tinha valor “1” vira “0” e o que tinha valor “0” passa a ter “1”.
ACCU1-HH ACCU1-HL ACCU1-LH ACCU1-LL
Copia Bits Inverte Bits
Figura 3.13: Função INVI
Inverte Bits
Figura 3.14: Função INVD

NEGI / NEGD
Essas instruções invertem o sinal do ACCU1 para os números inteiros (INT e DINT). Isso
representa um complemento de dois, o que também poderia ser feito realizando um
complemento de um (INVI e INVD) e depois somando um, conforme Figura 3.15.
Inverte Bits - INVD
INC 1
Figura 3.15: Demonstração do Complemento de dois NEGD = INVD + INC 1
NEGR
Essa instrução inverte o sinal do ACCU1 considerando que ele continha um número
REAL. Diferentemente das funções NEG para números Inteiros (NEGI e NEGD) que
trabalham com complemento de dois, essa instrução apenas inverte o bit mais
significativo do ACCU1, de acordo com a Figura 3.15.
Inverte Bit
Expoente – 8bits Mantissa – 23bits
do sinal
Figura 3.16: Funções NEGR

RLDA / RRDA
As instruções RLDA e RRDA deslocam todos os 32 bits do ACCU1 em uma posição para
a esquerda e para a direita, respectivamente. O bit que fica livre depois do
deslocamento terá seu valor igual ao bit CC1 antes da instrução, conforme se pode
observar no exemplo de um RRDA na Figura 3.17. Percebe-se também que ao final da
instrução o Bit que saiu terá seu valor armazenado no CC1. Essas funções zeram os Bits
CC) e OV.
Antes:
CC1=
ACCU1=
Depois:
CC1=
ACCU1=
Recebeu o valor
do CC1 antes do
RRDA
Figura 3.17: Função RRDA

Anotações:

Números Reais – Ponto Flutuante
S = Sinal
0 = Positivo
1 = Negativo f = Mantissa = 23bits
e = Expoente = 8bits
Representação:
Limites:
0.0
Figura 4.1: Formato do Número REAL - IEEE 754-1985

O Step7 usa o padrão IEEE 754-1985 para representação de seus números REAIS. Ele define a
formatação dos números com pontos-flutuantes assim como suas operações (soma,
subtração, multiplicação, divisão, logaritmo, exponencial, sin, cos, tan etc.), as formas de
arredondamentos e conversões e as exceções possíveis.
O formato, conforme pode ser visto na Figura 4.1, consiste em três elementos principais:
1. S = Sinal
O sinal é representado pelo bit mais significativo, ou seja, o bit 31. Se ele for igual a
zero (Falso) o número REAL é positivo, e se for igual a um (Verdadeiro) o número é
negativo.
2. e = Expoente
Representa o expoente e possui 8 bits. Dessa forma pode variar de 0 a 255.
3. f = Mantissa (fração)
Constitui a parte fracionária do número e contém 23 bits
Um número REAL inválido existirá quando ao tentar visualizar uma memória ou os

acumuladores como Ponto-Flutuante, a representação é mostrada como Hexadecimal
(D#16#7FFF FFFF).
Isso poderá acontecer, por exemplo, ao se tentar achar a Raiz Quadrada do número REAL -2.0,
como pode-se observar na Figura 4.2. O Step7 não entra em “Stop” nem gera registro no

Buffer de Diagnóstico devido a erros em operações matemáticas, como a citada previamente
ou uma divisão por zero, sendo necessário para isso a análise dos Bits OV, OS, CC0 e CC1 da
Status Word.
Número REAL
Inválido
Bits OV, OS, CC0 e
CC1 = 1
Figura 4.2: Número REAL Inválido
Operações Matemáticas com Números REAIS
Funções Fundamentais
As operações aritméticas fundamentais com números Reais no step7 são semelhantes
as operações com números Inteiros e Duplo-Inteiros. Dessa forma precisa-se apenas
informar que a soma, por exemplo, será de números REAIS: +R.
a) Soma: +R
b) Subtração: -R
c) Divisão: /R
d) Multiplicação: *R
Funções Estendidas
As operações estendidas com números Reais manipulam somente o ACCU1 e usam os
bits OV, OS, CC0 e CC1 para informar algum erro na execução das mesmas. Com isso,
os acumuladores ACCU2, ACCU3 e ACCU4 não são alterados. As funções disponíveis
são:
a) Eleva ao Quadrado: SQR =

b) Raiz Quadrada: SQRT = √
c) Exponencial: EXP =
d) Logaritmo Natural: LN =
Com relação ao Logaritmo na base Natural, o valor do ACCU1 deve ser um número
REAL positivo, senão a função irá retornar um erro, setando os bits OV, OS, CC0 e CC1
em “1”.
Segue na Figura 4.3 um exemplo do uso das funções EXP e LN para achar a solução da
equação: . Como o Step7 não possui uma instrução que calcule qualquer
potência de um número, será necessário utilizar as funções EXP e LN para chegar à
seguinte equação: .

Equação:
Onde,
W = 2.0
Y = 3.0
Figura 4.3: Exemplo das instruções LN e EXP
Funções Trigonométricas
Também é possível trabalhar com as funções trigonométricas e suas funções inversas.
Todavia, o Step7 trabalha com a medida de ângulos em Radiano e dessa forma, para as
funções trigonométricas, faz-se necessário converter o ângulo de entrada para
Radiano e o inverso para as funções de Arco. Esse valor deverá estar no ACCU1 no
formato REAL e o resultado será devolvido também para o ACCU1. As funções
disponíveis são:
a) Seno: SIN = SIN(ACCU1)

b) Cosseno: COS = Cos(ACCU1)
c) Tangente: TAN = TAN(ACCU1)
d) Arco-Seno: ASIN = ASIN(ACCU1)
e) Arco-Cosseno: ACOS = ACOS(ACCU1)
f) Arco-Tangente: ATAN = ATAN(ACCU1)
= 90°
180° = = 0°
270°
Figura 4.4: Dados para conversão Graus => Radianos

Anotações:

Endereçamentos com o Step-7
Opções de Endereçamento
Endereçamento Direto Endereçamento Indireto
Absoluto Simbólico
Memória indireta Registrador indireto
Ponteiro – 16 Bits Ponteiro – 32 Bits Ponteiro – 32 Bits Ponteiro – 32 Bits

(DB, FC, T, C) Área Interna Área Interna Área Cruzada
Figura 5.0: Endereçamentos com o Step-7
Endereçamento Direto
Todo acesso às áreas de memórias do CLP são realizados através da estrutura descrita na
Figura 5.1. Essa é composta pela Instrução + Área de memória + Endereço Inicial do Byte e Bit.
As formas representadas na Figura 5.1 mostram exemplos de Endereçamentos Diretos de
Bytes/Words/DWords e Bits.
L MW 100
Instrução T QW 124 Endereço
Inicial
Byte e Bit
Área de
Memória
A I 124.0
Instrução AN I 124.1 Endereço
Inicial
Byte e Bit
Área de
Memória
Figura 5.1: Estrutura do Endereçamento do Step-7
A leitura e o entendimento do programa tornam-se mais fáceis quando o endereçamento

direto é utilizado, sendo possível identificar exatamente as posições de memória que estão
sendo lidas e/ou escritas pelo programa.

Endereçamento Simbólico
Quando são utilizados símbolos para memórias, se está realizando um Endereçamento Direto
Simbólico. O símbolo é uma “máscara” que o editor associa a um endereço absoluto de
memória e tem como principal finalidade facilitar a identificação dessa através de um nome
(Símbolo), Tipo(Bool, Bytes, Word, Dword, REAL etc) e descrição. Quando se efetua um
download do programa para a CPU, somente os endereços absolutos são enviados e dessa
forma esse tipo de endereçamento existe apenas no editor.
L “PEÇAS PRODUZIDAS”
T “DISPLAY”
Endereço
Instrução Simbólico
Figura 5.2: Endereçamento Simbólico
A Figura 5.3, traz dois exemplos de programas idênticos. A diferença é que no exemplo de cima
não foram atribuídos Símbolos e no exemplo de baixo sim. Alternar entre Endereçamento
Direto Simbólico e Absoluto é possível através do Menu “View/Display With” do Editor de
Blocos, uma vez que isso é apenas uma mudança de visualização.
A chamada de blocos e DBs também possibilitam a utilização dos Endereçamento Diretos

Simbólico e Absoluto, conforme pode ser visto na Figura 5.4.
Figura 5.3: Representações de Endereçamentos Diretos no Step-7
Figura 5.4: Representações de Endereçamentos Diretos no Step-7
Endereçamento Direto utilizando Data Block (DB/DI)

Os Data Blocks (DB,DI) são utilizados pelos blocos lógicos do programa (OB,FC,FB) para
armazenamento de dados. Para isso é necessário que o Data Block a ser utilizado seja
aberto antes da instrução de leitura ou escrita.
A CPU possui dois registradores de Data Blocks, onde ficam armazenados os números
dos blocos que estão sendo utilizados no momento. O primeiro registrador (DB
Register) é de uso exclusivo de um Data Block (DB). Já o segundo registrador (DI
Register) é de uso exclusivo de um Data Block Instance (DI).
Existem duas opções para se abrir um DB ou DI no Step-7. As Figuras 5.5 e 5.6 trazem
exemplos da forma direta, onde são utilizadas as instruções OPN DB e OPN DI. Já a
Figura 5.7 ilustra um exemplo de uma instrução combinada: L DB10.DBW0. Ela é
“combinada” porque realiza duas instruções: abre o DB10 e ainda carrega no ACCU1 o
valor do DBW0 desse DB. Se por um lado ela executa duas instruções onde às vezes
poderia ser usada apenas uma, por outro lado ela permite o uso de símbolos, o que
facilita a leitura do programa.
Figura 5.5: Exemplo de utilização de DB e DI juntos
Figura 5.6: Exemplo de Utilização de dois DB´s abrindo o bloco separadamente
Figura 5.7: Exemplo de Utilização de dois DB´s utilizando instrução combinada
Instruções com registradores DB e DI

Quando se está monitorando um Bloco Lógico, é possível verificar através das colunas
DB1 (DB) e DB2 (DI) quais os blocos estão abertos no momento, conforme pode ser
visto na Figura 5.8:
Figura 5.8: Visualizando os registradores do DB e do DI abertos

Após o número do DB ser guardado em um dos registradores é possível através do
programa obter algumas informações referentes ao Data Block em uso, que serão
tratadas abaixo.
DBNO / DINO
Os comandos DBNO e DBNI retornam o número do DB que está aberto no momento.
A informação é retirada dos registradores (DB register / DI register), respectivamente.
Os comandos podem ser utilizados individualmente. O resultado fica armazenado no
ACCU1. A Figura 5.9 demonstra o uso da instrução e pode-se observar que o valor do
ACCU1 (standard) é 5, ou seja, o DB que está em uso é o DB 5.
Figura 5.9: Carregando no ACCU1 o número do DB aberto
DBLG / DILG
Os comandos DBLG e DILG retornam o tamanho do DB em bytes que estão abertos no
momento, sendo que a instrução DBLG é para Data Blocks e o DILG é para os Data
Blocks Instance. O resultado fica armazenado no ACCU1.
Figura 5.10: Carregando no ACCU1 a quantidade de Bytes do DB aberto
CDB
O comando CDB faz com que o DB e o DI que estão abertos e guardados nos
registradores sejam trocados de posição. Desta forma o número atual do DB será
movido para o registrador DI e o número do DI será movido para o registrador de DB.
A instrução CDB não altera o valor do ACCU1 e nem influência nos bits de status.

Figura 5.11: Resumo dos Endereçamentos Diretos do Step-7
Anotações:

Endereçamento Indireto
Quando se faz um Endereçamento Direto de memórias tem-se a Instrução seguida da

identificação da Área de Memória e do Endereço Inicial do Byte/Bit. No Endereçamento
Indireto, tanto a Área de Memória como o seu Endereço Inicial do Byte/Bit podem ser
definidos indiretamente através de uma Memória ou Registrador. As variáveis utilizadas para o
endereço indireto são chamadas comumente de: PONTEIROS ou INDEXADORES. Essas podem
conter desde informações simples como o número de um DB ou bloco que será aberto, até
informações mais complexas que definam a Área de Memória, o Endereço Inicial do Byte/Bit, o
Tipo do dado (BOOL, BYTE, INT, DINT, REAL) etc. Para isso existem alguns tipos de Ponteiros, os
quais serão descritos abaixo:
Tipos de Ponteiros
Ponteiros de 16 bits
Utilizado para endereçamento indireto de memória de Temporizadores, Contadores,
abertura de Data Blocks, FCs e FBs.
Utilizado para endereçamento indireto as Áreas de Memórias. Pode ser usado como
Ponteiro de Área Interna (área de memória predeterminada pela instrução) e Ponteiro
de Área Cruzada (área de memória variável). Os Registradores de Endereços (AR1 e
AR2) são Ponteiros de 32 Bits.
Utilizado para passagem de parâmetros para blocos (FB´s e FC´s). Contém área cruzada
e declaração do número do DB. Esse formato de dado é chamado de POINTER.
Utilizado para passagem de parâmetros para blocos (FB´s e FC´s). Contém área
cruzada, declaração do número do DB, tipo de dado e fator de repetição. Esse formato
de dado é chamado de ANY.

Endereçamento Indireto com Memória – Ponteiro de 16 Bits
OPN DB [MW 200] = OPN DB100
MW200 = = 100 (Decimal)
Inteiro de 16 Bits sem sinal = 0 a 65535

Figura 5.12 – Estrutura do Endereçamento Indireto de 16 Bits
Para se realizar um Endereçamento Indireto de Temporizadores, Contadores ou Blocos

(FC, FB, DB e DI) serão utilizadas memórias de 16 bits (Word). Ela é interpretada como
um número inteiro de 16 Bits sem sinal (de 0 até 65535), de acordo com a Figura 5.12.
O Exemplo da Figura 5.13 mostra a abertura indireta de um DB. Percebe-se que a única
informação necessária é o número do DB, que cabe em 16Bits e está contido na
memória MW200.
Figura 5.13: Exemplo abrindo DB utilizando endereçamento indireto:
Para chamada de blocos FC´s ou FB´s é necessário utilizar as instruções UC (chamada

de bloco incondicional) ou CC (chamada de bloco condicional). Os blocos de funções
FBs somente poderão ser chamados de forma indireta se o mesmo não estiver
utilizando parâmetros de interface (IN, OUT, INOUT). Para chamada de blocos de
forma indireta a instrução CALL não é aceita.
Figura 5.14: Exemplo abrindo DB utilizando endereçamento indireto:
Nota
Sempre que o valor da memória for igual a “0” e o programa mandar abrir um DB ou
um DI de forma indireta, será alocado o número “0” no registrador de DB. Porém a CPU
não interpretará como uma falha, com isso a mesma continuará seu funcionamento
normal.

Anotações:

Endereçamento Indireto de Área Interna com Memória – Ponteiro de 32 Bits
A I [MD200] = A I 124.6
Instrução
Área de
Memória
Ponteiro de 32 Bits
Endereço Inicial
(Byte + Bit)
MD200
MB200 MB201 MB202 MB203
31 19 18 3 2 0
Sem uso = 124(Decimal) = 6(Decimal)

Byte Inicial Bit Inicial
Inteiro de 16 Bits 3 bits
sem sinal
Figura 5.15 – Estrutura do Endereçamento Indireto de 32 Bits - Área Interna
Quando se deseja realizar um acesso indireto a memórias (Bit, Byte, Word e Dword)
dentro de uma mesma Área de Memória (M, I, Q, L, PI/PQ), precisa-se de um ponteiro
com no mínimo 32 Bits. Esse tipo de endereçamento Indireto é chamado de Área
Interna porque se aponta para diferentes Bytes/Bits iniciais dentro de uma mesma
Área de memória, que precisa ser declarada na instrução, EX: L DBW[MD200].
Nesse caso, para acessar indiretamente um Bit de Entrada Digital não bastará que o
PONTEIRO contenha apenas uma informação, um número, como é o caso do
PONTEIRO de 16 Bits. Será necessário um PONTEIRO com no mínimo duas
informações, uma que indique o número do Byte de Entradas Digitais e outra que
indique o número do Bit dentro deste Byte. Essa estrutura está exemplificada na Figura
5.15. Nela, os Bits menos significativos ( Bits 0,1 e 2) indicam o número do Bit que será
acessado enquanto que os 16 Bits seguintes ( Bits 3 a 18 ) Indicam o número do Byte
que será acessado. Os demais Bits não são processados pela instrução. Nota-se que a
Área de Memória, (Imagem de Entradas = “I”) foi indicada na instrução e por isso o
ponteiro estará sempre variando dentro das Entradas Digitais.
Nota
Sempre que forem utilizadas as instruções Load (L) ou Transfer (T), basta indicar qual o
número do byte a ser endereçado indiretamente, ou seja, o endereço do bit deve ser
sempre passado como 0. Caso isso não aconteça e o endereço do Bit seja diferente de
zero a CPU identificará um erro de “Alinhamento de Memória” e entrará em modo
Stop.

Carregando uma constante de Ponteiro
Para carregar uma constante de ponteiro de 32 bits no acumulador, deve-se utilizar a

sintaxe descrita na Figura 5.15.
L P#10.0 Endereço
Área Interna
T MD 200 Byte = 10
Instrução
L DBW [MD200} Bit = 0
Formato de
Ponteiro 32 Bits
Figura 5.16: Representação de uma Constante no Formato Ponteiro
A Figura 5.16 traz um exemplo onde se carrega uma constante no formato de

ponteiro. Nela, a Instrução L ( Load) carrega no acumulador 1 um valor em formato de
PONTEIRO (P#) cujo endereço corresponde ao Bit 0 do Byte 10. Com a instrução T (
Transfer), o valor do acumulador 1 é transferido para a Double Word MD200. Depois, a
Instrução “L DBW [MD200]” utiliza a Double Word MD200 como PONTEIRO para o
acesso indireto da memória DBW10 do DB que estiver aberto no momento.
Depois de carregar uma constante no formato ponteiro 32 bits em uma variável é

possível que o seu valor/endereço seja alterado através do programa, onde utilizam-se
as operações aritméticas normais de Duplo-Inteiros (+D, -D, +D, /D). A Figura 5.17 traz
um exemplo do incremento de ponteiro de área interna em dois bytes, onde a Word
IW10 é transferida para a Word QW10 e depois de incrementado o ponteiro, a Word
IW12 é transferida para a Word QW12.
Figura 5.17: Incrementando um Ponteiro de Área Interna – 32 Bits

O endereçamento indireto pode ser utilizado para uma infinidade de tarefas, mas é em
conjunto com a instrução LOOP que ele é mais usado. Isso pode ser visto na Figura
5.18, que traz um exemplo de endereçamento indireto de área interna para zerar 10
Words a partir do endereço inicial MW200.
Figura 5.18: Exemplo de uma Instrução de Loop com Ponteiro de Área Interna - Zera uma seqüência de Memórias
Nota
Quando se trabalha com Endereçamento Indireto de Área Interna com Memórias,

pode-se solicitar a visualização da Coluna de monitoramento “INDIRECT”, conforme
Figura 5.17. Nela será possível saber qual o endereço (Byte + Bit) que se está sendo
acessado indiretamente.

Anotações:

Endereçamento Indireto de Área Interna com Registradores – AR1 e AR2
A I [AR1, p#0.2] = A I 124.2

Instrução
Offset de
Endereço a ser
Área de
somado ao
Memória
Registrador AR1
de Endereços
AR1
L M W [AR1, p#1.0] = L MW125

Instrução
Offset de
Endereço a ser
Área de
somado ao
Memória
Registrador AR1
de Endereços
Qtd de Bytes: AR1
B = 1 Byte
W = 2 Bytes
D = 4 Bytes
AR1
31 19 18 3 2 0
Sem uso = 124(Decimal) = 0(Decimal)

Inteiro de 16 Bits 3 bits
sem sinal
Figura 5.19 – Endereçamento Indireto de Área Interna com o Registrador de Endereços 1 - AR1
As CPUs do Step-7 possuem dois Registradores de 32 Bits, reservados para

endereçamentos indiretos no formato de ponteiro de 32 Bits, conforme Figura 5.19.
Eles são chamados de AR1(Address Register 1) e AR2(Address Register 2). Esses dois
registradores trabalham de forma independente, pois diferentemente dos
acumuladores (ACCU1, ACCU2), quando se carrega um valor no AR1, o AR2 permanece
inalterado.
Declarações de instruções com Endereçamento Indireto de Área Interna com

Registradores podem ser vistas na Figura 5.19. Nesse caso, o AR1 possui as
informações de Byte e Bit iniciais, mas ainda é possível somar Offsets antes de se
acessar o endereço de memória. O Offset não altera o valor do AR1.
Para se carregar um endereço indireto na área dos registradores, utiliza-se o comando

LAR1 ou LAR2. O comando LAR1 copia o conteúdo atual do ACCU1 para dentro da área
do registrador, sendo utilizado o LAR1 para o registrador AR1 e o LAR2 para o
registrador AR2.

Carregando uma constante de Ponteiro de Área Interna nos Registradores
Existem duas formas para carregar nos registradores uma constante no formato
ponteiro. A Figura 5.20 demonstra essas opções, onde na primeira o endereço é
carregado primeiramente no ACCU1 através da instrução Load. Depois o conteúdo do
ACCU1 é transferido para o AR1 pela Instrução LAR1. Isso normalmente é feito quando
se deseja manipular um endereço antes de carregá-lo no AR1. A outra forma elimina a
necessidade de se manipular o ACCU1 e carrega o endereço diretamente no AR1
através de uma instrução Combinada.
L P#10.0
Carrega o Endereço
P#10.0 no ACCU1 LAR1 Transfere o
Conteúdo do
ACCU1 para o
AR1
LAR1 P#10.0
Carrega o Endereço
P#10.0 diretamente
no AR1
Figura 5.20: Carregando uma Constante no Formato Ponteiro para o AR1
Nota
Não se pode usar o AR2 quando se trabalha em um FB, pois esse já utiliza o AR2 para
acesso aos parâmetros contidos no Bloco de Dados DI. Quando se trabalha com
múltiplas instâncias pode-se utilizar o TAR2 para carregar no ACCU1 o endereço inicial
dos Dados do FB em questão dentro do DI.
Uma das vantagens de se trabalhar com os registradores de endereços para

Endereçamentos indiretos de Área Interna é que se pode monitorá-los habilitando a
coluna de monitoramento AR1 no Editor de Blocos. A figura 5.21 retrata isso.
Figura 5.21: Monitorando o AR1 pelo Editor

Anotações:

Anotações:

Endereçamento Indireto de Área Cruzada com Registradores – AR1 e AR2
A [AR1, p#0.2] = A M 124.2

Instrução
Offset de
Endereço a ser
Registrador somado ao
de Endereços AR1
AR1
L W [AR1, p#1.0] = L MW125

Instrução
Offset de
Endereço a ser
Qtd de Bytes: somado ao
B = 1 Byte AR1
Registrador
W = 2 Bytes
de Endereços
D = 4 Bytes
AR1
AR1
31 26 25 24 19 18 3 2 1 0
Área Cruzada = 124(Decimal) = 0(Decimal)

Área de Memória Inteiro de 16 Bits 3 bits
000 Periferia de I/O sem sinal
001 Imagem das Entradas - I
010 Imagem das Saídas - Q
011 Memórias - M
100 Bloco de Dados - DB
101 Bloco de Dados Instância - DI
110 Variáveis Locais (#Temp) - L
111 Parâmetros de Bloco
(IN, OUT, INOUT)
Figura 5.22 – Endereçamento Indireto de Área Cruzada com o Registrador de Endereços 1 - AR1
O Endereçamento Indireto de Área Cruzada permite variar a Área de Memória que se

deseja acessar e não mais somente o Endereço Inicial (Byte e Bit) que é o caso da Área
Interna. Isso somente é possível através dos registradores de endereço, AR1 e AR2. Na
Figura 5.22, percebe-se que as declarações das instruções não determinam a Área de
memória, estando essa codificada em três Bits dentro do Ponteiro de 32 Bits – AR1.
Nele, os bits 24, 25 e 26 especificam a Área de Memória de acordo com a tabela
existente na Figura 5.22. Para que o Step7 entenda o ponteiro como sendo de Área
Cruzada, o 31º Bit deverá estar em “1”.
Carregando uma constante de Ponteiro de Área Cruzada nos Registradores
Existem duas formas para carregar nos registradores uma constante no formato
ponteiro de Área Cruzada. A Figura 5.23 demonstra essas opções, onde na primeira o
endereço é carregado primeiramente no ACCU1 através da instrução Load. Depois o
conteúdo do ACCU1 é transferido para o AR1 pela Instrução LAR1. Isso normalmente é
feito quando se deseja manipular um endereço antes de carregá-lo no AR1. A outra
forma elimina a necessidade de se manipular o ACCU1 e carrega o endereço
diretamente no AR1 através de uma instrução Combinada.
L P# M10.0
Carrega o Endereço
P#M10.0 no ACCU1 LAR1 Transfere o
Conteúdo do
ACCU1 para o
AR1
LAR1 P#M10.0
Carrega o Endereço
P#M10.0 diretamente
no AR1
Figura 5.23: Carregando uma Constante no Formato Ponteiro de Área Cruzada para o AR1
Nota
Não se pode carregar diretamente no AR1 um endereço de um parâmetro de bloco FC

(IN, OUT, INOUT), sendo necessário para isso o uso de instruções separadas. Carrega-se
primeiramente o endereço no ACCU1 e depois o transfere para o AR1. Em blocos FB,
isso é permitido.
Instruções com Registradores de Endereço

LAR1 / LAR2
As instruções mais utilizadas e que já foram vistas anteriormente são o LAR1 e o LAR2,
onde se carrega o valor atual do ACCU1 para o registrador solicitado: AR1 ou AR2.
TAR1 / TAR2
Também é possível realizar a função contrária, ou seja, devolver ao ACCU1 o valor

atual que está armazenado nos registradores. Para isso utilizamos as instruções TAR1
ou TAR2, conforme pode ser visto na Figura 5.25.
Figura 5.24: Carregando o Valor do AR1 no ACCU1 e “vice-versa”
Da mesma forma que as instruções LAR1 e LAR2 trabalham com instruções

combinadas, o TAR1/TAR2 pode ser declarado da seguinte forma: “TAR1 MD600”.
Nesse caso o conteúdo do AR1 é transferido diretamente para a DWord MD600. Deve-

se observar que a memória utilizada para receber o valor do endereço indireto é uma
DWord, tendo em vista que o AR1 e o AR2 sempre estarão no formato Ponteiro 32
Bits. Também é possível transferir esse valor para Variáveis Locais (#Temp) e Data
Blocks (DB ou DI).
CAR
Os registradores AR1 e AR2 trabalham de forma independente, onde um não afeta o

trabalho do outro. Porém é possível realizar a troca de seus conteúdos, invertendo os
valores atuais que estão armazenados dentro de cada um. Para isso utilizamos a
instrução CAR.
+AR1 / +AR2
Uma das principais vantagens de se usar os registradores de endereços é a

possibilidade de se incrementá-los diretamente através da instruções +AR1 e +AR2. O
valor a ser incrementado pode ser especificado através de uma constante: “+AR1
p#2.0”, ou através do valor atual contido no ACCU1: “+AR1”. Esse último é utilizado
quando o valor a ser incrementado é resultado de operações, onde é necessário
manipular esse valor no ACCU1 e ACCU2 para depois adicioná-lo ao AR1 ou AR2.
Anotações:

Anotações:

Parâmetro POINTER – 48 Bits
Byte
7 0
Número do DB Byte N:
INT - 16 Bits sem sinal
(0 a 65535) Byte N+1:
Byte N+2: POINTER

48 Bits - 6 Bytes
Ponteiro de 32 Bits de Byte N+3:
Área Cruzada
Byte N+4:
Byte N+5:
Figura 5.25: Parâmetro de interface de Blocos – POINTER – 48 Bits
Quando se precisa passar para um bloco o endereço inicial de uma memória, usa-se
um parâmetro do tipo POINTER. Ele possui 48 bits, ou 6 bytes, e pode ser utilizado em
FC´s e FB´s como parâmetros IN, INOUT e OUT.
O formato POINTER está demonstrado na Figura 5.25 e consiste em um ponteiro de

área cruzada (ponteiro de 32 bits) mais o número do DB, representado em forma de
número inteiro sem sinal (0 até 65535). Caso o parâmetro POINTER não contenha o
endereço de um DB ou DI, os dois primeiros bytes, que armazenam o número do DB,
serão zerados.
Passagem de Parâmetros do Tipo POINTER
Figura 5.26: Passagem de parâmetros do tipo POINTER – 48 Bits
A Figura 5.26 demonstra duas chamadas de um FC que contém parâmetros POINTER

como IN e OUT. Percebe-se que existem duas formas de se inserir um valor do tipo
POINTER, uma onde se usa o endereço direto da memória (“Origem”) e outra onde se
usa a formatação de ponteiro: p# (“Destino”). Nesse caso precisa-se especificar o Bit.
Ambas funcionam da mesma forma, mas somente a primeira permite visualização de
símbolos.

Usando Parâmetros do Tipo POINTER dentro de um Bloco FC ou FB
Figura 5.27: Acessando parâmetros do tipo POINTER dentro do Bloco
Como um parâmetro POINTER ocupa 48 bits de memória, não se pode carregar no

ACCU1 (32 Bits) todas as informações do POINTER ao mesmo tempo. Sendo assim faz-
se necessário desmembrar o POINTER, transferindo o número do DB para uma variável
de 16 bits e o ponteiro para outra com 32 Bits. O exemplo da Figura 5.27 traz o modelo
de acesso a essas informações, o qual está dividido em três etapas:
1. Carrega-se no ACCU1 o endereço inicial ocupado pela variável POINTER na

área de memória dos parâmetros de Bloco. Depois o transfere-se do
ACCU1 para o AR1.
2. Aponta-se para o endereço contido no AR1 e carrega-se no ACCU1 uma

Word. Ao se observar a Figura 5.25, percebe-se que essa Word contém o
número do DB. Depois se transfere o número do Db para a Word MW40;
3. Ainda apontando-se para o endereço contido no AR1 e somando-se a ele

um Offset de 2 bytes, carrega-se uma DWord que contém o ponteiro
declarado na chamada do Bloco. Feito isso, transfere-se o ponteiro do
ACCU1 para a DWord MD42.

Figura 5.28: Exemplos de declarações Tipo POINTER
Parâmetro ANY – 80 Bits – Áreas de Memórias

Byte
7 0
Sempre = 10h Byte N:
Tipo do Dado Byte N+1: ANY

80 Bits - 10 Bytes
Fator de Repetição Byte N+2:
VALOR TIPO DO
INT - 16 Bits sem sinal (HEX) DADO
(0 a 65535) Byte N+3: 00h VOID
01h BOOL
Número do DB Byte N+4: 02h BYTE
03h CHAR
INT - 16 Bits sem sinal 04h WORD
(0 a 65535) Byte N+5: 05h INT
06h DWORD
07h DINT
Byte N+6: 08h REAL
09h DATE
Ponteiro de 32 Bits Byte N+7: 0Ah TOD
de Área Cruzada 0Bh TIME
Byte N+8: 0Ch S5TIME
0Dh DT
Byte N+9: 0Eh STRING
Figura 5.29: Parâmetro de interface de Blocos – ANY – Áreas de Memórias
Enquanto o parâmetro POINTER fornece o Número do DB e o ponteiro do Endereço

Inicial, o Parâmetro ANY fornece, além disso, um Fator de Repetição e o Tipo do Dado
fornecido. Com isso, em uma única declaração de interface de Bloco pode-se passar 4
informações, conforme Figura5.29. Assim como o POINTER, um dado ANY só existe em
uma interface de Bloco (IN, INOUT e OUT).
Passagem de Parâmetros do Tipo ANY – Áreas de Memórias
Figura 5.30: Passagem de parâmetros do tipo ANY – Áreas de Memórias

A Figura 5.30 demonstra duas chamadas de um FC que contém parâmetros ANY.
Percebe-se que existem duas formas de se inserir um valor do tipo ANY, uma onde se
usa o endereço direto da memória e outra onde se usa a formatação de ponteiro: p#.
Nesse caso precisa-se especificar o Bit, o Tipo e o Fator de Repetição. Ambas
funcionam da mesma forma, mas somente a primeira permite visualização de
símbolos.
Usando Parâmetros do Tipo ANY dentro de um Bloco FC ou FB
Figura 5.31: Figura 5.34: Declarando Variáveis #Temp para Receber dados do ANY
Como um parâmetro ANY ocupa 80 bits de memória (10 Bytes), não se pode carregar
no ACCU1 (32 Bits) todas as suas informações ao mesmo tempo. Dessa forma faz-se
necessário desmembrar o ANY, assim como se faz com o POINTER. O exemplo da
Figura 5.31 traz a declaração de memórias temporárias para receber essas
informações que foram separadas, enquanto a Figura 5.32 demonstra a declaração e o
desmembramento das informações de um Dado ANY.
Figura 5.32: Acessando parâmetros do tipo ANY dentro do Bloco

Parâmetro ANY – 80 Bits – FBs, FCs, DBs, SDBs, T e C
Byte
7 0
Sempre = 10h Byte N:
Tipo do Parâmetro Byte N+1: ANY

80 Bits - 10 Bytes
Sempre = 1h Byte N+2:
Byte N+3:
VALOR TIPO DO
Byte N+4: (HEX) PARÂMETRO
Sempre = 0h
17h Bloco FB
Byte N+5: 18h Bloco FC
19h Bloco DB
Se T ou C = Tipo
Byte N+6: 1Ah Bloco SDB
Se FB, FC, DB, SDB = 0h 1C Temporizador
1D Contador
Sempre = 0h Byte N+7:
Número do FB, FC, Byte N+8:

DB, SDB, T ou C
Byte N+9:
Figura 5.33: Parâmetro de interface de Blocos – ANY – FBs, FCs, DBs, SDBs, T e C
O parâmetro ANY também pode ser usado para passagem de FBs, FCs, DBs, SDBs, T e
C. Nesses casos as informações contidas diferenciam-se de uma declaração de Áreas
de Memórias, pois não se tem Fator de repetição nem Ponteiro de 32 Bits.; A Figura
5.33 demonstra a estrutura de um Dado ANY para esse caso.
Usando Parâmetros do Tipo ANY dentro de um Bloco FC ou FB
Figura 5.34: Declarando Variáveis #Temp para Receber dados do ANY
Como um parâmetro ANY ocupa 80 bits de memória (10 Bytes), não se pode carregar
no ACCU1 (32 Bits) todas as suas informações ao mesmo tempo. Dessa forma faz-se
necessário desmembrar o ANY, assim como se faz com o POINTER. O exemplo da
Figura 5.34 traz a declaração de memórias temporárias para receber essas
informações que foram separadas, enquanto a Figura 5.35 demonstra a declaração e o
desmembramento das informações de um Dado ANY.

Figura 5.35: Acessando parâmetros do tipo ANY dentro do Bloco
Anotações:

Anotações:

Dados com Mais de 32 bits – “Complexos”
Tipo do Dado Quantidade de Bytes Exemplo
Date and Time 8 ( 64 Bits) DT#10-01-02-12:45:00.0
String QTDE de Caracteres + 2 ‘ORKAN’
Array Variável ARRAY[1..365] OF INT
Struct Variável ...
UDT Variável ...

Figura 6.1: Tipo de Dados com mais de 32 bits – Dados Complexos
Conforme já foi descrito no Capítulo “Funções com Acumuladores”, todo processamento de

Bytes, Word e Dwords é executado nos acumuladores. Como esses possuem 32 bits cada, as
instruções do Step7 estão restritas a trabalharem nessa faixa. Os dados complexos existem
para permitir ao usuário criar variáveis que excedam essa faixa e dessa forma personalizar o
programa de acordo com a necessidade da aplicação. Embora essas variáveis não possam ser
acessadas em suas totalidades pelas instruções diretas no Step7, isso pode ser feito através de
um conjunto delas.
Anotações:

DATE_AND_TIME
Byte
7 0
Ano: Byte N:
Mês: Byte N+1:
Dia: Byte N+2:
Hora: Byte N+3:
DATE_AND_TIME
Minuto: Byte N+4:
64 Bits - 8 Bytes
Segundos: Byte N+5:
Byte N+6: Byte N+7: 1 = Domingo

2 = Segunda
7 0 7 0 3 = Terça
4 = Quarta
5 = Quinta
6 = Sexta
Milissegundos Dia da 7 = Sábado
(000...999) Semana
Figura 6.2: Variável DATE_AND_TIME
As variáveis complexas do tipo DATE_AND_TIME (DT#) possuem 8 bytes e armazenam as

informações de Ano, Mês, Dia, Hora, Minuto, Segundo, Milissegundo e dia da Semana. Cada
valor desses está formatado como BCD e ocupa um Byte, exceto os milissegundos (usa 12 bits)
e o dia da semana (usa 4 bits), conforme Figura 6.2.
Ela poderá ser usada como parâmetro de blocos FCs e FBs, assim como em DBs e UDTs, mas
não se pode declarar uma constante no formato DT#. Quando se quer usar esse tipo de
variável tem-se que montar o valor byte a byte, conforme Figura 6.3. Outra forma de fazer isso
é usando o FC 3 "D_TOD_DT" ou as demais Funções de DT# da Biblioteca: FC 1, FC 3, FC 6, FC 7,
FC 8, FC 33, FC 34, FC 35, FC 40.
A Figura 6.3 demonstra o uso de variáveis DATE_AND_TIME para Ajuste do Relógio da CPU.
Nesse caso o valor dos Milissegundos é ignorado, considerando-se Zero, e o Dia da Semana é
calculado automaticamente.

Figura 6.3: Usando uma Variável DATE_AND_TIME para ajustar o Relógio da CPU

ARRAY
Figura 6.4: Exemplo de declaração de Array em um DB
Um Array, também conhecido como “Vetor”, representa uma série de elementos de dados,
geralmente do mesmo tamanho e tipo. Cada elemento individual pode ser acessado por seu
Índice ou posição no Array. Eles podem ser unidimensionais ou multidimensionais (no máximo
6 dimensões) e poderão ocupar no até 8kb para o System 100V, 200V, 300V e S7300 e 64kb
para o Speed7 e S7400.
Um Array pode ser declarado em DBs, UDTs ou como parâmetro em um FC, FB e OB (#Temp).
O Figura 6.4 demonstra o uso de Arrays em DBs enquanto a Figura 6.5 mostra como declarar
Arrays como Parâmetro de Blocos. Nela também segue um exemplo do uso de Arrays do tipo
BOOL (#Conexão[1,1]).
Figura 6.5: Exemplo de declaração e uso de um Array como um Parâmetro de Bloco de Função FC

Acessando todo o Conteúdo de um Array
Como um Array pode ocupar bem mais do que 32bits (limite dos ACCUs da CPU), para
se acessar todo o seu conteúdo tem-se que usar um parâmetro de bloco do tipo ANY.
Nesse caso deverá ser declarado na chamada do bloco o símbolo do Array, conforme
Figura 6.6. Nesse caso não será possível escrever o endereço absoluto, mas sim apenas
o simbólico.
Figura 6.5: Exemplo de declaração e uso de um Array como um Parâmetro de Bloco de Função FC
Anotações:

STRUCT
Figura 7.3:
Visão geral
No exmplo acima, um ARRAY [1..4] dimensional simples com componentes do tipo

STRUCTé declarado dentro do DB6 ("Turn_6") com o editor de bloc incremental.
A estrutura sucessiva consiste de três componentes dos quais os dois

primeiros, isto é, "START" e"STOP" têm o tipo de dado BOOL . O terceiro componente
tem um tiop de dado complexo ARRAY[1..10].
Os componentes deste tipo de ARRAY[1..10] são sucessivamente do tipo

STRUCT com os componentes REAL "Cutoffpoint_front", "Cutoffpoint_ back" e
"Stoppingpoint" .
Acesso de STRUCTs
Os componentes individuais podem ser endereçados como segue, por exemplo:
• L "Turn_6".Axis[3].Position[7].Cutoffpoint_back
• S "Turn_6".Axis[2].START, etc.
Inicialização de STRUCTs
Os componentes de estrutura individual podem ser valores pré-escolhidos na

declaração (column “Initial Value”) (não com parâmetros FC, parâmetros de entrada e
saída de FBs ou variáveis temporárias). Os tipos de dados dos valores de inicialização
devem ser compatíveis com os tipos de daos dos componentes.

Aceitação dos Valores de Inicialização
Se novos valores de inicialização são inseridos na visualização de declaração dos DB’s,

estas alterações somete tornam-se efetivas (válidas como valor atual) depois que o
item de menu Edit -> Initialize Data Block for executado. Na declaração dos
parâmetros de entrada e saída nos FBs, os valores de inicialização dos STRUCTs são
aceitos como valor atual no instante em que os Db’s são gerados.
Inserindo parâmetros de STRUCTs
Figura 7.3:
Visão geral
Uma estrutura pode ser inserida como uma variável completa em um bloco de
parâmetro que é do mesmo tipo de dado ou é do tipo dado apontador ou ANY.
Assim o conteúdo completo de uma variável estrutura pode ser copiado

dentro de outra área marcada com, por exemplo, ajuda da função de sistema SFC 20
BLKMOV.
Componentes individuais estrutura podem também ser inseridos em um

parâmetro de bloco, se o parâmetro de bloco e os componentes do estrutura são do
mesmo tipo de dados.
Variáveis do Tipo STRUCT
A alimentação de parâmetro de bloco definido como estrutura, pode somente ser

simbólica. Para isto, a estrutura deve ser definida de antemão (parâmetros atuais),
com a mesma estrutura (dimensão, tipo de dado, etc.) que um bloco de parâmetro.

Os parâmetros atuais, isto é, a variável estrutura pode ser localizada no bloco
de dados (DB instance ou DB compartilhado) ou na área de dados locais do bloco
chamado.
Parâmetros Internos Inseridos no FC
Depois que o Editor STL/LAD/FBD checou (checando tipo) a compatibilidade dos tipos
de dados dos parâmetros atuais com aqueles dos parâmetros de blocos durante a
inserção de parâmetros no FC, somente a inserção de um apontador, isto é, o
endereço inicial do parâmetro atual do FC chamado permanece.
Esta visualização absoluta de um bloco chamado é mostrada quando o bloco é

aberto online via Nós de Acessibilidade. Neste caso não existe informação simbólica
offline que permitirá a recompilação do bloco chamado em sua forma simbólica.
Armazenamento de Variáveis STRUCT na Memória
Figura 7.4:
Visão geral
A figura acima mostra como variáveis STRUCT são armazenadas na memória.
Conhecendo exatamente as variáveis ARRAY armazenadas na memória é então

necessário que, durante o runtime, os componentes individuais sejam acessados via
endereçamento indireto de memória ou registrador.
Armazenamento De Variáveis
Uma variável STRUCT sempre inicia pela palavra limite, isto é, em um byte com
endereço par. Subseqüentemente, componentes individuais são colocados na
seqüência conforme declaração na memória. Uma variável STRUCT ocupa a memória
até a próxima palavra limite.
Componentes com tipo de dados BOOL inicia no bit mais significativo, componentes
com tipo de dados BYTE e CHAR iniciam no endereço do byte par. Componentes com
outros tipos de dados sempre iniciam na próxima palavra.
Anotações:

STRING
Figura 7.5:
Visão geral
O tipo de dado STRING é usado para armazenar caracteres string ( por exemplo:
mensagens de texto). Deste modo uma simples “(mensagem) sistema de
processamento de palavra” pode ser implementada em uma CPU S7. O tipo de dado
STRING representa um caracter string de até 254 caracteres.
O número especificado entre colchetes na declaração (1..254) dá o número máximo de

caracteres que pode ser salvo na variável STRING. Se não existir esta informação o
editor STL/LAD/FBD assume o comprimento de 254 caracteres.
Acesso das Variáveis STRING
Os caracteres individuais de uma variável STRING podem ser acessados com a ajuda
das instruções STL elementares, tais como:
• L StringName[5] (carrega o quinto caracter que está armazenado na

variável)
O processamento atual da variável STRING ( mensagens de texto) é possível via os FC’s

– biblioteca IEC.
Inicialização
Na declaração, as variáveis do tipo de dados STRING podem ser pré-escolhidas com

texto início ( não como parâmetros de blocos para um FC, como parâmetros de
entrada e saída em um FB ou como variável tamporária). A inicialização pode ser feita

com caracteres em ASCII que são digitadas entre aspas simples. Se caracteres
especiais para controlar o termo forem incluídos, então o caracter dolar (§) deverá ser
colocado na frente.
Caracteres especiasi utilizados:
• §§ Caracter dolar simples
• §L, §l line feed (LF)
• §P, §p page feed
• §R, §r carriage return
• §T, §t tabulator
Armazenamento de Variáveis STRING na Memória
Figura 7.6:
Visão geral
A variável do tipo de dado STRING possui no máximo 256 bytes, dos quais até 254 "net
data", isto é, caracteres podem ser aceitos.
Armazenamento De Variáveis
Uma variável STRUCT sempre inicia pela palavra limite, isto é, em um byte com
endereço par. No setup da variável, seu máximo comprimento é introduzido no
primeiro byte da variável de acordo com a declaração de variáveis. Do mesmo modo,
na pré-escolha ou no processamento, o comprimento corrente utilizado, que é o
comprimento do caracter STRING salvo é introduzido no segundo byte com a ajuda das
funções da biblioteca IEC. Ambas as informações são requeridas pelas funções da
biblioteca IEC no processamento das variáveis STRING.
Funções para Processamento de Variáveis STRING
Figura 7.6:
Visão geral
Com a instalação do STEP7, a biblioteca StdLib30 e a sub-biblioteca IEC são também

instaladas, elas contêm funções para processar tipos de dados IEC.
A figura acima lista as funções para processar as variáveis do tipo STRING.
Nota
As funções, em geral, executam avaliação de erros com a ajuda de detalhes sobre

máximo comprimento ou autal comprimento usado. Se as funções reconhecem um
erro, então, geralmente, o bir BR é colocado em “0”.
A descrição detalhada das funções individuais podem ser encontradas na ajuda online
da biblioteca IEC.

Anotações:

UDTs
Figura 7.6: UDTs
Visão geral
Quando uma estrutura de dados é repetida freqüentemente no programa do usuário

ou quando uma estrutura de dados usa o mesmo nome, então o Step 7 permite que
tipo de dados definidos pelo usuário (UDT) sejam definidos (assim como typedef na
linguagem de alto nível “C”)
Através do uso do tipo de dado relacionados na aplicação, a tarefa executada pode ser
programada com mais eficiência. Usuários como fabricantes podem projetar e isntalar
tipos de dados adaptados ao seu problema.
Geração de UDTs
UDTs são gerados com o editor incremental ou com o editor de texto e então serem
armazenados no bloco recipiente como blocos únicos (UDT1 ... UDT65535).
Um nome simbólico pode então ser escolhido para este UDT ou estrutura de dados
relacionados através de um nome na tabela de símbolo global.
Um template geral válido é gerado através da UDT, que pode então ser usado tão
freqüente quanto desejado na declaração de novas variáveis ou para gerar DB’s
compartilhados.

Uso de UDTs
Figura 7.6: Uso de UDTs
Visão geral
No exemplo acima, a UDT5 é gerada com quatro componentes (ON, OFF,

SetpointSpeed and ActualSpeed) para uma estrutura dirigida e então inserida no FC23
na declaração dos parâmetros de entrada e saída.
Um ARRAY dimensional simples com 10 componentes do tipo de dado UDT5é

declarado no FC23.
Valores Iniciais Para UDTs
Tipos de dados definidos pelo usuário são pré-escolhidos e usados como estrutura. A
estrutura da UDT é igual àquela para a STRUCT. A declaração de variáveis, que pode
ser processada pelo programa do usuário, não tem entretanto resultado com a
geração de uma UDT.
A UDT representa de preferência um tamplate, que pode ser usado tão frequente
quanto desejado para a declaração de novas variáveis. Exatamente como a estrutura o
usuário também tem a possibilidade de estabelecer valores iniciais no UDT. Se a UDT é
então usada para a declaração de variáveis, o conteúdo destas variáveis são
inicializados como os valores iniciais da UDT (não parâmetros em Fc’s, para parâmetros
de Entrada e saída de FB’s ou variáveis temporárias).
Geração de DBs
Uma UDT pode também ser usada como padrão para a geração ( Dialog: New Data
Block) de blocos de dados compartilhados. Neste caso um DB é setado com a mesma
estrutura e com os valores iniciais das respectivas UDT’s.

Utilizando as Bibliotecas
Figura 7.8: Bibliotecas
Introdução
Bibliotecas são usadas para armazenar componentes de programas reutilizáveis para

SIMATIC S7/M7. Os componentes dos programas podem ser copiados de projetos
existentes para dentro da biblioteca ou eles podem ser gerados diretamente na
biblioteca independente de qualquer projeto em uso.
As mesmas funcionalidades de um projeto estão disponíveis para a geração do

S7-Programs na biblioteca – com exceção do teste.
Configuração
Os projetos e bibliotecas são configurados de maneira hierárquica:
• bibliotecas podem conter programas S7.
• um programa S7 pode conter exatamente um "Block" ("Programa usuários")

um "Sources", um "Charts“, um "Symbols"(tabela de símbolos).
• Na pasta "Blocks“ os blocos podem ser transferidos para a CPU. Já as tabelas

de variáveis (VAT) não podem ser transferidas para a CPU..
• Na pasta "Sources" contém arquivos fontes gerados em arquivo ASCII.

• Na pasta "Charts" contém o CFC-Charts (somente para uso com o
software S7-CFC)
Quando você inseri um novo programa S7, as pastas “Block”, “Sources” e “Symbols”
são criadas automaticamente.
Usando as Bibliotecas
Você criando a sua biblioteca ou utilizando uma standard estará disponível para uso
sempre, podendo ainda ser copiada para um outro Simatic Manager.
Configuração e Conteúdos das Bibliotecas Standard
Figura 7.9:
Introdução
Duas bibliotecas são automaticamente instaladas no seu hard disk com a instalação
software STEP7.
• a biblioteca standard stdlibs(V2) para Versão 2 e
• Standard Library V3.x para Versão 3.
Você pode copiar destas duas bibliotecas os blocos para dentro do seu projeto quando
precisar usá-los.
Abrindo Biblioteca
Para abrir a biblioteca, utilize o comando: File -> Open ou utilize o ícone associado na
barra de ferramentas.
Será perguntado pelo software se você quer abrir uma biblioteca ou um projeto.
Biblioteca Standard
A StdLib30 biblioteca standard contém os programas S7 a seguir:
• Communication Blocks: contém as funções para conectar I/O distribuídos

utilizando-se de CP Profibus - S7-300.
• IEC Converting Blocks: contém blocos para funções IEC ex. para
manipulação de dados em formatos DATE_AND_TIME e STRING.
• Organization Blocks: contém todas as funções de sistema para S7-300/400
• PID Control Blocks: contém blocos de função para controle PID.
• S5-S7 Converting Blocks: com os blocos standard você converte programas S5

para S7
• System Function Blocks: contém todas as funções de sistema para S7-300/400
• TI-S7 Converting Blocks: blocos standard utilizados com freqüência

ex. escala de valores analógicos, etc.
Anotações:

System Functions
Figura 8.0: System Functions
Introdução
Funcionalmente, não se pode implementar instruções no STEP 7 (ex. criação de DB,

comunicação com outros CLPs, etc.). Para poder implementar no STEP7 é necessário
utilizar as funções de sistema (SFCs) ou blocos de funções de sistema (SFBs).
SFCs e SFBs são blocos armazenados no sistema operacional das CPU’s em vez de
utilizar memória do usuário. Com isto, estes blocos jamais poderão serem apagados e
estarão sempre disponível para o usuário.
Não é possível alterar os blocos de sistema SFC e SFB. Estes blocos estão protegidos
onde o usuário somente pode utiliza-los conforme conta nos manuais.
No programa do usuário, os SFBs e SFCs podem ser chamados através da instrução

CALL.
Manual
A descrição extensiva dos system functions podem ser encontrados nos manuais:
•System Software Reference Manual para S7-300/400, System Functions e

Standard Functions.
Ajuda On-line
A maioria dos blocos são parametrizáveis, ou seja, para utilização dos mesmos é
necessário configura-los para um perfeito funcionamento. Para isto estão disponíveis
manuais para configuração de todos os blocos SFC e SFB.

• Help topics -> Block help -> Help with SFBs/SFCs .
Introdução sobre System Functions (Parte 1)
Figura 8.1:
Copiando Funções e Blocos de Funções
• SFC 20 copia o conteúdo da área de memória (origem) para outra área de

memória (destino)
• SFC 21 preencher a área de memória (campo de destino) com o conteúdo

da área de memória (campo de origem)
• SFC 22 cria um DB sem valores de preset na memória de trabalho (vazio)
• SFC 23 cria um DB na área de memória e possibilita carregar na memória.
• SFC 24 determina se DB está presente na área de trabalho (com tamanho).
• SFC 25 comprimi a área de memória. Aloca na área de memória correta os
e libera os espaços ocupados por blocos apagados.

• SFC 44 (chamado no OB 122) salva o valor da falha nos módulos no Accu1
Programa Controle
• SFC 35 triggers, com multicomputing, sincroniza o start do OB 60 para

todas as CPUs
• SFC 43 inicia a CPU e monitora o tempo de ciclo novamente

• SFC 46 coloca a CPU para o modo STOP
• SFC 47 retarda o tempo de ciclo em até 32767 µs
Relógio
• SFC 0 altera a data e hora do relógio interno CPU
• SFC 1 lê a data e hora atual da CPU
• SFC 48 sincroniza todos os relógios dos escravos presentes no bus.
Contador de Horas
A CPU tem um número especifico de contadores de horas no qual você pode gravar a
duração da operação do equipamento.
• SFC 2 seta o contador de horas para um especifico valor
• SFC 3 inicia e para a operação de contagem de horas
• SFC 4 lê o número corrente de operações de horas e seu status
• SFC 64 lê da CPU’s o tempo do sistema.

Figura 8.2:
Transferir Data Records
Esta área de dados de sistema grava os parâmetros e diagnósticos de parâmetros-

associados aos módulos. Está área contém dados gravados de 0 até 255 onde você
pode ler ou escrever..
• SFC 55 transfere os parâmetros ativos para o endereço do modulo.

Os parâmetros gravados no SDB da CPU não podem ser sobrescritos.
• SFC 56 transfere os parâmetros (data record RECNUM) para o modulo.
• SFC 57 transfere todos os data records do SDB para os modulos.
• SFC 58 transfere o GRAVADO data record para o modulo.
• SFC 59 lê o data record GRAVADO dos modulos.
Tempo Interrupções
Estes blocos são usados para controle de processo através de data e hora (OB 10 to
17). Você pode determinar o ponto de início destes blocos através do STEP7 ou
utilizando o bloco de system functions.
• SFC 28 seta a data e hora de início para a execução do OB.
• SFC 29 apaga a data e hora de início de execução do OB (OB 10 to OB 17).

• SFC 30 ativa um tempo específico para interrupção do OB.
• SFC 31 verifica o status do tempo de interrupção do OB.
Retardo Interrupções
• SFC 32 inicia um tempo de atraso do OB (OB 20 to 27).
• SFC 32 cancela um interrupção por atraso.
• SFC 34 varre o status do tempo de interrupção.
Erros Sincronismo
• SFC 36 mascara um erro de sincronismo
• SFC 37 desmascara um erro sincronizado
• SFC 38 leitura do registro de erro
Interrupção e erros Asynchronous
• SFC 39 desabilita o processo de interrupção e eventos asynchronous error
• SFC 40 habilita novamente o processamento de interrupção de erros

asynchronous
• SFC 41 atrasa o processamento de interrupção e erros asynchronous
• SFC 42 habilita novamente o processamento de atrasos na interrupção e erros

asychronous.

Figura 8.3:
Sistema de Diagnósticos
• SFC 6 lê as informações de inicio do OB chamado anteriormente
• SFC 51 lê uma parte da lista de status de sistema. A lista contém:

dados de sistema, buffer de diagnósticos.
• SFC 52 o usuário escreve no campo do diagnóstico buffer.
Imagem de Processo, Área I/O
• SFC 26 atualiza o conjunto ou parte da tabela memória imagem de

entrada
• SFC 27 transfere o conjunto ou parte tabela memória imagem de saída

para os módulos
• SFC 79/ 80 são usados para setar e resetar os bits dos campos da área
de I/O em conjunto com a função Master Control Relay function
Endereçando os Módulos
• SFC 5 suprir o endereço lógico para endereço físico
• SFC 49 determina o endereço físico do endereço lógico
• SFC 50 suprir todos os endereços lógicos do módulo
I/O Distribuído

• SFC 7 manda o programa do usuário de um escravo inteligente (CPU
315-2DP) interromper o hardware de um DP master
• SFC 11 sincroniza um ou vários grupos de escravo DP
• SFC 13 lê o diagnostico de um escravo DP
• SFC 14 lê dados consistentes de um escravo DP
• SFC 15 escreve dados consistentes para um escravo DP
Dados de Comunicação Global
As áreas de dados global são transferidas ciclicamente sem utilizar o SFC. Com a ajuda
dos SFC 60 e 61 blocos de sistemas, enviam e recebem pacotes de dados pelo
programa do usuário sempre que necessário.
• SFC 60 envia pacote de dados globais
• SFC 61 recebe pacotes de dados globais

Figura 8.4:
Troca de dados via SFBs
Os SFBs são usados para trocar dados e para administrar os programas via conexões
configuradas. SFBs existe somente para o sistema operacional S7-400.
• SFC 62 determina o estado do CFB local instance e o estado das conexões

associadas.
• SFB 8 envia dados para a estação remota sem coordenação
• SFB 9 é um complemento para o SFB 8
• SFB 12 envia dados (até 64 KByte) para a estação remota com reconhecimento.
• SFB 13 recebe dados da estação remota com reconhecimento.
• SFB 14 lê os dados da CPU remota (comunicação unilateral)
• SFB 15 escreve dados para a CPU remota (comunicação unilateral)
• SFB 16 envia dados com formatação para a impressora remota
• SFB 19 força um restart completo para a estação remota
• SFB 20 passa a estação remota para o modo STOP
• FB 21 executa o restart da estação remota

• SFB 22 mostra os status do dispositivo (estado operacional, informação de
erros) da estação remota.
• SFB 23 recebe o status do dispositivo da estação remota.
Troca de dados via SFCs
Essas comunicações - se referem para comunicação básicas - é implementadocom S7-

300 e também com o S7-400. Comparado com os SFB as seguintes diferenças podem
ser observadas:
• não necessita configurar a conexão
• não requer data blocks instance
• máximo de dados com tamanho de 76 bytes
• comunicação ativa para configuração
• comunicação via MPI ou bus K

Figura 8.5:
Controle integrado De malha fechada
Esses blocos são integrados em algumas versões de CPU’s.
Tecnologia Avançada
Para as CPU 614 (S7-300), blocos individuais podem ser criados em linguagem “C” . O
SFC 63 system function é usado para chamar esses blocks.
Funções Integradas
Estes blocos existem somente para as CPU 312 IFM (S7-300).
Você pode achar a descrição completa no manual Funções Integradas
• SFB 29 contador de pulsos para entradas integradas da CPU.
• SFB 30 é usado para medir freqüências via entradas integradas.
IEC Temporizadores e Contadores
Com essas funções de temporizadores e contadores estão disponíveis de acordo com

IEC 1131-3 padrão. Estes blocos são remanescentes das funções encontradas no
SIMATIC S5, com funcionamento compatível.
Os temporizadores e contadores IEC diferem na faixa de valores de uso para

temporizadores e contadores.
A biblioteca: S5 - S7 Convertendo blocos
Figura 9.2:
Introdução
Esta biblioteca contém blocos padrões do S7 necessários para a conversão de

programa em S5. Isto significa que se o bloco padrão FB 240, por exemplo, estiver
presente em programa em S5, o bloco FC 81 substitui na biblioteca o bloco padrão FB
240.
Porque o conversor somente transmite a chamada do bloco FC 81, você deve copiar o
bloco chamado da biblioteca dentro do seu programa em S7.
Conteúdo da Biblioteca
Os blocos Biblioteca são divididos dentro das seguintes funções:
• Aritmética em ponto flutuante, assim como adição e subtração.
• Funções de sinais, assim como primeiro sinal com freqüência duplo

flash
• Funções integradas, assim como conversor de código BCD --> Dual
• Funções lógicas básicas, assim como LIFO
Manual
Os blocos são descritos detalhadamente no manual “Converting from STEP 5

Programs”.
Ajuda Online
No Editor de Programa, você chama ajuda --> Help topics --> References --> Additional
reference aids --> Help with S5/S7 functions.
Assim flags de rascunho também são usados por estes blocos como é típico no
SIMATIC S5.
A biblioteca : TI - S7 Convertendo blocos (Parte 1)
Figura 9.3:
FC 80
A função FC80 inicia o tempo com o latch delay aceso (TONR). O FC80 acumula o valor
do tempo até que o valor corrente de tempo do tempo de run time (ET) seja o mesmo
que o valor de tempo preset (PV) ou o tenha excedido.
FC 81
Com a função indireta de transferência da faixa de dados (IBLKMOV), você pode
transferir uma faixa de dados consistindo de bytes, words, inteiros (16 bits), double
words, ou inteiros (32 bits) de uma fonte para o destino.
Os apontadores S_DATA e D_DATA apontam, para estruturas do tipo de dado

"POINTER" que determina o início da área fonte e da área destino. O comprimento da
área a ser copiada é determinado através de parâmetros separados.
FC 82/83
Seta o estado do sinal dos bits em um área especificada como “1” (FC 83) ou como
"0"(FC 82), se o bit MCR é “1.” Se o bit MCR é ”0,” o estado do sinal dos bits na área
não é alterado.
FC 84-FC92
Lidar com funções de tabela para implementar funções FIFO, por exemplo.Os valores
são inseridos no formato word e o comprimento é ajustável.
FC 93-FC 99
Este grupo faz várias conversões de funções avaliadas.

A biblioteca : TI - S7 Convertendo blocos (Parte 2)
Figura 9.4:
FC 100-FC 101
A função (RSETI) reseta o estado do sinal dos bits em uma faixa específica de bytes
para ”0” ou para "1" no FC 101, se o bit MCR é ”1.” Se o bit MCR é ”0,” o estado do
sinal dos bytes na faixa não são alterados.
FC 102
A função desvio padrão (DEV) calcula o desvio padrão do grupo de valroes
armazenados na tabela TBL). O resultado é armazenado na saída OUT. O desvio
padrão é calculado de acordo com a seguinte fórmula:
Desvio padrão =
• Sum = Soma dos valores na TBL N = número de valores na TBL
• SqSum = Soma de todos os valores na TBL
FC 103
As funções das tabelas de dados correlacionadas (CDT) comparam um valor de entrada
(IN) com com valores de entrada de uma tabela já existente (IN_TBL) e olha para o
primeiro valor que é maior ou igual ao valor de entrada.

Com a ajuda do index do valor local, o valor é então copiado para o valor de saída
respectivo (OUT) na tabela de valores de saída (OUT_TBL).
FC 105-FC 106
São usados para escalonar valores analógicos para escala de engenharia e serve a uma
Entrada Analógica (FC105) ou a uma Saída Analógica (FC106).
FB 80- FB 86
Refere ao manual eletrônico.
Anotações:

Manipulando Erros no Step7
Através de “Blocos de Organização” (Organization Blocks - OB) o usuário pode interagir com o
sistema operacional da CPU. Esses blocos são chamados pela CPU e controlam o
funcionamento normal da CPU, as interrupções (hardware, cíclica, Data e hora etc), o
comportamento da CPU no início de funcionamento e a Manipulação de Erros, que é o assunto
desse capítulo.
No Step7 o usuário pode programar a CPU para reagir aos diferentes tipos de erros que podem
acontecer, sendo possível existir um procedimento para tipo de erro que acontece com a CPU.
Algumas falhas permitem que a CPU continue em execução enquanto outras possibilitam
apenas que a CPU registre o erro antes de entrar em modo “STOP”.
Toda vez que um Bloco de erro é chamado, ele recebe em suas Variáveis #Temp as
informações sobre a falha que acabara de acontecer. É através da análise dessas variáveis
Locais que o programa trata a falha. Por exemplo, quando ocorre uma falha na alimentação
24Vdc da CPU ela pode, antes de ser desligada, setar um bit de alarme para que o
supervisório/IHM registre aquela falha.
Existem dois tipos básicos de erros: Síncronos e Assíncronos, os quais serão abordados nesse
capítulo.
Anotações:

Erros Assíncronos
Os erros assíncronos acontecem independentemente do ciclo da CPU, ou seja, podem

acontecer a qualquer momento e não estão vinculados a um determinado momento
do ciclo.
OB Descrição
OB80 Erros de Tempo - Tempo Máximo de Ciclo Excedido
OB81 Erro de Alimentação – Falha na Bateria, Falha na Alimentação etc
Interrupção para Diagnóstico – Quebra de fio em um módulo com
OB82
capacidade de diagnóstico
Interrupção para Remover/inserir módulo – “Troca a Quente”
OB83
Obs.: Somente para o S7400
Erro de Harware na CPU – Ausência de Sinal na Interface MPI
OB84
Erro de Seqüência de Programa – Erro na troca da imagem do processo
OB85
OB86 Erro nos Racks – Erros na Rack central, Profibus e Profinet
Erro de Comunicação – Erro n e comunicação com FB’s ou “Global
OB87
Data”
OB80 - Erro de Tempo

O ciclo de monitoração de tempo tem um valor padrão de 150 ms. O sistema
reconhece um erro de tempo se a duração do ciclo for maior que 150 ms. Se o erro
ocorre duas vezes no mesmo ciclo, a CPU vai para STOP.
OB81 - Erro da Fonte de Alimentação

Ocorre com a ausência da bateria backup ou se a mesma estiver descarregada. No
S7400 além destes motivos, ocorre ainda com a falta da alimentação de 24 V no
dispositivo central ou de expansão.
Para outros diferentes tipos de erro a CPU, sem erros de OB, permanece em RUN e o
led vermelho de erro acende na CPU.
OB82 - Interrupção para Diagnóstico

Módulos capazes de diagnosticar, como alguns módulos analógicos, podem disparar
uma interrupção para diagnóstico no caso de um erro. A interrupção para diagnóstico
será habilitada pelos parâmetros designados nos módulos.
OB83 - Interrupção para Remover/Inserir Módulos

É disparada pela inserção ou retirada de módulos no CLP S7400. Na inserção de
módulos, o sistema em operação checa se foi inserido o tipo de módulo correto. Esta
função possibilita a remoção ou inserção de módulos com o programa em ciclo.

OB84 - Erro de Hardware da CPU
No S7-400, estes erros são reconhecidos na interface MPI através do K-Bus ou através
do módulo de interface para I/O distribuído.
OB85 - Erro de Seqüência de Programa

Resulta dos erros de acesso de I/O na troca da imagem de processo ou, por exemplo,
na ausência de um OB para a parametrização de interrupção de hora e data.
OB86 - Falência de Rack

Esse bloco é chamado na entrada e saída de um evento de falha em um Rack, em uma
sub-rede de uma rede de CLP’s ou em uma estação de I/O distribuído (Profibus
DP/Profinet).
OB87 - Erro de Comunicação

No S7300 quando há identificação de mensagem incorreta no recebimento de dados
compartilhados ou quando o bloco de dados é pequeno para armazenar a informação
de status. No S7400 existem outras além destas causas, por exemplo, quando o envio
de mensagens de sincronização não é possível.

Erros Síncronos
Os erros síncronos são aqueles que acontecem em um momento específico do ciclo da

CPU e conseqüentemente acontecerá toda vez que o programa execute aquela função.
OB Descrição
OB121 Erros de Programação
OB122 Erros de Acesso a I/O
O OB121 é chamado com um erro de programação. O OB122 é chamado com um erro

de acesso a periferia. Se ocorrer um erro desses e o OB específico não foi carregado na
CPU, ela vai para “STOP”. A CPU não pára devido ao erro, mas sim porque não foi
carregado um procedimento (OB121 ou OB122) para “tratar” o erro.
Um OB de erro síncrono tem a mesma prioridade que o bloco no qual ocorreu o erro.
Por esta razão os registradores dos blocos interrompidos podem ser acessados no OB
de erro síncrono. Isso permite ao programa no OB de erro síncrono retornar os
registradores (com conteúdo alterado) para o bloco interrompido.
OB121 – Erros de Programação
Figura 9.5: Variáveis Temporárias do OB121
O OB121 trata os erros relacionados à programação. Ou seja, Cahama de FC que não

foi carregado na CPU, start de temporizador com a base “S5T” errada, acesso a um DB
que não foi carregado, acesso a área de memória que não existe etc.
Seguem abaixo as descrições das variáveis #Temp do OB121.
OB121_SW_FLT
B#16#21: Erro de Conversão BCD.

B#16#22: Erro comprimento de faixa durante leitura.
B#16#23: Erro comprimento de faixa durante escrita.
B#16#28: Acesso de leitura indireta de BYTE, WORD ou DWORD com bit

de endereço diferente de 0 (Mal alinhamento durante leitura).
B#16#29: Acesso de escrita indireta de BYTE, WORD ou DWORD com bit

de endereço diferente de 0 (mal alinhamento durante escrita).
Obs.: Nesses últimos dois casos(B#16#28 e B#16#29), OB121_FLT_REG contém

o endereço do byte de falha e o OB121_RESERVED_1 contém o tipo de acesso
e a área de memória, descritos abaixo:
Bits 0, 1, 2 e 3 (Área de memória)

0: I/O área
1: PII
2: PIQ
3: Bit de memória
4: DB Global
5: DB de instance
6: Dados locais próprios
7: Dados locais de chamada
Bits 4, 5, 6, e 7 (Tipo de acesso):
0: Bit de acesso
1: Byte de acesso
2: Word de acesso
3: Double word de acesso
B#16#24: Erro de faixa durante leitura.
B#16#25: Erro de faixa durante escrita.
B#16#26: Erro no número de temporizador (número inválido em

OB121_FLT_REG).
B#16#27: Erro no número de contador (número inválido em

OB121_FLT_REG).
B#16#30: Acesso escrita DB compartilhado prot.escrita (No. Inv. no

OB121_FLT_REG)
B#16#31: Acesso escrita DB instance prot. escrita DB (No. inv. no

OB121_FLT_REG)
B#16#32: Número do erro no acesso de DB compartilhado (No. in

OB121_FLT_REG)
B#16#33: Número do erro no acesso de DB instance (No. in

OB121_FLT_REG)

B#16#34: Número de erro na chamada de FC (No. Inválido no
OB121_FLT_REG).
B#16#35: Número de erro na chamada de FB (No. Inválido no

OB121_FLT_REG)
B#16#3A: Acesso de DB não carregado (No. in OB121_FLT_REG)
B#16#3C: Acesso de FC não carregado (No. in OB121_FLT_REG)
B#16#3D: Acesso de SFC não carregado (No. in OB121_FLT_REG)
B#16#3E: Acesso de FB não carregado (No. in OB121_FLT_REG)
B#16#3F: Acesso de SFB não carregado (No. in OB121_FLT_REG)
OB122 – Erros de Acesso a I/O
Figura 9.6: Variáveis Temporárias do OB122
O OB122 é chamado quando a CPU não consegue acessar uma memória de Periferia,
ou seja, um módulo. Esse falha Também acontece quando um FC tenta acessar uma
parâmetro de entrada o qual não foi fornecido na chamada do Bloco.
OB122_SW_FLT
B#16#42: S7-300: erro de acesso I/O, leitura
B#16#43: S7-300: erro de acesso I/O, escrita S7-400: primeira escrita de

acesso após ocorrer um erro
B#16#44: Só para S7-400: erro para o enésimo (n>1) acesso de leitura

após um erro ocorrido.

B#16#45: Só para S7-400: erro para o enésimo (n>1) acesso de escrita
após um erro ocorrido.
OB122_MEM_AREA
A variável #OB122_MEM_AREA contém informações sobre o tipo de acesso e a

área de memória:
Bits 0, 1, 2 e 3 (Área de memória)

0: Área de I/O
1: Tabela Imagem de Entrada(I)
2: Tabela Imagem de Saída(Q)
Bits 4, 5, 6 e 7 (Tipo de acesso)

0: Acesso a Bit
1: Acesso a Byte
2: Acesso a Word
3: Acesso a Double Word
Mascarando Erros Síncronos

S7 tem os seguintes SFCs, com os quais você pode mascarar e desmascarar eventos
iniciais no OB 121 enquanto seu programa está sendo processado:
• SFC36 "MSK_FLT": Mascara códigos de erros específicos
• SFC37 "DMSK_FLT": Libera máscara os códigos de erro que foram

mascarados pelo SFC36
• SFC38 "READ_ERR": Lê o registro de erros.
Anotações:

Anotações:

Apostila S7-N2

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila S7-N2

Enviado por

Direitos autorais:

Formatos disponíveis

Step-7 / Nível 2

Orkan Automação Industrial Pág. 2 Step-7 / Nível 2

Orkan Automação Industrial Pág. 3 Step-7 / Nível 2

Orkan Automação Industrial Pág. 4 Step-7 / Nível 2

Orkan Automação Industrial Pág. 5 Step-7 / Nível 2

Memory Code Memory Code Periferia de  Imagem de I/O

Acumuladores Registradores de Registradores de Status Word

ACCU4 – 32Bits Registradores

Figura 1.1: Registradores e Áreas de Memória de uma CPU S7

Registradores de Data Blocks

Status Word (Palavra de Status)

Orkan Automação Industrial Pág. 6 Step-7 / Nível 2

Existem quatro áreas de memórias nas CPU´s S7

Memória de Carga (Load Memory)

Memória de Trabalho (Work Memory)

Orkan Automação Industrial Pág. 7 Step-7 / Nível 2

Resultado Binário – BR – 28 20 – /FC – First Check

Bit de Resultado 1 – CC1 – 27 21 – RLO – Resultado de

Overflow – OV – 25 22 – STA – Bit de Status

Overflow Retentivo – OS – 24 23 – OR – Lógica OU

Figura 1.2: Status Word (Palavra de Status)

O /FC = 0 indica o fim da lógica, pois foi

Figura 1.3: Análise dos Bits RLO, STA e /FC - STL

20 – /FC – First Check

Orkan Automação Industrial Pág. 8 Step-7 / Nível 2

Atribui o RLO, naquele

RLO sempre STA – Status

21 – RLO – Resultado de Operação Lógica

Figura 1.5: Exemplo com SET e CLR

Orkan Automação Industrial Pág. 9 Step-7 / Nível 2

OR = Verdadeiro. Indica que a

Orkan Automação Industrial Pág. 10 Step-7 / Nível 2

Figura 1.7: Análise do Bit OV e uso da instrução “A OV”

26 – CC0 e 27 – CC1 – Bits de Resultado

 Depois de Instruções Matemáticas, sem Overflow

CC1 CC0 Significado

CC1 CC0 Significado

Orkan Automação Industrial Pág. 11 Step-7 / Nível 2

CC1 CC0 Significado

CC1 CC0 Significado

CC1 CC0 Significado

Figura 1.8: Uso do Bit BR para Chamada de Blocos de instruções

Já na Figura 1.8, uma instrução aritmética salva no BR a informação de Overflow para

Orkan Automação Industrial Pág. 12 Step-7 / Nível 2

Figura 1.7: Uso do Bit BR para Chamada de Blocos de instruções

Orkan Automação Industrial Pág. 13 Step-7 / Nível 2

Orkan Automação Industrial Pág. 14 Step-7 / Nível 2

Orkan Automação Industrial Pág. 15 Step-7 / Nível 2

Figura 2.0: Instruções de Salto no Step-7

As instruções no Step7 que manipulam os acumuladores, registradores de endereço e de Data

É o identificador de uma posição no programa que é o destino de uma instrução de

Orkan Automação Industrial Pág. 16 Step-7 / Nível 2

A instrução de Salto JU é sempre executada, independentemente do estado do RLO ou dos

Figura 2.1: Exemplo de salto incondicional

Orkan Automação Industrial Pág. 17 Step-7 / Nível 2

Figura 2.2: Exemplo de salto condicional ao RLO

Figura 2.3: Exemplo de salto condicional salvando o estado do RLO no BR

Figura 2.4: Exemplo de salto condicional ao bit BR

Orkan Automação Industrial Pág. 18 Step-7 / Nível 2

Figura 2.5: Exemplo de salto condicional ao bit OV

Figura 2.6: Exemplo de salto condicional se resultado = 0

Figura 2.7: Exemplo de salto condicional se resultado <> 0

Orkan Automação Industrial Pág. 19 Step-7 / Nível 2