APOSTILA AUTOMAÇÃO APLICADA À ENGENHARIA MECÂNICA

Prévia do material em texto

UNIVERSIDADE FEDERAL DE MINAS GERAIS 
ESCOLA DE ENGENHARIA 
DEPARTAMENTO DE ENGENHARIA MECÂNICA 
 
 
 
 
 
 
 
 
PROJETO DE SISTEMAS SEQÜENCIAIS DE 
AUTOMAÇÃO UTILIZANDO CLPS 
 
 
 
 
 
 
 
 
DR. EDUARDO JOSÉ LIMA II 
 
 
 
 
 
 
 
Belo Horizonte, Janeiro de 2007 
 1
 
Sumário 
 
1. INTRODUÇÃO ................................................................................................................................................. 5 
2. SISTEMAS DE AUTOMAÇÃO ...................................................................................................................... 6 
2.1 - TIPOS DE AUTOMAÇÃO .................................................................................................................................... 6 
2.2 - SISTEMAS SEQÜENCIAIS DE AUTOMAÇÃO ...................................................................................................... 7 
2.3 - COMANDOS ELÉTRICOS BÁSICOS ................................................................................................................... 8 
2.3.1 - Elementos de entrada de sinais ..................................................................................................... 8 
2.3.2 - Elementos de processamento de sinais ...................................................................................... 9 
2.3.3 - Elementos de saída de sinais ....................................................................................................... 12 
2.4 - CIRCUITOS SEQÜENCIAIS ELETROPNEUMÁTICOS ......................................................................................... 17 
2.5 - EXERCÍCIOS ................................................................................................................................................... 18 
3. CONTROLADORES LÓGICOS PROGRAMÁVEIS................................................................................. 21 
3.1 - ESTRUTURA ................................................................................................................................................... 21 
3.2 - EXECUÇÃO .................................................................................................................................................... 22 
3.3 - LINGUAGENS DE PROGRAMAÇÃO................................................................................................................. 24 
3.3.1 - Ladder ................................................................................................................................................. 25 
3.3.2 - SFC....................................................................................................................................................... 34 
3.4 - EXERCÍCIOS ................................................................................................................................................... 44 
4. PROGRAMAÇÃO DE SISTEMAS SEQÜENCIAIS EM CLPS................................................................ 46 
4.1 - AUTOMAÇÃO PNEUMÁTICA UTILIZANDO LADDER......................................................................................... 46 
4.2 - AUTOMAÇÃO PNEUMÁTICA UTILIZANDO SFC .............................................................................................. 48 
4.3 - EXERCÍCIOS ................................................................................................................................................... 53 
5. CONVERSÃO DE PROGRAMAS EM SFC PARA LADDER .................................................................. 55 
5.1 - REPRESENTAÇÃO DOS PASSOS .................................................................................................................... 55 
5.2 - REPRESENTAÇÃO DAS TRANSIÇÕES ............................................................................................................ 62 
5.3 - ORGANIZAÇÃO DO PROGRAMA ..................................................................................................................... 64 
5.4 - EXERCÍCIOS ................................................................................................................................................... 69 
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................................................... 71 
 
 2
Lista de Figuras 
 
 
Figura 2.1 – Elemento de entrada de sinal (botoeira). Fonte: [Parker, 2001]. ...................9 
Figura 2.2 – Representação de Sensores. Fonte: [Parker, 2001] ........................................9 
Figura 2.3 – Relé auxiliar. .........................................................................................................10 
Figura 2.4 – Relé auxiliar com contatos comutadores. ........................................................10 
Figura 2.5 – Relé temporizador com retardo na energização.............................................11 
Figura 2.6 – Relé temporizador com retardo na desenergização. .....................................11 
Figura 2.7 – Relé contador. ......................................................................................................12 
Figura 2.8 – Elementos de saída de sinal. .............................................................................12 
Figura 3.1 – Ligações de um CLP. ..........................................................................................22 
Figura 3.2 – Ciclo de execução de um CLP. .........................................................................23 
Figura 3.3 – Representação em diagrama Ladder de contatos NA, NF e bobinas.........25 
Figura 3.4 – Exemplo de programa em Ladder.....................................................................25 
Figura 3.5 – Analogia entre uma memória e um relé auxiliar. ............................................26 
Figura 3.6 – Lógicas E e OU em Ladder. ...............................................................................28 
Figura 3.7 – Auto-retenção em linguagem Ladder. ..............................................................28 
Figura 3.8 – Bobinas com retenção em linguagem Ladder.................................................29 
Figura 3.9 – Equivalência entre programas utilizando bobinas com retenção ................29 
Figura 3.10 – Contatos sensíveis à borda..............................................................................30 
Figura 3.11 – Temporizador TON. ...........................................................................................31 
Figura 3.12 – Temporizador TOFF. .........................................................................................31 
Figura 3.13 – Contador CTU. ...................................................................................................32 
Figura 3.14 – Contador CTD. ...................................................................................................32 
Figura 3.15 – Contador CTUD..................................................................................................33 
Figura 3.16 – Ligações entre passos e transições ...............................................................35 
Figura 3.17 – Exemplo de SFC. ...............................................................................................36 
Figura 3.18 – Divergência e convergência OU......................................................................37 
Figura 3.19 – Divergência e convergência E. ........................................................................38 
Figura 3.20 – Evolução de um SFC. .......................................................................................39 
Figura 3.21 – SFC com conflito (divergência E sem convergência). .................................40 
Figura 3.22 – Bloco de ações associado a um passo ..........................................................41Figura 3.23 – Exemplos de ações. ..........................................................................................42 
Figura 3.24 – Exemplo de condições lógicas associadas transições................................43 
Figura 3.25 – Divisor de freqüência por 2. .............................................................................43 
Figura 5.1 – Programação em Ladder de ação com qualificador S...................................56 
Figura 5.2 – Programação em Ladder de ação com qualificador R. .................................56 
Figura 5.3 – Programação em Ladder de ação com qualificador N. .................................57 
Figura 5.4 – Programação em Ladder de uma mesma ação N acionada em dois passos 
diferentes. ............................................................................................................................57 
Figura 5.5 – Execução da ação com qualificador D. ............................................................58 
Figura 5.6 – Programação em Ladder de ação com qualificador D. .................................58 
Figura 5.7 – Execução da ação com qualificador L. .............................................................58 
Figura 5.8 – Programação em Ladder de ação com qualificador L. ..................................59 
Figura 5.9 – Programação em Ladder de ação com qualificador P...................................59 
Figura 5.10 – Programação em Ladder de ação com qualificador SD..............................60 
Figura 5.11 – Programação em Ladder de ação com qualificador DS..............................60 
Figura 5.12 – Programação em Ladder de ação com qualificador SL. .............................61 
Figura 5.13 – Programação em Ladder de ação com qualificadores P1 e P0.................61 
Figura 5.14 – Programação em Ladder de transição disparada por um sinal de entrada 
do CLP. ................................................................................................................................62 
 3
Figura 5.15 – Programação em Ladder de transição disparada por um sinal de entrada 
do CLP. ................................................................................................................................62 
Figura 5.16 – Programação em Ladder de transição temporizada. ...................................63 
Figura 5.17 – Programação em Ladder de divergência E. ..................................................64 
Figura 5.18 – Programação em Ladder de convergência E................................................64 
Figura 5.19 – Utilização de bit de memória para evitar que mais de uma transição seja 
disparada em um mesmo ciclo de varredura.................................................................66 
Figura 5.20 – Linha de inicialização do programa. ...............................................................66 
 
 4
Lista de Tabelas 
 
Tabela 3.1 – Qualificadores de ações.....................................................................................41 
 
 5
1. Introdução 
 
Essa apostila faz parte do material utilizado na disciplina “Automação Aplicada à 
Engenharia Mecânica” do Departamento de Engenharia Mecânica da Universidade 
Federal de Minas Gerais. 
Inicialmente serão apresentados alguns conceitos fundamentais sobre 
automação, bem como sobre circuitos de comandos elétricos. Serão mostrados os 
aspectos fundamentais do funcionamento dos Controladores Lógicos Programáveis 
(CLPs), necessários ao entendimento dos recursos disponíveis e de suas limitações. 
Os fundamentos da linguagem Ladder serão apresentados, bem como os diagramas 
seqüenciais (SFCs). Por ser a linguagem mais comum de programação de CLPs, será 
apresentada uma metodologia de geração de programas em Ladder a partir de 
programas feitos em SFCs. Ao final de cada parte da apostila são apresentados 
exemplos resolvidos e exercícios a serem feitos pelos alunos. 
 
 6
2. Sistemas de Automação 
 
Automação é o conjunto das técnicas baseadas em máquinas e programas com 
objetivo de executar tarefas previamente programadas pelo homem e de controlar 
seqüências de operações sem a intervenção humana. Através de intertravamentos 
(seqüências de programação) do sistema, o usuário consegue maximizar com 
qualidade e precisão seu processo produtivo, controlando, assim, variáveis diversas 
(temperatura, pressão, nível e vazão) e gerenciando à distância toda a cadeia produtiva 
[Gomes, 2004]. 
 
2.1 - Tipos de automação 
 
Pode-se classificar sistemas de automação em três tipos: automação fixa, 
automação programável e automação flexível. 
Automação fixa utiliza equipamentos concebidos para a produção de 
determinado tipo de peça. É utilizada para volumes de produção muito altos. Possui um 
custo relativamente baixo, porém os equipamentos ficam obsoletos quando há 
mudanças no tipo de peça produzida, já que são capazes de fabricar apenas 
determinados produtos. 
A automação programável é utilizada para volumes mais baixos de produção e 
com grande variedade de produtos. O funcionamento dos equipamentos pode ser 
programado para fabricar diferentes tipos de peças. Dessa forma, as peças podem ser 
fabricadas em lotes, entre os quais os equipamentos devem ser reprogramados. São 
exemplos de sistemas de automação programável robôs, máquinas CNC etc. 
Os sistemas flexíveis de manufatura (FMS) se caracterizam por permitir o 
processamento de produtos com diferentes especificações por meio da troca 
automática de programas dos equipamentos, bem como da alteração da seqüência de 
equipamentos e processos a serem utilizados. Dessa forma, tal tipo de sistema pode 
reunir equipamentos de automação fixa e programável. Toda a produção é integrada 
por computador, que coordena as tarefas a serem realizadas. 
 
 7
2.2 - Sistemas seqüenciais de automação 
 
Sistemas de automação são compostos basicamente por um equipamento de 
controle e pelo sistema controlado. Esses sistemas se comunicam por meio de sinais 
elétricos. Os comandos são enviados pelo equipamento de controle aos atuadores do 
sistema controlado, que convertem tais comandos em ações como forças, movimentos, 
correntes elétricas etc. O estado e as respostas do sistema controlado são medidos por 
meio de sensores, que convertem as grandezas físicas em sinais elétricos que são 
enviados ao equipamento de controle. 
O equipamento de controle deve possuir uma lógica (programável ou fixa) para 
realizar o comando para o sistema controlado de acordo com os sinais recebidos dos 
sensores. A lógica de comando pode ser combinacional ou seqüencial. 
Em sistemas combinacionais, o valor atual dos comandos (saídas - O) depende 
apenas do valor atual dos sensores (entradas - I): 
 O(k) = f (I(k)). 
Por exemplo, considerando três sensores S1, S2 e S3, um sistema combinacional 
poderia ser representado pela equação: 
3211 SSSO += 
 Nesse caso, a saída depende apenas do estado atual das entradas. 
Em sistemas seqüenciais, o valor atual das saídas (O) depende do valor das 
entradas (I) e do estado atual do sistema (E(k)). O estado seguinte do sistema 
depende, por sua vez, do estado atual e do valor das entradas, ou seja: 
 O(k) = f (E(k),I(k)); 
 E(k+1) = g (E(k),I(k)). 
Dessa forma, um elemento essencial em um sistema seqüencial é a memória. 
Em um sistema seqüencial de automação, o controlador deve gerar sinais em 
uma determinada seqüência de forma a fazer o sistema evoluir da maneira desejada. 
Esses sinais podem possuir uma seqüência fixa ou podem possuir seqüências 
dependentes de seleções feitas pelo usuário ou de condições do sistema em 
determinado momento (diferenças entre peças por exemplo). 
Antes do advento dos controladores programáveis (CLPs, microcontroladores, 
PCs etc.), um dos métodos maiscomuns de geração de sinais para automação de um 
processo eram os circuitos de comandos elétricos. Para aplicações mais simples e que 
não necessitem de reprogramação, o método ainda é bastante utilizado, porém torna-
 8
se menos atraente à medida que o número de elementos de memória necessários 
aumenta, já que isso representa um aumento do custo de implantação. 
 
2.3 - Comandos elétricos básicos 
 
Os circuitos de comandos elétricos são compostos basicamente por três tipos de 
elementos [Parker, 2001]: 
• elementos de entrada de sinais; 
• elementos de processamento de sinais; 
• elementos de saída de sinais. 
Os diagramas de comandos elétricos são também chamados de diagramas de 
contatos. 
 
2.3.1 - Elementos de entrada de sinais 
 
Os elementos de entrada de sinais são responsáveis por fornecer informações 
ao circuito de comando para o processamento. Essas informações podem ser 
comandos fornecidos pelo usuário (botoeiras, pedais, chaves seletoras etc.) ou 
informações sobre o processo, obtidas por meio de sensores (chaves fim de curso, 
sensores de proximidade, pressostatos etc.). 
A Figura 2.1 mostra um botão com um contato normalmente aberto (NA) e um 
contato normalmente fechado (NF) e sua simbologia utilizada em diagramas de 
contatos. Ao se pressionar o botão, o contato NA se fecha, permitindo a passagem de 
corrente elétrica entre os terminais 13 e 14, enquanto o contato NF se abre, impedindo 
a passagem de corrente entre os terminais 11 e 12. É importante lembrar que, em 
circuitos elétricos, um contato fechado permite a passagem de sinal, ao contrário de 
sistemas pneumáticos e hidráulicos, em que uma válvula fechada impede a passagem 
de fluido, e vice-versa: um contato aberto impede a passagem do sinal enquanto uma 
válvula aberta permite a passagem do fluido. 
 
 9
 
(a) Estrutura 
13 11
14 12 
(b) Simbologia 
Figura 2.1 – Elemento de entrada de sinal (botoeira). Fonte: [Parker, 2001]. 
 
Na Figura 2.2 são mostrados outros elementos de entrada de sinal, como rolete 
e sensores capacitivo, indutivo e óptico. 
 
 
(a) rolete 
 
(b) capacitivo 
 
(c) indutivo 
 
(d) óptico 
Figura 2.2 – Representação de Sensores. Fonte: [Parker, 2001] 
 
 
2.3.2 - Elementos de processamento de sinais 
 
Os elementos de processamento de sinais são responsáveis por manipular os 
sinais de entrada, de forma a fornecer os sinais de saída de acordo com a 
especificação do sistema de comando. 
Um dos principais elementos de processamento de sinais são os relés auxiliares 
(Figura 2.3). Os relés auxiliares são contatos elétricos acionados por uma bobina 
eletromagnética. Ao se energizar a bobina, os contatos elétricos são comutados, ou 
 10
seja, os contatos NA são fechados e os contatos NF são abertos. Geralmente os relés 
auxiliares são compostos de quatro contatos, que podem ser NA, NF ou combinações. 
Na Figura 2.3(b), ao se energizar os contatos A1 e A2, os contatos NA 13-14, 23-24 e 
33-34 são fechados, enquanto o contato NF 41-42 é aberto. 
 
 
(a) 
K
A2
A1
14 24 34 42
13 23 33 41
K
A2
A1
14 24 34 42
13 23 33 41 
(b) 
Figura 2.3 – Relé auxiliar. 
 
Como se pode observar, os quatro pares de contatos do relé mostrado na Figura 
2.3 são independentes entre si, ou seja, podem ser utilizados em partes diferentes do 
circuito de comando, bem como ser acionar circuitos diferentes com tensões diferentes. 
Um outro tipo de relé auxiliar possui contatos comutadores (Figura 2.4). Nesse 
relé, quando a bobina é energizada, o terminal 11 é desconectado do terminal 12 e 
conectado ao terminal 13, o mesmo ocorrendo com os terminais 21, 22 e 23. Esse relé 
pode ser utilizado, por exemplo, para energizar alternadamente duas máquinas 
diferentes (a fonte de energia poderia ser conectada ao terminal 11 e a alimentação de 
cada uma das máquinas conectadas aos terminais 12 e 13, respectivamente). 
 
K
A2
A1
12 13 22 23
11 21
K
A2
A1
12 13 22 23
11 21 
Figura 2.4 – Relé auxiliar com contatos comutadores. 
 
Relés auxiliares especialmente projetados para o acionamento de circuitos de 
potência são chamados de contatores de potência. 
 11
Os relés temporizadores são utilizados para causar um atraso de tempo Ton pré-
determinado por meio de um potenciômetro em algum acionamento ou 
desacionamento no sistema. O relé temporizador com retardo na energização (Figura 
2.5), após acionado, realiza um retardo de tempo para que os contatos sejam 
comutados (Figura 2.5(b)). Quando desenergizado, os contatos retornam 
imediatamente para a posição normal. 
 
K
A2
A1
12 13
11
K
A2
A1
12 13
11 
(a) simbologia 
A1-A2
11-12
Ton
A1-A2
11-12
A1-A2
11-12
Ton
(b) diagrama de acionamento 
Figura 2.5 – Relé temporizador com retardo na energização. 
 
Já os relés temporizadores com retardo na desenergização (Figura 2.6), quando 
energizados, realizam imediatamente a comutação dos contatos auxiliares. Porém, 
quando desenergizados, é aguardado um período de tempo Toff pré-determinado para 
que ocorra o retorno dos contatos para a posição normal. 
 
K
A2
A1
12 13
11
K
A2
A1
12 13
11 
(a) simbologia 
A1-A2
11-12
Toff
(b) diagrama de acionamento 
Figura 2.6 – Relé temporizador com retardo na desenergização. 
 
Relés contadores registram a quantidade de pulsos elétricos recebidos e 
comutam seus contatos quando a contagem atingir um valor pré-determinado. O 
contador pode ser reiniciado por meio de um botão no painel do relé ou por meio de um 
 12
sinal elétrico de reset. A Figura 2.7(a) mostra a simbologia de um relé contador e a 
Figura 2.7(b) mostra o diagrama de acionamento para uma contagem de 3 pulsos. 
 
K
A2
A1
12 13
11
K
A2
A1
12 13
11 
(a) simbologia 
A1-A2
11-12
Reset
A1-A2
11-12
Reset
(b) diagrama de acionamento 
Figura 2.7 – Relé contador. 
 
 
2.3.3 - Elementos de saída de sinais 
 
Após realizado o processamento, o resultado pode ser utilizado para acionar 
atuadores e máquinas ou exibir informações para o operador. Como sinais de saída 
tem-se os sinais sonoros (Figura 2.8(a)) e luminosos (Figura 2.8 (b)) e os solenóides de 
válvulas (Figura 2.8 (c)), entre outros. 
 
 
(a) sonoro 
 
(b) luminoso 
 
(c) solenóide 
Figura 2.8 – Elementos de saída de sinal. 
 
Os próprios contatos dos relés auxiliares podem ser utilizados como elementos 
de saída de sinal, caso estejam conectados à alimentação de máquinas e outros 
equipamentos. 
 
 13
Exemplo 2.1: Acionamento direto de um solenóide. 
 
+
-
B
Y
 
Y
 
 
Ao ser acionado o botão B, seu contato NA será fechado, permitindo a 
passagem de corrente elétrica. O solenóide Y será então alimentado, acionando a 
válvula direcional. O ar comprimido alimentará o cilindro, provocando seu avanço. Ao 
ser liberado o botão B, a mola provocará o retorno da válvula à sua posição normal, 
permitindo o recuo do cilindro. 
 
Exemplo 2.2: Acionamento direto de um solenóide por dois botões (lógica OU). 
 
+
-
B1
Y
B2
 
Y
 
 
Nesse exemplo, se qualquer um dos botões B1 ou B2 for acionado, o solenóide 
Y será alimentado, acionando a válvula. Como os contatos dos botões estão em 
paralelo, tem-se uma lógica OU, ou seja: o solenóide Y será acionado caso o botão B1 
OU o botão B2 seja acionado. 
 
 14
Exemplo 2.3: Acionamento direto de um solenóide por dois botões (lógica E). 
 
+
-
B1
Y
B2
 
Y
 
 
Para que o solenóide seja alimentado, é necessário que os botões B1 e B2 
sejam acionados simultaneamente.Como os contatos dos botões estão em série, tem-
se uma lógica E, ou seja: o solenóide Y será acionado caso o botão B1 E o botão B2 
sejam acionados. 
 
Exemplo 2.4: Acionamento indireto de um solenóide. 
 
+
-
B1
K
K
Y
 
Y
 
 
Ao ser acionado o contato NA do botão B, o relé auxiliar K será alimentado, 
fechando o contato NA de K, que, por sua vez, alimentará o solenóide Y, acionando a 
respectiva válvula. 
 
 15
Exemplo 2.5: Acionamento com memória de um solenóide – auto-retenção ou selo 
(reset prioritário). 
 
+
-
B1
K
K
Y
B2
K
 
Y
 
 
Ao ser pressionado o botão B1, seu contato NA é fechado e o relé auxiliar K é 
alimentado, fechando os dois contatos auxiliares K. O solenóide Y é então alimentado 
provocando o avanço do cilindro. Quando o botão B1 é liberado, a bobina do relé K 
continua a ser alimentada pelo próprio contato auxiliar de K. Nesse ponto, só é possível 
interromper a alimentação de K pressionando-se o botão B2 provocando a abertura de 
seu contato NF. Os contatos auxiliares de K retornam então para sua posição inicial 
(NA), desenergizando o solenóide Y. 
Pode-se dizer que esse sistema representa uma memória do tipo set-reset, com 
o botão B1 representando o set e o botão B2 representando o reset. Caso os botões 
B1 e B2 sejam pressionados simultaneamente, a bobina do relé K não é energizada. 
Por essa razão se diz que essa é uma memória com reset prioritário. 
 
 16
Exemplo 2.6: Acionamento com memória de um solenóide – auto-retenção ou selo (set 
prioritário). 
 
+
-
B1
K
K
Y
B2
K
 
Y
 
 
Nesse caso, ao se pressionar os botões B1 e B2 simultaneamente, o sistema é 
acionado (set). Por isso tem-se um sistema com set prioritário. 
 
Exemplo 2.7: Acionamento de um cilindro de dupla ação utilizando uma vávula 5/2 vias 
acionada por duplo solenóide. 
 
+
-
B2
Y2
B1
Y1
 
Y1 Y2
 
 
Nesse sistema, a própria válvula funciona como uma memória. Ao ser 
pressionado o botão B1, o solenóide Y1 é alimentado e o carretel da válvula se 
desloca. Mesmo ao ser liberado o botão, a válvula permanece nessa posição, 
provocando o avanço do cilindro. O botão B2, por sua vez, provoca o acionamento de 
Y2, causando o retorno do cilindro. 
 
 17
Exemplo 2.8: Acionamento de um cilindro de dupla ação utilizando uma vávula 5/2 vias 
acionada por duplo solenóide com retorno automático após o avanço. 
 
+
-
Y2Y1
B A1
A1
Y1 Y2
 
 
O contato NA de A1 é comutado pelo rolete posicionado no final do curso do 
atuador. Dessa forma, ao chegar ao final do avanço, o cilindro aciona A1, que energiza 
o solenóide Y2, provocando o recuo do cilindro. 
 
2.4 - Circuitos seqüenciais eletropneumáticos 
 
Na seção anterior foi mostrado um circuito eletropneumático com retorno 
automático do atuador. Nomeando o atuador como A, pode-se dizer que tem-se a 
seqüência: 
A+ A- 
Pelo método intuitivo, pode-se implementar, de maneira simples, circuitos 
eletropneumáticos com mais de um cilindro, desde que a seqüência desejada seja 
direta. Para verificar se uma seqüência é direta, basta dividi-la ao meio e verificar se os 
atuadores aparecem na mesma ordem e sem repetições. Por exemplo, a seqüência: 
A+ B+ A- B- 
é direta, já que dividindo-a ao meio, tem-se A+ B+ e A- B-. Já a seqüência: 
A+ B+ B- A- 
não é direta. Nesse caso, o método intuitivo não é aplicável, já que o sinal que 
comanda o avanço de B (fim de curso de A) continua existindo no momento em que se 
comandaria o retorno de B, já que o cilindro A ainda não retornou. No Capítulo 4 é 
mostrada uma metodologia para a programação em CLPs de seqüências indiretas. 
O método intuitivo consiste em, ao final de cada movimento, utilizar o sinal do 
sensor de fim de curso para comandar diretamente o movimento seguinte. 
 
 18
Exemplo 2.9: Seqüência A+ B+ A- B-. 
Para essa seqüência, observa-se que o sensor fim de curso de A (A1) deve 
comandar o avanço de B. O sensor fim de curso de B (B1) deve comandar o retorno de 
A. Um sensor posicionado no início do curso de A (A0) deve comandar o retorno de B. 
Dessa forma, observa-se que são necessárias, no mínimo, três chaves de fim de curso, 
sendo necessária uma quarta chave caso se deseje confirmar o retorno de B antes de 
aceitar o comando de reinício da seqüência gerado, por exemplo, por um botão (ST). 
 
A1A0
A+ A-
B1B0
B+ B-
 
 
+
-
B0
ST
A+
A1
B+
B1
A-
A0
B-
 
 
 
2.5 - Exercícios 
 
Exercício 2.1: Faça os diagramas de contatos para acionar uma lâmpada quando as 
lógicas a seguir forem verdadeiras. Considere A, B e C como três botões. 
 
a) ABC 
 19
b) CBA ++ 
c) CAB +)( 
d) )( CBA + 
e) CBA 
 
Exercício 2.2: Faça os diagramas de contatos para acionar uma lâmpada quando as 
lógicas a seguir forem verdadeiras. Considere A, B e C como três botões que possuem 
apenas um contato NA cada. 
 
a) BCA 
b) )()( ACCBA + 
c) )(ABC 
 
Exercício 2.3: Refaça o exercício anterior considerando que cada botão possui apenas 
um contato NF cada. 
 
Exercício 2.4: Um cilindro pneumático deve iniciar seu avanço quando dois botões 
forem pressionados simultaneamente. O cilindro deve retornar quando chegar ao final 
de seu curso ou quando um terceiro botão (emergência) for acionado. Faça o diagrama 
de contatos e o pneumático que implemente essa lógica. Considere uma válvula 3/2 
vias com retorno por mola. 
 
Exercício 2.5: Um sistema hidráulico de acionamento de um cilindro deve permitir 
paradas intermediárias. Seu acionamento deve se dar da seguinte maneira: 
 Botão Av: inicia o avanço do cilindro 
 Botão Re: inicia o retorno do cilindro 
 Botão P: provoca a parada do cilindro, aliviando a pressão da bomba. 
Ao terminar o avanço ou recuo, a válvula direcional deve aliviar a pressão da 
bomba. 
Faça o diagrama hidráulico e o de contatos elétricos para acionamento do sistema. 
 
 20
Exercício 2.6: Faça o diagrama elétrico para o comando da seguinte seqüência de 
movimentos de atuadores pneumáticos: 
A+ C+ B+ A- C- B- 
 
 
 21
3. Controladores Lógicos Programáveis 
 
Controladores Lógico Programáveis (CLPs), também conhecidos como PLCs 
(Programmable Logic Controller), são dispositivos desenvolvidos para substituir 
circuitos elétricos baseados em relés para o controle de máquinas. O CLP trabalha 
monitorando suas entradas (que podem ser analógicas, digitais ou dados recebidos por 
uma rede industrial), processando-as de acordo com o programa e definindo valores 
para saídas (que também podem ser analógicas, digitais ou valores a serem enviados 
pela rede). 
As vantagens da substituição dos circuitos de comandos elétricos por CLPs 
estão na flexibilidade de programação (o CLP pode ser reprogramado via software, 
enquanto os circuitos elétricos podem exigir uma nova montagem de todas as 
conexões do sistema), na economia de espaço físico (o limite do tamanho de um 
programa em CLP é determinado apenas pela memória do mesmo, ou seja, um 
pequeno CLP substitui circuitos elétricos que poderiam ocupar vários gabinetes) e, a 
depender da complexidade do sistema, o CLP pode ter um custo mais baixo que o 
material necessário para a montagem do circuito elétrico. 
 
3.1 - Estrutura 
 
O CLP consiste basicamente de uma CPU (unidade central de processamento), 
memórias, circuitos de entradas e saídas de sinais e dispositivos para conexão via 
redes industriais. De acordo com o modelo do CLP, esses dispositivos podem ser fixos 
ou configuráveis, pela inserção de cartões de entrada, saída e comunicação. 
A grande maioria das funçõesdo CLP (funções lógicas, contadores, 
temporizadores etc.) não existem fisicamente, mas são simuladas em software, e são 
executadas de acordo com a programação do usuário. Alguns CLPs dispõem de 
contadores de alta velocidade, utilizados para contabilizar pulsos em freqüências 
maiores que a capacidade de processamento da CPU, como os pulsos de um encoder. 
A Figura 3.1 mostra como são realizadas as interligações entre um CLP de 8 
entradas e 8 saídas e os elementos externos, como sensores e atuadores. 
 
 22
24Vcc24Vcc
C
O
M
C
O
M
IN
0
IN
0
IN
1
IN
1
IN
2
IN
2
IN
3
IN
3
IN
4
IN
4
IN
5
IN
5
IN
6
IN
6
IN
7
IN
7
C
O
M
C
O
M
O
U
T0
O
U
T0
O
U
T1
O
U
T1
O
U
T2
O
U
T2
O
U
T3
O
U
T3
O
U
T4
O
U
T4
O
U
T5
O
U
T5
O
U
T6
O
U
T6
O
U
T7
O
U
T7
 
Figura 3.1 – Ligações de um CLP. 
 
Na figura, o CLP é alimentado por uma fonte externa de 24Vcc (em muitos 
casos, a fonte é encapsulada no próprio corpo do CLP). 
Para que uma entrada seja sensibilizada é necessário aplicar +24Vcc entre o 
respectivo terminal e o terminal comum. Por esse motivo, o terminal comum é ligado no 
terminal negativo da fonte e cada chave é conectada ao terminal positivo e a respectiva 
entrada. Dessa forma, quando a chave se encontra aberta (não é aplicado +24Vcc ao 
terminal), a entrada correspondente realizará uma leitura de “falso”. Quando a chave 
estiver fechada (aplicando +24Vcc ao terminal) será realizada uma leitura de 
“verdadeiro”. 
Ao ser escrito um valor “verdadeiro” em uma saída, o CLP aplica +24Vcc ao 
respectivo terminal. Dessa forma, para que uma saída acione, por exemplo, o 
solenóide de uma válvula, seus terminais devem ser ligados à saída e ao terminal 
negativo da fonte. 
 
3.2 - Execução 
 
O ciclo de execução de um CLP é representado na Figura 3.2. Após ligado, o 
CLP executa uma rotina de inicialização e entra em um ciclo chamado ciclo de 
 23
varredura. Primeiramente é realizada a leitura dos sinais de entrada, e os valores 
desses sinais são armazenados em uma região de memória denominada imagem de 
entrada. Durante a execução do programa do usuário, quaisquer leituras realizadas nas 
variáveis de entrada na realidade são lidas da imagem de entrada. Esse artifício é 
utilizado pois uma leitura em uma posição de memória é muito mais rápida que uma 
leitura realizada na entrada em si. Após a leitura dos sinais de entrada, o programa do 
usuário é executado instrução por instrução. Todos os valores escritos pelo programa 
nas saídas do CLP na realidade são armazenados em uma área de memória chamada 
de imagem de saída. Após a completa execução do programa é realizado o 
procedimento de atualização das saídas a partir da imagem de saída. 
 
Leitura das 
entradas
InicializaçãoInicialização
Execução do 
programa
Atualização das 
saídas
 
Figura 3.2 – Ciclo de execução de um CLP. 
 
Como o ciclo de execução do CLP normalmente é mais rápido que as 
constantes de tempo do sistema controlado, e já que as saídas são atualizadas apenas 
no final do ciclo de varredura, pode-se dizer que o CLP simula, com fidelidade, os 
circuitos de comandos elétricos, em que o processamento é realizado em paralelo por 
todos os dispositivos. 
É importante salientar algumas conseqüências da utilização de imagens de 
entrada e saída pelo CLP. Por exemplo, caso o valor de uma saída seja alterada mais 
de uma vez durante a execução do programa, apenas o último valor será realmente 
escrito na saída do CLP. Por outro lado, caso o valor de alguma entrada for alterado 
durante a execução, essa alteração somente será percebida no ciclo de varredura 
seguinte. 
 24
Alguns modelos de CLPs dispõem de comandos de leitura e escrita imediatas 
em dispositivos de entrada e saída. Nesses casos, a leitura do sinal e a escrita do 
resultado são realmente realizados no momento da execução do comando. Porém, é 
importante salientar que a execução desses comandos é mais lenta que a leitura e 
escrita nas imagens de entrada e saída. 
O tempo do ciclo de varredura depende do tamanho do programa e das 
instruções utilizadas. Esse tempo pode ser fixo em programas que não utilizem 
variação no controle de fluxo (instruções condicionais etc.), porém em muitos casos 
pode ser variável. Caso o tempo de execução ultrapasse um valor pré-determinado, o 
CLP acusa um sinal de erro e interrompe a execução do programa. 
 
3.3 - Linguagens de Programação 
 
As linguagens de programação de CLPs são definidas pela norma IEC 61131-3. 
A norma define 2 linguagens textuais e duas gráficas: 
Linguagens textuais: 
• IL (Instruction List), ou lista de instruções; 
• ST (Structured Text), ou texto estruturado. 
Linguagens gráficas: 
• LD (Ladder Diagram), ou diagrama escada, ou de contatos; 
• FDB (Function Block Diagram), ou diagrama de blocos funcionais. 
Uma quinta forma de representação é definida pela norma como SFC 
(Sequential Function Chart). O SFC é uma forma de representação gráfica utilizada 
para programação de eventos seqüenciais, cujos elementos podem ser utilizados em 
conjunto com quaisquer das quatro linguagens definidas. 
Neste texto serão utilizadas as linguagens Ladder, por ser a mais utilizadas na 
programação de CLPs, bem como o SFC, por ser a representação mais apropriada 
para a programação de sistemas seqüenciais de automação. Será apresentado 
também um método para a conversão de diagramas representados por SFC para a 
linguagem Ladder, já que o SFC não está disponível em todos os CLPs comerciais, 
como a linguagem Ladder. 
 
 25
3.3.1 - Ladder 
 
A linguagem Ladder é derivada dos diagramas de contatos elétricos. Por esse 
motivo, é a linguagem mais popular de programação de CLPs. Além dos elementos de 
entrada, saída e processamento de sinais presentes nos diagramas de contatos 
elétricos (tipicamente sinais discretos, 0 ou 1, falso ou verdadeiro), a linguagem Ladder 
permite trabalhar também com outros tipos de dados, como inteiros e reais e entradas 
e saídas analógicas, tornando-a uma poderosa forma de programação da automação e 
controle de processos. 
O elemento básico de um diagrama Ladder são os barramentos de energização, 
representados por duas linhas verticais. Eles representam os terminais da fonte 
existente nos diagramas de contatos elétricos. Os elementos da lógica da programação 
(Figura 3.3) são representados entre os barramentos como os degraus de uma escada 
(daí o nome Ladder, escada em inglês), como mostrado na (Figura 3.4). O programa é 
executado pela CPU do CLP executando a lógica de cada degrau, da esquerda para a 
direita e varrendo degrau por degrau de cima para baixo. 
 
 
(a) Contato NA 
 
(b) Contato NF 
( )( )( )
 
(c) Bobina 
Figura 3.3 – Representação em diagrama Ladder de contatos NA, NF e bobinas. 
 
( )( )( )
E0E0 S0
( )( )( )
E1 S1E2E2
E0E0 E2E2
( )( )( )
S2
 
Figura 3.4 – Exemplo de programa em Ladder. 
 
 26
Cada contato e bobina devem ser endereçados de modo a identificar a 
correspondência com os sinais de entrada, saída e memórias. Durante a execução do 
programa, caso o valor associado a um contato NA seja verdadeiro, o contato se fecha, 
“permitindo a passagem de corrente elétrica” (considerando a analogia com os 
diagramas de contatos elétricos). Caso o valor associado seja falso, o contato NA 
permanece aberto. O contrário acontece para o contato NF, que se abre quando o valor 
associado é verdadeiro e se fecha quando o valor associado é falso. 
Quando a lógica à esquerda de uma bobina é verdadeira (analogamente à 
bobina energizada),é atribuída à saída ou posição de memória associada o valor 1. 
Caso a lógica seja falsa, é atribuído o valor 0. Caso essa posição de memória 
corresponda ao espelho de saída, o valor armazenado será atribuído à saída 
correspondente no final do ciclo de execução. Caso essa posição seja uma memória 
auxiliar, o valor será simplesmente armazenado, podendo ser utilizado em outras 
partes do programa. Dessa forma, pode-se fazer uma analogia com um relé: quando 
um valor é armazenado em uma posição de memória significa que se está energizando 
ou desenergizando a bobina do relé; ao se utilizar o valor armazenado na memória está 
se utilizando os contatos do relé (Figura 2.1). Ao contrário do relé físico, em que existe 
um número limitado de contatos, no programa do CLP a posição de memória pode ser 
utilizada um número indeterminado de vezes. 
 
+
-
B1
Y
B2
K
K
K
L1
(a) Relé auxiliar 
B1B1
( )
K
( )( )( )
K
( )
L1
( )( )( )
L1KK
B2B2
KK
( )
Y
( )( )( )
Y
 
(b) Memória 
Figura 3.5 – Analogia entre uma memória e um relé auxiliar. 
 
A forma de endereçamento das entradas, saídas e memórias depende de cada 
fabricante de CLP, mas normalmente é composta de três campos: 
• Tipo de memória 
• Endereço do byte 
 27
• Número do bit dentro do byte (0 a 7) 
Em programas que utilizem apenas sinais discretos, os tipos de memória 
utilizados são: imagem da entrada, imagem da saída, memória auxiliar. Nessa apostila 
serão utilizados os seguintes símbolos: E para imagem da entrada, S para imagem da 
saída e M para memória auxiliar. 
O campo endereço do byte identifica a posição na respectiva memória em que 
se encontra o byte que contém o bit referenciado. Normalmente o endereço vai de 0 
até um valor que depende do número de entradas e saídas e do tamanho da memória 
auxiliar. 
Por último, o campo número do bit identifica, dentre os 8 bits do byte, qual o bit 
referenciado. 
Considerando o modo de endereçamento utilizado nessa apostila, são exemplos 
de identificadores: 
• E0.3 – Bit 3 do byte 0 de entrada; 
• S2.0 – Bit 0 do byte 2 de saída; 
• M10.7 – Bit 7 do byte 10 da memória auxiliar. 
Para simplificar a representação, no caso de programas pequenos que utilizem 
no máximo 8 bits de entrada, saída e de memória auxiliar, serão utilizados apenas os 
campos de memória e de bit (ex.: E0, S5, M3). 
Alguns fabricantes de CLPs permitem a associação de símbolos (ex: VALVULA1, 
BOTAO3 etc.) a determinadas posições de memória e de espelho de entrada e saída de 
forma a tornar mais fácil a programação por parte do usuário. Ao se compilar o 
programa, os símbolos são automaticamente convertidos para os respectivos 
identificadores. 
Assim como em circuitos de comandos elétricos, dois contatos em série 
representam uma lógica “E”, enquanto dois contatos em paralelo representam uma 
lógica “OU” (Figura 3.6). 
 
 28
E0E0
( )
S0
( )( )( )
S0
E1E1
 
(a) S0=E0+E1 
E0E0
( )
S1
( )( )( )
S1E1E1
 
(b) S1=E0×E1 
Figura 3.6 – Lógicas E e OU em Ladder. 
 
A auto-retenção ou selo pode ser utilizada para acionar e manter o estado de 
uma saída, assim como no diagrama de contatos elétricos. A Figura 3.7 mostra um 
exemplo em que, quando é acionada a entrada E0 (set), a saída S0 é acionada, 
permanecendo nesse estado mesmo que E0 seja desacionada. S0 apenas é 
desacionada quando E1 (reset) é acionada (abrindo o contato NF). Na Figura 3.7(a) 
tem-se reset prioritário (a saída é desacionada quando E0 e E1 são acionadas 
simultaneamente), enquanto na Figura 3.7(b) tem-se set prioritário (a saída é acionada 
quando E0 e E1 são acionadas simultaneamente). 
 
E0E0
( )
S0
( )( )( )
S0E1E1
S0S0
 
(a) reset prioritário 
E0E0
( )
S0
( )( )( )
S0
E1E1 S0S0
 
(b) set prioritário 
Figura 3.7 – Auto-retenção em linguagem Ladder. 
 
A linguagem Ladder prevê, ainda comandos de bobinas com retenção (set e 
reset). A Figura 3.8 mostra uma lógica equivalente à da Figura 3.7, utilizando bobinas 
com retenção. Observe que, como a saída somente é atualizada após o término do 
ciclo de execução do programa, caso as entradas E0 e E1 sejam acionadas 
simultaneamente, apenas a última instrução executada tem influência no valor real da 
saída, determinando assim o reset ou set prioritário. 
 
 29
E0E0
E1
( )
S0
R( )
S0
( )( )( )
S0
R
( )
S0
S( )
S0
( )( )( )
S0
S
 
(a) reset prioritário 
E0E0
( )
S0
( )( )( )
S0
( )
S0
( )( )( )
S0E1
R
S
 
(b) set prioritário 
Figura 3.8 – Bobinas com retenção em linguagem Ladder. 
 
É importante observar uma diferença fundamental entre as bobinas normais e as 
bobinas com retenção. Nas bobinas normais, o resultado da lógica à esquerda da 
bobina, quer seja falso ou verdadeiro, é sempre escrito na memória (auxiliar ou espelho 
de saída) referenciada. No caso das bobinas com retenção, seu valor é setado ou 
resetado apenas se o resultado da lógica for verdadeiro. Isso significa que, caso um 
programa possua várias linhas que acionem uma bobina normal referenciando uma 
saída, apenas a última terá efeito real na saída, já que o resultado de sua lógica é que 
será utilizado na atualização das saídas. Porém, caso várias linhas utilizem bobinas 
com retenção, o efeito será equivalente a uma única linha com uma lógica OU entre as 
lógicas de cada linha (Figura 3.9). 
 
E1E1
E2
( )
S0
R( )
S0
( )( )( )
S0
R
( )
S0
S( )
S0
( )( )( )
S0
S
( )
S0
S( )
S0
( )( )( )
S0
S
E5
( )
S0
R( )
S0
( )( )( )
S0
R
E3E3
E4
 
E1E1
E2
( )
S0
R( )
S0
( )( )( )
S0
R
( )
S0
S( )
S0
( )( )( )
S0
S
E5
E3E3
E4
 
Figura 3.9 – Equivalência entre programas utilizando bobinas com retenção . 
 
A norma IEC 61131-3 prevê, também, a utilização de contatos sensíveis à borda 
de subida ou de descida de um sinal. No caso do contato sensível à borda de subida, 
seu valor é verdadeiro durante um ciclo de execução caso o valor da variável 
associada sofra uma transição de falso para verdadeiro durante o ciclo de execução 
 30
anterior. O contato sensível à borda de descida possui valor verdadeiro durante um 
ciclo de execução quando a variável associada sofre uma transição de valor verdadeiro 
para falso. A Figura 3.10(a) mostra um programa utilizando contatos sensíveis à borda 
de subida e descida, enquanto a Figura 3.10(b) mostra os estados das saídas em 
função de variações da entrada (Texec é o tempo do ciclo de execução). 
 
N
( )
S0
( )( )( )
S0
( )
S1
( )( )( )
S1
E0
P
E0
 
(a) programa 
E0
S0
TexecTexec
S1
 
(b) estado das saídas em função da entrada 
Figura 3.10 – Contatos sensíveis à borda. 
 
Assim como em diagramas de contatos, em Ladder é também possível se 
utilizar temporizadores com retardo na energização e na desenergização. Dependendo 
do fabricante, a representação do temporizador pode variar. 
O temporizador com retardo na energização, também chamado de TON, 
provoca um atraso entre a condição de ativação e o acionamento de uma saída ou 
memória. A Figura 3.16(a) mostra a representação de um temporizador conforme a 
norma IEC 61131-3. A condição de ativação deve ser ligada à entrada IN, enquanto a 
saída a ser acionada (ou o restante de uma condição lógica) deve ser ligada à saída Q. 
O valor de tempo do atraso é representado por uma variável numérica ou por uma 
constante, e deve ser configurada na entrada PT (preset time). A saída ET (elapsed 
time) pode ser armazenada em uma variável numérica para ser utilizada em outra parte 
do programa. 
 
 31
E3E3
( )
S0
( )( )( )
S0TON
IN
3s PT
Q
ET
 
(a) representação 
IN
Q
PT
IN
Q
IN
QPT 
(b) estado da saída em função da entrada 
Figura 3.11 – Temporizador TON. 
 
O temporizador com retardo na desenergização (TOFF) aciona a saída no 
momento em que a condição de entrada é satisfeita, porém provoca um atraso na 
desenergização da saída a partir do momento em que a entrada é desenergizada 
(Figura 3.12). A representação em Ladder é semelhante ao temporizador TON, com o 
indicador substituído por TOFF. 
 
E3E3
( )
S0
( )( )( )
S0TOFF
IN
3s PT
Q
ET
 
(a) representação 
IN
Q
PT 
(b) estado da saída em função da entrada 
Figura 3.12 – Temporizador TOFF. 
 
Contadores são utilizados para contar o número de pulsos de determinado sinal 
ou função lógica e acionar uma saída quando tal número atingir um valor pré-
determinado. A norma prevê três tipos básicos de contadores: counter up (CTU), 
counter down (CTD) e counter up-down (CTUD). 
O counter up (Figura 3.13) faz a contagem de pulsos em sentido crescente. São 
utilizados 2 sinais de entrada CU (counter up), sinal a ser contado e R (reset), sinal que 
provoca o reinício da contagem. É necessário fornecer ainda um valor inteiro PV (preset 
value), correspondente ao número de pulsos a serem contados. Como saídas tem-se 
um inteiro CV (current value) que corresponde ao número de pulsos contabilizados e 
um sinal lógico Q, que é acionado quando CV atinge o valor de PV. 
 32
 
E3E3
( )
S0
( )( )( )
S0CTU
CU
R
Q
CV3 PV
E4E4
 
(a) representação 
CU
Q
R
 
(b) estado da saída em função da entrada 
Figura 3.13 – Contador CTU. 
 
Já o counter down (Figura 3.14) faz a contagem de pulsos em sentido 
decrescente. São utilizados 2 sinais de entrada CD (counter down), sinal a ser contado 
e LD (load), sinal que provoca o reinício da contagem a partir do valor PV (preset 
value), correspondente ao número de pulsos a serem contados. Como saídas tem-se 
um inteiro CV (current value) que corresponde ao valor atual do contador e um sinal 
lógico Q, que é acionado quando CV atinge o valor 0. 
 
E3E3
( )
S0
( )( )( )
S0CTD
CD
LD
Q
CV3 PV
E4E4
 
(a) representação 
CD
Q
LD
 
(b) estado da saída em função da entrada 
Figura 3.14 – Contador CTD. 
 
Considerando-se apenas a relação entre os sinais de entrada CU e CD e de 
saída Q, o efeito dos contadores CTU e CTD é o mesmo. 
Por último, tem-se o contador CTUD (counter up-down). Esse contador pode 
contar pulsos de modo crescente, quando acionada a entrada CU ou decrescente 
quando acionada a entrada CD. Possui sinais de reset (R), que reinicia a contagem do 
 33
zero e load (LD), que carrega o valor de PV em CV. Como saídas, possui QU, que é 
acionada quando o valor de CV atinge PV e QD que é acionada quando CV atinge 0. 
 
E1E1
( )
S0
( )( )( )
S0CTUD
CU
CD
QU
CV3 PV
E2E2
E3E3
R
LD
E4E4
( )
S1
( )( )( )
S1
QD
 
Figura 3.15 – Contador CTUD 
 
 
Exemplo 3.1: Utilizando apenas contatos simples, faça um programa que substitua o 
programa abaixo. 
N
( )
S0
( )( )( )
S0
( )
S1
( )( )( )
S1
E0
P
E0
 
 34
Resolução: Utiliza-se uma memória para armazenar o valor anterior de E0, ao final do 
ciclo de execução. Os contatos sensíveis à borda podem então ser substituídos por 
uma lógica que verifique o valor atual e o anterior da entrada (armazenado na 
memória): 
E0E0
( )
M0
( )( )( )
M0
E0E0 M0M0
M0M0E0E0
( )
S0
( )
S0
( )
S1
( )
S1
 
 
3.3.2 - SFC 
 
Como mencionado anteriormente, o diagrama Ladder simula um diagrama de 
contatos elétricos. Por esse motivo, simula-se um ambiente de processamento 
paralelo, ou seja, cada linha seria processada em paralelo com as outras. Esse efeito é 
conseguido pela utilização do ciclo de execução, que é realizado normalmente em um 
tempo menor que as constantes de tempo do sistema. Dessa forma, essa linguagem é 
apropriada para intertravamento e monitoramento de várias máquinas ao mesmo 
tempo. 
Por outro lado, para sistemas seqüenciais de automação, a programação em 
linguagem Ladder pode se tornar uma tarefa tediosa e propensa a erros, já que as 
linhas e condições devem ser intertravadas com outras. Nesses casos, a forma de 
programação mais adequada é o SFC (Sequential Function Chart), por ser orientada a 
estados e eventos do sistema. 
O SFC é uma linguagem de programação gráfica baseada no GRAFCET. O 
GRAFCET foi inicialmente desenvolvido na França sob o nome de GRAphe 
Functionnel de Commande Etape/Transition e é baseado nas redes de Petri 
interpretadas. Em 1988 foi publicado o padrão IEC 848: “Preparation of function charts 
for control system”, baseado na linguagem GRAFCET. Posteriormente, a norma IEC 
61131-3 introduziu modificações no GRAFCET de forma a adequá-lo às outras 
linguagens definidas na norma, definindo então o SFC. 
 35
Um SFC é baseado em passos e transições, interligados por arcos direcionados. 
Os passos são representados por retângulos e as transições por traços horizontais. 
Cada transição deve estar ligada, no mínimo, a um passo de entrada e um passo de 
saída, por meio de arcos direcionados. 
Os passos podem estar ativos ou inativos. A cada instante de tempo, pelo 
menos um passo deve estar ativo. A cada passo ativo corresponde um conjunto de 
ações a serem executadas, que na prática são sinais de saída que devem ser 
acionados ou desligados. Esse conjunto de ações podem ser desde simples atribuições 
de valores de saída até programas escritos em uma das linguagens de programação 
de CLPs. Todo SFC deve possuir, no mínimo, um passo inicial, que estará ativo no 
início da execução do programa (representado por um retângulo de linhas duplas). 
Os passos são ligados a transições por meio de arcos direcionados (Figura 
3.16). Os arcos de saída de um passo são conectados em sua borda inferior. Os arcos 
de entrada são ligados a sua borda superior. 
 
11
22
Arco de entrada 
do passo 2
Arco de saída do 
passo 2
1
2
Arco de entrada 
da transição 1
Arco de saída da 
transição 1
 
Figura 3.16 – Ligações entre passos e transições 
 
As transições determinam as mudanças de passos. Um passo ativo habilita a 
transição ligada a seu arco de saída. Quando as condições de disparo de uma 
transição habilitada são satisfeitas, ela é disparada, desativando o passo ligado a seu 
arco de entrada e ativando o passo ligado a seu arco de saída. 
A (Figura 3.17) mostra um exemplo de SFC com três passos (sendo um inicial) e 
três transições. No início da execução do programa, o passo 1 está ativo, habilitando a 
transição 1. Ao ser pressionado o botão de início, a transição é disparada, desativando 
o passo 1 e ativando o passo 2. No passo 2, é realizada a ação “Liga lâmpada”. Após 
decorridos 5 segundos, a transição 2 é disparada, desativando o passo 2 e ativando o 
passo 3, que realiza a ação “Desliga lâmpada”. Após decorridos 3 segundos, a 
transição 3 é disparada, desativando o passo 3 e reativando o passo 1. 
 36
 
11
22 Liga lâmpadaLiga lâmpada
Botão Início
T=5seg
T=3seg
33 Desliga lâmpadaDesliga lâmpada
1
2
3
 
Figura 3.17 – Exemplo de SFC. 
 
Há casos em que duas transições podem estar ligadas a arcos de saída de um 
lugar ou dois lugares estarem ligados aos arcos de saída de uma transição. Nesses 
casos, tem-se as divergências e convergências E e OU. 
 
Divergência e convergência OU 
 
A divergência/convergência OU é utilizada quando se deseja que uma dentre 
duas ou mais seqüências seja executada. 
No caso de uma divergência OU, um passo ativo habilita duas transições ao 
mesmo tempo, porém apenas uma delas pode ser disparada. Será disparada a 
transição cujas condições de disparoforem satisfeitas primeiro. Esse caso é 
identificado quando mais de uma transição é ligada a arcos de a saída de um passo. 
No exemplo da Figura 3.18, o processo é iniciado quando é pressionado o botão 
“Início”, ativando o passo 2. O passo 2 habilita as transições 2 e 4 (divergência OU). 
Caso o botão 1 seja pressionado, a transição 2 é disparada, desativando o passo 2 e 
ativando o passo 3. Caso o botão 2 seja pressionado, a transição 4 é disparada, 
desativando o passo 2 e ativando o passo 4. Tanto o disparo da transição 3 como o da 
transição 5 ativam o mesmo passo (5). Nesse caso, tem-se uma convergência OU. 
 
 37
11
22
Botão Início
Botão 1
T=3seg
33
1
2
3
Botão 24
T=5seg
44
5
55
Divergência OU
Convergência OU
 
Figura 3.18 – Divergência e convergência OU. 
 
 
Divergência e convergência E 
 
A divergência/convergência E é utilizada quando se deseja que mais de uma 
seqüência seja executada simultaneamente. 
No caso de uma divergência E, o disparo de uma transição ativa mais de um 
passo ao mesmo tempo. As ações relacionadas aos passos ativados são, então, 
executadas simultaneamente. Esse caso é identificado quando mais de um passo é 
ligado a arcos de saída de uma transição. É utilizada uma barra horizontal dupla para 
indicar a divergência. 
A transição associada à convergência (também identificada por barras 
horizontais duplas) somente é habilitada se todos os passos conectados aos seus 
arcos de entrada estiverem ativos. Ao ser disparada a transição, todos esses lugares 
são então desativados e o passo conectado ao arco de saída da transição é ativado. 
 No exemplo da Figura 3.19, o disparo da transição 2 ativa os passos 3 e 5. As 
duas seqüências (passo 3, transição 3, passo 4 e passo 5, transição 4, passo 6) são 
então executadas paralelamente. A transição 5 apenas é habilitada quando as duas 
seqüências forem finalizadas, ou seja, passos 4 e 6 ativos. 
 
 38
11
22
33
1
2
3
55
4
Divergência E
Convergência E
44 66
77
5
 
Figura 3.19 – Divergência e convergência E. 
 
Na Figura 3.20 é mostrada a evolução do SFC para a seguinte seqüência de 
disparo de transições: 1, 2, 3, 4 e 5. 
 
 39
1
2
3
1
2
3
5
4
4 6
7
5
11
22
33
1
2
3
55
4
44 66
77
5
 
(a) passo 1 ativo 
 
1
2
3
1
2
3
5
4
4 6
7
5
11
22
33
1
2
3
55
4
44 66
77
5
 
(b) passo 2 ativo 
1
2
3
1
2
3
5
4
4 6
7
5
11
22
33
1
2
3
55
4
44 66
77
5
 
(c) passos 3 e 5 ativos 
 
1
2
3
1
2
3
5
4
4 6
7
5
11
22
33
1
2
3
55
4
44 66
77
5
 
(d) passos 4 e 5 ativos 
1
2
3
1
2
3
5
4
4 6
7
5
11
22
33
1
2
3
55
4
44 66
77
5
 
(e) passos 4 e 6 ativos 
1
2
3
1
2
3
5
4
4 6
7
5
11
22
33
1
2
3
55
4
44 66
77
5
 
(f) passo 7 ativo 
Figura 3.20 – Evolução de um SFC. 
 40
 
No caso da ocorrência de uma divergência E, deve necessariamente existir uma 
ou mais convergências E de modo que torne a existir apenas um passo ativo no ramo 
do programa. A Figura 3.21 mostra um SFC com uma divergência E sem a respectiva 
convergência. Nesse caso, a transição 2 ativa os passos 3 e 5 simultaneamente. 
Conforme a evolução do sistema, os passos 1 e 2 podem estar ativados 
simultaneamente, o que causaria um conflito, já que são dois passos que deveriam ser 
executados em seqüência. 
 
11
22
33
1
2
3
55
5
44 66
4 6
 
Figura 3.21 – SFC com conflito (divergência E sem convergência). 
 
 
Representação de ações 
 
A cada passo de um SFC, podem corresponder uma ou mais ações a serem 
executadas enquanto o passo estiver ativo. Essas ações devem ser representadas por 
um retângulo posicionado ao lado direito do passo, como mostrado na (Figura 3.22). O 
campo “a” é o qualificador da ação. Indica, por exemplo, se um sinal somente é ligado 
enquanto o passo estiver ativo, ou se é ligado e permanece assim até que seja 
executado um comando que o desligue. O campo “b” corresponde à descrição da ação 
executada, normalmente indicando qual sinal será acionado, por exemplo. O campo 
“c”, chamado de indicador lógico, corresponde a qual sinal lógico indica o término de 
 41
execução da ação. Esse sinal pode ser um sinal externo, como uma válvula fim de 
curso ou uma variável setada pela própria ação. Em grande parte das vezes, a 
transição que faz o programa avançar para o próximo passo é disparada pela própria 
variável indicada nesse campo. 
O campo “d” contém o programa relacionado à ação. Esse programa pode ser 
escrito em qualquer uma das quatro linguagens definidas pela norma (IL, ST, LD ou 
FDB). Quando o campo “b” indica uma variável lógica, não é necessário se definir o 
campo “d”, já que a ação já está completamente definida. 
 
22 a b caa bb cc
dd
 
Figura 3.22 – Bloco de ações associado a um passo 
 
Os qualificadores de ações são definidos na (Tabela 3.1). 
 
Tabela 3.1 – Qualificadores de ações 
Qualificador Descrição 
(Nenhum) Não armazenada 
N Não armazenada 
R Reset 
S Set 
L Limitada no tempo (equivalente a Toff) 
D Atrasada no tempo (equivalente a Ton) 
P Pulso 
SD Setada e com atraso de tempo. A ação é ativada após um tempo estipulado 
mesmo se o passo associado for desativado antes do tempo de atraso. 
DS Atrasada no tempo e setada. Caso o passo associado seja desativado 
antes de completado o tempo de atraso, a ação não é setada. 
SL Armazenada apenas durante um período de tempo. 
P1 Pulso (borda de subida) 
P0 Pulso (borda de descida) 
 42
 
Observe as diferenças entre os qualificadores D, SD e DS e entre os 
qualificadores L e SL. Nos casos de SD e SL, as ações continuam ativas mesmo após 
a desativação do passo correspondente, assim como a S. As ações D, DS e L são 
imediatamente interrompidas quando o passo é desativado. 
Segundo a norma, a ação é sempre executada novamente quando o passo é 
desativado, porém, isso depende da implementação do fabricante. 
Na Figura 3.23 são mostrados alguns exemplos de representações de ações. 
 
77 SS Abrir válvulaAbrir válvula
 
33 PP Iniciar programa CNCIniciar programa CNC
 
99 NN Fechar portaFechar porta E3E3
 
44 L
T#20s
Furar peçaFurar peça
 
Figura 3.23 – Exemplos de ações. 
 
 
Representação de Transições 
 
Uma transição representa as condições a serem satisfeitas para que o controle 
do programa seja transferido de um ou mais passos ativos para outro(s). Como 
mencionado anteriormente, uma transição está habilitada se todos os passos cujos 
arcos estejam ligados a essa transição estiverem ativos. A transição habilitada é 
disparada caso as condições relacionadas a ela sejam satisfeitas. As condições de 
disparo de uma transição podem ser definidas em quaisquer das linguagens definidas 
pela norma IEC 61131-3. Nessa apostila as condições serão definidas como funções 
lógicas (Figura 3.24). Essas funções podem ser traduzidas para qualquer uma das 
linguagens de programação. 
 
 43
2
E2 E E3
3
5
22
E2 E E3
33
5
88
99
9 ( )CBA ×+
 
Figura 3.24 – Exemplo de condições lógicas associadas transições. 
 
As condições de disparo podem também envolver condições de mudança de 
estado de uma variável (borda de subida ou de descida). Na Figura 3.25 são mostrados 
dois programas equivalentes que implementam um divisor de freqüência por 2. 
Observe que,no segundo caso, a utilização da condição de borda de subida reduz 
significativamente o tamanho do programa. Observe também que no segundo caso 
utilizou-se o qualificador de ação N. Nesse caso, o valor da saída S0 é verdadeiro 
apenas no passo 2, não sendo necessário especificar seu valor no passo 1. 
 
11
22
33
44
E0
E0
E0
E0
SS S0S0
RR S0S0
 
11
22
E0↑
NN S0S0
E0↑
 
Figura 3.25 – Divisor de freqüência por 2. 
 
 
 44
3.4 - Exercícios 
 
Exercício 3.1: Descreva o funcionamento do programa abaixo. Qual o resultado efetivo 
do programa? Como alterá-lo de modo a funcionar como seria esperado? 
E0E0
( )
S0
( )( )( )
S0
( )
S0
( )( )( )
S0E0E0
 
 
Exercício 3.2: Dada a lógica de comando digital abaixo, escreva um programa 
equivalente para CLP em linguagem Ladder. (Questão do Exame Nacional de Cursos 
de 1998) 
 E1
 E2
 E3
 E4
 S1
 S2
 
 
Exercício 3.3: O início de operação de uma máquina depende da condição de três 
sensores, S1, S2 e S3. O início da seqüência se dá somente quando uma das seguintes 
condições é satisfeita: 
S1 S2 S3 
0 0 1 
0 1 0 
0 1 1 
1 0 0 
1 1 0 
 
Em todas as outras condições a operação da máquina não deve ser iniciada. 
 
 45
Pede-se: 
 
a) Mapa de Karnaugh do comando de acionamento de início da operação. 
b) Equação booleana baseada no mapa de Karnaugh. 
c) Diagrama elétrico da equação booleana. Considere que os sensores possuam 
apenas um contato NA disponível. 
d) Diagrama Ladder da equação booleana. 
 
Exercício 3.4: Considere um sistema de produção de peças com um buffer de entrada 
alimentado por uma esteira. Enquanto houver peças no buffer, o CLP deve manter um 
robô em funcionamento por meio de um sinal de saída RB. Quando o número de peças 
no buffer chegar a 10, a esteira deve ser desligada. A entrada de peças no buffer é 
detectada por um sensor ENT. Sempre que o robô retira uma peça do buffer, sinaliza 
para o CLP com um sinal SAI. Faça um programa em Ladder para controlar esse 
sistema. 
 
Exercício 3.5: Faça, utilizando SFC, um divisor de freqüência por 4. 
 
 46
4. Programação de sistemas seqüenciais em CLPs 
 
4.1 - Automação pneumática utilizando Ladder 
 
Por se basear na representação de contatos elétricos, a lógica de programação 
em Ladder de sistemas seqüenciais pneumáticos é bastante semelhante aos 
diagramas de contatos. 
Para seqüências diretas de acionamento, utiliza-se o método intuitivo para 
especificação da lógica, em que a conclusão de cada movimento comanda diretamente 
o início do movimento seguinte. O exemplo a seguir mostra o programa em Ladder 
para uma seqüência direta. 
 
Exemplo 4.1: Seqüência A+ B+ A- B-. 
A seguir é mostrado o diagrama pneumático do sistema. São utilizadas duas válvulas 
de 5/2 vias (5 vias e 2 posições) acionadas por duplo solenóide, dois cilindros de dupla 
ação e 4 sensores de fim de curso (contatos NA acionados por roletes). 
 
A-A+
A1A0
A-A+
A1A0 B0
B-B+
B1B0
B-B+
B1
 
 
As tabelas a seguir mostram a equivalência entre os sinais de entrada e saída do CLP 
e os sensores e solenóides. 
 
 47
E0 Botão de início (ST) S0 Solenóide A+ 
E1 Fim de curso A0 S1 Solenóide A- 
E2 Fim de curso A1 S2 Solenóide B+ 
E3 Fim de curso B0 S3 Solenóide B- 
E4 Fim de curso B1 
 
O diagrama a seguir mostra as ligações realizadas no CLP. 
24Vcc24Vcc
C
O
M
C
O
M
IN
0
IN
0
IN
1
IN
1
IN
2
IN
2
IN
3
IN
3
IN
4
IN
4
IN
5
IN
5
IN
6
IN
6
IN
7
IN
7
C
O
M
C
O
M
O
U
T0
O
U
T0
O
U
T1
O
U
T1
O
U
T2
O
U
T2
O
U
T3
O
U
T3
O
U
T4
O
U
T4
O
U
T5
O
U
T5
O
U
T6
O
U
T6
O
U
T7
O
U
T7
ST A0 A1 B0 B1
A+ A- B+ B-
 
 
O programa em Ladder é semelhante ao diagrama de contatos elétricos do Exemplo 
2.9: 
 48
E0E0
( )
S0
( )( )( )
S0
( )
S2
( )( )( )
S2
E4E4
E2E2
E1E1
( )
S1
( )( )( )
S1
( )
S3
( )( )( )
S3
E3E3
 
 
O início da seqüência (avanço de A, S0) se dá com o comando do botão de início 
(E0), desde que o atuador B esteja recuado (rolete B0, E3). Quando A chega ao fim de 
curso e aciona o rolete A1 (E2), o avanço de B é comandado (S2). Quando B chega 
ao fim de curso e aciona o rolete B1 (E4), é comandado o recuo de A (S1). 
Finalmente, quando A aciona o rolete A0 (E1), é comandado o recuo de B. 
 
 
Para seqüências indiretas, pode-se utilizar o método de maximização de 
contatos ou de minimização de contatos [Parker, 2001] para geração do programa em 
Ladder. Nessa apostila será mostrada a utilização da representação em SFC, por ser 
mais poderosa no sentido de permitir uma mais fácil representação de seqüências 
alternativas e eventuais alterações na seqüência de acionamento. No Capítulo 5 é 
mostrada uma metodologia para conversão de programas representados em SFC para 
a linguagem Ladder. 
 
4.2 - Automação pneumática utilizando SFC 
 
Como mencionado anteriormente, a representação SFC permite a programação 
de movimentos seqüenciais de uma forma por meio de uma linguagem gráfica e de 
fácil interpretação. Para seqüências pneumáticas indiretas, uma das soluções mais 
simples é a utilização de SFC. 
Cada um dos movimentos da seqüência deve ser representada por um passo do 
SFC, e cada confirmação de movimento (sensores fim de curso) dispara uma transição. 
 49
O exemplo a seguir mostra a programação de uma seqüência simples. 
 
Exemplo 4.2: O SFC a seguir mostra a programação da seqüência A+ B+ B- A-. 
 
11
22
ST
A1
33
NN Recuar ARecuar A A0A0
NN Recuar BRecuar B B0B0
B0A0×
NN Avançar AAvançar A A1A1
B1
44 NN Avançar BAvançar B B1B1
B0
55 NN Recuar BRecuar B B0B0
A0
66 NN Recuar ARecuar A A0A0
2
3
4
5
6
1
 
 
O passo inicial, 1, comanda o recuo dos cilindros A e B de modo a levar o sistema a 
sua posição inicial. A transição 1 é disparada quando os sensores A0 e B0 confirmam 
essa posição. No passo 2, nenhuma ação é executada. Apenas é aguardado que seja 
pressionado o botão ST para o disparo da transição 2. Os passos 3, 4, 5 e 6 executam 
cada um dos movimentos da seqüência. A cada passo aguarda-se a confirmação do 
término do movimento indicado pelo respectivo sensor. Ao término da seqüência, após 
o recuo do atuador A, o programa retorna para o passo 2, em que se aguarda um novo 
comando pelo botão ST. 
 
 50
Exemplo 4.3: O SFC a seguir mostra a programação da seqüência A+ B+ A- A+ A- B-. 
 
11
22
ST
A1
33
NN Recuar ARecuar A A0A0
NN Recuar BRecuar B B0B0
B0A0×
NN Avançar AAvançar A A1A1
B1
44 NN Avançar BAvançar B B1B1
B0
88 NN Recuar BRecuar B B0B0
A0
55 NN Recuar ARecuar A A0A0
2
3
4
8
5
1
A1
66 NN Avançar AAvançar A A1A1
6
A0
77 NN Recuar ARecuar A A0A0
7
 
 
Seqüências em que dois ou mais movimentos ocorrem simultaneamente são 
representados da seguinte forma: 
A+ B+ (A- B-) C+ C-. 
Nesse caso, após o avanço de B, o recuo de A e B ocorrem simultaneamente. É 
importante observar que, como o recuo de A não tem necessariamente a mesma 
duração do recuo de B, é necessária a confirmação de ambos os movimentos antes 
que seja comandado o avanço de C. 
 
 51
Exemplo 4.4: Seqüência A+ B+ (A- B-) C+ C-. 
 
11
22
ST
A1
33
NN Recuar ARecuar A A0A0
NN Recuar BRecuar B B0B0
C0B0A0 ××
NN Avançar AAvançar A A1A1
B1
44 NN Avançar BAvançar B B1B1
2
3
4
1
NN Recuar CRecuar C C0C0
55
5
NN Recuar ARecuar A A0A0
NN Recuar BRecuar B B0B0
B0A0×C1
66 NN Avançar CAvançar C C1C1
6
C0
77 NN Recuar CRecuar C C0C0
7
 
 
 52
Exemplo 4.5: Após pressionado um botão ST, um sistema pneumático deve avançar 
um cilindro A. Após o término desse avanço, dois cilindros B e C devem avançar e 
recuar, não necessariamente sincronizadamente. Após o recuo de ambos, o cilindro A 
deve recuar. 
 
11
22
ST
A1
33
NN Recuar ARecuar A A0A0
NN Recuar BRecuar B B0B0
C0B0A0 ××
NN Avançar AAvançar A A1A1
2
3
1
NN Recuar CRecuar C C0C0
44
4
66
5
55 77
6
NN Avançar BAvançar B B1B1
NN Recuar BRecuar B B0B0
NN Avançar CAvançar C C1C1
NN Recuar CRecuar C C0C0
88
7
NN Recuar ARecuar A A0A0
B1 C1
C0B0×
A0
 
 
 53
Exemplo 4.6: Após pressionado um botão ST, um sistema pneumático deve avançar 
um cilindro A. Após o término desse avanço, a posição de uma chave seletora CH 
determinará qual das seqüências B+ B- ou C+ C- será realizada. Após o término dessa 
seqüência, o cilindro A deve recuar. 
 
CHA1×
11
22
ST
33
NN Recuar ARecuar A A0A0
NN Recuar BRecuar B B0B0
C0B0A0 ××
NN Avançar AAvançar A A1A1
2
1
NN Recuar CRecuar C C0C0
44
4
66
7
55 77
NN Avançar BAvançar B B1B1
NN Recuar BRecuar B B0B0
NN Avançar CAvançar C C1C1
NN Recuar CRecuar C C0C0
88
9
NN Recuar ARecuar A A0A0
B1 C1
A0
3 6 CHA1×
B05 8 C0
 
 
 
4.3 - Exercícios 
 
Exercício 4.1: Faça um programa em Ladder para o comando da seguinte seqüência 
de acionamento de cilindros pneumáticos: 
A+ C+ B+ A- C- B- 
Pede-se: 
(a) Diagrama pneumático 
(b) Diagrama de ligações de sensores e atuadores no CLP 
(c) Tabela de sinais 
(d) Programa em Ladder 
 
 54
Exercício 4.2: Faça um programa em SFC para o comando da seguinte seqüência de 
acionamento de cilindros pneumáticos: 
A+ C+ C- B+ A- B- 
 
 
 55
5. Conversão de Programas em SFC para Ladder 
 
Apesar de alguns ambientes de programação de CLPs possuírem a opção de se 
programar diretamente em SFC (ou Graphcet), essa opção pode não ser atraente, já 
que seria necessária a aquisição de uma licença para a utilização de tal ambiente. 
Como a linguagem Ladder é normalmente a mais utilizada, pode ser interessante 
realizar o projeto do sistema em SFC e depois convertê-lo para Ladder. Esse capítulo 
mostra uma metodologia objetiva para realizar tal conversão, o que minimiza ou 
extingue a possibilidade de erros. 
 
5.1 - Representação dos passos 
 
Cada passo de um SFC pode, em um determinado momento, estar ativo ou 
inativo. Dessa forma, para cada passo é utilizado um bit de memória para representar 
seu estado. É conveniente representar cada passo por um bit de memória com a 
mesma numeração de seu endereço, ou seja, passo 1 como M1, passo 2 como M2 etc. 
Para SFCs com mais de 8 passos, é conveniente numerá-los segundo a base de 
numeração octal. Na base octal, cada dígito de um número pode possuir valores de 0 a 
7, ou seja, o número sucessor de 7 é 10, o de 17 é 20, e assim por diante. Assim, se 
tem a seguinte relação: 
 
Passo Memória Passo Memória Passo Memória 
0 M0.0 10 M1.0 20 M2.0 
1 M0.1 11 M1.1 21 M2.1 
2 M0.2 12 M1.2 22 M2.2 
3 M0.3 13 M1.3 23 M2.3 
4 M0.4 14 M1.4 24 M2.4 
5 M0.5 15 M1.5 25 M2.5 
6 M0.6 16 M1.6 26 M2.6 
7 M0.7 17 M1.7 27 M2.7 
 
Para cada ação, deve ser criada uma linha no programa Ladder, que deve ser 
executada apenas quando o respectivo passo estiver ativo. A forma de se programar 
cada ação depende de seu qualificador. 
 56
 
Qualificadores S e R (set e reset) 
 
Os qualificadores S e R devem setar ou resetar um sinal de saída quando o 
passo correspondente estiver ativo. Utilizam-se então bobinas com retenção (S e R) 
que são ativadas pelas memórias correspondentes aos passos em que são realizadas 
as ações. A Figura 5.1 mostra a programação em Ladder de uma ação com 
qualificador S e a Figura 5.2 mostra a programação de uma ação com qualificador R. 
 
33 SS S3.2S3.2
 
M0.3
( )
S3.2
S
 
Figura 5.1 – Programação em Ladder de ação com qualificador S. 
 
77 RR S3.2S3.2
 
M0.7
( )
S3.2
R
 
Figura 5.2 – Programação em Ladder de ação com qualificador R. 
 
Caso dois passos diferentes referenciem uma mesma saída com o mesmo 
qualificador (por exemplo, uma saída pode ser setada em dois pontos diferentes do 
programa), pode-se utilizar uma lógica ou entre as memórias correspondentes aos dois 
passos, com o objetivo de se diminuir o tamanho do programa. Porém, dada a 
característica das bobinas S e R de serem executadas apenas se a condição de 
ativação for verdadeira, não há problema em se programarem duas linhas em Ladder 
que referenciem a mesma saída com bobinas S e R (ver Figura 3.9). 
 
Qualificador N (ou nenhum) 
 
O qualificador N (ou nenhum qualificador especificado) realiza ações que 
somente são válidas enquanto o passo correspondente está ativo. Portanto, nesse 
caso, utiliza-se bobinas comuns (sem retenção), como mostrado na Figura 5.3. 
 57
 
1515 NN S2.1S2.1
 
M1.5
( )
S2.1
 
Figura 5.3 – Programação em Ladder de ação com qualificador N. 
 
Diferentemente das bobinas com retenção (S e R) que são executadas somente 
quando a condição de ativação é verdadeira, as bobinas comuns são sempre 
executadas, escrevendo na saída valor verdadeiro caso a condição seja verdadeira, e 
falso caso a condição seja falsa. Dessa forma, caso uma mesma ação com qualificador 
N seja executada em mais de um passo, deve ser utilizada uma condição de 
acionamento OU entre as memórias correspondentes aos passos em que a ação é 
executada (Figura 5.4). 
 
88 NN S2.5S2.5
1414 NN S2.5S2.5
 
M0.8
( )
S2.5
M1.4
 
Figura 5.4 – Programação em Ladder de uma mesma ação N acionada em dois 
passos diferentes. 
 
 
Qualificador D 
 
O qualificador D determina que a ação deve ser iniciada após decorrido um 
intervalo de tempo especificado desde a ativação do passo, e finalizada quando o 
passo é desativado. Caso o passo seja desativado antes de a ação ser iniciada, a 
mesma não é executada (Figura 5.5). 
 
 58
Passo 
ativo
t
Ação
 
Passo 
ativo
t
Ação
 
Figura 5.5 – Execução da ação com qualificador D. 
 
A programação dessa ação em Ladder é feita pela utilização de um 
temporizador TON acionado pela memória correspondente ao passo em que a ação pe 
executada. 
 
14 D
T#8s
S5.3
 
M1.4
( )( )( )
S5.3TON
IN
8s PT
Q
ET
 
Figura 5.6 – Programação em Ladder de ação com qualificador D. 
 
 
Qualificador L 
 
O qualificador L determina que a ação deve ser iniciada e mantida enquanto o 
passo estiver ativo e enquanto o tempo especificado não tiver sido atingido, ou seja: 
 
Passo 
ativo
t
Ação
 
Passo 
ativo
t
Ação
 
Figura 5.7 – Execução da ação com qualificador L. 
 
A programação em Ladder deve utilizar uma memória auxiliar que é acionada 
quando decorrido o tempo t após o passo acionado. A execução da ação depende do 
 59
passo estar acionado e a memória auxiliar não estar ativa, como mostrado na Figura 
5.8. 
 
10 L
T#4s
S3.2
 
M1.0
( )( )( )
M9.0TON
IN
4s PT
Q
ET
M1.0 M9.0
( )
S3.2
 
Figura 5.8 – Programação em Ladder de ação com qualificador L. 
 
 
Qualificador P 
 
O qualificador P (pulso) determina que a ação deve ser executada durante um 
intervalo de tempo muito pequeno, ou seja, durante um ciclo de varredura do programa. 
 
2323 PP S2.7S2.7
 
( )( )( )
S2.7M2.3
P
 
Figura 5.9 – Programação em Ladder de ação com qualificador P. 
 
 
Qualificador SD 
 
O qualificador SD determina que