Como construir portas lógicas XOR e NAND em um CLP com o OLLA Lab

Para traduzir a álgebra booleana para a lógica ladder IEC 61131-3, os engenheiros mapeiam estados lógicos abstratos para o comportamento de contatos baseados em varredura (scan) e bobinas de saída. No OLLA Lab, XOR e NAND não são apenas desenhados como símbolos; eles são validados contra E/S simuladas, estados de falha e lógica de resposta da máquina antes de qualquer implantação em tempo real.

A álgebra booleana e a lógica ladder estão relacionadas, mas não são intercambiáveis. As expressões booleanas são abstratas e efetivamente atemporais no papel; a lógica ladder é executada por um CLP em um ciclo de varredura, com entradas reais, estados armazenados e atualizações de saída. Essa diferença é onde muitos erros de iniciantes começam.

Um benchmark interno da Ampergon Vallis destaca isso de forma precisa: 68% dos usuários falharam em sua primeira construção de alarme de discrepância ao implementar o comportamento XOR no OLLA Lab [Metodologia: n=500 sequências lógicas de iniciantes, tarefa definida como construir e testar um alarme de discrepância de duas entradas no ambiente de simulação, comparador de linha de base = aprovação/reprovação na primeira tentativa contra a tabela-verdade esperada e comportamento simulado, janela de tempo = jan-fev 2026]. Isso sustenta uma afirmação limitada: traduzir a intenção booleana para uma estrutura ladder correta é mais difícil do que reconhecer a tabela-verdade. Isso não sustenta qualquer afirmação mais ampla sobre a competência dos engenheiros em toda a indústria.

A álgebra booleana descreve relações lógicas. O Diagrama Ladder (LD) IEC 61131-3 descreve como essas relações são implementadas em um sistema de controle baseado em varredura.

A distinção prática é a seguinte:

- Lógica de CLP é executada ciclicamente: ler entradas -> executar lógica -> escrever saídas.

• Álgebra booleana trata variáveis como A e B como estados lógicos abstratos.
• Lógica ladder mapeia esses estados para tags, bits de memória e E/S físicas ou simuladas.
• Expressões booleanas são lidas como relações estáticas.

Esse comportamento do ciclo de varredura importa porque um degrau (rung) não é apenas uma equação simbólica. Ele é avaliado em sequência usando a imagem atual do processo no controlador.

### Matriz de tradução básica: booleana para lógica ladder

Os mapeamentos iniciais padrão são diretos:

• AND -> contatos em série
• OR -> contatos em paralelo
• NOT -> representação de contato normalmente fechado (NF)
• Condição de saída TRUE -> bobina energizada ou bit interno
• Condição de saída FALSE -> bobina desenergizada ou bit limpo

Esses mapeamentos são fundamentais, mas não são tudo. A tarefa de engenharia não é apenas representar a lógica. É representar a lógica em uma forma que permaneça observável, testável e segura sob condições de processo realistas.

Por que a camada física altera o significado

Uma variável booleana não é um fio. Em um CLP, uma tag pode representar:

• uma entrada de campo de 24 VCC,
• um bit de memória interna,
• um status derivado,
• uma permissiva,
• uma condição de disparo (trip),
• ou um estado de equipamento simulado.

É por isso que "correto" deve ser definido operacionalmente. Neste artigo, correto significa que o degrau produz a saída esperada para todas as combinações de entrada relevantes e se comporta de forma coerente quando testado contra estados de processo simulados e casos de falha.

Onde a IEC 61131-3 importa

A IEC 61131-3 padroniza linguagens de programação, incluindo Diagrama Ladder, Diagrama de Blocos de Funções e Texto Estruturado para controladores programáveis (IEC, 2013). Ela não apaga as diferenças de implementação entre fornecedores, mas fornece um modelo de execução e uma estrutura de linguagem comuns.

Isso importa porque a lógica booleana é universal, enquanto a implementação ladder está sempre ligada a um modelo de controlador, comportamento de varredura e contexto da planta.

Uma porta NAND torna-se falsa apenas quando ambas as entradas são verdadeiras. No controle industrial, isso a torna útil para padrões de permissiva e inibição, onde uma saída permanece disponível a menos que uma combinação específica de condições seja satisfeita simultaneamente.

A forma booleana é:

• C = NOT (A AND B)

A interpretação ladder equivalente é:

• A saída C está ligada quando A é falso, ou B é falso, ou ambos são falsos.
• A saída C desliga apenas quando A e B são ambos verdadeiros.

Por que a NAND aparece na lógica industrial

Na eletrônica, a NAND é frequentemente introduzida como uma porta universal. Na automação industrial, o enquadramento mais útil é mais restrito: é uma maneira prática de expressar "permitir a menos que estas condições coincidam".

Exemplos típicos incluem:

• lógica de queda de permissiva,
• condições de inibição combinadas,
• padrões de agregação de falhas,
• condições de retenção de sequência,
• supressão de estados anormais.

Isso deve ser delimitado cuidadosamente. Uma implementação ladder de NAND não é um substituto para o projeto formal de segurança funcional sob a IEC 61508 ou validação de segurança de máquinas. É um padrão de lógica de controle, não um caso de segurança automática.

Implementação ladder de uma porta NAND

Uma forma ladder comum de dois ramos é:

[Linguagem: Diagrama Ladder] // Porta NAND: A saída está LIGADA a menos que ambas as entradas A e B estejam LIGADAS.

|----[/]----------------------------------------( )----| | Entrada A Saída C | | | |----[/]------------------------------------------------| | Entrada B |

Este degrau usa contatos normalmente fechados (NF) em paralelo:

• Se Entrada A = 0, o ramo superior é verdadeiro.
• Se Entrada B = 0, o ramo inferior é verdadeiro.
• Se qualquer ramo for verdadeiro, a Saída C é energizada.
• Apenas quando A = 1 e B = 1, ambos os contatos NF são avaliados como falsos, derrubando a saída.

Tabela-verdade para NAND em termos ladder

| Entrada A | Entrada B | Saída C | |-----------|-----------|---------| | 0 | 0 | 1 | | 0 | 1 | 1 | | 1 | 0 | 1 | | 1 | 1 | 0 |

Como construir a porta NAND no OLLA Lab

Use o editor ladder baseado na web para construir um teste de permissiva compacto de duas entradas:

O passo importante não é desenhar o degrau. É provar o comportamento:

• ambas as entradas falsas -> saída ligada,
• uma entrada verdadeira -> saída ligada,
• ambas as entradas verdadeiras -> saída desligada.

1. Crie tags para Entrada_A, Entrada_B e Saída_C.
2. Insira dois contatos normalmente fechados em ramos paralelos separados.
3. Atribua um ramo à Entrada_A e o outro à Entrada_B.
4. Coloque a Saída_C como a bobina acionada.
5. Execute a simulação.
6. Alterne as entradas no Painel de Variáveis e verifique a tabela-verdade.

Um exemplo de permissiva realista

Considere uma permissiva simplificada onde uma inibição de manutenção deve permanecer disponível a menos que ambos:

• A = Modo remoto selecionado
• B = Sequência de partida automática ativa

Um degrau estilo NAND pode manter uma saída verdadeira até que ambas as condições estejam presentes simultaneamente. Na prática, esse padrão é frequentemente incorporado em redes de permissivas maiores, não exibido como uma porta de livro didático.

Uma porta XOR torna-se verdadeira apenas quando exatamente uma entrada é verdadeira. Na automação industrial, isso a torna útil para detecção de discrepância, verificação de estado duplo e identificação de falhas onde dois sinais não devem discordar de certas maneiras.

A forma booleana é:

• C = (A AND NOT B) OR (NOT A AND B)

Em termos ladder, a XOR é geralmente construída como dois ramos paralelos com contatos NA e NF acoplados de forma cruzada.

Por que a XOR importa em diagnósticos de máquinas e processos

A XOR torna-se valiosa quando dois sinais representam estados de equipamento mutuamente exclusivos.

Um exemplo clássico é uma válvula com:

• Chave de limite de aberta
• Chave de limite de fechada

Sob condições normais, essas duas indicações não devem ser ambas verdadeiras ao mesmo tempo para uma válvula simples de duas posições. Dependendo do tempo e do estado de deslocamento, elas também não devem permanecer ambas falsas indefinidamente. A filosofia exata do alarme depende do dispositivo e do projeto da sequência, mas a lógica de discrepância é frequentemente construída em torno da XOR ou seu complemento.

Implementação ladder de uma porta XOR

[Linguagem: Diagrama Ladder] // Porta XOR: A saída está LIGADA se A ou B estiver LIGADA, mas não ambos.

|----[ ]--------[/]----------------------------( )----| | Entrada A Entrada B Alarme C| | | |----[/]--------[ ]------------------------------------| | Entrada A Entrada B |

Este degrau funciona da seguinte forma:

• O ramo superior é verdadeiro quando A = 1 e B = 0
• O ramo inferior é verdadeiro quando A = 0 e B = 1
• Se qualquer ramo for verdadeiro, o Alarme C é energizado
• Se ambas as entradas forem iguais, o alarme permanece desligado

Tabela-verdade para XOR em termos ladder

| Entrada A | Entrada B | Alarme C | |-----------|-----------|----------| | 0 | 0 | 0 | | 0 | 1 | 1 | | 1 | 0 | 1 | | 1 | 1 | 0 |

Como a XOR suporta alarmes de discrepância

Para um alarme de discrepância, a XOR é útil quando a condição de alarme é definida como "os dois sinais de estado discordam".

Exemplos incluem:

• discordância de indicação aberto/fechado,
• incompatibilidade de sensores redundantes,
• incompatibilidade entre estado comandado e feedback,
• discordância de chave seletora,
• bits de status emparelhados que deveriam ser mutuamente exclusivos.

Isso ainda deve ser projetado com contexto. Uma válvula em trânsito pode legitimamente produzir discordância temporária ou perda temporária de ambas as confirmações de estado final. Uma boa lógica de alarme geralmente adiciona tempo, estado de sequência ou contexto de movimento. A XOR bruta é um núcleo útil, não a filosofia finalizada.

Como construir a porta XOR no OLLA Lab

Use o OLLA Lab para construir e testar o degrau de discrepância diretamente no navegador:

A sequência de teste deve confirmar:

• 00 -> alarme desligado
• 01 -> alarme ligado
• 10 -> alarme ligado
• 11 -> alarme desligado

Se o degrau fizer qualquer outra coisa, o problema geralmente é uma destas três coisas:

• tipo de contato invertido,
• estrutura de ramo incorreta,
• significado da tag mal definido.

1. Crie tags para Entrada_A, Entrada_B e Alarme_C.
2. Adicione dois ramos paralelos.
3. No primeiro ramo, coloque NA Entrada_A em série com NF Entrada_B.
4. No segundo ramo, coloque NF Entrada_A em série com NA Entrada_B.
5. Acione o Alarme_C com a saída do ramo.
6. Execute a simulação e alterne as duas entradas através de todos os quatro estados.

O ciclo de varredura do CLP torna a lógica ladder temporal, não apenas lógica. As entradas são lidas, a lógica é resolvida e as saídas são escritas em sequência, o que significa que o comportamento depende de quando as mudanças de estado são observadas.

Para exemplos básicos de duas entradas, o ciclo de varredura pode parecer invisível. Para equipamentos reais, não é.

A sequência de varredura padrão

A maioria das execuções de CLP segue este padrão amplo:

1. Ler entradas
2. Executar lógica do programa
3. Atualizar saídas
4. Realizar comunicações, diagnósticos, manutenção

Os detalhes exatos variam de acordo com a plataforma, modelo de tarefa e fornecedor, mas o princípio é estável.

Por que isso importa para a lógica de discrepância

Um alarme de discrepância XOR pode se comportar de maneira diferente dependendo de:

• tempo de atualização da entrada,
• tratamento de debounce,
• estado da sequência,
• lógica de pulso único (one-shot),
• uso de temporizadores,
• movimento assíncrono do dispositivo.

Por exemplo:

• uma válvula pode deixar ambas as chaves de limite falsas durante o trânsito,
• uma chave pode oscilar (chatter),
• um feedback pode atrasar o outro por várias varreduras,
• uma entrada simulada ou forçada pode mudar de forma limpa enquanto um dispositivo real não muda.

É por isso que a validação consciente da varredura importa. A álgebra booleana assume relações de estado idealizadas. O equipamento frequentemente introduz atraso, oscilação e ambiguidade.

Por que isso importa para permissivas

Uma permissiva estilo NAND pode derrubar uma saída apenas quando ambas as condições se tornam verdadeiras no mesmo estado avaliado. Se uma condição for travada (latch), atrasada ou derivada através de outro degrau, o comportamento observado pode diferir da tabela-verdade simples, a menos que a lógica circundante seja compreendida.

O OLLA Lab simula o comportamento de portas lógicas permitindo que os usuários construam degraus ladder, executem-nos em um ambiente controlado, alternem entradas, inspecionem estados de variáveis e comparem resultados ladder contra o comportamento simulado do equipamento.

Isso o torna um ambiente de validação delimitado para tarefas de aprendizado de alto risco, não um substituto para testes de aceitação no local ou validação formal de segurança.

O que "Pronto para Simulação" significa aqui

Neste artigo, Pronto para Simulação significa que um engenheiro pode:

• provar o comportamento lógico esperado contra estados de teste definidos,
• observar a causalidade de E/S na simulação,
• diagnosticar comportamento incorreto do degrau,
• injetar condições anormais,
• revisar a lógica,
• e verificar o comportamento revisado antes de tocar no equipamento real.

Como testar um caso de falha NAND no OLLA Lab

Use o Painel de Variáveis para percorrer as combinações de entrada:

• Defina Entrada_A = 0, Entrada_B = 0 -> confirme Saída_C = 1
• Defina Entrada_A = 1, Entrada_B = 0 -> confirme Saída_C = 1
• Defina Entrada_A = 0, Entrada_B = 1 -> confirme Saída_C = 1
• Defina Entrada_A = 1, Entrada_B = 1 -> confirme Saída_C = 0

Em seguida, injete um cenário de falha:

• redefina uma entrada conceitualmente como uma fonte de permissiva travada em nível alto,
• observe se a saída ainda pode ser explicada pela estrutura do degrau,
• revise a lógica ou a definição da tag se o comportamento não corresponder mais à filosofia de controle pretendida.

Como testar uma falha de discrepância XOR no OLLA Lab

Para um modelo de alarme de discrepância:

- Em seguida, simule um caso de falha como:

• Alterne Entrada_A e Entrada_B através de todos os quatro estados da tabela-verdade.
• Confirme que os estados de discordância energizam o Alarme_C.
• uma chave de limite travada ligada,
• ambas as chaves forçadas como verdadeiras,
• ambas as chaves falsas por mais tempo do que o esperado,
• estado de comando inconsistente com o estado de feedback.

O Painel de Variáveis é útil aqui porque expõe o estado diretamente.

Por que isso importa além de aprender a sintaxe

A simulação fecha a lacuna entre a construção do degrau e a prova comportamental. Pesquisas sobre gêmeos digitais, treinamento baseado em simulação e validação ciberfísica apontam para o valor dos testes virtuais para reduzir riscos, melhorar a compreensão do comportamento do sistema e apoiar a descoberta precoce de falhas em fluxos de trabalho de automação (Tao et al., 2019; Fuller et al., 2020; Villalonga et al., 2021).

Isso não significa que um simulador certifique um projeto. Significa que um simulador dá aos engenheiros um lugar mais seguro para encontrar erros óbvios antes que a planta o faça.

Um bom fluxo de trabalho define a correção antes que o teste comece. Se "correto" for deixado vago, a simulação torna-se teatro.

Use esta estrutura de evidências compacta ao documentar uma construção ou revisão de porta lógica:

Defina o equipamento ou função de controle. Exemplo: "Válvula de duas posições com feedback de aberta e fechada usada para alarme de discrepância."

Declare o comportamento esperado em termos observáveis. Exemplo: "O alarme energiza quando exatamente um feedback é verdadeiro; o alarme permanece desligado quando ambos são iguais, sujeito a quaisquer exceções de tempo documentadas separadamente."

Defina a condição anormal. Exemplo: "Chave de limite de fechada travada em nível alto durante a transição de comando de abertura."

Mostre o que mudou. Exemplo: "Adicionado temporizador de transição e qualificador de estado de comando para suprimir alarme incômodo durante o trânsito normal."

Declare o que o teste revelou. Exemplo: "A XOR bruta detectou a discordância corretamente, mas gerou alarme excessivo durante transições de estado legítimas."

1. Descrição do Sistema
2. Definição operacional de 'correto'
3. Lógica ladder e estado do equipamento simulado Inclua o degrau real e os estados correspondentes da tag simulada ou estados do equipamento.
4. O caso de falha injetado
5. A revisão feita
6. Lições aprendidas

O erro mais comum é assumir que a tabela-verdade é o projeto. Não é. A tabela-verdade é apenas a restrição inicial.

Erros frequentes de implementação

• Inverter contatos NA e NF
• Confundir o significado do sinal com o estado do sinal
• Ignorar os efeitos do ciclo de varredura
• Testar apenas o caso esperado
• Tratar a lógica de permissiva como equivalente à lógica de segurança
• Falhar ao definir o modelo de estado do processo

Uma correção prática

Ao construir qualquer degrau baseado em porta, defina três coisas antes de simular:

• o que cada tag representa física ou logicamente,
• qual comportamento de saída é considerado correto,
• quais estados anormais devem ser tolerados versus alarmados.

Essa disciplina remove uma quantidade surpreendente de confusão. Muitos "bugs de lógica" são, na verdade, bugs de especificação.

Use o OLLA Lab quando a tarefa de engenharia exigir ensaio do comportamento lógico, causalidade de E/S, injeção de falhas ou validação de sequência sem expor o equipamento real a riscos desnecessários.

Isso inclui:

• prática de ladder de nível iniciante a intermediário,
• ensaio de alarme de discrepância,
• teste de lógica de permissiva,
• trabalho de cenário de controle de válvula e motor,
• revisão de interação analógica/discreta,
• exercícios de laboratório conduzidos por instrutor,
• orientações de lógica de pré-comissionamento em um ambiente delimitado.

Com base na documentação do produto, o OLLA Lab suporta isso através de:

• um editor de lógica ladder baseado em navegador,
• modo de simulação,
• visibilidade de variáveis e E/S,
• predefinições industriais baseadas em cenários,
• fluxos de trabalho de validação orientados a gêmeos digitais,
• acesso à simulação 3D/WebXR/VR onde habilitado,
• instruções de construção guiadas,
• coaching de laboratório com IA através da GeniAI.

A afirmação delimitada é simples: o OLLA Lab oferece aos engenheiros um ambiente prático para construir e testar a lógica ladder contra o comportamento simulado. Ele não substitui o comissionamento da planta, procedimentos do local, manuais do fornecedor ou obrigações do ciclo de vida de segurança funcional.

A álgebra booleana fornece a forma lógica. A lógica ladder IEC 61131-3 fornece a estrutura executável. O desafio de engenharia é a tradução entre elas, especialmente quando o tempo de varredura, o comportamento do dispositivo e os estados de falha entram em cena.

NAND e XOR são exemplos úteis porque expõem essa tradução de forma clara:

• NAND expressa lógica de permissiva que cai apenas quando as condições coincidem.
• XOR expressa lógica de discordância que identifica incompatibilidade de estado.

Em ambos os casos, o degrau é apenas o começo. O trabalho real é provar o comportamento sob condições normais e anormais. É aí que um ambiente de simulação se paga.

Leitura relacionada

- Veja A mudança para o pensamento sistêmico: indo além de desenhar degraus.

• Para um contexto de padrões mais amplo, visite nosso Hub de Maestria em Lógica Ladder.
• Veja Por que os contatos "Normalmente Fechados" são os degraus mais importantes que você escreverá.
• Pronto para testar esta lógica de discrepância? Abra a predefinição de Controle de Válvula no OLLA Lab.

- IEC 61131-3: Controladores programáveis — Parte 3 - Família de normas de segurança funcional IEC 61508 - Recursos de validação e segurança funcional da exida - Recomendação de sinalização de status NAMUR NE 107 - Gêmeo digital na indústria: estado da arte (DOI)