Linguagem ladder

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Parte de um Diagrama Ladder

A linguagem Ladder foi originalmente desenvolvida para construir e melhor documentar circuitos a relés, utilizados em processos de produção [1] . Todos os dispositivos dos circuitos elétricos como botões, válvulas e solenoides podem ser representados em símbolos nos Diagramas Ladder, incluindo suas conexões.

Atualmente, a linguagem ladder, diagrama ladder ou diagrama de escada é um auxílio gráfico para programação de Controladores Lógicos Programáveis (CLPs), no qual as funções lógicas são representadas através de contatos e bobinas, de modo análogo a um esquema elétrico com os contatos dos transdutores e atuadores. A linguagem ladder está entre as cinco linguagens de programação de CLPs definidas pela IEC 61131-3 : FBD (Function Block Diagram, Diagrama de Blocos), LD (Ladder diagram, Diagrama Ladder), ST (Structured text, Texto Estruturado), IL (Instruction list, Lista de Instruções) e SFC (Sequential function chart, Diagrama de Funções Sequenciais) [2] [3] .

O nome (ladder, escada em inglês) provém do fato que a disposição dos contatos e bobinas é realizada, de maneira geral, na vertical, que lembra o formato de uma escada. A cada lógica de controle se dá o nome de rung (degrau), composta por linhas e colunas [4] .

A verificação do código pode variar entre as marcas de CLPs, mas é comum que a atualização seja feita da esquerda para a direita e de cima para baixo.

Visão Geral[editar | editar código-fonte]

A linguagem Ladder é uma linguagem de baixo nível utilizada para programar CLPs, capaz de realizar o controle de sistemas críticos e/ou industriais, substituindo os antigos circuitos controladores a relés que eram caros e de difícil manutenção, além de menos seguros. A principal vantagem de representar as lógicas de controle por meio de diagramas Ladder é que permite à engenheiros e técnicos de campo desenvolver "códigos" sem conhecimento prévio de outras lógicas de programação como o FORTRAN ou o C, devido à familiaridade com a lógica a relés. [5]

Um dos principais problemas apresentados pela linguagem é a incompatibilidade entre CLPs, mesmo entre modelos diferentes da mesma família. Embora a IEC 61131-3 tenha diminuído as diferenças mais marcantes entre os diferente CLPs, transferir um código de um controlador para o outro ainda pode ser um trabalho custoso.

Devido ao fato de todos os processos do diagrama serem realizados pelo processador (CPU) do CLP de forma sequencial, é preciso de um uma estrutura de loop que executa um certa quantidade de vezes por segundo, fazendo com que os resultados na saída sejam quase imediatos. Para isso, o CLP utiliza um Ciclo de Varredura que consiste nos seguintes passos:

  • Leitura das entradas e atualização da memória, que podem ser tantos as entradas externas como sensores e chaves, como entradas internas como valores de bobinas e temporizadores.
  • Execução do programa, onde todos os passos da programação são realizados, da esquerda para a direita e de cima para baixo. Nenhum valor obtido nesse processo é utilizado nos cálculos, portanto se alguma bobina obter um novo valor e houver alguma chave associada a ela, esse valor não é alterado até a próxima execução do ciclo de varredura.
  • Escrita da memória e atualização das saídas, onde os novos valores obtidos no passo de Execução do programa são atualizados na memória e as saídas externas são alteradas.

Os componentes da linguagem[editar | editar código-fonte]

Existem 3 tipos de elementos na linguagem Ladder:

  • as entradas (ou contatos), que podem ler o valor de uma variável booleana;
  • as saídas (ou bobinas) que podem escrever o valor de uma variável booleana;
  • os blocos funcionais que permitem realizar funções avançadas.

Os elementos estão associados à variáveis internas que podem tanto ser virtuais como entradas e saídas físicas de um CLP.

As entradas (ou contatos)[editar | editar código-fonte]

Existem dois tipos de contatos:

  • O contato normalmente aberto (NA) (em inglês, NO normally open):
   X
--| |--  a instrução de LÓGICA DIRETA tem na programação a mesma informação de nível lógico vinculada ao endereçamento.

Tal contato está fechado quando a variável booleana associada (no nosso caso X) é verdadeira, caso contrário, ele está aberto.

  • O contato normalmente fechado (NF) (em inglês, NC normally closed):
   X
--|/|-- a instrução de LÓGICA INVERSA tem na programação uma informação inversa de nível lógico vinculada ao endereçamento.

Tal contato está aberto quando a variável booleana associada é verdadeira, caso contrário, ele está fechado.

As saídas (ou bobinas)[editar | editar código-fonte]

As saídas sempre são bobinas, relés contatores ou "de estado sólido" (óptico, PWM, DC, etc...). Tal saída está ativa quando a variável booleana associada é verdadeira, caso contrário, ela está inativa.

Assim como as entradas, há dois tipos de saídas (bobinas) principais:

  • A bobina normalmente aberta, energizada quando a variável booleana associada é verdadeira.
   X
--( )--  a instrução de SAÍDA LÓGICA tem na programação o resultado que à antecedi.

Tal contato está fechado quando a variável booleana associada (no nosso caso X) é verdadeira, caso contrário, ele está aberto.

  • A bobina normalmente fechada, energizada quando a variável booleana associada é falsa.
   X
--(/)-- a instrução de SAÍDA LÓGICA INVERTIDA tem na programação o resultado inverso que à antecedi.

Alguns tipos de bobinas especiais são chamadas Blocos Funcionais, por possuírem implementações mais complexas, como as bobinas de SET e RESET, que funcionam de forma semelhante a Latchs;

Os blocos funcionais[editar | editar código-fonte]

Os blocos funcionais permitem realizar operações mais complexas que a leitura ou escrita de variáveis. São exemplos de blocos funcionais os contadores, temporizadores, bobinas de set ou reset, etc. Utilizando Diagramas de Blocos, pode-se inclusive criar blocos personalizados (funções encapsuladas) definidas pelo usuário para facilitar a organização. Algumas IDEs fornecem outras opções de blocos funcionais como comparadores (maior que, menor que e igual a), operadores matemáticos (adição, subtração, multiplicação e divisão) e portas lógicas. Ainda há a opção de obter bibliotecas com blocos já prontos para uso. [6]

Temporizadores[editar | editar código-fonte]

Temporizadores são dispositivos utilizados para medir o tempo e atuar ao final do ciclo. Comumente os temporizadores são representados por dois símbolos, um indica um retardo na ativação e outro um retardo na desativação.

Na linguagem Ladder os temporizadores levam alguns argumentos para seu funcionamento, são eles:

  • Entrada para ativação;
  • Tempo a ser atingido (delay do sinal).

Para os temporizadores com delay na subida (TON), no momento que houver uma entrada verdadeira, o tempo programado começará a correr. Após o tempo determinado ser atingido, a saída do temporizador será verdadeira e permanecerá nesse estado enquanto a entrada for verdadeira. Quando o valor da entrada for falso o temporizador volta para o estado falso, sendo que caso outra entrada verdadeira seja aplica o processo ocorrerá novamente. Caso o sinal se torne falso antes de o temporizador atingir o valor máximo, sua contagem é resetada e a saída permanece falsa.

Para os temporizadores com delay na descida (TOF), no momento que aplicar-se uma entrada verdadeira, a saída do temporizador também será verdadeira. Quando o valor da entrada for de verdadeiro para falso, o temporizador contará o tempo programado e então sua saída se tornará falso quando o tempo pré-definido for atingido.

Os temporizadores tem uma grande importância na automatização de processos, devido ao fato de dar ao utilizador o controle do tempo de processos. Os temporizadores podem ser tanto digitais, sendo executados pelo processador, ou físicos, possuindo ligação com o CLP.

Contadores[editar | editar código-fonte]

Os contadores são usados para contar o número de ocorrências de um processo. São normalmente conectados a sensores digitais e deste modo é possível controlar o número de pulsos no contador. Três tipos de contadores são normalmente usados, os de contagem crescente e os de contagem decrescente:

Os contadores crescentes (CTU, do inglês Count Up) possuem os seguintes argumentos para seu funcionamento são eles:

  • Sinal de entrada.
  • Valor máximo de impulsos.
  • Reset.

Quando o valor da entrada for de falso para verdadeiro, o contador adiciona um. O valor do contador sendo igual ao valor máximo inserido, a saída do contador será verdadeiro, e se o contador não for resetado, a saída continuará verdadeira e o contador continuará adicionando um a cada valor verdadeiro inserido na entrada. Caso o reset receba um valor verdadeiro o valor do contador volta para zero.

Os contadores decrescentes (CTD, do inglês Count Down) possuem os seguintes argumentos para seu funcionamento são eles:

  • Sinal de entrada.
  • Valor inicial de impulsos.
  • Reset.

O princípio é o mesmo do anterior, porém neste é inserido um valor inicial no contador e a cada vez que o valor da entrada passa de falso para verdadeiro ele irá decrementar um. O contador realizará essa ação até que seu valor seja zero, onde a saída do contador será verdadeira. Também é necessário resetar para utilizá-lo novamente.

Bobinas SET/RESET[editar | editar código-fonte]

Representadas pela bobina padrão com uma letra S (Set) ou R (Reset), esse tipo de bobina armazena um estado (verdadeiro, se a bobina for SET e falso se a bobina for RESET) em uma variável booleana toda vez que uma borda de subida é identificada. O estado então será mantido mesmo com a desenergização da bobina, até que uma outra chamada futura altere seu valor. Esse tipo de bobina facilita a implementação de sistemas com memória.

Exemplos de Programação Ladder[editar | editar código-fonte]

A linguagem Ladder pode ser entendida como uma série de conexões de contatos e bobinas. O lado esquerdo do diagrama é energizado. Se um caminho puder ser traçado da esquerda para a direita e que conecte alguma bobina, então o valor dessa bobina será verdadeiro. Os contatos representam algum valor de entrada, enquanto o valor da "bobina" poderá ser revertido em uma saída física no CLP ou um bit que será usado em alguma outra parte do programa, utilizando-se o nome da bobina como contato.

 ------| |--------------------( )
      Chave                  Bobina

No diagrama acima, ao acionar a Chave, uma conexão é estabelecida entre o lado energizado e a Bobina, que portanto apresentará estado lógico verdadeiro. A maioria dos aparelhos apresentam algum tipo de lógica como esse para ligar e desligar. Note que é necessário que o botão/chave se mantenha pressionado para a bobina manter o estado lógico verdadeiro.

Portas Lógicas[editar | editar código-fonte]

Ver artigo principal: Porta Lógica

Os contatos e relés simples podem ser utilizados para construir portas lógicas, que servem para facilitar a resolução problemas devido ao fato de ser possível o uso de ferramentas para Álgebra Booleana como o Mapa de Karnaugh e Máquinas de Estados.

Porta Lógica AND[editar | editar código-fonte]

A porta lógica AND pode ser representada por dois contatos em série, já que os dois precisam estar ativos para a bobina ser ativada.

 ------| |--------------| |----------------( )
     Chave 1          Chave 2            Bobina

Porta lógica OR[editar | editar código-fonte]

A porta lógica OR pode ser representada por dois contatos em paralelo, já apenas um estando ativo permite a energização de toda a linha.

 --+-------| |-------+--------------------( )
   |     Chave 1     |                   Bobina
   |                 |
   +-------| |-------+
         Chave 2

Porta Inversora NOT[editar | editar código-fonte]

A porta inversora NOT pode ser representada por um contato ou uma bobina invertida (não ambos).

 ------|/|--------------------( )
      Chave                  Bobina

Porta XOR[editar | editar código-fonte]

Com o auxílio de outras portas lógicas, pode-se criar modelos mais complexos, como a porta XOR (OU exclusivo).

 ------|/|--------------| |--------+-------( )
     Chave 1          Chave 2      |     Bobina
                                   |
                                   |
 ------| |--------------|/|--------+
     Chave 1          Chave 2      

Contato de Selo[editar | editar código-fonte]

O contato de selo, também conhecido como Latch, está geralmente associado à botões de INICIAR e PARAR e possui a característica de se manter ativo mesmo quando a chave de início não está mais pressionada, sendo parado somente quando o botão PARAR (ou alguma outra interrupção) for pressionado.

Ao ativar a chave INICIAR, a Bobina é energizada, que por sua ver fecha a chave Bobina, que representa o estado da Bobina. Desse ponto em diante, o circuito só pode ser parado fechando a chave PARAR, que abre o circuito desenergizando a Bobina e voltando o estado lógico da chave Bobina para falso.

 ------| |---------+----|/|-------------( )
     INICIAR       |   PARAR          Bobina
                   |              
                   |              
 ------| |---------+
      Bobina              

Por medidas de segurança, é comum adicionar um contato de Parada de Emergência (P/E) que poderá ser ativada em alguma outra parte do programa.

 ------| |---------+----|/|------[/]-----( )
     INICIAR       |   PARAR     P/E    Bobina
                   |              
                   |              
 ------| |---------+
      Bobina              


Referências

  1. All About Circuits. «“Ladder” Diagrams». Consultado em 17 de nov. de 2015. 
  2. Rockwell Automation. «What is IEC 1131?». Consultado em 17 de nov. de 2015. 
  3. Frank D. Petruzella (2014). Controladores Lógicos Programáveis AMGH [S.l.] ISBN: 978850552829. 
  4. Marcelo Georgini (2007). Descrição e Implementação de Sistemas Sequenciais com CLP Érica [S.l.] ISBN: 9788571947245. 
  5. W. Bolton (2006). Programmable Logic Controllers [S.l.: s.n.] ISBN: 9780750681124. 
  6. «Ladder Elements». www.unitronics.com. Consultado em 2015-11-18. 

Ligações externas[editar | editar código-fonte]

Wiki letter w.svg Este artigo é um esboço. Você pode ajudar a Wikipédia expandindo-o. Editor: considere marcar com um esboço mais específico.