Desenvolva o projeto de automação para o sistema de movimentação por esteiras transportadoras, descrito abaixo. O projeto deverá ser realizado conforme a metodologia de abordagem mostrada em aula e deverá conter os seguintes itens:
Programa em linguagem Ladder ou SFC.

Passo 1

O que o enunciado pede e quais informações temos (e as suposições que vou adotar sem te perguntar nada):
  • Pede: desenvolver o projeto de automação para um sistema de movimentação por esteiras transportadoras, seguindo a metodologia vista em aula, e entregar o programa em Ladder (ou SFC).
  • Informações dadas: apenas o enunciado genérico (sem diagrama, sem nº de esteiras, sem lista de sensores/atuadores).
  • Como não posso te perguntar nada, vou assumir um caso típico e completo que cobre o que normalmente se exige em provas e projetos de graduação: um sistema com três zonas/esteiras em série (Entrada / Transfer / Saída), detecção por sensores fotoelétricos, acionamento por contatores (ou VSD com comando digital), modos Automático/Manual, parada de emergência, detecção de atolamento (jam), sinalização e interface básica HMI.
  • Perguntas específicas que o projeto resolve (o que vou entregar): lista de requisitos funcionais, I/O física e mapeamento, diagrama de blocos lógico, especificações de segurança elétrica e intertravamentos, estratégia de controle (descrita passo a passo), o programa em Ladder rung a rung (com explicações pedagógicas de cada rung), timers/counters e rotina de diagnóstico, e roteiro de comissionamento/testes.

Passo 2

Resumo funcional do sistema (o que o sistema deve fazer — requisitos funcionais)
  • Objetivo geral: transportar peças de uma zona de entrada até a saída em três áreas consecutivas sem colisão entre peças; permitir operação em modo Automático e Manual; garantir parada segura e detectar falhas (jam/overload).
  • Requisitos de comportamento (modo Automático):
    • Ao pressionar Start (modo Auto), a esteira de entrada (M1) deve alimentar peças até que um sensor indique peça na zona 2; então, o movimento deve coordenar para evitar que duas peças se choquem (acumulação).
    • Cada motor só deve girar se a zona imediatamente à frente estiver livre (controle por zoneamento).
    • Quando a peça chega à zona 3 (saída) acionar a esteira de saída (M3) para descarregar.
    • Se uma peça permanecer muito tempo sobre um sensor (tempo de atolamento), gerar alarme e parar o sistema.
  • Requisitos de comportamento (modo Manual): operador pode ligar motores individualmente para jog ou limpeza; respeito ao E-Stop e às proteções.
  • Segurança: botão Emergency-Stop com circuito de segurança (hardware); reset de falha por operador; proteção por relés de segurança para cortar alimentação dos contactores.
  • Interface: sinais de status (Leds), alarme sonoro, HMI com modo, contagem de peças e log de falhas.

Passo 3

Componentes e seleção (hardware típica para a prova)
  • PLC: controlador com pelo menos 16 entradas digitais e 8 saídas digitais (qualquer modelo básico atende: ex. Siemens S7-1200, Allen-Bradley MicroLogix, ou equivalente).
  • Sensores: 3 fotoelétricos (S1 entrada, S2 transferência, S3 saída).
  • Atuadores: 3 contactores para motores (M1, M2, M3). Possível uso de VFD se controle de velocidade for necessário (aqui consideramos liga/desliga via digital).
  • Botões/Painel: Start Auto, Stop, Reset Falha, E-Stop, Seletor Auto/Manual, Botões Jog M1/M2/M3 (para manual).
  • Sinais visuais/auditivos: Luz verde (Operação), Amarela (Aviso), Vermelha (Falha), Buzzer.
  • Relé/Bloco de segurança para E-Stop antes do PLC (corta alimentação de contactores).
  • Fonte 24Vdc para sensores e entradas PLC.

Passo 4

Mapeamento de entradas e saídas (exemplo de mapeamento para o PLC)
  • Entradas digitais (exemplo):
    • I0.0 = Start (pushbutton)
    • I0.1 = Stop (pushbutton)
    • I0.2 = Reset Falha (pushbutton)
    • I0.3 = Seletor Auto/Manual (1 = Auto, 0 = Manual)
    • I0.4 = E-Stop (loop de segurança, normalmente fechado / via relé de segurança)
    • I0.5 = S1 (sensor entrada)
    • I0.6 = S2 (sensor transferência)
    • I0.7 = S3 (sensor saída)
    • I1.0 = Jog M1 (botão manual)
    • I1.1 = Jog M2
    • I1.2 = Jog M3
    • I1.3 = Overload / Fault do motor (comum)
  • Saídas digitais:
    • Q0.0 = Contator M1 (motor entrada)
    • Q0.1 = Contator M2 (motor transferência)
    • Q0.2 = Contator M3 (motor saída)
    • Q0.3 = Lamp Verde (Operação)
    • Q0.4 = Lamp Amarela (Aviso)
    • Q0.5 = Lamp Vermelha (Falha)
    • Q0.6 = Buzzer Alarme
  • Memória interna / flags (bits do PLC): AutoMode, StartLatch, Fault, Jam_S1, Jam_S2, Jam_S3, PieceDetected_S1_edge, etc. (vamos definir na lógica).

Passo 5

Estratégia de controle (explicação didática, passo a passo)
  • Conceito de zoneamento: o transportador é dividido em zonas; cada motor/acionamento move apenas a sua zona. Um motor só pode ligar se a próxima zona estiver livre — assim evita colisões.
  • Detecção de peça: sensor S_n indica presença de peça em zona n. Usamos detecção de borda (rising edge) para contar peças e timers para detectar atolamento.
  • Lógica básica em Auto:
    1. Se Start pressionado e não houver Falha, setar StartLatch.
    2. Enquanto StartLatch ativo e AutoMode selecionado:
      • M1 (entrada) liga se (zona 2 não ocupada) e (StartLatch). Ou seja, M1 = StartLatch AND (NOT S2).
      • M2 (transfer) liga se (S1 detectou peça) e (NOT S3). Uma prática mais robusta é: M2 liga se peça em zona 2 ou se peça chegando e zona 3 livre.
      • M3 (saída) liga quando S3 detecta peça (para descarregar).
    3. Para evitar “stop-and-go” indesejado e para garantir avanço suficiente, cada acionamento pode ter um mínimo tempo de funcionamento (timer run-min).
    4. Atolamento: se S1/S2/S3 permanecer ativo por tempo > T_jam (ex.: 8 s), gerar Falha e desligar StartLatch.
  • Lógica em Manual: operador pode acionar Q0.0 / Q0.1 / Q0.2 diretamente via botões jog, ignorando a lógica automática de zoneamento, mas mantendo E-Stop e proteções. É boa prática permitir jog apenas se seletor estiver em Manual.
  • Edge detection e contagem: ao detectar borda de sensor (0->1), incrementar contador de peças. Explicarei como implementar com contatos e bits internos no Ladder.

Passo 6

Lista de variáveis internas e timers/counters (definição explícita)
  • Bits internos:
    • M_Auto = I0.3 (Seletor Auto/Manual)
    • Start_PB = I0.0
    • Stop_PB = I0.1
    • Reset_PB = I0.2
    • EStop = I0.4
    • S1 = I0.5, S2 = I0.6, S3 = I0.7
    • Jog_M1 = I1.0, Jog_M2 = I1.1, Jog_M3 = I1.2
    • Fault = M0.0
    • StartLatch = M0.1
    • M1_Run = Q0.0, M2_Run = Q0.1, M3_Run = Q0.2
    • Jam_S1 = M0.2, Jam_S2 = M0.3, Jam_S3 = M0.4
    • S1_rising = M0.5, S2_rising = M0.6, S3_rising = M0.7
  • Timers:
    • T_minRun_Mn: garante tempo mínimo de acionamento (TON) para cada motor (ex.: 0,5s)
    • T_jam_Sn: temporizador para detectar atolamento (ex.: 8 s)
  • Counter: C_Pieces: contador de peças passadas pelo sensor S3.

Passo 7

Princípios de instruções Ladder usados (aula rápida)
  • Contato normalmente aberto (NO): avalia TRUE quando a entrada/bit está 1. Serve para condicionar um coil/ação.
  • Contato normalmente fechado (NC): avalia TRUE quando a entrada/bit está 0. Útil para permissivos e intertravamentos.
  • Coil (Saída): aciona uma saída física (Q) ou seta um flag interno (M).
  • Set / Reset: instruções para latch (SET mantém bit até RESET). Úteis para StartLatch e Falha.
  • TON (Timer ON Delay): quando a condição é verdadeira, o temporizador começa a contar; ao atingir preset, saída passa a 1. Usado para mínimos de tempo e jams.
  • RISING EDGE detect: detectar transição 0->1 de um sensor para contar peças. Implementa-se comparando o estado atual com o anterior (flag armazenada). Vou mostrar como fazer isso.

Passo 8

Programa Ladder — rungs com explicações passo a passo
Obs.: cada rung é apresentado em linguagem lógica sequencial (explicação + pseudocódigo Ladder). Na implementação real no software do PLC, cada contato e bobina deve ser colocado exatamente como mostrado.
Rung 1 — Reset de Falha e condição de E-Stop
  • Função: permitir reset de falha apenas se E-Stop estiver liberado. Se E-Stop ativado, forçar Fault.
  • Lógica:
    • Se EStop = 1 (ativo), então SET Fault (M0.0). (Mas em prática o E-Stop deve atuar em relé de segurança hardware; aqui também colocamos bit de diagnóstico).
    • Se Reset_PB pressionado AND (EStop = 0) então RESET Fault.
  • Explicação: isso garante que o operador só possa resetar depois de liberar o E-Stop.
Rung 2 — Start / Stop latch global (StartLatch)
  • Função: latch para Start do sistema.
  • Lógica:
    • Condição para SET StartLatch (M0.1): Start_PB AND (NOT Fault) AND (NOT EStop).
    • Condição para RESET StartLatch: Stop_PB OR Fault OR EStop.
  • Explicação: StartLatch é o “master run” do sistema em modo Auto.
Rung 3 — Modo Auto/Manual indicação e permissões
  • Função: Habilitar lógica Auto ou Manual.
  • Lógica:
    • Se M_Auto = 1 e StartLatch = 1 e NOT Fault então bit Auto_Run_Enable = 1 (interno).
    • Se M_Auto = 0 então ManualMode = 1.
  • Explicação: separa as rotinas de controle.
Rung 4 — Controle do motor M1 (entrada) em Auto
  • Função: ligar M1 quando permitido pelo zoneamento e StartLatch.
  • Lógica Auto:
    • Permissão M1_auto = StartLatch AND (NOT S2) AND (NOT Fault) AND (NOT EStop).
    • Saída Q0.0 = M1_auto OR Jog_M1 (se ManualMode e Jog_M1 pressed).
  • Mínimo tempo de acionamento:
    • Se M1_auto passa a 1, iniciar TON T_minRun_M1 (preset 0,5s). Q0.0 bloqueada para permanecer 1 até que T_minRun_M1 tenha expirado e condição de permissão fique 0 — isso evita ligar/desligar muito rápido.
  • Explicação: o contato NOT S2 garante que M1 só avance se a próxima zona estiver livre.
Rung 5 — Controle do motor M2 (transfer) em Auto
  • Função: ligar M2 quando houver peça na zona à sua frente e a seguinte estiver livre.
  • Lógica:
    • Permissão M2_auto = (S1 OR S2) AND (NOT S3) AND StartLatch AND (NOT Fault).
    • Q0.1 = M2_auto OR Jog_M2.
    • Aplicar T_minRun_M2 igual ao M1.
  • Explicação: incluir S1 OR S2 permite puxar a peça se estiver chegando; dependendo da topologia, essa expressão pode ser ajustada.
Rung 6 — Controle do motor M3 (saída)
  • Função: descarregar peças ao detectar S3.
  • Lógica:
    • Permissão M3_auto = S3 AND StartLatch AND (NOT Fault).
    • Q0.2 = M3_auto OR Jog_M3.
    • Contador de peças: ao detectar borda rising de S3, incrementar C_Pieces. Implementação da borda abaixo.
  • Explicação: M3 aciona para remover peça da zona 3.
Rung 7 — Detectores de borda (rising edge) para contagem
  • Função: detectar transição 0->1 de S3 e incrementar contador.
  • Lógica padrão:
    • S3_rising = S3 AND (NOT S3_prev) // onde S3_prev é armazenado em M1.0 por exemplo
    • Se S3_rising então CTU C_Pieces.
    • Ao final do ciclo, atualizar S3_prev := S3 (armazenamento em memória para próxima varredura).
  • Implementação prática: usar o bloco de detecção de flanco do ambiente do teu PLC ou criar com contatos e coils.
Rung 8 — Timer de jam (atolamento)
  • Função: detectar se um sensor ficou ativo por tempo excessivo.
  • Lógica por sensor (S1 como exemplo):
    • Se S1 = 1 então TON T_jam_S1 começa a contar (preset ex.: 8 s).
    • Se S1 = 0 então reset T_jam_S1.
    • Se T_jam_S1.DN = 1 então SET Jam_S1 (M0.2) e SET Fault (M0.0).
  • Fazer o mesmo para S2 e S3.
  • Explicação: se uma peça travar, após 8 s o PLC dispara falha e para o processo.
Rung 9 — Alarme e indicação
  • Função: ligar lâmpadas e buzzer conforme estado.
  • Lógica:
    • Q0.3 (Verde) = StartLatch AND (NOT Fault)
    • Q0.4 (Amarelo) = Warning (ex.: jam próximo) — opcional
    • Q0.5 (Vermelho) = Fault
    • Q0.6 (Buzzer) = Fault (pulsado)
  • Explicação: dá feedback ao operador.
Rung 10 — Proteções de Overload / Fault de motor
  • Função: garantir que um sinal de overload (I1.3) cause parada segura.
  • Lógica: se I1.3 = 1 então SET Fault e RESET StartLatch. Na prática, o contato de overload deve cortar a alimentação do motor via contator e também sinalizar ao PLC.
Rung 11 — Reset StartLatch e restart seguro
  • Função: após falha, permitir reset somente se condições seguras (EStop liberado).
  • Lógica: Reset Falha (I0.2) AND NOT EStop -> RESET Fault; então StartLatch pode ser re-armado via Start_PB.
Rung 12 — HMI Tags e Telemetria
  • Função: disponibilizar variáveis para HMI: C_Pieces, Fault message, status de S1,S2,S3, timers, etc.
  • Lógica: mapear bits e contadores para tags HMI.

Passo 9

Implementação prática e exemplos de rungs em texto (pseudocode Ladder)
Vou colocar alguns rungs em formato textual claro, que você pode traduzir diretamente para o editor Ladder do PLC.
Rung A (Start latch)
  • NO Start_PB — NC Fault — NC EStop — (SET StartLatch M0.1)
  • NO Stop_PB — (RESET StartLatch M0.1)
  • NO Fault — (RESET StartLatch M0.1) // alternativa redundante
Rung B (M1 Auto permissive)
  • NO StartLatch — NC S2 — NC Fault — NC EStop — (Coil M1_auto)
  • NO M1_auto — TON T_minRun_M1 (0,5s) — (Coil Q0.0)
Rung C (M2 Auto permissive)
  • NO StartLatch — (NO S1 OR NO S2) — NC S3 — NC Fault — (Coil M2_auto)
  • NO M2_auto — TON T_minRun_M2 (0,5s) — (Coil Q0.1)
Rung D (M3 Auto permissive)
  • NO StartLatch — NO S3 — NC Fault — (Coil M3_auto)
  • NO M3_auto — TON T_minRun_M3 (0,5s) — (Coil Q0.2)
Rung E (Jam detection for S1)
  • NO S1 — TON T_jam_S1 (preset 8s) — NO T_jam_S1.DN — // se CNF expira, abaixo:
  • T_jam_S1.DN — (SET Jam_S1 M0.2) — (SET Fault M0.0)
Rung F (S3 rising detect and counter)
  • NO S3 — NC S3_prev — (Pulse -> CTU C_Pieces)
  • After update: MOV S3 -> S3_prev
Obs.: no editor Ladder, a detecção de borda e armazenamento de “S_prev” pode ser feita com blocos auxiliares ou com instruções SET/RESET entre varreduras.

Passo 10

Testes de bancada, comissionamento e tuning (o que fazer na prova ou em aula prática)
  • Testes individuais: verificar cada sensor e cada saída manualmente (modo Manual). Testar botões Start/Stop/Reset/E-Stop.
  • Testes de sequência: em Auto, colocar peças (ou simular com fita/objeto) e observar transferência entre zonas; ajustar T_minRun se peças girarem pouco.
  • Testes de jam: simular peça travada em S2 e checar se após T_jam alarmes saltam e sistema para.
  • Ajustes: tempos, debounces de sensores (se necessário, adicionar filtro TON pequeno para evitar leituras falsas), tempos mínimos de acionamento.
  • Segurança: verificar circuito de E-Stop com relé de segurança externo — PLC não substitui prova de corte físico.

Passo 11

Boas práticas e considerações finais (dicas do amigo professor)
  • Separar lógica de segurança (hardware / relé de segurança) da lógica de controle (PLC). Nunca deixe apenas software para proteção crítica.
  • Documentar I/O no gabinete e no software, com etiquetas físicas.
  • Manter nomes claros para bits e timers no programa (ex.: M1_AUTO, JAM_S2, T_JAM_S2).
  • Implementar logs simples de falhas (timestamp se houver relógio) e contagem de reset para diagnóstico.
  • Em prova, comente brevemente as suposições dadas (nº de zonas, tempos) — mostra que você sabe justificar suas escolhas.

Resposta

Projeto completo com: requisitos, I/O mapping, estratégia de zoneamento, rotinas de segurança, lista de bits/timers/counters, rungs Ladder detalhados (StartLatch, controle M1/M2/M3, detecção de borda, timers de jam, alarmes) e procedimento de comissionamento — conforme descrito nos passos acima.

Exercícios relacionados