---

1. Escenario de referencia

Supongamos:

• Transmisor de nivel en tanque.

• Rango de proceso: 0–3 m de nivel.

• Señal: 4–20 mA.

• PLC: CompactLogix con módulo analógico de corriente (ej. 1769-IF4 / 5069-IF8).

• Fuente: 24 Vcc.

Objetivo:

1. Cablear el transmisor al módulo.

2. Configurar el canal como 4–20 mA.

3. Escalar la lectura a unidades de ingeniería (m o %).

4. Usar esa lectura en la lógica (alarmas, arranques, PID, HMI).

---

2. Conexión física del transmisor 4–20 mA (2 hilos)

2.1. Lazo típico de 2 hilos

FUENTE 24 Vcc
+24V  ─────────────▶ (+) TX_NIVEL   (borne + del transmisor)
0V    ─────────────▶ AI- / COM_AI   (referencia del módulo analógico)

TRANSMISOR 4–20 mA (2 hilos)
(+)  ─────────────▶ desde +24Vcc
(–)  ─────────────▶ AI_CH0+   (entrada de corriente del módulo)

MÓDULO AI
CH0+ ─────────────▶ (–) del transmisor
CH0- / RTN / COM ─▶ 0 Vcc (común de la fuente DC)

El lazo de corriente es:

+24 V → transmisor → AI_CH0+ → AI_CH0- (0 V)

Puntos clave:

• 0 V de la fuente debe ser el mismo 0 V que usa el módulo analógico (COM / RTN).

• Revisa siempre el manual del módulo: algunos piden AI– al 0 V, otros ya internamente referencian.

---

3. Configuración básica del canal analógico

En Studio 5000 / Logix:

1. Abrir propiedades del módulo AI (1769-IFx / 5069-IFx).

2. Para el canal CH0 elegir:

   • Tipo de señal: Current.

   • Rango: 4–20 mA.

   • Formato de datos:

     • Raw/Proportional Data si vas a escalar en lógica.

     • O Engineering Units si quieres que el módulo te entregue directamente el valor escalado (no todos los módulos tienen esto).

Voy a suponer el modo Raw/Proportional Data, que es el más clásico.

Valores típicos (ejemplo muy usado en Rockwell):

• 4 mA ≈ 3277

• 20 mA ≈ 16383

(Compruebas en el manual del módulo: ahí indica Raw_Min y Raw_Max para 4–20 mA).

---

4. Escalado en lógica (de cuentas crudas a metros o %)

4.1. Datos de partida

Supongamos:

• Raw_Min = 3277 (equivale a 4 mA → 0 m).

• Raw_Max = 16383 (equivale a 20 mA → 3 m).

Queremos:

• LT101_m = nivel en metros (0.00–3.00).

• LT101_pct = nivel en % (0–100).

La fórmula genérica es:

Ingeniería = (Raw – Raw_Min) × (EU_Max – EU_Min) / (Raw_Max – Raw_Min) + EU_Min

Para nuestro ejemplo, en metros:

LT101_m = (Raw – 3277) × (3.0 – 0.0) / (16383 – 3277)

En %:

LT101_pct = (Raw – 3277) × (100.0 – 0.0) / (16383 – 3277)

4.2. Implementarlo en Ladder (CPT o escalado equivalente)

Versión sencilla con CPT (Compute) en Logix:

Tag de entrada cruda del módulo:
  AI_CH0_Raw  (INT o DINT, p.ej. Local:3:I.Ch0Data)

Tags de ingeniería:
  LT101_m    (REAL)
  LT101_pct  (REAL)

Rung – Escalar a metros

CPT
Destination: LT101_m
Expression:  ((AI_CH0_Raw - 3277.0) * 3.0) / (16383.0 - 3277.0)

Rung – Escalar a %

CPT
Destination: LT101_pct
Expression:  ((AI_CH0_Raw - 3277.0) * 100.0) / (16383.0 - 3277.0)

Notas:

• Usa punto decimal en los números para que el cálculo sea en REAL (3277.0, 3.0, etc.).

• Puedes meter Raw_Min, Raw_Max, EU_Min, EU_Max como constantes en tags (configurables) en lugar de números fijos.

---

5. Uso de la lectura en la lógica

5.1. Ejemplo 1 – Alarmas de nivel alto / bajo

Supongamos:

• ALM_LL (nivel muy bajo) < 10 %.

• ALM_LH (nivel alto) > 90 %.

Rungs simples:

Rung – Alarma nivel muy bajo
      LT101_pct       10.0
----[ LES ]------------------------( OTE ALM_LL )

Rung – Alarma nivel alto
      LT101_pct       90.0
----[ GRT ]------------------------( OTE ALM_LH )

Si quieres las alarmas latched, haces lo que ya vimos:

• OTL ALM_LL_LAT cuando ALM_LL = 1.

• OTU ALM_LL_LAT con pulsador de reset y condición normal.

5.2. Ejemplo 2 – Control on/off según nivel

• Arrancar bomba cuando el nivel > 80 %.

• Parar bomba cuando baja de 30 %.

Rung – Arranque por nivel alto
      LT101_pct       80.0       P_101_RUN
----[ GRT ]-----------[ XIO ]----------------( OTE P_101_CMD )

Rung – Parada por nivel bajo
      LT101_pct       30.0
----[ LES ]------------------------( OTU P_101_CMD )   ; o lógicas equivalentes

O mejor, un solo rung con histeresis usando bits internos, pero la idea es: usas LT101_pct ya en %.

5.3. Ejemplo 3 – Usarla como PV de un PID

En un bloque PID de Logix:

• PV → LT101_pct (o en metros si quieres).

• SP → LT101_SP (tag REAL ajustable desde HMI).

• CV → LV101_OUT (salida 0–100 %, que luego escalas a 4–20 mA en un AO).

Dibujo conceptual:

LT101_m / LT101_pct  ──▶ [PID LEVEL] ──▶ LV101_OUT (0–100%)

---

6. Resumen rápido (receta)

1. Cableado

   • +24 Vdc → (+) transmisor.

   • (–) transmisor → AI_CH+.

   • AI_CH– → 0 Vdc (común).

2. Configuración del módulo

   • Canal como Current 4–20 mA.

   • Formato Raw/Proportional (si vas a escalar tú).

3. Escalado en PLC

   • Identificar Raw_Min y Raw_Max del módulo.

   • Aplicar fórmula de escala en CPT (o AOI tipo SCALE).

   • Sacar PV en unidades útiles (m, bar, %, etc.).

4. Uso en lógica

   • Comparaciones para alarmas y protecciones.

   • Condiciones de arranque/paro.

   • Entrada PV para PID.

   • Envío directo al HMI (tendencias, indicadores).

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.