A caixa fechou com cinco garrafas

O programa da bancada é curto e lê bem — cada linha pergunta direto pro sensor:

linha 1   ──┬──┤ ├ S1 ──┬──┤ ├ S0 ─────────────────( ) M0.0   em marcha
            └──┤ ├ M0.0 ┘
linha 2   ──┤ ├ M0.0 ──┤ ├ B1 ─────────────────────[TON T0 3 s]
linha 3   ──┤ ├ M0.0 ──┤ ├ B1 ──┤/├ T0 ─────────────( ) Y1   válvula
linha 4   ──┤ ├ M0.0 ──┤/├ C0 ──┬──┤/├ B1 ──┬───────( ) K1   esteira
                                └──┤ ├ T0 ──┘
linha 5   ──┤ ├ B1 ──────────────────────────────[CTU C0 6]
linha 6   ──┤ ├ S2 ──────────────────────────────( R ) C0
linha 7   ──┤ ├ C0 ──────────────────────────────( ) H1   caixa cheia

Na bancada, com o B1 numa chave, funciona perfeito: seis garrafas, caixa cheia, troca, recomeça. Na linha, a garrafa chega com um tranco, balança embaixo do bico e, por um instante, sai da frente do sensor.

O programa trata o B1 como se ele dissesse “tem garrafa”. O que ele diz é “tem alguma coisa na frente agora, nesta varredura”. Um balanço de um décimo de segundo são duas varreduras de B1 = 0 — e cada linha que pergunta pro B1 reage:

B1 cai por um instante, no meio do enchimento
  linha 2   o TON perde a entrada  →  o tempo volta a zero
  linha 3   a válvula fecha
  linha 4   ┤/├ B1 fecha  →  a esteira dá um tranco

B1 volta
  linha 2   o TON começa de novo  →  mais 3 s  →  a garrafa transborda
  linha 5   uma subida nova do B1  →  C0 conta a mesma garrafa duas vezes

São as duas aulas 03 juntas: o TON que zera quando a entrada abre, e o contador que soma cada subida. Nenhum dos dois está com defeito. A máquina é que ficou dependendo de um sinal que ninguém garantiu que é limpo.

O sensor decide quando começa. Depois disso, quem manda no ciclo é uma memória — ela não pisca:

linha 1   em marcha, com selo                                  ( ) M0.0
linha 2   ──┤ ├ M0.0 ──┤ ├ B1 ──┤/├ M0.2 ──┤/├ C0 ────────────( S ) M0.1  enchendo
linha 3   ──┤ ├ M0.1 ──────────────────────────────────────[TON T0 3 s]
linha 4   ──┤ ├ T0 ─────────────────────────────────┬───────( S ) M0.2  essa já encheu
                                                    └───────( R ) M0.1
linha 5   ──┤ ├ K1 ──┤/├ B1 ───────────────────────────────( R ) M0.2  a esteira levou
linha 6   ──┤ ├ T0 ────────────────────────────────────────[CTU C0 6]  conta a cheia
linha 7   ──┤ ├ S2 ────────────────────────────────────────( R ) C0
linha 8   ──┤ ├ M0.0 ──┤/├ M0.1 ──┤/├ C0 ──┬──┤/├ B1 ───┬───( ) K1   esteira
                                           └──┤ ├ M0.2 ─┘
linha 9   ──┤ ├ M0.1 ──┤ ├ M0.0 ───────────────────────────( ) Y1   válvula
linha 10  ──┤ ├ C0 ────────────────────────────────────────( ) H1

• M0.1 enchendoliga com a garrafa, e só desliga quando o tempo acaba. O TON olha pra memória, não pro sensor: o balanço não zera nada.
• M0.2 essa já encheuimpede de encher a mesma garrafa de novo enquanto ela ainda está na frente do sensor. Só solta quando a esteira está andando e o B1 some — um balanço com a esteira parada não conta.
• o contador conta o fima subida do T0 acontece uma vez por garrafa cheia, não importa quantas vezes o B1 pisque.

O jeito geral de pensar: o sensor dispara o passo, a memória sustenta o passo. É a mesma sequência de etapas da aula 06, desenhada em Ladder.

Toque em S1. Ligue o B1 (garrafa chegou) e, no meio do enchimento, desligue e ligue de novo — é o balanço. No ①, olhe o TON voltar a zero e o C0 contar dois. No ②, o enchimento segue, e o C0 só conta quando o T0 fecha. Desligue o B1 com a esteira andando pra mandar a garrafa embora.

Sem CLP físico, dá pra rodar o mesmo Ladder num ESP32. O OpenPLC Editor, gratuito e de código aberto, escreve o programa nas linguagens da IEC 61131-3 e manda pra placa pela USB. O programa sobe, o LED de teste acende. Aí vem o sensor da envasadora: PNP de 24 V, fio preto direto no pino de entrada. A placa não liga mais.

O pino do ESP32 trabalha em 3,3 V e não aguenta mais que isso. O borne de um CLP é outra coisa: atrás dele tem acoplador óptico, resistor, filtro e proteção — é por isso que a aula 01 podia ligar 24 V direto nele. O pino do microcontrolador vai direto no chip. Os mesmos 24 V que acendem o bit do CLP entram no ESP32 com mais de sete vezes a tensão dele.

E na saída, o contrário: o pino entrega pouca corrente, em 3,3 V. Não puxa bobina de contator de 24 V, muito menos de 220 V.

• na entradaum módulo de entrada isolado, de 24 V pra 3,3 V, com acoplador óptico: o sensor acende o LED de um lado, o ESP32 lê o receptor do outro. É o que o CLP já tem por dentro.
• na saídaum transistor comandando um relé de interface, com o diodo na bobina — o mesmo relé de interface da aula 01. O contato do relé é que comanda o contator.
• os endereçosno OpenPLC, cada variável do programa ganha uma localização da norma: %IX0.0 é a entrada 0, %QX0.0 a saída 0, %IW0 uma entrada analógica. Qual pino da placa é cada endereço, o editor mostra quando você escolhe a placa — confira ali, não num desenho da internet.

variável   localização   no painel desta aula
S0         %IX0.0        I0.0   parar
S1         %IX0.1        I0.1   partir
B1         %IX0.2        I0.2   garrafa
S2         %IX0.3        I0.3   caixa trocada
K1         %QX0.0        Q0.0   esteira
Y1         %QX0.1        Q0.1   válvula
H1         %QX0.2        Q0.2   caixa cheia

O roteiro que eu vou seguir quando montar — ainda não montei:

1. instalar o OpenPLC Editor e criar um projeto com um programa em Ladder;
2. copiar o programa ② desta aula, com as localizações da tabela;
3. escolher a placa ESP32 e anotar qual pino o editor dá pra cada endereço;
4. mandar pela USB e testar só com botões de 3,3 V e LEDs, sem nada de 24 V;
5. só então pôr os módulos de entrada isolados e os relés de interface.

Escolha o que vai entre o sensor e o ESP32, e entre o ESP32 e o contator: