CONTENIDOS
Materiales Eléctricos Industriales | Stock 4.0
PROGRAMACION LENGUAJES
LENGUAJES DE PROGRAMACION MAS USADOS, EJEMPLOS.
En la práctica, el Diagrama de Escalera (LD)
sigue siendo el más predominante, especialmente en América del Norte y para
aplicaciones de control discreto. Sin embargo, el Texto Estructurado (ST)
y el Diagrama de Bloques de Función (FBD) están ganando
terreno, especialmente en Europa y para aplicaciones más complejas, control de
movimiento o integración de datos. El Gráfico de Funciones
Secuenciales (SFC) se utiliza como una capa organizativa para
secuencias complejas, con las acciones internas programadas en cualquiera de
los otros lenguajes.
Los entornos de programación modernos (como TIA
Portal de Siemens o Studio 5000 de Rockwell) a menudo permiten la programación multilingüe, lo que significa que puedes usar
una combinación de estos lenguajes dentro del mismo proyecto, eligiendo el más
adecuado para cada parte de la lógica del control.
¿Hay algún lenguaje en particular que te gustaría
que detallara aún más o que te pusiera un ejemplo de su aplicación?
Ejemplo de Diagrama de Escalera (Ladder Diagram - LD / LAD)
El Diagrama de Escalera es el lenguaje más visual y
uno de los más fundamentales en la programación de PLCs. Para entenderlo bien,
lo mejor es ver algunos ejemplos de cómo se representa la lógica.
Conceptos Básicos del Diagrama de Escalera (LD/LAD)
Imagina un Diagrama de Escalera como un circuito
eléctrico. Tiene dos "rieles" verticales: el riel izquierdo es la
fuente de energía (L1 o línea positiva) y el riel derecho es el retorno o
neutro (L2 o línea negativa). Los "peldaños" horizontales entre estos
rieles contienen la lógica de control.
Los elementos principales son:
- Contactos (Entradas):
- Normalmente Abierto (NO): Se
cierra y permite que la energía fluya cuando la condición asociada es
VERDADERA (ej., un botón es presionado, un sensor detecta algo). Se
representa como --| |--.
- Normalmente Cerrado (NC): Se
abre y detiene el flujo de energía cuando la condición asociada es
VERDADERA (ej., un botón es presionado, un sensor detecta algo). Se
representa como --|/|--.
- Bobinas (Salidas):
- Representan
una salida que se activa (se energiza) cuando hay un flujo de energía
hasta ella. Se representa como --( )--.
- Temporizadores y Contadores:
Bloques especiales que se insertan en los peldaños para funciones de
tiempo o conteo.
Ejemplos de Lógica en Diagrama de Escalera
Ejemplo 1: Arranque y Parada Simple de un Motor
(Lógica de Auto-Retención)
Este es el circuito de control más básico para un
motor, donde un botón de arranque lo enciende y un botón de parada lo apaga.
Riel Izquierdo
Riel Derecho
|
|
|
|
|---[
Stop_PB]----[ Start_PB]------[ Motor_Run]------------------(Motor_Contactor)
---
| NC NO NO |
|
|
|---------------------[ Motor_Run
]--------------------------------------|
| NO
|
Explicación:
- Peldaño 1:
- Stop_PB: Es un contacto Normalmente Cerrado. Siempre que no se presione el
botón de parada, permite el flujo de energía.
- Start_PB: Es un contacto Normalmente Abierto. Cuando se presiona el botón de
arranque, se cierra y permite el flujo de energía.
- Motor_Run: Es un contacto Normalmente Abierto (asociado a la bobina Motor_Run).
- Motor_Contactor: Es la bobina de salida que activaría el contactor real del
motor.
- Lógica:
- Cuando
se presiona Start_PB, la energía fluye a través de Stop_PB (que está cerrado) y Start_PB (que
ahora está cerrado), energizando la bobina Motor_Contactor.
- Al
mismo tiempo, la bobina Motor_Contactor energiza el contacto Motor_Run en
el peldaño inferior.
- Este
contacto Motor_Run (en paralelo con Start_PB) crea una autorretención. Incluso si se suelta Start_PB, la
energía sigue fluyendo a través de Motor_Run y Stop_PB,
manteniendo el motor encendido.
- Para
apagar el motor, se presiona Stop_PB. Al ser Normalmente
Cerrado, se abrirá, interrumpiendo el flujo de energía y des energizando Motor_Contactor, lo
que a su vez abre el contacto Motor_Run y detiene el motor.
Ejemplo 2: Luz Indicadora con Temporizador
Queremos que una luz se encienda 5 segundos después
de que se active un sensor de presencia.
Riel Izquierdo
Riel Derecho
|
|
|
|
|---[
Sensor Presencia ]-----------------------------------------------( TON_0 )---
| NO
|
|
|
|
|
|---[
TON_0.Q ]--------------------------------------------------------( Luz
Indicadora )---
| NO
|
Explicación:
- Peldaño 1:
- Sensor Presencia: Un contacto
Normalmente Abierto. Cuando el sensor detecta algo, este contacto se
cierra.
- TON_0: Es un Temporizador con Retardo a la Conexión (Timer On Delay).
- IN (Entrada): Recibe la
energía del Sensor Presencia.
- PT (Preset Time): Aquí se
configura el tiempo de retardo (ej., 5 segundos).
- Q (Output): Un bit de
salida que se activa (VERDADERO) después de
que el tiempo PT ha transcurrido, siempre y cuando la entrada IN
siga activada.
- Peldaño 2:
- TON_0. Q: Un contacto Normalmente
Abierto asociado a la salida del temporizador.
- Luz Indicadora: La bobina de salida
que enciende la luz.
- Lógica:
- Cuando
Sensor Presencia detecta algo, el temporizador TON_0 comienza a contar.
- Después
de 5 segundos, si el sensor sigue activo, TON_0. Q se activa.
- Cuando
TON_0. Q se activa, permite el flujo de energía a Luz Indicadora,
encendiéndola.
- Si el sensor de presencia se desactiva antes de que pasen los 5
segundos, el temporizador se reinicia y la luz no se enciende.
Ejemplo 3: Lógica AND y OR
- Lógica AND (Y): Una salida se activa
solo si TODAS las entradas son verdaderas.
·
Riel Izquierdo
Riel Derecho
·
|
|
·
|---[
Sensor_1]----[ Sensor_2]-------------------------(Motor_AND)---
·
|
NO NO |
·
|
|
Explicación: Motor_AND se activa solo si Sensor_1 Y Sensor_2 están activos.
- Lógica OR (O): Una salida se activa
si CUALQUIERA de las entradas es verdadera.
·
Riel Izquierdo
Riel Derecho
·
|
|
·
|---[
Pulsador_A ]------------------------------------------|
·
|
NO
|
·
|
+---------------------------------------------( Bomba_OR )---
·
|---[
Pulsador_B ]------------------------------------------|
·
|
NO
|
Explicación: Bomba_OR se activa si Pulsador_A o Pulsador_B está activo (los contactos están en paralelo).
Ejemplo 4: Contador
Contar cajas en una cinta transportadora y detener
la cinta después de 10 cajas.
Riel Izquierdo
Riel Derecho
|
|
|
|
|---[
Sensor Cajas]---------------------------------------------------(CONT_0) ---
| NO
|
| (CU: Contar hacia arriba, Reset:
Reinicio, PV: Valor preestablecido)
|
|
|---[
Stop_Reset ]-------------------------------------------------------|
| NO
|
|
|
|---[
CONT_0. Q]-------------------------------------------------------(Cinta Motor)
---
| NC
|
Explicación:
- Peldaño 1:
- Sensor Cajas: Un contacto Normalmente
Abierto. Cada vez que el sensor detecta una caja, este contacto se cierra
un instante, enviando un pulso al contador.
- CONT_0: Es un Contador Ascendente (CTU).
- CU (Count Up): Entrada para
contar pulsos.
- PV (Preset Value): Valor al
que queremos contar (ej., 10).
- Reset: Entrada para reiniciar
el contador a 0.
- Q (Output): Se activa
(VERDADERO) cuando el contador alcanza o supera el PV.
- Peldaño 2:
- Stop_Reset: Un botón para reiniciar
el contador a cero.
- Peldaño 3:
- CONT_0. Q: Un contacto Normalmente Cerrado asociado a la salida del
contador.
- Cinta Motor: La bobina de salida que
controla el motor de la cinta transportadora.
- Lógica:
- Cada
vez que Sensor Cajas detecta una caja, CONT_0 incrementa su conteo.
- Cuando
el conteo de CONT_0 llega a 10 (su PV), CONT_0.Q se
activa.
- Como
el contacto CONT_0.Q en el peldaño 3 es Normalmente Cerrado, al activarse se abre, interrumpiendo el flujo de energía a Cinta Motor y
deteniendo la cinta.
- Para
reiniciar el sistema, se presiona Stop_Reset, lo que reinicia el
contador.
Estos ejemplos ilustran cómo el Diagrama de
Escalera utiliza un enfoque visual, similar a un circuito eléctrico, para
representar la lógica de control. Es su simplicidad y familiaridad para el
personal técnico lo que lo mantiene como uno de los lenguajes más populares en
la automatización industrial.
EJEMPLOS DE FUNCION FBD
Diagrama de Bloques de Función (FBD) es otro de los lenguajes fundamentales en la
programación de PLC según la norma IEC 61131-3. A diferencia del Ladder, FBD se
enfoca en el flujo de datos y funciones entre bloques predefinidos, lo
que lo hace muy intuitivo para el control de procesos y algoritmos.
Conceptos Básicos del Diagrama de Bloques de
Función (FBD)
En FBD, la lógica se construye conectando
"bloques" gráficos, donde cada bloque representa una función
específica (lógica booleana, temporizadores, contadores, operaciones
matemáticas, etc.). Las líneas conectan las salidas de un bloque a las entradas
de otro, indicando cómo los datos y las señales fluyen a través del programa.
Los elementos principales son:
- Bloques de Función: Cajas
rectangulares con entradas a la izquierda y salidas a la derecha. El
nombre de la función suele estar dentro del bloque (ej., AND, ADD, TON).
- Entradas: Puntos en el lado izquierdo del bloque
que reciben valores o estados de otras partes del programa o de las
entradas físicas del PLC.
- Salidas: Puntos en el lado derecho del bloque que
envían los resultados de la función a otras partes del programa o a las
salidas físicas del PLC.
- Líneas de Conexión: Unen
las salidas de un bloque/variable con las entradas de otro
bloque/variable, mostrando el flujo de datos.
- Variables: Pueden aparecer como
entradas o salidas sueltas, o como los nombres de las señales que conectan
los bloques.
Ejemplos de Lógica en Diagrama de Bloques de
Función
Ejemplo 1: Lógica AND Simple
Queremos que un motor se encienda solo si se
cumplen dos condiciones (ambos sensores activos).
+----------+
---|> Sensor_1 |
+----------+
\ +-----+
+--->| AND |---> Motor_ON
/ +-----+
+----------+
---|> Sensor_2 |
+----------+
Explicación:
- Tenemos
dos entradas: Sensor_1 y Sensor_2.
- Un bloque AND toma estas dos entradas.
- La
salida del bloque AND se conecta a la variable Motor_ON.
- Lógica: Motor_ON será VERDADERO solo si Sensor_1 es
VERDADERO Y Sensor_2 es
VERDADERO. Si uno o ambos son FALSOS, Motor_ON será FALSO.
Ejemplo 2: Lógica OR Simple
Queremos que una luz de alarma se active si se
detecta cualquier falla (temperatura alta O presión baja).
+----------+
---|> Temp_Alta |
+----------+
\ +----+
+--->| OR |---> Alarma Activa
/ +----+
+----------+
---|> Pres_Baja |
+----------+
Explicación:
- Dos
entradas: Temp_Alta y Pres_Baja.
- Un bloque OR toma estas dos entradas.
- La
salida del bloque OR se conecta a la variable Alarma Activa.
- Lógica: Alarma Activa será VERDADERO si Temp_Alta es
VERDADERO O Pres_Baja es
VERDADERO (o ambos). Solo será FALSO si ambos son FALSOS.
Ejemplo 3: Temporizador con Retardo a la Conexión
(TON)
Queremos que una bomba se encienda 10 segundos
después de que se presione un botón de arranque, y se apague cuando se suelte.
+-----------+
---|> Start_PB |
+-----------+
\ +----------+
+--->| TON |
| IN = ... |
| PT = T#10s |
| Q |---> Bomba_ON
+----------+
Explicación:
- Start_PB: La entrada que activa el temporizador.
- TON: Es el bloque de función para un
Temporizador con Retardo a la Conexión.
- IN (Input): La entrada que
activa el temporizador. Aquí se conecta Start_PB.
- PT (Preset Time): El tiempo
de retardo que queremos (ej., T#10s para 10 segundos).
- Q (Output): La salida del
temporizador, que se vuelve VERDADERA después de que
el PT ha transcurrido, siempre y cuando IN siga VERDADERO.
- Bomba_ON: La salida que controla la bomba.
- Lógica: Cuando Start_PB se vuelve VERDADERO, el temporizador TON
empieza a contar. Después de 10 segundos, si Start_PB sigue
VERDADERO, la salida Q del TON se activa, encendiendo Bomba_ON. Si Start_PB se
desactiva antes de los 10 segundos, el temporizador se reinicia.
Ejemplo 4: Control de Nivel con un Comparador
Analógico
Queremos que una válvula de llenado se cierre
cuando el nivel de un tanque supere un umbral de 80 unidades, usando un sensor
de nivel analógico.
+-----------+
---|> Sensor Nivel |
+-----------+
\
+--->| |
| GREATER |--->
Cierra_Valvula
+--->| |
/ | |
+-----+ | (Valor Fijo: 80)
---|> 80 |--------+-----------+
+-----+
Explicación:
- Sensor Nivel: Una entrada analógica (por ejemplo,
0-10V o 4-20mA) que representa el nivel del tanque.
- GREATER: Es un bloque de función de
comparación (mayor que).
- Tiene
dos entradas: la primera para el valor actual (Sensor Nivel) y
la segunda para el valor de comparación (aquí, un valor fijo de 80).
- Su salida es VERDADERA si la primera entrada es mayor que la
segunda.
- Cierra_Valvula: La salida digital que
activa la válvula para que se cierre.
- Lógica: Cuando el valor de Sensor Nivel se
vuelve mayor que 80, la salida del bloque GREATER se activa, lo que a su vez activa Cierra_Valvula.
Ejemplo 5: Suma de Valores Analógicos
Sumar las lecturas de dos sensores de flujo y
mostrar el flujo total.
+------------+
---|> Flujo_Sensor1 |
+------------+
\ +-----+
+--->| ADD |---> Flujo Total
/ +-----+
+------------+
---|> Flujo_Sensor2 |
+------------+
Explicación:
- Flujo_Sensor1, Flujo_Sensor2: Entradas analógicas que representan los
valores de flujo.
- ADD: Es un bloque de función de suma.
- Tiene múltiples entradas numéricas.
- Su salida es la suma de todas sus entradas.
- Flujo Total: Una variable analógica o registro que
almacena el resultado de la suma.
- Lógica: El bloque ADD suma los valores de Flujo_Sensor1 y Flujo_Sensor2, y el
resultado se asigna a Flujo Total.
Estos ejemplos demuestran cómo el FBD permite
construir la lógica de control de una manera muy visual, enfocándose en cómo
los datos fluyen a través de las diferentes funciones. Su modularidad y
claridad lo hacen particularmente útil para el control de procesos y
aplicaciones donde la interconexión de funciones es clave.
Ejemplos de Texto Estructurado (Structured Text - ST)
El Texto Estructurado (ST)
es un lenguaje de programación de PLC que se asemeja mucho a lenguajes de
programación de alto nivel como Pascal o C. Es muy potente para lógica
compleja, cálculos matemáticos y manipulación de datos.
Conceptos Básicos del Texto Estructurado (ST)
En ST, el programa se escribe como una serie de
sentencias, utilizando operadores, funciones y estructuras de control. Cada
sentencia generalmente termina con un punto y coma (;).
Los elementos clave incluyen:
- Variables: Nombres para almacenar
datos (ej., Temperatura Actual, Conteo Cajas).
- Tipos de Datos: Definen el tipo de
información que una variable puede almacenar (ej., BOOL para
verdadero/falso, INT para enteros, REAL para números con decimales, TIME para
duraciones).
- Operadores:
- Aritméticos: +, -, *, /
- Comparación: =, <>, <, >, <=, >=
- Lógicos: AND, OR, NOT, XOR
- Estructuras de Control:
- Condicionales: IF...THEN...ELSIF...ELSE...END_IF;
- Selección: CASE...OF...ELSE...END_CASE;
- Bucles (Loops): FOR...DO...END_FOR;, WHILE...DO...END_WHILE;, REPEAT...UNTIL...END_REPEAT;
- Funciones y Bloques de Función:
Llamadas a funciones predefinidas (ej., SQRT para raíz cuadrada) o bloques de función
(ej., TON para temporizador).
Ejemplos de Lógica en Texto Estructurado
Ejemplo 1: Arranque y Parada de un Motor con
Auto-Retención
Este es el equivalente al ejemplo de Ladder que
vimos, pero en ST.
(* Declaración de variables (generalmente en una
tabla de variables global o local) *)
VAR
Start_PB : BOOL; (* Pulsador
de arranque *)
Stop_PB : BOOL; (* Pulsador
de parada *)
Motor_Contactor: BOOL; (* Salida para el contactor del motor *)
END_VAR
(* Lógica de programa *)
IF (Start_PB AND NOT Motor_Contactor AND NOT
Stop_PB) THEN
Motor_Contactor:
= TRUE; (* Si se presiona Start y el motor no está encendido y no se presiona
Stop, encenderlo *)
ELSIF (Stop_PB) THEN
Motor_Contactor: = FALSE; (* Si se presiona Stop, apagar el motor *)
END_IF;
Explicación:
- Las
primeras líneas con VAR y END_VAR son para la declaración de variables, donde se
define el nombre y tipo de dato de cada señal.
- El
bloque IF evalúa la condición para encender el motor: Start_PB debe
ser TRUE (presionado) Y Motor_Contactor debe ser FALSE
(motor no encendido aún) Y Stop_PB debe
ser FALSE (botón de parada no presionado). Si todo es TRUE, Motor_Contactor se
establece en TRUE.
- El
bloque ELSIF (else if) evalúa la condición para apagar el motor: Si Stop_PB es TRUE
(presionado), entonces Motor_Contactor se establece en FALSE.
Ejemplo 2: Luz Indicadora con Temporizador (TON -
Timer On Delay)
Utilizamos el bloque de función TON para
encender una luz después de un retardo de 5 segundos.
(* Declaración de variables *)
VAR
Sensor
Presencia: BOOL; (* Entrada de sensor *)
Luz
Indicadora: BOOL; (* Salida de luz *)
Mi
Temporizador : TON; (* Instancia del bloque de función TON *)
END_VAR
(* Lógica de programa *)
MiTemporizador (IN:= Sensor Presencia, PT:= T#5s);
(* Llamada al temporizador *)
Luz Indicadora:= Mi Temporizador.Q; (* La luz se
enciende cuando la salida del temporizador está activa *)
Explicación:
- MiTemporizador : TON;
declara una instancia de un temporizador llamado MiTemporizador.
- MiTemporizador (IN:= Sensor Presencia, PT := T#5s); es la llamada al bloque de función TON.
- IN := Sensor_Presencia:
Conecta la entrada IN del temporizador a la variable Sensor_Presencia.
- PT := T#5s: Establece el tiempo de
retardo (Preset Time) en 5 segundos. El formato T#5s es
el estándar para tiempo.
- Luz Indicadora:= MiTemporizador.Q;: La
variable Luz Indicadora tomará el valor de la salida Q del temporizador. Q es TRUE
cuando el tiempo ha transcurrido y la entrada IN sigue
activa.
Ejemplo 3: Lógica AND y OR
(* Declaración de variables *)
VAR
Sensor_1 : BOOL;
Sensor_2 : BOOL;
Pulsador_A : BOOL;
Pulsador_B : BOOL;
Motor_AND : BOOL;
Bomba_OR : BOOL;
END_VAR
(* Lógica AND *)
Motor_AND := Sensor_1 AND Sensor_2;
(* Lógica OR *)
Bomba_OR := Pulsador_A OR Pulsador_B;
Explicación:
- Las
operaciones lógicas (AND, OR) se escriben directamente.
- La
sentencia := es el operador de asignación. Motor_AND será TRUE si Sensor_1 y Sensor_2 son TRUE.
- Bomba_OR será TRUE si Pulsador_A o Pulsador_B (o
ambos) son TRUE.
Ejemplo 4: Contador Ascendente (CTU) y Condición de
Parada
Contar cajas y detener la cinta después de 10.
(* Declaración de variables *)
VAR
Sensor
Cajas : BOOL;
Stop_Reset : BOOL;
Cinta
Motor : BOOL;
Contador
Cajas : CTU; (* Instancia del contador
*)
END_VAR
(* Lógica de programa *)
Contador Cajas (CU := Sensor_Cajas, RESET :=
Stop_Reset, PV := 10); (* Llamada al contador *)
IF Contador Cajas.Q THEN (* Si el contador alcanzó
su valor preestablecido *)
Cinta
Motor := FALSE; (* Apagar la cinta *)
ELSE
Cinta
Motor := TRUE; (* Si no, mantener la cinta encendida (asumiendo que se enciende
por otra lógica inicial) *)
END_IF;
Explicación:
- Contador Cajas: CTU;
declara una instancia de un contador ascendente.
- Contador Cajas (CU := Sensor_Cajas, RESET := Stop_Reset, PV := 10); es la llamada al bloque de función CTU.
- CU: Conectado a Sensor_Cajas para
contar cada flanco.
- RESET: Conectado a Stop_Reset para
reiniciar el contador.
- PV: El valor preestablecido
es 10.
- IF ContadorCajas.Q THEN ... END_IF;: La
salida Q del contador se activa cuando el contador llega a PV. En
ese momento, Cinta_Motor se establece en FALSE. De lo contrario (ELSE), se
mantiene en TRUE.
Ejemplo 5: Cálculo y Escalamiento Analógico (usando
un IF y operaciones matemáticas)
Convertir una lectura de temperatura de un sensor
(0-4095) a grados Celsius (0-100).
(* Declaración de variables *)
VAR
SensorRawTemp : INT; (* Lectura del sensor, ej. 0 a 4095 *)
TemperaturaC: REAL; (* Temperatura en grados Celsius, ej. 0.0 a 100.0 *)
END_VAR
(* Lógica de programa *)
IF SensorRawTemp >= 0 AND SensorRawTemp <=
4095 THEN
(*
Escalamiento lineal: (Valor Sensor - Min_Sensor) * (Max Real - Min_Real) / (Max
Sensor - Min_Sensor) + Min_Real *)
TemperaturaC := (INT_TO_REAL(SensorRawTemp) - 0.0) * (100.0 - 0.0) /
(4095.0 - 0.0) + 0.0;
ELSE
(* Manejo
de error si la lectura está fuera de rango *)
TemperaturaC := -999.9; (* Asignar un valor de error o alarma *)
END_IF;
Explicación:
- SensorRawTemp: La lectura cruda de un módulo de
entrada analógica (típicamente un entero).
- TemperaturaC: La variable donde se guardará la
temperatura ya escalada, como un número real (con decimales).
- El
bloque IF verifica si la lectura del sensor está dentro de un rango válido.
- INT_TO_REAL(SensorRawTemp): Es
una función de conversión de tipo de dato. Es crucial convertir el entero
a un real antes de realizar divisiones o multiplicaciones que resulten en
decimales para asegurar precisión.
- La
fórmula realiza un escalamiento lineal.
- El
bloque ELSE es una buena práctica para manejar valores fuera de rango.
Como puedes ver, el Texto Estructurado es muy
poderoso para lógica compleja, cálculos matemáticos y cuando necesitas la
flexibilidad de un lenguaje de programación tradicional. Su sintaxis es clara y
estructurada, lo que facilita la escritura de algoritmos avanzados.
Ejemplos de Gráfico de Funciones Secuenciales (Sequential
Function Chart - SFC)
El Gráfico de Funciones
Secuenciales (SFC) es un lenguaje gráfico que, si bien no ejecuta la
lógica de control directamente como el Ladder o el Texto Estructurado, es
excepcional para estructurar y visualizar el comportamiento secuencial de un
proceso. Piensa en SFC como un flujograma o un diagrama de estados que
coordina la ejecución de diferentes partes de tu programa PLC.
Conceptos Básicos del Gráfico de Funciones
Secuenciales (SFC)
SFC se construye alrededor de tres elementos
principales:
- Pasos (Steps):
- Representan
un estado o una etapa específica del proceso. Cuando un paso está activo,
se ejecutan las acciones asociadas a ese
paso.
- Gráficamente
se representa como un rectángulo.
- Transiciones (Transitions):
- Representan las condiciones que deben cumplirse para pasar de un
paso a otro. Una transición "dispara" o "habilita" el
siguiente paso cuando su condición es verdadera.
- Gráficamente
se representa como una línea horizontal con un
pequeño cuadro o marca. La condición de la transición se
escribe junto a ella.
- Acciones:
- Son
la lógica de control real que se ejecuta cuando un paso está activo. Las
acciones se programan utilizando otros lenguajes IEC 61131-3, como Ladder (LD), Bloques de Función (FBD) o Texto Estructurado
(ST).
- Se asocian a un paso y se ejecutan mientras el paso está activo.
Estructuras SFC Básicas:
- Secuencia Simple: Un
paso tras otro.
·
---
·
| Inicio |
·
---
·
|
·
---( Condición_1 )---
·
|
·
---
·
| Paso_1 |
·
---
·
|
·
---( Condición_2 )---
·
|
·
---
·
| Paso_2 |
·
---
- Divergencia (Selección Alternativa): El programa toma una de varias ramas posibles según qué condición
de transición se cumpla primero. Se representa con una línea horizontal
doble.
·
---
·
| Paso_A |
·
---
·
|
·
-------
·
| |
·
---( Condición_1 )--- ---( Condición_2 )---
·
| |
·
--- ---
·
| Paso_B | | Paso_C |
·
--- ---
- Divergencia (Ejecución Paralela): El
programa ejecuta varias ramas simultáneamente una vez que la transición se
cumple. También se representa con una línea horizontal doble.
·
---
·
| Paso_A |
·
---
·
|
·
=======
·
| |
·
---( Condición_1 )---
·
|
·
---
·
| Paso_B |
·
---
·
|
·
|
·
|
·
-----------------------------> Rama
Paralela 1
·
|
·
|
·
---( Condición_1 )---
·
|
·
---
·
| Paso_C |
·
---
·
|
·
|
·
|
·
-----------------------------> Rama
Paralela 2
(Nota:
La "entrada" a las ramas paralelas es la misma condición)
- Convergencia: Varias ramas paralelas
o alternativas se unen de nuevo en un solo flujo. Se representa con una
línea horizontal doble (para unir paralelas) o simple (para unir
alternativas).
Ejemplos de Lógica en Gráfico de Funciones
Secuenciales
Aquí tienes algunos ejemplos que ilustran cómo SFC
se utiliza para gestionar secuencias.
Ejemplo 1: Proceso de Llenado y Mezclado Simple
Imagina un tanque que debe llenarse con líquido,
luego mezclarse por un tiempo y finalmente vaciarse.
---
| Inicio |
(* Paso inicial - siempre activo al inicio *)
---
|
--( Start_Button )--- (* Transición: Presionar
botón de arranque *)
|
---
| Llenar Tanque | (* Acciones: Activar válvula de
llenado *)
---
|
--(Nivel Alto) --- (* Transición: Sensor de nivel
alto detectado *)
|
---
| Mezclar |
(* Acciones: Activar mezclador, temporizador de mezcla *)
---
|
--(Mezcla Completa) --- (* Transición: Temporizador
de mezcla ha terminado *)
|
---
| Vaciar Tanque | (* Acciones: Activar válvula de
vaciado *)
---
|
--(Nivel Bajo) --- (* Transición: Sensor de nivel
bajo detectado *)
|
---
| Parado |
(* Acciones: Desactivar todo *)
---
|
--( Reset_Button )--- (* Transición: Presionar
botón de reinicio o ciclo completo *)
|
---
(Bucle de vuelta a Inicio)
Explicación:
- Inicio: El paso inicial del proceso.
- Start_Button: Cuando el operario presiona el botón de
arranque, el proceso avanza al paso LlenarTanque.
- LlenarTanque: Mientras este paso está activo, se
ejecutan las acciones de "Activar válvula de llenado".
- Nivel Alto: Cuando el sensor de nivel alto detecta
el líquido, la transición se cumple y el proceso pasa al paso Mezclar.
- Mezclar: Las acciones aquí incluyen "Activar
mezclador" y "Iniciar temporizador de mezcla".
- Mezcla Completa: Una vez que el temporizador de mezcla
termina, la transición se cumple y el proceso avprevancesa al paso Vaciar Tanque.
- Vaciar Tanque: Las acciones aquí incluyen "Activar
válvula de vaciado".
- Nivel Bajo: Cuando el sensor de nivel bajo detecta
que el tanque está vacío, la transición se cumple y el proceso va al paso Parado.
- Parado: Todas las acciones se desactivan. El
proceso espera por una Reset_Button para volver al paso Inicio y
comenzar un nuevo ciclo.
Ejemplo 2: Proceso con Selección Alternativa
(Divergencia)
Imagina un sistema de clasificación que envía un
producto a una de dos bandas transportadoras dependiendo de su tamaño.
---
| Espera Producto |
---
|
--(Producto Detectado) ---
|
======= (* Línea de divergencia para selección
alternativa *)
| |
---(Tamaño Grande) --- (* Transición: Si el
producto es grande *)
|
---
| Enviar Grande | (* Acciones: Activar
transportador grande *)
---
|
--(Transportador Grande Libre) --- (* Transición:
La salida del grande está libre *)
|
---
| Fin Proceso |
---
|
---(Tamaño Pequeño) --- (* Transición: Si el
producto es pequeño *)
|
---
| Enviar Pequeño | (* Acciones: Activar
transportador pequeño *)
---
|
--(Transportador Pequeño Libre) --- (* Transición:
La salida del pequeño está libre *)
|
---
| Fin Proceso |
---
======= (* Línea de convergencia *)
|
--( Reset_Condicion )---
|
(Bucle de vuelta a Espera Producto)
Explicación:
- Espera Producto: El sistema está esperando un nuevo
producto.
- Producto Detectado: Cuando un sensor detecta un producto, el
proceso avanza a la divergencia.
- Divergencia de Selección:
- Si la
condición Tamaño Grande se cumple (ej., el sensor de tamaño indica grande), la rama Enviar Grande se
activa.
- Si la
condición Tamaño Pequeño se cumple (ej., el sensor de tamaño indica pequeño), la rama Enviar Pequeño se
activa. Solo una de las ramas se activará.
- Enviar Grande / Enviar Pequeño: En estos pasos, se activan los
transportadores correspondientes.
- TransportadorGrande_Libre / TransportadorPequeno_Libre: Una vez que la salida del respectivo
transportador está libre (el producto ha salido), la transición se cumple.
- Fin Proceso: Ambos caminos convergen en este paso, que podría ser un paso de
limpieza o simplemente un punto de espera.
- Convergencia: Una vez que cualquiera
de las ramas ha llegado al Fin Proceso, se espera la Reset_Condicion para
volver al inicio.
Ejemplo 3: Proceso con Ejecución Paralela
(Sincronización)
Imagina una máquina que tiene dos operaciones que
pueden realizarse al mismo tiempo: un brazo robótico carga una pieza mientras
un cabezal de soldadura se prepara. Ambas deben terminar antes de que la
siguiente etapa (soldar) comience.
---
| Inicio Ciclo |
---
|
--( Ciclo_Start )---
|
======= (* Línea de divergencia para ejecución
paralela *)
| |
|---(Cargar Pieza) --->| Cargar Pieza | (*
Acciones: Mover brazo, tomar pieza *)
| ---
| |
| --(Pieza Cargada) ---
| |
| ---
| | Carga Completa |
| ---
| |
|---(Preparar Soldadura) --->| Preparar
Soldadura | (* Acciones: Calentar cabezal, limpiar *)
| ---
| |
| --(Soldadura
Lista) ---
| |
| ---
| | Preparación
Completa |
| ---
======= (* Línea de convergencia para
sincronización *)
|
--(Carga Completa AND Preparación Completa) --- (*
Transición: Ambas ramas deben haber terminado *)
|
---
| Soldar | (* Acciones: Activar soldadura *)
---
|
--(Soldadura Terminada) ---
|
---
| Fin Ciclo |
---
|
(Bucle de vuelta a Inicio Ciclo para el próximo
producto)
Explicación:
- Inicio Ciclo: El ciclo comienza.
- Ciclo_Start: Se inicia el ciclo de trabajo.
- Divergencia Paralela:
- Una
vez que Ciclo_Start se cumple, ambas ramas (Cargar Pieza y Preparar Soldadura) se activan y se ejecutan en paralelo.
- Cargar Pieza y Preparar Soldadura: Estas acciones se realizan al mismo
tiempo. Cada rama tiene su propio paso de "completado" (Carga Completa, PreparacionCompleta).
- Convergencia: El flujo del programa
solo puede pasar del paso PreparacionCompleta y Carga Completa al
paso Soldar cuando ambas condiciones de transición se
cumplen (es decir, Carga Completa es VERDADERO AND PreparacionCompleta es VERDADERO). Esto
asegura que ninguna soldadura comience hasta que la pieza esté cargada Y
el cabezal de soldadura esté listo.
- Soldar: Se ejecuta la acción de soldadura.
- Soldadura Terminada: Una vez terminada, el ciclo pasa a Fin Ciclo.
SFC es increíblemente potente para gestionar
procesos complejos y secuenciales, haciendo que la lógica sea mucho más clara y
fácil de depurar que si se intentara escribir todo en Ladder o Texto
Estructurado de forma lineal. A menudo se utiliza como la capa superior de
control, mientras que las acciones dentro de cada paso se implementan
utilizando LD, FBD o ST.
Ejemplos de Lista de Instrucciones (IL)
La Lista de Instrucciones (IL)
es el lenguaje de programación de PLC más elemental y se asemeja al lenguaje ensamblador de las computadoras. Aunque forma
parte del estándar IEC 61131-3, su uso ha disminuido considerablemente en favor
de lenguajes más gráficos y de alto nivel como el Diagrama de Escalera (LD),
Diagrama de Bloques de Función (FBD) o Texto Estructurado (ST). Es más difícil
de leer y mantener para la mayoría de los programadores, pero ofrece un control
muy preciso sobre las operaciones del PLC.
En IL, el programa se escribe como una secuencia de
operaciones de máquina simples. Cada línea de código generalmente consta de un operador (la instrucción a realizar) y un operando (el dato o la dirección sobre la que actúa la
instrucción).
Conceptos Clave en IL:
- Acumulador (o resultado): Una
característica central de IL es que las operaciones se realizan
típicamente en un registro interno llamado acumulador. Una
instrucción a menudo carga un valor en el acumulador, y luego otras
instrucciones operan con el contenido del acumulador.
- Operadores: Son las instrucciones
o comandos básicos, como LD (Load), ST (Store), AND, OR, ADD, SUB, etc.
- Operandos: Son los datos o
direcciones de memoria sobre los que actúan los operadores (ej., una
variable, una constante, una dirección de entrada/salida).
Ejemplos de Lógica en Lista de Instrucciones
Aquí tienes algunos ejemplos que ilustran cómo se
representa la lógica en IL.
Ejemplo 1: Lógica AND Simple
Queremos que una salida (Motor_ON) se active si dos entradas (Sensor_1 y Sensor_2) son verdaderas.
Fragmento de código
(* Declaración de variables (no se hace
directamente en IL, sino en la tabla de símbolos del PLC) *)
(* Sensor_1
: BOOL *)
(* Sensor_2
: BOOL *)
(* Motor_ON
: BOOL *)
(* Lógica de programa en IL *)
LD
Sensor_1 (* Carga el valor de
Sensor_1 en el acumulador *)
AND
Sensor_2 (* Realiza una
operación lógica AND con el valor de Sensor_2 y el acumulador *)
ST
Motor_ON (* Almacena el
resultado (contenido del acumulador) en Motor_ON *)
Explicación:
- LD Sensor_1: La instrucción LD
(Load) carga el estado de Sensor_1 (Verdadero/Falso) en el acumulador.
- AND Sensor_2: La instrucción AND
realiza una operación lógica booleana "Y" entre el valor actual
del acumulador (que es Sensor_1) y el valor de Sensor_2. El
resultado de esta operación se guarda en el acumulador.
- ST Motor_ON: La instrucción ST
(Store) toma el valor final del acumulador y lo guarda en la variable Motor_ON.
Así, Motor_ON será verdadero solo si Sensor_1 es verdadero Y Sensor_2 es verdadero.
Ejemplo 2: Lógica OR Simple
Queremos que una salida (Alarma Activa) se active si Temp_Alta O Pres_Baja son verdaderas.
Fragmento de código
(* Declaración de variables *)
(* Temp_Alta
: BOOL *)
(* Pres_Baja
: BOOL *)
(* Alarma Activa: BOOL *)
(* Lógica de programa en IL *)
LD
Temp_Alta (* Carga el valor de
Temp_Alta en el acumulador *)
OR
Pres_Baja (* Realiza una
operación lógica OR con el valor de Pres_Baja y el acumulador *)
ST Alarma
Activa (* Almacena el resultado en Alarma Activa *)
Explicación:
- LD Temp_Alta: Carga el estado de Temp_Alta en el
acumulador.
- OR Pres_Baja: Realiza una operación lógica booleana
"O" entre el acumulador y Pres_Baja. El resultado se guarda en el
acumulador.
- ST Alarma Activa: Guarda el resultado
final del acumulador en Alarma Activa.
Ejemplo 3: Arranque y Parada Simple de un Motor
(con autorretención)
Este es un poco más complejo en IL debido a la
autorretención, que implica ramificación.
Fragmento de código
(* Declaración de variables *)
(* Start_PB
: BOOL *)
(* Stop_PB
: BOOL *)
(* Motor_Contactor : BOOL *)
(* Lógica de programa en IL *)
LD
Start_PB (* Carga el
estado de Start_PB *)
ANDN
Stop_PB (* AND NOT
Stop_PB (Stop_PB es normalmente cerrado) *)
OR
Motor_Contactor (* OR con el
estado actual del Motor_Contactor (autorretención) *)
ANDN
Stop_PB (* AND NOT
Stop_PB de nuevo para asegurar que Stop_PB apague *)
ST
Motor_Contactor (* Almacena el
resultado en Motor_Contactor *)
Explicación:
- LD Start_PB: Carga el estado del pulsador de
arranque.
- ANDN Stop_PB: Realiza un "AND NOT" con el
pulsador de parada. Esto significa que si Stop_PB está pulsado (verdadero), NOT Stop_PB es
falso, y la condición general será falsa. Si Stop_PB no
está pulsado (falso), NOT Stop_PB es verdadero.
- OR Motor_Contactor: Realiza una operación
"OR" con el estado actual del Motor_Contactor. Esta es la parte de
la autorretención: si el motor ya está encendido (Motor_Contactor es
verdadero), mantendrá la condición verdadera incluso si Start_PB se
suelta.
- ANDN Stop_PB: Se repite el ANDN Stop_PB. Esto
es crucial para asegurar que el botón de parada (Stop_PB)
siempre tenga prioridad para detener el motor, rompiendo la
autorretención. Si Stop_PB se presiona, esta operación forzará el acumulador a falso.
- ST Motor_Contactor: Guarda el resultado
final en la salida del motor.
Ejemplo 4: Suma de dos Números Enteros
Sumar los valores de Valor_A y Valor_B y guardar el resultado en Resultado Suma.
Fragmento de código
(* Declaración de variables *)
(* Valor_A
: INT *)
(* Valor_B
: INT *)
(* Resultado Suma : INT *)
(* Lógica de programa en IL *)
LD
Valor_A (* Carga Valor_A en
el acumulador *)
ADD
Valor_B (* Suma Valor_B al
contenido del acumulador *)
ST
Resultado Suma (* Almacena el resultado en Resultado Suma *)
Explicación:
- LD Valor_A: Carga el valor entero de Valor_A en el
acumulador.
- ADD Valor_B: Suma el valor entero de Valor_B al
contenido actual del acumulador. El resultado de la suma se almacena en el
acumulador.
- ST Resultado Suma: Guarda el valor final
del acumulador en la variable Resultado Suma.
Ejemplo 5: Uso de un Temporizador (TON - Timer On
Delay) en IL
Llamar a un temporizador MiTemporizador para encender una luz (Luz_Activada) después de que Sensor_Activacion ha estado encendido por 3 segundos.
Fragmento de código
(* Declaración de variables *)
(* Sensor_Activacion : BOOL *)
(* Luz Activada
: BOOL *)
(* MiTemporizador
: TON *) (* Instancia del bloque de función TON *)
(* Lógica de programa en IL *)
CAL
MiTemporizador(IN := Sensor_Activacion, PT := T#3s) (* Llama al bloque
de función TON *)
LD
MiTemporizador.Q (* Carga la
salida Q del temporizador *)
ST Luz
Activada
(* Almacena el estado en Luz Activada *)
Explicación:
- CAL MiTemporizador(IN := Sensor_Activacion, PT := T#3s):
- CAL (Call): Es la instrucción
para llamar a un bloque de función.
- MiTemporizador: Es la instancia del
temporizador que se está utilizando.
- IN := Sensor_Activacion:
Asigna el valor de Sensor_Activacion a la entrada IN del temporizador.
- PT := T#3s: Asigna el tiempo
preestablecido de 3 segundos a la entrada PT del temporizador.
- LD MiTemporizador.Q: Carga el estado de la
salida Q del temporizador (MiTemporizador.Q) en el acumulador. La
salida Q es TRUE cuando el temporizador ha terminado de contar y su entrada IN está
activa.
- ST Luz Activada: Almacena el valor del acumulador en Luz Activada.
Como puedes ver, IL es muy conciso, pero su
legibilidad es baja para programas complejos. Cada instrucción es una operación
atómica. Por esta razón, se utiliza menos directamente en la programación
actual, aunque es el lenguaje en el que muchos softwares de programación de PLC
finalmente compilan los lenguajes gráficos y de alto nivel.
