0% encontró este documento útil (0 votos)

570 vistas208 páginas

Manual de Autómatas Programables

Este documento presenta un manual de contenidos sobre autómatas programables. Se describe la arquitectura interna de los autómatas, incluyendo sus bloques esenciales como la unidad central de proceso y la memoria. También se explica el ciclo de funcionamiento de los autómatas y conceptos como el control en tiempo real. Por último, se detallan aspectos relacionados con la instalación, mantenimiento y programación de los autómatas, incluyendo lenguajes de programación y diseño de automatismos lógicos.

Cargado por

Daniel Cano Bernal

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

0% encontró este documento útil (0 votos)

570 vistas208 páginas

Manual de Autómatas Programables

Cargado por

Daniel Cano Bernal

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

AUTÓMATAS PROGRAMABLES
(ELEE018PO)
Familia profesional: ELECTRICIDAD Y ELECTRÓNICA

Manual de contenidos

Reservados todos los derechos. El contenido de esta obra está

protegido por la ley, que establece penas de prisión o multas,
además de las correspondientes indemnizaciones por daños y
perjuicios, para quienes reprodujeren, plagiaren, distribuyeren o
comunicaren públicamente en todo o en parte, una obra literaria,
artística o científica, o su transformación, interpretación o
ejecución artística fijada en cualquier tipo de soporte o
comunicada a través de cualquier medio, sin la preceptiva
autorización.

Todos los nombres propios de programas, sistemas operativos, equipos, hardware, programas de afiliación, páginas web, etc.
que aparecen en esta publicación son marcas registradas de sus respectivas compañías, organizaciones y propietarios y tan
solo se muestran a modo informativo.

ÍNDICE

Contenido
ÍNDICE .............................................................................................................................................................................................................. 2
OBJETIVOS ...................................................................................................................................................................................................... 4
CONTENIDOS................................................................................................................................................................................................... 5
1. ESTRUCTURA, MANEJO E INSTALACIÓN DE LOS AUTÓMATAS PROGRAMABLES ........................................................................... 7
1.1. Arquitectura interna de un autómata..................................................................................................................................................... 7
1.1.1. Introducción .................................................................................................................................................................................. 8
1.1.2. Bloques esenciales de un autómata........................................................................................................................................... 10
1.1.3. Unidad central de proceso, CPU ................................................................................................................................................ 13
1.1.4. Memoria del autómata ................................................................................................................................................................ 17
1.1.5. Interfaces de entrada y salida .................................................................................................................................................... 22
1.1.6. Fuente de alimentación .............................................................................................................................................................. 28
1.2. Ciclo de funcionamiento de un autómata y control en tiempo real ..................................................................................................... 30
1.2.1. Introducción ................................................................................................................................................................................ 30
1.2.2. Modos de operación ................................................................................................................................................................... 32
1.2.3. Ciclo de funcionamiento ............................................................................................................................................................. 38
1.2.4. Chequeos del sistema ................................................................................................................................................................ 42
1.2.5. Tiempo de ejecución y control en tiempo real ............................................................................................................................ 44
1.2.6. Elementos de proceso rápido ..................................................................................................................................................... 51
1.2.7. Procesado rápido de programas ................................................................................................................................................ 52
1.2.8. Contador de alta velocidad ......................................................................................................................................................... 54
1.2.9. Entradas detectoras de flanco .................................................................................................................................................... 57
1.3. Instalación y mantenimiento de autómatas programables ................................................................................................................. 59
1.3.1. Introducción ................................................................................................................................................................................ 59
1.3.2. Fase de proyecto con autómatas programables ........................................................................................................................ 60
1.3.3. Selección del autómata .............................................................................................................................................................. 62
1.3.4. Fase de instalación ..................................................................................................................................................................... 64
1.3.5. Fijaciones y condiciones mecánicas .......................................................................................................................................... 65
1.3.6. Espacios de ventilación .............................................................................................................................................................. 66
1.3.7. Distancias de seguridad eléctrica ............................................................................................................................................... 67
1.3.8. Condiciones ambientales ........................................................................................................................................................... 67
1.3.9. Compatibilidad electromagnética ............................................................................................................................................... 71
1.3.10. Alimentación y protecciones ..................................................................................................................................................... 74
1.3.11. Distribución y cableado interno del armario de control ............................................................................................................ 76
1.3.12. Cableado externo ..................................................................................................................................................................... 78
1.3.13. Diseño e instalación del software ............................................................................................................................................. 79
1.3.14. Fiabilidad de las instalaciones con autómatas ......................................................................................................................... 79
1.3.15. Mantenimiento de instalaciones con autómatas ...................................................................................................................... 83
2. LENGUAJES Y PROGRAMAS EN LOS AUTÓMATAS PROGRAMABLES .............................................................................................. 86
2.1. Diseño de automatismos lógicos ........................................................................................................................................................ 86
2.1.1. Introducción ................................................................................................................................................................................ 87
2.1.2. Modelos y funciones de transferencia ........................................................................................................................................ 89
2.1.4. Diseño de automatismos combinacionales ................................................................................................................................ 92
2.1.5. Diseño de automatismos secuenciales ...................................................................................................................................... 94
2.1.6. GRAFCET: Resumen histórico ................................................................................................................................................... 94
2.1.7. Diseño basado en GRAFCET .................................................................................................................................................... 95
2.1.8. GRAFCET: Elementos de base y reglas de evolución ............................................................................................................... 96
2.1.9. GRAFCET: Ejemplo de diseño ................................................................................................................................................... 97
2.1.10. Macroetapas y representación en detalle................................................................................................................................. 99
2.1.11. Estructuras básicas del GRAFCET ........................................................................................................................................ 100
2.1.12. Diagramas de flujo y diagramas GRAFCET ........................................................................................................................... 101
2.1.13. Etapas iniciales, preposicionamiento y alarmas ..................................................................................................................... 102
2.1.14. Puestas en marcha y paradas: GEMMA ................................................................................................................................ 104

2.1.15. Método general de diseño basado en GEMMA ..................................................................................................................... 106

2.1.16. Paros de emergencia.............................................................................................................................................................. 107
2.1.17. Ejemplo de diseño .................................................................................................................................................................. 107
2.2. Programación del autómata .............................................................................................................................................................. 108
2.2.1. Introducción .............................................................................................................................................................................. 108
2.2.2. Representación de sistemas de control ................................................................................................................................... 110
2.2.3. Descripciones literales .............................................................................................................................................................. 113
2.2.4. Identificación de variables y asignación de direcciones ........................................................................................................... 114
2.2.5. Lenguajes de programación ..................................................................................................................................................... 117
2.2.6. Lenguajes booleanos y lista de instrucciones .......................................................................................................................... 119
2.2.7. Diagramas de contactos ........................................................................................................................................................... 120
2.2.8. Plano de funciones ................................................................................................................................................................... 123
2.2.9. Lenguajes de alto nivel ............................................................................................................................................................. 124
2.3. Programación de bloques funcionales ........................................................................................................................................ 125
2.3.1. Introducción .............................................................................................................................................................................. 126
2.3.2. Bloques secuenciales básicos.................................................................................................................................................. 127
2.3.3. Bloques funcionales de expansión ........................................................................................................................................... 134
2.3.4. Instrucciones especiales .......................................................................................................................................................... 137
2.4. Estructuras de programación ............................................................................................................................................................ 139
2.4.1. Introducción .............................................................................................................................................................................. 139
2.4.2. Programación lineal .................................................................................................................................................................. 141
2.4.3. Programación estructurada ...................................................................................................................................................... 141
2.4.4. Programación multitarea .......................................................................................................................................................... 144
2.4.5. Tareas rápidas e interrupciones ............................................................................................................................................... 145
2.4.7. Programación de procesadores periféricos inteligentes .......................................................................................................... 148
2.5. Programación en STEP-7 ................................................................................................................................................................. 149
2.5.1. Introducción a Step-7................................................................................................................................................................ 149
2.5.2. Estructura interna de un S7-200............................................................................................................................................... 153
Signal board ............................................................................................................................................................................................. 155
2.5.3. Direccionamiento ...................................................................................................................................................................... 156
2.5.4. Estructura de un programa y módulos de S7-200 .................................................................................................................... 159
2.5.5. Operaciones combinacionales ................................................................................................................................................. 164
2.5.6. Operaciones de memoria ......................................................................................................................................................... 165
2.5.7. Operaciones de tiempo ............................................................................................................................................................ 165
2.5.8. Operaciones con contadores .................................................................................................................................................... 167
2.5.9. Operaciones de comparación ................................................................................................................................................... 168
2.5.10. Operaciones aritméticas ......................................................................................................................................................... 169
2.5.11. Operaciones entre bloques .................................................................................................................................................... 170
2.5.12. Relaciones entre bloques ....................................................................................................................................................... 171
3. EJEMPLOS BÁSICOS DE PROGRAMACIÓN ......................................................................................................................................... 173
3.1. Introducción....................................................................................................................................................................................... 173
3.2. Identificación de entradas y salidas .................................................................................................................................................. 174
3.3. Programas con operaciones combinacionales ................................................................................................................................. 177
3.4. Programas con contadores ............................................................................................................................................................... 178
3.5. Programas con operadores de comparación .................................................................................................................................... 182
3.5.1. Escalar valores analógicos ....................................................................................................................................................... 184
3.6. Programas con operadores de memoria .......................................................................................................................................... 185
3.7. Programas con temporizadores ........................................................................................................................................................ 187
3.8. Ejemplo: Máquina empaquetadora ................................................................................................................................................... 188
3.9. Ejemplo: Máquina mezcladora .......................................................................................................................................................... 191
RESUMEN ..................................................................................................................................................................................................... 200
GLOSARIO .................................................................................................................................................................................................... 201
BIBLIOGRAFÍA.............................................................................................................................................................................................. 206
BIBLIOGRAFÍA GENERAL Y BÁSICA .................................................................................................................................................... 206
PÁGINAS WEB DE INTERÉS ................................................................................................................................................................. 206

OBJETIVOS

¡Bienvenido al curso AUTÓMATAS PROGRAMABLES (ELEE018PO)!

Una acción formativa que tiene como objetivo general aplicar los autómatas programables a la
gestión de proyectos.

Para abordar la programación de los autómatas programables, tan distinta a la de los
ordenadores convencionales, y entender sus peculiaridades, es condición indispensable conocer
previamente su estructura interna, tanto de software como de hardware.

En este curso aprenderá todos los fundamentos teóricos y prácticos para que, al finalizarlo, esté
capacitado para aplicar los autómatas programables a la gestión de proyectos.

Esperamos que este tiempo dedicado a la formación sea fructífero para usted y que pueda aplicarlo
profesionalmente de ahora en adelante a lo largo de su vida laboral.

CONTENIDOS

1. ESTRUCTURA, MANEJO E INSTALACIÓN DE LOS AUTÓMATAS PROGRAMABLES
1.1. Arquitectura interna de un autómata
1.1.1. Introducción
1.1.2. Bloques esenciales de un autómata
1.1.3. Unidad central de proceso, CPU
1.1.4. Memoria del autómata
1.1.5. Interfases de entrada y salida
1.1.6. Fuente de alimentación
1.2. Ciclo de funcionamiento de un autómata y control en tiempo real
1.2.1. Introducción
1.2.2. Modos de operación
1.2.3. Ciclo de funcionamiento
1.2.4. Chequeos del sistema
1.2.5. Tiempo de ejecución y control en tiempo real
1.2.6. Elementos de proceso rápido
1.2.7. Procesado rápido de programas
1.2.8. Contador de alta velocidad
1.2.9. Entradas detectoras de flanco
1.3. Instalación y mantenimiento de autómatas programables
1.3.1. Introducción
1.3.2. Fase de proyecto con autómatas programables
1.3.3. Selección del autómata
1.3.4. Fase de instalación
1.3.5. Fijaciones y condiciones mecánicas
1.3.6. Espacios de ventilación
1.3.7. Distancias de seguridad eléctrica
1.3.8. Condiciones ambientales
1.3.9. Compatibilidad electromagnética
1.3.10. Alimentación y protecciones
1.3.11. Distribución y cableado interno del armario de control
1.3.12. Cableado externo
1.3.13. Diseño e instalación del software
1.3.14. Fiabilidad de las instalaciones con autómatas
1.3.15. Mantenimiento de instalaciones con autómatas

2. LENGUAJES Y PROGRAMAS EN LOS AUTÓMATAS PROGRAMABLES
2.1. Diseño de automatismos lógicos
2.1.1. Introducción
2.1.2. Modelos y funciones de transferencia
2.1.3. Automatismos combinacionales y secuenciales
2.1.4. Diseño de automatismos combinacionales
2.1.5. Diseño de automatismos secuenciales
2.1.6. GRAFCET: Resumen histórico
2.1.7. Diseño basado en GRAFCET
2.1.8. GRAFCET: Elementos de base y reglas de evolución
2.1.9. GRAFCET: Ejemplo de diseño
2.1.10. Macroetapas y representación en detalle
2.1.11. Estructuras básicas del GRAFCET
2.1.12. Diagramas de flujo y diagramas GRAFCET
2.1.13. Etapas iniciales, preposicionamiento y alarmas
2.1.14. Puestas en marcha y paradas: GEMMA
2.1.15. Método general de diseño basado en GEMMA
2.1.16. Paros de emergencia
2.1.17. Ejemplo de diseño
2.2. Programación del autómata
2.2.1. Introducción
2.2.2. Representación de sistemas de control
2.2.3. Descripciones literales

2.2.4. Identificación de variables y asignación de direcciones
2.2.5. Lenguajes de programación
2.2.6. Lenguajes booleanos y lista de instrucciones
2.2.7. Diagramas de contactos
2.2.8. Plano de funciones
2.2.9. Lenguajes de alto nivel
2.3. Programación de bloques funcionales
2.3.1. Introducción
2.3.2. Bloques secuenciales básicos
2.3.3. Bloques funcionales de expansión
2.3.4. Instrucciones especiales
2.4. Estructuras de programación:
2.4.1. Introducción
2.4.2. Programación lineal
2.4.3. Programación estructurada
2.4.4. Programación multitarea
2.4.5. Tareas rápidas e interrupciones
2.4.6. Parametrización de módulos funcionales
2.4.7. Programación de procesadores periféricos inteligentes
2.5. Programación en STEP‐7
2.5.1. Introducción a Step7
2.5.2. Estructura interna de un S7‐200
2.5.3. Direccionamiento
2.5.4. Estructura de un programa y módulos de S7‐200
2.5.5. Operaciones combinacionales
2.5.6. Operaciones de memoria
2.5.7. Operaciones de tiempo
2.5.8. Operaciones con contadores
2.5.9. Operaciones de comparación
2.5.10. Operaciones aritméticas
2.5.11. Operaciones entre bloques
2.5.12. Relaciones entre bloques

3. EJEMPLOS BÁSICOS DE PROGRAMACIÓN
3.1. Introducción
3.2. Identificación de entradas y salidas
3.3. Programas con operaciones combinacionales
3.4. Programas con contadores
3.5. Programas con operadores de comparación
3.6. Programas con operadores de memoria
3.7. Programas con temporizadores
3.8. Ejemplo: Máquina empaquetadora
3.9. Ejemplo: Máquina mezcladora

1. ESTRUCTURA, MANEJO E INSTALACIÓN DE LOS AUTÓMATAS

PROGRAMABLES

Para abordar la programación de los autómatas programables es fundamental conocer y
comprender, al menos de forma genérica, su estructura interna, tanto de hardware como de
software. Solo así entenderemos las peculiaridades de su programación, muy diferente a la habitual
en los ordenadores convencionales.

En este tema se presentarán la estructura hardware interna, la estructura software de su sistema
operativo y las peculiaridades de su instalación física.

1.1. Arquitectura interna de un autómata

Un autómata programable es un dispositivo que, aunque similar en cierto sentido a un ordenador
convencional, cumple una tarea muy específica por lo que dispone de una arquitectura hardware
muy especial, pensada para optimizar su funcionamiento como controlador de instalaciones
industriales.

Se repasan en este tema sus principales características hardware que tanto influyen en su uso y
programación posterior.

1.1.1. Introducción

Un autómata programable, más conocido como PLC, es un equipo electrónico de control
desarrollado para ser utilizado en tareas de automatización y control industrial.

El autómata programable se conecta a la instalación que controla mediante unas entradas que le
informan del estado de cada elemento que la conforma y, gracias a un programa interno de control
que contiene la secuencia lógica deseada, determina cómo actuar sobre la planta a través de sus
salidas, y conseguir el funcionamiento deseado de la instalación.

En automatización industrial es habitual referirse a la instalación controlada por un
PLC como planta (planta industrial) o instalación; a la zona física que ocupa como
campo y a la secuencia lógica de acciones que se desarrollan en la planta como
proceso.
TOME NOTA

A finales de los sesenta se comenzó a trabajar con estos dispositivos, que permiten sustituir las
maniobras eléctricas convencionales (lógica cableada) por unas implementaciones basadas en
elementos programables mucho más pequeñas, manejables, económicas, versátiles y fáciles de
adaptar a posteriori.

Actualmente los autómatas programables siguen ocupando un espacio preferente en las tareas de
control industrial porque presentan diferencias importantes respecto a los ordenadores industriales
que los hace especialmente aptos para el trabajo para el que están diseñados.

Ventajas más relevantes de los PLC frente a los ordenadores

 Están preparados para manejar señales eléctricas de tensiones y corrientes elevadas, típicas
del ámbito industrial.
 Mecánicamente están preparados para ser instalados en el interior de cuadros eléctricos,
maquinaria, etc. con envolventes robustas y compactas adaptadas a ese entorno y a prueba
de vibraciones.
 Pueden trabajar en un rango de temperatura y humedad mucho más amplio que un
ordenador convencional.

 Disponen de un diseño modular que permite ir ampliando funciones y prestaciones para
adaptarse a instalaciones de diversos tamaños.
 Su funcionamiento es muy estable gracias a su sistema operativo cerrado, centrado en una
tarea específica y orientado a la fiabilidad frente a los sistemas operativos generalistas y
abiertos de los ordenadores.
 Disponen de buses de comunicación que facilitan la interconexión entre varias unidades para
cooperar en una misma tarea.
 La rapidez de reacción del PLC es muy superior a la de un ordenador convencional, aunque
este sea más rápido al tratar grandes volúmenes de información, lo que los hace más
apropiados para el control en tiempo real.
 Los PLC están pensados para que puedan ser programados por personas con conocimientos
de automatización aunque no dispongan de conocimientos informáticos.

Las señales de entrada al autómata pueden ser digitales (con dos estados solamente) o analógicas
(pueden adoptar valores intermedios), y llegan al mismo a través de sensores. Por su parte, las
salidas también pueden ser digitales o analógicas, y se traspasan desde el autómata a la planta a
través de actuadores. La función primordial del autómata es controlar el estado de las salidas según
el estado de las entradas siguiendo las instrucciones del
programa de control, que se introduce en el PLC con una
herramienta de programación y se almacena en una memoria
interna.

El PLC, internamente, se compone de distintos elementos

interconectados por buses. El principal es la Unidad Central
de Proceso (CPU) que, con las memorias, interfaces de
entrada y salida, periféricos de control (temporizadores,
contadores, vigilantes de funcionamiento, etc.) posibilitan el
almacenamiento y ejecución del programa de control.

En el siguiente vídeo puede ver la definición de un PLC y conocer su historia:

1.1.2. Bloques esenciales de un autómata

Un autómata programable está constituido por los siguientes elementos internos:

Fuente de alimentación

La fuente interna de alimentación genera las tensiones internas requeridas por los distintos
elementos que forman el PLC (típicamente del orden de 3.3 a 5 voltios), a partir de una
tensión de alimentación externa que suele moverse típicamente en el rango de los 12 a 48
voltios de tensión continua.

Interfaz de entradas

La interfaz de entradas permite la conexión de las señales de la planta al PLC, adaptando los
niveles de las señales presentes en la instalación (tanto digitales como analógicas) a los

niveles internos que requieren la CPU (Unidad Central de Proceso) y el resto de elementos
internos para su lectura.

Interfaz de salidas

La interfaz de salidas adapta los niveles de las señales internas generadas por la CPU y sus

periféricos a los niveles de salida al exterior del autómata que requieren los actuadores de la
planta (tanto digitales como analógicos1).

Memoria de programa

La memoria de programa contiene el programa de control del autómata, es decir, el conjunto
de instrucciones que definen el comportamiento deseado por el autómata una vez en
funcionamiento. Esta memoria es de tipo no‐volátil, es decir, que no se pierde su contenido
cuando se corta la alimentación al PLC, siendo necesario grabarla una única vez y pudiendo
ser usada indefinidamente a partir de ese momento.

Memoria de datos

La memoria de datos es una memoria, normalmente volátil, que almacena los resultados de
los cálculos y operaciones intermedias requeridas por el programa de control, variables que
no son traspasadas directamente a las salidas sino que se usan como cálculos intermedios.
Estos valores se suelen perder en caso de pérdida de alimentación, salvo aquellas posiciones
especiales que estén protegidas como verá más adelante.

Memoria de imágenes de entradas y salidas

La memoria de imágenes de entradas y salidas es una memoria volátil utilizada por la CPU
para almacenar una imagen del estado instantáneo global de todas las entradas y salidas
justo al inicio de cada ciclo de procesado. De este modo, si durante el ciclo de procesado
cambian los estados de alguna de las entradas, el programa de control sigue disponiendo de
un estado coherente de cómo estaban todas ellas en el mismo instante.

Temporizadores, contadores y otros periféricos

Los temporizadores son unos elementos gobernados por la CPU que permiten gestionar
tiempos de forma muy precisa, de manera autónoma y sin consumir recursos de la unidad
central de proceso. Pueden usarse para contabilizar el tiempo durante el cual una señal está
activa, el tiempo transcurrido desde que se activa una señal, a modo de cronómetro, etc.

Los contadores son otros elementos internos independientes de la CPU que permiten
contabilizar activaciones de entradas o de señales internas sin consumir para ello tiempo de
ejecución de la unidad central de proceso.

Unidad Central de Proceso o CPU

1 ANALÓGICO: Tipo de medida que puede presentar valores continuos de dicha medida, con múltiples valores posibles

dentro de su rango de trabajo.

La unidad central de proceso o CPU es el corazón del autómata, siendo la que accede al
estado de las entradas, interpreta las instrucciones almacenadas en la memoria de programa,
las ejecuta secuencialmente y por último traslada los valores deseados a las salidas.

Bus interno

El bus interno es un conjunto de pistas que interconectan internamente todos los elementos
anteriores entre sí, permitiendo que la CPU acceda a todos ellos para leer y escribir los
valores necesarios. Por economía se comparten las mismas pistas eléctricas de bus entre
todos los bloques internos, por lo que la CPU debe ir accediendo secuencialmente a cada
elemento, señalizando por unos hilos de control con qué bloque comunica en cada instante.

Para implementar esta interconexión entre bloques habitualmente se distinguen en el bus interno las
líneas de comunicaciones destinadas a control, direcciones y datos.

Por las líneas de control la CPU señaliza con qué dispositivo interno quiere comunicar y si desea leer
o escribir en él, por las líneas de direcciones indica qué registros o direcciones de cada bloque desea
leer o escribir, y por las líneas de datos se intercambian los datos leídos o escritos.

En la siguiente presentación con diapositivas puede ver en qué consiste la estructura interna del PLC:

1.1.3. Unidad central de proceso, CPU

La Unidad Central de Proceso o CPU es el corazón del autómata y está construida en torno a un
sistema electrónico microprocesado. Es la encargada de ejecutar el programa de usuario y de
coordinar las tareas de los elementos descritos en el apartado anterior a través de los buses de
comunicación: entrada/salida, lecturas de memoria de programa, acceso a contadores, etc. Para
efectuar esta tarea la CPU lee las instrucciones de la memoria de programa y va ejecutando las
órdenes allí descritas.

Un sistema electrónico microprocesado es una pequeña computadora que contiene un elemento
llamado microprocesador capaz de ejecutar sentencias de programa escritas en lenguaje de bajo
nivel que se almacena en una memoria propia e independiente. El microprocesador necesita una
serie de elementos internos:

ALU

La Unidad Aritmético/Lógica o ALU2 es la encargada de realizar las operaciones matemáticas
sencillas (multiplicaciones, divisiones, sumas y restas de números enteros —sin decimales—)
y las operaciones lógicas (AND, OR, comparaciones —mayor que, menor que, igual que—).

Acumulador

Es un registro muy importante, ya que es el que almacena el resultado de cualquier
operación efectuada por la ALU.

2 ALU: Arithmetic Logic Unit

Registros

Son unidades que almacenan parámetros numéricos de las instrucciones aritméticas y lógicas
que queramos ejecutar.

FLAGS

También llamados marcadores digitales de estado, almacenan los resultados de las
operaciones binarias efectuadas por la ALU, así como información complementaria sobre
dichos cálculos: desbordamiento de operación, signo del resultado, menor que, igual que,
resultado igual a cero, resultado distinto de cero, etc. Estos resultados pueden ser
consultados directamente por el programa.

Todas las operaciones matemáticas se efectúan en la CPU en lógica binaria, codificando
todos los números con “1” y “0”. Para trabajar en binario se opera normalmente con los
números, sumando y multiplicando de derecha a izquierda como hacemos
convencionalmente, salvo que 1+1 proporciona el valor binario 10, es decir, 1+1=0 y nos
llevamos 1 para el siguiente dígito.

Contador de programa

O PC3. Es el registro encargado de ir recorriendo la memoria de programa y que almacena la
dirección de la siguiente instrucción a ejecutar. Si bien lo más habitual es que la ejecución de
las instrucciones sea secuencial, una tras otra, también hay juegos de instrucciones
denominadas de salto que producen precisamente saltos en la ejecución del programa (toma
de decisiones en función de comparaciones, por ejemplo).

Decodificador de instrucciones y secuenciador

Este elemento interpreta las instrucciones de bajo nivel apuntadas por el Contador de
Programa, generando internamente las señales de control necesarias para ejecutar la orden
leída. Esta ejecución de la instrucción leída puede implementarse de dos formas
fundamentalmente: o bien con una lógica cableada (ejecución más rápida pero más costosa
de implementar) o bien por una lógica interpretada (más lenta pero menos costosa de
implementar). Un microprocesador de lógica interpretada ejecuta internamente otro
programa adicional que traduce las instrucciones del lenguaje de bajo nivel a otras aún más
básicas solo para uso interno de la CPU, de modo que cada instrucción de programa accedida
por el PC (Contador de programa) es a su vez convertida a una o más instrucciones internas a
la lógica de la CPU.

Memoria de programa de sistema

Esta memoria, interna a la CPU y no accesible para el usuario, contiene el programa de
sistema que es el que permite al microprocesador que conforma la CPU ser capaz de ir

3 PC: Program Computer

leyendo, interpretando y ejecutando las instrucciones del programa de usuario. Es decir,
contiene el programa que describe a la CPU cómo interpretar las órdenes escritas en el
programa de usuario y cómo llevarlas a cabo convenientemente. Además contiene los
algoritmos necesarios para controlar la puesta en marcha de la CPU, para controlar los
errores en la ejecución así como facilitar su seguimiento, para controlar la carga del
programa de usuario en la CPU, etc.

Registros de pila

O stack registers. Estos registros permiten a la CPU almacenar variables temporales sobre la
memoria RAM, por ejemplo los parámetros de llamadas a subrutinas. El término de “pila” se
debe a la forma de operar con ellos, depositándolos uno sobre otro en la memoria, de forma
que al ir leyéndolos vamos leyendo el más reciente, luego el anterior, como si estuviesen
amontonados en una pila en la que solo podemos acceder al elemento superior.

Coprocesador matemático

En sistemas de gama media / alta suele ser habitual la inclusión en la CPU de una estructura
compleja, similar a otra pequeña CPU en ocasiones, que ejecuta de forma rápida y eficiente
operaciones matemáticas complejas como por ejemplo operaciones con decimales.

Los microprocesadores que ejecutan lógica cableada se denominan RISC4 y los que ejecutan
lógica interpretada CISC5.

Como ya se ha mencionado, la ejecución del programa interno de la CPU puede efectuarse por lógica
interpretada o por lógica cableada. Este funcionamiento es transparente para el usuario, que no
puede acceder a dichas operaciones internas ni modificar su comportamiento. Por el distinto coste
que implica cada solución, habitualmente los autómatas programables de gama baja y media suelen
usar lógicas internas interpretadas, mientras que los de gama alta suelen implementar lógica interna
cableada por la mejora de velocidad de ejecución que supone.

Por otro lado, dada la diversidad de autómatas programables existentes, sus características y los
requisitos que se les demandan, existen diferentes arquitecturas de microprocesadores que
mejoran la velocidad de ejecución de los programas, como son:

Estructura concurrente

Estructura concurrente de varios microprocesadores trabajando internamente en la misma
CPU de forma paralela, ejecutando entre ellos las instrucciones del programa de usuario de
forma más rápida.

Estructura de control distribuido

4 RISC: Reduced Instruction Set Computer, "computador con conjunto de instrucciones reducidas".

5 CISC: Complex Instruction Set Computer, "computador con conjunto de instrucciones complejas".

En esta estructura unidades externas a la CPU ejecutan tareas específicas complejas a modo
de coprocesadores o periféricos inteligentes. Estos periféricos inteligentes suelen incorporar
internamente otra pequeña CPU con un programa específico para la tarea concreta que se
les asigne, como por ejemplo la regulación de velocidad de un motor eléctrico, la
comunicación con otros equipos, etc., de modo que la CPU principal del autómata
encomienda dicha tarea compleja al periférico inteligente que corresponda, quedando
descargada de esa pesada tarea.

Estas dos estructuras alternativas para la mejora de prestaciones pueden coexistir en autómatas de
gama alta, de modo que la CPU principal puede disponer de varios microprocesadores internos y al
mismo tiempo contar con periféricos inteligentes externos para ejecutar de modo más eficiente las
tareas más complejas, aumentando la velocidad de ejecución y la precisión de las tareas de control.

En las gamas de producto de autómatas programables, a las unidades que contienen interiormente a
la CPU con la memoria interna, la memoria de programa de usuario y la memoria de imágenes de
entrada y salida, se les suele denominar por extensión también como tarjeta CPU, tarjeta principal,
unidad de proceso o simplemente como CPU.

El microprocesador también es el corazón de un ordenador portátil, una tableta o
un teléfono de última generación.

TOME NOTA

El buscador de Google es un potente conversor de números de decimal a binario. Basta buscar un

número indicando que queremos verlo en binario para ver la conversión. Para operar con un número
binario en Google, indique que es binario con el prefijo “0b”. De este modo para multiplicar los
números binarios 1011 por 1101 y ver su resultado, pongamos en el buscador de Google el texto
“0b1011*0b1101”. Si lo que queremos es ver ese resultado en decimal, tendríamos que indicarle al
buscar “0b1011*0b1101 in decimal”.

1.1.4. Memoria del autómata

Una memoria es un dispositivo electrónico donde se almacena información de todo tipo. En el
entorno de trabajo de los PLC todas las memorias son de tipo electrónico (la información se
almacena en semiconductores grabados en una oblea de silicio). Para acceder a la información
interna de una memoria, los datos se almacenan en compartimentos identificados por sus posiciones
de memoria, a las que se accede direccionando la posición que se desea leer o escribir.

Internamente los datos se almacenan en formato binario. El almacén básico de información es un
elemento que contiene un “1” o un “0” (bit). Para el manejo de información se suele trabajar con
agrupaciones de 8 bits (byte) o con grupos de 16 bits (word).

La información que se quiera almacenar en las memorias puede ser de muy diversos tipos, pero
todos ellos se traspasan internamente a estas estructuras descritas. Vea el siguiente ejemplo Tabla
de representación de valores alfanuméricos y de formateo de texto codificando cada carácter con un
byte de información.

Tipos de información que se almacena en las memorias

— Estados digitales, binarios, de ON u OFF (Activo y Desactivo). Se almacenan como un bit,
que puede estar a “1” o a “0” para señalizar un estado u otro.

— Valores numéricos enteros. Dependiendo del valor que puedan alcanzar se almacenarán
como un byte (0‐255), un word (0‐65535) o un long (0‐4294967295).

— Valores numéricos con decimales. Suelen almacenarse en un formato especial que ocupa
4 bytes (float ó single) o bien 8 bytes (double) dependiendo de la precisión requerida. El
manejo de números decimales es mucho más lento en las CPU que el de números enteros,
por lo que se suelen evitar en la programación en la medida de lo posible.

—Textos con valores alfanuméricos. Suelen almacenarse en memoria asignando un byte a
cada carácter, usualmente codificados en código ASCII. Existen formatos ampliados de
información alfanumérica que precisa de 2 bytes por cada carácter que permiten el uso de
distintos alfabetos, no contemplados en el formato reducido.

— Programas de usuario o de sistema. Codificados en códigos de operación binarios y
almacenados en bytes.

La memoria electrónica ideal debería ser rápida tanto en escritura como en lectura, disponer de gran
capacidad de almacenamiento, consumir poca energía y no borrarse al perderse la alimentación
eléctrica. Como esta combinación de características es inalcanzable, se usan memorias de distintos
tipos para cada una de las funciones requeridas y se usa la más apropiada para cada caso. Haga clic
en la imagen para ampliarla.

Las memorias volátiles pierden la información al quedarse sin alimentación, y las no volátiles la
mantienen.

Existen memorias que solo pueden leerse y no escribirse (ROM: Read‐Only Memory), vea aquí un
ejemplo

Ejemplo de memoria ROM

El almacenamiento del programa de sistema, que es el ejecutado por el sistema
microprocesador interno a la CPU, que se programa en fábrica al construirse la CPU y ya no
puede ser borrado ni modificado.

También hay memorias que pueden leerse y escribirse, y, según la tecnología con que estén
fabricadas, serán de uno u otro tipo, pero la diferencia fundamental entre ellas es el modo en que se
escriben. Las más habituales en autómatas programables las vemos en el siguiente ejemplo.

Ejemplos memoria lectura y escritura

— Memorias RAM (Ramdom Access Memory o memoria de acceso aleatorio). Son memorias
de acceso muy rápido tanto en escritura como en lectura, pero cuentan con el inconveniente
de que son volátiles. Es decir, se pierde la información al cortarse el suministro eléctrico. En
ocasiones se instalan con una pequeña batería recargable interna que mantiene su
información en caso de corte eléctrico.

— Memorias EEPROM (Erasable Programmable Read Only Memory o memoria solo de
lectura, programable y borrable), que permiten borrar cada uno de los bytes que almacenan
individualmente. Son muy lentas en escritura debido al borrado byte a byte, mientras que en
lectura pueden ser muy rápidas. Son ideales para almacenar variables de configuración o
parámetros que no cambien muy frecuentemente y que sin embargo necesiten leerse con
mucha frecuencia.

— Memorias FLASH, que no permiten borrar bytes independientes pero sí borrar y reescribir
bloques de memoria de muchos bytes al mismo tiempo, lo que las hace mucho más rápidas
en escritura que las EEPROM, ya que prácticamente lo que tarda una EEPROM en borrar un
byte es lo que tarda una FLASH en borrar un bloque de memoria o página. Teniendo en
cuenta que el tamaño de estas páginas puede llegar a ser de muchos miles de bytes, el
resultado es una escritura miles de veces más rápida en la práctica que la de una EEPROM.

Memoria interna

La memoria interna es aquella en la que el autómata almacena las variables que precisa para la
ejecución del programa de usuario: variables temporales, estado de entradas, de salidas, relés
internos, valores de contadores, estados internos, etc.

Al ser estos valores temporales y precisarse mucha velocidad para leerlos y escribirlos, siempre se
implementa esta memoria sobre una de tipo RAM. Esto permite que el programa de usuario acceda
de forma continua a la memoria interna sin limitaciones de velocidad tanto para leer como escribir
los valores deseados.

El tamaño de esta memoria de tipo RAM, fijo para cada modelo de autómata programable y no
ampliable externamente, determina la cantidad de variables internas que el PLC es capaz de manejar
simultáneamente: pueden ser de tipo digital (binarias, de un solo bit) o numéricas (precisan según el
tipo 1 o más bytes). Dentro de la memoria interna del autómata se suele disponer de un rango de
posiciones de memoria destinado a almacenar bits individuales (estados o resultados binarios), y
otro destinado a almacenar variables numéricas.

Por otro lado, esta memoria interna debe disponer de una zona denominada memoria imagen de
entradas donde se almacena el estado instantáneo de las entradas en el momento de inicio del ciclo
de programa, y de otra denominada memoria imagen de salidas, donde se guarda el estado
instantáneo de las salidas en ese momento. Esto permite, en entornos de trabajo con entradas muy
cambiantes, trabajar durante el tiempo de ejecución del ciclo de programa con un conjunto
coherente de señales, las que existían en el momento de inicio del ciclo, aunque puedan cambiar de
estado durante el ciclo de programa.

Si el programa de usuario accediese directamente al estado de las entradas podría manejar
información incoherente ya que algunas cambian en el tiempo durante el que se van ejecutando
cada una de las instrucciones del ciclo de proceso.

Para evitar que esto ocurra la CPU procede de la siguiente forma:

 Antes de iniciarse el procesado cíclico que efectúa la CPU de forma continua, esta carga el

estado de las entradas en la memoria de imagen de entradas. Lo mismo hace con el estado
de las salidas, que en realidad al ser impuestas por la CPU están tal cual se hubiesen dejado
en la memoria de imagen de salidas en el ciclo anterior.
 Se inicia el ciclo de procesado durante el que la CPU lee las instrucciones del programa de
usuario y, basándose en ellas, en el estado de las entradas y salidas en las correspondientes
memorias de imágenes y en el estado de los contadores, temporizadores y variables
intermedias de cómputos anteriores, determina el estado que deben tener las nuevas
variables intermedias y las salidas, escribiendo el estado de salidas necesario en la memoria
de imagen de salida.
 Finalizado el ciclo de ejecución, la CPU transfiere el contenido de la memoria de imagen de
salida a las salidas físicas. La CPU inicia inmediatamente un nuevo ciclo de ejecución.

El tamaño de las memorias de imágenes de entrada y salida (E/S) determina cuántos puntos de E/S
puede manejar el autómata. El número es muy variable, dependiendo del modelo y su configuración.
Esta característica es una de las que diferencian los autómatas en distintas categorías. Es frecuente
dividir de forma aproximada los autómatas en gama baja (hasta 256 puntos de E/S), gama media
(hasta 1024 puntos de E/S) y gama alta (más de 1024 puntos de E/S).

La memoria interna del autómata también se usa para almacenar variables intermedias del proceso,
registros con valores necesarios para el procesado posterior, valores de contadores, temporizadores,
estado de relés internos, etc.

En general, esta memoria interna es volátil, ya que ante un corte eléctrico y un reinicio de programa
puede prescindirse de la mayoría de valores intermedios. Pero es frecuente que parte de la memoria
interna sea no volátil (implementada sobre memoria EEPROM o con batería en apoyo de la RAM), de
modo que aquellas variables intermedias, contadores, temporizadores o relés internos que sea
importante mantener tras un reinicio de sistema se puedan alojar en dicha área. Estos registros
especiales protegidos contra cortes eléctricos se suelen denominar Holding registers (bytes) o
Holding relays (bits). En español nos referimos a estas posiciones de memorias protegidas como
memoria remanente, memoria mantenida o memoria protegida.

La zona de memoria interna de contadores y temporizadores almacena los valores de conteo de
dichos elementos en registros típicamente de 2 o 4 bytes para poder contener valores altos si fuese
necesario. En caso de necesitar valores de conteo superiores a 65.535 unidades hay que utilizar 4
bytes por cada contador, con lo que se alcanzan más de 4.000 millones de posibles valores; en la
práctica, si se requiere trabajar con contadores de 5 dígitos o más hay que usar contadores de 4
bytes para poder alcanzar 99.999 unidades.

Los relés internos se almacenan ocupando solo 1 byte de memoria interna, de modo que cada byte
(unidad mínima de trabajo habitualmente disponible en las memorias físicas) contendrá 8 bits
internos diferentes.

Estos bits guardan temporalmente estados intermedios de operaciones lógicas, resultados de
operaciones, indicadores de estado que indican al programa de usuario cómo modificar otros valores
o contadores, señales de control de estado de procesos, etc. Pueden usarse como operadores para
operaciones lógicas, comparaciones, bifurcaciones de proceso, para asignar estados a otros
elementos internos del PLC o del programa de usuario o para recibir los resultados de otras
operaciones binarias.

Algunos relés internos de los autómatas son de uso especial, ya que con ellos se controla o se
consulta el estado de funcionamiento de parte del hardware del autómata: configuración de
periféricos, configuración de entradas/salidas, modo de trabajo de contadores, marcha/paro de
funciones internas del PLC, estado de errores, modo de trabajo del autómata (RUN/STOP/HALT), etc.

Finalmente, el área de memoria interna destinada al almacenamiento de registros internos se usa
para alojar variables intermedias de cómputo, parámetros de funcionamiento de los programas,
consignas de trabajo del programa principal y en general cualquier valor numérico que pueda ser
interesante manejar por el programa principal que no esté asociado directamente con ninguna
salida, contador o temporizador. Se accede a ellos como bytes, words o enteros para ser usados
como fuente de operaciones matemáticas, de comparación, etc. o bien para guardar los resultados
de dichas operaciones.

Tanto bits como registros internos no modifican ninguna salida del autómata, de modo que si se
desea transferir el estado de alguno de ellos a una salida, hay que definir expresamente en el
programa de usuario la transferencia del valor interno al punto de entrada/salida deseado.

Memoria de programa

La memoria de programa del autómata almacena el programa de usuario, que es la aplicación
desarrollada por su programador para que desempeñe la tarea deseada.

Además, contiene datos numéricos y alfanuméricos, como parámetros de funcionamiento para los
distintos algoritmos, valores de umbrales de comparación, textos literales asignados a distintos
estados, valores de temporización, ajustes de calibración, etc.

Finalmente, en la memoria de programa también se pueden guardar datos parametrizados sobre el
sistema: nombre de la aplicación, anotaciones sobre configuración de las entradas, recordatorios de
aspectos importantes sobre el funcionamiento del programa o sobre la instalación que se vaya a
controlar.

Actualmente, la mayoría de las memorias de programa internas al autómata son del tipo FLASH, ya
que proporcionan una alta velocidad de lectura, su precio es contenido y permiten cambiar el
programa grabado con buena velocidad al realizarse las grabaciones en bloque.

Muchos autómatas disponen además de memoria de programa externa que casi siempre se
implementan sobre tarjeta de memoria convencional, del mismo tipo que las usadas en cámaras de
fotos digitales. Estas memorias son económicas y de gran capacidad, pero permiten una velocidad de
lectura relativamente lenta, insuficiente para que el PLC alcance buenas prestaciones trabajando
sobre un programa de usuario directamente grabado en la tarjeta.

Para alcanzar la velocidad de trabajo necesaria el autómata carga o transfiere al iniciarse el
contenido de la tarjeta de memoria a su memoria interna, por ejemplo de tipo RAM, que puede
borrarse y leerse muy rápidamente. Esta carga se ejecuta bajo el control de la CPU. Nótese que aun
siendo la tarjeta de memoria de programa externa de mayor tamaño que el de la memoria interna, el
tamaño máximo permitido para el programa de usuario, los datos y los valores de configuración no
podrá superar el que admita dicha memoria interna.

Se denomina mapa de memoria a todo el conjunto de posiciones de memoria correspondientes a
todas las memorias descritas anteriormente, organizadas entre sí en función de sus rangos de
direcciones.

La dirección más alta que puede ser direccionada por el PLC es un parámetro fijo de cada modelo que
no puede ser modificado por el usuario, normalmente ni siquiera con ampliaciones externas, y
depende de varios factores:

 La capacidad de direccionamiento interna que permita el bus de direcciones, limitada por la
tecnología de fabricación de la CPU.
 El tamaño de las memorias de imágenes de entradas y salidas, que a su vez dependerán de la
cantidad máxima de entradas y salidas que pueda manejar el autómata.
 El tamaño de la memoria de registros y relés internos.
 El tamaño admitido por la memoria de programa.

El programa de usuario se almacena en la memoria de programa codificando las distintas
instrucciones que lo componen en paquetes de bytes, y normalmente se necesitan como mínimo 2
bytes para codificar internamente cada instrucción. El tamaño máximo admitido para el programa de
usuario suele imponer grandes diferencias entre los autómatas de gama baja, media y alta, pudiendo
establecerse una categoría aproximada entre ellos en base a este parámetro:

 PLC de gama baja con memorias de programa de usuario de hasta mil instrucciones.
 PLC de gama media con memorias de programa de usuario de decenas de miles de
instrucciones.
 Finalmente los de gama alta con programas de usuario con capacidad para varias centenas
de miles de instrucciones.

1.1.5. Interfaces de entrada y salida

Las interfaces de entrada y salida son un conjunto de circuitos electrónicos que establecen la
conexión entre la unidad central y las señales eléctricas del proceso, adaptando niveles de tensión y
corriente a los niveles necesarios a cada lado de la interfaz, filtrando las señales del proceso,

amplificando las procedentes de la CPU y, en definitiva, adaptando las características eléctricas de las
señales de entrada y salida de la unidad central de proceso a los niveles utilizables en la planta.

Pueden encontrarse muchas diferentes señales en la instalación a nivel físico, por lo que se precisan
múltiples interfaces de campo para poder adaptar las señales de cada tipo. Para empezar estas
señales de campo se pueden diferenciar entre:

Interfaces digitales y analógicas

 Digitales, de 1 bit, con solo dos estados posibles: activo e inactivo (como el estado de un
motor, en marcha o parado).
 Analógicas, en las que la entrada puede tomar muchos valores diferentes en un
determinado rango, como la corriente consumida por el motor anterior.

Recuerde que es muy importante comprender las diferencias entre entradas y salidas digitales y
analógicas para comprender el funcionamiento y programación de un PLC.

Interfaces digitales de E/S de distintas tensiones de trabajo (ver abajo)

Otra distinción clara entre unas interfaces digitales y otras se realiza según su tensión de trabajo.
Las entradas y salidas pueden ser:

 Entradas y salidas de corriente continua
 Entradas y salidas de corriente alterna
 Salidas de relé libres de tensión

A continuación verá cada una de ellas con más detalle.

Entradas y salidas analógicas

Las entradas y salidas analógicas pueden ser:

 Entradas y salidas analógicas de tipo tensión, en las que el valor analógico codificado se
identifica con una tensión cambiante linealmente entre un valor mínimo y uno máximo.
Suelen ser típicamente de 0 a 5Vdc ó bien de 0 a 10Vdc. Para indicar el valor mínimo
representable por la entrada se usa el valor de 0V, y para indicar el valor máximo
representable de esa variable se usa o bien 5V (en el caso de ser 0 a 5V) o bien 10V (en
las de tipo 0‐10V). El resto de valores intermedios se representan linealmente en ese
rango. Por ejemplo si tenemos una sonda de temperatura con salida 0‐10V y un rango de
temperatura de 0 a 100ºC, cuando tengamos 50ºC nos dará una señal de 5V.

 Entradas y salidas analógicas de tipo corriente, en las que se codifica el valor a
representar con la corriente que circula por la salida o entrada y no por su tensión. En
este caso suelen ser casi siempre del tipo 4‐20mA, un formato muy usual en el entorno
industrial.

El valor mínimo representable se identifica con una circulación de 4mA de corriente continua en
la entrada o salida, mientras que el valor máximo representable se identifica con 20mA de
corriente. Nótese que cualquier valor por debajo de 4mA sería considerado erróneo, fuera de
rango, lo cual presenta la gran ventaja de que si se rompe un hilo eléctrico que transporta esta
señal la corriente pasaría a ser de 0mA, fuera de rango, siendo posible señalizar error de
cableado en dicha señal para así advertir de dicho fallo.

En el caso de las entradas analógicas de tensión 0‐5V ó 0‐10V, el valor de 0V (que sería el
presente en caso de rotura de un hilo) entra dentro del rango aceptable por lo que se confundiría
la lectura más baja posible con una eventual rotura de hilo.

Otra gran ventaja en el ámbito industrial de las señales analógicas en modo corriente es que son
aptas para ser transmitidas a lo largo de grandes distancias. Esto es así por dos motivos:

 La caída de tensión que produciría la tirada larga de cable en una señal analógica de
tensión sería interpretada con una lectura de señal más baja de la real (al perderse parte
de la tensión en el cable). En el caso de ser una medida de corriente, esta es la misma a
lo largo de todo el cableado siendo solamente superior la tensión que tendría que
proporcionar la salida analógica para poder mantener esa corriente en el bucle de salida.
 El lazo de salida de corriente analógica trabaja con una impedancia habitualmente muy
inferior a la de una salida de tensión, por lo que es más inmune a captar interferencias.

Interfaces de entradas y salidas locales y remotas

Otra diferencia entre interfaces de entrada y salida la marca el que sean locales a la CPU del
autómata o que sean remotas (en módulos de ampliación externos).

Una de las principales consecuencias de que las interfaces sean locales o remotas es el tiempo
que emplea la CPU en conocer su estado, siendo mucho más rápida la lectura de las E/S locales.

Interfaces de entradas y salidas aisladas

Un tipo especial de E/S son las que están aisladas eléctricamente del interior del autómata. En
capítulos posteriores verá que esta característica es especialmente interesante cuando se trabaja
en entornos eléctricamente muy ruidosos.

Las entradas y salidas aisladas suelen implementarse con optoacopladores, que están
constituidos internamente por un diodo fotoemisor y un transistor fotoreceptor, traspasándose
el estado de la señal de un lado a otro del interfaz con una señal óptica a través de un espacio
vacío, proporcionando por tanto un alto grado de aislamiento eléctrico.

Las salidas de relé ofrecen separación galvánica, pues entre la bobina que recibe la señal de
entrada y los contactos de salida no existe unión física, simplemente aire que proporciona
separación entre la señal de entrada y la de salida.

Interfaces de entradas y salidas comunes en autómatas compactos

En los PLC de gama compacta las entradas y salidas que se suelen presentar en el propio cuerpo
de la CPU suelen ser de los tipos más habituales, siendo usualmente de los siguientes tipos:

 Entradas de corriente continua de 24Vcc ó 48Vcc.
 Entradas de corriente alterna a 110Vca ó 230Vca.
 Entradas analógicas de tensión de 0 a 10 Vcc ó bien de corriente de 4‐20mA.
 Salidas de relé, pudiendo tener disponibles los terminales Común, Normalmente Abierto
y Normalmente Cerrado.
Una salida a relé, recibe una señal de entrada que hace que se genere un campo
magnético en la bobina que atraerá los contactos de salida (NA‐NC‐Común). La
generación de este campo magnético necesita de un tiempo de conmutación elevado,
por lo que una salida a relé podrá conmutar como máximo 1 vez por segundo, siendo su

límite, en muchos casos, de 30 conmutaciones en un minuto. Por el contrario, sus
contactos podrán manejar corrientes grandes, de entre 10A y 16A dependiendo del
modelo.
Si necesitamos conmutaciones más elevadas, por ejemplo para realizar regulación de
sistemas de iluminación, motores, etc… necesitaremos usar salidas a transistor (PNP‐
NPN) que al estar formadas por dispositivos electrónicos, pueden conmutar a gran
velocidad (decenas de veces en un segundo), pero con una circulación de corriente muy
pequeña (del orden de mA).
 Salidas de tensión alterna por Triac hasta 230Vca de baja potencia.
 Salida de colector abierto con tensiones de trabajo de 24Vcc ó 48Vcc.
 Salidas analógicas de tensión 0‐10V ó de corriente en 4‐20mA.

En los autómatas modulares de gama media o alta normalmente las entradas y salidas son
externas a la CPU principal, existiendo módulos de entradas y salidas con muy variadas
interfaces, incluso con algunas específicas para conectar directamente todo tipo de sondas
especiales, transductores y actuadores.

Las interfaces digitales de E/S de distintas tensiones de trabajo pueden ser:

E/S de corriente continua

Habitualmente trabajan a 5Vcc, 12Vcc, 24Vcc ó 48Vcc, y suelen marcar una señal lógica de

activación cuando la señal de tensión es superior a la mitad de la tensión nominal, y una
señal de desactivación cuando la tensión es inferior a la mitad de dicha tensión nominal (por
ejemplo, una señal de más de 12Vcc indicará un estado activo ‐un “1”‐ en una interfaz de
24Vcc), mientras que una señal de menos de 12Vcc indicará un “0”.

Las salidas digitales de tensión más frecuentes son las del tipo “colector común”. Son salidas
que señalizan su estado permitiendo o no el paso de corriente eléctrica entre el terminal de
salida y un terminal común, diferenciándose entre ellas dos tipos:

 de tipo NPN (haciendo referencia al tipo de transistor bipolar usado para
implementarla), que permiten el paso de corriente desde el terminal de entrada al
terminal común negativo (y no al contrario).

 de tipo PNP (aludiendo de nuevo al tipo de transistor bipolar usado internamente),
que permiten el paso de corriente desde el terminal común positivo al terminal de
entrada (y no al contrario).

E/S de corriente alterna

Las tensiones típicas de trabajo pueden ser de 24Vca, 115Vca ó 230Vac.

Las salidas de tensión alterna más comunes se implementan a base de TRIACs, y
normalmente son capaces de proporcionar poca potencia.

Salidas de relé libres de tensión

En este caso el estado de activación se señaliza cerrando un contacto eléctrico entre dos
terminales, mientras que el de desactivación se señaliza abriendo (interrumpiendo) dicho
contacto.

Pueden manejar indistintamente señales alternas o continuas, según la señal que se aplique
a sus contactos.

1.1.6. Fuente de alimentación

Un autómata está formado por distintos bloques que para funcionar requieren diferente tensión de
alimentación y distinta potencia, factores ambos que proporciona la fuente de alimentación.

Debido a las diferencias eléctricas internas entre los bloques del autómata es habitual que la fuente
de alimentación proporcione una señal interna para cada uno de ellos. Son necesarias al menos:

 Una señal de alimentación de baja tensión, bastante corriente y muy filtrada de ruido
eléctrico para suministrar la energía a la CPU y las memorias (habitualmente suelen ser líneas
de 5Vcc, 3.3Vcc, 2.8Vcc e incluso inferiores en autómatas potentes).
 Alimentación de entradas, habitualmente de 12Vcc, 24Vcc ó 48Vcc y poca corriente.
 Alimentación de salidas. Son habituales las mismas tensiones, pero con corrientes
superiores.

En cuanto a la alimentación externa, la procedente de la instalación, la más frecuente es de 230 Vca
o bien de 24Vcc.

Es habitual que la propia fuente de alimentación gestione, mediante una batería interna, la tensión
de las líneas de mantenimiento de memoria RAM soportada por batería. De este modo, en esas
líneas tendremos siempre tensión, suministrada por la fuente de alimentación si tenemos disponible
suministro eléctrico en el autómata o por la batería si se ha desconectado el PLC del suministro
eléctrico. El nivel de carga de la batería se señaliza con pilotos externos. La duración es de hasta 10
años en los autómatas de gama alta.

En el caso de los PLC compactos, estos pueden integrar la fuente de alimentación en el propio cuerpo
de la CPU. Además, suelen proporcionar una tensión de salida para alimentar a los distintos sensores
y actuadores externos que se necesiten usar, siempre que no requieran mucha potencia.

En el caso de los PLC de gama media y alta, de diseño modular, es más habitual que se usen fuentes
de alimentación externas, ya que por el diseño es habitual que se requiera bastante corriente para
alimentar todos los módulos necesarios en el control de una planta. Son habituales para este uso
fuentes de alimentación modulares que ya disponen de distintas tensiones de salida a las que
conectar las distintas expansiones modulares, cada una a la tensión que requiera.
Actualmente, casi todas las fuentes de alimentación de autómatas, sean internas o externas, se
implementan con fuentes de alimentación de tipo conmutada por sus grandes ventajas en eficiencia,
peso y volumen respecto a las antiguas, lineales.

En el caso de los autómatas modulares, cuando se desee usar una fuente de alimentación común
para varios dispositivos, se pueden utilizar racks o bastidores en los que ya se integra una fuente que
traspasa su alimentación a todos los módulos que encajemos en el bastidor a través de conectores
internos, simplificando el cableado.

A continuación, se muestra la imagen de un bastidor para el montaje de un autómata S7‐400 de
Siemens, con su fuente de alimentación y sus módulos de expansión.

1.2. Ciclo de funcionamiento de un autómata y control en tiempo real

Quizás la principal diferencia entre el modo de ejecutar su programa que tiene un PLC respecto a un
ordenador convencional es el concepto de ejecución cíclica de todo el programa de usuario a cada
ciclo de scan, en contraposición a la ejecución continua y progresiva habitual en un programa de
ordenador.

La capacidad de control en tiempo real de un autómata está ligada a su vez con su ciclo de
funcionamiento, en concreto con la duración del mismo, aunque hayan otros factores como el
tiempo de procesado de entradas y salidas que también son importantes para poder garantizar el
control en tiempo real de instalaciones.

1.2.1. Introducción

Como se ha visto en el capítulo anterior, los autómatas programables o PLC son unos dispositivos
que tienen la capacidad de analizar el estado de una serie de entradas de distinto tipo y, en función
del programa de usuario que se les haya programado, generar las actuaciones sobre las salidas
correspondientes al control de la planta que se hayan querido implementar.

Para efectuar esa tarea de control el autómata debe ser capaz, después de estudiar las entradas, de
ejecutar secuencialmente todas las instrucciones que se le hayan dado en el programa de usuario,
analizándolas y actuando en consecuencia para que la tarea de de control se realice de modo eficaz.

Fases consecutivas de la operación continua del autómata

 Lectura de estado de entradas, que se traspasan como ya vimos a la memoria de imagen
de entradas desde la interfaz de entrada.
 Ejecución de las instrucciones contenidas en el ciclo de usuario, para que en función del
estado de las entradas y los estados intermedios o temporales cargados en ese momento
se decida el estado correcto de las salidas.
 Carga de valores de salida en la interfaz de salidas.

Es frecuente referirse al ciclo de operación por su nombre en inglés: ciclo de scan.

TOME NOTA

Para optimizar la velocidad de ejecución y garantizar la coherencia entre los valores de las entradas
durante el ciclo de ejecución de instrucciones, las entradas son leídas simultáneamente todas en un
mismo procedimiento, y se traspasan a la memoria de imagen de entrada en una sola operación.

El autómata procesa las instrucciones del programa de usuario sobre estos valores almacenados en la
memoria de imagen de entradas, no sobre los estados físicos de las entradas, que pueden continuar
cambiando durante la fase de ejecución de programa, va generando las variables temporales
intermedias que va guardando sobre registros y relés internos y va cargando sobre la imagen de
memorias de salida el estado deseado para cada una de las salidas.

Finalizado el ciclo de ejecución de programa al completarse la ejecución de todas las instrucciones, se
pasan en un mismo instante el estado de todas las variables de salida contenidas en la memoria de
imagen de salidas en las salidas físicas, terminando el ciclo de operación y e iniciándose el siguiente,
y así indefinidamente mientras el autómata esté en modo de ejecución.

Además de esta tarea primordial de ejecución del programa de usuario, el autómata efectúa
constantemente otras tareas de verificación que garantizan el correcto funcionamiento del sistema,
como son los chequeos de CPU, chequeos de memoria, supervisión del sistema de vigilancia de
estado de funcionamiento (más conocido por el término en inglés, watchdog o perro guardián) y
comunicación con otros elementos externos, como pueden ser otros autómatas, pantallas,

impresoras o incluso periféricos externos especializados, como controladores de motores, variadores
de frecuencia, etc.

Todo este conjunto de tareas que se repite una y otra vez conforman lo que se conoce como ciclo de
operación, que se repite indefinidamente y requiere cierto tiempo para ejecutarse. Este tiempo
puede variar en función de la potencia de cómputo del autómata, número de entradas y salidas,
longitud y complejidad del programa de usuario y cantidad y tipo de periféricos conectados.

1.2.2. Modos de operación

Cuando se alimenta eléctricamente a un autómata, este siempre estará en uno de los siguientes
modos de operación: STOP ‐ RUN ‐ ERROR

Dependiendo del PLC y de su programación, al conectarse la alimentación al autómata puede pasar
por defecto a RUN (lo más habitual) o a STOP. Manualmente, el usuario siempre puede pasar de un
modo a otro: dependiendo del autómata, puede hacerse fácilmente mediante pulsadores en la CPU o
bien a través del terminal de programación.

Vea con qué se corresponde cada modo de operación:

Modo STOP

En este modo se detiene la ejecución del programa de usuario y pasan todas las salidas a
modo OFF o desactivadas. Por su parte, las variables internas, sean registros o relés internos,
mantienen todas sus valores actuales (incluso aquellas que no son de tipo mantenidas, que
se perderían en caso de corte eléctrico). Los contadores, temporizadores y resto de periferia
también mantienen sus valores instantáneos correspondientes con el momento de paso a
STOP.

Al pasar a RUN se recupera el ciclo de programa en base a los estados de las entradas y
variables internas almacenadas en el momento de paso a STOP.

Recuerde que, si pasa manualmente un autómata a STOP, este no volverá a ejecutar el
programa de usuario hasta que lo pasemos a RUN también manualmente.

Modo ERROR

El autómata pasa a este modo si detecta algún error de funcionamiento y así se quedará
hasta que se solvente el problema. Durante este estado todas las salidas pasan a estado
desactivo u OFF.

Al corregirse el problema el autómata saldrá de este estado, bien por reinicio físico (pérdida
de alimentación y vuelta a ser conectado), por un comando desde el módulo de
programación, por pulsación de botones o interruptores en el cuerpo de la CPU o bien por
orden directa de la CPU.

Entre los posibles errores pueden encontrarse los siguientes:

 Error de hardware del PLC: bloques internos, memorias y CPU.
 Error en el programa de usuario, error en el chequeo de integridad de contenido de tipo
checksum o CRC.
 Error al conectar con la periferia: periféricos no conectados o respondiendo
incorrectamente en sus direcciones de red correspondientes.
 Nivel de carga de la batería de mantenimiento de memoria insuficiente.
 Error de funcionamiento o de integridad de datos en la tarjeta de memoria externa.

Es buena práctica configurar los actuadores, siempre que sea posible, de modo que,
cuando la salida que los controla esté desactivada (OFF), queden en la posición más
segura para la planta y los usuarios. Así, cuando se pase a ERROR, todos los
actuadores estarán en su estado más seguro.
TOME NOTA

En los PLC de gamas media y alta es frecuente que haya interruptores para los cambios de modo de
operación, además de indicadores luminosos de estado que permiten saber en qué modo de trabajo
se encuentra el autómata. En cambio, en los autómatas de gama baja es frecuente que estos
cambios de modo solo se puedan hacer mediante la unidad de programación. Para suplir esta falta
de botones de control, en ocasiones es posible asociar las tareas de cambio de modo de trabajo con
cambios de entradas físicas del PLC, de modo que pueden ser configuradas para esta tarea en el
programa de usuario o en la propia configuración del autómata.

Cuando un autómata se encuentra en modo STOP, como se mantienen los valores de todas sus
variables internas, se puede hacer un diagnóstico completo de funcionamiento verificando los
valores de registros internos, relés internos, estado de las entradas, etc. como tareas de
mantenimiento y revisión. Suele ser necesario conectarle la unidad de programación con la que es
posible efectuar esos chequeos en autómatas de cualquier gama.

A veces los PLC disponen de estados especiales de trabajo para diagnóstico y control manual de
entradas y salidas; dicho modo recibe distintos nombres, dependiendo del modelo: DIAG (de
diagnóstico), MONITOR, MANUAL, forzar variables, etc.

1.2.2.1. Modos de ejecución del S7‐1200

En las CPU más modernas, ya no se tiene un interruptor físico para poder cambiar de RUN a STOP o
de STOP a RUN, sino que el estado actual del PLC viene mostrado por los LED situados en la parte
frontal de la CPU, que cambiarán de color según el estado en que se encuentre.

Al no disponer de palancas o botones para cambiar el estado del autómata, necesitará conectarse al
equipo mediante el terminal de programación y, dentro de TIAPortal, cambiar el estado de ejecución
del programa.

En primer lugar, tendrá que estar conectado online con la CPU. Una vez esté online, debe acceder al
apartado «Online y diagnóstico» que encontrará en el árbol del proyecto. Por último, debe pulsar en
la pestaña «Herramientas Online» situada en la barra lateral derecha de TIA Portal.

Como resultado de lo anterior, se visualizan los LEDs de la CPU indicando el estado operativo.
Asimismo, en este caso de la imagen anterior, puede comprobarse como la CPU en este momento
está en modo STOP ya que el LED está de color amarillo. Es decir, que por código de colores se
reconocerá qué funciones está ejecutando el autómata.

Colores y significados del LED RUN / STOP

Este LED va a representar dos estados operativos, ya que nos va a mostrar dos colores:

 Color amarillo si está en STOP.
 Color verde si está en modo RUN.

El color amarillo intermitente (parpadeando) si está en modo ARRANQUE.

Color y significado del LED ERROR

Este LED nos puede indicar dos problemas con la CPU:

 Error de programación
 Error de Hardware

Este LED se ilumina de color rojo cuando existe un error en la CPU. Asimismo, mostrará este color

rojo cuando se tiene configurado un Hardware en el proyecto, pero físicamente no está ese
módulo acoplado en el PLC.

Por ejemplo, imagine que tiene configurado en su proyecto un PLC y dos módulos de entradas y
salidas. En cambio, a la hora de montar y realizar pruebas, no ha colocado un modulo de entradas y
salidas porque no lo tiene en este momento. Por esta razón, el LED rojo de ERROR se iluminará
indicando que ahí falta algo.

Color y significado del LED MAINT

Este LED de mantenimiento se ilumina de color amarillo cuando se está realizando el proceso de
carga del programa mediante una tarjeta MMC de Siemens.

También se puede iluminar de amarillo cuando está arrancando el programa, cuando se inicia el
proceso por primera vez.

Estado operativo STOP

El PLC no está ejecutando el programa, no se están leyendo las entradas ni tampoco se puede activar
ninguna salida del autómata, por lo que en este estado se podrá cargar el proyecto al PLC

Este es un estado seguro, ya que permite revisar la instalación sin peligro porque no se va a
activar ninguna salida y, por tanto, ningún actuador.

Estado operativo ARRANQUE

El PLC está ejecutando una rutina de arranque «OB de arranque». OB100 en el caso del S7‐1200.

En esta parte del programa se pueden incluir ciertas tareas específicas que se ejecutarán solamente
durante el arranque, por ejemplo:

 inicializar el grafcet,
 poner a cero determinados contadores,
 inicializar variables, etc.

Los eventos de alarma, si existen, no se ejecutarán en este estado.

En la imagen puede ver cómo se tiene un OB100 que se ejecutará durante el arranque del autómata.

Estado operativo RUN

Cuando la CPU está en RUN el programa se ejecutará cíclicamente. Por ello, el programa se ejecutará
de arriba abajo, leyendo las entradas, ejecutando el código y todas las condiciones del programa, y
activando las salidas necesarias en todo momento.

En este modo se podrá:

 trabajar online con el PLC,
 ver todos los datos en tiempo real,
 comprobar las entradas y salidas,
 asignar valores a los datos DB y
 crear el código de programa necesario para volver a transferirlo al autómata.

1.2.3. Ciclo de funcionamiento

El funcionamiento de un autómata es básicamente secuencial: ejecuta una vez tras otra las
instrucciones del programa de usuario en pasos que denominamos ciclo de funcionamiento o de
operación. Un autómata no está en este ciclo únicamente justo tras un reinicio o cuando está en los
modos STOP, ERROR o DIAG.

En la figura podemos ver los distintos estados en los que puede estar el autómata en todo su ciclo de
funcionamiento: el ciclo de operación es el que se repite indefinidamente.

Tareas que ejecuta un PLC tras un reset o reinicio

Tras un reset o reinicio, el autómata ejecuta una serie de tareas iniciales destinadas a:

 Chequear el hardware del PLC: bloques internos, memorias y CPU.
 Verificar la integridad del programa de usuario, efectuando un chequeo de integridad de
contenido de tipo checksum o CRC.
 Comprobar la conexión con la periferia: periféricos conectados y respondiendo
correctamente en sus direcciones de red correspondientes.

 Verificar el nivel de carga de la batería de mantenimiento de memoria.
 Comprobar el correcto funcionamiento e integridad de datos en la tarjeta de memoria
externa, si la tiene.

En caso de localizarse un error, el autómata pasaría a modo ERROR directamente, lo señalizaría con
su indicador luminoso y se detendría la secuencia de arranque en caso de que el error fuera de cierta
consideración.

Si por el contrario se supera correctamente el chequeo, se inicializa la memoria de trabajo, las
entradas y salidas. En esta fase:

 Se marcan como desactivados todos los registros y bits internos que no fuesen de tipo
mantenido, ya que estos seguirán con su valor.
 Se marcan como desactivas todos los puntos de entrada y salida en las memorias de
imágenes de entrada/salida.
 Se inicializan todos los valores de contadores, temporizadores y periféricos especiales, como
por ejemplo el vigilante de operaciones o watchdog.

Este proceso de arranque es muy rápido en cualquier autómata.

Si durante esta fase tampoco se encuentra ningún error, el autómata pasa a repetir indefinidamente
su ciclo de operación, que a su vez está compuesto por los siguientes procesos:

Proceso común

Este bloque de tareas es el destinado a vigilar el buen funcionamiento del programa de usuario y que
no se produzcan errores en el hardware o el software, y para ello emplea el vigilante de
funcionamiento o watchdog, el chequeo cíclico de conexiones y el chequeo cíclico de memorias.

El vigilante de funcionamiento es un hardware específico interno a la unidad principal del PLC o
implementado sobre contadores internos especiales del autómata a los que no puede accederse ni
manipularse y que establece un tiempo máximo de refresco tras el cual, si no se ha recibido orden de
refresco convenientemente, detiene o resetea (según el modelo) la ejecución del programa. Para que
el funcionamiento del autómata no se vea afectado por el watchdog, va siendo refrescado
periódicamente, de modo que el watchdog no llega a dispararse. Pero si por algún problema no llega
a refrescarse, detendrá la ejecución. Algunos de los motivos que pueden provocar que salte el
watchdog son:

 Avería en la CPU o alguno de los periféricos.
 Error en la ejecución del programa de usuario o error en el propio programa de usuario
(como por ejemplo un bucle infinito del que no se pueda salir por no darse nunca la
condición de salida).
 Fallo de comunicación o fallo en la memoria interna.

En general, cualquier situación anómala que haga que la ejecución del programa de usuario se quede
bloqueada o que vaya extraordinariamente lenta provocará el salto de watchdog.

El chequeo cíclico de conexiones es un bloque de verificaciones encargado de comprobar:

 Estado de funcionamiento de los distintos buses internos y externos.
 Conexiones con los periféricos externos.
 Niveles de tensión de cada uno de los distintos bloques internos al PLC.
 Estado de la batería.

Como ocurre con el watchdog, en caso de encontrarse un fallo el autómata pasa a STOP, se visualiza
en los indicadores luminosos y se posibilita el acceso mediante la unidad de programación al código
de error concreto que ha provocado la parada.

El chequeo cíclico de memoria efectúa constantemente chequeos de integridad de memoria
(mediante verificaciones de cheksum o CRC), de mantenimiento de datos y de la corrección de las
instrucciones del programa de usuario.

Todo este proceso común de vigilancia suele tener un tiempo total de ejecución bastante breve, del
orden de 1 milisegundo.

Las verificaciones de integridad por CRC6 son más eficaces que las de CHECKSUM7, aunque más lentas
de computar, por lo que son las más recomendadas tanto en integridad de tramas de protocolos de
comunicaciones como en verificaciones de memoria.

Ejecución del programa de usuario

Este bloque de operaciones es el más importante de todos, ya que es el encargado de ejecutar el
programa de usuario sobre los datos de entradas y variables internas para generar las salidas
apropiadas y controlar la planta del modo requerido.

El tiempo de ejecución de este ciclo de operación dependerá de los siguientes factores:

 Tiempo de lectura de la interfaz de entrada y traspaso de variables a la memoria de imagen
de entradas.
 Tiempo de volcado del contenido de la memoria de imagen de salidas a la interfaz de salidas.

6 CRC: Verificación por redundancia cíclica.

7 CHECKSUM: Suma binaria o suma de verificación.

 Tiempo de ejecución del programa de usuario, que a su vez dependerá del número de
instrucciones que contenga, de su complejidad, de la potencia de la CPU que procesa dicho
programa y del número total de puntos de entrada y salida.

Los tiempos de lectura de la interfaz de entradas y de escritura en la interfaz de salidas dependen

enormemente de si dichas interfaces son locales (internas al propio cuerpo del autómata, como
ocurre en los autómatas compactos) o externas (bien sea a través de buses externos genéricos o
adosadas a la CPU a través de buses de ampliación dedicados). Estos tiempos pueden ser rápidos,
como menos de 1 milisegundo en caso de interfaces internas o buses específicos de alta velocidad a
alguna decena de milisegundos en el caso de interfaces de E/S externas a través de bus genérico.

El tiempo de ejecución del programa de usuario varía dependiendo del número de instrucciones y su
tipo, del tipo de CPU que lo procesa y de la existencia de coprocesadores que aligeren la labor de la
CPU en el caso de tareas específicas costosas en cómputo.

Cada tipo de instrucción de las que conforman el programa de usuario tienen un tiempo de ejecución
diferente. Son muy rápidas las instrucciones lógicas (AND, OR, etc.), más lentas las de manipulación
de datos y mucho más lentas las aritméticas. Cada fabricante proporciona una tabla de tiempos de
ejecución de cada instrucción, y es frecuente que el propio PLC pueda calcular el tiempo de ejecución
con un comando específico, como el RUNTIME de los S7.

Conexión con periféricos externos

Este bloque se ejecuta dentro del ciclo de operación cuando hay algún intercambio pendiente con un
periférico externo.

En los autómatas suele haber una conexión específica para conectar elementos concretos, como la
unidad de programación, visualizadores del propio fabricante o terminales de usuario específicos.
Esta conexión de alta velocidad no suele estar disponible ni para dispositivos de otro fabricante ni
para visualizadores de terceros fabricantes, ya que para acelerar el funcionamiento de esta conexión
se usan protocolos privados de los que no se dispone de información.

Además, los autómatas de gama media y alta disponen de uno o más buses de conexión con
periféricos externos, con protocolos estándar y bien documentados, lo que suele permitir la
interconexión de elementos de fabricantes diferentes al del autómata y brinda acceso a una infinidad
de accesorios con los que complementar el trabajo del PLC. La contrapartida de esta flexibilidad es
que normalmente estas conexiones son mucho más lentas que las internas del PLC y que las de sus
buses específicos.

Algunos de los buses de ampliación de periféricos externos más usuales son:

 Profibus.
 Profinet.
 Modbus RTU, Modbus TCP.
 CANopen.
 LONworks.
 DEVICEnet.
 EIB.

Mediante estos buses podemos conectar al PLC elementos como:

 Otros PLCs.
 Ordenadores industriales.
 Pantallas de distintos tipos.
 Impresoras.
 Interfaces para conexión de actuadores complejos, como variadores de velocidad para
gestión de motores eléctricos de alta potencia.
 Sensores avanzados.

Los tiempos de comunicación entre la CPU y estos dispositivos de campo puede ser del orden de 1 a
10 milisegundos.

A los buses de comunicación con la periferia remota suele denominárseles buses de
campo, haciendo referencia a que posibilitan el acceso a otros dispositivos
instalados en la planta en cualquier punto del campo de trabajo.

TOME NOTA

1.2.4. Chequeos del sistema

Ya se ha mencionado que el propio PLC incorpora rutinas de autochequeo en su programa interno,
almacenado en su propia ROM. Estas tareas de verificación, tanto del hardware como del programa,
pueden ser:

Tareas de verificación iniciales

Se ejecutan justo al iniciarse el PLC (al recibir la tensión de alimentación o al salir de un proceso de
reseteo).

Las tareas de autoverificación iniciales son:

 Comprobación de la CPU: verificación de watchdog, de microprograma y de memoria
interna.

 Comprobación de memoria de programa: comprobación de lectura, verificación de
integridad de programa de usuario (comprobación de checksum o CRC).
 Comprobación de estado de las interfaces de entrada y salida. Verificación de la conexión
con ellas y de su buen estado de funcionamiento y generación de la tabla de direcciones que
asigna a cada punto de entrada y salida su dirección correspondiente.

Tareas de verificación cíclicas

Se efectúan durante la ejecución del programa y están destinadas a asegurar la correcta ejecución

por parte del autómata programable del programa de usuario.

Las tareas cíclicas de verificación suelen ser:

 Verificación de funcionamiento del bus interno y de que la comunicación entre los distintos
elementos que une sea correcta.
 Verificación de funcionamiento de las interfaces de entrada y salida y de su correcta
comunicación con la CPU.
 Verificación permanente de la memoria de programa, y en particular del programa de
usuario.
 Verificación permanente del contenido de la memoria interna, chequeo de coherencia de
datos de registros y relés internos.

Cualquier error detectado en una de estas tareas de verificación se anotará internamente,
identificando el tipo de error localizado con un código de error propio de ese modelo de autómata.
Para ayudar en la localización y corrección de problemas, el fabricante proporciona una tabla de
identificación de errores en la que por un lado aparecen listados todos los posibles códigos de error
que pueden producirse y por otro muestra una descripción del error que lo produce. Finalmente,
suele incorporar una guía de corrección del posible problema que lo haya provocado.

Lo habitual es que, mediante un indicador luminoso, se visualice la presencia de errores.
Dependiendo de la gravedad del error localizado puede llegar a detenerse la ejecución del programa
y el PLC pasar a modo ERROR. De este modo se diferencian los errores entre Fatales (los que
provocan la parada de la ejecución) y No fatales (los que permiten que el programa de usuario siga
funcionando y no sacan al PLC del modo RUN).

Para identificar el error exacto, lo habitual es que conectar la unidad de programación, con lo que se
tiene acceso al código de error e información adicional como la fecha y hora en que se produjo.

En autómatas de gama media y alta, además de anotarse el código de error se cuenta con una
memoria histórica de errores detectados.

Errores más habituales

Los errores que se suelen producir más habitualmente son:

 Salto de vigilante de funcionamiento (watchdog) por no refrescarse cuando corresponde.
 Fallo de comunicación en el bus de campo.
 Fallo de comunicación con las interfaces de entrada y salida.
 Fallos de alimentación.
 Fallo de carga de programa de usuario.
 Valores fuera de rango en variables intermedias, contadores o temporizadores.

Las rutinas de chequeo descritas se ejecutan de forma automática e interna al PLC sin intervención
por parte del usuario. Además, algunos fabricantes proporcionan otras tareas de chequeo, incluso
más detalladas, que pueden ser ejecutadas bajo demanda mediante la unidad de programación.
Dichas tareas se efectúan con el autómata en modo STOP y permiten analizar a fondo el correcto
estado de funcionamiento de sus subsistemas hardware, así como la integridad del programa de
usuario y variables de memoria interna.

1.2.5. Tiempo de ejecución y control en tiempo real

En apartados anteriores se ha descrito las distintas tareas que componen el ciclo de operación así
como el tiempo necesario en completar cada una de ellas. Pues bien, al tiempo total de ejecución de
dicho ciclo de operación se le denomina “tiempo de ejecución de ciclo”, simplemente “tiempo de
ciclo” o scan time en inglés.

Este tiempo de ciclo es uno de los parámetros de funcionamiento del programa de usuario más
importantes y no solo depende del programa sino que también lo hace del autómata programable
donde se ejecuta.

En general, este tiempo de ciclo depende de:

 Tamaño (número de instrucciones) y complejidad del programa de usuario.
 Cantidad de puntos de entrada y salida requeridos.

 Tipo de interfaces de entradas y salidas (locales, remotas).
 Periféricos externos conectados.
 Modelo y prestaciones del autómata utilizado.

Tiempo de ejecución

En el apartado 1.2.3 se mostraron los bloques de operaciones que conformaban el ciclo de
operación, siendo el tiempo de ciclo el resultante de computar los tiempos necesarios para cada uno
de estos bloques de operación:

 Lectura de entradas: Operación muy rápida sobre interfaz de entrada local, del orden de 1 a
5 milisegundos si se tratan de interfaces externas. Más adelante comentamos los tiempos
requeridos por la interfaz para validar los cambios de estado de las entradas, aspecto
también muy importante.
 Ejecución de ciclo de programa. Muy variable, comentado a continuación.
 Carga de salidas. Nuevamente es una operación muy rápida sobre interfaz local, y
relativamente lenta sobre interfaces externas. El tiempo que tarda la interfaz en hacer eficaz
ese cambio sobre la señal de campo es importante y se desglosará más adelante.
 Actualización de datos de periféricos. Dependiendo de su número, tipo y bus de
comunicaciones empleado el sincronizar los datos con los periféricos externos puede
suponer un tiempo de entre 1 milisegundo y 20 milisegundos.
 Tareas cíclicas de autochequeo. Aunque es muy variable, podemos estimar una duración
típica para estas tareas de aproximadamente 1 milisegundo.

La duración de la ejecución del ciclo de programa es muy variable ya que depende de las
instrucciones exactas que se ordenen en el programa de usuario. El fabricante proporciona tablas en
las que se describe la duración exacta de cada instrucción, siendo las más rápidas las operaciones
lógicas y las más lentas las aritméticas. Haga clic en la imagen de arriba para ampliarla.

El tiempo de ejecución de cada instrucción individual puede ser del orden de microsegundos, y como
resulta complejo analizar una a una todas las instrucciones del programa de usuario para computar la
duración exacta, los fabricantes proporcionan un parámetro denominado “tiempo de escrutación”
que da una idea aproximada de las prestaciones del autómata y que se expresa en milisegundos de
tiempo de ejecución por cada mil instrucciones (ms/K). El fabricante para proporcionar este tiempo
de escrutación supone un reparto de instrucciones típico en un programa de usuario medio, lo que
da un valor orientativo sobre la duración estimada del programa de usuario sin tener que hacer el
análisis exhaustivo de los tiempos de operación instrucción por instrucción.

Valores típicos en autómatas de gama media pueden ser de entre 5 a 20 ms/K, aunque actualmente
los autómatas de gama alta pueden moverse en el orden de menos de 1ms/K. Haga clic en la imagen
de la derecha para ampliarla.

Una vez estudiado el tiempo de ciclo resultante, debe configurarse en el PLC una periodicidad de
ejecución cíclica algo superior al tiempo de ciclo esperado, para garantizar que en todo caso el ciclo
de operación se finaliza antes de que llegue el momento de iniciarlo de nuevo.

En un autómata de gama media este tiempo de ciclo para un programa de usuario típico puede ser
del orden de unos 20 milisegundos, mientras que en un compacto de gama baja puede ser del orden
de los 100‐200 milisegundos y por contraste en uno de gama alta se puede estar en el entorno de 1 a
5 milisegundos de tiempo de ciclo para un programa habitual.

Control en tiempo real

El control en tiempo real de una instalación supone el que seamos capaces de garantizar que ante
cualquier combinación de estados que se vaya a producir en la planta, nuestro sistema de control
reaccionará convenientemente antes de un plazo mínimo en cualquier circunstancia, plazo mínimo
que garantice el perfecto control sobre la instalación. Ese tiempo de reacción no solo mide el tiempo
de toma de decisiones del autómata, sino también el tiempo de actuación física de los actuadores
que reciben las órdenes de control desde el autómata.

Así que el concepto «control en tiempo real» no implica necesariamente que sea un control muy
rápido, ya que los tiempos de reacción necesarios pueden ser desde milisegundos en instalaciones de
procesos rápidos a minutos o incluso horas en sistemas de procesos lentos.

Cuando en la instalación que controlamos con el autómata programable hayan procesos rápidos que
necesiten de una actuación concreta sobre las salidas en tiempos cortos tendremos que evaluar muy
detenidamente el tiempo de ciclo de nuestra aplicación para garantizar que en todo momento se
proporcionan las respuestas de control a través de las actuaciones sobre las salidas que permitan un
buen funcionamiento de la planta.

Tiempos de respuesta de las entradas y salidas

Además de controlar estrechamente el cumplimiento de los tiempos de ciclo necesarios por la
aplicación, hay que analizar en profundidad los tiempos de respuesta de las interfaces de entradas y
salidas, ya que éstos son también muy variables e introducen retardos adicionales en el sistema.

En el apartado 1.1.5 se vio como existen diversos tipos de interfaces de entradas y salidas, en
distintos formatos eléctricos, y ahora analizaremos su repercusión sobre el control en tiempo real.

Las interfaces de entradas podían ser, a nivel eléctrico en el lado de campo, tanto de tensiones
continuas como alternas.

 Tiempos de respuesta de interfaces de entrada de señal continua. Estas interfaces
incorporan filtros de rechazo al ruido que introducen pequeños retardos sobre la señal
medida, digamos del orden de 1 a 5 milisegundos de retraso. Estos filtros de rechazo a ruido
son fundamentales en instalaciones industriales, y el retardo que introducen sobre el estado
de la señal se acumula al tiempo necesario para que el autómata acceda a la lectura
proporcionada por el interfaz de entrada.

 Tiempos de respuesta de interfaces de entrada de señal alterna. Estas interfaces, además

de incorporar un filtro de rechazo al ruido, cuentan con el hándicap propio del tipo de señal,
alterna, que se presenta como una senoide con ciclos propios del entorno de los 50Hz (es
decir, que cambian 50 veces por segundo según un patrón senoidal, lo que da un tiempo de
duración de cada ciclo del orden de 20ms). Pues bien, para poder asegurar si tenemos dicha
señal de entrada en estado Activo (“1”) ó inactivo (“0”) las interfaces de lectura de entrada
alterna tendrán que computar al menos un ciclo completo para identificar si está presente la
señal o no, lo que ya de por sí tiene una duración de 20 milisegundos. Esto, añadido al
filtrado de rechazo de ruido eléctrico proporciona un retraso de la señal leída del orden de
los 25 a 30 milisegundos. En la imagen siguiente puede ver cortes o microcortes de señal
alterna que no deberían considerarse como desactivaciones de la señal.

Por su parte, vimos que las salidas digitales podían ser del tipo salidas de relé, salidas de
colector común, salidas alternas con TRIAC o relés de estado sólido.

 Tiempos de respuesta de interfaces de salida de corriente continua. Las interfaces de salida
de colector común son muy rápidas, siendo sus tiempos de actuación inferiores a 1
milisegundo, con escasa diferencia del tiempo de conmutación del estado OFF al ON que del
cambio opuesto, del estado OFF al ON.

 Tiempos de respuesta de interfaces de salida alterna por relé estático. Las interfaces de
salida alterna por relé estático o TRIACs son más lentas, nuevamente penalizadas por la
naturaleza cíclica de la tensión alterna. Además, el funcionamiento de los semiconductores
que se utilizan en estas salidas, que precisan de un “paso por cero” de la señal alterna para
desactivarse por completo, hace que estas salidas tengan un tiempo de reacción mucho peor
en el cambio de estado ON a OFF, ya que el paso por cero que necesitan puede llegar a
tardar hasta 10 milisegundos (medio ciclo). De este modo mientras que los tiempos de paso
de OFF a ON pueden durar del orden de 2 milisegundos, los pasos de ON a OFF pueden durar
del orden de unos 12 milisegundos.

 Tiempos de reacción de interfaces de salida digital por relé. Estas interfaces tienen un
tiempo de actuación alto, debido a la naturaleza electromecánica del propio relé. Los
tiempos de actuación pueden estar en el orden de los 6 a 20 milisegundos. A continuación
vemos la distribución estadística de tiempos de operación en desconexión (más rápidas) y
conexión (más lentas) de un relé especialmente rápido. Nuevamente los relés con bobina de
corriente continua son más rápidos en operación que los de corriente alterna por los mismo
motivos comentados anteriormente para otras E/S (vea el gráfico de la imagen inferior
izquierda).
 Tiempos de reacción de interfaces de entrada analógicos. Por su parte, si el autómata
precisa manejar señales de entrada analógicas, las interfaces de entrada también pueden
tener un tiempo de lectura que puede llegar a ser considerable dependiendo del tipo de
convertidor analógico / digital (ADC, de “Analog to Digital Converter) utilizado. Los más
usuales de doble rampa tienen tiempos de lectura del orden de la decena de milisegundos,
mientras que si son de tipo SAR (Aproximaciones Sucesivas) o similares la duración de la
lectura se reduce a decenas de microsegundos de duración.

Finalmente, si la automatización también necesita el manejo de salidas analógicas, los convertidores
de tipo DAC (Digital to Analog Converter) tienen también un tiempo de conversión de la señal de
salida que puede llegar a ser del orden de decenas de milisegundos en los más lentos frente a
decenas de microsegundos en los más rápidos.

Tiempo de respuesta

Conocidos todos estos tiempos de reacción:

 Tiempo de establecimiento de señales de lectura tras su filtrado en la entrada de la interfaz
de entradas.
 Tiempo de ejecución de ciclo (que incluye el tiempo necesario para acceder a la lectura del
interfaz de entradas y el necesario para escribir los valores deseados de salida en el interfaz
de salidas).
 Tiempo de actuación de la salida de la interfaz de salida.

Se define como tiempo de respuesta el tiempo total entre que se presentan unos valores
determinados en las entradas y que se consiguen los valores de control apropiados en las salidas, que

será la suma de estos tres tiempos: tiempo de lectura de entradas + tiempo de ejecución de ciclo +
tiempo de establecimiento de salidas.

A la hora de computar el tiempo de respuesta tendremos en cuenta los peores valores posibles de
todas las interfaces de entrada y salida, de modo que el valor que obtengamos sea el
correspondiente a la peor situación y por tanto nunca sea excedido en la práctica.

Recuerde que el PLC efectúa una lectura del estado de las entradas a la memoria de imagen de
entradas, al principio de su ciclo de operación, y que aunque los valores de las entradas se
modifiquen posteriormente durante el ciclo de operación, el programa de usuario solo verá los
valores instantáneos que tenían en dicho momento.

Por este motivo el tiempo de respuesta del sistema de control no es el mismo en todo momento,
dependiendo muy fuertemente del momento exacto respecto a los ciclos de ejecución del autómata
en que se presenten los cambios de las señales:

 Si los cambios de las entradas se presentan justo antes del inicio del ciclo de operación, al

estar disponibles los cambios justo en el momento de hacer la copia de las entradas a la
memoria imagen, el tiempo de respuesta puede ser: tiempo de retardo de entradas + tiempo
de ciclo + tiempo de retardo de salidas.

 Sin embargo, si el cambio de entradas se produce un instante después del inicio del ciclo, el
programa de usuario no será consciente del cambio de dichas entradas hasta después de
terminar el ciclo de operación, comenzar el siguiente y cargar de nuevo la memoria de
imagen de entradas. Por tanto el tiempo de reacción es, en este caso: tiempo de retardo de
entradas + 2 * tiempo de ciclo + tiempo de retardo de salidas

En general debemos considerar este último tiempo, el peor posible, como el tiempo de reacción del
sistema para garantizar que en todo caso y como mucho ese es el tiempo que tarda el sistema en
reaccionar convenientemente a un cambio de entradas.

A la inversa del tiempo de reacción se la denomina frecuencia de conmutación, se mide en hercios e
indica el número de veces por segundo que pueden cambiar las entradas en la instalación,
consiguiendo el sistema de control reaccionar a tiempo convenientemente.

En relación con el tiempo de respuesta y su correspondencia con la frecuencia de conmutación vea el
siguiente ejemplo:

Tiempo de respuesta y frecuencia de conmutación

Un tiempo de respuesta de 33 milisegundos se corresponde con una frecuencia de
conmutación de Fcon=1/Tres=1/33 ms = 30 Hz. En general podríamos decir que este sistema
de control podría manejar instalaciones en que las entradas no cambien más de 30 veces por
segundo.

Aunque no se han tenido en cuenta en este cómputo, tanto los sensores de planta (los elementos
que leen las variables físicas y las presentan en valores electrónicos) como los actuadores (los
elementos que traducen las salidas a alteraciones de magnitudes físicas) tienen también sus tiempos
de lectura, conversión y establecimiento que tienen que ser tenidos en cuenta a la hora de computar
el tiempo de respuesta total.

Dependiendo del entorno de trabajo del autómata puede haber instalaciones con elementos de
actuación lentos, como electroválvulas, solenoides, relés, etc. que tienen tiempos de respuesta
relativamente lentos y frente a los cuales los tiempos de reacción de un moderno PLC son casi
irrelevantes, pero en otros entornos con actuadores modernos, control sofisticado de motores,
encoders de posición, etc. el tiempo de reacción del PLC llega a ser significativo.

Si el tiempo de respuesta del autómata es muy inferior a los tiempos de reacción de los procesos de
la instalación, decimos que el sistema de control es capaz de procesar en tiempo real dicha planta.

Para poder proporcionar control en tiempo real en entornos de actuadores y sensores cada vez más
rápidos, los fabricantes de autómatas van introduciendo funciones específicas en ellos para acelerar
los procesos más especiales funciones de proceso rápido como son: procesado rápido de programas,
contadores de alta velocidad y entradas detectoras de flanco.

1.2.6. Elementos de proceso rápido

Durante el manejo de una instalación nos podemos encontrar, entre otras, las siguientes
circunstancias que requieren de una respuesta muy rápida del autómata:

 Señales de entrada cuyas activaciones son muy breves, menores al tiempo de ejecución de
ciclo. Si no se implementa un manejo específico para esta situación, el comportamiento del
control frente a esta señal sería errático, ya que a menudo no sería ni siquiera detectada.
 Ejecución de bloques de programa que deban ser ejecutados con intervalos inferiores al
tiempo de ciclo resultante.
 Lectura de impulsos de alta frecuencia procedentes de sensores especiales que señalizan
valores mediante pulsos.

Para la lectura de señales de activación breve los autómatas pueden ofrecer la función de detección
de flancos en alguna de las entradas digitales. Esta función activa un relé interno que indica al
programa de usuario si alguna entrada ha cambiado de estado desde la última lectura. Al programa
le consta que se ha activado la señal, aunque desconozca el momento exacto, y reacciona en
consecuencia.

Por otro lado, para ejecutar bloques de programa con intervalos inferiores al tiempo de ciclo, los
autómatas pueden proporcionar funciones independientes al ciclo de operación con una estrategia
de temporización interna (ejecutándose cada vez que se dispare un temporizador interno) o bien por
disparo por interrupción (por ejemplo, ante el cambio físico de una entrada externa, analizada
directamente y no a través de la copia de la imagen de entradas).

Finalmente, para la lectura de impulsos de alta frecuencia no sería suficiente la estrategia de
detección de flancos, ya que con ella sabríamos que se ha disparado algún impulso, pero no su
número. Para solventar este inconveniente pueden utilizarse contadores de alta frecuencia.

En el siguiente documento puede ver, en inglés, una hoja de características de sensor de
temperatura con salida de impulsos:

1.2.7. Procesado rápido de programas

Los autómatas que incluyen la función de procesado rápido de programas permiten que algunos
bloques de programa sean ejecutados sin seguir el ciclo de operación estándar, de modo que los
bloques de programa pueden ejecutarse de dos formas diferentes:

Ejecución cíclica

Siguiendo el procesado cíclico descrito, durante el cual se ejecutan las instrucciones del programa de
usuario una tras otra en el orden que hayan sido programadas. Esta es la forma apropiada de
ejecutar el programa principal y la mayoría de los bloques de programa. El tiempo de proceso de la
ejecución de estos bloques de programa determina el ciclo de ejecución del autómata.

Ejecución rápida

Bloques de procesado rápido, normalmente rutinas cortas que se disparan para atender a un proceso
prioritario o crítico en el tiempo, y que no se ejecutan en un orden preestablecido en el programa de
usuario, sino como respuesta a algún evento específico.

Estos bloques de programa de procesado rápido tienen sentido fundamentalmente en la atención de
señales de entrada que precisen de una atención urgente por parte del PLC, por lo que en los
autómatas que implementan esta función también suele haber algunas entradas específicas para
procesado rápido. El autómata además hace un tratamiento especial de estas entradas,
denominadas entradas rápidas, ya que para acelerar su velocidad de reacción suelen estar menos
filtradas que las convencionales.

La combinación de entradas rápidas y bloques de programa de procesado rápido disminuyen mucho
el tiempo de reacción desde que cambian las señales en la instalación y se efectúa la tarea de control
mediante las salidas, lo que permite tiempos de reacción inferiores a 5 milisegundos en autómatas
de gama media y mucho menos en los de gama alta.

El ciclo de operación en estos autómatas queda un poco modificado, ya que se rompe su naturaleza
secuencial. Mientras que no se dispare la ejecución de ningún bloque de programa de procesado
rápido, el ciclo de operación se repite indefinidamente.

Sin embargo, en el momento en que se dispara la ejecución del bloque rápido se interrumpe la
ejecución secuencial del programa de usuario, se atiende la rutina o bloque de programa de
procesado rápido, se traslada a las salidas los cambios de salidas que haya determinado dicho bloque
de programa, y se continúa la ejecución del programa de usuario convencionalmente. Al final del
ciclo de operación se actualizará el estado de las salidas según determine el programa convencional.
Así que en este caso las salidas se habrán actualizado dos veces en el mismo ciclo de trabajo: en una

ocasión con los cambios producidos por el bloque de ejecución rápida, y con la aplicación de las
salidas producidas por el resto del programa de usuario.

El disparo de la ejecución de estos bloques puede ligarse a un suceso externo (típicamente la
activación de una entrada rápida) o bien a un suceso interno (reloj temporizador que la dispare
periódicamente cada tiempo prefijado, por ejemplo).

Sea producida la ejecución del bloque de procesado de una forma o de otra, el programa principal es
interrumpido para ejecutar el bloque rápido y continúa posteriormente la ejecución por el punto en
que fue interrumpido. Por tanto, aunque al dispararse estos bloques se acelera el tiempo de reacción
ante los eventos que atienden, el tiempo de ciclo de ejecución se alarga, ya que al tiempo de proceso
del programa convencional hay que añadirle el tiempo de ejecución de las rutinas de procesado
rápido tantas veces como se hayan ejecutado durante el mismo ciclo de operación. Es decir, que
puede empeorarse el tiempo de reacción de las entradas a salidas gestionadas por el procesado
normal a costa de conseguir ese mejor tiempo de reacción de las rutinas de procesado rápido.

Algunos autómatas permiten jerarquizar los distintos bloques de procesado rápido de modo que
cuando se dispare alguno de ellos se puede analizar si se está ejecutando algún otro de jerarquía
superior, y de ser así, se esperaría a su finalización para ejecutarse. Sin embargo, de no haber
ninguna rutina de jerarquía superior en curso en ese momento, se ejecutaría de inmediato.

1.2.8. Contador de alta velocidad

El seguimiento de señales extremadamente rápidas por parte de la CPU supondría una carga de
trabajo muy grande que ralentizaría la ejecución del programa de usuario. Para descargar a la CPU de
esa tarea, algunos PLC incorporan un hardware electrónico específico, los contadores de alta
velocidad, que son capaces de realizar el procesado de señales rápidas que necesitan de una
atención especial (por ejemplo, contabilizar el número de pulsos que emiten por unidad de tiempo).

Al igual que otros temporizadores y contadores, estos elementos son independientes de la CPU y
controlados por ella mediante el bus de comunicación interno. Acceden directamente a ciertos
terminales de entrada que reciben un tratamiento especial para esta función con un filtrado leve que
permite detectar impulsos muy breves que quedarían filtrados por una interfaz de entradas
convencional.

Una vez activada la función de conteo esta se desempeña de forma autónoma, contabilizando los
pulsos que se vayan detectando en las entradas correspondientes.

Puesta en marcha, parada y puesta a 0

Su puesta en marcha, parada y puesta a cero se ordenan desde la CPU mediante la activación
de relés internos (bits de control) en el mapa de direcciones correspondiente al control del
contador rápido. Una vez que está puesto en marcha, su valor de conteo vuelve a cero o bien
por la escritura de la CPU del relé interno de puesta a cero o bien por la activación externa de
una señal de entrada de reseto (señal Z).

Estos contadores pueden encontrarse tanto empotrados en el cuerpo de la unidad de control
principal como en módulos externos de ampliación.

El seguimiento de los valores de estos contadores puede hacerse o bien desde programa,
consultando su valor en los registros internos correspondientes, o bien mediante interrupciones que
disparan bloques de programa específicos cuando el valor de contador llega a unas marcas
prefijadas. Para la tarea de atención de los saltos de interrupción de contador rápido son idóneos los
bloques de programa de ejecución rápida, ya que normalmente el tratamiento de las señales de
contador rápido requieren de una pronta respuesta por parte del sistema de control.

Los contadores rápidos pueden ser de dos tipos:

Contadores rápidos unidireccionales

En estos tenemos una única entrada de pulsos de la que se van contabilizando con incrementos
positivos del valor de contador cada uno de los pulsos que emite.

Son típicas, por ejemplo, las señales que codifican un valor analógico en función del número de
pulsos por unidad de tiempo que emiten.

Contadores rápidos bidireccionales

En estos tenemos dos entradas de pulsos, pudiendo el valor de contador ir incrementándose o
decrementándose en función del estado de cada una de las entradas de pulsos. Podemos encontrar
estos funcionamientos:

 Dos señales de entrada de pulsos, una que incrementa el valor de conteo al emitir un
impulso (señal UP) y otra que decrementa el valor de conteo al emitir su impulso (señal
DOWN).
 Dos señales de entrada para control de pulsos, una que modifica el valor de conteo cada vez
que emite un impulso (señal PULSE) y otra que indica según su estado binario si la señal de
impulso incrementa o decrementa el valor en ese preciso momento.
 Dos señales de entrada de pulsos, que emiten trenes de pulsos desfasados 90º en el tiempo
(differential phase). Las dos entradas de pulsos suelen denominarse señal A y señal B. Este
tipo de entrada es muy habitual en el ambiente industrial, ya que es el tipo que emiten
numerosos codificadores de posición (encoders). Este tipo de entradas emite dos trenes de
pulsos, y dependiendo de la fase relativa de la señal A respecto a la señal B se incrementará o
decrementará el valor de conteo del contador.

1.2.8.1. Encoder de posición

Los encoder de posición, bien sean lineales o rotativos, dan una información precisa del
desplazamiento de una pieza respecto a su punto central de referencia (en el caso de los lineales) o
bien su ángulo de giro respecto a la dirección de referencia (la que marquemos como 0º, en el caso
de los rotativos).

Los encoders de posición giro pueden ser de tipo óptico o magnético ya que estos formatos evitan
desgastes, rozamientos y problemas con la suciedad que podrían darse en sensores de posición
basados en potenciómetros.

Un encoder rotativo tiene dos sensores de giro, instalados cada uno a 90º del otro, de modo que si el
eje gira en sentido positivo se activará primero la señal A y posteriormente la señal B, mientras que si
gira en sentido contrario primero se activará la señal B, y posteriormente la A.

Finalmente estos sensores cuentan con otro detector que se activa cuando el eje se encuentra
alineado justo en la dirección marcada como 0º o posición de referencia.

Conexión del encoder

La conexión de un encoder de este tipo al contador de alta velocidad descrito es directa, conectando
la señal de 0º del encoder a la señal de reseteo de contador (señal Z) y las señales de detección de
giro a las entradas A y B.

Cada vez que el eje pase por la posición de referencia el contador pasará a 0 y, a partir de ese
momento, cada pulso incremental emitido por el eje aumentará o disminuirá en una unidad el valor
de conteo (dependiendo de las fases relativas de las señales A y B) por lo que en todo momento
podremos leer en del contador rápido la posición actual del eje en base a las señales incrementadas
recibidas por el contador rápido.

Compatibilidad del encoder

Para asegurar la compatibilidad entre un encoder y el contador rápido de nuestro autómata
tendremos que detenernos a valorar las siguientes características:

 Tensión de trabajo de las señales del encoder (A, B, Z).
 Duración mínima de cada impulso emitido por el encoder.
 Frecuencia máxima de trabajo.

Las frecuencias de trabajo de los contadores rápidos pueden ir desde varios kHz en los de gama baja
a cientos de kHz en los de gama alta, siendo típicos valores de entre 10 y 50.

1.2.9. Entradas detectoras de flanco

A veces puede necesitarse que el autómata detecte señales que se activan durante un corto espacio
de tiempo, muy inferior a nuestro tiempo de ciclo de trabajo. Si el autómata dispone de contadores
rápidos y de bloques de programa de procesado rápido resulta sencillo detectar dichas señales y
reaccionar ante ellas:

 Se configura un valor de comparación de solo 1 unidad en el registro de valor de
comparación del contador.
 Se asocia el disparo de interrupción producido al alcanzarse dicho valor de conteo a un
bloque de programa de procesado rápido que atenderá la activación de dicha señal rápida.
 Se resetea el contador (paso a valor 0) y se activa.

De este modo, en cuanto se detecte una sola activación de la señal rápida se disparará la
interrupción, esté el ciclo de operación donde esté, y se ejecutará el código asociado al evento.

Sin embargo, no todos los autómatas disponen de estas prestaciones, así que sobre todo en los de
gama baja pueden estar disponibles señales detectoras de flanco que, aunque no de un modo tan
potente, permiten detectar la activación de señales muy rápidas. Las entradas detectoras de flanco
tienen un relé interno asociado que se pone a cero al inicio de cada ciclo de operación o bien a
demanda del programa de usuario.

Si la entrada detecta una activación de la señal en la entrada de una duración superior a la duración
mínima aceptada, se activará el relé interno señalizando que se ha detectado al menos una señal
rápida desde la última limpieza de dicho relé (típicamente borrado al inicio de cada ciclo de
operación, tras pasar su valor a la memoria de imágenes de entrada).

El autómata no tendrá posibilidad de diferenciar si en el mismo ciclo de scan (ciclo de trabajo) se
activa la señal rápida más de una vez, ya que la primera activación ya activa el estado del relé interno
correspondiente, y las posteriores lo dejan en el mismo estado de activación.

Nótese que al inicializarse el flag interno a cero al inicio de un scan, si durante ese ciclo de scan llega
un pulso ya no será detectado por el programa de usuario hasta el siguiente ciclo de scan, cuando
vuelva a traspasarse su valor a la memoria de imagen de entradas, por lo que la frecuencia máxima
de la señal rápida que podrá detectarse será la inversa del tiempo de ejecución de ciclo, del orden en
un autómata medio de los 50‐100 Hercios. Esta velocidad es insuficiente para trabajar con encoders
de posición como los descritos, por lo que el uso principal de estas entradas se reduce a la detección
de activaciones en señales cortas, que pasarían inadvertidas por el procesado convencional de las
interfaces de entrada.

1.3. Instalación y mantenimiento de autómatas programables

El entorno de trabajo de un PLC puede ser muy complicado, en condiciones eléctricas y ambientales
que pueden llegar a ser duras para una electrónica tan compleja, así que para garantizar el correcto
funcionamiento del control industrial hay que estudiar concienzudamente tanto el lugar donde se
instala, como el cableado y el diseño de las líneas de alimentación. En este tema se repasan de forma
somera estos aspectos fundamentales en la aplicación práctica de los PLC.

1.3.1. Introducción

Los autómatas programables son dispositivos diseñados expresamente para sustituir las antiguas
instalaciones de maniobra y control industrial de lógica cableada, implementadas en base a
dispositivos electromecánicos como relés, interruptores y cableado físico de señales, por lo que su
campo de aplicación primordial es el industrial.

Dentro de este ambiente de trabajo, los autómatas programables suelen utilizarse para controlar
maquinaria, motores y todo tipo de automatismos, por lo que físicamente suelen instalarse en el
entorno cercano a esa maquinaria pesada que puede trabajar con altos niveles tanto de tensión
como de corriente eléctrica. Este ambiente puede ser ruidoso eléctricamente, pero además con
temperaturas elevadas, humedad y polvo en suspensión.

Los autómatas programables no dejan de ser sistemas

electrónicos microprocesados con multitud de subsistemas
electrónicos, todos ellos sensibles a fluctuaciones de
alimentación o interferencias eléctricas en sus líneas de
alimentación, datos y direcciones. Estos dispositivos deben
soportar ambientes de trabajo complicados, por lo que aun
incorporando los fabricantes filtros antirruido tanto en la fuente
de alimentación como en las interfaces de entrada y salida,
buses, etc., es importante que el diseñador respete unas reglas
que garanticen la seguridad en el funcionamiento del autómata en estos ambientes industriales.

Las fases de diseño y trabajo en las que tendremos que tener en cuenta estas normas básicas para
garantizar el funcionamiento seguro del PLC son:

 Fase de diseño
 Fase de instalación
 Fase de explotación

Si quiere ampliar información sobre lógica cableada, lea el siguiente artículo.

1.3.2. Fase de proyecto con autómatas programables

Durante la fase de proyecto, que condiciona el funcionamiento posterior del sistema, se decide qué
tecnologías adoptar, con qué topología instalar los elementos, las líneas de cableado idóneas, se
estudia la planta para decidir dónde instalar cada elemento, etc. Justo en esa fase se dispone de
multitud de posibilidades y es cuando el coste para resolver un problema o modificar un elemento es
más bajo. Conforme vaya avanzando el proyecto y se llegue a la fase de instalación, cualquier
problema que haya que resolver con elementos ya comprados y en fase de instalación es mucho más
costoso. Además, una vez iniciada la instalación, las posibilidades de sustitución van siendo más
limitadas por los condicionantes impuestos por el resto de la instalación. Esto se agudiza mucho más
en la fase de explotación, cuando resolver cualquier problema es complicado y costoso y las
posibilidades de modificar un elemento que no se haya mostrado idóneo son ya muy reducidas.

Etapas de la fase de proyecto

Anteproyecto

En esta fase se debe:

 realizar el estudio de la instalación que se desea gobernar,
 especificar los accionamientos que se van a utilizar,
 determinar la obra civil que haya que realizar,
 intentar prever las condiciones de funcionamiento futuras,
 definir un esquema gráfico (GRAFCET) del proceso global y
 analizar las condiciones de paro, marcha y los cambios que puedan producirse entre
dichas condiciones (guía GEMMA).

Operaciones

En esta fase del proyecto habrá que:

 definir la planta o instalación que se vaya a controlar y
 proyectar tanto la planta como la interrelación que pudiese existir con otras plantas o
procesos anexos.

Control

En esta fase se deben:

 escoger los sensores y actuadores requeridos en la instalación,
 elaborar el esquema gráfico (GRAFCET) de la parte de control,
 revisar la guía GEMMA (análisis de estados de paro, marcha, error, alarma y transiciones
entre ellos) del control,
 determinar el número de entradas y salidas necesarias,
 elegir el autómata programable apropiado y sus periféricos,
 analizar la posible conexión con otros autómatas u ordenadores presentes en la
instalación,
 asignar las entradas y salidas con sus sensores y actuadores correspondientes,
 esbozar en líneas generales el programa de usuario y, finalmente,
 elaborar la documentación y el pliego de condiciones de instalación.

En aplicaciones de control sencillas la elección del autómata programable adecuado es simple. Es
habitual escoger autómatas compactos de gama baja, normalmente sobrados de prestaciones para
controlar plantas sencillas. Dentro de esta gama baja hay una amplia oferta de modelos. A veces los
fabricantes venden esta gama bajo la denominación comercial relé programable. Sin embargo,
cuando la planta tiene una dificultad media o alta, la elección del autómata no es trivial y hay que
tener en cuenta como mínimo los siguientes aspectos:

Aspectos a considerar para elegir un autómata en una planta difícil

 Análisis en profundidad de todos los elementos de la instalación: partes eléctricas,
electromecánicas, hidráulicas, neumáticas, etc.
 Prestaciones necesarias para el correcto control de la planta, haciendo especial hincapié en
la velocidad de los cambios de señales y en los tiempos de respuesta necesarios para
conseguir un buen funcionamiento del sistema de control.
 Condiciones de trabajo ambientales: temperatura, humedad, polvo en suspensión, etc.
 Análisis de la parte de alimentación eléctrica y su
topología. Distancia de los elementos electrónicos a las
fuentes de alimentación, una fuente común o una para
cada agrupación de elementos, presencia de
perturbaciones eléctricas en las líneas, separación de
líneas de mando y control de las líneas eléctricas de
potencia y otras fuentes de interferencia
electromagnética, etc.
 Elección del tipo de señales ideales para las interfaces de
entrada y salida (tensión de trabajo, tipo de corriente,
modo tensión o corriente) teniendo en cuenta el tipo de

sensores y actuadores, distancia de ellos hasta las tarjetas de entradas y salidas, tipo de
cableado y perturbaciones electromagnéticas esperadas en el trazado de dicho cableado.
 Estudiar las posibles ampliaciones de la planta o del sistema de control para instalar
automatismos que dejen suficientes entradas y salidas de reserva, o espacio libre para
montar tarjetas de ampliación para atender necesidades futuras.
 Analizar las funciones que deba ejecutar el PLC y cuáles será preferible que se ejecuten por
maniobras tradicionales, bien en exclusiva o bien en redundancia con el control del PLC. Una
función típica que suele encomendarse a maniobras cableadas puede ser la de activación de
paradas de emergencia, donde suelen instalarse pulsadores de emergencia que por simple
maniobra eléctrica independiente del PLC detienen todo el proceso, incluso en situación de
fallo o bloqueo del autómata.

Una de las decisiones más importantes a tomar en la fase de proyecto es la topología del sistema de
control deseado: centralizado en un autómata o distribuido entre varios, interfaces de entrada y
salida concentrados en un punto o distribuidos por distintas zonas de la instalación, formato de
interconexión entre los distintos elementos (por red, por bus). Estas decisiones dependen del
número de entradas y salidas que se deban utilizar y su distribución espacial a lo largo del área de
trabajo en la instalación.

Como resultado de esta fase de proyecto se debe elaborar una documentación lo más detallada
posible con el pliego de condiciones de la instalación. En esta documentación se deben comentar
aspectos como la distribución de los puntos de toma a tierra, el cableado recomendado para cada
tipo de línea (alimentación, señales de bus, señales de entrada/salida), los cables que deban ser
apantallados, las cogidas de las pantallas de los cables, la ubicación de las fuentes de alimentación,
los puntos de entrada/salida que deban ir aislados galvánicamente, las conducciones por las que
deben ir los cables de potencia y los de señal, la envolvente donde debe ir alojado el sistema de
control, el diseño de la ventilación de estos elementos, etc.

A modo de ejemplo, puede consultar el siguiente catálogo con una amplia gama de relés
programables:

1.3.3. Selección del autómata

Para seleccionar un autómata, una de las decisiones que se deben tomar es qué fabricante utilizar.
Cada marca dispone de un amplio espectro de soluciones con las que cubrir desde las instalaciones
sencillas a las complejas, así que no suele ser un factor determinante a la hora de decantarse por una
u otra. El servicio técnico postventa que ofrece cada uno, la atención comercial en nuestra zona o

sobre todo el estar habituado a manejar las herramientas de desarrollo de un fabricante pueden ser
los factores que nos harán escoger un fabricante u otro. En general, una vez dominado el entorno de
trabajo de un fabricante es poco recomendable cambiar de un proyecto al siguiente, ya que el bagaje
adquirido es fruto de un arduo proceso que debemos optimizar. Así que la selección del autómata
consistirá fundamentalmente en determinar qué gama de modelos es la apropiada para el control de
la planta y cuál se adapta mejor a la disposición física de las distintas entradas y salidas.

No se debe abordar la selección del autómata hasta no tener claros otros puntos importantes en esta
fase de proyecto, como son el número de entradas y salidas, la ubicación idónea para cada periférico
de ampliación y los tiempos de reacción necesarios para el gobierno de la planta. Una vez aclarados
estos puntos, los detalles que tendremos que analizar serán:

CPU

El tipo de CPU necesaria para la aplicación dependerá fundamentalmente de:

 el tiempo de reacción requerido para el control de la planta,
 si podemos trabajar con un autómata compacto (en el que la CPU y las entradas y salidas
están integradas en el mismo módulo),
 si necesitaremos periféricos externos (tarjetas de entradas y salidas remotas) o
 si será suficiente con una sola CPU o habrá que contar con varias, destinadas a tareas
específicas y comunicadas entre sí.

Software

Tiende a menospreciarse el coste de elaboración del software, pero suele resultar incluso superior al
del hardware.

Debe escogerse un autómata que disponga de las herramientas de programación adecuadas
para implementar de forma sencilla el programa de usuario deseado.

Son de agradecer los lenguajes de programación de alto nivel para implementar los cómputos y
algoritmia y las plataformas de programación mediante diagramas de contactos y GRAFCET para
implementar las relaciones secuenciales entre elementos y bloques de programas

Interfaz de usuario

Es importante determinar las necesidades de interacción entre los usuarios finales y la aplicación.

El programa de usuario suele funcionar por sí mismo, sin la intervención de ninguna persona, pero es
importante aclarar qué parámetros podrán cambiar o qué actuaciones directas podrán efectuar los
usuarios sobre el programa.

Es recomendable proyectar un boceto de la interfaz de usuario prevista: qué visualizadores utilizar,
qué terminales o consolas de configuración usar, etc., siempre con la perspectiva de que el sistema
pueda ser utilizado, parametrizado y manejado por alguien que no tiene por qué ser un experto en
automática.

Entradas y salidas

Las interfaces de entrada y salida son elementos cruciales en la implementación de un sistema de
control por autómata programable.

Uno de los primeros parámetros que deben establecerse en la fase de proyecto es el número
total y tipo de entradas y salidas necesarias, así como las que se deban dejar de reserva para
futuras ampliaciones.

El número de entradas y su tipo determinará dónde debemos ubicar cada una de las tarjetas de
entrada y salida en caso de no ser suficiente con un autómata compacto, que incluye las E/S en
el propio cuerpo de la CPU.

Además habrá que determinar el tipo de tensión que manejarán, voltaje de trabajo, tensión
alterna o continua, salidas por relé o por colector abierto, etc.

1.3.4. Fase de instalación

Los autómatas programables nacieron para sustituir las maniobras tradicionales cableadas, y aunque
es cierto que han mejorado enormemente la funcionalidad, comodidad de diseño, prestaciones y
mantenimiento posterior de las instalaciones tradicionales, hay algún aspecto concreto, como la
robustez de funcionamiento, en la que no pueden alcanzar del todo la obtenida por la automática
tradicional.

Esto se debe a que todos los elementos de nuestra instalación de control basada en autómatas
programables (CPU, tarjetas de memoria, tarjetas de entrada, de salida, interfaces de bus, etc.) son
sistemas electrónicos complejos que funcionan internamente con bajas tensiones de alimentación
que no pueden funcionar a temperaturas fuera de su rango de trabajo y que necesitan para su
correcto funcionamiento una gran limpieza eléctrica en las alimentaciones internas, señales bien
filtradas y sin sobretensiones en las entradas y consumos bien limitados en las salidas. Esta
complejidad frente a la simpleza electromecánica de un relé o interruptor hace que el conjunto de la
instalación sea más susceptible de tener problemas de funcionamiento si no se dan las óptimas
condiciones de trabajo.

Sin embargo, con un correcto análisis de las especificaciones de trabajo publicadas por los
fabricantes y siguiendo una lógica de prudencia en cada uno de los aspectos de la instalación desde

la fase inicial de proyecto se pueden conseguir sistemas

muy robustos y casi totalmente libres de errores de
funcionamiento.

Se analizarán en detalle algunos de los puntos importantes
a tener en cuenta para conseguir ese comportamiento
robusto imprescindible en el control de cualquier planta.

1.3.5. Fijaciones y condiciones mecánicas

El autómata y todo el conjunto de periféricos que necesite deben estar fijados en paneles o armarios
eléctricos firmemente y a ser posible alejados de elementos mecánicos o electromecánicos que
puedan transmitirles vibraciones o golpeteos al trabajar. Si fuese necesario, se pueden instalar
elementos elásticos de fijación para reducir los posibles niveles de vibración.

Todos los elementos de control deben estar instalados de forma que no soporten tensiones, pesos o
esfuerzos.

Es importante cuidar también que no sea el propio cableado el que genere tensiones sobre las
bornas de los distintos elementos y por extensión sobre su propia estructura. Para ello se dispondrá
el cableado con los elementos de guiado convenientes para que la llegada a las bornas se haga sin
tensiones y en un ángulo de entrada correcto.

Hay que asegurarse de que ninguna de las rejillas de ventilación quede tapada ni por el cuerpo de
algún elemento ni por el propio cableado.

1.3.6. Espacios de ventilación

Deben respetarse siempre las indicaciones del fabricante respecto a los espacios de ventilación,
especialmente críticos en los elementos que precisen de ventilación forzada (la que requiere
ventiladores para mantener las temperaturas de trabajo de la electrónica dentro de su rango de
trabajo tolerado).

En las indicaciones del fabricante se detalla el espacio libre que se debe dejar en cada una de las
direcciones, espacio necesario para que el flujo de aire caliente procedente del dispositivo pueda
evacuarse convenientemente.

En el diseño de un cuadro eléctrico con mezcla de elementos de potencia y de control hay que tener
siempre en cuenta que por la naturaleza propia del aire caliente éste siempre tiende a subir por
convección, por lo cual no es recomendable instalar los elementos de control en la parte alta del
armario eléctrico, y mucho menos instalarlo justo sobre elementos de potencia que puedan adquirir
una importante temperatura de trabajo (transformadores de alimentación, controladores de
motores, etc.).

Una parte importante de la ventilación del cuadro es el diseño de las ranuras, aberturas o incluso
ventilación forzada que pueda incluir la propia envolvente del cuadro, imprescindible para poder
evacuar el calor generado por los elementos de su interior.

Amplíe información sobre modelos de rejillas y ventiladores para armarios eléctricos pulsando el
siguiente enlace.

1.3.7. Distancias de seguridad eléctrica

Para garantizar el aislamiento eléctrico entre circuitos deben respetarse las distancias de seguridad
eléctricas entre las partes sometidas a tensión. Dependiendo de la norma que se siga, las distancias
de seguridad eléctrica pueden variar algo, pero como mínimo de referencia deberían respetarse las
distancias de seguridad de la siguiente tabla, extraídas de la norma VDE de 1997.

La línea de fuga indica el camino de separación entre el conductor activo y un
conductor conectado eléctricamente a tierra.

TOME NOTA

En un ambiente limpio, donde se espera una muy baja sedimentación de polvo y suciedad con el
paso del tiempo, se puede trabajar con menores distancias de seguridad entre conductores que en
un ambiente sucio, donde la combinación del polvo acumulado junto con la humedad puede
producir conducción de corriente entre conductores que deberían estar aislados.

1.3.8. Condiciones ambientales

Debemos considerar las condiciones ambientales en las que va a trabajar el autómata si queremos
garantizar su correcto funcionamiento durante mucho tiempo, ya que pueden provocar un
envejecimiento prematuro del aparato y acortar su vida útil. Las condiciones ambientales que más
afectan a los dispositivos electrónicos son las climáticas, el ruido electromagnético y la suciedad
ambiental.

Condiciones climáticas

Actualmente, los rangos normales de utilización de los autómatas industriales programables son los
siguientes:

Rango de temperaturas de uso

Para productos industriales es común un rango de temperaturas de uso de entre 0º y 55ºC. En
productos especiales, este rango puede extenderse hasta menos de ‐20º y más de 70ºC. Para
trabajar de forma segura hay que tener muy en cuenta las indicaciones de montaje del fabricante,
respetando las distancias de ventilación estudiadas.

Es importante destacar que si el autómata está instalado en el interior de un armario eléctrico, este
debe disponer de conductos de aireación e incluso ventilación forzada por ventiladores para
garantizar esa temperatura de uso en el interior del armario, siempre superior a la ambiental,
máxime si incluye elementos que disipen mucha potencia.

Humedad relativa

Es habitual que los dispositivos soporten una humedad ambiente
del 90 % siempre que esta no llegue a condensar.

En el caso de que se puedan alcanzar humedades ambiente
superiores o que exista riesgo de condensación, se deben
disponer sistemas de caldeo que eviten la condensación de
agua, que sería nefasta para la electrónica del autómata o
sus periféricos.

Normalmente es el propio PLC el que controla el funcionamiento del sistema de caldeo mediante un
sensor de humedad conectado a una de sus entradas y una resistencia de caldeo controlada por una
de sus salidas.

Emplazamiento

No instalar los dispositivos a la intemperie ni bajo la acción directa de los rayos de sol. Salvo contados
casos, la mayoría de los autómatas no son herméticos y tienen grados de protección IP bajos.
Siempre habrá que proporcionar el grado de protección adecuado con algún tipo de envolvente
mecánica.

La norma IEC 60529 indica cómo clasificar los grados de protección proporcionados por las
envolventes que resguardan los materiales eléctricos.

Para ello, se utiliza el índice de protección IP:

 El primer dígito está relacionado con la resistencia ante sólidos en una escala del 0 al 6.
 El segundo dígito expresa la resistencia ante la entrada de líquidos en una escala del 0 al 8.

En la imagen mostrada en el apartado 1.3.6 vemos que el autómata SIEMENS S7‐
1200, por construcción interna, soporta 10º C más de temperatura cuando se
instala horizontalmente que cuando se instala verticalmente: es importante leer
atentamente las recomendaciones del fabricante.
TOME NOTA

Suciedad ambiental

No deben instalarse los autómatas ni sus periféricos en ambientes como los descritos a continuación,
y si inevitablemente tuviese que ser así, se tomarán las medidas oportunas para proteger los
dispositivos mediante las envolventes mecánicas que sean necesarias.

Polvo en suspensión

En un ambiente con polvo en suspensión o, peor aún, martículas metálicas en suspensión, hay que
instalar los dispositivos en armarios cuyas rendijas de ventilación estén protegidas con filtros
apropiados para la polución ambiental presente.

Vapores y gases

En ambientes con vapores de cualquier tipo o con gases corrosivos las envolventes mecánicas usadas
deberían proporcionar un alto grado de aislamiento IP.

Salinidad

Ambientes con alta salinidad (por ejemplo, ambientes marinos).

Electromagnetismo

Campo electromagnético

Ambientes con campos electromagnéticos fuertes que pueden llegar a dañar los circuitos internos o,
más frecuentemente, provocar fallos de funcionamiento de la electrónica. Es importante no instalar
los dispositivos junto a grandes transformadores eléctricos, motores potentes, etc.

Ruido electromagnético

Denominamos ruido electromagnético a cualquier señal de interferencia de origen eléctrico, no
deseada, que pueda llegar a superponerse a nuestra señal principal, bien sea esta de alimentación,
de datos, digital o analógica. En los ambientes con campo o ruido electromagnético los armarios
eléctricos metálicos proporcionan un grado extra de protección al producir el efecto jaula de
Faraday.

En el caso de superponerse sobre señales analógicas, este ruido puede falsear las lecturas de las
señales de entrada o los valores de trabajo marcados por las salidas analógicas.

En el caso de las señales digitales, podrían llegar a alterar el valor leído, aunque por la propia
naturaleza digital de estas señales la interferencia tendría que ser muy potente para confundir un “0”
con un “1”.

Y finalmente en las líneas de alimentación el riesgo principal es que estas perturbaciones no puedan
llegar a ser bien filtradas por las fuentes de alimentación y se trasladen a las líneas de alimentación
internas de la electrónica, por ejemplo a los 3.3V internos con que puede trabajar una CPU, en cuyo

caso pueden producirse fallos de ejecución que terminen con el autómata detenido o en modo
ERROR.

1.3.9. Compatibilidad electromagnética

Para garantizar el buen funcionamiento de nuestro sistema basado en autómatas programables hay
que seguir unas normas de diseño que permitan un trabajo libre de problemas.

Compatibilidad electromágnética: conceptos fundamentales

Denominamos así —o EMC (Electromagnetic Compatibility)— al conjunto de conocimientos respecto
a la producción y traspaso de perturbaciones electromagnéticas de unos dispositivos a otros, así
como las técnicas de reducción de dichas perturbaciones.

Si alguna de estas perturbaciones llega a perturbar el funcionamiento de un dispositivo hablaremos
de interferencia electromagnética o EMI (Electromagnetic Interference).

En el mundo industrial, los principales emisores de perturbaciones electromagnéticas son los grandes
motores y los dispositivos de control electrónico de potencia asociados, como los variadores de
velocidad y las fuentes conmutadas de alta potencia. La alimentación eléctrica de estos dispositivos
genera fuertes alteraciones y campos electromagnéticos en su entorno. Además, son dispositivos
especialmente problemáticos a este respecto porque manejan altas corrientes y por su forma interna
de trabajo, en que las corrientes se conmutan a frecuencias muy altas (un MHz o más). La
combinación de estos factores produce mucho ruido eléctrico porque genera grandes perturbaciones
de alta frecuencia. Ambos son los factores que más favorecen la propagación a otros dispositivos.

Formas de propagación de las perturbaciones electromagnéticas

Por conducción

Este tipo de propagación de las perturbaciones electromagnéticas se produce sobre los propios hilos
eléctricos que unen los distintos elementos.

 Para reducir estos problemas en nuestro sistema habrá que cuidar con especial cuidado la
topología de líneas de alimentación. Es una buena técnica no compartir los mismos circuitos
eléctricos de alimentación entre los equipos más conflictivos y los dispositivos de control.
 Para mantener limpias las líneas de alimentación es posible instalar filtros de reducción de
ruido, habitualmente en cabecera, al inicio del circuito de alimentación.

 Para las entradas y salidas es buena práctica aislar las

conflictivas respecto a EMC.
 Para los buses de comunicación se recomienda aislamiento
eléctrico o usar en los conductores elementos como ferritas y
filtros de ruido que ayuden a disminuir la presencia de
perturbaciones en estas líneas.

Por acoplamiento inductivo o capacitivo

En este caso la perturbación se transfiere típicamente de conductores
de potencia que trasladan fuertes perturbaciones a cables cercanos de
señal o comunicaciones.

Para disminuir el acoplamiento de estas pertubaciones en nuestras instalaciones es importante guiar
separadamente, a ser posible por conducciones diferenciadas, las señales de entrada/salida y las de
buses de comunicación de las líneas eléctricas de potencia, especialmente de las que alimenten a
equipos problemáticos.

Por radiación

La propagación de perturbaciones electromagnéticas por radiación se da a larga distancia, y es
menos frecuente que pueda producir problemas en el ambiente de trabajo industrial del que
hablamos. La presencia de antenas emisoras de gran potencia sí que puede llegar a generar
problemas de radiación, aunque no sean elementos frecuentes en las instalaciones industriales
típicas.

Además de las causas artificiales de EMC hay que destacar entre las causas naturales las descargas de
electricidad electrostática y sobre todo las descargas eléctricas atmosféricas.

Es casi imprescindible en cualquier instalación industrial proteger las fases de
maniobra y control con descargadores de sobretensiones transitorias.

TOME NOTA

Guía orientativa para los acoplamientos

Instalando los filtros necesarios, separando convenientemente los circuitos y disponiendo las fuentes
de alimentación para reducir o eliminar las EMC conducidas por las líneas de alimentación, el
principal punto débil de nuestros sistemas de control respecto a las EMC será el acoplamiento entre
cables por efectos inductivos y capacitivos.

Como guía orientativa para enfrentarnos a estos acoplamientos podemos tener en cuenta los
siguientes parámetros:

 El acoplamiento capacitivo entre cables es inversamente proporcional a la separación entre
ellos, y directamente proporcional a la longitud en que ambos transcurran paralelos.

 El acoplamiento inductivo entre cables será inversamente propocional a la separación entre
espiras del cable emisor y el receptor, y directamente proporcional a la sección de espira que
forman el cable emisor y el receptor.
 Para ambos acoplamientos, éste será más intenso conforme mayor sea la frecuencia de la
señal interferente.
 El acoplamiento será tanto menor cuanto más cerca se encuentren los cables a un plano de
masa.
 Hay que mantener bien separadas las líneas de potencia de las de señales y comunicaciones.
 Si es posible, las líneas de potencia que alimentan equipos complejos respecto a la EMC
deben ir dentro de conducciones metálicas (bandejas, canaletas) puestas a tierra.
 Se recomienda usar cables de señales y comunicaciones apantallados, con su pantalla
metálica cogida a tierra en uno de los extremos.
 Es importante analizar la disposición de componentes en nuestros cuadros eléctricos para
minimizar el cruce de líneas de potencia con las de señal y comunicaciones.
 El mejor cable para disminuir los acoplamientos es el trenzado y apantallado, en el que cada
señal usa un par trenzado: el negativo y el positivo, aunque luego en un extremo se unan
todos los negativos del cable en un único negativo. El par trenzado, como va girando sobre sí
mismo, recibe alternativamente cada pocos centímetros las interferencias en un sentido y en
el contrario, por lo que estas tienden a anularse.
 Es recomendable usar señales analógicas del tipo 4‐20 mA frente a las de tensión 0‐10 V, por
ser más inmunes a las señales interferentes.

Amplíe información consultando la siguiente guía para la protección contra descargas atmosféricas:

1.3.10. Alimentación y protecciones

Ya hemos hablado de la importancia de que los equipos de potencia y los dispositivos de control no
compartan las líneas de alimentación. La forma más eficaz se separar estas alimentaciones es
utilizando un transformador de separación.

Lo ideal es usar un transformador con entrada de fase a fase (400Vca) y salida en 230Vca, para así
evitar conectarnos a la línea de neutro, ya que esta suele ser más ruidosa. De este modo, la línea de
secundario que usemos como “neutro” en el circuito de alimentación de control no será realmente el
neutro real, sino uno flotante.

Si se cuenta con un gran número de entradas/salidas o varios periféricos externos a la CPU principal
es recomendable utilizar una fuente de alimentación para la CPU y otra diferente para alimentar las
tarjetas periféricas.

En caso de disponer de tarjetas de ampliación externas, no conectadas directamente al cuerpo de la
CPU principal, si no remotas e incluso en cuadros independientes, es conveniente utilizar una fuente
de alimentación independiente instalada junto a esas tarjetas de ampliación, aunque la potencia de
la fuente principal fuese suficiente para alimentarlas a todas. Al distribuir la línea de alimentación en
230Vca, y de ella localmente alimentar a la periferia mediante una fuente de alimentación anexa a
las tarjetas de ampliación, reducimos la incidencia de las EMC acopladas a la línea de alimentación,
ya que la fuente de alimentación filtra notablemente dichas señales interferentes, que pasan muy
atenuadas a la alimentación de las tarjetas periféricas.

Consideraciones a tener en cuenta

Respecto a las protecciones necesarias para la línea de alimentación de autómata y periféricos,
debemos tener en cuenta lo siguiente:

 La instalación debe tener un interruptor automático general.
 Si desde este interruptor general hasta el autómata o periféricos tenemos líneas de más de 3
metros de longitud, estas líneas precisarán de un interruptor automático propio.
 Puede ser recomendable instalar filtros de supresión de ruido en la línea de alimentación, o
al menos en la línea que vaya a alimentar a la CPU principal.
 Se recomienda utilizar una fuente de alimentación adicional para las tarjetas de entrada /
salida, sobre todo si se instalan lejos de la CPU, en cuyo caso se recomienda una por cada
grupo de tarjetas que tengamos distribuidas por la instalación.
 Si tenemos numerosas tarjetas de salida cuyas salidas trabajen en 230Vca se recomienda
alimentar el circuito de salidas con un transformador independiente, de forma que aislemos
la alimentación de los dispositivos de control de las posibles derivaciones que puedan darse
en las líneas de salida.
 Normalmente la toma de tierra de toda la instalación de control estará unida a la toma de
tierra general de protección.
 Respecto a las líneas de salida de las interfaces de salida, también es interesante instalarles
protecciones extra para supresión de picos, sobretensiones o transitorios rápidos que
pueden generar EMC.

En el caso de las salidas de señal continua, típicamente de 24Vcc, es recomendable la instalación de
dos protecciones:

 Un diodo de protección frente a la inversión de la polaridad (D1 en la siguiente imagen), que
solo deja circular corriente desde la salida positiva hacia afuera, evitando dañar la etapa de
salida del interfaz si se produce un error de cableado. Esta protección es un simple diodo
montado en serie, con su ánodo cogido a la salida de la interfaz y su cátodo hacia la carga.
 Un diodo de libre circulación (freewheeling diode, D2 en la siguiente imagen) para la
protección de las sobretensiones generadas en la conmutación de elementos inductivos
como bobinas, relés o solenoides.
 Si no se protegen las salidas contra los picos de tensión que producen las bobinas al ser
desconectadas con un diodo de libre circulación, dichos picos pueden doblar la tensión
nominal de salida y romper la etapa.

Si las salidas de nuestras interfaces son de tensión alterna (típicamente serán de 230Vca), las
protecciones que se recomienda instalar para la protección de las interfaces de salidas son:

Varistor supresor de picos

Un varistor supresor de picos (V en la imagen, púlsela para ampliarla) que reducirá los picos de
tensión instantáneos que puedan darse durante la conmutación de la salida, evitando dañar a los
elementos de la etapa de salida de la interfaz (sobre todo en el caso de tratarse de salidas por TRIAC
o relé estático).

Filtro paralelo

Un filtro paralelo de tipo RC (resistencia + condensador) que reduzca la velocidad de los flancos de la
tensión de salida, disminuyendo la generación de EMC.

Escoja con cuidado la tensión de trabajo del varistor al menos un 15 % por encima
del valor de trabajo nominal de sus salidas.

TOME NOTA

1.3.11. Distribución y cableado interno del armario de control

Tras un análisis pormenorizado de la instalación se debe escoger la ubicación idónea para el armario
de control y de los armarios complementarios que pudiesen ser necesarios para alojar la periferia
(sobre todo si es distribuida).

Dicho emplazamiento tendrá en cuenta las consideraciones derivadas de lo mostrado en el apartado
1.3.9 sobre las EMC, y también las derivadas del análisis ambiental del mismo: cerca de conductos de

aireación, apartado de los rayos de sol directos, apartado de grandes
emisores de calor, vapores, polvo, posibles salpicaduras, etc. En
cualquier caso el armario debe disponer de la categoría de protección
IP necesaria para resguardar a los automatismos de las condiciones
climáticas insalvables.

Su emplazamiento también debe reducir la longitud de cableado de
señales hasta los sensores y actuadores, simplificando la instalación y
reduciendo las posibilidades de acoplamiento de ruido.

Analizada la potencia disipada dentro del armario, se estudiará la
necesidad de complementarlo con rendijas de ventilación natural o
incluso incorporarle ventilación forzada.

Dentro del armario en sí, también es necesario replantear la ubicación
de los distintos elementos, recordando los consejos del apartado 1.3.6
respecto a los espacios de separación para ventilación y teniendo en cuenta siempre que el aire
caliente fluirá por convección hacia arriba, evitando montar los elementos más delicados (como la
CPU) sobre elementos que vayan a desprender mucho calor. Es recomendable instalar los elementos
más delicados en la parte baja de los cuadros que generan mucho calor.

Cableado interior

Respecto al cableado interior, habrá que replantear la posición de los distintos elementos para
intentar evitar el acoplamiento de ruido electromagnético entre el cableado de potencia y el de
control, tal como se describió en el apartado 1.3.9. Especial cuidado hay que prestar al cableado de
potencia de equipos de alto consumo y electrónica conmutada de gestión de potencia. A ser posible,
el cableado de potencia destinado a dichos elementos debería conducirse por canaletas, tubos o
conducciones metálicas.

Los mismos criterios de protección descritos al hablar de cableado exterior debemos aplicarlos al
cableado interno al cuadro de control, usando de ser necesario cable trenzado y apantallado para las
señales más sensibles.

Los cuerpos de los equipos más conflictivos deben estar bien cogidos a tierra, al igual que todas las
partes del armario si es metálico. Especial cuidado hay que tener con las puertas, añadiendo tomas
específicas para ellas ya que en ocasiones podrían quedar aisladas eléctricamente a través de las
bisagras y juntas de goma. El cuerpo principal del armario debe estar unido a tierra con cable
desnudo.

1.3.12. Cableado externo

Para proyectar el cableado externo hay que tener

en cuenta básicamente las mismas normas de
diseño ya establecidas, con la salvedad de que por
ser el cableado externo a los cuadros de control
mucho más largos que los internos, son más
susceptibles de recibir interferencias, de modo que
hay que extremar el cuidado por los detalles.

Desde la salida del armario se deben agrupar los

cables por clases que luego deben ser distribuidas
juntas en la medida de lo posible.

Clases de cables que deben identificarse y agruparse

 Líneas de alimentación y salidas de potencia. Habitualmente monofásica 230Vca o

trifásica 400Vca.
 Cables de entrada y salida de baja tensión, habitualmente 24 Vcc.
 Cables de entrada y salida analógicas, preferiblemente en 4‐20mA.
 Cable de entrada de contadores rápidos.
 Cables de comunicaciones.

Cada clase de cable debe contar con sus propias canalizaciones independientes de las demás.

Los cables de alimentación y salidas de potencia deben distribuirse por el exterior preferiblemente
en conducción metálica, por ejemplo bandejas, canaletas o tubo metálicos.

Para cualquier señal, ya sea de salida, entrada, de potencia o de alimentación, debemos recordar que
la ida de corriente y la vuelta de dicha corriente discurrirá por hilos conductores diferentes, y para
minimizar la captación de interferencias por acoplamiento inductivo esos hilos de ida y vuelta deben
ir lo más juntos posible para reducir la espira de captación que forman entre sí, por ejemplo yendo
en el mismo cable. En el caso de los hilos de potencia, cuanto más cercanos estén entre sí más se
reducirá la emisión de EMC al disminuir el área efectiva de la espira que genera la ida y vuelta de
estas corrientes.

Para minimizar aún más tanto la emisividad como la captación de interferencias, el mejor cableado
será aquel en el que las señales de ida y retorno se monten sobre un par trenzado y donde el cable
que porte dichos pares vaya también apantallado.

Todas las pantallas metálicas de los cables deben tener, a ser posible, continuidad en las
bifurcaciones, bornas de paso, etc. y siempre que se pueda deben ir unidas a tierra en un solo
extremo. Si no fuese posible se intentaría acoplar eléctricamente las pantallas a la toma de tierra en
el extremo de planta a través de una inductancia. De este modo, frente a las frecuencias elevadas
(las que más fácilmente pueden generar perturbaciones) el inductor será un circuito abierto, por lo
que a efectos de dicha alta frecuencia la cogida de las pantallas solo se hace en un extremo.

1.3.13. Diseño e instalación del software

Como el programa de usuario es el que realmente gobierna el sistema de control, su correcto
funcionamiento es el punto crucial para garantizar el buen desempeño de la automatización.

Normas básicas

 Conseguir ciclos de ejecución totales del entorno de 100 milisegundos o inferiores para
lograr un control fluido de la instalación.
 Prever qué tareas ejecutará el autómata en exclusiva y cuáles serán o bien redundantes o
bien encomendadas directamente a un sistema externo al autómata, quizás con maniobras
tradicionales (como las paradas de emergencia) que garanticen que puedan activarse esas
operaciones de seguridad incluso en caso de fallo del autómata.
 Plantear una planificación gráfica de tipo GRAFCET desde la fase de diseño para el análisis del
sistema global.
 Analizar la guía GEMMA para tener bien previstos los distintos modos de marcha, paro, error
y las transiciones entre ellas que pensamos que puedan darse en la planta.
 Sacar partido de todas las herramientas de simulación que proporcione el fabricante del
autómata.
 Planificar el programa de modo que sea factible su chequeo de funcionamiento sin activar en
realidad las salidas de control de planta.
 Contar siempre con un tiempo de pruebas y ajustes de la instalación antes de su puesta en
servicio final y contar con dichos plazos en la planificación del proyecto.
 Generar una documentación lo más extensa y clara posible.

1.3.14. Fiabilidad de las instalaciones con autómatas

Cuando se plantean comparaciones de fiabilidad entre instalaciones controladas por autómata y por
lógica cableada es difícil que se haga teniendo en mente instalaciones realmente comparables, dado
que la llegada de los autómatas programables al mundo de la automatización ha tenido como efecto
secundario el aumento de la complejidad de las instalaciones. Dicha complejidad se traduce en un
programa de usuario más complicado, quizás un autómata un poco más rápido y algunas tarjetas de
E/S extra. Comparativamente, por motivos de dificultad física, las maniobras tradicionales eran
mucho más sencillas que las actualmente planteadas en base a los PLC.

Respecto a las averías más frecuentes en instalaciones controladas por autómatas industriales
programables, hay que destacar que la mayor parte se deben a factores externos al autómata, como
problemas de cableado, condiciones ambientales, sobretensiones, fallos de actuadores o sensores.
De las averías producidas por fallo del autómata en sí, la mayoría se deben a fallos en las interfaces
de entrada y salida, por ser los puntos de contacto con la planta y los que pueden, por tanto, recibir

más interferencias, sobretensiones, sobrecorrientes y en definitiva condiciones de trabajo anómalas.
Un pequeño porcentaje, achacable al autómata en sí, se debe a fallos en las memorias, buses
internos, fuente de alimentación interna o la propia CPU.

Dentro del ámbito de lo que denominamos fiabilidad podemos diferenciar tres conceptos para
entender qué podemos esperar de una instalación con autómatas:

Fiabilidad

Valor estadístico que indica la probabilidad de que un equipo se averíe a lo largo del tiempo.

Para computarla habría que ensayar un gran número de equipos, incluso diferentes lotes, durante un
largo periodo y determinar la tasa de averías dividiendo el número de equipos averiados entre el de
equipos testados.

La cifra también puede extraerse en función del tiempo transcurrido desde su fabricación. En
equipos electrónicos, esta representación siempre da como resultado la denominada curva de la
bañera por su aspecto característico: curva decreciente abrupta en el primer tiempo de vida del
dispositivo, meseta que se mantiene cierto tiempo con valor muy bajo y de nuevo una subida muy
pronunciada al final de la vida útil del dispositivo.

Las fases bien diferenciadas de esta gráfica se corresponden con estos estadios:

 Fase inicial de averías prematuras. Esta fase inicial, de alta tasa de fallo, se debe a
problemas de materiales o de montaje, que se manifiestan sobre todo al principio de la vida
útil del producto. Los fabricantes aplican diferentes técnicas para disminuir esta tasa
efectuando tests intensivos (sometiéndolos a vibraciones, cambios de temperatura,
temperaturas extremas) antes de ser vendidos. El objetivo es que cualquier fallo de montaje
(soldadura fría, mal contacto, componente defectuoso) se manifieste en esa fase interna al
fabricante y no después de ser comercializado. La mayor parte de estas averías prematuras
deberían ocurrir dentro de los periodos de garantía.
 Fase de averías normales. Es la fase que debe cubrir el tiempo de uso principal del equipo.
Una vez superado el umbral en que se averían los equipos que tuviesen fallos de fabricación
o montaje debe mantenerse en un nivel relativamente bajo durante mucho tiempo. Durante
esta fase los fallos se suelen deber a circunstancias ajenas al equipo o al fallo aleatorio de
componentes dentro de su vida útil, que debe ser una tasa muy baja.
 Fase de averías por envejecimiento. Durante esta fase los componentes del dispositivo
electrónico van deteriorándose hasta llegar a unos límites que los van haciendo fallar
progresivamente. En los autómatas los elementos más sujetos a trabajo delicado suelen ser
las interfaces de entrada y salida, porque están en contacto con las señales de planta, que
pueden acarrear sobretensiones, picos de corriente, interferencias, y además, en el caso de
las salidas, pueden manejar potencias eléctricas más elevadas que el resto de elementos, lo
que incide en que su envejecimiento pueda adelantarse al de los elementos de control.

Disponibilidad

Antes de describir qué es la disponibilidad vamos a conocer dos unidades estadísticas en la
explotación de cualquier equipo: el tiempo medio antes de fallo (MTBF) y el tiempo medio de
reparación.

 Se denomina tiempo medio antes de fallo (MTBF, Mean Time Before Failure) al promedio de
los tiempos en que un equipo está en funcionamiento entre que se produce un fallo y el
siguiente; a veces se considera en el cómputo de este valor estadístico el tiempo de parada
por mantenimiento preventivo como un fallo, aunque en realidad no lo sea.
 Se denomina tiempo medio de reparación (MTTR, Mean Time To Repair) al tiempo que de
media tarda el equipo en tener reparada su incidencia y por tanto lo que tarda en volver a

ser productivo. Nuevamente puede computarse esta cifra considerando las paradas de
mantenimiento preventivo o no.

Pues bien: se define la disponibilidad como el porcentaje de tiempo total de uso del equipo durante
el que está en estado productivo, y se computa como:

Disponibilidad = MTBF / (MTBF + MTTR)

Este indicador se mueve de 0 a 1, donde 1 es un sistema que está disponible todo el tiempo.

Cada vez que se produce un paro por avería o mantenimiento preventivo resulta útil ir calculando de
nuevo la disponibilidad real del dispositivo para intentar planificar el mantenimiento preventivo en
función de este valor y así intentar evitar la avería.

Seguridad

Antes de definir este concepto comenzaremos diferenciando las averías o fallos en averías peligrosas
o activas y averías no peligrosas o pasivas.

 Llamamos averías peligrosas o activas a aquellos fallos que al producirse pueden poner en
peligro la integridad de la instalación o, peor aún, de las personas. Desde la perspectiva del
PLC, aunque no sea cierto al 100%, puede interpretarse que una avería puede ser peligrosa
cuando el automatismo activa una salida cuando no debería hacerlo (de ahí la denominación
de “activa”).
 Por otro lado llamaremos averías no peligrosas o pasivas aquellas que no suponen, al
producirse, ningún efecto peligroso para la instalación ni las personas, sino que implican que
no se hace algo cuando debería hacerse. Nuevamente trasladando esa interpretación al
mundo de la automática esta avería se correspondería con no activar una salida cuando
debiera hacerse (de ahí el término “pasiva”).

Obviamente esta categorización no es correcta al 100%, porque dependiendo de la maniobra y de los
actuadores, no activar una salida en el momento correcto puede llegar a ser tan peligroso como
hacerlo a destiempo.

En función de estas definiciones, denominamos seguridad de un automatismo a:

Seguridad = 1 – número de averías activas / número de averías totales

El valor de seguridad se mueve entre 0 y 1, correspondiéndose el valor 1 con una instalación
absolutamente segura: es decir, aquella en la que ninguna de las averías que se produce genera un
problema de seguridad.

Una instalación totalmente segura no es aquella que no se avería nunca, sino la que
nunca tiene averías peligrosas.

TOME NOTA

Para conseguir sistemas de control lo más seguro posible se pueden incorporar al programa de
usuario técnicas de autoquecheo que bloqueen el programa de usuario en caso de localizar un
problema, implementar controles redundantes o chequear en todo caso las actuaciones de las
salidas conectándolas a entradas. Nótese que en algún caso podrían incluso empeorar la
disponibilidad (aumentando el número de incidentes), pero mejorarían la seguridad.

Amplíe información viendo la siguiente presentación con diapositivas sobre los tiempos medios de
reparación de fallos en autómatas programables:

1.3.15. Mantenimiento de instalaciones con autómatas

Las intervenciones de mantenimiento pueden ser de dos tipos: correctivo (el necesario para corregir
una avería imprevista) y preventivo (el que se efectúa sin que se haya producido una avería, según un
plan prefijado y establecido que precisamente pretende minimizar la aparición de averías en base a
un correcto estado de mantenimiento de la instalación).

Mantenimiento general

En el apartado anterior mostramos una distribución aproximada de las distintas averías en un
sistema de control por autómata programable y su origen. Esa distribución nos da una pauta en
cuanto al repuesto que debe preverse tener incluso en stock para solventar de forma rápida los
problemas más probables.

Además de esto debe existir documentación a pie de máquina que describa cómo proceder en casos
de emergencia. Otra documentación interesante que debería estar disponible en el interior de cada
armario de control son los esquemas unifilares del cuadro eléctrico, identificación de borneros y
cableado, diagrama GRAFCET del proceso así como toda documentación que pueda facilitar las
tareas de mantenimiento.

Finalmente es importante que el sistema de control presente mediante visualizadores externos al
cuadro de control o con avisos sonoros la presencia de averías y el estado de funcionamiento del
autómata, para que la salida de estado RUN sea fácilmente detectable por el personal que atienda la
instalación.

Mantenimiento correctivo

En el caso de que se haya producido una avería fortuita, es importante que el personal de
mantenimiento intente detectar en qué estado estaba el proceso cuando ocurrió el suceso, a ser
posible identificando sobre el diagrama GRAFCET en qué estado estaba el programa de usuario y qué
valores tenían las variables internas importantes en ese momento, las entradas y las salidas.

Para verificar el estado de las entradas y salidas se comienza comprobando si los pilotos luminosos
que muestran las interfaces con su estado se corresponden con el estado real de los sensores y
actuadores en ese momento.

Si el autómata ha pasado a modo ERROR, hay que comprobar si puede dar un código de error que
ayude a identificar el problema.

Si el autómata dispone de modo TEST, hay que pasarlo a él a fin de verificar que las salidas y
actuadores funcionan correctamente forzando sus estados en modo manual.

Mantenimiento preventivo

Cuando se realicen tareas de mantenimiento preventivo, es aconsejable seguir una serie de pautas
que faciliten la eficacia de dichas intervenciones, así como mejoren el mantenimiento preventivo
futuro en base al aprendizaje que incorporemos a las tablas y calendarios de mantenimiento.

Parte fundamental del mantenimiento preventivo consiste en revisar el estado de bornas y
conexiones vigilando su apriete, la presencia de polvo o suciedad y el deterioro del cableado.

También es importante mantener un cuadrante de mantenimiento donde se anoten las fechas
previstas de mantenimiento preventivo, los resultados de cada una de esas intervenciones, las
averías que se hayan producido con explicación del motivo y de la solución aplicada, los paros no
previstos que se produzcan, así como las observaciones que a pie de instalación tengan que hacer los
operarios sobre el funcionamiento del sistema.

La revisión de este cuadrante, analizando las tareas efectuadas, las averías producidas y qué
intervenciones de mantenimiento preventivo podrían haberlas minimizado o evitado son
fundamentales para mejorar el correcto funcionamiento de la instalación, minimizar las paradas no
previstas, mejorar la seguridad y la eficacia de la planta.

También forma parte de las tareas de mantenimiento preventivo revisar las fechas de caducidad de
los elementos perecederos y planificar sus cambios de forma que pueda hacerse coincidir con
paradas planificadas de la planta. La observación de los cuadrantes con las averías detectadas
pueden hacer que el personal de mantenimiento decida incluso acortar las fechas de caducidad o las
horas de uso de elementos que se hayan mostrado conflictivos cuando se acercan a su tiempo su
sustitución.

Un adecuado mantenimiento preventivo debería disminuir las intervenciones de

mantenimiento correctivo y mejorar la seguridad de las instalaciones.

TOME NOTA

Si desea información adicional sobre mantenimiento predictivo consulte el siguiente artículo.

2. LENGUAJES Y PROGRAMAS EN LOS AUTÓMATAS PROGRAMABLES

Los primeros autómatas se destinaron a sustituir pequeñas instalaciones de lógica cableada por un
elemento programable que pudiese ser manejado por técnicos electricistas. Esto condicionó su modo
de programación, cercano a los diagramas eléctricos manejados por dichos técnicos.

Pero con el paso del tiempo el alcance de control encomendado a los PLC ha ido en constante
aumento, necesitando la envergadura de los proyectos nuevas técnicas de programación más
escalables, estructuradas y sistemáticas.

En este tema se presentará una visión general sobre todos los aspectos relativos a la programación
de los PLC.

2.1. Diseño de automatismos lógicos

Los fundamentos del diseño de automatismos lógicos, a nivel de diagramas de grafos, estados de
funcionamiento y sus transiciones no solo fueron la base del estilo de programación de los primeros
autómatas, sino que siguen siendo útiles hoy día incluso aunque se utilice algún tipo de lenguaje de
alto nivel, ya que resulta fundamental analizar bien los diferentes estados de trabajo de la instalación
y para ello siguen siendo muy válidas las técnicas iniciales de representación de estados y
transiciones como los diagramas GRAFCET.

2.1.1. Introducción

La misión inicial de los autómatas programables era sustituir las
maniobras eléctricas tradicionales implementadas con lógica
cableada por controles programables más flexibles y cómodos
de modificar; siguiendo esa tónica se comenzaron a programar
con lenguaje de contactos que prácticamente permiten
traspasar directamente el diagrama de contactos de una
instalación de lógica cableada al programa de usuario de un
autómata, con lo que eran programas que se diseñaban de
forma casi intuitiva dada su sencillez.

Con la creciente sofisticación de instalaciones, sensores y

actuadores actualmente hay muchas funciones desempeñadas
por los autómatas que ni siquiera podrían representarse con un
clásico diagrama de contactos, así que se han hecho
imprescindibles nuevas formas de diseño de programas, más
sistemáticas. Estas formas implican representar los elementos
de la instalación por su estado, y no por cómo están construidos o de qué forma trabajan.
Asociaremos cada elemento con un bloque y frecuentemente nos referiremos a él con ese término.

Podemos distinguir tres tipos de bloques en las instalaciones:

De naturaleza binaria

Nos referiremos a ellos como subsistemas lógicos. Son elementos que pueden estar en dos estados
diferentes: un motor que está en marcha o parado, una puerta abierta o cerrada, un interruptor que
está pulsado o no pulsado. Identificaremos su estado con un bit con los consabidos valores de “1” y
“0”, activo/desactivo o verdadero/falso.

De naturaleza digital

Nos referiremos a ellos como subsistemas binarios. Son aquellos elementos cuyo estado puede
adoptar un número finito de posibles valores bien enumerables. Por ejemplo, la planta en que puede
estar detenido un ascensor se podría representar con un bloque digital que aceptase los valores 0, 1,
2, 3 o 4. Estos valores se codificarán con un conjunto de bits: en este caso sería suficiente con un
byte, que como sabemos permite representar hasta 256 estados diferentes. De ser necesarios más
posibles valores tendríamos que recurrir a una variable de tipo word o long.

De naturaleza analógica

En teoría pueden adaptar infinitos valores: por ejemplo, la temperatura del agua de un depósito. En
realidad en el mundo digital los valores analógicos son convertidos a discretos o binarios. Por
ejemplo, en el caso de la temperatura mencionada, y aunque la magnitud física puede tener infinitos
valores, cuando la representamos con una determinada resolución la estamos discretizando,
traspasando a valores finitos. En el caso de la temperatura comentada, si su rango es de 0º a 100º y
trabajamos con una resolución de 0.1º para dar sus lecturas, en realidad estamos dando solo 1000
valores diferentes (0.0º, 0.1º, 0.2º, 0.3º... 99.9º), no infinitos valores. Además, en automatización los
convertidores analógicos a digitales (ADC) justamente realizan esta tarea, dando una lectura
analógica representada con un valor digital, por lo que en realidad los bloques analógicos podrían
tratarse como bloques digitales con el suficiente número de estados posibles para representar la
magnitud física con la resolución deseada.

La naturaleza binaria del estado del motor lo impone la característica que nosotros
queramos destacar de él: si solo nos interesa su estado de marcha/paro, lo
caracterizaremos con un bloque binario, aun sabiendo que el sistema real cuenta
con muchas más variables posibles (velocidad de giro, consumo de corriente, par

TOME NOTA motor, etc.).

En este capítulo vamos a desarrollar el trabajo con bloques lógicos, con subsistemas lógicos, para
cuyo manejo es fundamental conocer algunos rudimentos de la lógica booleana o álgebra de Boole,
que es la forma de operar con estas variables lógicas.

Existe una extensa bibliografía respecto a la lógica booleana y, como base, es recomendable
profundizar en el siguiente documento:

2.1.2. Modelos y funciones de transferencia

El modelo sistemático que buscamos para representar nuestras instalaciones y el control sobre ellas
nos lleva a buscar modelos de comportamiento de cada bloque o elemento, entendiendo como
modelo una representación gráfica o matemática que nos permita saber el estado en que estará
dicho bloque con una condición determinada de entradas.

Desde este punto de vista, cada bloque tendrá unos condicionantes o entradas, y su modelo
permitirá saber con certeza en qué estado se encontrará dicho bloque en esa situación. Este estado
puede considerarse como la salida de ese bloque, que a su vez podrá conectarse como entrada a
otros bloques.

En cada caso interesará un aspecto particular del bloque modelizado, de modo que por ejemplo de
un motor podría interesar modelar su estado (con lo cual su salida sería lógica, motor parado/motor
en marcha) y en otras situaciones podría interesar modelar la corriente eléctrica que consume (con
lo cual su salida sería analógica).

En una misma representación de una planta convivirán bloques de distintas naturalezas, mezcladas,
e incluso hay bloques que determinan una salida lógica en función de unas entradas analógicas (por
ejemplo, un bloque comparador que active la señal lógica de “sobrecorriente” cuando la señal
analógica de entrada “corriente consumida” sea superior a 100 amperios).

La relación entre las entradas a un bloque y su estado (que se pueden considerar también como su
salida) se denomina función de transferencia, y es todo lo que necesitamos conocer sobre el bloque
para modelarlo, independientemente de cómo esté construido en la realidad dicho elemento. Para
nuestro diseño, dos elementos con idéntica función de transferencia serán idénticos a todos los
efectos, indistintamente de si en la realidad son elementos eléctricos, hidráulicos, más sencillos o
más complejos.

Pues bien, el diseño sistemático de instalaciones pasa por definir un modelo matemático que permita
conocer con certeza total el estado de cada uno de los bloques de la instalación en función de las
entradas, así que para analizar nuestra instalación tendremos que seguir los siguientes pasos:

Pasos para analizar la instalación

 Identificar todos los bloques que la componen, y de cada uno de ellos, analizar cuáles son las
variables de entrada y de salida que nos interesa representar. Cada una de ellas se asociará a
una variable, que podrá ser lógica, binaria o analógica.

 Buscaremos para cada bloque su función de transferencia, es decir, cómo reaccionará su
salida en función del estado de sus entradas.
 Analizar en detalle cómo se interconectan estos bloques entre sí, por ejemplo las salidas de
un bloque podrán ser entradas para uno o varios bloques subsiguientes.

Además de esta operación de análisis se puede realizar su inversa, la de síntesis, que consiste
prácticamente en lo opuesto: sabiendo cómo queremos que se comporte una instalación, deducir los
bloques y funciones de transferencia que se necesitarán para conseguir ese comportamiento. En este
caso la forma de proceder sería:

Operación de síntesis

 Conocer las especificaciones del problema: qué salidas necesitamos y con qué entradas
contaremos.
 Estudiar la función de transferencia global del sistema, que nos dirá cómo queremos que se
comporten esas salidas ante cada combinación de entradas.
 Utilizar bloques ya existentes con comportamientos bien conocidos o recurrir a bloques
programables que nos permitan implementar los comportamientos deseados y combinarlos
entre sí para obtener la función de transferencia global que necesitamos.

Con este procedimiento de síntesis tan genérico pueden obtenerse múltiples soluciones diferentes
con unas mismas especificaciones iniciales, y serán criterios posteriores como los de economía,
dificultades tecnológicas o disponibilidad de elementos los que nos harán escoger entre unas
soluciones y otras.

Justamente en la síntesis de soluciones los autómatas programables tienen mucho que ofrecer, ya
que permiten usar un mismo bloque (el autómata) para infinidad de funciones y adaptar su función
de transferencia a lo que deseemos gracias a su programa de usuario.

Los bloques lógicos (aquellos que solo tienen dos posibles estados de salida) pueden dividirse en dos
grandes grupos: los combinacionales y los secuenciales.

Combinacionales

Un bloque lógico combinacional es aquel en el que el estado del bloque, la salida, solo depende del
estado de las entradas en ese preciso momento.

El comportamiento de un bloque de este tipo se puede representar con una tabla de verdad, que
muestra el estado de las salidas con cada una de las combinaciones de entradas.

Si el sistema cuenta con n entradas, la tabla de verdad tendrá 2^n combinaciones.

Secuenciales

Un bloque lógico secuencial es aquel en el que la salida del bloque depende de las entradas y del
propio estado interno en que se encontraba el bloque en ese momento. Ese estado interno
tendremos que asociarlo a una variable interna o variable de estado.

El comportamiento de un bloque secuencial no se puede representar con una tabla de verdad; debe
hacerse con una tabla de evolución de estados, que muestra las posibles salidas en función de las
entradas y en función de cada uno de los estados internos.

Como hemos visto, las variables internas de un sistema secuencial son cruciales para su
funcionamiento e implican un cierto grado de memoria, ya que el estado de la variable interna debe
recordarse de un paso de evaluación al siguiente.

El elemento básico de memoria interna se almacena en un bit de información, y el sistema físico que
lo implementa es el conocido como biestable o flip‐flop, que puede implementarse con lógica
combinacional sencilla en la que se realimenta la salida hacia las entradas a modo de enclavamiento
eléctrico (término usual en cuadros eléctricos de lógica cableada).

Funcionamiento básico del biestable

 Si las señales Set (establecer) y Reset (resetear) son 0,
la salida Q se mantiene igual a como estuviese
previamente.
 Si se activa la señal Set la salida pasará a ser 1. Nótese
que cuando desaparezca la señal Set, la salida
continuará indefinidamente a 1.

 Si se activa la señal Reset la salida pasará a ser 0 y seguirá así indefinidamente tras pasar
Reset a 0.
 No está permitida la activación simultánea de Set y Reset.

Si bien en electrónica el elemento de memoria interna es el biestable, en autómatas estas variables
internas se representarán con relés internos (recordemos, bits internos) que no tienen por qué tener
conexión directa con ninguna salida.

Las variables internas pueden ser función de las entradas o de otras variables
internas. La salida de un bloque interno al sistema, que no traspase su salida
directamente a la salida del sistema completo, pasa a considerarse de forma global
como una variable interna.
TOME NOTA

Amplíe información sobre biestables consultando el siguiente documento:

2.1.4. Diseño de automatismos combinacionales

Diseñar un automatismo combinacional implica analizar los requisitos solicitados, sintetizarlo y
definir los bloques internos que conseguirán dicho comportamiento.

Hemos visto que un automatismo combinacional puede modelarse con su tabla de verdad, que es
una representación de todas las combinaciones de entradas que pueden darse y la salida que
proporcionará cada una de estas combinaciones.

Una vez establecida la tabla de verdad, deben buscarse los bloques lógicos que nos permitan
implementar ese comportamiento y finalmente traspasar esas funciones lógicas a circuitos lógicos, o
en nuestro caso, a un programa de autómata.

Vea el siguiente EJEMPLO

Ejemplo de diseño de automatismo combinacional

Se plantea la programación de un bloque en el que tendremos 10 señales de entrada,
indicando cada una de ellas un número decimal: 0, 1, 2… hasta el 9. A estas entradas las
denominaremos E0, E1,... E9 respectivamente. Por otro lado este bloque debe atacar a un
display visualizador de 7 segmentos en el que se mostrará el número correspondiente a la
entrada activa (0,1,2... hasta el 9). Téngase en cuenta que siempre tendremos una y solo una
de las entradas activas en cada momento.

Se va a analizar cuál sería la señal de transferencia de la señal de control del segmento C, que
debe encenderse cuando queramos mostrar el número 0,1,3,4,5,6,7,8,9. La tabla de verdad
sería:

Para determinar la función lógica que determina el estado de la salida C podemos pensar
inmediatamente que la función que mejor la describe es la que hace que se encienda (que
esté a 1) cuando tengamos que mostrar un valor 0, 1, 3, 4, 5, 6, 7, 8 o 9. Esto se traduce en la
siguiente función lógica que solo emplea el operador O (OR):

C = E0 O E1 O E3 O E4 O E5 O E6 O E7 O E8 O E9

Aunque esta función describe el comportamiento deseamos, observemos que el único
momento en que no queremos encender el visualizador C es cuando queramos mostrar el
número 2, así que la siguiente función de transferencia también es correcta y resulta mucho
más económica y simple:

C = NOT E2

2.1.5. Diseño de automatismos secuenciales

En la práctica muchos de los problemas que quieran abordarse en la vida real serán secuenciales y lo
que tenga que ocurrir en cada momento dependerá de estados previos.

Por ejemplo, piense en el botón de llamada de un ascensor que tenemos en el rellano de la tercera
planta de un edificio y cómo el hecho de pulsarlo se traslada en un movimiento de subida o bajada
del motor del ascensor. ¿Cómo determinar si el motor debe hacer elevar o descender al ascensor?

Para eso tenemos que saber previamente en qué planta se encuentra detenido y así determinar
si debe subir o bajar. La variable de estado que almacena en qué planta se detuvo por última
vez el ascensor sería una variable interna.

La búsqueda de un sistema que permita sintetizar un automatismo secuencial de forma sistemática
llevó, tras muchos intentos infructuosos, a la creación de una herramienta de tipo gráfica apoyada en
álgebra booleana que es la herramienta conocida como GRAFCET (Gráfico Funcional de Control de
Etapas y Transiciones).

2.1.6. GRAFCET: Resumen histórico

El GRAFCET nació como resultado del estudio realizado por un grupo de trabajo de la AFCET en los
años setenta. Se pretendía disponer de un método de descripción de procesos, independientemente
de cómo se implementasen posteriormente esos procesos. De este modo los gráficos GRAFCET son
aplicables a distintos campos, como el de organización, el de ingeniería de diseño o el de
mantenimiento.

El GRAFCET se ha complementado con otras herramientas metodológicas como las guías GEMMA o
el añadido del álgebra booleana para convertir el GRAFCET en un método de diseño y no solo un
método descriptivo como comenzó siendo originalmente.

Actualmente hay autómatas que admiten programarse con unos grafos casi directamente
traspasados de GRAFCET o que disponen de compiladores que son capaces de trasladar un grafo
GRAFCET a un programa en lenguaje máquina ejecutable por el autómata.

2.1.7. Diseño basado en GRAFCET

La aplicación del GRAFCET se basa en los siguientes principios:

 Se centra en las funciones a realizar, no en su funcionamiento físico.
 Todo el conjunto de una automatización se divide en dos partes: parte de control (PC) y
parte operativa (PO). La parte de control incluye lo relacionado con la automatización y la
parte operativa lo relacionado con todo lo demás.
 La unidad fundamental del proceso es la “operación”, que es una acción realizada por el
automatismo. Dividiremos el proceso global en pocas operaciones denominadas
“macroetapas”, relativamente complejas, que luego iremos analizando internamente en
otras funciones más sencillas.
 En esta división llegaremos a funciones sencillas que puedan definirse de forma clara como
funciones combinacionales entre entradas y salidas. Cada etapa básica tendrá asociada una
variable de estado.
 Definir el gráfico de evolución con la secuencia de etapas que se irán dando, y las
transiciones de unas a otras. El resultado de esta definición es la formulación de la parte
secuencial de la automatización.
 Definir la función de transferencia para cada etapa elemental que nos indique su salida en
función de sus entradas, combinacionalmente.
 Implementar el sistema asignando un biestable a cada variable de estado, programando las
relaciones lógicas que generan las transiciones de unos a otros y las funciones de
transferencia de las etapas elementales.
 Como resultado de este análisis uno de los primeros resultados obtenidos será el número de
entradas, salidas y variables de estado que se necesitan para implementar esta
automatización.

El método GRAFCET no busca la optimización del número de variables de estado, más bien pretende
alcanzar el modelo de una forma simple e intuitiva que nos permita facilitar la fase de diseño aunque
la implementación no sea la más compacta posible, cosa que con la sencillez de programación de los
autómatas no es lo prioritario.

2.1.8. GRAFCET: Elementos de base y reglas de evolución

Este modelo de representación gráfica del modelo de funcionamiento de un sistema de control se
basa en los siguientes elementos y reglas de transición:

Elementos gráficos de base

Se usarán símbolos para definir cada uno de los elementos básicos del gráfico.

a. Etapas, siendo cada una de ellas un estado del sistema. Dentro de una etapa la función de
transferencia de entradas a salida debe ser combinacional. Las etapas se representan con un
cuadrado con un identificador en el interior (que, si son numéricos, no tienen por qué ir en
orden). Las etapas con que se inician los procesos se simbolizan con un cuadrado inscrito
dentro de otro.
b. Líneas de evolución, que unen unas etapas con las siguientes. Se representan con líneas
verticales y el sentido de la evolución es hacia abajo salvo que se explicite lo contrario con
una flecha.
c. Transiciones. Son las reglas que determinan las situaciones que deben darse para que se
produzca una evolución, un cambio de una etapa a otra. Se indican con una línea que corta la
línea de evolución gobernada por dicha transición y se anota, junto a la marca de transición,
la regla que sigue.
d. Reenvíos. Son flechas que indican el destino o el origen de una línea de transición.
e. Toda transición entre dos etapas debe estar gobernada exclusivamente por una condición
combinacional que dé un resultado binario de transición. Es decir, puede ser una expresión
compleja pero termina señalizando exclusivamente si se ejecuta la transición o no.

Mensajes de interpretación

Son textos o fórmulas asociados a etapas y transiciones que detallan, comentan o explican cuál es la
actividad a realizar en la etapa o cuál es la fórmula asociada a una transición.

Reglas de evolución

Estas reglas gobiernan el comportamiento del sistema y son esenciales para poder interpretar un
GRAFCET. Se destacarán las principales:

a. Cada etapa, como se indicó antes, se corresponde con un estado del sistema al que
asociaremos un bit de estado. Este bit de estado puede estar a “1” (si la etapa está activa) o a
“0” (si la etapa está desactiva).
b. Se denomina arranque en frío a aquel inicio de proceso que inicia todas las etapas iniciales a
“1” (activas) y todas las demás a “0” (desactivas).
c. Serán arranques en caliente los que pueden iniciar el proceso en un estado anterior distinto
al inicial, cargando cada estado con su valor de activación o desactivación correspondiente.
d. Una etapa pasa a estar activa cuando la anterior esté activa y se dispare la condición de
transición de una a otra. En ese momento la etapa anterior queda desactivada.

e. Las transiciones pueden encontrarse en los siguientes estados lógicos:
i. No validada. Una transición estará en estado “no validada” si su etapa anterior no
está activa. Lógicamente esta transición no se podrá ejecutar hasta que la etapa
anterior quede validada.
ii. Validada. Una transición estará en estado “validada” si su etapa anterior está activa
pero no se cumple la condición de transición.
iii. Franqueable y franqueada. Una transición pasa a estar en modo franqueable al
cumplirse su condición de transición estando activa la etapa anterior. En cuanto que
se encuentra en modo franqueable, la transición pasa a estar franqueada,
activándose la etapa posterior y desactivándose la etapa anterior.
f. Si hay varias transiciones franqueables al mismo tiempo, todas ellas pasarán a estar
franqueadas en ese mismo momento.
g. La evolución del GRAFCET debe seguir caminos cerrados, ningún camino posible puede
quedar abierto.
h. Si la evolución de un GRAFCET indica al mismo tiempo activar y desactivar una etapa, esta
quedará desactivada (en caso de indeterminación, no se activará).

2.1.9. GRAFCET: Ejemplo de diseño

Se va a implementar el control del movimiento de un husillo mediante un motor y unos sensores de
final de carrera con un diseño GRAFCET. Los elementos a usar son los siguientes:

El comportamiento que se desea es: estando el husillo detenido a la izquierda, si se pulsa el
interruptor debe ponerse en marcha hacia la derecha. Al alcanzar el final de carrera derecho el
husillo debe detenerse 7 segundos y, acto seguido, ponerse en marcha hacia la izquierda,
deteniéndose y terminando el ciclo cuando llegue a activar de nuevo el final de carrera Fi.

GRAFCET con todos los posibles estados

 La condición de transición para pasar del estado inicial a la primera marcha hacia la derecha
es la función binaria S1*Fi. Dicha condición solo se activará (dará “1”) cuando estén activos al
mismo tiempo S1 y Fi, es decir, cuando estando el husillo en la izquierda (Fi activo) el
operario pulse el botón (S1 activo). Esta condición es justo la descrita en la especificación de
la transición inicial.
 El siguiente estado, E1, pondrá en marcha el actuador KMD para que el motor mueva el
husillo a la derecha. Este estado solo finalizará cuando se cumpla la condición Fd (es decir,
que el husillo llegue a la derecha), lo cual llevará al estado E2, en el que se parará KMD y se
iniciará el temporizador de 7 segundos.
 Una vez cumplida la condición de que finalice el temporizador, TO/7, se pasa al estado E3,
poniéndose en marcha KMI y por tanto moviéndose el husillo hacia la izquierda.
 Finalmente, al llegar al final de carrera izquierdo se activa Fi, disparándose la condición de
paso al estado de parada, E4, que detiene KMI, tras lo que se pasa de nuevo a la etapa de
inicio en espera de comenzar el ciclo de nuevo.

Elementos para su implementación

Para implementar este ejemplo en un autómata se necesitarían:

 Las variables de estado internas (relés internos) E0, E1, E2, E3 y E4.
 Las entradas S1, Fi y Fd.
 Las salidas KMI y KMD.
 El temporizador T0.

Para activar un estado, por ejemplo E1, tendría que darse:

 Que estuviese activo E0.
 Que se cumpliese la condición de transición Fi*S1.

Así que la asignación de la carga del estado E1 podría ser del tipo E1 = E0 * Fi * S1

Amplíe información sobre sobre este ejemplo consultando el siguiente enlace.

2.1.10. Macroetapas y representación en detalle

Para representar un proceso complejo indicamos con un esquema GRAFCET los estados y
transiciones de bloques generales, de forma que en una sola etapa se pueden incluir internamente
multitud de distintas etapas básicas, aunque por facilitar la comprensión del sistema global se
ocultan en el interior de esa única etapa a la que denominamos macroetapa.

Para que las etapas básicas se puedan representar agrupadas en una macroetapa tienen que darse
las siguientes circunstancias:

a. Internamente, la macroetapa debe tener una etapa inicial y otra final.

b. Al activarse en el esquema global la condición anterior a la macroetapa, se activa la etapa
inicial de la macroetapa. Lo mismo ocurre al darse la condición de salida de la etapa final de
la macroetapa: se activará en el esquema global la siguiente etapa a la macroetapa recién
desactivada.
c. Dentro de una macroetapa también pueden definirse más macroetapas, siguiendo las
normas descritas anteriormente.

2.1.11. Estructuras básicas del GRAFCET

El ejemplo del apartado 2.1.9 tenía una estructura lineal y sin caminos alternativos en la que todas
las etapas se disparaban secuencialmente, pero en la implementación de automatismos se dan otras
circunstancias, como bucles o bifurcaciones de proceso que deben poder describirse con el
GRAFCET.

Las 3 estructuras básicas del GRAFCET son:

 Estructura lineal de etapas.
 Convergencia y divergencia en O.
 Convergencia y divergencia en Y.

Toda representación GRAFCET se construirá con una combinación de
estas estructuras descritas, que vamos a detallar.

Estructura lineal de etapas

En esta estructura de trabajo las etapas se irán activando
secuencialmente, una tras otra, hasta llegar a la final. Una secuencia
de etapas de este tipo puede formar parte de un GRAFCET más
complejo que incluya otras estructuras.

Divergencia y convergencia en O

En estas estructuras de etapas se abre la posibilidad de seguir la ejecución del GRAFCET por distintos
caminos alternativos, existiendo una condición de transición propia para cada uno de estos caminos
que debe ser excluyente con las demás condiciones de la divergencia:
en cada ocasión solo se recorrerá uno de los caminos divergentes en
O.

Cada uno de los distintos caminos divergentes es una estructura lineal
de etapas, aunque internamente alguna de ellas puede tener
estructuras más complejas.

Todos los caminos divergentes en O deben terminar confluyendo en

unos puntos de convergencia en O, ya que como sabemos no puede
quedar ningún camino abierto. Los puntos de convergencia pueden ser
distintos para cada camino, pero todos ellos tienen que terminar
convergiendo.

100

Divergencia y convergencia en Y

En este caso la estructura con divergencia y convergencia en Y abre
paso a la ejecución de varios caminos paralelos, los cuales se inician
todos al mismo tiempo cuando se cumple la condición de transición
común. Es decir, al cumplirse dicha transición se ponen en ejecución
simultánea todos los caminos divergentes en Y.

Todos estos caminos deben terminar en una convergencia en Y, aunque
no todos tienen que terminar en la misma convergencia.

Por su parte, las convergencias en Y implican una condición de
transición, y es que solo se activa la transición cuando hayan concluido
todos los caminos en Y que convergen en ese punto.

Es muy importante cuando se planteen estructuras de este tipo que se tenga presente que los
caminos a seguir en paralelo implican procesos que se van a dar simultáneamente, por lo que debe
comprobarse que el proceso real acepte dichas ejecuciones simultáneas.

En la siguiente página puede ampliar información sobre las estructuras de los GRAFCET.

2.1.12. Diagramas de flujo y diagramas GRAFCET

En informática es habitual el uso de una herramienta gráfica de descripción de algoritmos, el
diagrama de flujo, y cualquiera habituado a ellos observará ciertas similitudes con los gráficos
GRAFCET.

Sin embargo, existen varias diferencias fundamentales entre ellos:

 En los diagramas de flujo no existe la posibilidad de establecer caminos divergentes en Y, no
hay estructuras de programa que se puedan ejecutar en paralelo ni forma de representarlas
con un diagrama de flujo.

 El diagrama de flujo representa procesos monotarea, mientras que en los GRAFCET pueden
representarse varias tareas simultáneas.

101

 En GRAFCET se separan las tareas secuenciales de las puramente combinacionales, cosa que
no ocurre en los diagramas de flujo.

 Un diagrama de flujo representa los pasos que va ejecutando el procesador, mientras que en
el GRAFCET la secuencia de tareas es descrita a nivel de procesos, no de procesador.

Aun contando con esas diferencias, es fácil representar con GRAFCET las clásicas bifurcaciones, saltos
y bucles de un diagrama de flujo.

Amplíe información sobre los diagramas de flujo y su construcción consultando el siguiente enlace.

2.1.13. Etapas iniciales, preposicionamiento y alarmas

Anteriormente expusimos la existencia de arranques en frío y en caliente: los arranques en frío son
los que se efectúan con el sistema completamente detenido, por primera vez, y los calientes los que
se ejecutan tras darse una condición de parada que hubiese detenido el proceso.

102

El arranque en frío pasa todas las etapas que no sean iniciales a modo desactivo, mientras que activa
todas las iniciales.

Sin embargo, el arranque en caliente debe analizar en qué estado de funcionamiento se quedó la
planta en la parada para analizar en qué estados deben inicializarse todas las etapas para que la
condición de partida sea segura. A este proceso de análisis lo denominamos tratamiento preliminar.

Para que el comportamiento del sistema pueda quedar bien descrito en estas circunstancias se
añaden al esquema GRAFCET unas variables internas que denominaremos variables de sistema. Así
que, tras un arranque en frío o un arranque en caliente, antes de comenzar a ejecutar las primeras
etapas de procesado, habría que ejecutar la etapa de tratamiento preliminar, que actuaría con y
sobre las variables de sistema, definiendo además los estados iniciales de cada etapa.

Por otro lado, para tener contemplada la posibilidad de que en cualquier punto del GRAFCET puede
darse una alarma, habría que incluir como mínimo una divergencia en O en la salida de cada etapa:
una de procesado convencional y otra a ejecutar en caso de alarma. Como esto generaría GRAFCET
poco legibles, se suele representar el camino convencional de los procesos, dejando siempre
implícita la posibilidad de que una alarma puede sacar al proceso de su ejecución secuencial para
saltar directamente a las etapas de atención de alarma.

Además, existe otra herramienta complementaria con el GRAFCET para el tratamiento de estas
situaciones especiales: la guía GEMMA.

Amplíe información consultando la guía GEMMA en el siguiente documento:

103

2.1.14. Puestas en marcha y paradas: GEMMA

Como hemos visto, el GRAFCET es una herramienta apropiada para el análisis sistemático de sistemas
de control que describe perfectamente el proceso mientras que no ocurra ninguna alarma o parada
de emergencia, porque no cuenta con herramientas idóneas para describir rigurosamente cómo
proceder ante estos eventos, importantes en los procesos industriales.

Para poder generar unas especificaciones claras, concretas y que describan cómo actuar en cada caso
se ha desarrollado la herramienta conocida como GEMMA (Guía de estudio de modos de paro y
marcha) que permite definir de forma clara las posibles situaciones de marcha y paro en que puede
encontrarse la parte operativa de la instalación.

Para ello se define un útil gráfico que tiene una serie de estados tipificados de la parte operativa y
que muestra cómo puede pasarse de unos estados a otros.

Elementos de base

El gráfico está compuesto por estos elementos:

 Rectángulos de estado. Se disponen una serie de estados tipificados que en teoría son
generales y pueden darse en cualquier instalación. Si nuestra automatización precisa definir
alguno específico no contemplado en esta lista, debe añadirse al marco. Los que no tengan
aplicación en el proyecto se tacharán.
 Familias de estado. Los estados posibles del sistema se pueden agrupar en estas familias:
estados de paro, estados de funcionamiento y estados de fallo. Se dice que un sistema está
en producción cuando funciona normalmente cumpliendo la tarea para la que estaba
previsto, y fuera de producción cuando no es así. Nótese que mientras estar en estado de
funcionamiento implica estar en producción, no ocurre lo mismo con las familias de estado

104

de paro y de fallo, ya que un sistema puede estar en producción aun teniendo parte o todo el
sistema en estado de paro (por ejemplo, un paro de cambio de turno).
 Líneas orientadas. Son las que marcan todos los pasos posibles y la dirección de cada paso.
 Condiciones de evolución. Iguales a las condiciones de transición de GRAFCET, salvo que
estas pueden existir o no, mientras que en GRAFCET siempre se explicita una condición de
transición entre etapas. El diseñador de un sistema de control debe repasar todos los
estados de la guía GEMMA e identificarlos en su sistema, advirtiendo quizás así condiciones
que no había previsto o que no había planteado.

Estados de funcionamiento

En esta familia de estados se describen todos por los que tiene que pasar la planta para conseguir su
objetivo, incluyendo los estados de test, controles iniciales, estados de preparación, controles finales
y todos los propios del proceso de producción en sí.

Concretamente, los estados tipificados de funcionamiento son:

 F1: Producción normal
 F2: Marcha de preparación
 F3: Marcha de finalización
 F4: Verificación de marcha en desorden
 F5: Verificación de marcha en orden
 F6: Marcha de test

Estados de paro

En la familia de estados de paro se incluyen todos los que pueden parar el funcionamiento del
proceso. Concretamente se describen los siguientes:

 A1: Paro en estado inicial
 A2: Demanda de paro a final de ciclo
 A3: Demanda de paro en un estado determinado
 A4: Paro en estado intermedio
 A5: Preparación de arranque después de un fallo
 A6: Inicialización de la parte operativa
 A7: Preposicionamiento de la parte operativa

Estados de fallo

Finalmente esta familia de estados incluye todos los estados normalizados que pueden alcanzarse
por fallo de la parte operativa de la planta. Se tienen tipificados los siguientes:

 D1: Paro de emergencia
 D2: Diagnóstico y/o tratamiento del fallo
 D3: Seguir en producción con fallo

105

Consulte en el siguiente documento el esquema completo de la guía GEMMA.

2.1.15. Método general de diseño basado en GEMMA

La aplicación de las técnicas GRAFCET y GEMMA a la sistematización del estudio del nuestro proyecto
se sintetiza en un proceso de diseño similar al siguiente:

 Estudiar las etapas del proceso global y generar el GRAFCET correspondiente.
 Estudiar la parte operativa del proceso y generar su GRAFCET.
 Estudiar los modos de marcha y paro con GEMMA, así como las evoluciones de estado.
Incluir en este estudio la interfaz de interacción con el usuario y generar GRAFCET completo.
 Escoger el tipo de mando que se vaya a usar en la implementación física del control y
componer el programa de control.

Como resultado de este proceso, nuestro GRAFCET final describirá las distintas etapas de operación
que se encuentran dentro de cada estado GEMMA, y en la práctica tendremos al menos dos
secuencias de estados: el bucle de operación y el de atención a paradas y fallos.

106

En esta página puede consultar un GRAFCET enriquecido con los estados de marcha y paro de la guía
GEMMA.

2.1.16. Paros de emergencia

Como ya hemos mencionado, todo GRAFCET descriptivo del proceso de control de la parte operativa
lleva implícita la posibilidad de que se interrumpa el servicio normal
que el propio GRAFCET describe en caso de alarma o fallo, aunque
no se muestre a la salida de cada etapa.

Por ser la parada de emergencia una de las maniobras de seguridad
básica y obligatoria en muchos ámbitos de trabajo, merece tener
un tratamiento específico en los diagramas de funcionamiento de
nuestra automatización.

Los desarrolladores de GRAFCET previeron dos posibles reacciones
ante un paro de emergencia:

 Desactivación de todas las salidas de acción y paso a un GRAFCET de alarma que describirá
qué hacer a continuación.
 Incluyendo detalle de salida de emergencia en cada etapa, lo que genera GRAFCETs más
detallados y complejos.

En implementaciones con autómatas programables
es habitual trabajar con la primera aproximación.

2.1.17. Ejemplo de diseño

Como resumen general del método sistemático de

diseño descrito se propone el seguimiento de un
ejemplo de diseño en el que se describirán varias
secciones de trabajo de una planta embotelladora.

Dada la extensión de este ejemplo se recomienda la
consulta de esta página web, donde podrá ver su
análisis y conclusiones.

107

2.2. Programación del autómata

En los apartados anteriores hemos descrito al autómata programable como un elemento hardware
que permite controlar una planta gracias a un conjunto de entradas que le permite conocer el estado
de cada elemento relevante de la instalación, así como un conjunto de salidas que le permiten actuar
sobre los elementos necesarios para gobernar el proceso (los actuadores) según una lógica de
control que hemos denominado programa
de usuario.

Para implementar ese programa de usuario

es necesaria la intervención humana, donde
un operador (el programador) define el
conjunto de reglas de control necesarias
para poder controlar la planta, es decir, la
programación del autómata.

A continuación se pasa a estudiarla en los

siguientes apartados.

2.2.1. Introducción

Durante la ejecución del control automatizado de la planta también puede necesitarse intervención
humana, bien para supervisar el proceso, bien para cambiar la configuración de sus parámetros o
incluso para actuar manualmente sobre la instalación (por ejemplo, para activar una parada de
emergencia). A este manejo de la planta o estas modificaciones del control de la planta a través del
autómata y su programa de usuario lo denominamos explotar la aplicación.

De la interacción del autómata con la planta se encargan las interfaces de entrada/salida, y de la
interacción con los humanos un software que hace de intermediario entre el programador y el
usuario con el autómata con el objetivo de facilitar las tareas de programación y explotación de la
aplicación de usuario.

Herramientas de software

Para posibilitar el traspaso del programa de usuario al autómata y que este ejecute la función
que se le encomienda necesitamos dos grupos distintos de herramientas de software:

108

 El sistema operativo que se ejecuta en el interior de la CPU del autómata, que como
vimos se encarga de cargar en memoria el programa de usuario, ejecutar
secuencialmente las órdenes programadas en él y velar por el correcto funcionamiento
del sistema.
 Un conjunto de programas de edición y verificación del programa de usuario que
permiten al programador desarrollarlo, grabarlo en algún tipo de soporte físico,
modificarlo y comprobarlo. Antiguamente era habitual que este conjunto de programas
se ejecutasen en una unidad de programación, un hardware específicamente
desarrollado para ese objetivo. Actualmente lo normal es que sea un ordenador personal
el que ejecute este conjunto de programas de edición y verificación. En ese caso es
habitual que el ordenador precise de una interfaz de comunicación que permita conectar
el ordenador con el autómata, siendo este interfaz habitualmente proporcionado por el
fabricante del autómata. Gracias a esta unidad de programación, bien sea implementada
por un hardware específico o con un ordenador y su interfaz apropiada, el programador
puede definir el programa de usuario, modificarlo, traspasarlo al autómata y finalmente
verificar su funcionamiento.

Lenguajes de programación y explotación

Para poder definir el programa de usuario es necesario el uso de un lenguaje de
programación, que es un lenguaje formal diseñado para especificar los procesos que
posteriormente podrá ejecutar el autómata. El lenguaje de programación está compuesto
por un conjunto de símbolos y textos además de un conjunto de reglas sintácticas y
semánticas que definen el significado de sus expresiones.

Por su parte, el lenguaje de explotación es el conjunto de comandos que el usuario puede
utilizar para comunicar con la aplicación del autómata, comprobar su estado de
funcionamiento y modificar algunos de sus parámetros. Esto podrá hacerse desde la unidad
de programación, o en ocasiones si la aplicación de usuario lo ha previsto así, con terminales
específicos para la aplicación en cuestión.

La CPU del autómata, en general, no será capaz de procesar directamente el lenguaje de
programación, por lo que será preciso un proceso de compilación en el que nuevamente un software
específico genere un programa en formato binario, inteligible para la CPU del autómata, con base en
el programa de usuario definido con el lenguaje de programación: será ese programa binario
compilado el que se traspase al autómata para su ejecución. Estos códigos binarios (no inteligibles
fácilmente por un humano) son posteriormente interpretados por la CPU, que es capaz, gracias a su
sistema operativo, de ejecutar dichas órdenes binarias.

El usuario programador, que es quien define el programa de usuario, debe comenzar modelando el
comportamiento deseado para el programa, por ejemplo usando un grafo tipo GRAFCET, para seguir
identificando las entradas y salidas que precisará, definiendo las secuencias de funciones que
tendrán que ejecutarse y sus interrelaciones, traspasando este modelo al lenguaje de programación
elegido, compilando dicho programa y traspasando el código binario resultante al autómata para su
comprobación.

A continuación se explican en detalle los pasos a seguir hasta tener el programa de usuario
ejecutándose en el autómata.

109

2.2.2. Representación de sistemas de control

En el apartado anterior se ha descrito el proceso de programación como aquel que ha resultado en
un programa escrito en código binario inteligible para el autómata a raíz del control de la planta que
se desea, expresado originalmente de algún modo no computable por el autómata, pero apropiado
para ser manejado por el usuario programador.

El operador puede usar el lenguaje coloquial para detallar los estados que se dan en el control, las
condiciones que deben darse para cambiar de estado, y en general todos los aspectos relevantes del
control.

Sin embargo, en cuanto que el proyecto de control no es sencillo, el lenguaje coloquial no es el más
apropiado para expresar claramente y sin ambigüedades todas las condiciones involucradas, de
modo que se impone el uso de lenguajes simbólicos que permitan detallar la tarea a realizar. Según
los tipos de símbolos usados, esta representación puede ser:

 Proposicional, implementada con descripciones literales.
 Algebraica, implementada con operadores matemáticos y booleanos.
 Gráfica, descrita en base a diagramas de flujo, GRAFCET, esquemas de relés, etc.

Cada uno de estos tipos de representación es apropiado para distintas partes de las tareas a
describir, y es habitual que se utilice incluso una mezcla de ellos para detallar de forma más eficaz la
tarea de control.

Descripciones literales

Las descripciones literales las veremos en más detalle en el siguiente epígrafe.

Implementación algebraica

El lenguaje algebraico es aquel que usa símbolos y letras para expresar números y funciones. Su gran
ventaja es la rigurosidad, con el resultado de expresiones totalmente cerradas y no susceptibles de
interpretación y su capacidad para trabajar con números desconocidos (x = a + b).

En descripción de procesos de control se usa el álgebra booleana (la que detalla el comportamiento
de operadores binarios —0, 1—) y el álgebra convencional sobre valores numéricos digitales (con
cualquier rango de valores posibles). Vea el siguiente EJEMPLO.

En el ejemplo del apartado 2.1.9 se explicitaron las condiciones de transición entre estados
para el diagrama GRAFCET en álgebra booleana. Por ejemplo la primera condición “estando
el husillo detenido a la izquierda, si se pulsa el interruptor debe ponerse en marcha hacia la
derecha” queda descrita con la expresión booleana: S1*Fi. Esta expresión solo es verdadera
cuando simultáneamente son verdaderos los dos operadores, es decir, cuando se pulsa el
botón S1 y cuando al mismo tiempo el sensor de final de carrera izquierdo está activado (Fi).
Esta forma de expresar las relaciones no deja lugar a la imprecisión, pero cuando el proyecto
es medianamente complejo dificulta mucho su escritura y revisión. No obstante la expresión
algebraica posiblemente sea la forma más correcta de expresar las relaciones
combinacionales dentro de cada tarea incluso en sistemas de representación gráfica, por lo
que es muy usual recurrir a ella para ese tipo de expresiones.

110

Esquemas de relés

Esta forma de representación, muy conocida por los electricistas, ya que es la forma habitual de
representar maniobras sencillas de control por lógica cableada, se basa en la descripción mediante
diagramas de contactos abiertos y cerrados de la tarea de control.

Un relé se representa en estos formatos con al menos un par de elementos gráficos: su bobina por
un lado y al menos un contacto de salida por otro. En su formato de salida más sencillo de un único
circuito con un único contacto, cuando la bobina recibe excitación eléctrica el contacto de salida
estará cerrado, y cuando no la reciba, el contacto estará abierto. En el ejemplo de la imagen de la
derecha (púlsela para ampliarla), los 6 relés quedan descritos con sus bobinas K1, K2, … K6 y sus
contactos de salida correspondientes K1, K2, … K6.

Diagramas lógicos

Este tipo de diagramas muestra las expresiones booleanas que podrían haberse expresado de modo
algebraico con diagramas lógicos en los que cada una de las distintas operaciones booleanas está
implementada por un determinada tipo de puerta lógica.

Al contrario de lo que ocurre con los diagramas de relé, en estos diagramas lógicos sí que existen
mecanismos para describir cómo procesar señales digitales que tomen más de un valor (que estén
formadas por más de un bit) usando representaciones de elementos tales como multiplexores,
dermutiplexores, etc., del mismo modo que permiten describir sistemas secuenciales con elementos
como registros de desplazamiento, contadores, etc.

111

El uso de este tipo de representación es habitual para el diseñador de circuitería electrónica digital,
pero no tanto para quien aborda un proceso de automatización por PLC.

Diagrama de flujo

Los anteriores formatos de representación son apropiados para la descripción de operaciones
combinacionales, pero no tanto para aquellas operaciones secuenciales que tengamos que detallar.

Para expresar mejor esas secuencias de tareas y la interrelación entre ellas se puede utilizar con éxito
el diagrama de flujo, habitual entre los programadores al describir algoritmos.
Un diagrama de flujo es un modelo que utiliza bloques entrelazados para describir una secuencia
temporal y condicional de operaciones a ejecutar.

Para darle un carácter competo a este tipo de diagramas habría que recurrir al lenguaje algebraico y
comentar en extenso cada uno de los bloques, lo que merma la claridad de interpretación.

112

Representación GRAFCET

Tras la exposición de los anteriores mecanismos de representación de modelos de control vemos con
claridad la potencia del GRAFCET, ya presentado, que une la potencia de descripción gráfica del
diagrama de flujo con el uso riguroso de las condiciones algebraicas necesarias en sus condiciones de
transición, ya descritas en los apartados 2.1.7 y 2.1.8.

Hay que destacar que es muy frecuente describir las relaciones combinacionales entre entrada y
salida de una tarea del GRAFCET bien de forma algebraica o bien en forma de diagrama de contactos,
lo que proporciona una descripción casi completamente gráfica del proceso.

Finalmente recuerde que hay autómatas que permiten un paso casi directo de una representación de
tipo GRAFCET a su programa de usuario.

El diagrama GRAFCET se puede utilizar para describir especificaciones funcionales,

tareas de mantenimiento o la programación del autómata.

TOME NOTA

2.2.3. Descripciones literales

Para describir una tarea de control en lenguaje natural se deben intentar detallar de forma
secuencial cada uno de los pasos deseados e intentar dejar bien explicado cómo se pasa de un
estado a otro. La gran ventaja de este sistema de representación es la sencillez de interpretación, al
tiempo que ese también es su gran inconveniente: la falta de rigor en la exposición puede dejar
condiciones no especificadas por completo.

En el apartado 2.1.9 encontramos un ejemplo de descripción literal en el que se detalló el
comportamiento deseado para el sistema de movimiento del husillo:

El comportamiento que deseamos es el siguiente: estando el husillo detenido a la izquierda, si se
pulsa el interruptor debe ponerse en marcha hacia la derecha. Al alcanzar el final de carrera derecho
el husillo debe detenerse durante 7 segundos, y acto seguido ponerse en marcha hacia la izquierda,
deteniéndose y terminando el ciclo cuando llegue a activar de nuevo el final de carrera Fi.

113

2.2.4. Identificación de variables y asignación de direcciones

Tras modelar el proceso mediante alguno de los modelos de representación vistos en el apartado
anterior, toca identificar las variables involucradas en él y asignarles sus direcciones
correspondientes. Como resultado de desarrollar ese modelo es fácil extraer el listado de entradas y
salidas necesarias. De hecho, suele ser un paso previo a la elaboración final del modelo de
representación del sistema de control de planta.

Además de estas variables de entradas y salidas será necesario revisar la necesidad de crear variables
de los siguientes tipos:

Tipos de variables

 Variables internas predefinidas por el fabricante mediante las cuales se accede a los
módulos de hardware necesarios en el proyecto para el control de contadores,
temporizadores, configuración de parámetros de funcionamiento del autómata, etc.
 Variables intermedias, usadas para almacenamiento de valores temporales. Tales como
identificador de estado interno (estado de cada una de las etapas del GRAFCET, por ejemplo),
resultados intermedios de operaciones combinacionales, señalización de distintas alarmas,
etc.
 Variables de usuario, creadas para parametrizar el funcionamiento del programa de usuario
y que pueden ser modificadas, habitualmente, con el terminal de programación o por un
interfaz de consola por el propio usuario. Algunas variables de usuario típicas pueden ser:
tiempo máximo de funcionamiento de un motor, consumo de corriente máximo de modo
que se genere una alarma al superarse, etc.

Una vez listadas todas las variables necesarias, pasamos a asignarles direcciones a cada una de ellas.
Veamos cómo hacerlo a continuación.

Entradas y salidas

En el caso de las entradas y salidas, la dirección determinará en qué entrada física del autómata o de
las ampliaciones se debe conectar la señal correspondiente. Para numerar las entradas y salidas
pueden usarse dos tipos de codificaciones, relativas o absolutas:

 Direcciones absolutas de E/S: en este
su posición en el hardware es fija,
siendo la forma habitual de trabajar
en PLCs compactos donde las E/S
están incorporadas en el propio
cuerpo de la CPU.
 Direcciones relativas de E/S: en el
caso de usar PLC modulares es más
habitual definir las salidas de forma
relativa, apuntando por un lado en
qué posición en qué posición se encuentra dentro del bastidor el módulo al que pertenece la
salida, y por otra parte, qué posición ocupa esa salida en dicho módulo.

114

Es habitual nombrar las direcciones de las E/S relativas con dos índices separados por un punto,
indicando primero el ordinal ocupado por el módulo, y a continuación del punto el ordinal de la
entrada/salida dentro de su módulo.

De esta forma podemos ver que en la imagen anterior tenemos activas las entradas 1.1, 1.7 (séptima
entrada del módulo 1), 3.2, 3.6, 6.1 y 6.3. Es frecuente acompañar estos números con una etiqueta
que indique si el ordinal referenciado es una entrada, salida o si es una variable interna. De este
modo la primera entrada del primer módulo sería nombrada como IN1.1 y la salida activa en el
módulo 4 la OUT4.7

Variables internas

Por su parte las variables internas de acceso a características del hardware (watchdog,
temporizadores, etc.) tienen siempre sus direcciones de memoria fijas en el autómata (y por tanto,
de tipo absoluto), siendo necesario consultar el manual de usuario para identificar las posiciones de
memoria correspondientes con cada variable de interacción con el hardware.

Variables intermedias y de usuario

Finalmente las variables intermedias y de usuario se almacenan todas en la memoria de la CPU,
pudiendo de nuevo ser su posición absoluta respecto al mapa de memoria completo de la CPU, o
bien relativa a un conjunto de datos que funciona como una zona de memoria con sentido propio,
comúnmente denominado “bloque de datos”.

 Variables intermedias direccionadas de forma absoluta. Las variables intermedias o de
usuario direccionadas de forma absoluta explicitan en su definición la posición de memoria
del PLC donde se almacenan, de forma inequívoca.
 Variables intermedias direccionadas de forma relativa. En estas agrupaciones lógicas de
memoria o “bloques de datos” se almacenan todas las variables intermedias que vaya a
necesitar un programa de usuario o alguna parte notable de él, de forma que el programa se
referirá a dichas posiciones con el identificador de bloque de datos seguido de la posición de
la variable dentro de dicho bloque. Es decir, al declarar la variable no explicitamos la
dirección exacta de memoria donde se almacenará. Más tarde será el sistema operativo del
autómata el que aloje dicho bloque de datos en unas posiciones finales absolutas de la
memoria o en otras, posiciones que ni siquiera serán conocidas para el programa de usuario,
que referenciará a esas variables solo por el bloque de datos y su posición en él.

115

Tipos de datos y direccionamiento

Tanto en el caso de direccionar las variables internas de forma absoluta como relativa a bloques de
datos, cuando se den de alta hay que tener muy en cuenta el tamaño físico ocupado por cada una de
ellas.

Habitualmente hay una zona de memoria destinada a los relés internos (bits sueltos direccionables
uno a uno) y otra destinada a las variables digitales (que pueden ser de 1 byte, 2 bytes, 4 bytes e
incluso más en algunos tipos de datos). Pues bien, al darlas de alta debemos tener bien presente
dicho tamaño ya que las de 2 bytes consumirán dos posiciones de memoria de datos, y las de 4
bytes, 4 posiciones.

116

En la siguiente página puede consultar los datos del autómata s7‐300 a modo de ejemplo.

2.2.5. Lenguajes de programación

Se ha definido el lenguaje de programación como un lenguaje formal diseñado para especificar los
procesos que posteriormente podrá ejecutar el autómata. Está compuesto por símbolos y textos
junto con un conjunto de reglas sintácticas y semánticas que definen el significado de sus
expresiones.

Sería muy positivo que el mismo modelo de representación que hayamos usado para modelar
nuestro sistema de control se pudiese traspasar directamente al autómata, es decir, que uno de los
lenguajes de programación del autómata fuese el mismo que se haya usado para modelar el proceso.

Esto no siempre es posible, aunque como se verá más adelante hay autómatas que aceptan
lenguajes de programación gráficos muy similares a algunos de los grafos de representación ya
expuestos. De este modo, los lenguajes de programación de autómatas podemos catalogarlos en dos
categorías principales:

Lenguajes algebraicos

Lenguajes booleanos, lista de instrucciones y lenguajes de alto nivel.

117

Lenguajes gráficos

De diagrama de contactos, de diagramas de funciones e intérpretes GRAFCET.

En general será necesario trasladar nuestra representación del sistema de control al lenguaje
escogido, efectuando las modificaciones necesarias para compatibilizarlo con el lenguaje de
programación.

El programa resultante será un conjunto de instrucciones, sentencias, bloques y grafos que marcan
las instrucciones que tendrá que ejecutar secuencialmente el PLC, considerando que:

 Una instrucción es la tarea más básica de que es capaz un programa: cargar una salida, leer
una entrada, negar una variable, hacer una operación lógica OR de dos bits, etc.
 Una sentencia es un grupo de instrucciones que hacen una tarea concreta: comprobar si una
entrada está activa y si lo está invertir una salida, por ejemplo.
 Finalmente un bloque es un conjunto de sentencias que implementan una tarea compleja.

Todos estos elementos se organizan entre sí mediante los símbolos o grafismos propios del lenguaje
de programación. En cualquier caso la instrucción, independientemente de cómo la represente el
lenguaje, siempre consta de dos campos:

 Un campo de operación, donde se define qué se debe hacer (leer entrada, cargar salida,
hacer una AND)
 Un campo de operando, donde se define con quién debe operarse (una entrada, una salida,
una variable interna...)

Cuando una instrucción referencia a una variable de memoria, esta puede referenciarse de modo
directo (cuando indicamos directamente la dirección donde está la variable con la que queremos
operar) o de modo indirecto. En el modo indirecto se recurre a otro registro o variable interna que es
la que contiene en ese momento la dirección de la variable con la que en realidad queremos operar.

118

Es decir, se especifica en la instrucción de direccionamiento indirecto un índice que es el que en
realidad contiene la dirección del operando.

2.2.6. Lenguajes booleanos y lista de instrucciones

Las instrucciones básicas de un lenguaje booleano son las que implementan las operaciones lógicas
booleanas existentes, como son:

Función de suma lógica, cuyo resultado es 1 si al menos uno de los operandos es 1.

AND

Función de producto lógico, con la que el resultado es 0 si al menos uno de los operandos es
0.

NOT

Negación del operando.

Leer una variable.

Guardar una variable.

Un programa escrito en lenguaje booleano es una secuencia de instrucciones que operan sobre las
entradas y variables internas secuencialmente, efectuando las operaciones que se indiquen paso a
paso en cada línea.

Además de estas instrucciones básicas son imprescindibles algunas que permitan acceder a los flags
de configuración del autómata, que permitan cargar salidas, leer entradas, activar contadores, etc.

119

Por otro lado surge el problema de las variables digitales, no binarias, y su manejo. Para ello se
añaden funciones aritméticas (ADD —suma—, SBB —resta—, MUL —multiplicar—), de manipulación
de datos (SHIFT —desplazamiento o rotación de bits—, CMP —comparar valores—, JMP —saltar a
otro bloque de programa—).

Al lenguaje booleano complementado con todo este tipo de instrucciones que permiten manejar las
variables no booleanas lo denominamos lenguaje de lista de instrucciones.

2.2.7. Diagramas de contactos

El lenguaje de programación por diagrama de contactos, conocido en inglés como Ladder Diagram,
es una representación gráfica de operaciones booleanas presentadas como una sucesión de
contactos eléctricos en serie y en paralelo, unidos entre sí por líneas, y que representan casi una
copia literal de los esquemas de relés de las maniobras eléctricas tradicionales.

Un contacto puede identificarse con un pulsador, un interruptor de fin de carrera, un presostato, un
sensor de temperatura que se activa a partir de una cierta temperatura, el contacto de salida de un
relé... en definitiva, cualquier elemento booleano que solo pueda estar en estado abierto/cerrado,
activo/desactivo, especialmente aquellos que estén presentes en maniobras eléctricas tradicionales.

120

En un diagrama ladder se siguen las operaciones gráficas de izquierda a derecha en cada línea, se
leen las entradas o bits representados por contactos, se cargan las salidas o bits como si fuesen
bobinas de relés y se operan lógicamente unas con otras como si se tratase de un circuito eléctrico
convencional, con sus contactos en paralelo (OR) y sus contactos en serie (AND) y analizando por qué
caminos podría pasar la corriente.

Cada uno de sus elementos gráficos transfiere su estado de ON u OFF por la derecha al siguiente
elemento, para el cual dicho estado es su entrada. A su vez cada elemento queda identificado con un
identificador numérico o alfanumérico que señaliza el bit correspondiente con ese gráfico. Vea el
siguiente EJEMPLO

Según el ladder de la siguiente imagen, la primera instrucción se ejecutará si el bit
identificado por 0000 se encuentra en ON, al estar a la derecha de un contacto normalmente
abierto gobernado por el bit 0000. Sin embargo la segunda instrucción se ejecutará si el bit
0000 está en estado OFF al estar a la derecha de un contacto normalmente cerrado.

Para implementar unas operaciones de AND entre varios operandos no hay más que
serializar sus contactos, de modo que el ramal resultante solo se activará cuando todos estén
simultáneamente activos (operación AND). Si incluimos un operando negado (con contacto
normalmente cerrado) se computará la AND con su negado, como en el siguiente caso:

121

La instrucción final del diagrama ladder anterior solo se ejecutará si el flag 0000 está ON, el
flag 0100 está en OFF y el falg HR000 está también en ON. Algebraicamente la instrucción
recibiría el valor: OOOO * (NOT 0100) * HR000

Para implementar operaciones de tipo OR, montaremos los contactos que usamos de
operando en paralelo, de modo que si se activa cualquiera de las ramas, se activaría la
instrucción siguiente:

En este ejemplo la instrucción se activará si el flag 0000 está en OFF, o si el flag 0100 está en
OFF o si el flag HR000 está en ON. Cualquiera de esas activaciones dejaría pasar la corriente
eléctrica, siguiendo el símil de los diagramas de relés, a la instrucción de salida.
Algebraicamente sería: (NOT 0000) + (NOT 0100) + HR000.

Al igual que ocurría con los lenguajes booleanos, esta representación cuenta con la limitación de su
naturaleza puramente booleana, que no le permite en principio trabajar con contadores, o con
valores numéricos. Para solventar este problema estos lenguajes introducen bloques de funciones
asignados a tareas frecuentes: contadores, temporizadores, etc. así como a funciones de control de
secuencia de ejecución como pueden ser los saltos dentro del código.

Amplíe información sobre algunos ejercicios de lenguaje ladder consultando el siguiente documento:

122

2.2.8. Plano de funciones

Como evolución natural a los esquemas de contactos y para superar su naturaleza booleana surgen
los planos de funciones, muy similares estructuralmente a un esquemático de funcionamiento de un
circuito de electrónica digital, frente a la similitud con un diagrama de relés del lenguaje ladder.

Cada bloque o función tiene un aspecto normalizado, generalmente este: a la izquierda tenemos las
entradas u operandos para la función, a la derecha las salidas y en el interior el identificador de la
función que ejecuta este bloque.

Puede ver el aspecto que tienen las operaciones básicas AND y OR en este lenguaje en el siguiente
EJEMPLO

Operaciones básicas AND y OR AND y OR

Funciones AND y OR en su simbología electrónica y con su símbolo lógico normalizado

En este lenguaje se incluyen multitud de bloques preconstruidos con muchas de las operaciones
disponibles con componentes electrónicos tradicionales: registros de desplazamiento, contadores,
multiplexores, demultiplexores, biestables, etc.

Aun así no existen bloques normalizados para cualquier función que se nos ocurra, por lo que
muchos fabricantes permiten la inclusión de bloques dentro de los que podemos establecer las
operaciones combinacionales o secuenciales que deseemos, que pueden ser especificadas, por
ejemplo, en lenguaje de contactos, por lo que el resultado es un híbrido que muestra grandes

123

bloques lógicos dentro de los cuales se pueden implementar funciones más complejas. A estos
bloques, que pueden incluir dentro de ellos incluso otros bloques, se les denomina macrobloques.

Algunos fabricantes, como Siemens, han desarrollado lenguajes mixtos de este tipo, como el
conocido STEP‐7.

2.2.9. Lenguajes de alto nivel

Con la velocidad que tienen actualmente los microprocesadores que conforman el corazón de la CPU
de los autómatas, sobre todo los autómatas de gama alta van invadiendo terrenos anteriormente
reservados a los ordenadores industriales junto con software de control específico, debido a la
complejidad de los programas que ejecutaban.

Por este motivo es cada vez más frecuente que los fabricantes proporcionen, al menos para algunos
autómatas de su gama, la posibilidad de programarlos en un lenguaje de alto nivel. Estos lenguajes,
tradicionales en la informática, suelen ser BASIC, C ó PASCAL preferentemente.

Con ellos no solo pueden implementarse las funciones ampliadas ya mencionadas en los lenguajes de
lista de instrucciones, booleanos y de bloques de funciones, sino que se tiene acceso a las
características fundamentales de la programación estructurada:

 Posibilidad de trabajar con funciones o procedimientos, y variables locales a ellas o globales.

124

 Incluyen los iteradores típicos de los lenguajes informáticos: bucles for, repeat ... until X,
while X do, así como los operadores condicionales IF … THEN … ELSE
 Proporcionan instrucciones de manejo de cadenas alfanuméricas.

Los autómatas que permiten estos lenguajes de alto nivel habitualmente permiten incluir sentencias
en los macrobloques o incluso en sus diagramas de contacto, lo que permite una más cómoda
utilización de esta sintaxis, menos familiar en muchas ocasiones para los programadores de
autómatas clásicos.

Otros fabricantes han optado por definir su propio lenguaje de programación de alto nivel, como es
el caso del Siemens SCL.

Amplíe información sobre el lenguaje de programación de Siemens, SCL consultando el siguiente
documento:

2.3. Programación de bloques funcionales

Hoy día quizás sea el lenguaje de programación más extendido, ya que los programas de bloques
funcionales se presentan comprensibles gráficamente, al mismo tiempo que permiten una
programación avanzada de cada uno de los bloques que posibilita ampliar las funciones básicas de

125

cada lenguaje con nuestro propio código, consiguiéndose además una buena reutilización de bloques
y algoritmos.

2.3.1. Introducción

Como ha visto en el apartado 2.2.7, los bloques funcionales amplían las posibilidades de procesado
de los autómatas por ofrecer la posibilidad de introducir complejos algoritmos en sus funciones
internas, aunque una vez definidos nos permiten usarlos de un modo sencillo, incluso en formato
gráfico dentro de un diagrama de contactos.

Actualmente muchos de los lenguajes de programación de los autómatas incluyen un conjunto de
bloques funcionales estándar con las funciones básicas más habituales, como temporizadores,
contadores, biestables, registros de desplazamiento y las funciones combinacionales más sencillas:
puertas AND, OR, operaciones matemáticas, etc.

Además de esos bloques estándar los lenguajes para autómatas más potentes permiten definir
funciones propias dentro de los bloques funcionales, usando lenguajes de diagrama de contactos,
literales o incluso de alto nivel. Estas posibilidades permiten implementar tareas muy complejas,
embutiendo funciones complejas dentro de bloques funcionales de modo que el programa global
quede perfectamente legible.

Tanto en los bloques funcionales preprogramados como en los programados libremente es necesario
indicar las operaciones que queremos realizar. Habitualmente, en el caso de los preprogramados hay
que indicar las entradas a usar, parametrizar la función realizada con parámetros de configuración

126

(tiempo del temporizador, número máximo de cuentas de un contador, etc.) y las salidas asociadas.
Además de poder usar estos parámetros fijos, también pueden parametrizarse las funciones con
otras variables internas, registros o resultados de otros bloques de operación.

En el caso de los programables, además de estas definiciones hay que implementar la propia función
de transferencia, combinacional o secuencial, que nos da el estado de las salidas en función de las
entradas y las variables internas.

2.3.2. Bloques secuenciales básicos

Entre los bloques básicos presentes en prácticamente todos los lenguajes de programación de
autómatas están los siguientes bloques secuenciales (aquellos cuyas salidas no solo dependen del
estado de las entradas, sino también de los estados internos actuales):

Biestables

Como ya vio en el apartado 2.1.3, los biestables son elementos hardware o software que mantienen
el valor de un estado binario indefinidamente hasta que no se reciba una nueva orden de cambio
para dicho valor. Esta orden habitualmente llega por dos líneas de mando: establecer (Set) y resetear
(Reset). A este biestable común se le puede denominar biestable RS. Cuando se activa la señal de
Set, esté como esté previamente el biestable pasa a estar a “1”. Por el contrario, cuando se activa la
señal de Reset, independientemente de su estado anterior pasará a “0”. La activación simultánea de
Reset y Set no está permitida y puede producir un resultado indeterminado. Vea el siguiente
EJEMPLO

Otro tipo de biestable bastante habitual es el denominado biestable JK, de comportamiento similar
al RS salvo que cuando se activan simultáneamente las líneas de establecer (J) y la de reset (K) el
estado, el lugar de ser indeterminado, pasa a ser el inverso del anterior. Si denominamos Q a la salida
del biestable (coincidente con su valor interno), la tabla de verdad del biestable JK sería la siguiente:

Este tipo de biestables JK introducen una dificultad: si se dejan permanentemente activas las señales
J y K la salida estaría cambiando constantemente de valor. Para salvar esta dificultad estos biestables
suelen tener una línea adicional de reloj, clock o sincronización que es la que determina en qué
momento se aplican los cambios indicados por las líneas J y K sobre la salida.

Este tipo de biestables con línea de reloj se denominan biestables síncronos, y en sistemas
secuenciales medianamente complejos es habitual usarlos con una línea global de reloj que
sincroniza el momento en que todos los biestables y demás elementos secuenciales validan sus
estados, lo que da estabilidad a todo el sistema. El instante preciso en que la señal de reloj valida los
cambios suele ser uno de sus flancos, normalmente el de subida.

127

Biestable tipo RS

Aquí vemos un biestable de tipo RS que carga la variable de salida "outVar" con su valor
interno, que será:

— “0” si se activa al menos una de las variables “memVar1”, “memVar2” o “stopVar”.

— “1” si no se activa “memVar3” (obsérvese que está invertida), y además se activa al menos
una de las variables “inVar” o “alwaysTrue”.

Mientras que no se produzca ninguno de esos cambios, se mantendrá indefinidamente el
último valor guardado.

Contadores

En el apartado 1.2.8 se describieron los contadores de alta velocidad, que son los que usan hardware
específico para manejar pulsos muy rápidos sin sobrecargar el trabajo de la CPU. Si la tarea
encomendada al contador es el seguimiento de señales con periodos de trabajo más rápidos que el
tiempo de ciclo de ejecución del programa de usuario, se tendrá que recurrir a usar contadores
rápidos para dicha función.

Tal como se describió en dicho apartado, los contadores pueden ser unidireccionales (conteo solo en
una dirección), bidireccionales con señal Up y señal Down o bidireccionales con señal de conteo y
señal de dirección (Up/Down).

La implementación más habitual como bloque funcional maneja valores de conteo de 0 a 9999 (de
modo que se implementan con una variable interna de 16 bits).

Además de las señales de conteo (Up, Down, Up/Down) se precisan otras, que suelen ser:

 Preset, P. Al activarse carga un valor de conteo predeterminado en el contador.
 Preset Value, PV. Valor que se carga en el contador al activarse Preset. Puede ser una
variable interna, o un valor fijo.
 Reset, R. Al activarse se pone a cero el valor de contador.
 Enable, E. Señal de habilitación que desactiva el funcionamiento del contador cuando la
entrada no está activa.

128

Por otro lado, se suele tener otra variable asociada, esta binaria con un cierto valor numérico, que
indica o bien el valor final de conteo o el valor que se asigna al contador al activarse la señal PV
(Preset Value).

Dependiendo del tipo de contador, la salida (siempre booleana) del contador se activará o bien al
alcanzar el valor final de conteo o bien al llegar al valor “0”.

Además de la salida booleana del contador el programa de usuario puede acceder al valor actual de
conteo del contador en todo momento. Debajo de este listado se muestra como ejemplo el uso de
un contador bidireccional con señal de Up y señal de Down independientes, el denominado tipo
CTUD en el lenguaje de programación STEP 7.

Temporizadores

Un temporizador es un dispositivo capaz de realizar temporizaciones precisas como reacción a
señales de entrada por sí mismo, sin ocupar tiempo de procesado de la CPU.

Para gestionar los temporizadores debemos asignar las entradas o bits internos que gestionan sus
líneas de control e indicar la constante de tiempo que queremos usar, bien sea procedente de una
variable interna, bien sea un valor fijo. Resulta recomendable hacerlo a través de una variable
interna, porque así se facilita la posterior explotación de la aplicación, permitiendo que el usuario
pueda modificar dentro de un cierto rango de valores esa temporización para realizar un ajuste fino
del funcionamiento del programa en fase de explotación.

Para definir el tiempo que deseamos programar hay que considerar la base de tiempos usada por el
temporizador, ya que dependiendo del lenguaje de programación e incluso del autómata en concreto
pueden especificarse de forma distinta: con base en milisegundos, con base en décimas de segundo,
etc. Por ejemplo, un temporizador con base de tiempos en décimas de segundos en el que se asigna
el valor “55” a su módulo de tiempo quedaría configurado con una temporización de 5 segundos y
medio:

Tiempo = base de tiempos * módulo de tiempos.

Existen diferentes modalidades de temporizadores dependiendo del tipo de comportamiento
temporal que se desee conseguir; se destacan los principales (ver listado abajo).

Registros de desplazamiento

Los registros de desplazamiento son bloques funcionales que permiten gestionar el desplazamiento o
rotación de bits de un registro de datos de una cierta longitud.

Los desplazamientos son operaciones a nivel de bit que trasladan todos los bits de un registro bien
una posición a la derecha, bien una posición a la izquierda.

 Para desplazar los bits a la derecha se procede como se indica en la imagen de la derecha: a
cada posición de bits de la palabra (de 8 bits en este ejemplo) se le asigna el bit que estaba a
su izquierda, de forma que el resultado tiene los bits desplazados a la derecha.

129

Al bit más representativo (el de mayor peso, el de la izquierda) de la palabra se le denomina MSB

(Most Significant Bit) y al menos significativo LSB (Least Significant Bit, el de la derecha). Como puede
ver en esta operación se pierde el LSB original, ya que no tiene a quien asignársele. En algunos
bloques funcionales, el estado del LSB que se perdería se presenta en una salida de bit especial, a
veces denominado bit de rebose. Del mismo modo, en el nuevo MSB “entra” un nuevo bit
inexistente en la palabra original. El valor que tomará este nuevo bit es el que se indique en una
entrada de datos del bloque funcional.

La operación de desplazar 1 bit a la derecha un número binario equivale a dividir entre 2 el número
original. Además, el resto de la división sería el bit que saldría por la salida de rebose.

 En el caso del desplazamiento a la izquierda tenemos un caso similar aunque cambian los
extremos: el MSB se perderá, y eventualmente se mostrará por la salida de rebose, mientras
que el LSB adquirirá el valor presente en la entrada de datos del bloque funcional. (Esta
operación de desplazamiento de 1 bit a la izquierda de un número binario equivale a
multiplicar por dos el valor binario original).

La implementación hardware de un registro de desplazamiento de n bits se realiza con n biestables
síncronos conectados secuencialmente, siendo la salida de un biestable la entrada del siguiente,
realizándose las operaciones de carga de todos los biestables en sincronización con una señal de
reloj, normalmente activa en su flanco de transición de subida.

En el caso del registro de desplazamiento hardware presentado en la imagen, el nuevo bit de datos
(el que pasa a ser el MSB en el caso de rotar a la derecha como hace este registro) entra como
operación lógica “A AND B”, la línea de reloj cuyos flancos producen cada desplazamiento es CP y la
señal MR (Master Reset) hace que todos los bits internos pasen a cero cuando se activa. Por su parte

130

el LSB sería Q7, y además como puede verse tenemos disponibles todos los bits intermedios en las
líneas desde Q0 a Q7.

Los bloques funcionales pueden implementar registros de desplazamiento hacia la izquierda, hacia la
derecha o bidireccionales. En este último caso precisan de otra línea de entrada que indica la
dirección de desplazamiento que se aplicará.

Uso de un contador de tipo CTUD: EJEMPLO

Ejemplo de uso de un contador de tipo CTUD

La entrada 0 del módulo de expansión 0 (I0.0) se usa como señal de conteo ascendente (CU,
Count Up). A su vez la entrada 1 del mismo módulo de expansión (I0.1) se usa como señal de
conteo descendente (Count Down). Cada vez que se active la entrada 2 del módulo 0, el valor
de conteo pasará a cero (entrada Reset), y finalmente el valor de carga de final de conteo es
fijo, siendo 10 el valor asignado (conectado a PV, Preset Value). En la siguiente línea de
programa vemos que la salida de contador (C3) se asigna a la señal de salida 0 del módulo de
salidas 0 (Q0.0). De este modo, tras resetearse el contador (por activación de I0.2), la salida
se activará cuando se hayan dado 10 pulsos más de Up que de Down, sea cual sea el valor
total de pulsos que se hayan aplicado en cada dirección (por ejemplo, cuando se hayan dado
97 pulsos de Up y 87 de Down).

131

Lista de temporizadores

Temporizador de impulso

En este modo de funcionamiento programamos un tiempo de impulso, t, durante el cual el
temporizador estará activo tras activarse su línea de establecimiento (Set). La salida del
temporizador se mantendrá activa hasta que:

 Finalice el pulso de Set.
 Se active la línea de Reset.
 O bien se alcance el tiempo de impulso programado, t.

Puede verse gráficamente en el siguiente diagrama:

En el primer pulso de la línea Set observamos la desactivación de la salida por alcanzarse el tiempo
total programado (t). En la segunda activación vemos cómo se desactiva la salida antes de alcanzarse
el tiempo programado, porque previamente se desactivó la línea de Set. Y finalmente en la tercera
activación puede ver cómo se desactiva la salida por activarse la línea de Reset.

Temporizador de impulso prolongado

Este tipo de temporizador tiene un comportamiento muy parecido al anterior, diferenciándose en
que la salida no se desactiva si se desactiva la línea de establecimiento (Set). De este modo, cada vez
que se activa la señal de Set se activará la salida durante un tiempo t, hasta que se alcance dicho
tiempo o que se active la señal de Reset.

En la primera activación de la línea de Set vemos como la salida pasa a desactivarse tras alcanzar el
tiempo total programado, aún continuando activa la línea Set. En la segunda se desactiva por tiempo,
pero habiéndose desactivado previamente la línea Set. En el siguiente tren de activaciones de Set,
vemos que la salida no llega a desactivarse ya que antes de alcanzar el tiempo programado (t) se
recibe un nuevo impulso de Set, desactivándose finalmente por la activación del Reset.

132

Temporizador de retardo de conexión

Este tipo de temporizadores son muy útiles para filtrar señales breves que no deban ser aceptadas en
el sistema. Por ejemplo, para filtrar pulsos cortos que emita una sonda de detección de presencia en
circunstancias de falsa alarma y que estos no sean considerados como alarma por el sistema.

En este caso el tiempo programado, t, indica el tiempo mínimo que tiene que estar activa la señal de
Set para activar la salida del temporizador. Hasta que no se alcanza dicho tiempo mínimo, la salida no
se activa.

En la siguiente imagen puede ver reflejado este comportamiento bajo distintas circunstancias:

Podemos observar cómo el segundo pulso de Set ha sido filtrado en la salida por no haber alcanzado
la línea de Set el tiempo mínimo programado (t).

Temporizador de retardo a la desconexión

En esta modalidad el temporizador, en lugar de filtrar la señal de Set durante un tiempo
determinado, lo que hace es alargarla en ese tiempo. Es decir, la salida está activa desde que se
activa la señal de establecimiento (Set) y cuando esta se desactiva se pone en marcha el
temporizador manteniendo la salida activa durante un tiempo t adicional.

Puede ver este comportamiento en el diagrama siguiente:

Puede ver cómo la Salida se activa de inmediato al establecerse la señal de Set, pero no se desactiva
al desactivarse la salida, sino que lo hace tras transcurrir un tiempo t con la señal Set desactiva. Y si
antes de cumplirse ese tiempo se vuelve a activar Set, la salida no llegará a desactivarse.

133

2.3.3. Bloques funcionales de expansión

Los bloques funcionales de expansión permiten definir funciones propias, que podrán utilizarse en
los programas y almacenarlos en librerías para poder usarlos en otros sistemas. Por ejemplo, podrá
crearse una función llamada arranque_motor, que pida la salida a la que está activada el motor y
arrancar varios motores usando dicha función.

Normalmente los lenguajes de programación de autómatas permiten integrar en estos bloques
funcionales todo el potencial disponible con acceso al conjunto completo de funciones avanzadas,
como las de manejo de datos, de cadenas alfanuméricas, de comunicación con otros dispositivos y
autómatas, etc. En autómatas de gama alta se suele acceder a funciones avanzadas, como manejo de
números decimales en coma flotante, operaciones trigonométricas, etc. La contrapartida suele ser
una velocidad de ejecución más baja que la de los bloques funcionales estándar, por lo que hay que
gestionarlos con cuidado.

Funciones habituales en la programación de los bloques funcionales de
expansión

Operaciones de transferencia de datos

Las funciones de transferencia de datos se utilizan para traspasar información entre registros
internos, bloques secuenciales, direcciones de entrada o de salida, etc. al mismo tiempo que pueden
ser cambiados sus formatos de representación (de BCD a binario puro, por ejemplo) o tamaño de
almacenamiento.

Estas operaciones suelen ser necesarias antes de procesar dichos valores numéricos con las
operaciones que veremos en el siguiente apartado, preparando los formatos apropiados para alojar
los valores intermedios y de resultados de nuestro procesado.

Otras funciones avanzadas de movimiento de datos permiten mover bloques de memoria entre
distintos dispositivos con una sola operación, por ejemplo para transferir un bloque grande de datos
del PLC a un visualizador externo.

El movimiento de datos entre distintos dispositivos puede hacerse a través de protocolos propios del
autómata, usualmente para comunicar periféricos estándar del mismo fabricante, a través de
protocolos de comunicación estándar para comunicar con periféricos de distintos fabricantes, o
finalmente a través de un protocolo propio definido por el programador.

134

El uso del protocolo propio del autómata suele ser muy sencillo, con bloques funcionales específicos
que permiten intercambiar información entre PLC y consola de explotación, visualizadores o
pantallas. Generalmente el PLC dispone de una toma de conexión específica para estos elementos y
este formato propietario de comunicación, bien en el cuerpo del PLC, bien a través de bastidores de
expansión, y su uso se limita a definir la dirección de destino de datos o incluso solo el tipo de
dispositivo con el que queremos conectar.

Por otro lado en autómatas de gama media es muy habitual disponer de conexiones con buses de

comunicación estándar, compartidos por distintos fabricantes y que nos permiten interconectar
periféricos de distintas gamas de productos e incluso de otros fabricantes. Algunos de los protocolos
más habituales para comunicar estos elementos son: MODBUS, PROFIBUS, CANBUS, LONWORKS...

El uso de las funciones de traspaso de datos entre dispositivos a través de estos protocolos es un
poco más complicadas que las comunicaciones por buses propietarios ya que al ser genéricos
disponen de múltiples parámetros de funcionamiento para adecuar la comunicación a la requerida
por el dispositivo periférico con el que queremos conectar. Por tanto, hay que asegurarse de
parametrizar de modo correcto la conexión con el bus de expansión, con parámetros diversos según
el tipo de protocolo empleado: velocidad de comunicación, largo de datos, bits de arranque y
parada, direcciones de destino de datos, contraseña de acceso al dispositivo, etc.

Estos protocolos permiten ampliar las posibilidades de actuación del PLC al conectarse, por ejemplo,
a software de control y supervisión de tipo SCADA en ordenadores.

Operaciones matemáticas

Las operaciones matemáticas básicas, como: suma, resta, multiplicación y división de números
enteros, así como las operaciones lógicas entre palabras (AND, OR, NOT, XOR) suelen estar
disponibles en toda la gama de PLCs, aplicables normalmente a palabras de 16 bits (recordemos,
valores de 0 a 65535 para números positivos, de ‐32768 a 32767 si se usa signo, y de ‐9999 a 9999 si
se usa en BCD).

Cuando las operaciones usadas desbordan el rango descrito, el valor resultante se trunca a 16 bits

quedando activo un flag interno especial que se denomina “acarreo”. Hay operaciones aritméticas de
gestión de este acarreo que nos permiten expandir el rango de manejo de datos mediante software,
como en este EJEMPLO.

135

Acarreo

La suma BCD de 8000 y 7000 daría 5000 (15 000 no podría exprearse en BCD de 4 dígitos),
quedando activo el flag de acarreo, que nos indica que la expresión anterior superó el rango
de las 10 000 unidades.

Las funciones lógicas sobre palabras más habituales son la OR de dos palabras de 16 bits y la AND.
Otro grupo importante de funciones matemáticas básicas son las comparaciones entre datos
numéricos, que nos indican simplemente si se cumple o no la condición de comparación entre los
datos de entrada seleccionados. Las operaciones disponibles son:

 Igualdad (=). Resultado activo (verdadero) si ambos datos de entrada son iguales.
 Mayor que (>). Activo si el primer parámetro es mayor que el segundo.
 Menor que (<). Activo si el primer parámetro es menor que el segundo.
 Mayor o igual que (>=). Activo si el primer parámetro es mayor o igual que el segundo.
 Menor o igual que (<=). Activo si el primer parámetro es menor o igual que el segundo.

A continuación dispone de una pequeña explicación de los protocolos habituales para la
interconexión de periféricos son los siguientes:

 Profibus
Profibus (Field Bus Process) es el estándar propietario (no libre) para la comunicación por bus
en la tecnología de automatización y fue promovido por primera vez en 1989 por el BMBF
(departamento alemán de educación e investigación) y luego utilizado por Siemens.
No debe confundirse con el estándar Profinet para la industria de Ethernet.
 ModBus
Modbus es un protocolo de comunicación en serie publicado por Modicon en 1979 para su
uso con controladores lógicos programables (PLC). Simple y potente, se ha convertido desde
entonces en uno de los protocolos de comunicación estándar de facto en la industria, y
ahora se encuentra entre las formas más comunes disponibles para conectar dispositivos
electrónicos industriales. Es un protocolo abierto libre de derechos.
 Bus CAN (Controller Area Network)
El bus CAN es un protocolo basado en mensajes, diseñado específicamente para aplicaciones
de automoción, pero que ahora también se utiliza en otras áreas como la automatización
industrial y los equipos médicos.
El desarrollo del bus CAN comenzó inicialmente en 1983 en Robert Bosch GmbH. Este
protocolo se publicó oficialmente en 1986 en la Sociedad de Ingenieros de Automoción (SAE)
en Detroit.
 AS‐Interface:
AS‐Interface (Actuator Sensor Interface, AS‐i) es una solución de red industrial (capa física,
método y protocolo de acceso a datos) utilizada en sistemas de automatización basados en
PLC.
Está diseñada para conectar dispositivos simples de I/O (binarios como dispositivos ON/OFF :
actuadores, sensores, codificadores rotativos, entradas y salidas analógicas, pulsadores y
sensores de posición de válvulas) en aplicaciones de fabricación discreta y de proceso
utilizando 2 cables de un solo conductor.

136

La AS‐Interface es una tecnología ‘abierta’ utilizada por muchos proveedores de equipos de
automatización.
 Interbus
El Interbus con velocidades de transmisión de hasta 2 Mbps se caracteriza por una seguridad
de transmisión especialmente alta y un tiempo de ciclo corto y constante. Está dividido en
subsistemas y consta del bus remoto, el bus remoto de instalación y el bus local dispuesto en
una topología de anillo.

2.3.4. Instrucciones especiales

Las instrucciones especiales son aquellas más específicas de cada lenguaje de autómata, por lo que
habitualmente no son compatibles entre distintos lenguajes ni entre distintas marcas de PLC. Incluso
no siendo exactamente compatibles hay ciertas instrucciones que por su utilidad están disponibles
de un modo u otro en la mayoría de lenguajes.

Dentro de esta categoría podemos considerar ciertos tipos, como son: instrucciones de diagnóstico,
de paréntesis, de pausa y de control.

Instrucciones de diagnóstico

Este tipo de instrucciones proporcionan códigos de estado y de alarmas de autochequeo internos, así
como cadenas de texto que muestran en qué estado de funcionamiento se encuentra el PLC.

Habitualmente estas salidas se trasladan a otros periféricos como pantallas conectadas al PLC en
explotación o bien a visualizadores de mensajes conectados a la toma de terminal del PLC.

Instrucciones de paréntesis

Del mismo modo que usamos los paréntesis para agrupar y ordenar los cálculos matemáticos en una
expresión donde se concantenan numerosos operadores aritméticos, en los lenguajes de PLC existen
funciones de agrupación que permiten clarificar el orden de aplicación de una sucesión de
instrucciones sucesivas, facilitando la comprensión del programa y asegurando que la secuencia de
instrucciones se aplica tal como se ha diseñado.

Obsérvese cómo cambia el sentido de aplicación de los operadores la inclusión de los paréntesis en
el siguiente EJEMPLO:

Uso de paréntesis y diagramas de contactos equivalentes

137

Instrucciones de pausa

En distintos formatos siempre tendremos disponibles funciones de pausa temporal en la ejecución
del programa de usuario, que nos permite introducir una temporización extra entre dos operaciones
consecutivas.

Esta pausa se da dentro de cada ciclo de ejecución, y no tiene nada que ver con el tiempo total de
ciclo de ejecución. Obviamente cualquier pausa introducida ampliará el tiempo de ciclo de ejecución
en ese mismo tiempo.

Instrucciones de control de acceso

Estas palabras de control permiten bloquear el acceso al código de programa mediante contraseñas,
de modo que nadie no autorizado pueda visualizar y mucho menos alterar el contenido del programa
de usuario.

Es también habitual introducir varios niveles de acceso, de modo que cada usuario diferente pueda
acceder a una vista total de la aplicación (acceso de supervisión) o a una versión reducida (acceso de
usuario).

138

2.4. Estructuras de programación

Una vez presentadas las diferentes técnicas de programación centramos este tema en mostrar
aspectos específicos de las tareas de programación de control de instalaciones, como pueden ser la
multitarea, la atención a interrupciones, la parametrización de bloques funcionales o la
programación de periféricos inteligentes. Todos estos conceptos o no están presentes en los
entornos de programación convencionales o bien siguen un criterio muy diferente por lo que es
interesante conocerlos.

2.4.1. Introducción

En los capítulos anteriores se ha explicado cómo llegar a programar el programa de usuario,
verdadero sentido del PLC, y cómo el autómata es capaz de obedecer la secuencia de órdenes que
contiene.

Hasta ahora siempre se ha tratado el programa de autómata como una entidad que desarrolla una
tarea única, aunque dentro pudiese haber caminos de ejecución simultáneos como se mostró en los
diagramas GRAFCET y sus divergencias en Y (capítulo 2.1.11).

139

A esta estructura que trata el procedimiento a realizar como una única tarea, implementada con el
programa de usuario, se le denomina monotarea. En ella el programa incorpora todas las variables y
procedimientos para hacer la gestión completa del sistema y manejar las salidas convenientemente.

Como contraposición a esta estructura de trabajo se plantea la posibilidad de entornos de trabajo
multitarea, donde el programa de usuario se divide conceptualmente en varias tareas
independientes (donde cada una de ellas podría ser considerada una monotarea).

Cada una de estas tareas simultáneas sigue el ciclo de trabajo ya conocido para las aplicaciones de
autómatas convencionales: lectura de entradas, ejecución del ciclo de programa de la tarea, escritura
de salidas y atención a periféricos.

Algunos PLC incorporan hardware específico para optimizar el funcionamiento de las aplicaciones
multitarea mediante el uso de varias CPU (multiprocesadores) o más recientemente con el uso de
procesadores de varios núcleos, pudiendo correr cada tarea en un procesador o núcleo separado.

Una vez escogida la estructura de programación que deseemos usar, sea monotarea o multitarea,
cada una de las tareas resultantes son programadas como un programa de usuario independiente,
que a su vez puede implementarse con programación lineal o estructurada.

Se entiende por programación lineal aquella que genera secuencias de instrucciones correlativas que
se van ejecutando una tras otra en ese mismo orden.

Por el contrario, en programación estructurada el programa principal se divide en módulos y
subrutinas que implementan cada una de las operaciones que puedan ser repetitivas o que sea
interesante agrupar de modo lógico, de forma que el programa principal puede llamar a esas
subrutinas una o varias veces según se necesite, clarificando el código por la agrupación de las tareas
comunes.

Por ejemplo, si necesitamos arrancar varios motores de diferentes potencias, podremos crear
un bloque que nos permita incluir el número del motor, y arrancar cada motor usando el mismo
bloque

140

2.4.2. Programación lineal

En GRAFCET este tipo de saltos se implementan con las divergencias en O.

Para poder efectuar saltos de código en lenguaje de diagrama de contactos es necesaria la adición al
lenguaje de marcas denominadas LABEL (etiquetas) que indiquen las direcciones a las que se puede
saltar, y se incorporan además al lenguaje de contactos instrucciones de salto a dichas posiciones
marcadas por etiquetas (LABEL).

Vea el siguiente EJEMPLO

Instrucción de salto en diagrama de contactos

En este ejemplo, si la entrada E0.1 está activa se saltará el segmento 2 de programa, no
chequeándose la entrada E0.2 por pertenecer al segmento 2, que ha sido saltado. Sin
embargo, si la entrada E0.1 no está activa no se ejecuta el salto incondicional (JMP) por lo
que se pasa a la siguiente línea de ejecución, se comprueba la entrada E0.2, y de estar activa,
se activará finalmente la salida A0.1.

Las instrucciones condicionales de salto permiten implementar estructuras de

bucles típicas de los lenguajes de alto nivel, tales como iteradores de tipo FOR,
WHILE... DO, etc.

TOME NOTA

2.4.3. Programación estructurada

En autómatas programables se entiende por programación estructurada la que permite
descomponer el programa de usuario en módulos que implementan fragmentos parciales de la tarea
a realizar y que son invocados desde el programa principal.

Al dividir el programa en tareas más reducidas y sencillas, que luego van siendo llamadas, se mejora
la claridad del código y simplificamos la programación de cada una de esas tareas. Para permitir esta

141

división se dispone de dos herramientas: las subrutinas y la programación modular. La división del
programa en módulos y subrutinas facilita también el trabajo de distintos programadores en el
mismo proyecto, de forma que cada uno puede ir desarrollando módulos independientes y
subrutinas que luego pueden usarse conjuntamente desde el programa principal. Otra ventaja es la
mejora de la documentación y de la reutilización del código, gracias a la agrupación de las subrutinas
en librerías de software que pueden ser utilizadas en otros proyectos.

Subrutinas

Son bloques de programa que tienen una cierta entidad propia y que pueden usarse varias veces a lo
largo del programa. Las subrutinas pueden usarse con o sin programación modular, y facilitan la
programación al ejecutar cada una de ellas un subprograma reducido, concreto y más sencillo de
depurar.

Si la aplicación necesita realizar una misma tarea en diferentes ocasiones durante el transcurso del
programa es conveniente definir esa tarea en una subrutina a la que le asignamos un nombre
identificador, y que será invocada por el programa principal u otras subrutinas por su nombre. La
llamada de una subrutina desde dentro de otra subrutina se denomina anidamiento.

A cada subrutina se le puede traspasar un conjunto de variables denominadas parámetros, cuyos
valores serán usados en el código interno de la subrutina según el algoritmo que se desee. El final de
ejecución de la subrutina debe ser señalado por una instrucción especial de final de subrutina
(RETURN habitualmente), que indica a la CPU que debe volver la ejecución al programa o subrutina
que la llamó.

Un tipo especial de subrutina es aquel que devuelve un valor al programa que la llamó como
resultado de su ejecución, valor que dicho programa utilizará para sus siguientes operaciones. A este
tipo particular de subrutina se la denomina función.

Programación modular

La programación modular divide la tarea total en distintos módulos que suelen ser independientes
entre sí y que son invocados desde el módulo principal o raíz, que es lo más sencillo posible y va
llamando a los distintos módulos de programa. En autómatas es posible utilizar diferentes lenguajes
de programación para cada uno de los módulos, usando para cada tarea el más conveniente.

142

El programador decide, en función de la automatización a la que se enfrenta, definir los módulos que
crea convenientes para conseguir una buena claridad de código y una división razonable de la tarea
principal.

En algunos casos es la propia plataforma de desarrollo de software para el PLC la que impone el uso
de distintos módulos para distintas tareas. Por ejemplo en el lenguaje literal STEP 7 de Siemens se
usa una estructura modular abierta en la que se pueden usar estos distintos tipos de módulos:

 Módulos de organización (OB), llamados directamente por el sistema operativo y que
controlan el comportamiento global del autómata. Algunos de los módulos de control
disponibles en STEP 7 son:
o OB 1. Se invoca cíclicamente e implementa las llamadas al programa de usuario.
o OB 21. Es llamado al darse una transición de STOP a RUN del autómata.
o OB 22. Se invoca cuando se produce un rearranque por pérdida de suministro
eléctrico.
o OB 34. Se invoca cuando se da un fallo de batería de mantenimiento de memoria no
volátil.
 Módulos de programa (PB). Estos módulos son los que contienen el programa de usuario, y
son invocados desde el programa de control OB 1.
 Módulos funcionales (FB). También incluyen operaciones del programa de usuario, pero
permiten instrucciones especiales avanzadas del lenguaje de programación. Existen módulos
funcionales ya programados que cubren tareas complejas y repetitivas que pueden
comprarse al fabricante, facilitando la programación de la aplicación.
 Módulos de datos (DB). Los módulos de datos definen variables usadas por el programa tales
como cadenas de texto, constantes numéricas usadas por el resto de los módulos, códigos
binarios, valores de configuración de periféricos, etc.

En los lenguajes de programación existen multitud de funciones básicas ya definidas, como pueden
ser las operaciones matemáticas básicas (ADD, SUB, MUL, DIV), las operaciones lógicas (AND, OR,
XOR), etc.

143

Una vez que el programador programa una nueva subrutina, podríamos considerar que ha efectuado
una ampliación del lenguaje de programación incorporando una nueva función avanzada al lenguaje,
función que podrá incluso usar en futuros programas incorporando la librería o módulo donde se
englobe a dichos programas.

Anteriormente hablamos de los bloques de instrucciones “macro” (apartado 2.4.2), conjunto de
instrucciones que pueden ser invocadas por su nombre varias veces en el transcurso del programa,
igual que las funciones. Sin embargo, mientras que el programa final vuelve a incluir todo el código
de la macro cada vez que es utilizada (aumentando el largo del programa con todas las operaciones
incluidas en la macro cada vez que se invoca), en el caso de la función sus instrucciones solo se
incluyen una vez en el programa final, consistiendo cada una de las llamadas a ella que se efectúen
en una simple instrucción de llamada a subrutina (CALL) acompañada con el identificador de
subrutina a la que se invoca. Esta prestación puede llegar a reducir considerablemente el tamaño
final del programa de usuario.

2.4.4. Programación multitarea

Como se expuso en el apartado 2.4.1, en un entorno de programación multitarea con autómatas
programables el trabajo se reparte en distintas tareas que atienden normalmente algún campo
concreto del trabajo a realizar, cada una tiene las características de un programa de usuario concreto
y su ejecución sigue el ciclo ya conocido de lectura de entradas, escrutinio de programa, escritura de
salidas y atención a periféricos una y otra vez.

La programación multitarea no es muy habitual en autómatas programables, por lo que su uso queda
restringido a modelos específicos de alta gama.

Antiguamente solo los grandes autómatas multiprocesador podían obtener todo el beneficio de un
entorno de programación multitarea al asignar el uso de un procesador diferente a cada tarea.
Actualmente con los microprocesadores de varios núcleos (procesadores multinúcleos, multicore en
inglés) puede hacerse lo mismo al dedicar cada núcleo a una tarea diferente, de forma que cada una
de ellas puede verdaderamente ejecutarse de forma simultánea.

Para mantener la operación de un sistema multitarea es imprescindible el control mediante un
programa especial supervisor que controla el acceso de cada tarea a los elementos compartidos por
los procesadores o núcleos, como son:

 Buses internos
 Buses externos
 Memoria
 Contadores
 Temporizadores
 Periféricos internos

Para organizar el uso compartido de estos recursos, el programa supervisor implementa una
estrategia de prioridades y de reparto de tiempos, de modo que va permitiendo el acceso a los
recursos compartidos alternativamente a las distintas tareas en función de la prioridad asignada a
cada una de ellas.

Excepto en los momentos en que las tareas esperan disponer de permiso para poder acceder a un
recurso compartido, cada una se ejecuta libremente y sin interrupciones en su procesador, sin

144

interferir ni entorpecer a las demás, por lo que se consigue una velocidad de ejecución superior a la
que se obtendría en un entorno de trabajo monotarea.

En el procesado en tiempo real de plantas industriales es donde mayor partido se puede obtener de
estas estructuras de funcionamiento, ya que podemos separar en distintas tareas las funciones
genéricas que requieren poca velocidad de respuesta por un lado y las que requieren una elevada
velocidad de respuesta por otro, asignando a esta última tarea la prioridad de funcionamiento. De
este modo nos aseguramos de que todos los apartados relacionados con el control rápido en tiempo
real se procesen de la forma más rápida posible.

En algunos entornos de trabajo multitarea se permite incluso escribir cada una de las distintas tareas
en lenguajes de programación distintos, de forma que podemos usar el más apropiado para las
particularidades de cada una de las tareas.

2.4.5. Tareas rápidas e interrupciones

La necesidad de proporcionar una atención rápida a ciertos eventos en entornos de control en
tiempo real hace que algunos fabricantes incorporen en sus autómatas programables monotarea
estructuras rápidas que permitan una atención inmediata de eventos saltándose el ciclo de trabajo
convencional.

En los apartados 1.2.6, 1.2.7 y 1.2.8 expusimos el procesado rápido de programas y los contadores
rápidos. La función de atención a interrupciones avanza aún más que dichas funciones en la atención
inmediata de eventos.

Una tarea de interrupción es un código de programa que pasa a ser ejecutado de inmediato al
dispararse cierto evento, independientemente de en qué punto se encuentre el ciclo de ejecución
del programa de usuario.

145

En realidad en todo PLC existen interrupciones funcionando constantemente aunque no sean
accesibles ni visibles por el usuario, ya que buena parte de la gestión del sistema (chequeos de CPU,
verificación de funcionamiento de programa de usuario, mantenimiento de las bases de tiempo
maestras) se implementa internamente mediante interrupciones del sistema operativo.

Las interrupciones pueden dispararse por eventos internos o externos a la CPU.

Eventos externos

Los eventos externos se usan para detectar eventos muy cortos o ante los que hay que reaccionar
muy rápidamente, y pueden dispararse por:

 Activación o desactivación de una entrada. Para conseguir una mayor rapidez ante dicho
evento los PLC suelen disponer de entradas rápidas, que eliminan parte del filtrado de
protección para conseguir cambios de estado más inmediatos.
 Alcance de un valor de finalización de un contador rápido, que recibe pulsos de conteo a
través de una entrada.

Eventos internos

Entre los eventos internos capaces de disparar una interrupción podemos destacar:

 Cambio de un relé interno.
 Final de temporización de un contador.
 En ambos casos hay que tener en cuenta que el código asociado al disparo de una
interrupción debe siempre plantearse lo más corto posible, ya que puede llegar a ejecutarse
literalmente miles de veces por segundo, ralentizando la ejecución del programa principal e
incluso llegando a hacerlo inviable por el aumento que produce su disparo en el tiempo de
scan.
 Cuando un programa de usuario trabaja con interrupciones, su estructura de trabajo resulta
similar a una aplicación bitarea, con una tarea principal que es la que gestiona la mayor parte
del programa de usuario y una pequeña tarea de alta prioridad que sería ejecutada con el
salto de las interrupciones.
 Es la tarea principal la que dispone del control para activar y desactivar la ejecución de las
interrupciones, pudiendo detenerlas por completo o temporalmente dependiendo de las
circunstancias concretas.
 Por ejemplo, al establecer una comunicación con un periférico externo a través de un bus de
comunicaciones, podemos configurar una interrupción que chequee periódicamente si hay
datos para leer en el buffer de entrada.

146

2.4.6. Parametrización de módulos funcionales

En el apartado 2.3.3 se presentaron los bloques funcionales de expansión, bloques cuya
funcionalidad no es estándar y que implementan funciones que no son parte nativa del lenguaje de
programación, sino que se han programado a posteriori. Estos bloques pueden ser escritos por el
propio programador o pueden ser comprados en paquetes de software de ampliación de
funcionalidades. Habitualmente se almacenan en librerías temáticas con otros bloques que manejan
aspectos similares: manejo de comunicaciones, regulación PID, etc.

La parametrización de módulos funcionales supone un paso más en la capacidad de reutilización del
software, permitiendo que puedan ser usados de un modo mucho más flexible y que puedan
invocarse múltiples veces durante la ejecución del programa de usuario efectuando tareas algo
diferentes en cada caso. Vea el siguiente EJEMPLO

Ejemplo parametrización módulos funcionales

Imagine que controla una instalación compuesta por 8 motores de impulsión de agua y 8
electroválvulas asociadas con ellos que deben ser maniobradas de forma sincronizada con los
motores. Podríamos pensar en diseñar un módulo funcional que implemente la tarea de
arrancar un motor, maniobrando de forma conveniente su electroválvula y realizando los
chequeos de que el proceso se ha ejecutado convenientemente. Con un bloque funcional de
expansión sin parametrización podríamos escribir el código para manejar el motor M1 junto
con la válvula V1, otro bloque para el motor 2, y así hasta completar 8 bloques funcionales de
expansión, que serían usados por la aplicación en todos los puntos donde se necesitase
arrancar uno de los motores.

Parametrizar el bloque funcional implica definir una serie de parámetros de entrada al bloque, que
no apuntan a priori a ningún elemento concreto, y operar con ellos internamente sin tener en cuenta
qué elemento concreto se manejará cuando sea invocado por la aplicación principal. En el ejemplo
anterior se definirían los parámetros de entrada nMotor, nValvula y tMaximo para referirse al ordinal
descriptivo del motor y de la válvula que se quiera manejar, así como al tiempo máximo permitido
para la operación. El código interno del bloque debe usar acceso indirecto a los datos de forma que
sus instrucciones puedan operar sobre cualquiera de los motores en función de la dirección
traspasada en tiempo de ejecución por nMotor y nValvula.

147

En el código del programa de usuario donde se invoca dicho bloque parametrizado se traspasará en
cada caso los parámetros necesarios para manejar el motor y válvula correspondiente en cada caso,
así como el tiempo máximo de operación permitido; esos valores serán leídos por el bloque
parametrizado en sus variables internas nMotor, nValvula y Tmaximo.

Para favorecer al máximo la reutilización de estos bloques, los entornos de programación permiten
almacenarlos en librerías de software que pueden ser enlazadas de nuevo en futuros programas
optimizando por tanto el esfuerzo de programación y revisión de los bloques funcionales.

2.4.7. Programación de procesadores periféricos inteligentes

Los periféricos inteligentes son equipos independientes, microprocesados, que por sí mismos son
capaces de ejecutar una tarea concreta de control de cierta complejidad, liberando de esa
complejidad al autómata; además estos periféricos cuentan con las entradas y salidas necesarias
para poder efectuar su función de control independientemente.

Estos periféricos que ejecutan tareas en paralelo con la CPU principal pueden convertir en cierto
sentido su entorno de trabajo en un sistema multiproceso, ya que aunque el usuario no puede tener
control sobre la ejecución de su programa interno, sí que debe coordinar el seguimiento de la
ejecución de los programas de los periféricos inteligentes con el del programa de usuario principal.

Diferencias con entorno de trabajo multitarea

 No se necesita un programa supervisor de tareas, ya que el periférico inteligente se maneja
desde la CPU como otro módulo cualquiera de E/S.
 No se puede programar la tarea ejecutada por el periférico, pero sí configurarla,
parametrizarla, hacerle seguimiento a su estado de funcionamiento y sincronizarla con los
estados del programa de usuario principal.
 El único recurso compartido entre las dos tareas que corren en paralelo es el bus de
comunicación con el que se comunica la CPU con el periférico inteligente.

148

 La configuración y parametrización del funcionamiento del periférico inteligente puede

hacerse bien directamente con la unidad de programación sobre el periférico, bien desde el
propio PLC en tiempo de ejecución mediante el programa de usuario.
 Es habitual que para simplificar el manejo de estos periféricos inteligentes el propio
fabricante proporcione las librerías de bloques funcionales necesarios para su manejo de
forma que el programador solo tiene que enlazar dichas librerías en el proyecto de control
para manejar de un modo sencillo estos periféricos inteligentes. Vea en vídeo el siguiente
EJEMPLO

Configurando y programando un variador de velocidad Micromaster 420 de Siemens en STEP 7

2.5. Programación en STEP‐7

En capítulos anteriores se han presentado distintos modelos de representación de procesos, como
los diagramas de contactos, GRAFCET, GEMMA, y varios tipos de lenguajes de programación, como
los de lista de instrucciones, de diagramas de contactos, de alto nivel y de bloques de funciones.

Por desgracia la implementación de estos lenguajes en cada modelo de autómata no es compatible
con los de otras marcas, e incluso en ocasiones tampoco lo es ni siquiera entre modelos del mismo
fabricante. A la implementación particular de los lenguajes de programación realizada por cada
fabricante la denominamos lenguaje propietario.

La Comisión Electrotécnica Internacional (IEC) desarrolló un lenguaje de programación normalizado
(el IEC‐61131) con el que intentó impulsar el desarrollo de aplicaciones escritas en lenguajes
compatibles entre diversos dispositivos programables, y aunque su uso no sea muy extendido,
convive con los lenguajes propietarios de los distintos fabricantes.

Como ejemplo de uno de estos lenguajes propietarios se va a presentar uno de los más conocidos, el
STEP‐7 de Siemens, software común para toda su gama SIMATIC.

2.5.1. Introducción a Step‐7

El software de programación STEP‐7 dispone de distintos lenguajes de programación, como son:

 FBD, lenguaje de bloques funcionales.
 KOP, lenguaje de diagramas de contactos.
 AWL, lenguaje de lista de instrucciones. Es el lenguaje ensamblador del STEP‐7, al que se
convierten el resto de lenguajes para ser transferidos a la CPU.
 S7‐SCL, lenguaje de texto estructurado. Es un lenguaje de programación estructurado de alto
nivel similar al PASCAL.

149

 S7‐GRAPH, lenguaje de grafos de control heredero del GRAFCET.
 S7‐HiGRAPH, lenguaje de transición de estados que junto con el S7‐CFC (lenguaje de
conexión de bloques funcionales) proporcionan un lenguaje de bloques en el que cada uno
de los bloques es a su vez un programa.

Una parte importante del proyecto de automatización es la elección del lenguaje de programación

adecuado para la tarea de control a realizar. Cada uno de estos lenguajes son muy diferentes entre
sí, pero comparten elementos importantes en todos ellos, como son los tipos de datos, las unidades
de organización del programa y las variables.

Tipos de datos

Un elemento común a todos los lenguajes de programación STEP‐7 son los tipos de datos posibles

para cada variable. Los principales tipos de datos pueden verse en la tabla de la derecha.

Es muy importante confirmar que el tipo de datos elegido para almacenar cada variable del
programa proporciona el rango de valores necesario para dicha variable.

Aunque no sean tipos de datos propiamente dichos, las conversiones de enteros a BCD soportan
estos dos formatos BCD diferentes:

El formato BCD (Decimal Codificado en Binario) representa dígitos binarios con 4 bits para
representar cada dígito, de modo que con un byte podemos representar 2 dígitos binarios. Es
frecuente su uso para cargar visualizadores numéricos.

150

Siempre debemos especificar el tipo de datos en que deseamos almacenar cada una de las variables
que vayan a ser usadas por el programa, y también es importante chequear los tipos de datos
aceptados por las funciones y entradas de bloques funcionales que utilicemos.

Unidades de organización del programa

En cuanto que una aplicación de autómata adquiere cierta complejidad es conveniente fragmentarla
en diferentes bloques, que son un conjunto de instrucciones agrupadas entre sí con una
determinada funcionalidad. Programando los distintos bloques para realizar las diferentes
funcionalidades y uniéndolos entre sí para proporcionar la tarea completa conseguimos un programa
de usuario más sencillo de programar, mantener y revisar.

STEP‐7 cuenta con los siguientes tipos de unidades de organización del programa, que pasamos a
analizar de forma más sucinta debajo:

 Bloques de organización (OB).
 Funciones (FC).
 Bloques funcionales (FB).

Variables

Las variables contienen la información de entrada, salida o valores intermedios que necesite el
programa de usuario o cualquiera de sus módulos (funciones o bloques funcionales) y se definen con
un nombre identificativo único y el tipo de datos que queramos que contenga.

Los lenguajes de programación proporcionan ciertas variables predefinidas que el programador
puede emplear en cualquier punto del programa de usuario.

Por su parte, las variables dadas de alta por el programador pueden ser definidas de modo que sean
accesibles desde cualquier punto del programa (variables globales) o solo desde la unidad de
organización del programa donde haya sido declarada (variables locales).

Es buena práctica de programación usar el menor número de variables globales que sea posible, ya
que el acceso limitado a las variables locales proporciona una mayor claridad en el código resultante.

De los distintos lenguajes de programación disponibles en STEP‐7 nos vamos a centrar más adelante
en el lenguaje de bloques funcionales FBD (o FUP, en alemán).

Tipos de unidades de organización del programa

Bloques de organización (OB)

Estos bloques son invocados directamente por el sistema operativo del PLC periódicamente y ante
ciertos eventos de relevancia, y son los que permiten el funcionamiento ordenado del programa de
control.

Entre ellos cabe destacar los siguientes:

 OB 1. Se invoca cíclicamente e implementa las llamadas al programa de usuario.

151

 OB 21. Es llamado al darse una transición de STOP a RUN del autómata.
 OB 22. Se invoca cuando se produce un rearranque por pérdida de suministro eléctrico.
 OB 34. Se invoca cuando se da un fallo de batería de mantenimiento de memoria no volátil.

Funciones (FC)

Una subrutina es una unidad de organización del programa que agrupa un conjunto de instrucciones
que implementan cierta funcionalidad, necesaria en una o más ocasiones dentro del programa de
usuario, y que dispone de cierta entidad propia. Se identifican por un nombre descriptivo y son
invocadas desde el programa principal o desde dentro de otras subrutinas.

Un tipo especial de subrutina es la función, subrutina que devuelve un valor de resultado al
programa o subrutina que la invoca cuando finaliza su ejecución.

Los distintos lenguajes de programación incorporan un conjunto muy amplio de funciones para
facilitar al programador las tareas más habituales, siendo las funciones estándar más comunes las
operaciones matemáticas básicas, las operaciones lógicas y binarias y las de manejo de cadenas de
caracteres. Algunas tienen un nombre ligeramente diferente en cada uno de los lenguajes STEP‐7.

Cuando el programador necesita una nueva función para implementar alguna operación necesaria en
su programa que no estaba disponible previamente, en la práctica está efectuando una ampliación
del lenguaje de programación original al que agrega la nueva función, que pasa a estar disponible en
su programa de usuario actual y en los que realice en el futuro. Para facilitar esa reutilización se
almacenan las funciones en librerías, conjunto de funciones y datos que son fáciles de incluir en otros
proyectos.

Bloques funcionales (FB)

Un bloque funcional (FB) es una representación gráfica de un algoritmo o de una función, que puede
ser compleja, y que en función de unas entradas proporciona una o más salidas.

En STEP‐7 los bloques funcionales se encapsulan en cajas rectangulares que muestran el identificador
del FB, el conjunto de entradas y el conjunto de salidas.

152

Para implementar su función interna el FB puede necesitar variables intermedias, solo accesibles en
el interior del bloque, por lo que el FB se acompaña de un bloque de datos (DB) asociado a él donde
se describen todas las variables que pueda necesitar internamente.

En STEP‐7 existe un conjunto amplio de bloques funcionales estándar del lenguaje, incorporados a él
de forma nativa, que permiten efectuar la mayoría de operaciones más frecuentes.

Igual que ocurre con las funciones, el programador puede definir nuevos bloques funcionales,
programar su comportamiento y almacenarlos en librerías para su reutilización futura en otros
proyectos.

2.5.2. Estructura interna de un S7‐200

El autómata programable S7‐200 fue el perfecto representante de las prestaciones deseables en un
PLC de gama media desde que se introdujo en 1995 y la referencia en el sector de la automatización
industrial.

Actualmente ha sido sustituido por un nuevo autómata, heredero en su concepción, pero actualizado
con nuevas prestaciones y tecnología más moderna: el S7‐1200.

A continuación se va a presentar la estructura interna del Siemens S7‐1200 en lugar del PLC al que
reemplaza.

Hibridación y capacidad de ampliación

Como su antecesor S7‐200, es un PLC de gama media híbrido entre un PLC compacto (aquel que
incorpora todas las E/S en el propio cuerpo de la CPU) y un PLC modular (que no incorpora E/S en la
CPU, pero permite ser ampliado con módulos externos).

153

Esta hibridación consiste en que el cuerpo de la CPU incorpora una fuente interna de alimentación e
interfaces de entrada y salida (como en un autómata compacto), además de, de forma nativa, un bus
de ampliación en bastidor y un bus de campo de ampliación externa en protocolo PROFINET (como
en un PLC modular).

Su capacidad de ampliación en bastidor permite incorporarle hasta 3 módulos de comunicaciones
(CM) que se conectan por la parte izquierda y hasta 8 módulos de entrada/salida (SM) que se
conectan por la parte derecha (pulse sobre la imagen de la derecha para ampliarla).

Las entradas y salidas incorporadas en el cuerpo de la CPU difieren de un modelo a otro, por lo que
existen distintas combinaciones que permiten adquirir la versión apropiada para nuestro proyecto.
Además existen variantes con distintos tipos de interfaces de entrada y salida: salidas digitales de
relé o de colector abierto, entradas de continua o de alterna...

Características técnicas del S7‐1200

En la siguiente tabla puede ver la comparación de las características técnicas principales de las 3
variantes más extendidas de este autómata.

Modelos de comunicación

Como vemos, existen diferencias notables desde el modelo más básico al más completo, cubriendo
con ellos un campo de aplicación muy amplio.

154

Los módulos de comunicaciones (CM) disponibles incluyen interfaces RS‐232, RS485 y PROFIBUS DP,
siendo el PROFINET nativo en toda la gama. Una mejora considerable sobre el S7‐200 está en su
terminal de programación, ya que utiliza un simple cable de red Ethernet con el que se conecta a un
ordenador personal con el software de edición y programación TIA PORTAL. Este cable permite al
software de programación realizar tareas de supervisión, prueba, programación y consulta de un
modo mucho más sencillo que antes.

Módulos de ampliación de señales de E/S (SM) más usados

Puede ver los distintos módulos de ampliación en la siguiente tabla:

Signal board

Una novedad del S7‐1200 es la inclusión en el cuerpo de la CPU de un
pequeño puerto de ampliación denominado Signal Board (SB) que

 permite incorporar sobre el módulo principal una pequeña

ampliación de señales,
 especialmente útil cuando en un proyecto solo se necesitan una o
dos señales más de las proporcionadas por la CPU.

Como puede verse existe:

 una ampliación SB con una salida analógica y
 otra ampliación SB que incorpora 2 entradas digitales y 2 salidas digitales.

155

Amplíe información consultando el manual de sistema del S7‐1200 en el siguiente documento:

2.5.3. Direccionamiento

La CPU S7‐1200 ofrece las siguientes posibilidades para almacenar los datos necesarios para el
programa de usuario:

Memoria global

La CPU tiene diferentes áreas de memoria, como la memoria de entradas (I), la memoria de
salidas (Q) y la memoria de marcas (M), estando permitido el acceso a estas memorias
globales desde todos los bloques lógicos. La zona de memoria de marcas (M) es la única zona
de memoria remanente en este autómata (es decir, su contenido permanece inalterado tras
cortes de suministro eléctrico).

Bloque de datos (DB)

Se pueden incluir uno o varios bloques de datos (DB) en el programa de usuario para guardar
los datos necesarios para la operación de los bloques lógicos. Se pueden definir DBs globales,
que pueden ser accedidos por todos los bloques lógicos, y DBs locales, que alojan todos los
datos de un bloque de función (FB) concreto, asociado a él. Los datos guardados en los DB se
conservan al finalizar su FB asociado, y se mantienen intactos hasta la próxima ejecución del
FB.

Memoria temporal

Al ejecutarse un FB, el sistema operativo del PLC asigna memoria local temporal (L) para su
uso durante la ejecución del bloque; al finalizar la ejecución del FB esta zona de memoria
queda libre para ser usada por el sistema operativo que puede asignarla como memoria
temporal al siguiente FB que se ejecute.

Al acceder a las memorias de entradas (I) o salidas (Q) se lee el estado traspasado a la memoria de
imagen de entradas y salidas al inicio del ciclo. Sin embargo es posible acceder al estado instantáneo
de la entrada o salida física, terminando la descripción de la dirección con el sufijo “:P”. Por ejemplo,
la entrada I0.0 leerá el estado almacenado en la imagen de memorias, mientras que la entrada I0.0:P
leerá el estado físico de la entrada I0.0.

156

El programa de usuario accede a las posiciones de memoria indicando su dirección y el largo de datos
que desea leer, ya que se puede acceder a bits sueltos (indicando con el sufijo “.n” el ordinal del bit n
deseado), bytes (B), palabras de 2 bytes (W) y palabras dobles (D).

Para referenciar unívocamente la dirección de memoria deseada hay que indicar el tipo de memoria
que queremos leer, la dirección y el tipo de datos. Vea aquí algún EJEMPLO

Tipo de memoria que se quiere leer, dirección y tipo de datos: ejemplos

— I0.3:P. Lectura de la entrada física del bloque 0, bit 3 (cuarta entrada de dicho bloque ya
que la numeración de bits arranca en 0, siendo el primero I0.0).

— Q1.7. Salida 8 del bloque 1, escribiendo o leyendo sobre la zona de imágenes de salida.
Recordemos que la memoria imagen se volcará a las salidas físicas al finalizar el ciclo de
operación.

— M17. Acceso al byte 17 de la memoria de marcas.

— MW4. Acceso a la palabra de dos bytes de la memoria de marcas contenida en las
direcciones de memoria 4 y 5 (recordemos, una palabra ocupa 2 posiciones de memoria).

— QD8. Acceso sobre la imagen de salidas con una palabra doble (32 bits localizados en las
direcciones de salidas 8, 9, 10 y 11).

Para facilitar la programación, STEP‐7 permite definir variables simbólicas definiendo en el bloque de
datos (DB) o en la interfaz de un bloque funcional variables identificadas por un nombre de variable.

Para cada variable simbólica se deben definir:

Nombre de la variable

El nombre de la variable será usado en el programa o FB para referirnos a ella.

Datos

Tipo de datos que contiene.

Offset

Dirección relativa que ocupa esta variable dentro del DB o interfaz.

Posición absoluta

De forma alternativa a la dirección por offset se puede definir la posición absoluta donde
queremos alojar la variable, indicando el tipo de memoria, tamaño de datos y dirección
absoluta. Para indicar que una variable se define con posición de memoria absoluta se la
precede por el sufijo “%”.

157

Comentario literal

Sirve para anotar observaciones sobre esta variable.

Para direccionar variables de lectura o escritura en bloques de datos se usa la notación
“DB[n].DB[x][d].[b]”, siendo n el ordinal del bloque de datos al que queremos acceder, x el tipo de
datos, del offset en bytes dentro del bloque de datos y b el ordinal del bit al que queremos acceder,
en caso de que la operación sea sobre bits. Vea algún EJEMPLO

Direccionamiento de variables de lectura o escritura en bloques de datos: ejemplos

— DB1.DBB4: variable del bloque de datos 1, accedida en modo byte (B), que ocupa el quinto
byte del bloque (4 indica al quinto byte ya que se comienza a numerar por el 0).

— DB1.DBB4.2: tercer bit del byte referenciado anteriormente (recordar que se comienzan

numerando desde el bit 0).

— DB1.DBW4: variable del bloque de datos 1, accedida en modo palabra de 2 bytes (W),
bytes quinto y sexto del bloque (4 indica al quinto byte, y al ser de tipo W la variable ocupa
dos bytes).

— DB20.DBD8: variable del bloque de datos 20, accedida en modo palabra de 4 bytes (D),
ocupando los bytes 9º, 10º, 11º y 12º del bloque de datos.

Si se utilizan tarjetas de expansión de entradas y salidas, el sistema asigna automáticamente
direcciones a sus entradas y salidas al darlas de alta en el proyecto sobre las áreas de entradas (I) y
de salidas (Q). Se puede modificar manualmente dicha asignación si se desea.

Amplíe información viendo el siguiente vídeo:

158

2.5.4. Estructura de un programa y módulos de S7‐200

Como ya se ha comentado, habiendo sido reemplazado el autómata Siemens S7‐200 por el S7‐1200,
vamos a estudiar la estructura de programa y módulos de este nuevo PLC.

En la CPU se ejecutan dos programas: el sistema operativo, que controla el funcionamiento de la
CPU, la carga del programa de usuario y su ejecución, y el programa de usuario propiamente dicho.

Principales tareas del sistema operativo

 Chequear el hardware al arrancar la CPU.
 Cargar el programa de usuario tras un arranque.
 Cargar las memorias de imágenes de entrada y salida antes de cada ciclo de ejecución.
 Ejecutar el programa de usuario en cada ciclo de operación.
 Detectar alarmas y llamar a los bloques de control OB correspondientes para su
tratamiento.
 Gestionar las distintas zonas de memoria.

El programa de usuario debe traspasarse a la CPU tras crearse, o puede copiarse en una tarjeta de
memoria para que la CPU lo ejecute desde ella.

STEP‐7 es un entorno de programación estructurado que permite dividir el programa de usuario en
distintos fragmentos, lo que ofrece ventajas por la claridad del programa final, la reutilización de
partes del programa, hacer las comprobaciones del software más sencillas y proporcionar una mejor
organización del programa y de su documentación.

Bloques en que se puede fragmentar el programa en STEP‐7

 Bloques de organización o control (OB). Estos bloques son los que dan forma a la estructura
del programa de usuario.
 Bloques de función del sistema (SFB) y funciones del sistema (SFC). Estas funciones son parte
del lenguaje STEP‐7 y permiten acceder a funciones relevantes del sistema.
 Bloques de función (FB), bloques programables a los que se puede asignar memoria.
 Funciones (FC), son fragmentos de programa organizados de forma que facilitan su
reutilización.
 Bloques de datos de instancia (DB de instancia). Estos bloques de datos se asocian con las
llamadas a un FB o SFB, y solo resultan accesibles para él. En ellos se traspasan los
parámetros de llamada al FB o SFB
 Bloques de datos (DB).

159

Bloques de organización y estructura del programa

La estructura del programa de usuario la conforman los bloques de organización (OB), que son
llamados por el sistema operativo en momentos relevantes: para el arranque del sistema, para el
procesado cíclico del programa, para el tratamiento de errores, etc.

Ya que no podemos acceder ni modificar al sistema operativo, los bloques de organización son
nuestro modo de definir el comportamiento de la CPU que deseamos. Los OB determinan el orden
en que se van llamando los diferentes bloques de programas, tras la ejecución, en las ejecuciones
cíclicas y en los tratamientos de errores y alarmas. Cada OB tiene asignada una prioridad, y puede
darse el caso de que la ejecución de un OB sea interrumpida por la de otro OB de mayor prioridad.

Para desactivar un OB podemos asignarle prioridad 0, con lo que no se ejecutará nunca. Desactivar
algunos OB permite liberar más memoria para datos locales.

Los eventos que producen la llamada a un OB se denominan “alarmas” aunque no todos ellos sean
alarmas propiamente dichas, por ejemplo cada vez que el sistema operativo requiera ejecutar un
ciclo de programa de usuario disparará la alarma “ciclo de scan” y llamará al OB 1. Haga clic en la
primera imagen para ampliarla.

Si el programa de usuario es pequeño y sencillo, se puede programar linealmente y contenerlo por
completo en el OB1, de forma que cada vez que el sistema operativo lo requiera se ejecutará el
bloque OB1 y el programa contenido en él instrucción por instrucción.

Sin embargo resulta recomendable fragmentar el programa en bloques de menor tamaño que
puedan ser depurados independientemente; en esta implementación de programación estructurada
se sigue llamando periódicamente al OB1, y este va llamando a su vez a los distintos bloques de
programa que conforman el programa de usuario. Haga clic en la segunda imagen para ampliarla.

160

Los bloques de programa (FB) pueden a su vez llamar a otros FB, operación que se denomina
anidamiento. La CPU S7‐1200 permite hasta 4 profundidades de anidamiento; en el siguiente
diagrama podemos ver un programa de usuario dividido en FBs y FCs (funciones) con una
profundidad de anidamiento de 3 capas. Haga clic en la tercera imagen para ampliarla.

La ejecución del programa de usuario puede ser interrumpida por los siguientes sucesos:

 Que se produzca una alama.
 Una orden de STOP desde el programador o desde los botones de la CPU.
 Una pérdida de alimentación.
 Un error de programa o de dispositivo.

El tiempo de ciclo es el tiempo consumido por la CPU para realizar un proceso cíclico completo, en el
que se efectúan las diferentes tareas:

 Actualizar memoria de imagen de salidas, estados que se vuelcan a las salidas.
 Actualizar memoria de imagen de entradas, que se lee de las entradas.
 Ejecución de ciclo de programa de usuario (OB1).
 Tareas que puedan generarse en base a alguna alarma producida, interrumpiendo o no la
ejecución de OB1 dependiendo de su nivel de prioridad. En caso de tener inferior nivel de
prioridad, se atienden al final de la ejecución de OB1.
 Atención a periféricos externos.

Si el tiempo de ciclo es muy bajo y no necesitamos repetir con mucha frecuencia el programa de
usuario podemos definir el tiempo de ciclo mínimo que deseemos, lo que genera que el sistema
operativo introduzca una pausa al final de cada ciclo si no se ha consumido el tiempo mínimo
programado.

Por el contrario, si el tiempo de ejecución de ciclo es muy largo, superior al que definamos, saltaría la
alarma de error de tiempo, disparando la ejecución de OB80 donde podemos programar la reacción
deseada ante el salto de watchdog.

En el S7‐1200 también es posible definir un tiempo máximo de atención a periferia y
comunicaciones, de modo que si encuentra algún problema en las comunicaciones que lo retrase no
se convierte en un problema para la normal ejecución del ciclo de programa, ya que se interrumpe el
tratamiendo de la periferia hasta el final del siguiente.

161

Funciones y bloques logicos: módulos del programa

Si optamos por generar un programa estructurado, el bloque OB1 de ejecución cíclica no contendrá
todo el programa de usuario, sino que estará fragmentado en varios bloques funcionales y funciones
que serán llamados desde el bloque principal OB1 y desde otros bloques funcionales.

Las funciones son bloques de programas que se usan frecuentemente o que tienen una función muy
concreta, autocontenida en su código. Por ejemplo, determinar si es necesario arrancar una máquina
de frío industrial según varias temperaturas medidas por termómetros. Si es una tarea que vamos a
repetir varias veces en el programa de usuario actual o en el futuro, merece la pena agrupar las
instrucciones necesarias para desarrollar esa acción en una función. De este modo, además, es más
fácil depurar el código y una vez que esté perfeccionado se puede incluir en otros programas de
forma segura.

Las funciones (FC) no tienen memoria asociada como los bloques funcionales, aunque tienen un DB
de instancia que se usa para traspasarle los parámetros de llamada. Por tanto la memoria temporal
que precise la FC en sus cómputos internos se tomará de la memoria temporal, liberándola el
sistema operativo para su uso posterior al finalizar la ejecución de la función.

Las variables que se traspasan a un FC o a un FB en la instancia de la función se denominan
parámetros. Cuando se define una función se dan de alta los parámetros que va a necesitar para su
funcionamiento, y posteriormente en cada punto desde el que se invoca la ejecución de la FC (desde
OB1 o desde otros bloques o funciones) se explicitan los valores que se traspasan a esos parámetros.
A los parámetros dados de alta en la función los denominamos parámetros formales, y a los que se
usan desde el punto en que se invoca a la FC, parámetros reales.

En la imagen de la derecha (haga clic para ampliarla) vemos los parámetros necesarios para el
funcionamiento de la función FC20: Start, Stop y Time. Esos son sus parámetros formales. Todo el
código de FC20 usa esas variables sin saber realmente con qué valores se cargará cuando se invoque
ni su procedencia. Simplemente se usan, a modo de comodín, para indicar las operaciones que
deben efectuarse con ellos.

162

Cuando desde el bloque OB1 se invoca la ejecución de FC20 se indica (en este ejemplo) que el
parámetro Start se carga desde la entrada E10.0, Stop desde la entrada E10.1, y Time desde la marca
de memoria MW12: esos son los parámetros reales en esa llamada concreta. En otro punto del
código OB1 podría volver a llamar a FC20 con otros parámetros reales diferentes. Internamente la
función FC20 trabaja sobre los parámetros formales, que se almacenan en la memoria temporal y se
usan mediante punteros.

Por el contrario, vemos en el ejemplo cómo el bloque de función FB40 cuenta con un bloque de
datos de instancia asociado, DB40, donde están definidos los parámetros necesarios. Internamente
el bloque funcional accede a la memoria de su DB de instancia asociado, DB40.

El mismo procedimiento se sigue con las salidas de las funciones y bloques de función.

Los bloques de función (FB) disponen de un bloque de memoria DB asociado, por lo que el
intercambio de datos se realizará utilizando dicho bloque de memoria. Sin embargo, los bloques de
FC, no disponen de dicho bloque DB, utilizando variables globales para el paso de parámetros. Si el
FB necesita datos temporales para su uso, el sistema operativo se los asignará de la zona de memoria
temporal, perdiéndose su contenido al finalizar el FB, cosa que no ocurre con los datos del DB de
instancia, que permanecen intactos al disponer de su memoria reservada para ellos.

Un ejemplo de cómo se traspasan los parámetros formales al FB lo tenemos en la imagen anterior,
donde DB40 es el bloque de datos de instancia de FB40.

Al no borrarse los datos escritos en el DB de instancia, cuando invocamos al FB no es imprescindible
volver a escribir todos los parámetros actuales de la instancia, solo se escriben los parámetros
actuales que necesiten ser refrescados. Si en la instrucción de llamada al FB se incluyen parámetros
actuales, se usan estos, y si no se incluyen, se usan los valores que ya estuviesen almacenados en el
DB de instancia.

Es posible utilizar varios DB de instancia con un mismo FB. Por ejemplo, imaginemos que nuestro
programa de usuario va a controlar 3 motores diferentes y que tenemos un bloque de función que
gestiona el arranque de motores, para lo que necesita varios parámetros. Pues bien, podríamos crear
3 bloques de datos de instancia, uno por cada motor, e ir manteniendo en cada uno de ellos los
parámetros necesarios para los 3 motores. Al invocar al bloque funcional (FB) de manejo de motores
indicamos con qué DB de instancia lo queremos ejecutar, usando por tanto los parámetros
guardados para ese motor en concreto.

Bloques de datos globales

Los bloques de datos globales no pueden contener código, solo datos que son almacenados
en ellos y a los que pueden acceder todos los bloques lógicos y funciones.

Estos datos tienen su memoria asignada y reservada durante todo el tiempo de ejecución,
por lo que no se pierde su contenido al finalizar ninguno de los FB o FC que los utilicen.

Los bloques funcionales y funciones pueden acceder al mismo tiempo a sus bloques de datos
de instancia y a bloques de datos globales.

163

2.5.5. Operaciones combinacionales

De los distintos lenguajes de programación disponibles en STEP‐7 vamos a centrarnos en el lenguaje
de bloques funcionales (FUP), que es posiblemente el más utilizado en la actualidad.

Las operaciones combinacionales, al igual que el resto de operaciones, se implementan con un
lenguaje simbólico basado en la interconexión de cuadros de funciones basados en el lenguaje
normalizado (el IEC‐61131) aunque no exactamente iguales. Estos cuadros de funciones se unen en
segmentos de cuadros, donde se interconectan entre sí, compartiendo entradas, pasando salidas de
un cuadro a entradas de otros, etc.

Las operaciones lógicas básicas AND (Y), OR (O) y OR EXCLUSIVA (XOR) se implementan con los
siguientes cuadros de función:

La operación de inversión lógica (NOT) se implementa con una marca circular en la entrada o salida
de cualquier cuadro lógico, usándose en dicho caso el inverso del dato conectado como entrada, o el
inverso de la salida, según sea el caso (pulse sobre la imagen para ampliarla):

Los bloques de función de operaciones lógicas pueden implementar su operación lógica sobre más
de dos parámetros de entrada, añadiendo más entradas al bloque funcional.

Las operaciones combinacionales complejas se implementan enlazando varios grupos de bloques
lógicos de los tipos básicos:

Finalmente para trasladar los resultados de las funciones combinacionales a variables o salidas se usa
el bloque de asignación, con los que podemos asignar la salida directamente o asignarla invertida:

164

2.5.6. Operaciones de memoria

Para almacenar variables cuyos valores se mantengan permanentemente en memoria es necesario

que la CPU usada disponga de una zona de memoria remanente, que retiene su contenido en caso de
corte de suministro eléctrico.

STEP‐7 dispone de varios bloques de función para manejar estas variables de memoria, de los cuales
el más práctico es el conocido biestable de tipo RS, implementado con dos bloques funcionales
diferentes, el RS y el SR:

Recuerde que el estado de un biestable RS es indeterminado si tanto Set como
Reset están activos al mismo tiempo; en STEP‐7 el bloque RS pasa a 1 en ese caso,
mientras que el bloque SR pasa a 0.

TOME NOTA

2.5.7. Operaciones de tiempo

STEP‐7 proporciona 5 tipos diferentes de operaciones con temporizadores:

Temporizador de impulso. Genera un impulso de una duración determinada.

165

TON

Temporizador de retardo a la conexión. La salida del temporizador se activa al pasar un tiempo
determinado desde la activación de la entrada y se desactiva al desactivarse la entrada.

TOF

Temporizador de retardo a la desconexión. La salida del temporizador se activa al activarse la
entrada y se desactiva tras pasar un tiempo determinado desde la desactivación de la entrada.

TONR

Temporizador de retardo acumulado a la conexión. Este temporizador activa su salida tras
acumularse un tiempo determinado de tiempo de activación de entrada.

166

Borrado de temporizaciones. Inicializa los datos de tiempo transcurridos en el temporizador al
que referencia.

Los temporizadores usan bloques de datos asociados para mantener sus datos, DB que son asignados
automáticamente por el editor de programas cuando se incluye un temporizador en el proyecto.

Uso de las entradas y salidas de estos bloques

 La entrada IN es la línea de entrada de disparo de temporizaciones.
 La entrada PT es el valor de tiempo programado para la función de temporización.
 La salida Q es la salida del temporizador, que sigue la función correspondiente al tipo de
temporizador.
 La salida ET señaliza el tiempo acumulado de operación.
 La línea R permite resetear el tiempo acumulado en el temporizador de tipo TONR.

2.5.8. Operaciones con contadores

En STEP‐7 disponemos de operaciones para trabajar con dos tipos de contadores: contadores
software y contadores rápidos.

 Los contadores software manejan señales lentas, que no cambian de estado a mayor
velocidad que el ciclo de ejecución de programa, por tanto pueden ser estudiadas con una
entrada convencional.
 Los contadores rápidos por el contrario usan hardware específico en la CPU que
implementan de forma autónoma el control de señales asociadas al contador. De este modo

167

se pueden seguir señales mucho más rápidas que el ciclo de trabajo, sin sobrecargar la CPU
con el seguimiento de estas entradas rápidas.

Contadores software disponibles en STEP‐7

 Contador CTU. Contador de tipo UP, ascendente, donde el valor de conteo se va
incrementando con cada activación de la entrada. El valor interno de conteo (CV) se inicia a 0
al activarse el reset, y la señal de salida se activará al alcanzar el valor predeterminado (PV).
 Contador CTD. Contador de tipo DOWN, descendente, en el que el valor de conteo se va
decrementando con cada activación de la entrada. Se inicializa el valor interno de conteo
(CV) cuando se activa la señal de carga con el valor predeterminado (PV) y la salida se
activará al llegar a 0.
 CTUD. Contador de tipo UP‐DOWN, bidireccional, donde tenemos disponibles dos entradas
de conteo independientes, generando cada una de ellas un incremento (CU) o un
decremento (CD) del valor de conteo.

Señales de control de bloques lógicos

 CU. Contador ascendente, las activaciones de esta señal aumentan en una unidad el valor de
conteo.
 CD. Contador descendente, las activaciones de esta señal decrementan el valor de conteo.
 R. Reseteo de valor de conteo, que se pone a cero al activarse R.
 LOAD. Señal que ordena la carga del valor predeterminado (PV).
 PV. Valor predeterminado. Cuando el contador es ascendente, la señal de salida se activa
cuando el valor de conteo (CV) iguala o supera al valor predeterminado. Por el contrario
cuando el contador es descendente, se inicia el conteo desde el valor predeterminado hasta
llegar a cero, momento en que se activa la salida Q.
 Q y QU. Salidas en conteo ascendente. Se activan cuando CV>=PV.
 QD. Salida en conteo descendente. Se activa cuando CV<=0.
 CV. Valor de conteo actual.

Todos estos contadores requieren también de un DB asociado para mantener sus datos, DB añadido
automáticamente al proyecto por el editor de programas al dar de alta el contador en el proyecto.

2.5.9. Operaciones de comparación

Los bloques funcionales de comparación tienen dos entradas, IN1 e IN2, que son las que se comparan
entre sí y una salida que es el resultado lógico de la comparación (verdadero o falso) y pueden ser de
los siguientes tipos:

 “==”. Este bloque da resultado verdadero si IN1 e IN2 son iguales.

168

 “<>”. La salida es verdadera si IN1 e IN2 son distintas.
 “>=”. La salida es verdadera si IN1 es mayor o igual que IN2.
 “<=”. La salida es verdadera si IN1 es menor o igual que IN2.
 “>”. La salida es verdadera si IN1 es mayor que IN2.
 “<”. La salida es verdadera si IN1 es menor que IN2.

Los bloques funcionales de comparación sustituirán el tipo de datos ??? por el tipo de datos de las
variables que se le asignen a la entrada, es decir, si los datos de entrada son enteros, el bloque
tomará el valor INT, si son bytes, tomará BYTE, etc… y todo ello de manera transparente al operador.
Los datos a comparar deberán ser del mismo tipo. De no ser así, tendremos que realizar primero un
cambio de tipo.

2.5.10. Operaciones aritméticas

Los bloques funcionales de operaciones aritméticas implementan las operaciones matemáticas más
comunes y tienen en común las siguientes señales:

 EN. Permitir la operación, que se calculará cuando EN sea verdadero.
 IN. Valor de entrada a la operación en las operaciones que solo tienen un operando.
 IN1, IN2. Valores de entrada para las operaciones que tengan dos operandos.
 OUT. Es el valor resultante de la operación.
 ENO. Señal de salida válida: solo cuando ENO esté activa la señal de resultado (OUT) será el
resultado correcto de la operación.

Si se produce un error en cualquiera de las operaciones matemáticas, la senal ENO no se activará,
ofrecerá un resultado “falso” o “0”. Algunos de los motivos por los que la operación matemática
puede generar una señal de error son:

 Resultado fuera de rango.
 División entre 0.
 Raíz cuadrada de un número negativo

Aunque algunas funciones matemáticas específicas necesitan algún parámetro adicional, la mayoría
operan con este listado anterior de señales.

169

Operaciones con números enteros

Como son muchas las operaciones matemáticas disponibles, a continuación se listan las principales
operaciones que trabajan con números enteros sin mostrar sus bloques funcionales, idénticos al
mostrado para la operación de suma (ADD):

 ADD. Operación de suma, en ella el resultado es la suma de los dos operandos: OUT = IN1 +
IN2.
 SUB. Operación de resta, OUT = IN1‐IN2.
 MUL. Operación de multiplicación, OUT = IN1*IN2.
 DIV. Operación de división, OUT = IN1/IN2.
 MOD. Resto de división, OUT = módulo de IN1/IN2 (resto de la división).
 NEG. Complemento a dos, OUT = ‐ IN1.
 MIN. Comparación de mínimo, OUT = valor más bajo de IN1 e IN2.
 MAX. Comparación de máximo, OUT = valor más alto de IN1 e IN2.

Operaciones con números en coma flotante

 SQR. Operación de cálculo de cuadrado, OUT = IN^2.
 SQRT. Operación de raíz cuadrada, OUT = raíz (IN).
 LN. Cálculo de logaritmo neperiano, OUT = ln(IN).
 EXP. Calcular el valor exponencial, OUT = e ^ IN.
 SIN. Cómputo del seno de un ángulo, OUT = seno(IN).
 COS. Cómputo del coseno de un ángulo, OUT = coseno(IN).
 TAN. Cálculo de la tangente de un ángulo, OUT = tangente(IN).

2.5.11. Operaciones entre bloques

Las operaciones de cada bloque lógico son internas y no se pueden intercambiar ni mezclar
operaciones con las de otros bloques lógicos.

Sí que son posibles distintas relaciones entre bloques de funciones (FB) y bloques de datos (DB); un
FB puede instanciar a más de un DB, un DB puede ser usado para instanciar a un FB en varias
ocasiones y puede usarse un DB de instancia para efectuar varias instancias de FB diferentes.

Las relaciones entre bloques funcionales se limitan a la llamada que desde un FB puede hacerse
sobre otro FB; recuerde que a esta operación se la denomina anidamiento y que el número de
profundidades de anidamiento está limitada en cada CPU a un valor concreto (4 en el caso del S7‐
1200).

170

2.5.12. Relaciones entre bloques

Durante el proceso de programación, cuando un bloque necesita invocar a otro, este segundo bloque
que va a ser llamado ya debe estar construido con anterioridad.

Esto introduce una suerte de jerarquía entre los bloques que obliga a crearlos en un cierto orden
para poder escribir el programa. Vea el anterior ejemplo de bloques usados para mostrar la
profundidad de anidamiento:

Observando, por ejemplo, el uso en este programa del bloque de datos DB1, verá que es usado
únicamente por FC21. Por su parte, FC21 solo es utilizado una vez, de modo que para escribir este
programa podría empezar escribiendo el bloque de datos DB1 y posteriormente la función FC21.

A partir de aquí podría definirse FB1, que es quien invoca a FC21, pero comprobando el uso de FB1
vemos que se usa en otro punto del programa llamando a FC1, que aún no tenemos definida. Por
tanto se debe proseguir definiendo FC1, y después FB1. Por último, se definiría FB2, y finalmente el
OB1.

Recuerde que al crear todos los bloques funcionales, FB1 y FB2 en este caso, hay que generar
también sus DB de instancia asociados.

171

Amplíe información sobre las relaciones de bloques consultando el Manual de Siemens Programar
con STEP‐7 en el siguiente documento:

172

3. EJEMPLOS BÁSICOS DE PROGRAMACIÓN

El alcance de este curso no permite profundizar en la parte práctica de la programación de los
autómatas, pero en este apartado se presentarán varios ejemplos básicos de programación en un
entorno real: el TIA PORTAL v14 de Siemens, con programas escritos para el modelo de PLC S7‐1200.

Recomendamos darse de alta en la página web de Siemens y descargar la versión de evaluación de
esta plataforma, que incluye entre otras herramientas la última versión del entorno de programación
STEP‐7.

La versión que recomendamos descargar es la que se denomina DVD 1: (STEP 7 Professional V14 +
SP1), que consta que cuatro ficheros. Cuando intente descargar el último se le pedirá registrarse en
la web. El registro es gratuito, aunque tarda varios días en validarse.

3.1. Introducción

Como ya se ha mencionado, el proyecto del que se partirá para ejemplificar los contenidos
estudiados en este curso será un software de control para un pozo que controlará el rellenado de un
depósito de agua que está junto al pozo.

Se plantea controlar el llenado de un depósito de agua con el control de un bombeo que extrae el
agua de un pozo cercano y la vierte en el depósito.

173

Para controlar el llenado del depósito se contará con un equipo hidronivel que activará su salida
cuando el nivel del depósito esté bajo y por tanto se desee rellenarlo con más agua; y que se
desactivará cuando el nivel del depósito sea suficientemente alto y se desee detener el bombeo.

Por su parte, el bombeo está formado por dos motores, cada uno de los cuales tiene un arrancador
estático asociado que proporciona una señal de fallo de motor si detecta alguna anomalía en el
motor.

Además el pozo cuenta con un sensor de agua que se activa cuando el nivel freático en el pozo sea
demasiado bajo y deje en riesgo a las bombas de aspirar en vacío, pues podría romperlas.

Con el avance del ejemplo también se incluirá una entrada analógica con un medidor de presión de 4
a 20 mA que informará de la altura exacta de agua que contiene el depósito.

Para un mejor seguimiento de los ejemplos mostrados en el MÁS INFO de este apartado podrá
encontrar una serie de videos con el paso a paso para la realización de un programa TIA‐Portal, así
como una serie de tutoriales que pueden ayudar a la hora de dar sus primeros pasos en TIA‐Portal.

Amplíe información consultando los siguientes recursos:

 Vídeos para realizar un programa TIA‐Portal
 S71200 Easy book
 S71200 Getting started
 Guía del taller S71200
 Manual S71200

3.2. Identificación de entradas y salidas

El primer paso va a ser generar un listado de todas las entradas y salidas necesarias en EL proyecto,
identificando el tipo de señal que necesitamos para cada una y el significado que tendrá cada uno de
sus estados.

174

Para controlar el llenado del depósito se cuenta con un hidronivel o relé sonda. Este equipo tiene 3
electrodos con los que detecta si los niveles de agua requieren que se rellene el depósito o no. Esta
señal es binaria, ya que no indicará más que dos estados: o bien está activa la señal de marcha o bien
no lo está. De modo que se tendrá que reservar solo una entrada digital para
ella.

A estas señales vamos a añadirles una entrada analógica de medición de la
altura del nivel del depósito que dará una corriente proporcional a la altura de
agua medida por la sonda. En concreto se va a usar una sonda de 4‐20mA que
tiene un fondo de escala de 6 metros de altura. Esto quiere decir que cuando la
altura de agua medida es de 6 metros, la sonda proporciona su máximo nivel:
20mA. Y cuando la altura de agua es de 0 metros, la sonda proporciona su nivel
mínimo: 4 mA.

En el pozo se tiene una señal que indicará si el nivel de agua es suficiente para
que las bombas trabajen sin problemas; se trata de una señal digital que solo indica si el nivel de
agua es peligroso para la maniobra o no. Así para su monitorización se necesitará otra entrada
digital.

Finalmente para el bombeo se tendrán dos señales más, que indica cada una de ellas si el arrancador
estático ha detectado un fallo en la bomba que controla, en cuyo caso no debe ponerse en marcha la
bomba asociada incluso aunque haga falta agua. Estas dos señales serán nuevamente digitales,
indicando simplemente si se detecta fallo o no, por lo que consumirán 2 entradas digitales más.

Y ya para terminar, cada uno de los motores necesita una señal de control que ordene su arranque:
el autómata actuará sobre los dos arrancadores estáticos, que a su vez pondrán en marcha cada
motor. Por tanto se necesitan dos salidas digitales, una para el control del arranque de cada motor.
Haga recuento de las entradas y salidas necesarias para el control de esta instalación y asígneles un
nombre descriptivo.

175

Entradas y salidas totales

El recuento total de señales indica que se necesita contar con:

 4 entradas digitales de tensión. #marcha, #agua, #fallo1 y #fallo 2.
 1 entrada analógica. #nivel.
 2 salidas digitales. #motor 1 y #motor2.

Tipos de interfaz necesarias para cada señal

Respecto al tipo de interfaz necesario para cada señal, se proponen los siguientes:

 Entradas digitales de tensión continua a 24Vdc.
 Entrada analógica de 4‐20mA para la señal #nivel.
 Salidas digitales de relé para actuar directamente sobre los arrancadores estáticos.

Revisando los modelos de S7‐1200 disponibles en la tabla del apartado 2.5.2 verá que la variante más
sencilla, la CPU 1211C, ya cubre la cantidad de entradas y salidas necesarias, dejando 2 entradas
digitales, 1 entrada analógica y 2 salidas digitales libres, de reserva, lo que resulta muy recomendable
por si se necesita ampliar un poco el control en el futuro.

Selección de modelo de CPU

De entre los modelos disponibles de la CPU 1211C, se buscará la que tenga salidas de relé, no de
colector abierto; revisando en TIA PORTAL las CPU disponibles se terminará escogiendo (pulse sobre
la imagen para ampliarla) la referencia 6ES7‐211‐1HD30‐0XB0. Con esta elección se minimiza el
número de dispositivos necesarios en la instalación, ya que esta CPU no necesitará de ampliaciones
ni de relés externos para convertir sus salidas.

176

El siguiente paso sobre su programa será mapear las entradas y salidas sobre el dispositivo. Quedará
como se ve a continuación:

3.3. Programas con operaciones combinacionales

Para empezar con el programa van a plantearse las operaciones combinacionales que gestionan el
funcionamiento básico descrito anteriormente:

 Cuando la señal “marcha” esté activa quiere que se activen las dos bombas a la vez.
 Si la señal “agua” está activa, se permite que funcionen las bombas. Si no lo está, no debe
ponerse en marcha ninguna.
 Si la señal de fallo de la bomba 1 “fallo1” está activa, la bomba 1 no debe ponerse en
marcha.
 Si la señal de fallo de la bomba 2 “fallo2” está activa, la bomba 2 no debe ponerse en
marcha.

Para implementar un esquema de control tan sencillo como ese la solución más intuitiva suele ser la
representada con diagramas de contactos; vea cómo quedaría el bloque principal (OB1) para
implementar estos requisitos:

177

Recuerde las diferencias entre las entradas directas (normalmente abiertas) y las entradas invertidas
(normalmente cerradas).

Siguiendo el diagrama de contactos puede ver que para que el motor 1 pueda ponerse en marcha

tendría que ocurrir justamente lo solicitado en los requisitos iniciales:

 Que el hidronivel detecte que hay poca agua en el depósito y active la señal “marcha”.
 Que la sonda de detección de agua en el pozo esté activa, indicando que es seguro operar.
 Que la señal de fallo de la bomba 1 “fallo1” no esté activa.

Lo mismo ocurre con la bomba 2.

La expresión booleana expresada literalmente para el estado de “bomba1” y “bomba2” sería:

bomba1 = marcha * agua * (! fallo1 )
bomba2 = marcha * agua * (! fallo2 )

3.4. Programas con contadores

Sobre el programa original se va a añadir una mejora que requerirá el uso de contadores.

Para darle un uso más racional a las bombas, se va a plantear un nuevo funcionamiento que
consistirá en que solo trabajará una de ellas cuando se ordene la marcha. Además, para que las dos
bombas tengan un uso similar deseamos que cada 10 activaciones el sistema cambie la bomba
seleccionada.

Para implementar esta funcionalidad se va a introducir un contador, tipo UP, que se irá
incrementando con cada petición de marcha y que al llegar a 10 debe hacer dos cosas:

 Cambiar la bomba seleccionada.
 Resetear el valor de conteo.

Este proyecto se va a definir con bloques funcionales (lenguaje FUP), más apropiado para escribir
numerosas operaciones lógicas.

178

El contador que producirá los cambios de bomba seleccionada recibirá un pulso de conteo cada vez
que se dé una orden de marcha. Esa será la variable que se asocie a su entrada de conteo hacia
arriba (CU). El valor de final de conteo (PV) será fijo, porque en todo caso serán 10 marchas
consecutivas las que cambien la selección de la bomba. Por tanto, en PV debe cargarse el valor
estático 10.

Para hacer que el contador que controla los ciclos de activación de marchas se resetee al llegar a 10
conteos y pase a cero se conectará su variable de salida QU a su entrada de reseteo (R). El contador
quedaría como se ve en la siguiente imagen. El contador, como puede ver, dará un pulso a 1 por su
línea de salida (Q) cada vez que se complete el ciclo de 10 órdenes de marcha consecutivas.

La señal Q de salida del contador debe hacer cambiar la bomba seleccionada, lo que implica utilizar
una posición de memoria para almacenar ese estado interno. Recuerde que la memoria más básica
descrita para un circuito secuencial era el biestable, que cambiaba su estado según se activase su
señal S (set, establecer, que activa el biestable) o si se activa la señal R (reset, reseteo, que desactiva
el biestable).

Pues bien, tiene que conseguirse que cada vez que llegue un pulso de cambio de bomba seleccionada
(la salida “Contador_1”.QU) el biestable cambie de estado. Si estaba a 1, debe pasar a 0, y si estaba a
0, debe pasar a 1. Se tendría que hacer lo siguiente:

 Activar la línea Reset cuando el biestable estuviese a 1, lo que lo pasaría a 0.
 Activar la línea Set cuando el biestable estuviese a 0, lo que lo pasaría a 1.

Para implementar esta función se pasa la señal de cambio de bomba seleccionada
(“Contador_1”.QU) por dos puertas AND, comparándose con el estado del biestable para la línea
Reset, y con el inverso del biestable para la línea Set.

179

El biestable de bomba seleccionada se denomina “Sel_Bomba2”, porque cuando esté a 1 indicará
que la bomba seleccionada es la bomba 2 y cuando esté a 0 será la bomba 1 la seleccionada. Al
arrancar el programa el biestable se inicia a 0, por lo que comienza trabajando la bomba 1.

Opciones disponibles

Cuando se den 10 pulsos de la señal marcha se activará la línea de salida del contador, que pasará a
través de las dos puertas AND hasta el biestable:

 Cuando la bomba 1 esté seleccionada (biestable a 0) la puerta AND de arriba no dará paso al
pulso de selección hasta la pata de Reset.
 Sin embargo, cuando la bomba 1 esté seleccionada (biestable a 0) será la puerta AND de
abajo la que dé paso al pulso hasta la pata Set del biestable, poniéndolo a 1, es decir,
seleccionando la bomba 2 como se quería. Observe que la línea “Sel_bomba2” entra a dicha
puerta lógica invertida (marca de entrada con el círculo indicando inversión de esa línea).
 Cuando llegue el pulso de cambio de bomba estando el biestable activo (por tanto, estando
seleccionada la bomba 2), será la puerta AND de arriba la que se active, pasando el pulso de
cambio de selección a la pata Reset del biestable, cambiando este a cero: es decir,
seleccionando la bomba 1 como se deseaba.
 Por su parte, estando la bomba 2 seleccionada la puerta AND de abajo nunca se activará, ya
que el estado del biestable le llega negado.

180

Cuándo se activará el motor 1

Una vez que se tiene bien generada nuestra señal de selección de bomba activa, recuerde, indicando
que es la bomba 1 la que debe trabajar cuando el biestable está a 0, tiene que generar finalmente las
órdenes de marcha para cada uno de los motores.

El motor 1 se activará cuando se reciba una señal de marcha, haya agua suficiente en el pozo, no esté
en fallo la bomba 1 y además el selector de bomba activa esté a 0:

Obsérvese que se ha sacado la señal del biestable invertida (círculo en su salida Q) por lo que tras esa
inversión la señal estará a 1 cuando sea la bomba 1 la seleccionada. La asignación de la salida
“motor1”, conectada en la salida física 0 de la CPU, hará que el motor arranque según las reglas
descritas.

181

Esquema completo del control de bombeo

Finalmente el esquema completo de este control de bombeo con dos bombas en alternancia cada 10
órdenes de marchas consecutivas queda así:

3.5. Programas con operadores de comparación

Se va a usar la entrada analógica “nivel” prevista en el autómata, que indicará la altura de agua que
hay en el depósito gracias a una sonda de presión analógica sumergida en el mismo.

La entrada analógica del PLC es de tipo 4‐20mA, y proporciona 4mA cuando tengamos 0 metros de
agua, 20mA cuando tenga 6 metros de agua y valores proporcionales a este rango entre medias.

En este ejemplo se va a cambiar la forma de trabajar del autómata para que no sea el hidronivel con
sus electrodos el que gobierne la marcha y paro del bombeo, sino que este se controle con la sonda
de nivel que mide la altura de agua. Trabajando en este nuevo formato se podría cambiar el nivel de
marcha y el nivel de paro editando la programación del autómata sin modificar ningún elemento
mecánico ni eléctrico en la instalación.

Se van a establecer dos niveles de comparación, nivelm, nivel de marcha y nivelp, nivel de paro, que
serán los que controlen el cambio de la señal de marcha previamente proporcionada por el
hidronivel.

Cuando el nivel de agua medido baje por debajo del nivel de marcha “nivelm”, se necesita que la
nueva señal generada, “marcha”, se active. Y cuando el nivel de agua medido suba por encima del
nivel de paro “nivelp”, esa señal generada debe desactivarse.

182

El comportamiento descrito para esa señal es el correspondiente a un biestable de tipo RS, donde la
comparación con “nivelm” debe activar la línea Set (activar), y la comparación con “nivelp” debe
activar la línea Reset (desactivar).

Para designar esos niveles “nivelm” y “nivelp” se dan de alta como contantes de sistema,
asignándoles los valores deseados para ambos niveles.

Vea cómo queda la generación de esta nueva señal de marcha sintetizada según la medida analógica
del nivel de agua medido en el depósito:

Cuando el nivel de agua supere la consigna de paro que hemos marcado, 16mA, la salida del
comparador superior se activará, actuando sobre la señal Reset del biestable ( R ) y desactivando la
señal de marcha.

El nivel de agua puede seguir cambiando, bajando por debajo del “nivelp” y desactivando la señal de
Reset del biestable, pero eso no modificará el estado del biestable, cosa que solo ocurirá cuando se
active la señal Set del biestable (S1).

Cuando el nivel de agua medido, “nivel”, baje por debajo del nivel de marcha programado “nivelm”,
la señal de salida del comparador de abajo se activará, activando la señal de Set del biestable y por
tanto activando la señal de marcha nuevamente.

Una de las ventajas del control de marcha por comparación con estas constantes
consiste en la posibilidad de modificar estos parámetros de niveles de marcha y
paro por software, por ejemplo en función de distintos horarios para conseguir un
mejor precio de la energía.
TOME NOTA

183

3.5.1. Escalar valores analógicos

Si se quiere trabajar con valores reales de la señal analógica, por ejemplo, con señales de entre 0 y 6
bares en el caso de estar midiendo presión, en TIA‐Portal deberá utilizar las funciones Norm_X y
Scale_X para realizar el escalado de la señal.

Como sabe, la señal de 4..20mA será convertida a digital, utilizando valores entre 5530 y 27648.

 La función Norm_X convertirá estos valores en un valor real entre 0 y 1.
 Posteriormente, se toma este valor entre 0 y 1 y se escalará con Scale_X para obtener un
valor entre 0 y 6 bares.

NORM_X: Normalizar

La instrucción «Normalizar» normaliza el valor de la variable de la entrada VALUE representándolo en
una escala lineal. Los parámetros MIN y MAX sirven para definir los límites de un rango de valores
que se refleja en la escala.

En función de la posición del valor que se debe normalizar en este rango de valores, se calcula el
resultado y se deposita como número en coma flotante en la salida OUT.

Si el valor que se debe normalizar es igual al valor de la entrada MIN, la salida OUT devuelve el valor
«0.0». Si el valor que se debe normalizar es igual al valor de la entrada MAX, la salida OUT devuelve
el valor «1.0».

La figura de la derecha muestra un ejemplo de cómo pueden normalizarse los valores.

SCALE_X: Escalar

La instrucción «Escalar» escala el valor de la entrada VALUE mapeándolo en un determinado rango
de valores. Al ejecutar la instrucción «Escalar», el número en coma flotante de la entrada VALUE se
escala al rango de valores definido por los parámetros MIN y MAX. El resultado de la escala es un
número entero que se deposita en la salida OUT.

184

Escalar una señal analógica

Con lo cual, combinando estas dos operaciones vamos a poder escalar una señal analógica en TIA
Portal sin ningún problema:

3.6. Programas con operadores de memoria

Las operaciones de memoria más habituales consisten en almacenar y consultar resultados binarios
en relés internos, así como variables de otros tipos.

Para usar posiciones de memoria como almacén de estos valores solo se tiene que definir las
variables en memoria, del tipo deseado, y acceder a ellas a través de sus nombres descriptivos como
se ha hecho previamente con las entradas y salidas.

Definir una nueva variable de memoria es posible dando de alta una nueva variable, y al definir su
campo “Dirección”, donde tenemos las opciones I, Q y M para definir el identificador del operando,
escogemos el tipo M (marca de memoria).

Los posibles tipos I, Q y M se corresponden con entradas (I), salidas (Q) y marca de memoria (M).

185

Tras definir esa nueva marca de memoria, la tabla de variables de memoria del sistema quedaría así:

En el listado puede ver las direcciones asignadas a cada entrada (%I..) y salida (%Q..).

Cualquier operación de consulta o asignación de la variable “Valor Memoria nivelm” se efectuaría
con el contenido de esa posición de memoria, no con una entrada o salida.

Por ejemplo podría usarse para cargar el comparador del ejemplo anterior:

Al estar el valor de comparación almacenado en memoria podría ser cambiado dinámicamente por la
aplicación para adaptarse a distintas condiciones de trabajo.

186

3.7. Programas con temporizadores

A continuación se va a agregar algún nuevo elemento a la instalación para hacer uso de funciones
con temporizadores en este ejemplo.

Suponga que para la potabilización del agua extraída del sondeo se debe aportar una determinada
cantidad de cloro al agua cada vez que se rellena el depósito. La aportación de cloro la realiza una
bomba de cloro que, tras las pruebas realizadas, debe bombear cloro durante 10 minutos por cada
rellenado de depósito.

Para gestionar esta bomba se va a proporcionar una nueva salida digital (gracias a disponer de
reserva suficiente de ellas en el autómata seleccionado) con la que se pondrá en marcha la bomba de
cloro.

Para poner en marcha la bomba de cloro se va a usar un temporizador, de modo que cada vez que se
genere una señal de marcha para rellenar el depósito se activará el temporizador durante un tiempo
de 600 segundos (los 10 minutos deseados).

Revisando las definiciones expuestas en el apartado 2.5.7 podrá comprobar que el temporizador
necesario es del tipo TP (temporizador de impulso). Este temporizador produce un impulso de la
duración deseada cuando se activa su entrada.

Para conectar la salida de control de cloro a este temporizador tendríamos que usar la programación
que podemos ver en la imagen:

187

Como vemos, cada vez que se active la señal “marcha” se disparará el temporizador de impulso, que
proporcionará una salida activa durante 600 segundos, que se traspasará a la salida de cloro
poniendo en marcha la bomba de inyección de cloro durante ese tiempo.

En TIA PORTAL, la hora preestablecida se ingresa usando este formato:

 T # (días) d (horas) h (minutos) m (segundos) s (milisegundos) ms.

Por ejemplo, T # 12d10h30m21s253ms es una hora válida, pero no es necesario especificar
todas las unidades de tiempo. Por lo tanto, T # 5h10s y T # 500h también son válidos.

3.8. Ejemplo: Máquina empaquetadora

En este ejemplo se va a programar una sencilla máquina de empaquetado de manzanas que va a
controlar dos cintas transportadoras para rellenar unas cajas que se desplazan por una de las cintas,
con 10 manzanas que se desplazan por otra cinta. El control debe mover convenientemente ambas
cintas para que cada caja quede rellena con sus 10 manzanas.

188

Esquema general de la máquina

 Dos botones de START y STOP controlan la marcha y parada del proceso.
 Una barrera infrarroja detecta la posición de la caja justo en el punto donde caen las
manzanas.
 Otra barrera infrarroja detecta la caída de una manzana sobre la caja.
 El motor de cada cinta transportadora se debe controlar de forma independiente.

Entradas y salidas necesarias

 motor_manzana. Salida de control del motor de la cinta transportadora de manzanas.
 motor_caja. Salida de control del motor de la cinta transportadora de cajas.
 start. Entrada asociada al pulsador de marcha.
 Stop. Entrada asociada al pulsador de paro.
 det_caja. Entrada asociada a la barrera infrarroja detectora de caja.
 det_manzana. Entrada asociada a la barrera infrarroja detectora de caída de manzana.

En un Siemens S7‐1200 estas entradas y salidas podrían quedar como muestra la imagen:

Para implementar el control del marcha/paro se va a usar un relé interno a modo de enclavamiento,
que contendrá el estado “marcha” activo cuando se pulse el botón de stop.

Vea el aspecto que tendría el control de este flag de “marcha” usando un diagrama de contactos.

En lugar de realizar un autoenclavamiento con contactos auxiliares, podemos utilizar la función
SR para activar el motor cuando la entrada S reciba una pulsación, y pararle cuando la entrada R
reciba otra pulsación.

189

Como puede verse, para que se ponga en “marcha” el proceso debe cerrarse el contacto “start”
(pulsándose el botón de start) y que no esté pulsado el botón de “stop”, para que así llegue la
activación al relé interno “marcha”.

Cuando está activo este estado de “marcha”, la señal le llegará a ese flag a través de la rama inferior
(por estar “marcha” activo) y del pulsador de stop, mientras que no esté pulsado (como vemos está
en lógica negativa, normalmente cerrado). Por tanto el estado de “marcha” se desactivará cuando se
pulse “stop”.

Vea la condición de movimiento para la cinta transportadora de manzanas: mientras que la caja sea
detectada justo en su posición, la cinta de manzanas estará en marcha aportando manzanas a la caja.

El final del rellenado de la caja lo determinará el conteo de 10 manzanas, conteo que pondrá en
marcha el motor de la cinta transportadora de cajas. En cuanto que se desplaza la caja, el detector de
caja se desactiva y por tanto se detiene el motor de la cinta de manzanas hasta que vuelva a
detectarse otra caja (que llegará vacía, claro está).

Para controlar la cinta transportadora de manzanas usaremos un contador ascendente (tipo CTU),
que contará el número de manzanas aportadas (la señal del detector de manzanas atacará a su
entrada de conteo) hasta llegar a 10 (el valor de PV). En cuanto que se llegue a 10, la cinta
transportadora de cajas se pondrá en marcha apartando la caja del detector.

La cinta seguirá en movimiento hasta que se detecte otra caja, de modo que para implementar este
comportamiento vamos a utilizar un biestable de tipo SR (prioridad al Set) que se pondrá en marcha
en cuanto se cuenten 10 manzanas (la salida del contador Q irá a la entrada Set del biestable) y se
desactivará justo cuando se detecte otra caja vacía: la señal del detector de caja se conectará a la
línea Reset del biestable. Como este biestable tiene exactamente el estado deseado para el motor de
cajas, se conecta dicho bit directamente al biestable.

190

Por su parte, al detectarse la nueva caja, también debe resetearse el contador CTU, para lo que debe
conectarse también la señal del detector de cajas a la línea Reset del contador (pulse sobre la imagen
inferior derecha para ampliarla).

Este tipo de controles, en los que los movimientos de unos elementos suponemos que van a
desactivar al instante otros detectores, deben someterse a prueba real para ajustar el ciclo de
trabajo a los tiempos de detección y de puesta en movimiento.

3.9. Ejemplo: Máquina mezcladora

Este ejemplo plantea una máquina mezcladora de dos líquidos diferentes (L1 y L2), que puede
proporcionar dos productos mezclados con composiciones diferentes: la mezcla1 y la mezcla2. Estos
productos responden a las siguientes proporciones:

 El producto mezcla1 contiene el doble del líquido L1 que del líquido L2.
 El producto mezcla2 contiene el doble del líquido L2 que del líquido L1.

Para generar esta mezcla los dos líquidos independientes, L1 y L2, se aportan al depósito de
aportación (Depósito 1) a través de dos electroválvulas: v1 y v2. Cuando se pulse el botón mezcla1 o
mezcla2 se inicia el proceso de llenado del depósito según el producto seleccionado. Si por error se
alcanza en el depósito el nivel máximo se detendría el proceso de aportación.

Una vez que se aporte el suficiente líquido al depósito de aportación se traspasará su contenido al de
mezcla a través de la válvula v3, que se cierra tras descargarse el depósito (situación que detecta el
detector min1 integrado en el depósito). En el depósito de mezcla se pone en marcha el agitador
para remover la mezcla durante un tiempo preestablecido, tras lo que se detiene el agitador y se da
por terminado el proceso, pudiendo servirse el producto final a través de una válvula manual.

Entradas y salidas necesarias

 mezcla1: botón de inicio con solicitud de producto “mezcla1” (entrada digital).
 mezcla2: botón de inicio con solicitud de producto “mezcla2” (entrada digital).
 máximo: detección de nivel demasiado alto en depósito de aportación (entrada digital).
 mínimo: detección de final de vaciado del depósito de aportación (entrada digital).
 v1: apertura de válvula v1, salida digital.
 v2: apertura de válvula v2, salida digital.

191

 v3: apertura de válvula v3, salida digital.
 agi: puesta en marcha del agitador de la mezcla, salida digital.

Las distintas variables y constantes son las siguientes:

Variables internas de estado

Para controlar el proceso vamos a definir 3 variables internas de estado que controlarán la fase en
que se encuentra el proceso en cada momento. Si todas estas fases están desactivas, el proceso
estará detenido en espera de iniciarse de nuevo. Los estados son:

 Llenando. Estado que se activa tras pulsar uno de los dos botones y que finaliza o bien por
tiempo de llenado de v1 y v2, o bien por alcanzar el nivel máximo del depósito.
 Trasvasando. Estado que se activa tras finalizar el llenado, y que controla el trasvase del
depósito 1 al depósito de mezcla. Finaliza cuando se active la señal de mínimo del depósito 1.
 Mezclando. Estado que se activa al terminar el trasvase de líquido al depósito de mezcla y
que finaliza tras consumirse el tiempo programado de mezclado.

Para controlar estas etapas del proceso definimos los relés internos de memoria “llenando”,
“trasvasando” y “mezclando”, que indicarán con sus estados en qué fase del proceso nos
encontramos.

192

Conjunto completo de variables necesarias

Vea en la siguiente imagen el conjunto completo de variables que se necesitan (entradas, salidas y
marcas de memoria):

Constantes de usuario

Para controlar los tiempos de llenado de cada líquido y el tiempo de mezcla se definen las constantes
de usuario siguientes:

 tl1m1: tiempo de aportación (en segundos) del líquido 1 para generar la mezcla1. Se define
como 300 segundos, 5 minutos. Recordemos que se definió el doble de L1 que de L2 en la
mezcla1.
 tl2m1: tiempo de aportación (en segundos) del líquido 2 para generar la mezcla1. Se define
como 150 segundos.
 tl1m2: tiempo de aportación (en segundos) del líquido 1 para generar la mezcla2. Se define
como 150 segundos. Recordemos que se definió el doble de L2 que de L1 en la mezcla2.
 tl2m2: tiempo de aportación (en segundos) del líquido 2 para generar la mezcla2. Se define
como 300 segundos.

193

Las fases del proceso son las tres siguientes:

Fase de llenado

Se comienza programando la máquina de transiciones de estados que dará el estado de cada
una de las etapas. Para empezar a operar la máquina es necesario pulsar el botón “mezcla1”
o el botón “mezcla2” cuando la máquina esté en reposo: es decir, que no esté ni llenando, ni
trasvasando ni mezclando. Esta condición se programa con una OR de los dos botones
(“>=1”) y a continuación con una AND (“&”) de 4 entradas que compruebe la pulsación de
alguno de los botones, y que la máquina no esté en ninguna de las fases de trabajo.

Así que esta condición de inicio para la fase de llenado se introduce en la pata Set de un
biestable RS, de modo que comenzará la fase de llenado cuando se dé esta circunstancia: se
pulsa uno de los dos botones mientras la máquina está en reposo. El biestable cargará
directamente el estado de la variable interna “llenando”.

El final de la fase de llenado lo pueden marcar dos circunstancias:

 O bien se llega al nivel máximo del depósito 1, activándose la señal “maximo”.
 O bien, estando en fase de llenado, se cierran las dos válvulas v1 y v2 (por haber
finalizado la aportación de líquido). Condición evaluada por la puerta AND (&) de triple
entrada

Estas dos circunstancias las implementa la puerta 0R (“>=1”) que activa el Reset (R1) del
biestable de llenado, marcando su fin. Al activarse esta señal de Reset se desactiva el estado
“llenando”.

194

Fase "trasvasando"

La próxima fase, “trasvasando”, se activa al desactivarse la fase de llenado: justo cuando
termina el llenado, comienza el transvase. Así que el inverso de la fase de llenado dispara el
Set de un biestable RS que controla la variable “trasvasando”, de modo que conforme
termina el llenado, se activa el biestable de señalización de la fase de trasvase.

El final de esta etapa de trasvase es muy directa, ya que finaliza cuando se detecta la señal de
mínimo en el depósito 1. Por tanto, simplemente se necesita pasar la activación de la señal
“minimo” al Reset del biestable que controla el estado “trasvasando”, como puede ver en la
imagen.

Etapa de mezclado

Para terminar el control de las distintas fases del funcionamiento de la máquina, en cuanto
que finaliza la etapa de trasvase debe activarse la etapa de mezclado. Del mismo modo que
en etapas anteriores, simplemente activando el Set del biestable que controla el estado
“mezclando” con la inversa de “transvasando” se conseguirá que esta última fase se inicie al
finalizar la de trasvase.

195

El final de la etapa de mezcla lo proporciona la finalización del tiempo programado de
mezclado, que se había guardado en la constante “tagitado”.

Para implementar esta temporización, en cuanto que se activa el estado “mezclando” en su
biestable asociado se dispara un temporizador de impulso que genera la señal de control de
la salida del agitador “agi”. El tiempo programado para este impulso es “tagitado” como
puede verse en la imagen. De modo que transcurrido ese tiempo, el agitador dejará de
remover la mezcla.

Como esta misma condición, final de la marcha de agitador, es la que finaliza el estado
“mezclando”, para desactivar el estado asociado solo tenemos que pasar por el Reset de su
biestable asociado la señal invertida del agitador (puede verla invertida en la entrada R1 del
biestable).

Una vez que se desactive la señal “mezclando” se tendrán desactivadas todas las fases:
“mezclando”, “transvasando” y “llenando” por lo que las puertas lógicas descritas al principio
volverán a aceptar la pulsación de los botones para iniciar un nuevo ciclo.

Para completar el control faltaría el control de las señales de las válvulas v1, v2 y v3, así como
la finalización del ciclo de llenado.

Los controles que se efectúan son los que se detallan a continuación:

Control válvula v3

El control de la válvula v3 es muy simple, ya que estará activa durante toda la fase de
trasvase:

Control de válvula v1

Estas válvulas deben abrirse simultáneamente al iniciarse el ciclo de llenado, deben estar
abiertas el tiempo programado según el tipo de producto que se quiera generar (“mezcla1” o
“mezcla2”) y cuando se cierren las dos, deben finalizar la fase de llenado.

Recuerde que los tiempos de llenado son diferentes para cada líquido y cada tipo de
producto, y que se definen con las constantes: tl1m1, tl2m1, tl1m2, tl2m2.

Vea cómo se realiza la temporización de la válvula v1 que controla el aporte del líquido l1.

196

El tiempo de activación de la válvula v1 se controlará con un temporizador de impusos
“Tliquido1”. El disparo del impulso se produce al iniciarse el ciclo de llenado, por lo que la
propia señal de estado de fase “llenando” puede disparar el biestable como puede ver.

La dificultad radica en programar el tiempo de llenado de ese impulso. Para ello se recurre a
un elemento de selección, que dependiendo del estado de su entrada “G” transfiere a su
salida (OUT) el valor que esté en la entrada IN0 (si G=0) o el que tiene en la entrada IN1 (si
G=1). Así que la señal que gobierna el tiempo que se necesita es la señal que indica la mezcla
solicitada (“mezcla1” o “mezcla2”): como introducimos en la entrada G la señal “mezcla2”,
cuando se haya pulsado el botón “mezcla2” el tiempo de consigna para el temporizador será
el correspondiente a IN1, que es “tl1m2” (es decir, el tiempo de llenado para el líquido 1
cuando se pulsa el botón “mezcla2”). Por el contrario, si se ha pulsado “mezcla1”, “mezcla2”
valdrá 0, y al meter 0 en la entrada G el tiempo seleccionado será “tl1m1”, es decir, el tiempo
de llenado para el líquido 1 cuando se selecciona “mezcla1”.

Así que con ese selector y el temporizador de impulsos ya tenemos controlada la salida de la
válvula v1.

Introducimos un mecanismo de seguridad, y es el necesario si se llena por completo el
depósito 1, cosa que no debería ocurrir, activando la señal “maximo”. Cuando esto ocurre,
como vimos más arriba, se finaliza la fase “llenando”. Debe conseguirse que cuando esto
ocurra, se detenga de inmediato el rellenado de las válvulas v1 y v2. Esta función de
seguridad se implementa con la puerta AND (“&”) que hace que la válvula v1 solo esté activa
si lo indica su temporizador y además está activa la fase “llenando”. De este modo, de
dispararse la señal de “maximo”, v1 se detendrá al momento.

197

Control de válvula v2

Un proceso totalmente análogo se sigue para el control de la válvula v2

Finalmente, una vez visto cómo se controlan v1 y v2, solo queda repasar cómo se finalizaba la fase de
llenado, que debe terminar cuando ya no estén abiertas ni v1, ni v2:

198

En este momento se vuelve a revisar cómo se reseteaba el biestable de “llenando”, bien porque se
active la señal “maximo”, bien porque estando en la fase de llenado dejen de activarse v1 y v2,
condición implementada por la AND (“&”) triple.

Amplíe información sobre otros ejemplos consultando los siguientes documentos:

 Pantalla táctil y S7‐1200 en TIA portal
 Comunicación entre dos equipos S7‐1200
 Conexión entre un S7‐1200 y un sistema SCADA

199

RESUMEN

¡Felicidades! Ha finalizado el curso AUTÓMATAS PROGRAMABLES (ELEE018PO)!

El objetivo general, tal y como define su programa formativo, ha consistido en aplicar los autómatas
programables a la gestión de proyectos.

Los autómatas programables son unos dispositivos electrónicos que facilitan las tareas de
control industrial gracias a un programa relativamente fácil de escribir para un técnico que no
sea especialista en informática, así como a unas características físicas especialmente apropiadas
para dichas tareas.

La primera parte de este curso ha sido teórica, centrada en la comprensión del hardware de los
autómatas programables, en sus peculiaridades y en cómo influyen en su manejo posterior,
conocimientos imprescindibles para entender los temas posteriores, más prácticos.

A continuación se ha visto otra singularidad específica del mundo de los autómatas
programables: el concepto del ciclo de funcionamiento. Se ha presentado la modalidad de
trabajo de su software, única de los PLC, cuya comprensión es vital para implementar un
programa.

No menos importante ha sido analizar las condiciones de trabajo, penosas en ocasiones, en que
tienen que funcionar los autómatas para su correcto funcionamiento a lo largo de su vida útil.

También se han introducido las distintas metodologías de diseño con que podemos abordar los
procesos de automatización y los principales lenguajes de programación disponibles, primero de
modo genérico y posteriormente centrándonos en el caso concreto del autómata S7‐200 y su
entorno de programación STEP‐7.

Finalmente, se han visto varios ejemplos prácticos para acercar al alumno a proyectos reales,
creados en un entorno de programación actual, que proponemos instalar para asimilar su
manejo y los condicionantes impuestos por un sistema de trabajo propietario.

En el apartado Documentación se ha incluido una extensa bibliografía para todas aquellas
personas que quieran seguir profundizando en el mundo de los autómatas programables.

Esperamos que el tiempo que ha dedicado a esta formación haya sido fructífero para usted y que
tenga la oportunidad de aplicarlo profesionalmente a lo largo de su vida laboral.

200

GLOSARIO

Actuadores

Dispositivos que reciben una señal eléctrica, neumática o hidráulica de un sistema de control
y trasladan dicha señal a una actuación física (desplazamiento, calentamiento, etc.).

Analógico

Tipo de medida que puede presentar valores continuos de dicha medida, con múltiples
valores posibles dentro de su rango de trabajo.

ASCII

Tabla de representación de valores alfanuméricos y de formateo de texto codificando cada
carácter con un byte de información.

Biestable

Circuito electrónico que puede mantener un bit de información por tiempo indefinido, con

entradas que permiten activarlo y desactivarlo.

Bit

Unidad básica de almacenamiento en un sistema binario que puede contener un único
estado (activo/desactivo).

Booleano

Relativo a la lógica de Boole, la aritmética de los valores binarios (verdadero y falso).

Bus de comunicación

Conjunto de líneas conductoras de la electricidad que transportan información digital bajo un
determinado protocolo que permite a distintos equipos comunicarse entre sí a distancia.

Bus interno

Conjunto de líneas conductoras de la electricidad que transportan información digital y por
las que un elemento principal de control transfiere información a distintos elementos
esclavos que comparten el acceso a dichas líneas conductoras dentro de un dispositivo.

Byte

Agrupación de 8 bits, unidad básica de almacenamiento en memorias, contenido de
registros, etc. Puede representar valores binarios desde el 0 al 255 (256 combinaciones en
total).

Campo

201

Espacio físico ocupado por la planta.

Combinacional

Tipo de sistema en el cual la salida solo depende de la combinación de entradas presentes en
ese momento.

Checksum

Suma de verificación de integridad de un fichero o conjunto de información. Es la suma del
valor binario de todos los bytes que conforman el fichero. Dado un fichero del que
conocemos su checksum, es fácil comprobar si el contenido es correcto o no, sumando todos
sus bytes y comprobando el resultado con el checksum que debería tener.

Contador

Elemento hardware especializado en el conteo rápido y preciso de señales que pueden llegar
a ser muy rápidas.

Corriente alterna

Aquella señal eléctrica en que el sentido de la corriente cambia regularmente, usualmente
varias veces por segundo. Las tensiones alternas pueden indicarse con el término Vca ó Vac
(de corriente alterna o alternating current).

Corriente continua

Aquella señal eléctrica en que el sentido de la corriente no cambia, pudiendo pasar más o
menos corriente, con más o menos tensión, pero circulando siempre en el mismo sentido.
Las tensiones continuas pueden indicarse con el término Vcc o Vdc (de corriente continua o
direct current).

CPU

Unidad central de proceso, acrónimo de Central Processing Unit. Corazón del autómata que
controla el funcionamiento del resto de subsistemas en base a un microprocesador, un
software de sistema y unos buses que la comunican con el resto de elementos.

CRC

Verificación de redundancia cíclica, es una técnica de generación de una marca de integridad
para un fichero o conjunto de datos más sofisticada y eficaz detectando errores que el
checksum.

Demultiplexor

Elemento con una entrada, varias salidas y un selector que indica qué salida recibe la
entrada.

202

Diagrama de flujo

Representación gráfica de los pasos a seguir en un algoritmo, con especial insistencia en las
bifurcaciones.

Digital

Que puede tener dos estados, habitualmente denominados activo y desactivo, ON y OFF, “1”
y “0”, verdadero y falso. Por extensión, que puede ser representado con un conjunto de
estos elementos.

Discretizar

Convertir una variable analógica en binaria, de modo que de los infinitos valores posibles
para la variable analógica en nuestra representación solo pueda tener un número
determinado de valores discretos. Por ejemplo, las temperaturas de 10º a 50ºC, si son
redondeadas a un único decimal, serían representables con 400 valores diferentes.

Envolvente

Caja o armario que protege a un equipo electrónico o un cuadro eléctrico.

E/S

Acrónimo de Entradas/Salidas.

Explotación

Se denomina explotación de la aplicación la parametrización, configuración o ajuste de ella
una vez que está siendo utilizada.

E2PROM

Lenta, no memoria que permite ser leída a buena velocidad y escrita de forma volátil.

FLASH

Memoria que permite ser leída a buena velocidad, y escrita a buena velocidad pero solo en
grandes bloques de información, no byte a byte.

GEMMA

Es una guía gráfica que representa de forma fácilmente comprensible todos los modos de
marcha y parada de una instalación y los posibles cambios de estado de unos estados a
otros.

GRAFCET

es un diagrama funcional que describe los procesos a automatizar, teniendo en cuenta las
acciones a realizar, y los procesos intermedios que provocan estas acciones.

203

Interfaz

Es un circuito electrónico que adapta las señales eléctricas procedentes de un entorno de
trabajo a los niveles de tensión, corriente y nivel de filtrado que necesita otro entorno de
trabajo diferente.

Long

Agrupación de 32 bits, 4 bytes, con 4294967296 de valores posibles.

Memoria volátil

Aquella que pierde su contenido al perder la alimentación eléctrica.

Multiplexor

Elemento con varias entradas, una salida y un selector que indica qué entrada se traspasa a
la salida.

Pantalla

En electrotecnica, lámina metálica que rodea a los hilos de un cable para protegerlos de las
interferencias.

Periférico

Dispositivo perteneciente a una computadora o autómata que no pertenece a la unidad
central.

Planta

Término que se refiere en automatización a la planta industrial, es decir, a la instalación que
está siendo controlada. También conocido como proceso.

PLC

Autómata programable, de Programmable Logic Controller, es un equipo electrónico de
control industrial y de automatización.

Protocolo de comunicación

Un conjunto de reglas que permiten a dos o más dispositivos electrónicos comunicarse entre
sí sobre un cierto soporte físico de intercambio de señales eléctricas.

RAM

Memoria volátil que permite ser leída y escrita a gran velocidad.

204

ROM

Memoria que solo permite ser leída.

Sensores

Dispositivos que detectan una cierta magnitud física o estado, y lo transmiten
convenientemente con señales eléctricas (pueden ser tanto digitales como analógicos).

Tabla de verdad

En un sistema booleano, es una tabla que muestra el estado de las salidas (verdadero/falso)
con cada una de las combinaciones de entradas. Si el sistema cuenta con n entradas, la tabla
de verdad tendrá 2^n combinaciones.

Tarjeta de ampliación

En sistemas modulares, módulo de ampliación de prestaciones de la unidad central. Su
nombre procede de los antiguos sistemas en los que en la unidad central existían zócalos
donde se insertaban circuitos electrónicos en forma de tarjeta. Actualmente suelen ser
elementos externos comunicados con la unidad central por un bus de comunicación.

Temporizador

Elemento hardware especializado en el conteo preciso de tiempos pudiendo funcionar a
modo de cronómetro, medidor de tiempo de activación, activando una alarma tras un
tiempo prefijado, etc.

Varistor

Componente electrónico pasivo muy usado para reducir picos de sobretensiones transitorias.
Su comportamiento se asemeja al de una resistencia variable de un valor resistivo muy alto
hasta que la tensión en sus bornas supera una tensión umbral, momento en que pasa a
comportarse como una resistencia con un valor óhmico muy bajo.

Watchdog

Vigilante de funcionamiento de sistema, es un tipo de temporizador especializado en
comprobar que el sistema está operativo. El watchdog se programa con un tiempo de
disparo, por ejemplo 0.5 segundos, y si antes de dicho tiempo no recibe órdenes del sistema
de refrescarse (y comenzar de nuevo su cuenta atrás de 0.5s) es él quien procede a resetear
al sistema, por interpretar que éste ha dejado de funcionar (ya que si funcionase, habría
refrescado al watchdog).

Word

Agrupación de 16 bits o lo que es lo mismo, de 2 bytes, codificando 65536 combinaciones de
valores binarios distintos.

205

BIBLIOGRAFÍA

BIBLIOGRAFÍA GENERAL Y BÁSICA

 BALCELLS, J., Romeral, J.L. Autómatas programables. Ed. Marcombo. Barcelona, 2000.
 MANDADO et al. Autómatas programables y sistemas de automatización. Ed. Marcombo.
Barcelona, 2009.

PÁGINAS WEB DE INTERÉS

 "¿Qué es un Siemens LOGO?" [en línea] Disponible en el siguiente enlace.
 "Álgebra de Boole. Lógica combinacional" [en línea] Disponible en el siguiente enlace.
 "Curso general de autómatas programables industriales". Presentación con diapositivas
disponible en el siguiente enlace.
 "Definición de diagrama de flujo" [en línea] Disponible en el siguiente enlace.
 "El contador rápido para encoder 'HSC' del S7‐1200" [en línea] Disponible en el siguiente
enlace.
 "Frecuencia y periodo". Física Práctica [en línea] Disponible en el siguiente enlace.
 "Funcionamiento de la pila (o stack)" [en línea] Disponible en el siguiente enlace.
 "Hacia el GRAFCET completo" [en línea] Disponible en el siguiente enlace.
 "Historia de los primeros microprocesadores" [en línea] Disponible en el siguiente enlace.
 "Iniciación a la programación en SCL" [en línea] Disponible en el siguiente enlace.
 "La función especial denominada watch dog timer para el sistema Bolt 18F2550" [en línea]
Disponible en el siguiente enlace.
 "La memoria de la CPU del ST‐1200" [en línea] Disponible en el siguiente enlace.
 "Los buses de campo: directo al grano" [en línea] Disponible en el siguiente enlace.
 "Los microprocesadores" [en línea] Disponible en el siguiente enlace.
 "Sencillo ejemplo de programación GRAFCET" [en línea] Disponible en el siguiente enlace.
 ÁVALOS, D. "Circuitos secuenciales". Presentación con diapositivas disponible en el siguiente
enlace.
 CANTO Q., Carlos. "Tipos de memoria". Presentación PowerPoint disponible en pdf en el
siguiente enlace.
 CCM. "Verificación de errores" [en línea] Disponible en el siguiente enlace.
 CHAVARRÍA COSAR, R. "NTP 86: dispositivos de parada de emergencia". Ministerio de
Trabajo y Asuntos Sociales. [en línea] Disponible en el siguiente enlace.
 CRUZ GUEVARA, E. "Mantenimiento preventivo, correctivo y adaptativo". Presentación con
diapositivas disponible en el siguiente enlace.
 El código ASCII [en línea] Disponible en el siguiente enlace.
 Gama de PLCs y controladores de Schneider. [en línea] Disponible en el siguiente enlace.
 Gama de relés programables del fabricante OMRON [en línea] Disponible en el siguiente
enlace.
 GARCÍA GONZÁLEZ, A. "Entradas y salidas analógicas y digitales". [en línea] Disponible en el
siguiente enlace.
 GARZÓN VÁZQUEZ, J.A. "¿Qué es la lógica cableada?" [en línea] Disponible en el siguiente
enlace.
 GEA. J.M. "Introducción al GRAFCET" [en línea] Disponible en el siguiente enlace.
 GÚTIEZ, I. "CPU Siemens 1217C: David contra Goliat" [en línea] Disponible en el siguiente
enlace.
 GÚTIEZ, I. "Giro de bits en step 7: el coche fantástico" [en línea] Disponible en el siguiente
enlace.

206

 GÚTIEZ, I. Vídeo Configuración básica de un variador Micromaster 420 [en línea] Disponible
en el siguiente enlace.
 GÚTIEZ, I. Vídeo Temporizadores en STEP7. Manejo y creación [en línea] Disponible en el
siguiente enlace.
 GÚTIEZ, I. Vídeo Giro de bits en step 7. Programación Siemens [en línea] Disponible en el
siguiente enlace.
 Ingeniería del mantenimiento. "Mantenimiento predictivo" [en línea] Disponible en el
siguiente enlace.
 JIMÉNEZ JUÁREZ, V. "Estructura interna del PLC". Presentación con diapositivas disponible
en el siguiente enlace.
 LLAMAS, L. "Medir el ángulo y sentido de giro con arduino y encoder rotativo" [en línea]
Disponible en el siguiente enlace.
 LÓPEZ AHUMADA, R. "Álgebra de Boole". En Fundamentos de los computadores. [en línea]
Disponible en el siguiente enlace.
 MARTÍN CASTILLO, J.C. Vídeo Bloques de datos (DB) STEP7 y TIAPORTAL [en línea] Disponible
en el siguiente enlace.
 MENGUAL, P. "Operaciones de byte, palabras y dobles palabras" [en línea] Disponible en el
siguiente enlace.
 MOZOS MUÑOZ, D. "Aritmética en punto flotante" [en línea] Disponible en el siguiente
enlace.
 RODRÍGUEZ, S. "Tiempos medios para, entre y reparar fallas". Presentación con diapositivas
disponible en el siguiente enlace.
 SALAZAR. "El PLC". Presentación con diapositivas disponible en el siguiente enlace.
 SARAVIA VASCONEZ, J. "Controlador lógico programable". Presentación con diapositivas
disponible en el siguiente enlace.
 Siemens. Controlador programable S7‐1200. Manual de sistema [en línea] Disponible en el
siguiente enlace.
 Siemens. Controlador programable S7‐1200. Manual de sistema [en línea] Disponible en el
siguiente enlace.
 Siemens. Programar con STEP 7 v5.2. Manual [en línea] Disponible en el siguiente enlace.
 Tecnoplc.com ""Tipos de datos en S7‐300" [en línea] Disponible en el siguiente enlace.
 TecTrux, D. "Configuración física del PLC". Presentación con diapositivas disponible en el
siguiente enlace.
 Vídeo 15 ADC de aproximaciones sucesivas [en línea] Disponible en el siguiente enlace.
 Vídeo Circuitos digitales 34. Convertidor analógico digital de rampa o escalera [en línea]
Disponible en el siguiente enlace.
 Vídeo Circuitos digitales 75. Convertidor analógico digital de tipo Flash [en línea] Disponible
en el siguiente enlace.
 Vídeo Qué es un PLC y su historia [en línea] Disponible en el siguiente enlace.
 VILLA, N. "Planta embotelladora" [en línea] Disponible en los siguientes enlace1 y enlace2.
 VILLANUEVA SÁNCHEZ, L. "Autómatas programables mod. 1". [en línea] Disponible en el
siguiente enlace.

207

También podría gustarte

Configuración de Instalaciones Domóticas y Automáticas
0% (2)
Configuración de Instalaciones Domóticas y Automáticas
2 páginas
Banco Ensayos Alecop
Aún no hay calificaciones
Banco Ensayos Alecop
19 páginas
Conexiones y Tipos de Cables Eléctricos
Aún no hay calificaciones
Conexiones y Tipos de Cables Eléctricos
39 páginas
Prácticas del Variador ATV31 en Mecatrónica
Aún no hay calificaciones
Prácticas del Variador ATV31 en Mecatrónica
17 páginas
Redes Aéreas de Distribución Eléctrica BT
Aún no hay calificaciones
Redes Aéreas de Distribución Eléctrica BT
80 páginas
TEMA - 2 Gestión de Montaje y Mantenimiento en Instalaciones Elécrtricas
Aún no hay calificaciones
TEMA - 2 Gestión de Montaje y Mantenimiento en Instalaciones Elécrtricas
20 páginas
Automatismos: Esquemas y Aplicaciones
Aún no hay calificaciones
Automatismos: Esquemas y Aplicaciones
6 páginas
Ud. 3 - Equipos Electricos y Electronicos
Aún no hay calificaciones
Ud. 3 - Equipos Electricos y Electronicos
51 páginas
Domótica y Programación con LOGO!
Aún no hay calificaciones
Domótica y Programación con LOGO!
156 páginas
Certificado Instalación Eléctrica Madrid
Aún no hay calificaciones
Certificado Instalación Eléctrica Madrid
2 páginas
Libros sobre Automatismos GRAFCET y PLC
Aún no hay calificaciones
Libros sobre Automatismos GRAFCET y PLC
6 páginas
Práctica 08 - Automático de Escalera Con 4 Hilos PDF
Aún no hay calificaciones
Práctica 08 - Automático de Escalera Con 4 Hilos PDF
3 páginas
Practica Puerta Garaje
Aún no hay calificaciones
Practica Puerta Garaje
11 páginas
Circuitos y Simulación en Electrónica
Aún no hay calificaciones
Circuitos y Simulación en Electrónica
7 páginas
Instrucciones Prueba B2 Instalaciones Electrotécnicas
Aún no hay calificaciones
Instrucciones Prueba B2 Instalaciones Electrotécnicas
22 páginas
Sistemas Hidráulicos: Diseño y Montaje
Aún no hay calificaciones
Sistemas Hidráulicos: Diseño y Montaje
96 páginas
CuadernoTrabajoICT UD1
Aún no hay calificaciones
CuadernoTrabajoICT UD1
23 páginas
Ejercicios de Instalaciones Eléctricas
Aún no hay calificaciones
Ejercicios de Instalaciones Eléctricas
1 página
Introducción a Sistemas Automáticos
Aún no hay calificaciones
Introducción a Sistemas Automáticos
30 páginas
Solucionario IEInteriores Muestra Ud1 PDF
Aún no hay calificaciones
Solucionario IEInteriores Muestra Ud1 PDF
8 páginas
Esquemas eléctricos para motores y cintas
Aún no hay calificaciones
Esquemas eléctricos para motores y cintas
3 páginas
Práctica Nº3 (Conexión de Tres Bat Mediante Regletas Repartidoras Idc)
Aún no hay calificaciones
Práctica Nº3 (Conexión de Tres Bat Mediante Regletas Repartidoras Idc)
2 páginas
EAE 1º IMA201 - Programación Didáctica
Aún no hay calificaciones
EAE 1º IMA201 - Programación Didáctica
15 páginas
Prácticas de Instalaciones Eléctricas
Aún no hay calificaciones
Prácticas de Instalaciones Eléctricas
69 páginas
Sistemas Eléctricos y Neumáticos en Automatización
Aún no hay calificaciones
Sistemas Eléctricos y Neumáticos en Automatización
24 páginas
Musa-Plus Manual Esp 08
Aún no hay calificaciones
Musa-Plus Manual Esp 08
12 páginas
MME 22 Ejercicios Automatismos Cableados
Aún no hay calificaciones
MME 22 Ejercicios Automatismos Cableados
1 página
Apuntes x10
Aún no hay calificaciones
Apuntes x10
9 páginas
Automatizacion Industrial III
Aún no hay calificaciones
Automatizacion Industrial III
5 páginas
Instalación Eléctrica en Viviendas
Aún no hay calificaciones
Instalación Eléctrica en Viviendas
15 páginas
Sistemas Secuenciales Programables en Automatización
Aún no hay calificaciones
Sistemas Secuenciales Programables en Automatización
43 páginas
Control de luces y persianas con pulsadores
Aún no hay calificaciones
Control de luces y persianas con pulsadores
3 páginas
Programación de Autómatas: GRAFCET y Lenguajes
Aún no hay calificaciones
Programación de Autómatas: GRAFCET y Lenguajes
21 páginas
Alecop CMA-200 - Manual de Prácticas - Regulación de Velocidad de Máquinas Asíncronas
Aún no hay calificaciones
Alecop CMA-200 - Manual de Prácticas - Regulación de Velocidad de Máquinas Asíncronas
125 páginas
Practica Nº5 Calculo de Lineas de Distribucion Con Dmelect Redbt
Aún no hay calificaciones
Practica Nº5 Calculo de Lineas de Distribucion Con Dmelect Redbt
2 páginas
Solucionario - Instalaciones Electricas Basicas Paranifo
Aún no hay calificaciones
Solucionario - Instalaciones Electricas Basicas Paranifo
29 páginas
Instalaciones Electrotécnicas
100% (1)
Instalaciones Electrotécnicas
4 páginas
Ejercicios Resueltos Grafcet PDF
100% (1)
Ejercicios Resueltos Grafcet PDF
3 páginas
Normativa 2019: Cambios en ICT y TDT
Aún no hay calificaciones
Normativa 2019: Cambios en ICT y TDT
28 páginas
Maxicontrolador LCD XTP040503 Kit Controlmax XTP270503 Kit Segurmax XTR200503
100% (1)
Maxicontrolador LCD XTP040503 Kit Controlmax XTP270503 Kit Segurmax XTR200503
80 páginas
Curso Instalaciones Eléctricas 2023/24
Aún no hay calificaciones
Curso Instalaciones Eléctricas 2023/24
50 páginas
TECNICAS Y PROCESOS EN LAS INSTALACIONES AUTOMATIZADAS EN EDIFICIOS Paraninfo PDF
Aún no hay calificaciones
TECNICAS Y PROCESOS EN LAS INSTALACIONES AUTOMATIZADAS EN EDIFICIOS Paraninfo PDF
217 páginas
Instalaciones Electrotecnicas y de Comunicaciones
Aún no hay calificaciones
Instalaciones Electrotecnicas y de Comunicaciones
6 páginas
0235 - Instalaciones Electricas Interiores
Aún no hay calificaciones
0235 - Instalaciones Electricas Interiores
8 páginas
Cuestionario sobre Automatismos Eléctricos
Aún no hay calificaciones
Cuestionario sobre Automatismos Eléctricos
8 páginas
Procedimiento Selectivo Profesores Música 2021
Aún no hay calificaciones
Procedimiento Selectivo Profesores Música 2021
12 páginas
Practica Logosoft
Aún no hay calificaciones
Practica Logosoft
9 páginas
Ejemplos Resueltos de Prevsión de Cargas
Aún no hay calificaciones
Ejemplos Resueltos de Prevsión de Cargas
25 páginas
Cálculo de Potencias y Secciones Eléctricas
Aún no hay calificaciones
Cálculo de Potencias y Secciones Eléctricas
8 páginas
Mantenimiento y Cableado Eléctrico
Aún no hay calificaciones
Mantenimiento y Cableado Eléctrico
16 páginas
Instalación de TV y Radio con Amplificador
Aún no hay calificaciones
Instalación de TV y Radio con Amplificador
4 páginas
Tema 1 Automatismos
100% (2)
Tema 1 Automatismos
10 páginas
Medición de Magnitudes Eléctricas y Circuitos
Aún no hay calificaciones
Medición de Magnitudes Eléctricas y Circuitos
5 páginas
TPDA UD06 Programación de Relés Programables en FBD
Aún no hay calificaciones
TPDA UD06 Programación de Relés Programables en FBD
26 páginas
Problemas de Circuitos Electrotécnicos
Aún no hay calificaciones
Problemas de Circuitos Electrotécnicos
62 páginas
II) Sistemas Programables Avanzados
Aún no hay calificaciones
II) Sistemas Programables Avanzados
303 páginas
Lab. 2 y 3 PLC 2025-1
Aún no hay calificaciones
Lab. 2 y 3 PLC 2025-1
30 páginas
Programacion GB EEE Informatica
Aún no hay calificaciones
Programacion GB EEE Informatica
44 páginas
Prácticas de Autómatas Programables
100% (1)
Prácticas de Autómatas Programables
4 páginas
Innovación en Programación con Arduino
Aún no hay calificaciones
Innovación en Programación con Arduino
2 páginas
Grabación de Pantalla con Screen ONVIF
Aún no hay calificaciones
Grabación de Pantalla con Screen ONVIF
1 página
Informe Programas Contables Ecuador
Aún no hay calificaciones
Informe Programas Contables Ecuador
4 páginas
Componentes Esenciales del Hardware Informático
Aún no hay calificaciones
Componentes Esenciales del Hardware Informático
13 páginas
Proyecto Calculo
Aún no hay calificaciones
Proyecto Calculo
10 páginas
Cuestionario Capítulo 1 - V7
Aún no hay calificaciones
Cuestionario Capítulo 1 - V7
19 páginas
Snapdragon 8 Gen 3: Potencia y Eficiencia
Aún no hay calificaciones
Snapdragon 8 Gen 3: Potencia y Eficiencia
6 páginas
Evaluación Preliminar de Arquitectura 8088
Aún no hay calificaciones
Evaluación Preliminar de Arquitectura 8088
6 páginas
Modelación Hidrodinámica con HEC-RAS
Aún no hay calificaciones
Modelación Hidrodinámica con HEC-RAS
12 páginas
Ga5 220501095 Aa1 Ev03 Elaboracion de Interfaz Grafica y Mapa de Navegacion Cumpliendo Con Reglas de Usabilidad y Accesibilidad - Compress
100% (1)
Ga5 220501095 Aa1 Ev03 Elaboracion de Interfaz Grafica y Mapa de Navegacion Cumpliendo Con Reglas de Usabilidad y Accesibilidad - Compress
17 páginas
Componentes y Evolución de Placas Base
Aún no hay calificaciones
Componentes y Evolución de Placas Base
14 páginas
Taller de Sensores IoT Económicos
Aún no hay calificaciones
Taller de Sensores IoT Económicos
5 páginas
Desarrollo de La Actividad Manual de Especificaciones
Aún no hay calificaciones
Desarrollo de La Actividad Manual de Especificaciones
43 páginas
Referentes Teóricos en Electricidad y Electrónica
Aún no hay calificaciones
Referentes Teóricos en Electricidad y Electrónica
6 páginas
Memoria Caché: Tipos L1, L2 y L3 Explicados
0% (2)
Memoria Caché: Tipos L1, L2 y L3 Explicados
4 páginas
Servicio de Mud Logging en Trujillo
Aún no hay calificaciones
Servicio de Mud Logging en Trujillo
21 páginas
MODULO2 Examen2
100% (1)
MODULO2 Examen2
3 páginas
Diferencias Entre Las Herramientas Ofimáticas
Aún no hay calificaciones
Diferencias Entre Las Herramientas Ofimáticas
4 páginas
Multilim 350 Capitulo 2
100% (1)
Multilim 350 Capitulo 2
17 páginas
(CASO) Error de División Del Intel Pentium (1994)
0% (2)
(CASO) Error de División Del Intel Pentium (1994)
8 páginas
HP Mini-110 3133ss
Aún no hay calificaciones
HP Mini-110 3133ss
2 páginas
Componentes Clave de Infraestructura TI
Aún no hay calificaciones
Componentes Clave de Infraestructura TI
5 páginas
Historia y Estrategia de Intel 1968-2003
Aún no hay calificaciones
Historia y Estrategia de Intel 1968-2003
6 páginas
Introducción a DSPS
100% (1)
Introducción a DSPS
17 páginas
Generaciones de La Computadora y Su Imagen
Aún no hay calificaciones
Generaciones de La Computadora y Su Imagen
5 páginas
Circuitos Integrados Digitales
Aún no hay calificaciones
Circuitos Integrados Digitales
28 páginas
Monografía Sobre Resistencia Térmica de Contacto - UCV
Aún no hay calificaciones
Monografía Sobre Resistencia Térmica de Contacto - UCV
16 páginas
Como Funcionan Las Computadoras PDF
Aún no hay calificaciones
Como Funcionan Las Computadoras PDF
103 páginas
Vlackpink Studio - Anfitrionas de Videochat - Formulario de Aplicante
Aún no hay calificaciones
Vlackpink Studio - Anfitrionas de Videochat - Formulario de Aplicante
3 páginas
Hardware y Software
Aún no hay calificaciones
Hardware y Software
21 páginas
Mantenimiento Informático Corporación A&E Valeria
Aún no hay calificaciones
Mantenimiento Informático Corporación A&E Valeria
5 páginas