22. O Contador de Parafusos (Funil):

Deseja-se empacotar parafusos em dezenas. Um funil possui uma válvula solenoide. Quando energizada, ela abre e deixa cair os parafusos. Um sensor óptico gera um pulso a cada parafuso.
  • Ao apertar o botão “Start”, a válvula abre.
  • Após a contagem de exatos 10 parafusos, a válvula deve fechar.
  • A esteira avança a caixa (Saída Q2 por 3 segundos), o contador deve ser resetado e o ciclo recomeça.

Passo 1

Vou clarear exatamente o que o enunciado pede e quais são as informações dadas, sem resolver ainda.
  • O que o enunciado pede (as perguntas/imposições):
    1. Ao apertar o botão “Start” a válvula do funil deve abrir.
    2. A cada parafuso que cai o sensor óptico gera um pulso.
    3. Quando forem contados exatamente 10 parafusos a válvula deve fechar.
    4. Após a válvula fechar, a esteira deve avançar a caixa (saída Q_2) por 3 segundos.
    5. Depois desses 3 segundos, o contador deve ser resetado e o ciclo recomeça automaticamente (ou seja, repetir o processo enquanto o sistema estiver em operação).
  • Informações relevantes que o enunciado dá:
    • Há um botão de entrada (Start) que inicia o processo.
    • Há um sensor que gera um pulso por parafuso (cada pulso = 1 parafuso).
    • Existe uma válvula controlada por uma saída (vou chamar genericamente de Q_{valve}).
    • Existe uma saída que comanda a esteira/avançamento por exatamente 3 segundos (vou chamar de Q_2).
    • O objetivo final é um ciclo repetitivo: abrir válvula → contar 10 pulsos → fechar válvula → ligar Q_2 por 3 s → resetar contador → reabrir válvula → etc.

Passo 2

Definir sinais, nomes e pressupostos práticos (isso ajuda a formular a solução com clareza).
  • Entradas (sensores/controles):
    • Start: botão digital (pulso de comando para começar / armar o ciclo).
    • Pulse: sinal digital do sensor óptico, gera um pulso por parafuso. Pode ser nível alto por um tempo curto; atenção a ruído/bounce.
  • Saídas:
    • Q_{valve}: saída digital que energiza a válvula (1 = aberta, 0 = fechada).
    • Q_2: saída digital que aciona a movimentação da esteira (1 = esteira ligada/avança).
  • Variáveis internas:
    • C: contador de pulsos (inteiro, inicia em 0, incrementa até 10).
    • T: temporizador programável com tempo 3 segundos.
    • RUN: bit que indica que o sistema está em operação (após o Start).
    • Done: bit que indica que já chegaram os 10 parafusos e aguardamos o avanço da esteira.
  • Pressupostos práticos que farei (importante para a implementação):
    • Contagem deve ser por borda do pulso do sensor (tipicamente borda de subida). Se o sensor gera nível, é preciso detectar a borda para evitar múltiplas contagens por um mesmo parafuso.
    • O botão Start coloca o sistema em RUN (latch), e o ciclo repete enquanto RUN=1. Se desejar comportamento diferente (Start só inicia um ciclo único), a lógica muda levemente.
    • Se houver necessidade de parada de emergência/Stop, isso seria um input adicional; aqui não foi solicitado, então não adiciono, mas menciono que na prática recomenda-se.

Passo 3

Explicar os elementos lógicos e componentes que usaremos — ensinar o conceito de cada um para você saber como aplicá-los na prova.
  • Contador ( C):
    • O contador é um elemento que armazena um número inteiro e possui normalmente entradas para incrementar, decrementar e resetar.
    • Aqui usaremos um contador que incrementa em +1 a cada pulso de borda do sensor e compara seu valor com 10.
    • Em lógica simples, podemos representar a ação: quando ocorrer uma borda válida do sensor e RUN=1 e Done=0 então C := C + 1. Se C = 10 então dispare Done := 1.
    • Exemplo didático: se C=0 e chegam 3 pulsos, C evolui 0 \to 1 \to 2 \to 3.
  • Detecção de borda (one-shot):
    • Sensores muitas vezes produzem sinais que duram algum tempo; se na lógica só testarmos o nível, podemos contar várias vezes. Para contar uma vez por parafuso, precisa-se detectar a borda (por exemplo, subida).
    • Uma técnica simples (em PLC ou algoritmo) é armazenar o estado anterior Pulse_{prev} e definir: Pulse_{edge} := Pulse \land \lnot Pulse_{prev}.Isso é verdadeiro só na transição 0 \to 1. Depois atualiza-se Pulse_{prev} := Pulse.
    • Ensina: borda é como “pegar o momento exato” quando um pulso sobe.
  • Temporizador ( T):
    • Usaremos um temporizador que, quando habilitado, conta o tempo até 3 segundos e então fica em estado “done” (ou “timed out”).
    • Em PLCs há temporizadores TON (on-delay) que começam a contar quando a entrada fica 1; depois de 3 s a saída do temporizador vira 1.
    • Aqui: ao detectar C=10 iniciamos T. Enquanto T não expirou, Q_2 fica 1; quando T expira, resetamos C e voltamos ao estado inicial.
  • Lógica de latch para RUN:
    • O botão Start normalmente dá um pulso; queremos que o sistema continue funcionando após o release do botão. Então fazemos um latch: RUN := RUN \lor StartEm prática: um contato que sela a si mesmo. Isso significa que, uma vez iniciado, o ciclo repete automaticamente.

Passo 4

Descrever a máquina de estados (sequência) e a transição entre estados — conceito essencial para a prova e para implementar com contador e temporizador.
  • Estados (nomes e significado):
    • Estado Idle: RUN=0. Válvula fechada ( Q_{valve}=0), Q_2=0, C=0.
    • Estado Fill: RUN=1, válvula aberta ( Q_{valve}=1), contador contando pulsos enquanto C<10.
    • Estado Advance: quando C=10 passa para aqui: válvula fechada ( Q_{valve}=0), Q_2=1, timer T ligado por 3 s.
    • Retorno: após T expirar reseta C para 0 e volta a Fill (com válvula aberta) mantendo RUN=1.
  • Transições (condições):
    • Idle \xrightarrow{Start} Fill: ao pressionar Start.
    • Fill \xrightarrow{C=10} Advance: quando contador atinge 10.
    • Advance \xrightarrow{T\_done} Fill: quando os 3 segundos terminaram, reseta contador e reabre válvula.
    • Em Fill, cada borda Pulse_{edge} incrementa C (desde que C<10 e Done=0).
  • Comportamentos das saídas por estado:
    • Em Idle: Q_{valve}=0,\\ Q_2=0.
    • Em Fill: Q_{valve}=1,\\ Q_2=0.
    • Em Advance: Q_{valve}=0,\\ Q_2=1.

Passo 5

Agora mostro a lógica passo a passo, como se fosse implementada num PLC simples ou num pseudocódigo reativo. Vou exibir a lógica em bloco sequencial para você entender e poder reproduzir na prova ou em ladder.
  • Variáveis internas (resumo):
    • Pulse_{prev} (bit)
    • Pulse_{edge} (bit)
    • C (contagem, valor inteiro)
    • RUN (bit)
    • T\_en (bit para habilitar temporizador)
    • T\_done (bit temporizador expirado)
    • Q_{valve} (saída)
    • Q_2 (saída)
  • Rotina cíclica (executada repetidamente; estilo PLC scan):
    1. Detecção de borda:
    Pulse_{edge} := Pulse \land \lnot Pulse_{prev}.
    Depois atualize:
    Pulse_{prev} := Pulse.
    1. Lógica de start (latch):
    RUN := RUN \lor Start.
    (Se quiser que Start só dispare um ciclo e depois precise apertar de novo para recomeçar, usar RUN := Start em vez de latch.)
    1. Controle da válvula e contagem:
    • Se RUN=1 e T\_en=0 (ou Done=0) então válvula deve estar aberta: Q_{valve} := 1.
    • Se RUN=0 ou estiver em Advance então: Q_{valve} := 0.
    • Incremento do contador: \text{se } Pulse_{edge}=1 \land RUN=1 \land T\_en=0 \text{ então } C := C + 1.ã
    • Comparação: \text{se } C \ge 10 \text{ então } (T\_en := 1,\\ C := 10).ã(colocar C:=10 para travar o valor e evitar contagens acima).
    1. Temporizador e Q_2:
    • Habilitar temporizador quando T\_en=1.
    • Enquanto o temporizador não expirar: Q_2 := 1.
    • Quando o temporizador expirar ( T\_done=1): Q_2 := 0,\\ T\_en := 0,\\ C := 0.E então reabre-se a válvula (porque volta ao passo 3 com RUN=1 e T\_en=0).
  • Observação sobre proteção contra ruído:
    • Se o sensor Pulse for ruidoso, aplique um pequeno filtro ou debounce antes da borda (ex.: exigir que o pulso dure pelo menos t_{min} ms ou usar um filtro por tempo). Em provas, basta mencionar a necessidade de detectar borda e debouncing.

Passo 6

Mostro a mesma lógica agora em forma de pseudocódigo sequencial (mais concreto — ótimo para escrever em prova ou converter em ladder):
Inicializações (no power-up):
RUN := 0,\\ C := 0,\\ Pulse_{prev} := 0,\\ T\_en := 0,\\ Q_{valve} := 0,\\ Q_2 := 0.
Loop (cada ciclo de varredura):
\begin{aligned} & Pulse_{edge} := Pulse \land \lnot Pulse_{prev}; \\\ & Pulse_{prev} := Pulse; \\\ & RUN := RUN \lor Start; \\\ & \text{if } (RUN=1 \land T\_en=0) \text{ then } Q_{valve}:=1 \text{ else } Q_{valve}:=0; \\\ & \text{if } (Pulse_{edge}=1 \land RUN=1 \land T\_en=0) \text{ then } C:=C+1; \\\ & \text{if } C \ge 10 \text{ then } T\_en:=1;\\ \text{/* fecha válvula automaticamente no passo acima */} \\\ & \text{if } T\_en=1 \text{ then } Q_2:=1 \text{ and inicia temporizador } T(3\\ \text{s}); \\\ & \text{if } T \text{ expirou (}T\_done=1\text{) then } \{ Q_2:=0; T\_en:=0; C:=0\}; \\\ \end{aligned}á
Explicando em palavras:
  • Enquanto RUN=1 e o temporizador não estiver ativo, a válvula fica aberta e cada pulso de borda incrementa o contador.
  • Ao chegar a 10, ativa-se T ( T\_en=1), o que faz Q_2=1 e fecha Q_{valve}.
  • Depois de 3 s, T\_done reseta C e desliga Q_2, voltando a abrir válvula automaticamente.

Passo 7

Dicas práticas e cuidados que valem na prova e na implementação (essenciais para não errar):
  • Sempre conte por borda — na prova explique explicitamente a expressão de borda como mostrei ( Pulse_{edge}=Pulse \land \lnot Pulse_{prev}).
  • Trave o contador em 10 quando atingir 10 para não aumentar acima caso haja pulso após a detecção até a ação do timer.
  • Use um timer do tipo TON (on delay): ao habilitar T\_en ele começa a contar; quando completar 3 s gera T\_done.
  • Lembre-se de resetar o temporizador ao reentrar em estado de contagem (no pseudocódigo acima, T\_en controla isso).
  • Se o Start tiver que ser acionado apenas no início (um só ciclo), troque o latch RUN := RUN \lor Start por RUN := Start (ou use um botão com retenção por hardware). Em provas, explique qual comportamento você escolheu e por que.
  • Em diagramas de ladder: haverá um contato de Start que sela em paralelo consigo mesmo (seal-in) a bobina RUN; o pulso do sensor incrementa o contador CUP; a comparação C=10 aciona uma bobina que liga o temporizador e desativa a válvula.

Resposta

\begin{aligned} &\text{Ao pressionar }Start:\\ Q_{valve}=1\\ (\text{válvula abre})\\ \text{e }RUN:=1.\\[4pt] &\text{Enquanto }RUN=1\\ \text{e sem temporizador, a cada borda }Pulse_{edge}\text{ faz }C:=C+1.\\[4pt] &\text{Quando }C=10:\\ Q_{valve}:=0,\\ T\_en:=1,\\ Q_2:=1\\ (\text{inicia temporizador de }3\\ \text{s}).\\[4pt] &\text{Quando o temporizador de }3\\ \text{s} \text{ expira }(T\_done):\\ Q_2:=0,\\ T\_en:=0,\\ C:=0.\\[4pt] &\text{Ao resetar }C\text{ o ciclo volta a abrir a válvula (se }RUN=1\text{) e o processo se repete.} \end{aligned}áá]

Exercícios relacionados