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.
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:
- Se Start pressionado e não houver Falha, setar StartLatch.
- 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).
- 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).
- 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.
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.
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.