05 tutorial s7-300 niveli

Página:

1/82

TUTORIAL DE PROGRAMACIÓN SIMATIC S7 300 (NIVEL I)

Página:

2/82

Contenido

1. OBJETIVOS ..................................................................................................................................... 4 2. INTRODUCCIÓN ............................................................................................................................ 4

2.1. PLC’s .......................................................................................................................... 4 2.2. Autómatas Siemens ..................................................................................................... 4 2.3. Lenguajes de programación ........................................................................................ 5 2.4. Concepto de instrucción .............................................................................................. 7 2.5. Organización de programas......................................................................................... 8

3. MÓDULOS Y DATOS..................................................................................................................... 8 3.1. Tipos de módulos ........................................................................................................ 8 3.2. Tipos de datos ............................................................................................................. 9 3.3. Entradas y salidas ........................................................................................................ 9 3.4. Marcas de memoria ................................................................................................... 10 3.5. Registros ................................................................................................................... 10

4. SISTEMAS DE NUMERACIÓN ................................................................................................... 11 4.1. Sistema Decimal ....................................................................................................... 12 4.2. Sistema Binario ......................................................................................................... 12 4.3. Hexadecimal ............................................................................................................. 12 4.4. BCD .......................................................................................................................... 12 4.5. Conversiones ............................................................................................................. 12 4.6. Ejercicios de aplicación ............................................................................................ 13

5. INTRODUCCIÓN A LA PROGRAMACIÓN EN STEP 7 ........................................................... 13 5.1. Introducción al autómata S7-300 .............................................................................. 14 5.2. Crear un proyecto en STEP 7 .................................................................................... 14 5.3. Ejercicio de aplicación .............................................................................................. 21 5.4. Introducción al PLCSim ............................................................................................ 22

6. PROGRAMACIÓN BÁSICA ........................................................................................................ 28 6.1. Primera consulta ........................................................................................................ 28 6.2. Consulta de entradas. Contactos na. y nc. ................................................................. 28 6.3. Asignación ................................................................................................................ 29 6.4. Función AND (Y) ..................................................................................................... 30 6.5. Función OR (O) ........................................................................................................ 31 6.6. Y antes de O .............................................................................................................. 31 6.7. Función XOR (O exclusiva) ...................................................................................... 32 6.8. Expresiones entre paréntesis ..................................................................................... 32 6.9. Ejercicios propuestos: ............................................................................................... 33 6.10. Set y Reset................................................................................................................ 34 6.11. Ejercicios propuestos ................................................................................................ 36 6.12. Operaciones de flancos ............................................................................................. 37 6.13. Marcas Remanentes .................................................................................................. 38 6.14. Marca de ciclo ........................................................................................................... 39 6.15. Negar, activar, desactivar y salvar el RLO ................................................................ 40

7. OPERACIONES DE CARGA Y TRANSFERENCIA .................................................................. 41 7.1. Operación de carga.................................................................................................... 41 7.2. Operación de transferencia ........................................................................................ 42

8. OPERACIONES DE CONTAJE .................................................................................................... 43 8.1. Operaciones con contadores ...................................................................................... 43 8.2. Ejercicios propuestos ................................................................................................ 46

Página:

3/82

9. OPERACIONES DE TEMPORIZACIÓN ..................................................................................... 47 9.1. Operaciones con temporizadores .............................................................................. 47 9.2. Temporizador como impulso (SI) ............................................................................. 50 9.3. Temporizador como impulso prolongado (SV)......................................................... 51 9.4. Temporizador como retardo a la conexión (SE) ....................................................... 52 9.5. Temporizador como retardo a la conexión con memoria (SS) .................................. 53 9.6. Temporizador como retardo a la desconexión (SA) .................................................. 54 9.7. Elegir el temporizador adecuado ............................................................................... 55 9.8. Preselección variable y visualización del valor de temporización ............................ 56 9.9. Ejercicios propuestos ................................................................................................ 57

10. FORMATOS DE REPRESENTACIÓN DE NÚMEROS .............................................................. 59 10.1. Números enteros (I) .................................................................................................. 59 10.2. Números dobles enteros (D)...................................................................................... 60 10.3. Números reales (R) ................................................................................................... 60

11. OPERACIONES DE COMPARACIÓN ........................................................................................ 61 11.1. Realización de comparaciones .................................................................................. 61 11.2. Comparar dos números enteros y dobles enteros ...................................................... 61 Comparación efectuada ....................................................................................................... 61 11.3. Comparar dos números reales ................................................................................... 63 11.4. Ejercicios propuestos ................................................................................................ 64

12. OPERACIONES DE CONVERSIÓN ............................................................................................ 65 13. OPERACIONES ARITMÉTICAS ................................................................................................. 67

13.1. Operaciones aritméticas con enteros ......................................................................... 67 13.2. Operaciones aritméticas con números reales............................................................. 68 13.3. Ejercicios propuestos ................................................................................................ 70

14. OPERACIONES LÓGICAS ........................................................................................................... 71 14.1. Operación lógica AND .............................................................................................. 71 14.2. Operación lógica O. .................................................................................................. 71 14.3. Operaciones lógicas XOR. ........................................................................................ 72

15. OPERACIONES DE DESPLAZAMIENTO .................................................................................. 73 15.1. Desplazar palabras .................................................................................................... 73 15.2. Desplazar doble palabras .......................................................................................... 73 15.3. Desplazar enteros ...................................................................................................... 73 15.4. Desplazar dobles enteros ........................................................................................... 74 15.5. Ejercicio propuesto .................................................................................................. 74

16. OPERACIONES DE ROTACIÓN ................................................................................................. 74 16.1. Rotar palabras dobles ................................................................................................ 74

17. OPERACIONES DE SALTO ......................................................................................................... 76 17.1. Operaciones de salto incondicional ........................................................................... 76 17.2. Operaciones de salto condicional, en función del RLO ............................................ 78 17.3. Operaciones de salto condicional, en función de RB u OV/OS ................................ 80 17.4. Operaciones de salto condicional, en función de A1 y A0 ........................................ 80 17.5. Finalizar módulos ...................................................................................................... 82

Página:

4/82

1. OBJETIVOS Con este tutorial se pretende enseñar los conocimientos necesarios para programar los autómatas de la serie Simatic S7-300 con el software de programación Step7. No se va a mostrar la utilización del programa Step7, ya que este programa es comercial e incluye los manuales necesarios para su empleo. Todo lo aquí expuesto ha sido obtenido de los manuales del autómata, pero se ha estructurado de distinta forma, tratando que la persona que lo utilice no se pierda en ningún momento y que acceda de forma rápida a lo que busca. Por supuesto, este tutorial no es una alternativa al manual que incorpora el autómata, se debe tomar como una guía complementaria. El manual proporciona más ejemplos y mayor detalle que el expuesto aquí. Es necesario que el lector esté familiarizado con el álgebra de Boole, y si se está familiarizado con algún otro lenguaje de será mucho más sencillo y rápido. 2. INTRODUCCIÓN

2.1. PLC’s Los Controladores Lógicos Programables (PLCs), también llamados autómatas programables, forman parte de la familia de los ordenadores. Se usan en aplicaciones comerciales e industriales. Un autómata monitoriza las entradas, toma decisiones basadas en su programa, y controla las salidas para automatizar un proceso o máquina. Este curso trata de suministrar la información básica sobre las funciones y las configuraciones de los autómatas programables. 2.2. Autómatas Siemens Siemens fabrica varias líneas de autómatas de la familia SIMATIC S7. Son: S7-200, S7-300 y S7-400. Actualmente ha sacado al mercado S7-1200 y S7-1500 S7-200 Al S7-200 es un autómata de gama media, a causa de su pequeño tamaño. El S7-200 tiene un diseño compacto que significa que la fuente de alimentación y las Entradas/Salidas las lleva incorporadas. El S7-200 puede usarse en pequeñas y medianas aplicaciones independientes. Este autómata será descatalogado a corto plazo. S7-300 y S7-400 Estos autómatas se usan en aplicaciones más complejas que necesitan de un mayor número de Entradas/Salidas. Ambos son modulares y ampliables. La fuente de alimentación y las Entradas/Salidas consisten en módulos independientes conectados a la CPU. La elección entre el S7-300 y el S7-400 depende de la complejidad de la tarea y de una posible ampliación futura.

Página:

5/82

Tabla comparativa de las CPU´s de un S7-300

2.3. Lenguajes de programación Hasta el momento se ha descrito al PLC como una máquina formada por elementos de hardware capaces de comunicarse físicamente con el proceso para:

Recoger el conjunto de variables (digitales y/o analógicas) que definen el estado del mismo (señales de entrada),

Enviar otro conjunto de variables que modifiquen dicho estado en un sentido predeterminado (señales de salida).

Pero para esto, el PLC necesita para su completa adaptación al proceso de un operador humano que defina como se quiere la evolución del mismo. Este operador intercambia entonces información con el hardware del PLC para:

Fijar, mediante una secuencia de órdenes, la ley general de mando, de la que se obtienen las variables de salida o de control,

Intervenir, continuamente o no, sobre el proceso para modificar la evolución o, simplemente, para leer su estado.

El primero de los puntos, establecimiento de la secuencia de órdenes, se denomina programación de PLC, y la secuencia establecida, programa de aplicación. Al segundo punto, intervención del operador sobre el proceso, se le conoce comúnmente como explotación de la aplicación, y durante ella se permiten modificar algunos parámetros (tiempo, consignas, módulos de cuenta, etc.), pero no modificar el programa. Se ha descrito pues, a la programación como la codificación al lenguaje del PLC del conjunto de órdenes que forman la ley de mando o control deseada. Codificar, a su vez, significa transformar una información en otra equivalente de distinto formato. Por lo que un programa es una sucesión o lista en un determinado orden de distintas órdenes de trabajo también llamadas instrucciones y capaz de hacer ejecutar al autómata la secuencia de trabajo pretendida.

Página:

6/82

Por lo tanto, se define, de esta manera, al lenguaje de programación como un conjunto de símbolos y textos inteligibles por la unidad de programación que le sirven al usuario para codificar sobre un cierto Autómata las leyes de control deseadas, mientras que lenguaje de explotación será el conjunto de órdenes y comandos que el usuario puede enviar, desde la misma unidad o desde un terminal adecuado, para recoger estados o modificar variables de proceso. La programación del PLC pasa, pues, por los siguientes pasos:

1. Determinar qué debe hacer el sistema de control y en qué orden (por ejemplo, mediante un diagrama de flujo, una descripción literal, etc.). 2. Identificar los componentes (señales) de entrada y salida al PLC. 3. Representar mediante un modelo el sistema de control, indicando todas las funciones que intervienen, las relaciones entre ellas, y la secuencia que deben de seguir. Esta representación puede ser:

Algebraica: Instrucciones literales. Gráfica: Símbolos gráficos.

4. Asignar direcciones de entrada/salida o internas a cada uno de los componentes que aparecen en el modelo. 5. Codificar la representación anterior en instrucciones o símbolos inteligibles por la unidad de programación. Esto, dado que, el código de salida a obtener son los códigos binarios que entiende la CPU; El código de entrada no es más que el control que se quiere implementar, representado en alguna forma. 6. Transferir las instrucciones obtenidas a la memoria del Autómata desde la unidad de programación. 7. Depurar el programa y obtener una copia de seguridad.

En pocas palabras, al conjunto total de instrucciones, órdenes y símbolos que están disponibles para escribir un programa se le denomina lenguaje de programación. Para toda la familia de autómatas Simatic S7 se emplean los siguientes lenguajes de programación:

VENTAJAS DEL AWL: Es el lenguaje que necesita menos instrucciones de programación de todos. Esto

permite optimizar la cantidad de memoria disponible en el PLC, pero sobre todo el tiempo de ciclo es menor, por lo que se pueden utilizar CPU’s “lentas” para procesos relativamente rápidos, aún con programas considerables.

Es el más indicado para operaciones de saltos condicionales en función de valores analógicos. Cualquier tratamiento analógico que sobrepase la simple comparación es el terreno del AWL.

Permite introducir una gran cantidad de sentencias en la misma pantalla, con lo cual los test status no requieren de desplazamientos en la misma. INCONVENIENTES DEL AWL:

La programación de secuencias de pasos en procesos (set y reset de etapas) carece de sentido en este lenguaje, ya que no se gana memoria y el programa se convierte en ininteligible hasta para el propio programador.

El programar una línea debajo de otra lleva a los programadores a implementar LINEAS Y LINEAS DE CODIGO SIN SER DIVIDIDAS EN SEGMENTOS Y SIN COMENTAR. Programas ininteligibles.

VENTAJAS DEL KOP: Es muy sencillo seguir las condiciones del proceso. Totalmente indicado para programadores más cercanos al mundo eléctrico

INCONVENIENTES EN KOP:

Las series y paralelos requieren tanto espacio en pantalla que enseguida se nos salen de la misma, por lo que en status nos debemos de desplazar a menudo.

El realizar comparaciones de salto analógicas es misión imposible, a poco que se compliquen.

Y el principal problema: las cajas de KOP necesitan una sistemática de proceso por parte del Step 7 que hace que no se optimice el código de las mismas, por lo que el programa haciendo lo mismo va más lento.

Página:

7/82

Internamente el autómata solo trabaja con lista de instrucciones, KOP y FUP son traducidos a AWL por Step7. En este tutorial veremos la programación en lista de instrucciones y esquema de contactos. ¿En qué lenguaje debo programar? La respuesta es evidente, cada vez uno. Para las tareas que no sean setear, resetear o activar bits, el AWL es sin dudas el lenguaje a utilizar. Las ventajas del mismo sobrepasan ampliamente los inconvenientes. Sin embargo para todas las activaciones (series y contactos que van a parar a bobinas, ya sean enclavadas o no) la decisión debe de ser KOP o FUP, dependiendo del gusto del programador. Si el programador tiene la misma destreza con KOP que con FUP. Decantarse por FUP tiene más ventajas. 2.4. Concepto de instrucción

Una instrucción puede no contener operando (ej. NOT). El operando puede ser sustituido por un nombre simbólico (ej. MOTOR_ON), el cual debe ser especificado al comienzo del programa para indicar a que entrada o salida equivale.

VENTAJAS DEL FUP: Permite realizar gran cantidad de series y paralelos en la misma pantalla,

con lo cual se acerca a la ventaja del AWL, pero con mayor claridad en el diagnóstico.

Es el indicado para los programadores electrónicos. INCONVENIENTES FUP:

No es útil, al igual que le pasaba al KOP, para tratar valores analógicos ni condiciones de salto.

Sufre el mismo problema de optimización de código en el tratamiento que realiza del mismo el Step 7.

Página:

8/82

2.5. Organización de programas Antes de diseñar un programa es necesario entender los diferentes modos en que se puede estructurar, distinguir los distintos tipos de módulo utilizables así como la forma de trabajo del PLC. La mayoría de los PLC permiten diseñar el programa de forma lineal o estructurada.

Programación Lineal : Todo el programa está contenido en un único módulo. Normalmente, este módulo es el OB1 (módulo de elaboración cíclica). Las instrucciones se van ejecutando secuencialmente una detrás de otra. Este sistema de programación sólo está recomendado en proyectos pequeños. Programación estructurada: La programación estructurada implica la división del programa en diversos bloques. Cada uno de estos bloques constituye al mismo tiempo un subprograma. Por lo tanto, se recomienda utilizar este tipo de programación. 3. MÓDULOS Y DATOS 3.1. Tipos de módulos Simatic S7 dispone de una serie de módulos que dividen la memoria de programa y la de datos en secciones, permitiendo una programación estructurada y un acceso ordenado a los datos. El número de módulos va a depender del tipo de CPU empleada, disponiendo en general de los siguientes:

Página:

9/82

Módulos de organización (OB) Constituyen la forma de comunicación entre el sistema operativo de la CPU y el programa de usuario. Existen varios tipos de OB, los cuales están accesibles o no según el tipo de CPU:

• OB 1 (ciclo libre): es el módulo principal, el que se ejecuta cíclicamente y del que parten todos los saltos a otros módulos.

• OB de interrupciones horarias y de error: son los que contienen la secuencia de acciones a realizar en caso de que se produzca una alarma o error programado.

• OB de arranque: en este módulo podemos introducir valores por defecto que permiten el arranque definido a la instalación, bien en un arranque inicial o tras un fallo en la alimentación.

Funciones (FC) Son módulos en los que podemos incluir parte del programa de usuario con lo que obtenemos un programa mucho más estructurado. A estos módulos se pueden acceder desde otro módulo FC o desde un módulo OB. Módulos de funciones (FB) Son módulos de programa especiales. Aquí se introducen las partes de programa que aparecen con frecuencia o poseen gran complejidad. Posee una zona de memoria asignada para guardar variables (módulo de datos de instancia). Lo que se hace es enviar parámetros al FB y guardar algunos de los datos locales en el módulo de datos de instancia. Módulos de datos (DB) Son áreas de memoria destinadas a contener datos del programa de usuario. Existen módulos de datos globales y de instancia. A los datos contenidos en un módulo de datos es posible acceder de forma absoluta o simbólica. Los datos complejos o compuestos pueden depositarse en forma de estructura. Los módulos de datos pueden ser de dos tipos:

• Módulos de datos globales: se pueden utilizar por cualquier módulo del programa. • Módulos de datos de instancia: se asignan a un determinado modulo de función y solo pueden manejarse desde

dicho módulo. Pueden asignarse varios módulos de datos de instancia a un módulo de función. Módulos de funciones especiales (SFB) Se tratan de módulos ya programados, los cuales están preparados para realizar acciones complejas como regulación PID (lazo cerrado), medida de frecuencia, etc... Funciones del sistema (SFC) Son funciones integradas en el sistema operativo de la CPU y que se pueden llamar en caso de necesidad desde el programa de usuario. 3.2. Tipos de datos Los operandos se componen de un dato que puede ser de distintos tipos. Los tipos de datos posibles son:

E entrada A salida M marca P periferia (acceso directo) L datos locales T temporizador Z contador DB módulo de datos

Cada uno de estos tipos se puede direccionar en 4 posibles modos (salvo T y Z):

• Por defecto (X para DB): Bit. Un bit es la unidad para dígitos binarios o caracteres binarios. Es la unidad más pequeña de información. Permite dos estados: "0" ó "1". Los bits pueden agruparse para formar unidades mayores.

• B: byte (8 bits). • W: palabra (16 bits). • D: palabra doble (32 bits).

Página:

10/82

3.3. Entradas y salidas Tal y como comentamos anteriormente, manejaremos una imagen de las entradas y las salidas. El número de e/s disponibles dependerá del tipo de CPU que empleemos, además de los módulos externos que tengamos conectados. La CPU 314 IFM puede manejar como máximo hasta 256 bytes para cada tipo de e/s. En este caso se podría direccionar como: IMAGEN DEL PROCESO DE LAS ENTRADAS (PAE): Entrada E 0.0 a E 255.7 Byte de entrada EB 0 a EB255 Palabra de entrada EW 0 a EW254 Palabra doble de entrada ED 0 a ED252 IMAGEN DEL PROCESO DE LAS SALIDAS (PAA): Salida A 0.0 a A255.7 Byte de salida AB 0 a AB255 Palabra de salida AW 0 a AW254 Palabra doble de salida AD 0 a AD252 Todas estas entradas y salidas pueden ser de tres tipos:

• E/S digitales: son las e/s más frecuentes y que en mayor cantidad vamos a tener. • E/S digitales de alarma/error: no son e/s adicionales, se configuran dentro de Step7 y ocupan una de las e/s digitales normales. • E/S analógicas: estas si son e/s adicionales, pero no obstante hay que configurarlas también desde Step7 para especificar el rango de direcciones que van a ocupar. Ocupan 2 bytes de memoria.

3.4. Marcas de memoria Cuando realicemos nuestro programa y operemos a nivel de bit en operaciones lógicas (and, or, etc.) puede que nos aparezca la necesidad de almacenar el resultado lógico que tengamos en un determinado momento. Para ello disponemos de 256 marcas de memoria de 1 byte, es decir un total de 2048 marcas de 1 bit, que podemos direccionar como: Marcas M 0.0 a M255.7 Byte de marcas MB 0 a MB255 Palabra de marcas MW 0 a MW254 Palabra doble de marcas MD 0 a MD252 3.5. Registros Todas las CPU Simatic S7 disponen de una serie de registros que se emplean durante la ejecución del programa de usuario. No vamos a comentar todos ellos, sólo los que realmente empleemos en la programación: Acumuladores (ACU1 y ACU2) El acumulador 1 (ACU 1) y el acumulador 2 (ACU 2) son dos registros universales de 32 bits que se emplean para procesar bytes, palabras y palabras dobles. En estos acumuladores se pueden cargar constantes o valores depositados en la memoria como operandos y ejecutar operaciones lógicas con ellos. También es posible transferir el resultado en ACU 1 a una dirección (un módulo de datos, una salida, etc.). Cada acumulador puede descomponerse en dos palabras de 16 bits (palabra baja y alta). La palabra baja contiene los bits de menor peso y la alta los de mayor peso lógico.

Página:

11/82

Todas las posibles operaciones que pueden realizarse son:

• Cargar: que siempre actúa sobre ACU 1 y guarda el antiguo contenido en ACU 2 (perdiéndose el valor antiguo de ACU 2). La carga de una palabra actúa sobre la palabra baja del ACU 1. • Transferir: copia el contenido de ACU 1 en una dirección de memoria, sin perder el valor de los acumuladores. • Intercambiar el contenido de los acumuladores. • Comparación, conversión y operaciones aritméticas.

Palabra de estado Es un registro de 16 bits que contiene algunos bits a los que puede accederse en el operando de operaciones lógicas de bits y de palabras. Solo nos serán de utilidad los 9 primeros bits, estando reservados el uso de los 7 últimos. A continuación pasaremos a describir cada bit: • BIT 0 (ER): 0 indica que la siguiente línea se ejecuta como nueva consulta (inhibida). En este estado la consulta se almacena directamente en RLO (ver 4.1). • BIT 1 (RLO): resultado lógico. Aquí se realizan las operaciones a nivel de bit (como AND, OR, etc.). • BIT 2 (STA): bit de estado. Solo sirve en el test de programa. • BIT 3 (OR): se requiere para el proceso Y delante de O. Este bit indica que una operación Y ha dado valor 1, en las restantes operaciones es 0. • BIT 4 (OV): bit de desbordamiento. Se activa (1) por una operación aritmética o de comparación de coma flotante tras producirse un error (desbordamiento, operación no admisible, o relación incorrecta). • BIT 5 (OS): bit de desbordamiento memorizado. Se activa junto con OV e indica que previamente se ha producido un error. Solo puede cambiar a cero con la instrucción SPS, una operación de llamada a módulo, o porque se ha alcanzado el fin del módulo. • BITS 6 (A0) y 7 (A1): códigos de condición. Dan información sobre los resultados o bits siguientes:

- resultado de una operación aritmética. - resultado de una comparación. - resultado de una operación digital. - bits desplazados por una instrucción de desplazamiento o rotación.

• BIT 8 (RB): resultado binario. Permite interpretar el resultado de una operación de palabras como resultado binario e integrarlo en la cadena de combinaciones lógicas binarias.

Página:

12/82

4. SISTEMAS DE NUMERACIÓN El autómata almacena información en forma de condiciones On y Off (1 ó 0), refiriéndose a dígitos binarios (bits). A veces los dígitos binarios se usan individualmente y otras son utilizados para representar valores numéricos. En los autómatas se usan varios sistemas numéricos. Todos los sistemas de números tienen las mismas características: dígitos, base, potencia 4.1. Sistema Decimal El sistema decimal, que es de utilización común en la vida diaria, tiene las características siguientes:

Dígitos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 Base: 10 Potencias: 1, 10, 100, 1000, ...

4.2. Sistema Binario El sistema binario se usa en los controladores programables. Tiene las siguientes características:

Dígitos: 0, 1 Base: 2 Potencias de base 2: 1, 2, 4, 8, 16, ...)

4.3. Hexadecimal El hexadecimal es otro sistema usado en los autómatas programables. El sistema hexadecimal tiene las características siguientes:

Dígitos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F Base: 16 Potencias de base 16 : 1, 16, 256, 4096 ...

Se utilizan los diez dígitos del sistema decimal para los primeros diez dígitos del sistema hexadecimal. Se usan las primeras seis letras del alfabeto para los seis dígitos restantes. A = 10 D = 13 B = 11 E = 14 C = 12 F = 15 El sistema hexadecimal se utiliza en los autómatas programables porque permite representar el estado de un gran número de bits binarios en un pequeño espacio como es la pantalla de un ordenador o un visualizador de programación. Cada dígito hexadecimal representa el estado exacto de 4 bits binarios. 4.4. BCD

El código BCD (Binary-Coded Decimal) son números decimales en los que cada dígito está representado por un número binario de 4 bits. Un contador de vueltas es un ejemplo de un dispositivo de entrada de 4 bits. El BCD se usa comúnmente con dispositivos de entrada y salida. Los números binarios se rompen en grupos de 4 bits, cada grupo representa un decimal equivalente. Un contador de vueltas de 4 dígitos, como el que se muestra abajo, podría controlar 16 (4 x 4) entradas al autómata.

Página:

13/82

4.5. Conversiones

4.6. Ejercicios de aplicación

1. Convierte los siguientes números decimales al sistema hexadecimal y sistema binario: a) 33 b) 342 c) 4321

3. Convierte los siguientes números hexadecimales al sistema decimal y sistema binario: a) 12BE b) AAA c) 3A6B

2. Convierte los siguientes números binarios al sistema decimal y sistema hexadecimal: a) 110110 b) 11110 c) 1011001

Página:

14/82

5. INTRODUCCIÓN A LA PROGRAMACIÓN EN STEP 7 El objetivo es familiarizar al alumno con los autómatas programables de la serie S7- 300 de Siemens, así como con su entorno de programación STEP 7:

• Identificar y conocer el funcionamiento básico de un PLC: ciclo de scan, concepto de entradas y salidas, copia en memoria, etc.

• Programación básica del autómata a través de la herramienta STEP7: programación en listas de instrucciones, en diagramas de contactos y en funciones.

• Depurar errores de comunicación con el autómata. 5.1. Introducción al autómata S7-300

En el aula se va a utilizar el autómata de la familia S7-300 de la firma Siemens.

El autómata base consta de CPU y entradas/salidas digitales/analógicas integradas en el propio autómata. Cada equipo que existe en el aula tiene una configuración distinta y un direccionamiento de entradas y salidas. El alumno deberá identificar los elementos que integran su equipo. 5.2. Crear un proyecto en STEP 7 Para programar el PLC, éste debe estar conectado a uno de los puertos serie del ordenador. En general, se debe conectar al puerto 1 (COM1/2 o USB). Los pasos a seguir para programar el autómata en el STEP 7 son los siguientes:

1. Arrancar el programa STEP7 y crear un proyecto. 2. Editar el programa. 3. Comprobar la comunicación con el PLC. 4. Cargar y ejecutar el programa en el PLC. 5. Depurar el programa

Página:

15/82

1. Arrancar el programa STEP7 y crear un proyecto nuevo Arranque el programa pinchando en el icono Administrador Simatic del escritorio de windows o bien a través del menú de inicio mediante la secuencia Inicio->Programas- >Simatic->STEP7 >Administrador SIMATIC (el camino puede variar – consulte a su profesor). Se pueden seguir las instrucciones del Asistente de STEP 7 para crear nuevos proyectos. Si se utiliza el asistente hay que tener en cuenta que el proyecto se guarda por defecto en la carpeta S7proj. En el caso de no usar el asistente, los pasos a seguir son los siguientes:

1. Archivo->nuevo

2. Insertar equipo

Nombre del proyecto que se va a generar

Ruta de la carpeta donde se quiere guardar el proyecto. En clase cada alumno guardará los proyectos en su carpeta.

Página:

16/82

3. Configurar hardware del equipo insertado:

Insertar los elementos que integran el equipo.

Dirección MPI. Por defecto el software asigna la dirección MPI=2 pero es conveniente asegurarse cuál es la dirección del equipo con el que se va a conectar (Comprobar comunicación con el PLC). Una vez se han editado todos los elementos que integran el equipo se debe Guardar, compilar y cerrar configuración. 2. Editar el programa.

El Slot 3 se debe dejar libre

Entrar en Hardware. Simatic 300-> Bastidor-> Perfil Soporte

Página:

17/82

Abrir programa:

Doble click en el bloque principal. Si no apareciese OB1 navegue por la ventana de proyecto mediante el ratón hasta visualizarlo. La secuencia a seguir es Equipo SIMATIC 300->CPU314- >Programas S7->Bloques.

Elegir el lenguaje de programación que se va a utilizar.

Página:

18/82

3. Comprobar la comunicación con el PLC. Encienda el autómata. Para ello hay 2 interruptores: uno en la fuente de alimentación del autómata y otro en la trasera del bastidor. Espere a que se enciendan los leds de estado de la CPU del autómata

Compruebe la conexión con el autómata. Para comprobar que el autómata está correctamente conectado al ordenador pulse el botón de comunicaciones. Se debe respetar la dirección MPI que tenga cada CPU del aula.

Página:

19/82

Ir a configuración de Hardware y cambiar la dirección MPI de la CPU del proyecto:

En caso de no aparecer ningún autómata en la ventana o de aparecer una ventana de error de comunicaciones compruebe que el autómata está encendido y que el cable serie está conectado al puerto COM1. Configurar del puerto de comunicación Para configurar la comunicación lo haremos desde el Administrador siguiendo los pasos: Herramientas�Ajustar interface PG/PC

Página:

20/82

Si sale uno de los puertos COM marcado con un asterisco significa que este puerto está ocupado, en este caso tendremos que seleccionar otro puerto para conectar el PLC.

4. Cargar y ejecutar el programa en el PLC. Pinche en el icono Cargar de la barra de herramientas (símbolo de PLC - flecha hacia abajo) para cargar el programa en el PLC. También se puede utilizar Sistema de destino->Cargar. 5. Depurar el programa en diagrama de contactos Una vez cargado el programa se puede depurar en la propia ventana de programación. Para ello seleccione Test->Observar. Sobre la ventana de programación se indica el estado de las entradas, el resultado de las ecuaciones lógicas parciales y el resultado de la salida.

Seleccionamos el puerto en el que se ha conectado el adaptador

Página:

21/82

Cambio de la ruta donde guardar los proyectos Si queremos guardar nuestros proyectos en un lugar diferente, desde el Administrador seguiremos los pasos siguientes: Herramientas ��Preferencias ��Examinar y seleccionaremos la ruta que queramos, pero eligiendo la misma ruta para: Ruta de proyectos y Ruta de librerías.

5.3. Ejercicio de aplicación 1. Crea 3 proyectos y cierra el Administrador SIMATIC cada vez. Selecciona las CPU’s y asigna los nombres a los 3 proyectos según la tabla siguiente:

CPU Nombre

313C ejer1a

314 ejer1b

314C-2DP ejer1c

2. Abre los 3 proyectos creados sin crear de nuevo.

3. Cierra el Administrador SIMATIC y desde Mi PC mira como se guardan los proyectos; qué carpetas y archivos se generan. Prueba de arrancar el Administrador SIMATIC desde algún archivo de la carpeta. Anota el nombre con la ruta completa del proyecto ejer1a. 4. Desde el Administrador abre el proyecto ejer1a y mediante la opción Guardar como cámbiale el nombre por ejer1d. Anota el nombre con la ruta completa del proyecto guardado como ejer1d. 5. Mira desde Mi PC y desde el Administrador, las carpetas y archivos de los proyectos creados y anota las diferencias que observes en la cantidad de carpetas y archivos.

6. Desde Mi PC renombra la carpeta del proyecto ejer1b por ejer1e. Desde el Administrador abre el proyecto renombrado y anota la ruta completa del proyecto.

Página:

22/82

5.4. Introducción al PLCSim Activación del simulador A continuación procedemos a abrir el simulador del S7. Con él podremos probar el circuito de la misma forma que si el autómata estuviera conectado al ordenador

Opciones básicas del simulador PLCSIM

Con la casilla RUN activada, no se puede transferir el programa ni forzar elementos. Con la casilla RUN-P activada, si se puede transferir el programa y forzar elementos. Para poder probar los circuitos que programamos en el S7, insertaremos una tarjeta de entradas. Las tarjetas de salidas las pondremos si queremos visualizar en el simulador su funcionamiento. Normalmente seleccionaremos ciclo continuo. El ciclo único, solo lo seleccionaremos para analizar cómo evoluciona en cada ciclo de scan el funcionamiento de algún ejercicio concreto.

Página:

23/82

Ejemplo • Nombre del proyecto: ejer2 • Tipo de CPU: 314C-2DP • La salida A124.0 ha de funcionar cuando estén accionadas al mismo tiempo las entradas E124.0, E124.1 y E124.2. • La salida A124.1 ha de funcionar cuando estén accionadas una cualquiera de las entradas E124.0, E124.1 y E124.2.

1. Configuración simulador PLCSIM • Desde el Administrador SIMATIC, creamos el proyecto ejer1 y abrimos el simulador. • Como tenemos que trabajar con las entradas E124.0, E124.1 y E124.2 insertamos un módulo de entradas que por

defecto será el EB0 y que vamos a renombrar como EB124 • Como tenemos que trabajar con las salidas A124.0 y A124.1 insertamos un módulo de salidas que por defecto será el

AB0 y que vamos a renombrar como AB124

Página:

24/82

2. Edición del programa. Desde el Administrador clicamos dos veces sobre OB1 y procedemos a editarlo

3. Transferencia de los módulos al autómata o al simulador (el PLC no puede estar en RUN) Se puede hacer de dos maneras:

• Directamente desde el administrador. Es imprescindible que antes se hayan guardado los módulos en el editor AWL/KOP/FUP.

Página:

25/82

• Desde el editor AWL/KOP/FUP. Enviará lo que haya en el editor, esté guardado o no.

4. Visualización del programa en online (el PLC debe estar en RUN) Desde el Editor AWL/KOP/FUP

RECUERDA CARGAR A LA CPU TODOS LOS BLOQUES Y FUNCIONES QUE HAYAS CREADO!!!!!!

Posibles anomalías: • Si el programa que hay en el autómata es diferente al que hay en el editor, las “gafas” aparecerán desactivadas. • Si las “gafas” se activan pero no se ve el estado del circuito, clicaremos con el botón izquierdo del ratón encima del nombre del segmento que queremos visualizar o encima del segmento 1 si es que queremos visualizar todo el programa, ya que solo se visualiza el circuito a partir del segmento marcado. • Si todavía no se visualiza el estado del programa, comprobar si en la parte inferior izquierda sale el mensaje “Las instrucciones no se ejecutan”. Si es así, quiere decir que el módulo no se ha llamado desde el OB1.

Página:

26/82

Resolución de problemas

Visualizar los símbolos en el PLCSim Para visualizar los símbolos en el simulador es necesario insertar “bit vertical”.

Página:

27/82

Una vez que se han insertado todas las variables ir a Herramientas-> Opciones -> Asignar símbolos

Abrir la tabla de símbolos del proyecto que se quiera simular

Gestionar ficheros del simulador Para guardar una simulación hay que guardar dos ficheros: Guardar plc: *.plc Guardar organización:*.lay

Cuando se quiera abrir la simulación es necesario abrir los dos ficheros.

Página:

28/82

6. PROGRAMACIÓN BÁSICA Dependiendo del tipo de operando que empleemos, se hará uso de uno o varios de los siguientes registros:

• Bit de resultado lógico (RLO): aquí se almacena el resultado de operaciones lógicas a nivel de bit y primera consulta.

• Acumuladores (ACU 1 y ACU 2): aquí se almacenan los operandos y resultados de operaciones lógicas a nivel de byte, palabra, y doble palabra.

6.1. Primera consulta Cuando efectuamos una asignación, o se comienza un nuevo ciclo de programa, se está en estado de primera consulta. Es decir, la primera instrucción lógica que se efectúe servirá para situar su operando en el RLO. Las operaciones S y R también producen que el bit de primera consulta se ponga a 0. Da igual si se trata de una operación AND, OR, o XOR, en los tres casos se introduce el operando en el RLO de forma directa. Si tratamos con instrucciones NAND, NOR, o XOR se introducirá el operando de forma negada (si es un 0 el bit RLO será 1). 6.2. Consulta de entradas. Contactos na. y nc. Eléctricamente:

Contacto normalmente abierto Contacto normalmente cerrado El autómata consulta el valor de sus entradas, es decir, si existe tensión (“1”) o no existe tensión (“0”). Sin tener en cuenta si el contacto asociado a la entrada es cerrado o abierto...

Página:

29/82

Para la elaboración del programa sí que debemos conocer las funciones técnicas del “contacto”:

• Si en una entrada hay conectado un contacto abierto, se aplicará el estado de señal “1” en la entrada cuando se accione el contacto.

• Si a la entrada nos encontramos con un contacto cerrado, se aplicará el estado de señal “0” en la entrada cuando se accione el contacto.

El autómata no tiene posibilidad de determinar si en una entrada hay conectado un contacto cerrado o abierto. Solo puede consultar o reconocer los estados de señal “1” ó “0”. Nos es indiferente si un estado se ha alcanzado a través de un contacto abierto o cerrado. Lo único importante es la elección del tipo de contactos, sobre todo teniendo en cuenta las normativas de seguridad... Cuando efectuamos una asignación, o se comienza un nuevo ciclo de programa, se está en estado de primera consulta. Es decir, la primera instrucción lógica que se efectúe servirá para situar su operando en el RLO. IMPORTANTE: Un contacto negado, NO significa contacto cerrado, sino LO CONTRARIO DE (“0” lógico). El elemento de referencia de una entrada, es la entrada física. 6.3. Asignación Instrucción “=” ---( ) Bobina de relé, salida Se copia el contenido del RLO al operando especificado, sin perder el contenido del RLO.

AWL

Página:

30/82

6.4. Función AND (Y) Eléctricamente la salida de la función AND sólo adopta el estado 1 si todas las entradas tienen el estado 1, es decir, si están cerradas.

En programación, la salida de la función AND sólo adopta el estado 1 si todas las condiciones son verdaderas, es decir, si el RLO está a “1”.

KOP AWL: Instrucción "U" “UN”

Realiza la función lógica AND entre el RLO y el operando especificado, almacenando el resultado en RLO (se pierde el valor anterior). Se puede operar con el negado del operando si se adjunta "N" (UN). ej. U E 0.0 //realiza un AND entre el RLO y la entrada E 0.0 ej. UN A 1.2 //realiza un AND entre el RLO y la salida A 1.2 negada

AWL

Si la entrada E124.0 está a “0” y la entrada E124.2 está a “1”, la salida A124.0 se activará.

Si la entrada E124.0 =“1” y la entrada E124.1=“1” y la E124.2 = “1”, la salida A124.0 se activará.

Página:

31/82

6.5. Función OR (O)

Eléctricamente, la salida de la función OR adopta el estado 1 si por lo menos una entrada tiene el estado 1.

En programación, la salida de la función OR adopta el estado 1 si al menos una de las condiciones es verdadera, es decir, si el RLO está a “1”. KOP: AWL: Instrucción “O”/”ON”

6.6. Y antes de O

Instrucción "O" sin operando Si introducimos una instrucción "O" sin operando seguida de una o varias instrucciones AND se evalúa en primer lugar las instrucciones AND y el resultado se combina con el RLO según un OR. Esta operación equivale a emplear "O(" con instrucciones del tipo AND dentro del paréntesis. Ejemplo: U E 0.0 //se introduce en el RLO el valor de la entrada 0.0 (primera c.) O //comenzamos una operación Y antes de O U E 0.1 //introducimos el valor de la entrada 0.1 en el RLO (primera c.) U M 0.3 //efectuamos un AND entre el RLO y la marca 0.3 = A 4.0 //se finaliza Y antes de O. Se efectúa un OR entre el primer RLO del RLO resultado de las operaciones AND. Luego se copia el contenido del RLO en la salida 4.0

AWL

Si la entrada E124.0 =“1” ò la entrada E124.1=“1” la salida A124.1 se activará.

Si la entrada E124.0 =“1” ò la entrada E124.1=“0” la salida A124.1 se activará.

Página:

32/82

6.7. Función XOR (O exclusiva) Eléctricamente, la salida de la función XOR (O-exclusiva) adopta el estado 1 si las entradas tienen diferentes estados.

En programación, la salida de la función XOR adopta el estado 1 si las condiciones son distintas, es decir, si el RLO es distinto a “1”. KOP: AWL: Instrucción “X” / “XN”

E124.0 E124.1 A124.1

E124.1 E124.0

Realiza la función lógica XOR entre el RLO y el operando especificado, almacenando el resultado en RLO (se pierde el valor anterior). Se puede operar con el negado del operando si se adjunta "N" (XN). 6.8. Expresiones entre paréntesis Instrucciones "U (", "UN(", "O(", "ON(", "X(", "XN(", ")" sin operandos. (SÓLO AWL). Las operaciones U, O, X, y sus negaciones UN, ON, y XN permiten ejecutar operaciones lógicas con fracciones de una cadena lógica encerradas entre paréntesis (expresiones entre paréntesis). Los paréntesis que encierran una fracción de una cadena lógica indican que el programa va a ejecutar las operaciones entre paréntesis antes de ejecutar la operación lógica que precede a la expresión entre paréntesis. La operación que abre una expresión entre paréntesis almacena el RLO de la operación precedente en la pila de paréntesis. A continuación, el programa combina el RLO almacenado con el resultado de las combinaciones lógicas ejecutadas dentro del paréntesis (siendo la primera operación dentro de los paréntesis de primera consulta). El número máximo de paréntesis anidados que se permiten es 8. Tabla de verdad Ejemplo: U ( O E 0.0 U E 0.1 ) = A 2.0

La salida A124.1 se activará si una de las entradas está a “1” pero, exclusivamente, una de ellas.

AWL

Un programa equivalente sería (en este caso): O E 0.0 //copiamos la E 0.0 en el RLO (primera c.) U E 0.1 //efectuamos un AND entre el RLO y la E 0.1 = A 2.0 //copiamos el resultado a la salida 2.0

Página:

33/82

6.9. Ejercicios propuestos: Ejercicio 1

Indica el valor de las salidas A124.3 a la A124.7 según sea el valor de A124.0 y A124.1 A124.0 A124.1 A124.3 A124.4 A124.5 A124.6 A124.7

0 0 1 0 0 1 1 1

Ejercicio 2 Programar el encendido y apagado de una bombilla controlado por 3 interruptores. La bombilla se enciende cuando al menos 2 de los 3 interruptores están pulsados.

a) Definir entradas y salidas b) Crear un proyecto nuevo con el Step7 c) Realizar el programa de usuario d) Probar en la instalación montada en el aula.

E124.0 A124.0

E124.1 A124.1

A124.0 A124.1 A124.3

A124.0 A124.4

A124.1

A124.0 A124.1 A124.5

A124.0 A124.1 A124.6

A124.0 A124.1 A124.7

CONVIERTE A AWL:

Página:

34/82

Ejercicio 3 Programar el encendido y apagado de una bombilla desde dos interruptores diferentes (acción conmutada)

a) Definir entradas y salidas b) Crear un proyecto nuevo con el Step7 c) Realizar el programa de usuario d) Probar en la instalación montada en el aula.

Ejercicio 4

La marcha-parada de una cinta transportadora se comanda mediante dos cajas de botoneras, una local y otra remota (Cada botonera tiene un pulsador de marcha NA y un pulsador de parada NC). La cinta también puede detenerse por la acción de un fin de carrera de seguridad.

6.10. Set y Reset Eléctricamente, la función Set-Reset equivale a una función marcha-paro:

Instrucciones "S" y "R" ---( S ) Activar salida ---( R ) Desactivar salida La operación set (S) fuerza a uno el operando especificado si el RLO es 1. La operación reset (R) fuerza a cero el operando especificado si el RLO es 1. En ambos casos el bit de primera consulta se hace 0.

Página:

35/82

Ejemplo: U E 1.0 //copiamos al RLO el valor de la entrada 1.0 (primera c.) S A 4.0 //si RLO=1 se fuerza la salida 4.0 a 1 U E 1.1 //copiamos al RLO el valor de la entrada 1.1 (primera c.) R A 4.0 //si RLO=1 se fuerza la salida 4.0 a En este ejemplo tiene preferencia el reset sobre el set, ya que esta última instrucción se ejecuta al después, es decir si E1.0 y E1.1 fuesen 1 la salida A4.0 sería 0. KOP Parámetro Tipo de datos Área de memoria Descripción

S BOOL E, A, M, L, D Activación habilitada R BOOL E, A, M, L, D Desactivación habilitada Q BOOL E, A, M, L,D Estado de señal operando

Parámetro Tipo de datos Área de memoria Descripción S BOOL E, A, M, L, D Activación habilitada R BOOL E, A, M, L, D Desactivación habilitada Q BOOL E, A, M, L, D Estado de señal operando

Ejemplo:

En este ejemplo tiene preferencia el reset sobre el set, ya que esta última instrucción se ejecuta al después, es decir si E1.0 y E1.1 fuesen 1 la salida A4.0 sería 0.

RS R Q S

SR S Q R

Si el estado en la entrada E 0.0 es "1" y en la entrada E 0.1 es el estado es "0", se activa la marca M 0.0, y la salida A 4.0 es "1". De no ser así, cuando el estado de señal en la entrada E 0.0 es 0 y en E 0.1 es 1, se desactiva la marca M 0.0 y la salida A 4.0 es "0". Si ambos estados de señal son "0", no cambia nada. Si ambos estados de señal son "1", domina la operación Desactivar debido al orden en que están dispuestas las operaciones. M 0.0 se desactiva y la salida A 4.0 es "0".

Página:

36/82

6.11. Ejercicios propuestos 1. Control de un taladro vertical

2. Control de una bomba de agua Disponemos de un depósito de agua. Para manejarlo tenemos un selector de mando con el cual seleccionaremos el modo de funcionamiento de la bomba de agua seleccionar modo manual o modo automático. En modo manual, lo que queremos es que mientras esté conectada, la bomba esté funcionando, y cuando desconectemos que se pare la bomba. No queremos que se haga caso a los detectores de nivel. En modo automático queremos que el nivel se mantenga entre las dos boyas. Cuando el agua llegue al nivel de abajo queremos que se ponga en marcha la bomba, y cuando el agua llegue al nivel de arriba queremos que se pare la bomba. Además se tiene un relé térmico que actúa tanto en funcionamiento manual como en automático. Cuando salta el relé, queremos que se pare la bomba y que nos avise con un indicador luminoso en el cuadro de mando.

Página:

37/82

6.12. Operaciones de flancos

Instrucciones "FP" y "FN"

Las operaciones de flanco positivo (FP) y flanco negativo (FN) pueden utilizarse para detectar cambios de flanco en el RLO. El cambio de 0 a 1 se denomina flanco positivo, mientras que el cambio de 1 a 0 se denomina flanco negativo. Cada instrucción FP o FN emplea un operando para poder comparar el RLO actual con el que había en el ciclo anterior, se recomienda emplear marcas de memoria. Si se realiza un cambio de flanco en el sentido de la instrucción empleada, ésta produce un impulso positivo (1) en el RLO durante el ciclo actual. Ejemplo: U E 124.0 //empleamos la entrada 124.0 para detectar un cambio de flanco FP M 0.0 //empleamos la marca 0.0 para detectar el cambio de flanco = A 124.0 //asignamos el resultado de la operación FP a la salida 1244.0

Ejemplo:

ATENCION: Es obligatorio no emplear los operandos ocupados por FP y FN (marcas de memoria) para otros fines, ya que entonces se falsifica el RLO almacenado en ellos y por lo tanto se produce un funcionamiento incorrecto del programa.

Página:

38/82

6.13. Marcas Remanentes Las salidas son elementos sin memoria, que trabajan a nivel interno y además dan una señal al exterior. Las marcas solamente trabajan a nivel interno. Las hay remanentes y no remanentes. Que una marca sea remanente, es decir que tenga memoria, significa que después de un corte de tensión, esta marca recuerda el estado que tenía antes del corte y lo mantendrá. Marcas remanentes (con memoria) por defecto: MB0 MB15 Marcas NO remanentes (sin memoria) por defecto: MB16 MB255 Para modificar el margen de las marcas establecido por defecto se han de seguir los siguientes pasos en Step7: Administrador Equipo Simatic 300 doble clic en Hardware.

En la ventana HW Config, clicar dos veces sobre la CPU Seleccionar la pestaña Remanencia Colocar el número de Bytes de marcas que queremos que tengan memoria a partir del MB0 Guardar y compilar y Cargar al autómata.

Página:

39/82

6.14. Marca de ciclo Una marca de ciclo es una marca que cambia periódicamente de valor binario. MB.b

Se define en las propiedades de la CPU: HW Config � CPU � Pestaña “Ciclo/Marca de ciclo”

Para crear una marca de ciclo: 1. Introducir la dirección del byte de marcas. 2. Activar la casilla de verificación � 3. “Guardar y compilar” y “Cargar en módulo” Cada bit del byte de marca de ciclo lleva asignada una duración de periodo / frecuencia en seg:

Ejemplo: U M100.3 //Si defino la marca 100 como marca de ciclo = A4.0 //el led parpadeará con una frecuencia de 0,5 seg. Ejercicio: Marca de ciclo Mediante interruptores realizar:

Página:

40/82

6.15. Negar, activar, desactivar y salvar el RLO Instrucciones "NOT", "SET", "CLR" y "SAVE" sin operando NOT Niega (invierte) el RLO actual al no haberse activado el bit OR. Registros afectados: RLO se invierte, STA=1 SET Fuerza el RLO de forma incondicional a 1. Registros afectados: RLO=1, STA=1, ER=0, OR=0 CLR Fuerza el RLO de forma incondicional a 0. Registros afectados: RLO=0, STA=0, ER=0, OR=0 SAVE Almacena el RLO en el registro de estado (en el bit RB). El RLO almacenado puede ser consultado de nuevo con la instrucción "U BR". Registros afectados: RB almacena el valor de RLO.

Página:

41/82

7. OPERACIONES DE CARGA Y TRANSFERENCIA ACU1 y ACU2 son dos registros de 32 bits para el procesamiento de bytes, palabras y doble palabras. Permiten programar un intercambio de información entre módulos de E/S y áreas de memoria.

• Imagen de proceso de entradas y salidas • Marcas • Temporizadores y contadores • Áreas de datos

Las instrucciones de carga y transferencia transfieren datos a ó desde el ACU1. Son operaciones incondicionales, o sea, independientes del RLO Ejemplo: U E1.0 L 2 //Carga el número 2 en ACU1 independientemente del estado de E1.0 7.1. Operación de carga

Instrucción "L" Carga en ACU1 constantes y valores de los operadores. Ejemplo: L 3 //Carga el número entero 3 (16 bits) en el ACU1 L EB0 //Carga el byte de entradas 0 en ACU1 L MB20 //Carga el byte de marcas 20 en ACU1

Los bytes no aprovechados se ponen a cero. La información que hubiese en ACU1 se desplaza a ACU2. Y lo que hubiese en ACU2 se pierde. Ejemplo: L 3 //ACU1=3 L 2 //ACU1=2; ACU2=3 L 5 //ACU1=5; ACU2=2 se pierde

Página:

42/82

7.2. Operación de transferencia

Instrucción "T" Transfiere el contenido de ACU1 a una dirección de operando. La transferencia no cambia el contenido de los acumuladores. Transferimos únicamente desde ACU1. Ejemplo: T AB10 //Transfiere el byte más bajo del ACU1 al byte de salida 0. T MW4 //Transfiero el contenido de la palabra baja de ACU1 a la palabra de marcas MW14 Los acumuladores sirven para ejecutar operaciones lógicas entre ACU1 y ACU2 (comparación, aritméticas, AND, OR...). El resultado siempre se almacena en ACU1, sobrescribiendo lo que hubiese en ACU1 pero el contenido de ACU2 permanece intacto. Ejemplo: L 8 //ACU1=8 L 2 //ACU1=2; ACU2=8 -I //ACU2-ACU1 � ACU1=6; ACU2=8 T MW10 //Transfiero el resultado de la resta a MW10 En cada ciclo de programa ACU1 y ACU2 se ponen a cero. KOP: Parámetro Tipo de datos Área de memoria Descripción EN BOOL E, A, M, L, D Entrada de habilitación ENO BOOL E, A, M, L, D Salida de habilitación IN Todos los tipos de E, A, M, L, D Valor de fuente OUT datos con una longitud E, A, M, L, D Dirección de destino de 8, 16 o 32 bits Descripción de la operación MOVE (Asignar un valor) es activada por la entrada de habilitación EN. El valor indicado por la entrada IN se copia en la dirección que la salida OUT. La salida de habilitación ENO tiene el mismo estado de señal que la entrada de habilitación EN.

MOVE EN ENO IN OUT

Página:

43/82

8. OPERACIONES DE CONTAJE 8.1. Operaciones con contadores Los contadores permiten distintas operaciones, que debemos emplear en su manejo:

• Cargar un valor de contaje (preselección). • Borrar el contaje. • Contar hacia adelante y hacia atrás. • Consultar su estado como un operando más en operaciones lógicas de bit. • Consultar su valor en ACU 1.

Todas estas operaciones serán explicadas con profundidad en los siguientes puntos. Cargar un valor de contaje

Instrucciones: "L C#" y "S Z" Un contador se pone a un determinado valor cargando dicho valor en la palabra baja del ACU 1, mediante una operación de carga, y luego en el contador, mediante una instrucción Set. "L C#" introduce un valor de contaje en la palabra baja del ACU 1. El valor de contaje puede ser un valor comprendido entre 0 y 999. "S Z" introduce el valor de contaje en ACU 1 en el contador si RLO vale 1. Ejemplo: L C#3 //introduce el valor de contaje 3 en el ACU 1 U E 1.0 //carga en el RLO el valor de la entrada 1.0 S Z 1 //introduce el valor 3 (dentro de ACU 1) en el contador 1 si la entrada E1.0 es 1 Borrar un contador

Instrucción: "R Z" Borra el contador especificado (puesta a cero) si el RLO vale 1. Ejemplo: U E 1.0 //carga en el RLO el valor de la entrada 1.0 R Z 1 //borra el contador 1 (a cero) si la entrada 1.0 es 1 (RLO=1) Contaje hacia adelante y hacia atrás

Instrucciones: "ZV" y "ZR" "ZV" incrementa el contador especificado si hay un cambio de flanco ascendente (0 a 1) en el RLO. El incremento se produce en una unidad. Cuando el contador alcanza el límite superior de 999, se detiene y no sigue incrementando. "ZR" decrementa el contador especificado si hay un cambio de flanco ascendente (0 a 1) en el RLO. El decremento se produce en una unidad. Cuando el contador alcanza el límite inferior de 0, se detiene y no sigue decrementando.

Página:

44/82

Ejemplos: U E 0.0 //carga en el RLO el valor de la entrada 0.0 ZV Z 1 //incrementa el contador 1 si la entrada 0.0 presenta un cambio de flanco ascendente U E 1.0 //carga en el RLO el valor de la entrada 1.0 ZR Z 1 //decrementa el contador 1 si la entrada 1.0 presenta un cambio de flanco ascendente Consulta del estado de contadores El programa puede consultar el estado de un contador de la misma manera que consulta el estado de señal de una entrada o salida, pudiendo combinar el resultado de la consulta. Cuando se consulta el estado del contador con las operaciones U, O, o X el resultado es 1 si el valor de contaje es mayor que 0. Ejemplo: L C#5 //introduce el valor de contaje 5 en el ACU 1 U E 2.0 //carga en el RLO el valor de la entrada 2.0 S Z 1 //introduce el valor 5 (dentro de ACU 1) en el contador 1 si la entrada 2.0 es 1 U E 1.0 //carga en el RLO el valor de la entrada 1.0 ZR Z 1 //decrementa el contador 1 si la entrada 1.0 presenta un cambio de flanco ascendente U Z 1 //introduce en el RLO el estado del contador 1 = A 0.0 //introduce el estado del contador 1 en la salida 0.0 Lectura de un valor de contaje

Instrucciones: "L Z" y "LC Z" Con la instrucción "L Z" introducimos en el ACU 1 (parte baja) el valor del contador especificado en binario. El valor en ACU 1 puede ser introducido en otro contador. Con la instrucción "LC Z" introducimos en el ACU 1 (parte baja) el valor del contador especificado en BCD. En esta codificación no es posible pasar el valor de ACU 1 a otro contador. Ejemplos: L Z 1 //introduce el valor del contador 1 en el ACU 1 LC Z 2 //introduce el valor del contador 2 en el ACU 1 en BCD

Página:

45/82

KOP: Los elementos con los cuales se puede trabajar con un contador son los siguientes: • ZV Incrementar. Contaje hacia arriba • ZR Decrementar. Contaje hacia abajo • SZ Carga del valor de preselección • ZW Valor de preselección, el valor máximo 999 y en formato BCD • R Puesta a cero del valor del contador • Q Conexión de la salida • DUAL Carga el valor del contador en binario • DEZ Carga el valor del contador en BCD IMPORTANTE: En la salida Q tendremos un 1 siempre que el valor del contador sea superior a 0. Ejercicio: Copia este ejemplo y analízalo.

Z0 E124.0 ZAEHLER A124.0

ZV Q E124.1

ZR E124.2

S C#10 ZW DUAL

E124.3

R DEZ

ZAEHLER ZV Q ZR S DUAL ZW DEZ R

Z Nº

CONVIERTE A AWL:

Página:

46/82

8.2. Ejercicios propuestos Cinta transportadora Se pretende controlar una cinta transportadora sobre la cual el trabajador irá colocando cajas. Se parte de un estado inicial en el que el contador de cajas se encuentra a 0. En el instante en el que se detecte que el número de cajas que han pasado por el detector DL alcanza el valor de 15, se encenderá la luz de “LÍMITE” al mismo tiempo que parará la cinta transportadora. Para reiniciar el proceso, el trabajador deberá inicializar el contador. Para que la cinta pueda entrar en funcionamiento, deberá estar el sistema disponible. La no disponibilidad del sistema no implica el reseteo del contador.

Sistema Sistema disponible no disponible

Pulsador Rearme Luz Límite Luz Defecto Térmico

Página:

47/82

9. OPERACIONES DE TEMPORIZACIÓN 9.1. Operaciones con temporizadores Los temporizadores permiten distintas operaciones, que debemos emplear en su manejo:

• Funcionamiento en un modo determinado. • Borrar la temporización. • Re-arrancar un temporizador (FR). • Consultar su estado como un operando más en operaciones lógicas de bit. • Consultar su valor en ACU 1.

Cargar un valor de temporización El valor de temporización se debe cargar en la parte baja del ACU 1, para desde allí transferirlo al temporizador mediante el set que determine el modo de temporización adecuado. El tiempo va decrementando hasta ser igual a 0. El valor de temporización puede cargarse en la palabra baja del ACU 1 en formato binario, hexadecimal o BCD. Para ello debemos elegir una base de tiempos y un valor dentro de dicha base, con lo que podemos realizar temporizaciones desde 0 a 9990 segundos (0H_00M_00S_00MS a 2H_46M_30S_00MS). La carga de un valor de temporización se puede hacer con dos sintaxis distintas (BCD o S5Time):

• L W#16#abcd

a = base de tiempos bcd = valor de temporización en formato BCD Base de tiempos y código respectivo: 10 ms 0 100 ms 1 1 s 2 10 s 3 Ejemplo: L W #16 # 2010 //esto introduce un valor de 10 segundos en ACU 1

(2 base de 1s, 10 los segundos que deseamos)

• L S5T#aH_bbM_ccS_ddMS a = horas, bb= minutos, cc = segundos, dd = milisegundos En este caso la base de tiempos se selecciona de forma automática, tomándose la de valor más bajo posible. Debido a esto los valores de resolución demasiado alta se redondean por defecto, alcanzando el rango pero no la resolución deseada. El formato general para el tipo de datos S5TIME tiene los siguientes valores límite para el margen y la resolución:

Configuración binaria en la palabra de temporización:

Página:

48/82

Ejemplo: L S5T#00H02M23S00MS //esto introduce un valor de temporización de 2 minutos y 23 segundos en el ACU 1 Borrar una temporización Instrucción: "R T" Esta instrucción borra (resetea) el temporizador indicado. El temporizador vuelve al estado de reposo, es decir parado y con la salida igual a 0. Ejemplo: U E 0.0 //Empleamos la entrada 0.0 como entrada del temporizador L S5T#2s //Introducimos un valor de temporización de 2 segundos SS T 2 //Empleamos el temporizador 2 como retardo a la c. con memoria U E 0.1 //Empleamos la entrada 0.1 como entrada de borrado R T 2 //Si la entrada 0.1 cambia de 0 a 1 el temporizador 2 se borra U T 2 //Leemos la salida del temporizador = A 3.1 //Asignamos la salida del temporizador a la salida 3.1 Re-arranque de un temporizador Instrucción: "FR T" (sólo AWL) Cuando el RLO cambia de 0 a 1 (flanco de subida) delante de una operación FR se habilita el temporizador. Este cambio del estado de señal siempre es necesario para habilitar un temporizador. Para arrancar un temporizador y ejecutar una operación normal de temporizador no hace falta habilitarlo. Esta función se emplea únicamente para redisparar un temporizador que está en marcha, es decir, para rearrancarlo. Este rearranque sólo puede efectuarse cuando la operación de arranque continúa procesándose con un RLO de 1. Ejemplo: U E 2.0 //Empleamos la entrada 2.0 como re-arranque FR T 1 //Re-arrancamos el temporizador 1 si la E 2.0 pasa a 1 U E 2.1 //Empleamos la entrada 2.1 como entrada del temporizador L S5T#5s //Introducimos un valor de temporización de 5 segundos SI T 1 //Empleamos el temporizador 1 como impulso U T 1 //Leemos la salida del temporizador = A 4.0 //Copiamos la salida del temporizador a la salida 4.0 Si el RLO cambia de 0 a 1 en la entrada de re-arranque mientras está en marcha el temporizador, el temporizador vuelve a arrancar. El tiempo programado se emplea como tiempo actual para el re-arranque. Un cambio del RLO de 1 a 0 en la entrada de re-arranque no produce ningún efecto. Un cambio del RLO de 0 a 1 en la entrada de habilitación no afecta al temporizador si todavíahay un RLO 0 en la entrada del temporizador.

Página:

49/82

Lectura de un valor de temporización Instrucciones: "L T" y "LC T" Con la instrucción "L T" introducimos en el ACU 1 (parte baja) el valor del temporizador especificado en binario. El valor en ACU 1 puede ser introducido en otro temporizador. Con la instrucción "LC T" introducimos en el ACU 1 (parte baja) el valor del temporizador especificado en BCD. En esta codificación no es posible pasar el valor de ACU 1 a otro temporizador. Ejemplos: L T 1 //introduce el valor del temporizador 1 en el ACU 1 LC T 2 //introduce el valor del temporizador 2 en el ACU 1 en BCD

Página:

50/82

9.2. Temporizador como impulso (SI)

Instrucción: "SI" Si el RLO (al ejecutar esta instrucción) cambia de 0 a 1, el temporizador arranca. El temporizador marcha con el valor de tiempo indicado en ACU1. Si el RLO cambia de 1 a 0 antes de terminar el tiempo, el temporizador se detiene. La salida del temporizador entrega 1 mientras el temporizador corre. Ejemplo: U E 0.0 //Empleamos la entrada 0.0 como entrada del temporizador L S5T#45s //Introducimos un valor de temporización de 45 segundos SI T 2 //Empleamos el temporizador 2 como impulso U T 2 //Leemos la salida del temporizador = A 0.1 //Asignamos la salida del temporizador a la salida 0.1 KOP:

Diagrama de temporización:

Ejemplo

S BOOL Entrada de arranque TW S5TIME Valor de temporización predeterminado R BOOL Entrada de desactivación DUAL DUAL Valor de temporización actual, codificado en binario DEZ WORD Tiempo restante, formato BCD Q BOOL Estado del temporizador

Si el estado de señal de la entrada E 0.0 cambia de "0" a "1" (flanco creciente en el RLO), se activa el temporizador T5. El temporizador continúa en marcha con el valor de temporización indicado de 2 segundos (2 s) mientras la entrada E 0.0 sea 1. Si el estado de señal de la entrada E 0.0 cambia de "1" a "0" antes de transcurrir el tiempo, el temporizador se para. La salida A 4.0 es "1" mientras esté en marcha el temporizador, y "0" si el tiempo ha transcurrido o si el temporizador fue puesto a 0.

Página:

51/82

9.3. Temporizador como impulso prolongado (SV)

Instrucción: "SV" Si el RLO (al ejecutar esta instrucción) cambia de 0 a 1, el temporizador arranca y continua en marcha incluso si el RLO cambia a 0 antes de que el temporizador termine. Mientras el tiempo está corriendo, la salida vale 1. Ejemplo: U E 0.2 //Empleamos la entrada 0.2 como entrada del temporizador L S5T#85s //Introducimos un valor de temporización de 85 segundos SV T 9 //Empleamos el temporizador 9 como impulso prolongado U T 9 //Leemos la salida del temporizador = A 9.1 //Asignamos la salida del temporizador a la salida 9.1 KOP:


Ejemplo:


Si el estado de señal de la entrada E 0.0 cambia de "0" a "1" (flanco creciente en el RLO), se activa el temporizador T5. El temporizador continúa en marcha con el valor de temporización indicado de dos segundos sin ser afectado por un flanco decreciente en la entrada S. Si el estado de señal de la entrada E 0.0 cambia de "0" a "1" antes de transcurrir el tiempo, el temporizador vuelve a arrancar. Si el estado de señal de la entrada E 0.1 cambia de "0" a "1" mientras el temporizador está en marcha, éste se pone a 0. La salida A 4.0 es "1" mientras esté en marcha el temporizador.

Página:

52/82

9.4. Temporizador como retardo a la conexión (SE) Instrucción: "SE" El temporizador arranca cuando hay un flanco creciente en el RLO (al ejecutar esta instrucción). El temporizador continúa en marcha con el valor de temporización indicado en el ACU 1 mientras sea positivo el estado de señal en la entrada (el RLO). El estado de la salida es 1 si el tiempo ha transcurrido sin errores y si el estado de la entrada (RLO) es 1. Si la entrada cambia de 1 a 0 mientras está en marcha el temporizador, éste cambia el estado de la salida a 0. Ejemplo: U E 0.7 //Empleamos la entrada 0.7 como entrada del temporizador L S5T#65s //Introducimos un valor de temporización de 65 segundos SE T 4 //Empleamos el temporizador 4 como retardo a la conexión U T 4 //Leemos la salida del temporizador = A 8.1 //Asignamos la salida del temporizador a la salida 8.1 KOP:


Ejemplo:


Si el estado de señal de la entrada E 0.0 cambia de "0" a "1" (flanco creciente en el RLO), se activa el temporizador T5. Si transcurre el tiempo de dos segundos y el estado de señal en la entrada E 0.0 sigue siendo "1", la salida A 4.0 será "1". Si el estado de señal de la entrada E 0.0 cambia de "1" a "0", el temporizador se para y la salida A 4.0 será "0". (Si el estado de señal de la entrada E 0.1 cambia de "0" a "1", el temporizador se pone a 0, tanto si estaba funcionando como si no).

Página:

53/82

9.5. Temporizador como retardo a la conexión con memoria (SS)

Instrucción: "SS" Si la entrada (RLO en la ejecución de la instrucción) cambia de 0 a 1, el temporizador arranca y continua corriendo incluso si la entrada (RLO) cambia a 0, antes que el temporizador termine de contar. Si el tiempo ha concluido la salida continua a 1 independientemente del estado de la entrada (RLO). Solo se puede poner a 0 la salida mediante un Reset. El temporizador vuelve a arrancar con el valor de temporización indicado en el ACU 1 si el estado de la señal en la entrada (RLO) cambia de 0 a 1 mientras el temporizador está en marcha. Ejemplo: U E 1.2 //Empleamos la entrada 1.2 como entrada del temporizador L S5T#32s //Introducimos un valor de temporización de 32 segundos SS T 2 //Empleamos el temporizador 2 como retardo a la c. con memoria U T 2 //Leemos la salida del temporizador = A 3.1 //Asignamos la salida del temporizador a la salida 3.1 KOP:


Ejemplo:


Si el estado de señal de la entrada E 0.0 cambia de "0" a "1" (flanco creciente en el RLO), se activa el temporizador T5. El temporizador continúa en marcha sin que un cambio de señal de "1" a "0" en la entrada E 0.0 repercuta en él. Si el estado de señal de la entrada E 0.0 cambia de "1" a "0" antes de que haya transcurrido el tiempo, el temporizador vuelve a arrancar. La salida A 4.0 será "1" si ha transcurrido el tiempo (Si el estado de señal de la entrada E 0.1 cambia de "0" a "1", el temporizador se pone a "0", independientemente de cuál sea el RLO en S).

Página:

54/82

9.6. Temporizador como retardo a la desconexión (SA)

Instrucción: "SA" Si la entrada (RLO en la ejecución de la instrucción) cambia de 1 a 0, el temporizador arranca y continúa corriendo. Si la entrada (RLO) cambia a 1 antes que el temporizador termine de contar, se resetea el temporizador. Mientras el tiempo está corriendo, la salida vale 1. Ejemplo: U E 4.2 //Empleamos la entrada 4.2 como entrada del temporizador L S5T#32s //Introducimos un valor de temporización de 32 segundos SA T 7 //Empleamos el temporizador 7 como retardo a la desconexión U T 7 //Leemos la salida del temporizador = A 1.1 //Asignamos la salida del temporizador a la salida 1.1 KOP:


Ejemplo:


El temporizador arranca si el estado de señal en la entrada E 0.0 cambia de "1" a "0". A 4.0 es "1" si E 0.0 es "1" o el temporizador está en marcha (Si el estado de señal en E 0.1 cambia de "0" a "1", mientras está en marcha el temporizador, éste se pone a 0).

Página:

55/82

9.7. Elegir el temporizador adecuado

Página:

56/82

9.8. Preselección variable y visualización del valor de temporización Realizaremos la preselección de un temporizador con un valor variable. Cada vez que accionemos el E124.0, el temporizador cogerá como preselección el valor que tenga en ese momento el MW0. El valor de MW0, debe estar en BCD o en tiempo Simatic, en caso contrario el temporizador no lo entenderá y el PLC en caso de no estar programado el OB121, se irá a STOP.

Una vez se haya activado el temporizador, aunque cambie el valor de MW0, el temporizador seguirá trabajando con el valor que tenia al ponerse en marcha. Para cargar el valor del temporizador, lo podremos ver en BCD (MW4) o en Binario (MW2). El valor cargado en BCD, contiene el valor y la base de tiempos. No obstante el MW4 lo podemos visualizar en BCD (formato hexadecimal) o en tiempo Simatic.

Forzar valores en el MW0 (Hexadecimal) con diferentes bases de tiempos y comprobar qué tiempo Simatic coge.

Página:

57/82

9.9. Ejercicios propuestos Ejercicio 1: Diagrama de tiempos Se dispone de un pulsador de activación E0.0. Se desea automatiza un sistema que debe cumplir el diagrama de tiempos definido en la imagen adjunta. Diseñar el programa, teniendo en cuenta que durante el ciclo se debe evitar cualquier rearme de tiempos

Ejercicio2: Control de un semáforo

Se dispone de un semáforo, el cual en condiciones normales se encuentra del modo siguiente: Verde vehículos, Rojo peatones El ciclo se inicia en el momento que un peatón accione sobre el pulsador situado en el semáforo. Durante el ciclo se evitará cualquier rearme hasta 2 minutos después de la finalización del ciclo. Finalizado el proceso, el semáforo regresará al estado normal.

Semáforo coches Verde Ámbar fijo Rojo Ámbar

intermitente

Semáforo peatones Rojo Rojo Verde Verde intermitente

3” 6” 3”

1. Diseña el programa con SI

2. Diseña el programa con SV

3. Diseña el programa con SE

4. Diseña el programa con SS

5. Diseña el programa con SA

Página:

58/82

Ejercicio 3: Generador de pulsos Realizar un tren de pulsos de 1 ciclo de scan con un periodo de 1 seg.

Ejercicio 4: Generador de onda cuadrada Realizar una onda cuadrada periódica de 1 seg.

Ejercicio 5: MAQUINA DISPENSADORA DE BEBIDA Determinada cadena de comida rápida requiere de un sistema de llenado de vasos de bebida automatizado. El proceso de llenado comienza cuando se acciona el pulsador de llenado correspondiente al tamaño de bebida, siempre que un sensor dispuesto a tal efecto detecte la presencia de un vaso. El flujo de líquido lo controla un servo-válvula que permanecerá abierto un tiempo determinado dependiendo del tamaño de bebida que se quiera dispensar: Bebida grande: 10s Bebida mediana: 7s Bebida pequeña: 4,5 s Además el sistema dispone de 2 indicadores de estado:

• “LLENADO”, se enciende mientras el dispensador esté proporcionando bebida. • “LLENO”, se enciende al terminar el llenado mientras no se retire el vaso del dispensador.

Realiza el programa lógico utilizando un sólo temporizador.

Página:

59/82

10. FORMATOS DE REPRESENTACIÓN DE NÚMEROS Tenemos 3 formatos de números: Entero, doble entero y real. 10.1. Números enteros (I) Los números enteros se denominan como I (de Integer). Un número entero es un número binario de 16 bits que tiene como signo el bit más significativo. Límite:

• Nº positivos: 215-1 = 32767 (El 0 se considera positivo) • Nº negativos: 215= -32768

Ejemplo: L 1 //Carga el número entero 1 en ACU1

Nº negativo: Se hace el complemento a 2, cambiando ceros por unos y sumando 1. Ejemplo: L -3 //Carga el número entero 3 en ACU1 3 = 0000 0000 0011 C’1= 1111 1111 1100 +1 = 1111 1111 1101 El número –3 por tanto sería:

Página:

60/82

10.2. Números dobles enteros (D) Los números dobles enteros se denominan como D. Son números binarios de 32 bits.

Límite:

• Nº positivos: 231-1 = 2147483647 (El 0 se considera positivo) • Nº negativos: 231 = -21474863648

Ejemplo: L L#-1 //Carga el número doble entero -1 en ACU1 10.3. Números reales (R) Los números reales se denominan como R. Son números binarios de 32 bits que constan de 2 partes: Mantisa: los 3 bytes más altos Exponente: el byte más alto

Se puede expresar de forma exponencial o como quebrados. Ejemplo:

L 4.83 //Carga el número real 4,83 en ACU1 El editor Step-7 lo pasa automáticamente a la forma exponencial:

L 4.830000e+000 Se redondea con exactitud hasta el 6 dígito

Página:

61/82

11. OPERACIONES DE COMPARACIÓN 11.1. Realización de comparaciones Las operaciones de comparación sirven para comparar los siguientes pares de valores numéricos: Dos enteros (16 bits) Dos enteros dobles (32 bits) Dos números reales (de coma flotante, 32 bits, IEEE-FP) Los valores numéricos se cargan en los ACU's 1 y 2. Las operaciones de comparación comparan l valor del ACU2 con el valor depositado en el ACU1. El resultado de la comparación es un dígito binario. Un 1 significa que el resultado de la comparación es verdadero, mientras que un 0 significa que el resultado de la comparación es aso. Este resultado se encuentra almacenado en el bit de resultado lógico (RLO). Este resultado puede emplearse para su posterior procesamiento. Cuando se ejecuta una comparación también se activan los bits de estado A1 y A0. 11.2. Comparar dos números enteros y dobles enteros Instrucciones y descripción:

Operación Comparación efectuada

==I El entero (16 bits) de la palabra baja del ACU2 es igual al entero (16 bits) de la palabra baja del ACU 1

==D El entero doble (32 bits) del ACU2 es igual al entero doble (32 bits) del ACU1.

<>I El entero (16 bits) de la palabra baja del ACU2 no es igual al entero (16 bits) de la palabra bajan del ACU 1.

<>D El entero doble (32 bits) del ACU2 no es igual al entero doble (32 bits) del ACU1.

>I

El entero (16 bits) de la palabra baja del ACU2 es mayor que el entero (16 bits) de la palabra baja del ACU 1.

>D

El entero doble (32 bits) del ACU2 es mayor que el entero doble (32 bits) del ACU1.

<I

El entero (16 bits) de la palabra baja del ACU2 es menor que el entero (16 bits) de la palabra baja del ACU 1.

<D

El entero doble (32 bits) del ACU2 es menor que el entero doble (32 bits) del ACU1.

>=D

El entero (16 bits) de la palabra baja del ACU2 es mayor o igual al entero (16 bits) de la palabra baja del ACU 1.

>=D El entero doble (32 bits) del ACU2 es mayor o igual al entero doble (32 bits) del ACU1.

<=I

El entero (16 bits) de la palabra baja del ACU2 es menor o igual al entero (16 bits) de la palabra baja del ACU 1.

<=D

El entero doble (32 bits) del ACU2 es menor o igual al entero doble (32 bits) del ACU1.

Estas operaciones afectan al estado de los bits A1 y A0, en función de la condición que se haya cumplido, tal y como se muestra en la tabla siguiente:

Página:

62/82

Registros afectados: RLO, A1, A0 Ejemplo: L MW10 //introducimos en el ACU1 la palabra de marcas MW10 L EW0 //introducimos en el ACU1 la palabra de entradas EW0 ==I //comparamos la igualdad de la palabra baja del ACU1 y ACU2 = A 1.0 //la salida 1.0 se excitará si MW10 y EW0 son iguales >I //comparamos el valor de la palabra baja del ACU2 para ver si es mayor que ACU1 = A 2.0 //la salida 2.0 se excitará si MW10 es mayor que EW0 KOP:

Página:

63/82

A 4.0 ( S )

Descripción de la operación CMP? y (Comparar enteros) puede utilizarse como un contacto normal. El cuadro puede colocarse en las mismas posiciones que puede tomar un contacto normal. Las entradas IN1 y IN2 son comparadas atendiendo al criterio de comparación que se haya seleccionado. Si la comparación es verdadera, el RLO de la operación es "1". El RLO se combina mediante una Y lógica con el RLO del circuito completo siempre que el elemento de comparación esté conectado en serie, y mediante una O lógica si el cuadro está conectado en paralelo.

Ejemplo: La salida A4.0 se activa si E 0.0 Y E 0.1 son 1 Y si MW0>=MW2 11.3. Comparar dos números reales Instrucciones y descripción:

Operación

Comparación efectuada

==R

El número de coma flotante de 32 bits IEEE-FP del ACU 2 es igual al número de coma flotante de 32 bits IEEE-FP del ACU 1

<>R

El número de coma flotante de 32 bits IEEE-FP del ACU 2 no es igual al número de coma flotante de 32 bits IEEE-FP del ACU 1

>R

El número de coma flotante de 32 bits IEEE-FP del ACU 2 es mayor que el número de coma flotante de 32 bits IEEE-FP del ACU 1

<R

El número de coma flotante de 32 bits IEEE-FP del ACU 2 es menor que el número de coma flotante de 32 bits IEEE-FP del ACU 1

>=R

El número de coma flotante de 32 bits IEEE-FP del ACU 2 es mayor o igual que el número de coma flotante de 32 bits IEEE-FP del ACU 1

<=R

El número de coma flotante de 32 bits IEEE-FP del ACU 2 es menor o igual que el número de coma flotante de 32 bits IEEE-FP del ACU 1

CMP >=I

IN1

IN2

E 0.0 E 0.1

MW0 MW2

AWL

Página:

64/82

11.4. Ejercicios propuestos Ejercicio 1: Área de almacenamiento La figura muestra un sistema de dos cintas transportadoras con un área de almacenamiento temporal entre ellas. La cinta 1 lleva paquetes al área de almacenamiento. Una barrera fotoeléctrica situada al final de la cinta 1, junto al área de almacenamiento, se encarga de determinar cuántos paquetes se han suministrado al área de almacenamiento. La cinta 2 transporta paquetes desde el área de almacenamiento temporal a un cargador donde llegan camiones para recoger los paquetes y suministrarlos a los clientes. Una barrera fotoeléctrica al final de la cinta transportadora 2, junto al área de almacenamiento, determina cuántos paquetes salen del área hacia el cargador. Un panel de cinco lámparas indica el nivel de llenado del área de almacenamiento temporal.

Ejercicio 2: ACCESO A UN CENTRO COMERCIAL Se desea controlar el acceso, de manera automática, a una sala comercial con capacidad de 100 plazas de asiento. Admitiendo 10 personas más de las autorizadas, que tendrían que permanecer de pie. Disponemos de dos barreras luminosas a la entrada de la sala, “A” y “B”, situadas de tal forma que al entrar una persona en la sala, interrumpa primero la barrera “A” y luego la “B”. La distancia física entre ellas es la mínima, de manera que siempre se interrumpirán también simultáneamente durante la entrada. De forma semejante sucede cuando una persona sale de la sala. Primero interrumpirá la barrera “B” y después la “A”. Cuando en la sala tenemos menos de 100 personas lo indicaremos activando la luz verde situada en la entrada. Si se diera el caso de que en un momento determinado hubiera más de 100 personas y menos de 110, deberá activarse la luz azul situada en la entrada. En el momento que entrara la persona 110 será la luz roja la que activaríamos.

Página:

65/82

12. OPERACIONES DE CONVERSIÓN

Instrucciones: "BTD", "BTI", "DTB", "DTR","DTR","ITB","ITD","RND","RND+","RND-" y "TRUNC" • Son operaciones incondicionales, no dependen ni afectan el RLO. • Se efectúan sobre el ACU1, donde también se almacena el resultado. Instrucción “BTD” : Convierte el número BCD de 7 dígitos en doble entero. Valores admisibles: -9999999 ÷ 9999999 Instrucción “BTI” : Convierte el número BCD de 3 dígitos de la palabra baja de ACU1 en un entero (16 bits) que se guarda en la palabra baja de ACU1. Valores admisibles: -999 ÷ 999 Instrucción “DTB” : Convierte un entero doble (32 bits) de ACU1 en un BCD de 7 dígitos. Instrucción “DTR” : Convierte un entero doble (32 bits) de ACU1 en real (32 bits). Si es necesario se redondea el resultado. Un entero de 32 bits es más exacto que un real.

BCD_DI EN ENO IN OUT

BCD_I EN ENO IN OUT

DI_BCD EN ENO IN OUT

DI_R EN ENO IN OUT

Página:

66/82

Instrucción “ITB” : Convierte un entero (16 bits) de ACU1 en BCD de 3 dígitos. El resultado lo guarda en la palabra baja del ACU1. Instrucción “ITD” : Convierte un entero (16 bits) de la palabra baja de ACU1 en doble entero (32 bits). Observación: No hay una instrucción que convierta de entero a real. Hay que hacer dos conversiones consecutivas: ITD y DTR. Instrucción “RND”: Redondea un número real (32 bits) a entero (32 bits). Primero lo convierte y luego lo redondea al entero más próximo. Si el primer decimal después de la coma es de 0 a 4, redondea a la baja; si el decimal es de 5 a 9, redondea al alza. Ejemplos: 148.7 RND = 149 148.4 RND = 148 Instrucción “RND+” y “RND–“: RND+ redondea el resultado al número entero mayor o igual que el real convertido. RND- redondea el resultado al número entero menor o igual que el real convertido. Ejemplos: 148.7 RND+ = 149 RND– = 148 148.4 RND+ = 149 RND– = 148 –5.7 RND+ = –5 RND– = –6 Instrucción “TRUNC” : Convierte un real (32 bits) a doble entero (32 bits) y lo redondea al entero de menor valor absoluto. Ejemplos: 8.34 RND = 8 TRUNC = 8 8.7 RND = 9 TRUNC = 8 –8.7 RND = –9 TRUNC = –8

I_BCD EN ENO IN OUT

I_DI EN ENO IN OUT

RONUD EN ENO IN OUT

CEIL EN ENO IN OUT

FLOOR EN ENO IN OUT

TRUNC EN ENO IN OUT

Página:

67/82

13. OPERACIONES ARITMÉTICAS 13.1. Operaciones aritméticas con enteros Para enteros instrucciones: "+I", "–I", "*I", "/I" Para dobles enteros instrucciones: "+D", "–D", "*D", "/D"

• Combinan el contenido de ACU1 y ACU2. • El resultado se deposita en ACU1 y el ACU2 permanece inalterado. • En el S7-400 después de la operación existe 4 acumuladores • Son operaciones incondicionales del RLO y no lo afectan.

La instrucción de suma “+I”, “+D” Suma el contenido de ACU2 con ACU1 y el resultado lo almacena en ACU1. En el caso de sumar dos enteros esta operación actúa sobre las palabras bajas de los acumuladores y el resultado lo almacena en la palabra baja del ACU1. Ejemplo: L 8 L 9 +I //ACU2+ ACU1 ACU1=17; ACU2=8 La instrucción de resta “–I”, “–D” Resta el contenido de ACU2 con ACU1 y el resultado lo almacena en ACU1 ( IN1 - IN2 = OUT ). Ejemplo: L 10 L 3 –I //ACU2-ACU1 ACU1=7; ACU2=10

ADD_DI EN ENO IN1 IN2 OUT

ADD_I EN ENO IN1 IN2 OUT

SUB_I EN ENO IN1 IN2 OUT

SUB_I EN ENO IN1 IN2 OUT

SUB_DI EN ENO IN1 IN2 OUT

Página:

68/82

La instrucción de multiplicación “*I”, “*D” Multiplica el contenido de ACU2 por ACU1 y el resultado lo almacena en ACU1. Si se multiplican dos enteros el resultado se almacena como doble entero en ACU1. Ejemplo: L L#2 L L#100 *D //ACU2* ACU1 ACU1=200; ACU2=2 La instrucción de división “/I”, “/D” divide el contenido de ACU2 entre ACU1 y el resultado se almacena de dos formas distintas según se multipliquen enteros y dobles enteros:

• En caso de división de enteros el resultado se almacena en ACU1 en forma de dos enteros de 16 bits:

En caso de dividir dos enteros dobles el cociente se almacena en ACU1 y el resto de la división se obtiene realizando la operación “MOD”. Ejemplo: L ED10 L MD14 /D T MD20 //Almaceno el cociente MOD T MD24 //Almaceno el resto 13.2. Operaciones aritméticas con números reales

Instrucciones: "+R", "–R", "*R", "/R" La instrucción de suma “+R”, suma el contenido de ACU2 (32bits) con ACU1 (32bits) y el resultado lo almacena en ACU1 (32 bits). Ejemplo: L 1.0 L 2.4 +R //ACU2+ ACU1 ACU1=3.4; ACU2=1.0

MUL_I EN ENO IN1 IN2 OUT

MUL_DI EN ENO IN1 IN2 OUT

DIV_I EN ENO IN1 IN2 OUT

MOD EN ENO IN1 IN2 OUT

ADD_R EN ENO IN1 IN2 OUT

Página:

69/82

La instrucción de resta “–R” resta el contenido de ACU2 (32bits) con ACU1 (32bits) y el resultado lo almacena en ACU1 (32 bits). Ejemplo: L 25.0 L 13.4 –R // ACU2-ACU1 ACU1=11.6; ACU2=25.0 La instrucción de multiplicación “*R” multiplica el contenido de ACU2 (32bits) por ACU1 (32bits) y el resultado lo almacena en ACU1 (32 bits). Ejemplo: L 10.0 L 2.0 *R //ACU2* ACU1 ACU1=20.0; ACU2=10.0 La instrucción de división “/R” divide el contenido de ACU2 (32bits) entre ACU1 (32bits) y el resultado lo almacena en ACU1 (32 bits). Ejemplo: L 10.0 L 2.0 /R //ACU2* ACU1 ACU1=5.0; ACU2=10.0 Instrucción “ABS”: Valor absoluto de ACU1, y el resultado se deposita en ACU1. Instrucción “SQRT”: Raíz cuadrada de ACU1 (debe ser ≥ 0), y el resultado se deposita enACU1. Instrucción “SQR”: Cuadrado de ACU1, y el resultado se deposita en ACU1. Instrucción “LN”: Logaritmo natural de ACU1 (logaritmo con base e), y el resultado se deposita en ACU1. Instrucción “EXP”: Calcula el exponente (valor exponencial con base e) de ACU1, y el resultado se deposita en ACU1. Instrucciones “SIN”, “COS” y “TAN”: Calculan el seno, coseno o tangente de un ángulo indicado en radianes, y el resultado se deposita en ACU1. Instrucción “ASIN”: Calcula el arcoseno de ACU1 (entre –1 y 1). El resultado es un ángulo indicado en radianes: -π/2 ≤ arcoseno(ACU1) ≤ π/2 Instrucción “ACOS”: Calcula el arcocoseno de ACU1 (entre –1 y 1). El resultado es un ángulo indicado en radianes: 0 ≤ arcocoseno(ACU1) ≤ π Instrucción “ATAN”: Calcula el arcotangente de ACU1. El resultado es un ángulo indicado en radianes: π/2 ≤ arcotangente(ACU1) ≤ π/2

SUB_R EN ENO IN1 IN2 OUT

MUL_R EN ENO IN1 IN2 OUT

DIV_R EN ENO IN1 IN2 OUT

Página:

70/82

13.3. Ejercicios propuestos Ejercicio 1: Multiplicación y división Con la entrada E0.5 cargo un valor inicial en AB0. A cada pulso de la entrada E0.0 iré multiplicando ese valor de AB0 por 2 hasta un máximo de 255. Además, a cada pulso de la entrada E0.1 podré ir dividiendo ese valor entre 2 hasta un mínimo de 1. Ejercicio 2: GASOLINERA Simularemos el funcionamiento de un surtidor de gasolina. Introduciremos la cantidad de dinero y seleccionaremos el tipo de gasolina que queramos cuyo precio por litro es el siguiente:

Tipo de gasolina Precio/litro Sin plomo 1 euro Súper 1,2 euros Gasoil 0,88 euros Cuando usemos la manguera, que simularemos como pulsador, nos saldrán X litros de gasolina a razón de 1 litro por segundo (la salida de gasolina la simulamos temporizando una salida del autómata).

ENTRADAS SALIDAS Botón 6 euros E0.0 Luz funciona A0.0 Botón 3 euros E0.1 Luz sin plomo A0.1 Anular E0.2 Luz súper A0.2 Pulsador sin plomo E0.3 Luz gasoil A0.3 Pulsador súper E0.4 Salida gasolina A0.4 Pulsador gasoil E0.5 Pulsador manguera E0.6

Página:

71/82

14. OPERACIONES LÓGICAS Las operaciones lógicas son instrucciones muy útiles a la hora de tratar estados de la instalación. A menudo su desconocimiento obliga al programador a realizar complicadas secuencias de bits, cuando se hubiera podido tratar todos los datos agrupados en una doble palabra, y resolver la tarea en pocas líneas de código. 14.1. Operación lógica AND La AND lógica en Step 7 puede realizarse en dos formatos distintos:

Palabra “UW”: realiza una AND entre los dos acumuladores a nivel de palabra (utilizando los 16 primeros bits).

Doble Palabra “UD”: realiza una AND entre los dos acumuladores a nivel de doble palabra (utilizando los 32 bits).

Esta operación se suele utilizar para “quitar” bits (o aplicar una máscara a una variable) con pocas instrucciones. Supongamos que deseamos resetear una serie de alarmas de una palabra determinada (MW10), eliminando los indicados en una máscara de alarmas no útiles (MW20). Las alarmas que queden (MW24) son para nosotros las válidas.

14.2. Operación lógica O. La O lógica en Step 7 puede realizarse en dos formatos distintos:

Palabra “OW”: realiza una O lógica entre los dos acumuladores a nivel de palabra (utilizando los 16 primeros bits).

Doble Palabra “OD”: realiza una O lógica entre los dos acumuladores a nivel de doble palabra (utilizando los 32

bits). Esta operación se suele utilizar para “poner” bits a 1 (o aplicar una máscara a una variable) con pocas instrucciones. Supongamos que tenemos que activar un motor en una palabra de estado de motores. Las instrucciones correspondientes serían:

Página:

72/82

14.3. Operaciones lógicas XOR. La XOR lógica en Step 7 puede realizarse en dos formatos distintos:

Palabra “XOW”: realiza una XOR lógica entre los dos acumuladores a nivel de palabra (utilizando los 16 primeros bits).

Doble Palabra “XOD”: realiza una XOR lógica entre los dos acumuladores a nivel de doble palabra (utilizando los 32 bits).

Las operaciones XOR se utilizan para detectar cambios de estado en bits de variables con pocas instrucciones. Supongamos que deseamos conocer la activación de alguna alarma de las 32 que componen una doble palabra de marcas (MD0). Cuando se produzca una transición positiva de alguno de sus bits deseamos setear una salida, que está cableada a una sirena que hace sonar la alarma en la instalación. Con la siguiente subrutina, utilizando la XOD, podremos realizar esta acción, muy útil en todas las instalaciones.

El único punto que puede no ser obvio es la parte en la que se realiza la Y lógica con el valor del ACU. Después de realizar la XOD, necesitamos conocer si el cambio en algún bit de la palabra se debe a que aparece la alarma o a que desaparece. Es por esto por lo que se requiere realizar esta operación, ya que en caso contrario la sirena sonaría cuando aparece la alarma y cuando desaparece. La función XOR es la gran desconocida por parte de los programadores para detectar qué está cambiando en su proceso.

Página:

73/82

15. OPERACIONES DE DESPLAZAMIENTO Instrucciones: "SRW", "SLW", "SRD", "SLD", "SSI", "SSD" Desplazan el contenido de ACU1 bit a bit. Son incondicionales, no dependen del RLO. Podemos desplazar, tanto a la derecha como a la izquierda, palabras, doble palabras, enteros y dobles enteros. 15.1. Desplazar palabras • A la derecha: • A la izquierda: 15.2. Desplazar doble palabras • A la derecha: • A la izquierda: 15.3. Desplazar enteros A la derecha:

“SRW <nº de bits>” Desplaza la palabra baja (bits 0 al 15) de ACU1 nº bits (0-15) a la derecha.

“SLW <nº de bits>” Desplaza la palabra baja (bits 0 al 15) de ACU1 nº bits (0-15) a la izquierda. Los bits vacíos se rellenan con cero.

“SRD <nº de bits>” Desplaza el contenido de ACU1 nº bits (0-32) a la derecha. Los bits vacíos se rellenan con cero.

“SLD <nº de bits>” Desplaza el contenido de ACU1 nº bits (0-32) a la izquierda. Los bits vacíos se rellenan con cero.

“SSI <nº de bits>” Desplaza la palabra baja (bits 0 al 15) de ACU1 nº bits (0-15) a la derecha.

Página:

74/82

15.4. Desplazar dobles enteros A la derecha: 15.5. Ejercicio propuesto Haremos que los leds de la palabra de salida se iluminen consecutivamente durante 0,5 seg desde arriba hacia abajo y viceversa

16. OPERACIONES DE ROTACIÓN

Instrucciones: "RRD", "RLD" Rotan el contenido de ACU1 equis posiciones de bit. 16.1. Rotar palabras dobles • A la derecha: • A la izquierda:

“SSD <nº de bits>” Desplaza el contenido de ACU1 nº bits (0-31) a la derecha. Los bits vacíos se rellenan con el bit de signo (el bit 32)

“RRD <nº de bits>” Rota el ACU1 nº bits (0-32) a la derecha. Los bits que van quedando vacíos se llenan con los que salen del ACU1.

“RLD <nº de bits>” Rota el ACU1 nº bits (0-32) a la izquierda. Los bits que van quedando vacíos se llenan con los que salen del ACU1.

Página:

75/82

Ejemplo:

Ejemplo de aplicación El desplazamiento y la rotación son las operaciones necesarias para poder realizar un control secuencial (por pasos) de un programa La utilidad de estas instrucciones va a ser, por ejemplo, la activación de una serie de motores o etapas de programa de una manera secuencial. Vamos a suponer que queremos activar una serie de 10 bombas, conectadas a las marcas M1.0 hasta la M0.1. Con un bit, que se va a desplazar en este rango, indicaremos que bomba debe de arrancar cada vez.

Es importante tener cuidado con dos cosas en estas acciones:

No activar bits de esta palabra por otras partes del programa. Entrar a esta subrutina exclusivamente cuando se deba realizar el cambio de bomba (normalmente es cada cierto

tiempo).

Página:

76/82

17. OPERACIONES DE SALTO La instrucción Salto es una instrucción de control de programa que significa “ir a etiqueta”. La instrucción de Salto identifica el punto donde se interrumpe el programa y la etiqueta indica el punto donde el programa continúa. Una etiqueta está formada por un máximo de cuatro caracteres; el primer carácter debe ser una letra, los restantes pueden ser letras o números. La etiqueta debe estar en el mismo módulo de programa que la instrucción de salto. Fundamentalmente, debemos distinguir dos categorías de Salto:

• Salto Incondicional : El Salto Incondicional se ejecuta ignorando cualquier condición. Este tipo de salto no se ve afectado por los bits de la palabra de estado.

• Salto Condicional : El Salto Condicional se ejecuta solamente si se cumple una condición previa. Esta condición puede referirse a cualquiera de los bits de la palabra de estado: RLO, RB, OV, OS, CC1 y

CC2, etc.

(Véase página 9)

17.1. Operaciones de salto incondicional

Página:

77/82

CAS1 ( JMP )

AWL: "SPA" y "SPL" Las operaciones de salto incondicional (SPA) interrumpen el desarrollo normal del programa, haciendo que el mismo salte a una meta determinada (operando de la operación SPA). La meta define el punto en que deberá continuar el programa. El salto se efectúa independientemente de condiciones. Ejemplo de salto SPA: U E 1.0 //cargamos en el RLO el valor de la entrada 1.0 SPA AQUÍ //saltamos de forma incondicional a la línea con meta "AQUI" AQUI: U E 2.0 //aquí continua la ejecución del programa = A 3.0 / /introducimos el resultado en la salida 3.0 La operación Salto a meta (SPL) es un distribuidor de saltos seguido de una serie de saltos incondicionales a metas determinadas (lista de saltos). El salto de la lista se escoge según el valor contenido en el ACU1, es decir si el acu1 vale 0 se escogerá el primer salto incondicional (SPA), si vale 1 se saltará al segundo salto... Si el valor se encuentra fuera de la lista se salta a la meta especificada en SPL. Una meta se compone de 4 caracteres como máximo. El primer carácter debe ser siempre una letra, no importando si el resto son números o letras. La meta se especifica normalmente en el operando de la instrucción de salto, y seguida de dos puntos frente a la línea que posee la meta (ver ejemplos). Ejemplo de salto SPL: L MB100 //cargamos en el ACU1 un valor de un módulo de datos SPL NORM //se salta a NORM si el valor de ACU1 no está en lista SPA UNO //se salta a UNO si ACU1 vale 0 SPA CONT //se salta a CONT si ACU1 vale 1 SPA DOS //se salta a DOS si ACU1 vale 2 NORM: SPA CONT //se salta a CONT de forma incondicional UNO: U E 0.0 //instrucción meta del salto UNO SPA CONT //se salta a CONT de forma incondicional DOS: U E 1.0 //instrucción meta del salto DOS SPA CONT //se salta a CONT de forma incondicional CONT: = A 2.0 //aquí saltamos finalmente, continuando el programa KOP: ---(JMP)--- Salto absoluto Funciona como un salto absoluto cuando no hay otro elemento KOP entre el conductor izquierdo y la operación (v. ejemplo). Cada salto ---( JMP ) tiene que tener una meta (LABEL). ¡No se ejecutarán las operaciones que se encuentren entre la operación de salto y la meta! Ejemplo: Segmento 1 . . . . . . . . . . . .

Página:

78/82

A 4.1 ( R )

Segmento x El salto se ejecuta en todos los casos, omitiéndose (“pasando por alto“) las operaciones que se encuentren entre la operación de salto y la meta. 17.2. Operaciones de salto condicional, en función del RLO

Instrucciones: "SPB", "SPBN", "SPBB", "SPBNB" Estas instrucciones efectúan un salto en el programa hacia una meta determinada, para el caso de cumplir la condición que necesitan: SPB: salto si RLO=1 SPBN: salto si RLO=0 SPBB: salto si RLO=1 y RB=1 SPBNB: salto si RLO=0 y RB=1 Ejemplo de salto SPB: U E 2.0 //cargamos en el RLO el valor de la entrada 2.0 SPB AQUI //saltamos a la línea con meta "AQUI" si el RLO=1 U E 1.0 //esta línea no se ejecuta si se salta AQUI: U E 3.0 //aquí continua la ejecución del programa = A 0.0 //introducimos el resultado en la salida 0.0 Como podemos observar en el ejemplo, el resultado de la salida 0.0 depende primeramente del valor de la entrada 2.0, ya que ella decide si se tiene en cuenta también la entrada 1.0 en el resultado final.

E 0.4

CAS1

Página:

79/82

A 4.1 ( R )

CAS1 ( JMP )

A 4.0 ( R )

Funciona como un salto condicional cuando el RLO de la combinación lógica anterior es "1". Cada salto ---( JMP ) tiene que tener una meta (LABEL). ¡No se ejecutarán las operaciones que se encuentren entre la operación de salto y la meta! Si un salto condicional no se ejecuta, el RLO cambia a "1" después de la operación de salto. Ejemplo: Segmento 1 Segmento 2 Segmento x Si la entrada E 0.0 es 0 se ejecuta el salto a la meta CAS1. Al llevarse a cabo el salto, en la salida A 4.0 no se ejecuta la operación “Poner salida a 0“, aunque E 0.3 sea 1.

CAS1

E 0.4

E 0.0

E 0.3

Página:

80/82

17.3. Operaciones de salto condicional, en función de RB u OV/OS

Instrucciones: "SPBI", "SPBIN", "SPO", "SPS" Estas instrucciones efectúan un salto en el programa hacia una meta determinada, para el caso de cumplir la condición que necesitan: SPBI: salto si RB=1 SPBIN: salto si RB=0 SPO: salto si OV=1 SPS: salto si OS=1 Ejemplo de salto SPS: SPS AQUI //saltamos a la línea con meta "AQUI" si OV=1 SPA SEGU //esta línea no se ejecuta si OV=1 AQUI: SET //forzamos el RLO a 1 = A 1.0 //con la salida 1.0 indicamos si hubo un error previo en la anterior ejecución del programa SEGU: U E 3.0 //aquí continua la ejecución del programa normalmente = A 0.0 //introducimos el resultado en la salida 0.0 17.4. Operaciones de salto condicional, en función de A1 y A0

Instrucciones: "SPZ", "SPN", "SPP", "SPM", "SPMZ", "SPPZ", "SPU"

Página:

81/82

Estas instrucciones efectúan un salto en el programa hacia una meta determinada, para el caso de cumplir la condición que necesitan: A continuación se muestra el estado de A1 y A0 tras una operación con los acumuladores:

Página:

82/82

17.5. Finalizar módulos

Instrucciones: "BEA" y "BEB" Durante el ciclo del autómata programable, el sistema operativo ejecuta un programa estructurado módulo a módulo. La operación fin de módulo es la que finaliza el módulo en ejecución. BEA finaliza la ejecución del módulo actual y devuelve el control al módulo que llamó al módulo finalizado. Esta instrucción se ejecuta sin depender del RLO ni de cualquier otra condición. Ejemplo: U E 1.0 //introducimos en el RLO el valor de la entrada 1.0 SPB NEXT //si la entrada 1.0 salta a meta NEXT L EW 4 T EW 10 U E 6.0 U E 6.1 S M 12.0 BEA //aquí finaliza el módulo de forma incondicional NEXT: NOP 0 Ejemplo: U E 1.0 //introducimos en el RLO el valor de la entrada 1.0 SPB NEXT //si la entrada 1.0 salta a meta NEXT L EW 4 T EW 10 U E 6.0 U E 6.1 S M 12.0 BEA //aquí finaliza el módulo de forma incondicional NEXT: NOP 0 BEA //fin de módulo U E 1.1 //estas instrucciones nunca se ejecutarían S A 4.0 BEB finaliza la ejecución del módulo actual y devuelve el control al módulo que llamó al módulo finalizado. Esta acción se realiza si el RLO es 1. Si no es así se continúa la ejecución del actual módulo, pero con el RLO a 1. Ejemplo: U E 1.0 //introducimos en el RLO el valor de la entrada 1.0 BEB //si la entrada 1.0 vale 1 el módulo acaba aquí U E 2.0 = A 3.0 BEA //aquí finaliza el módulo de forma incondicional Si el módulo que finaliza es el OB1 se finaliza el ciclo de ejecución del programa, volviendo a comenzar uno nuevo. ---( RET ) RET (Retorno) sirve para salir de los bloques condicionalmente. Para emplear esta salida se necesita una combinación lógica previa.

05 tutorial s7-300 niveli

Documents