Ejemplo práctico Start/Stop con auto-retención, temporizador y alarmas latched (Rockwell / CompactLogix)


Te armo un módulo completo tipo “motor/bomba estándar” con:

  • Start/Stop con auto-retención (sellado).

  • Temporizador de arranque (TON).

  • Alarma latcheada por falla (OTL/OTU).

1. Definición de señales (tags sugeridos)

Entradas físicas (DI)

  • PB_START → pulsador de marcha (NA).

  • PB_STOP → pulsador de paro (NC cableado como tal).

  • FLT_MOTOR → contacto de falla (por ejemplo del relé térmico).

  • PB_RESET → pulsador de reset de alarma (NA).

Salidas físicas (DO)

  • MTR_CMD → comando al contactor del motor.

  • PIL_ALM → piloto rojo alarma motor.

Bits internos

  • ALM_MOTOR → bit de alarma latcheada del motor.

  • MTR_RUN_OK → condición de permiso (sin falla, sin emergencia, etc., si quieres extender).

Temporizador

  • T4:0 → T_START_DELAY (TON).

2. Lógica de alarma latcheada (OTL/OTU)

Rung 1 – Disparo de alarma

La alarma se latcha cuando hay una falla real del motor.

Rung 1 – Latch de alarma motor
      FLT_MOTOR
----[ XIC ]------------------------( OTL ALM_MOTOR )

  • FLT_MOTOR = 1 cuando el relé de protección indica fallo.

  • En ese momento ALM_MOTOR queda en 1 y se mantiene aunque luego FLT_MOTOR vuelva a 0.

Rung 2 – Reset de alarma

Solo permitimos borrar la alarma si:

  • El operador pulsa PB_RESET, y

  • La condición de falla ya desapareció (FLT_MOTOR = 0).

Rung 2 – Unlatch de alarma motor
      PB_RESET       FLT_MOTOR
----[ XIC ]----------[ XIO ]----------------( OTU ALM_MOTOR )

  • XIO FLT_MOTOR: verdadero solo cuando no hay falla.

  • Así evitas que el operador “mate” la alarma mientras el fallo sigue presente.

Rung 3 – Piloto de alarma

Rung 3 – Piloto alarma
      ALM_MOTOR
----[ XIC ]------------------------( OTE PIL_ALM )

3. Start/Stop con auto-retención (sellado) + bloqueo por alarma

Vamos a hacer el clásico circuito con sello, pero bloqueado por alarma.

Rung 4 – Mandato de marcha (sin temporizador todavía)

Rung 4 – Sellado de marcha motor
      PB_STOP      PB_START      MTR_CMD      ALM_MOTOR
----[ XIC ]--------[ XIC ]--------[ XIC ]------[ XIO ]--------( OTE MTR_CMD )

Lectura:

  • PB_STOP (NC en campo) → XIC: verdadero cuando no está pulsado.

  • PB_START → XIC: verdadero mientras se pulsa.

  • MTR_CMD → XIC: contacto de sello (mantiene marcha).

  • ALM_MOTOR → XIO: si hay alarma (1), se bloquea el arranque y se apaga el motor.

Comportamiento:

  • Pulsas START sin alarma → motor arranca y se sostiene.

  • Pulsas STOP → motor se para.

  • Si aparece FLT_MOTOR, se latcha ALM_MOTOR y el XIO se vuelve falso → motor se para y no arranca hasta reset.

4. Añadir temporizador de arranque (TON)

Ahora supongamos que quieres:

cuando el operador pide marcha, el motor arranca 3 segundos después (por ejemplo para esperar una válvula, purga, etc.).

4.1. Ton de arranque

Primero generamos un bit MTR_START_REQ que indica la orden de marcha “limpia”, y con él alimentamos el TON.

Rung 5 – Petición de marcha (sin temporizador)
      PB_STOP      PB_START      MTR_START_REQ    ALM_MOTOR
----[ XIC ]--------[ XIC ]--------[ XIC ]----------[ XIO ]----( OTE MTR_START_REQ )

  • Es lo mismo que el Rung 4, pero usando MTR_START_REQ en vez de MTR_CMD.

  • Así MTR_START_REQ se mantiene mientras no haya STOP ni alarma.

4.2. Temporizador TON

Rung 6 – Temporizador de arranque
      MTR_START_REQ
----[ XIC ]------------------------[TON T4:0  PRE 3.0s  ACC 0.0s ]

  • Mientras MTR_START_REQ = 1, el TON empieza a contar.

  • Cuando llega a 3 s, T4:0/DN se pone en 1.

  • Si MTR_START_REQ se cae antes, el temporizador se resetea.

4.3. Comando final al motor

Rung 7 – Comando final al motor
      MTR_START_REQ     T4:0/DN
----[ XIC ]-------------[ XIC ]--------------------( OTE MTR_CMD )

Lógica:

  • Solo si el operador mantiene la petición (MTR_START_REQ = 1) y el tiempo se cumplió (DN = 1), se energiza MTR_CMD.

  • STOP, alarma o pérdida de petición tiran MTR_START_REQ a 0 → TON se resetea → MTR_CMD se desactiva.

Si quisieras retardo a la desconexión (post-ventilación), ahí usarías un TOF con MTR_CMD como condición, pero ya es otra variación.

5. Resumen rápido de patrones

  1. Start/Stop con auto-retención

    • Pulsador STOP (NC) en XIC.

    • Pulsador START (NA) en XIC.

    • Salida en OTE con su propio XIC en paralelo al START (sellado).

  2. Bloqueo por alarma

    • Bit de alarma (ALM_MOTOR) como XIO en serie con el circuito de marcha.

  3. Temporizador de arranque (TON)

    • Petición de marcha (MTR_START_REQ) alimenta un TON.

    • DN del TON habilita la salida final al motor.

  4. Alarmas latched

    • OTL ALM_MOTOR cuando se dispara la falla.

    • OTU ALM_MOTOR con PB_RESET y condición normal.

by IA. .