STEP7 y Programacion Siemens PDF

STEP7CURSO
NIVELIYNIVELII
http://industrial.uv.es
Curso STEP 7, nivel I y nivel II. Pg. 2 de 247

NDICE
1. Operaciones de bit. Instrucciones binarias ................................................ .........6

1. 1. Creacin del primer proyecto.................................................................................6
1. 2. Contactos en serie...............................................................................................16
1. 3. Contactos en paralelo..........................................................................................20
1. 4. Utilizacin del parntesis.....................................................................................24
1. 5. Contactos negados..............................................................................................27
1. 6. Marcas.................................................................................................................30
1. 7. Instrucciones SET y RESET................................................................................35
1. 8. Opcin TEST > OBSERVAR.............................................................................37
1. 9. Tabla OBSERVAR/FORZAR VARIABLE...........................................................42
1. 10. Depsito de agua...............................................................................................44
1. 11. Temporizadores.................................................................................................51
1. 12. Simblico global.................................................................................................56
1. 13. Cintas transportadoras.......................................................................................60
1. 14. Finales de programa en STEP 7........................................................................71
1. 15. Contadores y comparaciones ............................................................................73
1. 16. Control de un parking.........................................................................................75

1. 17. Puerta corredera.............................................................................................80
1. 18. Fbrica de curtidos.............................................................................................86
1. 19. Escalera automtica...........................................................................................89
1. 20. Instruccin MASTER CONTROL RELAY...........................................................93
2. Operaciones de byte, palabra y doble palabra..................................................99
2. 1. Instrucciones de carga y transferencia................................................................99
2. 2. Formatos de carga, operaciones de salto y metas............................................102
2. 3. Bloques de datos (DBs)............................................................... ................... 113
2. 4. Pesar productos dentro de unos lmites.................................................... ....... 120
2. 5. Introduccin a la programacin estructurada.................................................... 123
2. 6. Desplazamiento y rotacin de bits.....................................................................125
2. 7. Planta de embotellado.......................................................................................127
2. 8. FCs con y sin parmetros.................................................................................129
2. 9. Sistemas de numeracin...................................................................................136
2. 10. Carga codificada..............................................................................................143

2. 11. Operaciones aritmticas con enteros..............................................................147
2. 12. Conversiones de formatos.............................................................................. 150
2. 13. Operaciones aritmticas con reales.............................................................. ..154
2. 14. Control de un gallinero.............................................................. ......................157
2. 15. Operaciones de salto.......................................................................................162
2. 16. Mezcla de pinturas............................................................. .............................165
2. 17. Instrucciones NOT, CLR, SET y SAVE............................................................168
2. 18. Flancos............................................................................................................170
2. 19. Ajuste de valores analgicos...........................................................................174
2. 20. UDTs en STEP 7 (USER DATA TYPE)...........................................................180
2. 21. Operaciones lgicas con palabras.................................................................. 186
2. 22. Ejemplo de alarmas........................................................................................ 188
3. Operaciones de sistema................................................................................... 190
3. 1. Deteccin de errores........................................................................................190
3. 2. Instruccin LOOP.............................................................................................194
3. 3. Relacin de OBs. SFC's importantes..............................................................196
3. 4. Programacin OB 80 (SFC 43)........................................................................203
3. 5. OBs 100, 101 . Retardo en el arranque...........................................................205
3. 6. Programacin de alarmas cclicas....................................................................208
3. 7. Programacin de alarmas de retardo...............................................................210
3. 8. Programacinde alarmas horarias por hardware............................................. 212
3. 9. Programacin de alarmas horarias por software..............................................214
3. 10. Crear archivos fuente y proteger bloques.......................................................216
3. 11. Ajustar la hora.................................................................................................224
3. 12. Formatos fecha y hora....................................................................................225
3. 13. Hacer funcionar algo un da de la semana.....................................................230
3. 14. Direccionamiento indirecto..............................................................................234
3. 15. Control de fabricacin de piezas.....................................................................237
3. 16. Comparar dobles palabras..............................................................................240
3. 17. Referencias cruzadas.....................................................................................241


1. OPERACIONES DE BIT. INSTRUCCIONES BINARIAS
1.1. Creacin del primer proyecto.
Vamos a realizar el primer proyecto en STEP 7. Dentro de un proyecto de STEP 7 introdu-

ciremos todos aquellos equipos que vayan a formar parte de nuestra instalacin. Introduciremos
tanto los equipos de SIEMENS que estemos gastando, as como los equipos de otras marcas, y
los PC en caso de que los hubiera. De este modo podemos comunicarlos de modo sencillo y po-
demos visualizar todos los equipos de la instalacin con una sola programadora desde un solo
punto de la instalacin.
Adems, con el software NETPRO (incluido en el STEP 7 a partir de la versin 5.x) podre-
mos visualizar de forma grfica, las redes y conexiones entre los diferente equipos. Adems po-
dremos manejar estos enlaces a las redes con el ratn de la programadora de forma grfica.
En el primer proyecto que vamos a realizar en el curso, vamos a insertar un solo equipo.
Dentro del equipo vamos a incluir tanto el hardware que estemos utilizando, como los blo-
ques de programacin (programa propiamente dicho).
Esto nos aportar varias ventajas. La programadora sabr el equipo que vamos a gastar
en nuestro trabajo. Adems sabr las tarjetas que tenemos instaladas y las opciones de las que
dispone cada tarjeta. Si intentamos utilizar alguna instruccin que no soporta nuestra CPU, nos
avisar indicndonos que aquella instruccin es imposible. Adems cuando entremos en la opcin
Propiedades del objeto de cualquier objeto que tengamos en la instalacin, tendremos disponi-
bles las propiedades de ese objeto en concreto.
Adems tendremos la posibilidad de ajustar desde el software propiedades del propio

hardware. Por ejemplo nos permitir cambiar las alarmas, el tiempo de ciclo de scan preestable-
cido para la propia CPU, las direcciones de cada uno de los objetos, etc.
Cada vez que hagamos un proyecto nuevo tendremos que definir un hardware nuevo para
cada uno de los equipos que tengamos en la red.
Veamos como haramos esto prcticamente.
Abrimos el Administrador de SIMATIC. Tenemos disponible un asistente de nuevo proyec-

to. Si queremos utilizar el asistente, no tenemos ms que ir contestando a lo que se nos pregunta.
Si queremos podemos cancelar el asistente y generar nosotros nuestro nuevo proyecto.

Figura 1. Asistente Step 7
Si hacemos el proyecto con el asistente, no tendremos en el proyecto las tarjetas de entra-

das y salidas que estamos gastando.
Para generar un nuevo proyecto, podemos ir bien al men Archivo > nuevo, o bien al bo-
tn que tiene como icono una hoja en blanco.
Aparece una ventana en la que podemos decir si queremos crear un proyecto nuevo o una
librera nueva.
En nuestro caso decimos que queremos un proyecto nuevo.

Figura 2. Ajuste de nombre proyecto
A continuacin le damos el nombre que queramos al proyecto. Una vez tenemos el nom-
bre, aceptamos y observaremos que tenemos una ventana con el nombre de nuestro proyecto en
la parte izquierda y con la red MPI en la parte derecha.
El icono de la red MPI aparece por defecto. Es necesario que tengamos al menos una red
MPI porque la programacin de la CPU se hace a travs del puerto MPI de la CPU.
Posteriormente podremos insertar tantas redes como nos haga falta.

Figura 3. Primera vista de proyecto nuevo
Vamos a rellenar el proyecto. Lo primero que tenemos que hacer es insertar los equipos
que van a formar parte de nuestro proyecto. En este caso vamos a insertar un solo equipo. Para
ello, vamos al men de insertar y elegimos el equipo con el que vayamos a trabajar. En este ca-
so tenemos un equipo 300.
Veremos que en nuestra ventana del proyecto se ha creado un equipo. Hacemos doble clic
sobre el equipo, y en la parte derecha de la ventana, veremos que aparece un icono que se llama
Hardware.
Hacemos doble clic sobre l y entramos el editor de hardware. En principio veremos que
est todo en blanco. Para insertar los mdulos que nosotros tenemos en nuestro equipo, tendre-
mos que abrir el catlogo. Suele estar abierto por defecto. Si no lo est, podemos abrirlo con el
botn que representa un catlogo, o desde dentro del men de Ver, con la opcin Catlogo.
(Tambin funciona con la combinacin de teclas Ctrl K).

Figura 4. Vista del catlogo en configuracin HW
Una vez tengamos el catlogo abierto, desplegamos la cortina del equipo que tengamos
que definir. En este caso desplegamos la cortina de SIMATIC 300.
Lo primero que tenemos que insertar es un bastidor. Desplegamos la cortina de los basti-
dores, y vemos que tenemos un perfil soporte. Hacemos doble clic sobre el perfil soporte. Vere-
mos que en la instalacin del hardware se sita en la posicin cero.
A continuacin tenemos que ir rellenando el resto de posiciones que tengamos ocupadas.
Nos situamos en la posicin 1 y vamos a insertar la fuente de alimentacin que es lo pri-

mero que tenemos en nuestro equipo.
Desplegamos la cortina de las PS, y elegimos la que tengamos en cada caso.
A continuacin nos situamos en la posicin 2 para insertar la CPU. Desplegamos la cortina

de las CPU. Vemos que existen varias del mismo modelo. Si pinchamos una sola vez encima de
cada una de las CPU (o cualquier otro elemento del catlogo), vemos que en la parte inferior del
catlogo, tenemos una pequea explicacin sobre el elemento seleccionado, y adems la referen-
cia del elemento.
Tenemos que comprobar que esta referencia coincida con la referencia del elemento que
tenemos nosotros.
En la posicin 3 no podemos insertar cualquier mdulo. Es una posicin reservada para los
mdulos IM. Estos mdulos sirven para realizar configuraciones en ms de una lnea de bastidor.
En nuestro caso tenemos una nica lnea de bastidor. No tenemos tarjeta IM. En este caso tene-
mos que dejar la posicin 3 libre.

Pasamos a la posicin 4. En ella y en las siguientes posiciones, tenemos que insertar los
mdulos de entradas/salidas que tengamos. Si encontramos en el catlogo varios del mismo mo-
delo, tendremos que comprobar para cada caso la referencia del elemento.
El hardware que tenemos en el equipo didctico quedara de la siguiente manera:
Figura 5. Vista de configuracin HW del equipo didctico
Veremos que debajo de esta tabla, se va creando otra en la que podemos ver los elemen-
tos que vamos creando con sus referencias y adems con las direcciones que le corresponde a
cada uno de los mdulos.
Una vez hemos terminado la configuracin, tenemos que guardarla. Estamos trabajando
con dos CPU a la vez. Estamos trabajando con la programadora y con el PLC. Tenemos que
guardar la informacin en ambos sitios. Con el icono que representa un disquete, guardamos la
informacin en la programadora, y con el icono que representa un PLC y una flecha que entra,
guardamos la informacin en el PLC. Una vez tenemos la informacin guardada, salimos del edi-
tor de hardware.
Veremos que volvemos a la misma ventana en la que estbamos antes, es decir, volvemos
al administrador de SIMATIC. En nuestro proyecto, tenemos el equipo. Vemos que al lado del
equipo hay un + . Si desplegamos todo lo que tenemos, vemos que dentro del equipo est la CPU,
la carpeta para el programa, los bloques y las fuentes. Si pinchamos encima de los bloques, ve-
mos que en la parte derecha tenemos los datos de sistema y el OB 1.
Es el primer bloque que vamos a programar. Aparece por defecto, aunque est vaco.

Figura 6. Estructura del proyecto con bloque OB1 insertado
Estando en el administrador de SIMATIC vemos que tenemos abierta una ventana con
nuestro proyecto que acabamos de crear. En los iconos de la parte superior vemos que tenemos
uno seleccionado que representa un PC y un PLC cortados por una doble barra roja. Este es el
icono de offline. A su lado vemos que tenemos otro icono que representa el mismo PC y el mis-
mo PLC pero unidos con una lnea verde. Este es el icono de online.
Versiones 3 y 4 Versin 5
Figura 7. Iconos Online/Offline
En este momento tenemos apretado el icono de offline. Apretamos tambin el icono de

online. Vemos que en el administrador de SIMATIC tenemos dos ventanas parecidas. Con May.
F2, nos organizamos las ventanas.

Figura 8. Vista conjunta del proyecto en Online/offline
Siempre que estemos en offline, estamos trabajando en la programadora. Estamos le-

yendo del disco duro de la programadora. Vemos que en los bloques slo tenemos el OB 1 que es
el que ha creado el proyecto por defecto.
Siempre que estemos en online, estamos trabajando directamente en el PLC. Estamos

leyendo directamente lo que tenga el PLC. Vemos que tenemos otros bloques. Son los bloques
que lleva integrados y protegidos la CPU. Dependiendo de la CPU con la que estemos trabajando,
tendremos unos bloques diferentes. Estos bloques no los podemos borrar. Tampoco podemos ver
lo que hay programado en ellos. Slo podemos utilizarlos. Tenemos una ayuda de cada uno de
ellos en la que nos explica como se llama cada uno de los bloques, lo que hace y como debemos
utilizarlo y rellenarle sus parmetros. Para ver esta ayuda, slo tenemos que seleccionar el bloque
que queremos, y en esta posicin pulsar la tecla F1.
Si aparecen bloques que no sean los de sistema ( SFCs o SFBs) quiere decir que en el
PLC tenemos algn programa. Antes de empezar con nuestro programa vamos a borrar todo lo
que tenga el PLC.
Para ello pinchamos encima de la CPU de online. En esta posicin vemos al men Sistema
Destino, y elegimos la opcin Borrado Total.

Con esto borramos todos los bloques que tuviera la CPU excepto los de sistema. El hard-
ware no lo borramos.
Si volvemos a pinchar en bloques veremos que slo tenemos los de sistema.
A la hora de trabajar sobre los distintos bloques, lo podemos hacer tanto en offline como
en online. A la hora de guardar lo que hemos programado, lo podemos guardar tanto en la pro-
gramadora como en la CPU, tanto si estamos trabajando en online como si estamos trabajando
en offline.
A la hora de trabajar con los distintos bloques, tenemos que tener en cuenta que en un
momento dado podemos llegar a estar trabajando con tres bloques con el mismo nombre a la vez.
Por ejemplo, supongamos que estamos trabajando con un OB 1. El bloque que estamos viendo en
la pantalla de la programadora, mientras no lo guardemos en ningn sitio, lo tenemos nicamente
en la RAM. Se puede dar el caso de que tengamos un bloque en el PLC, tengamos otro bloque
diferente guardado en disco duro, y acabemos de hacer una modificacin y la tengamos en la
pantalla de la programadora pero todava no la hayamos transferido. Si teniendo el bloque en la
pantalla pinchamos el icono de guardar o el icono de transferir al autmata, estaremos guar-
dando el disco duro o en el autmata lo que tengamos en la pantalla. Pero si volvemos a la panta-
lla principal (Administrador de Simatic) sin haber guardado previamente el bloque en disco duro, y
transferimos algn bloque arrastrndolo con ayuda del ratn, vamos a transferir lo ltimo que hu-
bisemos guardado en disco duro, y no las ltimas modificaciones que hemos hecho en el bloqu
Cuntos tipos de bloques podemos programar?
OB Bloques de sistema.
FC Funciones.
FB Bloques de funcin.
DB Bloques de datos.
UDT Tipo de datos.
Veamos lo que podemos hacer con cada uno de estos bloques.
OB: Son bloques de organizacin. Cada OB tiene una funcin determinada. El OB 1

es el nico bloque de ejecucin cclica. Es el que ejecuta la CPU sin que nadie le
llame. Los dems OBs tienen una funcin determinada. Se ejecutan cuando les co-
rresponda sin que nadie les llame desde ningn sitio del programa. Tenemos OBs
asociados a diferente errores de la CPU, a alarmas, etc.

FC: Funciones. Son trozos de programa que yo me creo. Realizan una funcin de-
terminada dentro de mi proyecto. Se ejecutan cuando se las llama desde algn punto
de mi programa. Pueden ser parametrizables o no. Adems de las FCs que yo me
creo, existen FCs hechas en libreras. Se utilizan exactamente igual que las que yo
programo. No podemos entrar en ellas para ver la programacin.
FB: Bloques de funcin. En principio funcionan igual que las FC. La diferencia est
en que las FB se guardan la tabla de parmetros en un mdulo de datos. Esto tiene
dos ventajas. Una es que podemos acceder a los parmetros desde cualquier punto
del programa. Otra es que cada vez que llamemos a la FB no es necesario que le
demos todos los parmetros . Los parmetros que no rellenemos, se tomarn por de-
fecto los ltimos que hayamos utilizado.
DB: Mdulos de datos. En estos bloques no realizamos programa. Son tablas en

las que guardamos datos. Luego podremos leerlos y escribir sobre ellos.
UDT: Tipo de datos. Nos podemos definir nuestros propios tipos de datos para lue-
go utilizarlos en los DB.

1.2. Contactos en serie.
Teora
o Creacin del primer bloque
Vamos a programar nuestro primer OB 1. Entramos en el OB 1 de offline.
Nos aparece una ventana en la que tenemos que elegir el lenguaje de programacin.
Tenemos 3 posibilidades: KOP, FUP y AWL.
o KOP: Esquema de contactos.
o FUP: Funciones.
o AWL: Lista de instrucciones.
Supongamos que lo que queremos programar son dos contactos en serie. Veamos como
quedara hecho en cada uno de los tres lenguajes:
Circuito que queremos programar:
Solucin en KOP:
( )
Solucin en FUP:
Solucin en AWL:
U E 0.0
U E 0.1
= A 4.0
BE
En principio elegimos lista de instrucciones. En STEP 7, podemos hacer toda la progra-

macin que queremos en cada uno de los tres lenguajes.
Vamos a programar dos contactos en serie.
Tenemos que dar nombre a cada uno de los contactos. Tendremos que direccionar las en-
tradas y salidas de que disponemos.
El direccionamiento de tarjetas en un S7 - 300 es el siguiente:
0 4 8 12
PS CPU 1 5 9 13
2 6 10 14
3 7 11 15
Figura 9.Direccionamiento de tarjetas digitales
Las direcciones son las mismas independientemente de que las tarjetas sean de entradas
o de salidas. Como vemos, tenemos ocupados 4 bytes para cada posicin de tarjeta. Si tenemos
tarjetas de 2 bytes, estamos perdiendo estas dos direcciones.
En el caso de tarjetas analgicas, el direccionamiento es el siguiente:

256 272 288 304
PS CPU
270 286 302 318
Figura 10.Direccionamiento de tarjetas analgicas
Tambin es independiente de que las tarjetas sean de entradas o de salidas. Como vemos,
para cada puesto de tarjeta tenemos reservados 16 bytes.
En nuestro caso, tenemos la siguiente configuracin.
288
290
PS CPU 0 4 292
294
288
1 5 290
Figura 11.Direccionamiento de tarjetas en equipo didctico
Tendremos bytes de entradas 0 y 1, y bytes de salidas 4 y 5. La tarjeta de entradas/salidas

analgicas, ocupa la posicin 288. Tendremos palabras de entrada 288, 290, 292, 294, y palabras
de salidas 288 y 290.
Instruccin U: Es la instruccin que utilizaremos para unir varias condiciones en serie. La

instruccin sirve tanto para primera consulta como para el resto de condiciones en serie.

Contactos serie. Ejercicio resuelto
TEORA PREVIA: Introduccin. Generacin de nuevo proyecto.
Supongamos que queremos automatizar el siguiente circuito:
E 0.0 E 0.1 A 4.0
( )
Vemos que lo que tenemos son dos contactos en serie.
Tenemos que asignar nombre a cada uno de los contactos. A las entradas les vamos a
llamar E y a las salidas les vamos a llamar A. Esto corresponde a las iniciales en alemn (Lengua-
je SIMATIC). Tambin podemos cambiar y elegir las iniciales en ingls. (Lenguaje IEC). El cambio
lo podemos hacer en el men Herramientas Preferencias. De aqu en adelante trabajaremos
con lenguaje SIMATIC.
A parte de darles nombre a las entradas y a las salidas, tenemos que darles una numera-
cin.
Como hemos visto anteriormente, el direccionamiento de entradas y salidas, depende ni-

camente de la posicin que ocupen en el rack. Es decir, la primera tarjeta, que en nuestro caso es
una tarjeta de entradas, van a ser los bytes 0 y 1.
La siguiente tarjeta en nuestro caso es una tarjeta de salidas, ocupar las posiciones 4 y 5.
Por tanto tendremos disponibles 16 entradas (desde la 0.0 hasta la 1.7) y 16 salidas (des-
de la 4.0 hasta la 5.7)
Las direcciones que no estamos utilizando, las podramos utilizar en periferia descentrali-
zada.
Para unir los dos contactos en serie disponemos de la instruccin U.
El siguiente ejercicio lo podramos resolver en los tres lenguajes que nos permite el STEP
7. AWL, KOP y FUP.
Veamos primero la programacin en AWL.
SOLUCIN EN AWL

U E 0.0
U E 0.1
= A 4.0
BE
La instruccin BE es opcional. Significa final de programa. Si no la escribimos no pasa na-

da. Cuando el autmata lee la ltima instruccin del OB 1 vuelve a empezar la lectura por el prin-
cipio.
Una vez tenemos el programa hecho, podemos cambiarlo de lenguaje. Esto lo podremos
hacer siempre y cuando el programa sea traducible. En este caso, por ejemplo, la instruccin BE
no existe ni en KOP ni en FUP. Si intentamos traducir esto nos va a decir que no es traducible.
Si le quitamos el BE veremos que ya lo podemos traducir. En AWL podemos poner

o no poner la instruccin BE.
Veremos que tenemos el mismo programa en AWL en KOP o en FUP.
SOLUCION EN KOP
SOLUCIN EN FUP
1.2. Contactos en paralelo
Teora
INSTRUCCIN O
Para unir dos contactos en paralelo tenemos la instruccin O.
Con esta instruccin unimos varias condiciones en paralelo. La instruccin nos sirve tanto
para instrucciones de primera consulta como para el resto de condiciones.
Para la instruccin de primera consulta, podemos utilizar tanto la instruccin U como la

instruccin O.
El programa funcionara exactamente igual.

Contactos en paralelo. Ejercicio resuelto
TEORA PREVIA: Instruccin O.
Veamos cmo podramos resolver el siguiente circuito elctrico:
E 0.0
A 4.0
E 0.1 ( )
Vemos que lo que tenemos son dos contactos en paralelo.
Para programar los contactos en paralelo tenemos la instruccin O.
SOLUCIN EN AWL
U E 0.0 (tambin O E 0.0)
O E 0.1
= A 4.0
BE
SOLUCIN EN KOP

SOLUCIN EN FUP

1. 4. Utilizacin del parntesis
Teora
INSTRUCCIONES O( Y U(
Hasta ahora hemos visto la manera de unir varias condiciones en serie y condiciones en
paralelo.
Tambin podemos combinar series con paralelos. Para ello, nos har falta utilizar los pa-
rntesis. (Solamente si hacemos la programacin en instrucciones)
Para abrir el parntesis lo haremos siempre al lado de una instruccin. Por ejemplo U(
O(
Para cerrarlo lo haremos en una instruccin el parntesis solo ).
Tambin podemos obviar los parntesis. Para ello dejaramos la instruccin que abre el
parntesis sola en una lnea, y luego no cerramos el parntesis.
El significado sera el mismo.

Utilizacin del parntesis. Ejercicio resuelto
TEORA PREVIA: Instruccin parntesis.
Veamos cmo podramos programar el siguiente circuito elctrico:
E 0.0
E 0.1 E0.2 A 4.0
( )
E 0.3 E0.4
Vemos que en el circuito tenemos contactos en serie junto con contactos en paralelo. Ya
hemos visto que los contactos en serie se programan con la instruccin U, y que los contactos
en paralelo se programan con la instruccin O. Ahora tenemos que unir ambas instrucciones
para formar el circuito que queremos programar.
Para hacer algunas de estas uniones nos har falta utilizar los parntesis. Veamos cmo
quedara el circuito resuelto:
SOLUCIN EN AWL
U E 0.0
O(
U E 0.1
U E 0.2
U E 0.3
U E 0.4
= A 4.0
BE

Hemos visto dos formas de hacer lo mismo. Vemos que podemos utilizar la instruccin O(
o bien podemos utilizar la instruccin O, sin abrir y cerrar el parntesis.
En ambos casos el resultado que obtenemos es el mismo.
Del mismo modo, tambin podemos utilizar la instruccin del parntesis para la instruccin
U.
SOLUCIN EN KOP
SOLUCIN EN FUP

1.5. Contactos negados
Teora
INSTRUCCIONES UN Y ON.
Hemos visto las instrucciones U y O.
A ambas instrucciones podemos aadirle la letra N a continuacin. Se convierten en las

instrucciones UN y ON
Son las instrucciones negadas de las anteriores.
Por ejemplo si escribimos:
UN E 0.0
UN E 0.1
.........
Esto significa que cuando no est cerrado el contacto E0.0, y cuando no est cerrado el
contacto E 0.1, ........
Esto nos sirve para programar contactos que son normalmente cerrados.
Veremos a lo largo del curso que la letra N la podemos aadir a ms instrucciones. Lo que
conseguimos es negar lo que dice la instruccin precedente.

Contactos negados. Ejercicio resuelto
TEORA PREVIA: Contacto normalmente cerrado.
Vamos a ver cmo podemos programar contactos que son normalmente cerrados y que-
remos que la actuacin sea cuando abrimos el contacto en lugar de cuando lo cerramos.
Para ello utilizaremos las instrucciones ON y UN.
De esta manera estamos negando la instruccin precedente.
Veamos cmo resolveramos el siguiente circuito elctrico. Lo que queremos es que se ac-
tive la salida cuando accionemos los dos pulsadores. En un contacto queremos que d seal
cuando se cierre fsicamente el contacto. En el otro caso queremos que d seal cuando se abra
fsicamente el contacto.
SOLUCIN EN AWL
UN E 0.0
U E 0.1
= A 4.0
BE
Cuando no est el contacto E0.0 y si que est el E0.1, se activar la salida.
En el dibujo, cuando pulsemos en el botn de E 0.0 y cuando pulsemos en el botn de E

0.1, se activar la salida.

SOLUCIN EN KOP
SOLUCIN EN FUP

1. 6. Marcas
Teora
Las marcas son bits internos de la CPU. Disponemos de una cantidad limitada de marcas.
Esta cantidad depende de la CPU con la que estemos trabajando.
Estos bits podremos activarlos o desactivarlos como si fueran salidas. En cualquier

punto del programa los podremos consultar.
A las marcas les llamaremos M. A continuacin tenemos que decir a que bit en concreto
nos estamos refiriendo.
Por ejemplo tenemos las marcas, M 0.0, M 10.7, M 4.5, etc.

Marcas. Ejercicio resuelto
TEORA PREVIA: Introduccin a las marcas.
Veamos cmo podramos resolver el siguiente circuito elctrico:
En principio parece que esto es una cosa complicada. Lo podramos hacer dibujando direc-
tamente el circuito en KOP. Tambin lo podemos hacer pensando bien el circuito y con lo visto
hasta ahora programarlo a travs de parntesis.
Tambin lo podemos hacer utilizando MARCAS.
Lo que conseguimos utilizando las marcas, es simplificar el circuito todo lo que nosotros
queramos. De este modo programamos directamente el AWL de manera sencilla.
Veamos cmo podemos simplificar el circuito utilizando las marcas:

Al final lo que quedara por programar sera un circuito tan sencillo como este:
Veamos cmo quedara resuelto con MARCAS:
SOLUCIN EN AWL
U E 0.0
O E 0.1
O(
U E 0.2
U E 0.3
U E 0.4
=M 0.0
U E 0.6
O E 0.7
=M 0.1
U E 1.1
U E 1.2
O E 1.0
=M 0.2
U E 0.5

U M 0.1
=M 0.3
U M 0.0
U(
U M 0.3
O M 0.2
=A 4.0
BE
De esta manera, utilizando contactos auxiliares, (marcas) queda resuelto el circuito de ma-
nera sencilla.
El ejercicio lo hemos resuelto de modo ms largo pero sin tener que pensar mucho.
SOLUCIN EN KOP

SOLUCIN EN FUP

1. 7. Instrucciones SET y RESET
Teora
Las instrucciones SET y RESET son instrucciones de memoria.
Si programamos un SET de una salida o de una marca con unas condiciones, se activar
cuando se cumplan dichas condiciones. Aunque las condiciones dejen de cumplirse, no se desac-
tivar hasta que se haga un RESET de la salida o marca.
Estas instrucciones tienen prioridad. Dependen del orden en que las programemos. Siem-
pre va a tener prioridad la ltima que programemos.
Veamos porqu ocurre esto.
Existen dos registros internos que se llaman PAE (imagen de proceso de entradas) y PAA
(imagen de proceso de salidas).
Antes de ejecutarse el OB1, se hace una copia de las entradas reales en la PAE. Durante
la ejecucin del OB1, el PLC no accede a la periferia real para hacer sus consultas, lo que hace
en realidad es acceder a este registro interno. Este registro se refresca cada vez que comienza un
nuevo ciclo de scan.
Segn se van ejecutando las instrucciones, el PLC no accede a las salidas reales para ac-
tivarlas o desactivarlas. Accede al registro interno PAA y pone 0 o 1.
Slo cuando termina cada ciclo de scan accede realmente a las salidas.
Entonces lo que hace es copiar lo que hay en la PAA en las salidas reales.
En nuestro caso, si hacemos un SET y un RESET dentro del mismo ciclo de scan, al final
de cada ciclo har efecto lo ltimo que hayamos programado.

Instrucciones SET y RESET. Ejercicio resuelto
TEORA PREVIA: Instrucciones SET y RESET. Diferencia con un igual.
Vamos a ver cmo podramos programar un enclavamiento elctrico.
El circuito elctrico correspondiente a un enclavamiento elctrico sera el siguiente:
Esto lo podemos programar tal cual lo vemos en el circuito elctrico. Para ello lo haramos
utilizando lo que hemos visto hasta ahora.
Tambin lo podramos hacer utilizando dos instrucciones nuevas que hacen eso exacta-
mente.
Son las instrucciones S y R. (Set y Reset)
Veamos cmo quedara el circuito resuelto:
SOLUCIN EN AWL
U E 0.0
S A 4.0
U E 0.1
R A 4.0
BE
Esto hace las funciones de dos pulsadores, uno de marcha y otro de paro. Es la forma ms
cmoda de programar dos pulsadores.

E0.0 E0.1
Figura 12. Pulsador marcha y paro
SOLUCIN EN KOP
SOLUCIN EN FUP

1. 8. Opcin TEST > OBSERVAR.
Teora
Vamos a hacer el siguiente programa:
U E 0.0
U E 0.1
UN E 0.2
U E 0.3
O E 0.4
= A 4.0
Es un programa de un solo segmento que lo podemos ver tanto en AWL como en KOP o
en FUP.
PROGRAMA EN KOP

PROGRAMA EN FUP
Vamos a verlo en AWL y vamos a entrar en el men TEST > OBSERVAR.
Tambin podemos seleccionar esta opcin con un icono que representa unas gafas.
Veremos que aparecen tres columnas al lado de las instrucciones.
Estas columnas las podemos configurar nosotros. Para cambiar la configuracin de las co-
lumnas, lo podemos hacer entrando en el men Herramientas > Preferencias. Por defecto vemos
tres columnas. Lo que vemos es el estado real del contacto, el RLO (resultado de la operacin
lgica), y el valor del acumulador 1.
El estado real del contacto ser 1 si el contacto en cuestin est cerrado, y ser 0 si el
contacto est abierto.
El RLO es el resultado de la operacin lgica. Comprueba si de ah hacia arriba se va

cumpliendo la operacin que le hemos dicho que haga. Si cuando llega a la activacin de la salida
en el RLO hay 1, la activar. Si hay un 0 no la activar.
Hagamos varias pruebas con el programa ejemplo.

Figura 13. Pulsador marcha y paro
Ahora vamos a ver el programa en KOP y luego en FUP y vamos a ver el mismo men
TEST > OBSERVAR.
Aqu lo que veremos ser una lnea de color segn se van cumpliendo las instrucciones
que tenemos escritas.
Es lo mismo que hemos visto en AWL pero de modo grfico.
El significado es el mismo tanto en KOP como en FUP.
KOP

FUP

1. 9. Tabla OBSERVAR/FORZAR VARIABLE
Teora
Adems de lo que hemos visto en el ejercicio anterior, podemos abrir una tabla en la que
podemos observar las variables que nosotros queramos.
Estas tablas son un bloque ms dentro del proyecto. Hasta ahora tenamos el OB 1. Si ge-
neramos una tabla, tendremos el OB 1 y la VAT 1. Podemos tener ms de una tabla. La numera-
cin de las tablas ser VAT y a continuacin un nmero. Cuando pinchemos en los bloques del
proyecto, veremos las tablas que tenemos.
Para poder abrir la tabla tenemos que estar bien dentro de un bloque de
ONLINE/OFFLINE, o bien desde el administrador de SIMATIC pinchando en la parte izquierda
encima del nombre de la CPU en ONLINE. En las nuevas versiones lo podemos hacer desde
cualquier punto del administrador de SIMATIC.
Vamos al men SISTEMA DESTINO y cogemos la opcin de OBSERVAR / FORZAR

VARIABLE. Tenemos una tabla en la que podemos escribir nosotros las variables con las que
queremos trabajar.
Podemos observar bits, bytes, palabras, etc. A continuacin podemos decirle en qu for-
mato queremos observar la variable.
A continuacin tenemos dos columnas para los valores. En una de ellas vemos el valor ac-
tual de las variables, y en la siguiente podemos escribir el valor que queremos que tenga la varia-
ble. Esta ltima columna es para forzar valores.
Figura 14. Tabla de valores
Para poder observar y forzar estos valores, tenemos unos botones en la barra de herra-
mientas.

Figura 15. Tabla de valores
Hay un botn que representa unas gafas con una rayita al lado. Con este botn lo que po-
demos hacer es una visualizacin instantnea. Observamos los valores que tienen las variables
en ese instante y se quedan fijos en la pantalla. Si se producen cambios en las variables no los
vemos reflejados en la pantalla.
Tenemos otro botn que representa unas gafas solamente. Con esto podemos hacer una
observacin continua. Si se produce algn cambio en las variables, se refleja en la pantalla.
Despus tenemos unos botones que representan unos rayos. Estos son para forzar va-
riables. Podemos hacer un solo forzado o podemos hacer un forzado continuo.
Una vez forzado un valor, veremos que el valor actual de la variable es el que acabamos
de forzar.
Si hacemos un forzado instantneo y por programa estamos cambiando el valor de la va-

riable, veremos el nuevo valor que ha tomado la variable por programa.

1.10 Depsito de agua
Ejercicio resuelto
TEORA PREVIA: Contactos, marcas, set y reset.
Tenemos un depsito de agua. Para manejarlo tenemos un selector de mando. Podemos

seleccionar modo manual o modo automtico. Si seleccionamos 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 las boyas de nivel.
Si lo tenemos en modo automtico queremos que el nivel se mantenga entre las dos bo-
yas. 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.
Adems tenemos un rel trmico que acta tanto cuando tenemos la bomba en funciona-
miento manual como cuando la tenemos en funcionamiento automtico. Cuando salta el rel, que-
remos que se pare la bomba y que nos avise con un indicador luminoso en el cuadro de mando.
Adems tenemos una luz de marcha que nos indica cuando est en marcha la bomba.
Las boyas en reposo (sin que el agua las rebase) tienen contactos NA. Cuando el agua las rebasa
sus contactos se cierran.
E0.3
E0.2
E0.0 E0.1
Figura 16. Esquema control depsito de agua
Veamos cmo haramos la programacin del depsito:

SOLUCIN EN AWL
Segmento 1: MANUAL
U E 0.0 //Si activamos en modo manual
=A 4.0 //Pon en marcha la bomba
=A 4.1 //Enciende la luz de marcha
Segmento 2: AUTOMTICO
U E 0.1 //Si est en automtico
U E 0.7 //Y est bien el rel
U E 0.2 //Y est activo el nivel de abajo
UN E 0.3 //Y no est activo el nivel de arriba
S A 4.0 //Pon en marcha la bomba
S A 4.1 //Y enciende la luz de marcha
U E 0.7 //Y est bien el rel
UN E 0.2 //Y no est activo el nivel de abajo
U E 0.3 //Y se ha activado el nivel de arriba
ON E 0.7 //O ha saltado el rel
R A 4.O //Para la bomba
R A 4.1 //Apaga la luz de marcha
UN E 0.7 //Si ha saltado el rel
= A 4.7 //Avsame con la luz de rel
BE
Si hacemos la prueba de este circuito veremos que no funciona correctamente. Vemos que
en modo manual s que funciona pero en modo automtico no para la bomba cuando debera.
Para resolver este circuito correctamente, nos hace falta utilizar marcas auxiliares. En un
mismo bloque no podemos activar la misma salida dos veces con condiciones diferentes porque
se interfieren entre ellas.
Las salidas no se activan en el mismo instante en el que se lee la instruccin correspon-

diente. Existe un registro interno que se denomina PAA (Imagen de proceso de salida), en el que
se van almacenando los valores que se tienen que transferir a las salidas cuando finalice el co-
rrespondiente ciclo de scan. Cuando se lea la instruccin BE es cuando se mandarn estos valo-
res a las salidas reales. Si hemos enviado varios valores dentro del mismo ciclo de scan, el que
realmente llegar a las salidas, ser el ltimo que hemos enviado.
El ejercicio bien resuelto quedara de la siguiente manera:
Segmento 1 : MANUAL
U E 0.0 //Si est en manual
S M 0.0 //Activa la marca 0.0 (Marca ON manual)
R M 0.2 //Y desactiva la marca 0.2, (Marca ON automtico).
Segmento 2: AUTOMTICO
U E 0.7 //Y est el rel trmico bien
UN E 0.2 //Y no est activo el nivel inferior
UN E 0.3 //Y no est activo el nivel superior
S M 0.2 //Activa la marca 0.2 (ON automtico)
R M 0.0 // Desactiva la marca 0.0 (ON manual)
U E 0.2 //Y est activo el nivel inferior
U E 0.3 //Y se ha activado el nivel superior
ON E 0.7 //O ha saltado el rel
R M 0.2 //Desactiva la marca 0.2
UN E 0.7 //Si no est el rel
=A 4.7 //Activa la luz de rel.
Ahora nos quedara asignar las marcas a las salidas.

Aadimos:
U M 0.0 //Si est activa la marca 0.0 (Marca ON manual)
O M 0.2 //O est activa la marca 0.2 (Marca ON automtico)
=A 4.0 //Pon en marcha la bomba
=A 4.1 //Enciende la luz de marcha
Ahora ya no funciona el trmico en el modo manual. Al utilizar marcas diferentes para cada
tipo de funcionamiento, el trmico slo acta sobre la marca de modo automtico. Slo estamos
haciendo un reset de una de las marcas que activan la bomba. Nos falta resetear la otra marca.
Tendremos que aadir las siguientes lneas.
UN E 0.7 //Si ha saltado el rel
R M 0.0 //Desactiva la marca 0.0 (Marca ON manual)
R M 0.2 //Y desactiva la marca 0.2 (Marca ON automtico)
Otra posible solucin sera programar el paro de la bomba por apertura del rel trmico en
el ltimo segmento. Los paros de emergencia se suelen programar al final.
Ahora podemos hacer todas las objeciones que queramos y corregir sobre lo que ya tene-
mos hecho.
KOP




1. 11. Temporizadores
Teora
TEMPORIZADORES SE Y SI
Temporizadores sin memoria: Tenemos los temporizadores SE y SI.
Analicemos cada uno de ellos.
Temporizador SE: Es un temporizador de retardo a la conexin. Para programar el tem-

porizador, necesitamos cinco operaciones como mnimo.
1 Necesitamos una condicin a partir de la cual empiece a temporizar. Esta condicin

puede constar de una sola instruccin o de varias.
2 Necesitamos decirle cuanto tiempo tiene que temporizar.
3 Necesitamos decirle el modo de funcionamiento y n de temporizador que queremos uti-

lizar. (En cada CPU tenemos una cantidad de temporizadores)
4 Queremos que en algn momento dado, (mientras temporiza, cuando ha acabado de

temporizar, etc.)
5 haga algo.
Alguna de estas operaciones, puede constar de ms de una instruccin.
El modo de funcionamiento SE (RETARDO A LA CONEXIN).es el siguiente:
Cond. U E 0.0
L S5T#5S
T SE T 1
Temp. U T 1
= A 4.0
Salida
Adems de lo que hemos visto, en cualquier momento podemos hacer un RESET del tem-
porizador. Para hacer un RESET necesitamos una condicin. En el momento se cumpla si al tem-
porizador le corresponda estar a 1, automticamente se pondr a cero aunque por su modo de
funcionamiento no le corresponda.

El modo de funcionamiento SI (IMPULSO) es el siguiente:
Cond. U E 0.0
L S5T#5S
Temp. SI T 1
U T 1
Salida = A 4.0
A este temporizador tambin podemos aadirle un RESET en cualquier momento.
Veamos como podramos programar estos dos temporizadores en KOP y en FUP respecti-
vamente.
KOP

FUP
TEMPORIZADORES SS, SV y SA.
Adems de los temporizadores que hemos que hemos visto en ejercicios anteriores, tene-
mos tres ms llamados temporizadores con memoria. Son los temporizadores SS, SV y SA.
El temporizador SS es equivalente al temporizador SE. El funcionamiento es similar. La di-

ferencia est en que el funcionamiento del temporizador es independiente de la entrada. Una vez
se ha detectado un flanco de subida de la entrada se ejecuta el ciclo del temporizador indepen-
dientemente de lo que hagamos con la entrada. A continuacin vemos un esquema del funciona-
miento del temporizador. Observamos que tenemos un problema. El temporizador se queda a uno
si nadie lo resetea. Necesitamos aadir una condicin que resetee el temporizador para que vuel-
va a su estado inicial y lo podamos volver a utilizar.
El modo de funcionamiento SS (RETARDO A LA CONEXIN CON MEMORIA)
es el siguiente:
Cond.
U E 0.0
Temp. T L S5T#5S
SS T 1
U T 1
Salid. = A 4.0

Cond. de Reset
El temporizador SV es equivalente al SI. El funcionamiento es el mismo, pero es indepen-

diente de la condicin de entrada. Una vez se ha detectado un flanco de subida de la entrada se
ejecuta todo el ciclo del temporizador.
El modo de funcionamiento SV (IMPULSO CON MEMORIA) es el siguiente:
Cond.
U E 0.0
T L S5T#4S
Temp. SV T 2
U T 2
= A 4.1
Salida
Tambin disponemos de un temporizador de retardo a la desconexin Es el temporizador

SA. Veamos el esquema de funcionamiento del temporizador.
El modo de funcionamiento SA (RETARDO A LA DESCONEXIN) es el siguiente:
Cond.
U E 0.3
T L S5T#6S
Temp. SA T 5
U T 5
= A 5.3
Salida


1. 12. Simblico global
Teora
Hasta ahora hemos llamado a cada contacto por su nombre. Dependiendo de si es

entrada, salida o marca, tienen unos nombres predefinidos (E, A, M,...). Veremos que lo
mismo ocurre con los temporizadores, contadores, DB, etc.
Pero nosotros podemos dar nombre a todo esto. Para ello vamos a la ventana del adminis-
trador de SIMATIC, y pinchamos en la ventana de OFLINE, en la parte izquierda, encima de don-
de pone programa S7. En la parte derecha aparece un icono que se llama Smbolos.
Figura 17. Insertar smbolos en proyecto
Hacemos doble clic encima de Smbolos. Entramos en una tabla donde podemos definir
los nombres que queramos y decir a qu contacto corresponde cada nombre.
Figura 18. Definir smbolos en tabla de simblicos global

Podemos poner nombre a todo lo que queramos. Tenemos que tener en cuenta que el
programa diferencia las maysculas de las minsculas. Si luego intentamos acceder a uno de es-
tos contactos por su nombre, tendremos que escribir el nombre tal y como lo hemos definido dife-
renciando las maysculas de las minsculas.
Los nombres que definamos aqu son de mbito global. Los podremos utilizar en cualquier
bloque del programa.
Al escribirlos en el programa, sabremos que son de mbito global porque aparecern escri-
tos entre comillas.
Nosotros escribiremos el nombre que hemos definido, y veremos que el programa le aade
unas comillas. Esto nos indica que es un smbolo global. Luego veremos que tambin podemos
tener smbolos locales.
A la hora de ver el programa en AWL, KOP o FUP, podremos ver o no estos smbolos.
Tenemos dentro del men VER > MOSTRAR > REPRESENTACIN SIMBLICA para ver
o no los smbolos. Tambin tenemos la opcin informacin sobre el smbolo para ver a qu con-
tacto corresponde cada uno de los smbolos.
Nosotros podremos acceder a estos contactos por su nombre en cualquier sitio del pro-
grama.
Veamos unos pequeos ejemplos en cada uno de los lenguajes.
AWL

KOP

FUP


1.13. Cintas transportadoras
Ejercicio resuelto
TEORA PREVIA: Temporizadores SE y SI.
Tenemos tres cintas transportadoras dispuestas de la siguiente manera:
Figura 19. Esquema de instalacin de cintas transportadoras
Por las cintas transportadoras van a circular cajas grandes y pequeas indistintamente. El
tamao de las cajas con respecto a las clulas que tenemos en la segunda cinta es el siguiente:
C. G.
C.P
Figura 20. Esquema de deteccin de tamao de caja

El funcionamiento que queremos es el siguiente:
Cuando le demos al pulsador de marcha queremos que se ponga en marcha la cinta n 1.

Cuando llegue la primera caja a la cinta n 2, queremos que se pare la cinta n 1 y que se ponga
en marcha la cinta n 2. En la cinta n 2 detectamos si la caja es grande o pequea. Si es grande,
queremos que se ponga en marcha la tercera cinta hacia arriba, y si es pequea queremos que se
ponga en marcha la tercera cinta hacia abajo. La cinta n 2 se para cuando la caja ya est aban-
donando la cinta n2. La cinta n 3 se para a los 10 seg. de haberse puesto en marcha. A conti-
nuacin se pone en marcha de nuevo la primera cinta y vuelve a comenzar el ciclo.
SOLUCIN EN AWL
U E 1.0 //Si le damos al pulsador de marcha (un solo pulso no
mantenido)
S A 4.0 //Pon en marcha la primera cinta
U E 0.0 //Cuando la caja cambie de cinta
S A 4.1 //Pon en marcha la segunda cinta
R A 4.0 //y para la primera
U E 0.0 //Si ve la primera clula
U E 0.1 //Y ve la segunda clula
U E 0.2 //Y ve la tercera clula
S A 4.2 //Pon en marcha la cinta de caja grande
UN E 0.0 //Si no ve la primera clula
U E 0.1 //Y si que ve la segunda clula
UN E 0.2 //Y no ve la tercera clula
S A 4.3 //Pon en marcha la cinta de caja pequea
UN E 0.0 //Si no ve la primera clula
UN E 0.1 //Y no ve la segunda clula
U E 0.2 //Y si que ve la tercera clula
FN M 0.0 // justo en el momento que deja de verla
R A 4.1 //Para la segunda cinta
U A 4.2 //Si est en marcha la cinta de caja grande

O A 4.3 //O la cinta de caja pequea
L S5T#10S //Cuanta 10 segundos
SE T 1 //Con el T 1
U T 1 //Y cuando acabes de contar
R A 4.2 //Para la cinta de caja grande
R A 4.3 //Para la cinta de caja pequea
S A 4.0 //Y pon en marcha la primera cinta
U E 1.1 //Si pulsamos el paro de emergencia
R A 4.0 //Para la primera cinta
R A 4.1 //Para la segunda cinta
R A 4.2 //Para la cinta de caja grande
R A 4.3 //Para la cinta de caja pequea
BE
De este modo, si se va la luz en un momento determinado, al volver el ciclo empezara otra

vez desde cero.
Si se hubiera quedado una caja en el camino, no lo sabramos y tendramos un ciclo con

dos cajas circulando. Es una cosa que no hemos tenido en cuenta. El sistema podra reaccionar
errneamente.
Para arreglar esto podemos utilizar marcas remanentes en lugar de trabajar directamente
con las salidas.
De este modo el sistema se acordara de las cajas que estaban circulando antes del corte
de suministro.
Cambiaramos las salidas por marcas remanentes y aadiramos:
U M 0.0
= A 4.0
U M 0.1
= A 4.1
U M 0.2
= A 4.2
U M 0.3
= A 4.3
Marcas remanentes son aquellas que ante un corte de tensin mantienen su valor. Por de-
fecto, tenemos los primeros 16 bytes de marcas remanentes.
No obstante, la cantidad de marcas remanentes que queremos las definimos nosotros. Pa-
ra ello, vamos al administrador de SIMATIC. Pinchamos encima de Equipo 300. En la parte de-
recha aparece el icono del Hardware. Entramos en el hardware. Una vez dentro, pinchamos con el
botn derecho encima de la CPU. Entramos en el men Propiedades del objeto.
Veremos que aparecen unas fichas. Una de ellas se llama Remanencia. Entramos en es-
ta ficha. Vemos que podemos definir la remanencia de las marcas como nosotros queramos. Le
decimos la cantidad de bytes remanentes de marcas que queremos.
Figura 21. Definir reas de memoria remanente
Este mismo programa tambin lo podramos hacer con direccionamiento simblico.
Si utilizamos el direccionamiento simblico podramos hacer lo siguiente:

U MARCHA
S 1_CINTA
U CELULA_1
S 2_CINTA
R 1_CINTA
..........
..........
Veamos como quedara el ejercicio resuelto en KOP y en FUP.
KOP



FUP


Tanto en KOP como en FUP, tambin podemos utilizar el direccionamiento simblico. El

programa (a modo de ejemplo) quedara de la siguiente manera:

1. 14. Finales de programa en STEP
Teora
A parte del final que hemos visto (BE), existen otros dos finales. Estos son BEB y BEA.
Veamos para qu podemos utilizar cada uno de ellos.
BEB: Es un final condicional. Esto quiere decir que ser un final o no dependiendo de si se
cumple o no la condicin (RLO) que tenemos antes del BEB.
Si la condicin se cumple, ser un final de programa. Si la condicin no se cumple, no ser

un final.
BEA: Es un final absoluto. Siempre que se lea la instruccin BEA terminar el programa.
La diferencia con el BE es que podemos escribir detrs de l.
Veamos un ejemplo en el que podemos utilizar los BEA.
Supongamos que queremos el siguiente funcionamiento:
Si est activa la entrada E 0.0 queremos que funcione un trozo de programa. Si est activa
la entrada E 0.1 queremos que funcione otro trozo de programa. Si no est activa ninguna de las
dos, no queremos que funcione nada.
Esto lo programaramos del siguiente modo:
U E 0.0
Salta a meta 1
U E 0.1
Salta a meta 2
BEA
Meta1:..............
.................
.................
BEA
Meta2:..............
..................
...............
BE

Si no tuvisemos el primer BEA, aunque no estuviera ni la E 0.0 ni la E 0.1 se ejecutara la

primera meta. Si el PLC no encuentra una instruccin de fin, va ejecutando una instruccin detrs
de otra.
El BEA es una instruccin incondicional. Cada vez que el PLC la lea va a terminar el pro-
grama.
Veamos un ejemplo de como funcionara el BEB.
U E 0.0
= A 4.0
U E 0.1
BEB
U E 0.2
= A 4.2
BE
Si no est activa la E 0.1 funcionara todo el programa. Si est activa la E 0.1 slo funcio-
nara la primera parte del programa.
En este caso no tenemos operacin equivalente en KOP ni en FUP. La misma fun-

cin la podramos desarrollar utilizando metas. (Ver ejercicio ms adelante)

1. 15. Contadores.
Teora
Veamos como podemos programar un contador. A los contadores les llamaremos Z. Vea-
mos todo lo que podemos hacer con un contador:
U E 0.0
ZV Z 1 Contar una unidad con un flanco positivo de E0.0
------------------------------------------------
U E 0.1
ZR Z 1 Descontar una unidad con un flanco positivo de E0.1
------------------------------------------------
U E 0.2
L C#10
S Z 1 Setear con un valor. Inicializar el contador.
------------------------------------------------
U E 0.3
R Z 1 Resetear el contador (poner a cero).
------------------------------------------------
U Z 1 Consultar el bit de salida.
= A 4.0
Esto es todo lo que podemos hacer con un contador. No es necesario que para cada con-
tador utilicemos todas las posibilidades ni en este orden.
Z1 es el contador que estamos gastando en este ejemplo. El nmero de contadores que

podemos gastar depende de la CPU que estemos gastando.
El contador va a almacenar un valor. Ser la cuenta que lleve el contador en cada momen-
to.
A parte de esto, nosotros tambin podemos acceder a Z1 con instrucciones de bit. De este
modo estamos consultando el bit de salida del contador.

Este bit estar a 0 siempre y cuando el contador est a 0. Este bit estar a 1 siempre y
cuando el contador tenga un valor distinto de cero. (Los contadores no cuentan nmeros negati-
vos).
Adems de esto podemos consultar el valor del contador y trabajar con l como nmero
entero.
Con los contadores, podemos trabajar de dos modos distintos. Una forma es cargar ini-
cialmente un valor en el contador. Luego podemos saber cuando ha llegado a cero. Tenemos un
bit de salida que nos da cambio cuando pasamos de un valor distinto de cero a cero.
Otra forma de trabajar con los contadores, es comenzar a contar desde cero y comparar
con los valores con los cuales queramos que ocurra algo.
Para esto nos har falta comparar dos valores. Para comparar, al PLC le hace falta tener
estos valores en dos registros internos que son el acumulador 1 y el acumulador 2.
Para meter los valores en los acumuladores, tenemos la instruccin de carga. (L).
Cuando cargamos un valor, siempre se carga en el acumulador 1. Cuando volvemos a

cargar otro valor, tambin se guarda en acumulador 1. Lo que tena en el acumulador 1 pasa al
acumulador 2, y lo que tena en el acumulador 2 lo pierde.
En nuestro caso, cargaremos el valor de Z1 y a continuacin cargaremos el valor con el

que queremos comparar.
Una vez tengamos los valores en el acumulador, tendremos que compararlos. Para ello te-
nemos las siguientes instrucciones:
> < >= <= == <>
Mayor Menor Mayor o igual Menor o igual Igual Dist.
A continuacin del smbolo de comparacin pondremos una I si lo que estamos comparan-

do son dos nmeros enteros. Pondremos una R si lo que estamos comparando son nmeros
reales.

1. 16. Control de un parking
Ejercicio resuelto
TEORA PREVIA: Contadores y comparaciones. (Operaciones de carga).
Tenemos el siguiente parking de coches:
A 4.6
A 4.7
Figura 22. Esquema de un parking
Cuando llega un coche y el parking est libre, queremos que se abra la barrera. A la salida
no tenemos barrera. Cuando sale un coche simplemente sabemos que ha salido.
En el parking caben 10 coches. Cuando el parking tenga menos de 10 coches queremos

que est encendida la luz de libre. Cuando en el parking haya 10 coches queremos que est en-
cendida la luz de ocupado.
Adems queremos que si el parking est ocupado y llega un coche que no se le abra la ba-
rrera.

SOLUCIN EN AWL
U E 0.0 //Si llega un coche
U A 4.6 //Y est libre
=A 4.0 //Abre la barrera
U A 4.0 //Si se he abierto la barrera
ZV Z 1 //Cuenta uno con el contador 1
U E 0.1 //Si sale un coche
ZR Z 1 //Descuenta 1 con el contador 1
LZ 1 //Carga el contador 1
L 10 //Carga un 10
<I //Si en el contador hay menos de 10
S A 4.6 //Enciende la luz de libre
R A 4.7 //Y apaga la de ocupado
==I //Si el contador de coches vale 10
R A 4.6 //Apaga la luz de libre
S A 4.7 //Y enciende la luz de ocupado
BE
Esto sera una forma de hacerlo utilizando un contador y la funcin de comparacin.
Como slo queremos hacer una comparacin, es decir slo nos interesa la cantidad de 10
coches para hacer el cambio de las luces, tenemos otra posibilidad de programarlo. Podemos ha-
cerlo utilizando la salida binaria del contador. Veamos como quedara resuelto en AWL.

SOLUCIN AWL
U E 0.7 //Si activamos la entrada 0.7
L C#10 //Carga un 10
S Z 1 //Mete el 10 en el contador
U E 0.0 //Si llega un coche
U A 4.6 //Y est libre
=A 4.0 //Abre la barrera
U A 4.0 //Si se ha abierto la barrera
ZR Z 1 //Descuenta 1 en el contador 1.1 plaza libre menos
U E 0.1 //Si sale un coche
ZV Z 1 //Cuenta 1 en el contador 1. 1 plaza libre mas.
UN Z 1 //Si en el contador 1 hay un 0
=A 4.7 //Enciende la luz de ocupado
UN A 4.7 //Si no est ocupado
=A 4.6 //Enciende la luz de libre
BE
Pasemos a ver las soluciones en KOP y AWL

Solucion en KOP

Solucion en FUP

1.17. Puerta corredera
Ejercicio resuelto.
TEORA PREVIA: Temporizadores + contadores.
Tenemos una puerta corredera. El funcionamiento de la puerta es el siguiente.
E 0.6 E 0.7
M P
E 0.0
E 1.7 Rel sobrecarga
E 1.0 E1.1 A 4.1
A 4.0
E 0.0
Figura 23. Esquema de funcionamiento de puerta corredera
Queremos que cuando alguien pise en la goma del suelo, se abra la puerta. Motor de aper-
tura A 4.0. La puerta se est abriendo hasta que llegue al final de carrera. Cuando llega al final de
carrera, comienza a cerrarse. (Motor A 4.1). Se est cerrando hasta que llega al final de carrera.
Tenemos dos pulsadores de control. El de marcha y el de paro. Cuando le demos al pulsa-

dor de marcha queremos que el funcionamiento sea el que hemos explicado anteriormente.
Cuando le demos al de paro queremos que deje de funcionar. Es decir, si alguien pisa la goma no
queremos que se abra la puerta.
Adems tenemos un rel trmico. Queremos que cuando salte el rel trmico se pare la
puerta hasta que lo rearmemos. Cuando haya saltado el rel trmico 5 veces queremos que se
bloquee la puerta.
Volver a funcionar cuando desbloqueemos la puerta.

SOLUCIN EN AWL
U E 0.6 //Si le damos al pulsador de marcha
S M 0.0 //Activa la marca 0.0
U E 0.7 //Si le damos al pulsador de paro
R M 0.0 //Desactiva la marca 0.0
U E 0.0 //Si alguien pisa la goma
FP M 10.0 // Solo durante un flanco.
U M 0.0 //Y est la puerta en marcha
U Z 1 //Y el contador 1 tiene un valor distinto de 0
S A 4.0 //Y activa el motor de abrir
U E 1.0 //Si llega el final de carrera
R A 4.0 //Para el motor de apertura
S A 4.1 //Y pon en marcha el motor de cierre
U E 1.1 //Si se ha cerrado la puerta
R A 4.1 //Para el motor de cierre
***************************
UN E 1.7 //Si ha saltado el rel trmico
ZR Z 1 //Descuenta una unidad en el contador 1
R A 4.0 //Y para el motor de abrir
R A 4.1 //Y para el motor de cerrar
U E 1.6 //Si activamos la entrada 1.6
L C#5 //Carga un 5
S Z 1 //Y mtelo en el contador 1
BE

Veamos la solucion en KOP y en FUP.
KOP


FUP


1. 18. Fbrica de curtidos
Ejercicio resuelto.
TEORA PREVIA: Temporizadores + contadores.

Tenemos una fbrica de curtidos. Tenemos una mesa de trabajo, una cinta transportadora
y un caballete dispuestos del siguiente modo:
Figura 24. Esquema de funcionamiento de maquina en fbrica encurtidos
Cuando le demos al pulsador de marcha, queremos que se ponga en marcha la cinta trans-
portadora. La piel va cayendo por un lado del caballete. Cuando llegue a la mitad, queremos que
se active el mbolo y que doble la piel por la mitad.
Lo que pretendemos es que tenga el tamao que tenga la piel, siempre doble por la mitad.
Tenemos que medir la piel de algn modo. Lo que vamos a hacer es generar dos trenes
de impulsos de frecuencia uno el doble que el otro.
Mientras est la primera clula activa, estaremos contando los pulsos de frecuencia menor
con un contador. Mientras est activa la segunda clula estaremos contando los pulsos de fre-
cuencia mayor con otro contador.
Cuando la cuenta de los dos contadores sean iguales querr decir que la piel est por la
mitad. Activaremos el mbolo durante 3 segundos.
SOLUCIN EN AWL

U E 1.0 //Si le damos al botn de marcha
S A 4.0 //Pon en marcha la cinta
UN M 0.0 //Generamos unos pulsos
L S5T#10MS //de 10 milisegundos
SE T 1 //con la marca 0.0
U T 1
=M 0.0
UN M 0.1 //Generamos unos pulsos
L S5T#20MS //de 20 milisegundos
SE T 2 //con la marca 0.1
U T 2
=M 0.1
U E 0.0 //Mientras est la primera clula activa
U M 0.1 //y lleguen pulsos de frecuencia lenta
ZV Z 1 //Cuntalos con el contador 1
U E 0.1 //Mientras est activa la segunda clula
U M 0.0 //Y lleguen los pulsos rpidos
ZV Z 2 //Cuntalos con el contador 2
==I //Cuando sean iguales
S A 4.5 //Activa el mbolo
U A 4.5 //Cuando hayas activado el mbolo
L S5T#3S //Cuenta 3 segundos
SE T 3 //Con el temporizador 3
U T 3 //Cuando acabes de contar
R A 4.5 //Desactiva el mbolo
R Z 1 //Resetea el contador 1
R Z 2 //Y resetea el contador 2

U E 1.1 //Si pulsamos el paro
R A 4.0 //Para la cinta
BE
Ejercicio propuesto: Resolver el problema en KOP y en FUP con las instrucciones que se
han visto anteriormente.

1. 19. Escalera automtica
Ejercicio resuelto
TEORA PREVIA: Temporizadores SA
Tenemos una escalera automtica.
Figura 25. Esquema de escalera automtica
Cuando le demos al pulsador de marcha, queremos que la escalera est activa. Eso no
quiere decir que se ponga en marcha. Se pondr en marcha cuando llegue una persona.
Cuando est en marcha, el funcionamiento que queremos es el siguiente:
Cuando una persona pise, queremos que la escalera se ponga en marcha. A partir de
cuando la persona suba al primer escaln, queremos que est en marcha 5 seg. que es lo que le
cuesta a la persona subir.
Si antes de acabar el ciclo sube otra persona queremos que tambin llegue al final de su
trayecto. En resumen, queremos que la escalera est en marcha 5 seg. desde que la ltima per-
sona subi al primer escaln.
Cuando le demos al pulsador de paro, queremos que si hay alguna persona que est su-
biendo llegue al final de su trayecto, pero si llega otra persona ya no pueda subir.

SOLUCIN EN AWL
U E 1.0 //Si le damos al pulsador de marcha
S M 0.0 //Activa la marca 0.0
U M 0.0 //Si est activa la marca 0.0
U E 0.0 //Y llega una persona
L S5T#5S //Cuenta 5 segundos
SA T 1 //A partir de cuando empiece a subir
U T 1 //Mientras no hayas acabado de contar
= A 4.0 //Estar en marcha la escalera
U E 1.1 //Si le damos al paro
R M 0.0 //Resetea la marca 0.0
BE
Veamos las soluciones en KOP y en FUP.

Solucin en KOP.

Solucin en FUP:

1. 20. Instruccin MASTER CONTROL RELAY
Teora
El Master Control Relay consta de 4 instrucciones:
o MCRA Activar el Master Control Relay.
o MCR( Abrir el parntesis. (Necesita una condicin previa).
o )MCR Cerrar el Master Control Relay.
o MCRD Desactivar el Master Control Relay.
Esta instruccin la utilizaremos para programar esquemas como el que sigue:
E0.0
Delante de cada parntesis que abramos tendremos que poner una condicin que har las
funciones del contacto E 0.0 en el esquema.


Ejercicio resuelto.
Esto viene a ser como una activacin a desactivacin de un trozo de programa. La

funcin que realiza es la conexin o desconexin de un circuito que represente un esquema elc-
trico.
Esto slo sirve para operaciones de contactos. Dentro del MASTER CONTROL RELAY no
podemos poner temporizadores o llamadas a otros bloques. El programa si que nos permite ha-
cerlo pero no funciona correctamente.
Est pensado para utilizar contactos con asignaciones =. Viene a ser como un circuito
elctrico. Lo que quede activado cuando no se ejecuta lo que hay dentro de los parntesis del
Master Control Relay, se desactiva.
Si dentro del Master Control Relay utilizamos instrucciones SET y RESET, no funciona
como hemos dicho. Cuando deja de actuar lo que hay dentro de los parntesis, si estaba activado
con un SET se mantiene activado.
Si no hacemos un RESET desde fuera, no se desactiva.
Veamos cuales son las instrucciones necesarias para hacer un MASTER CONTROL
RELAY:
MCRA Activar al MCR
U E 0.0
MCR(
U E 0.1
= A 4.0
)MCR
U E 0.2
MCR(
U E 0.3
= A 4.1
)MCR
U E 0.7
= A 4.7
MCRD Desactivar el MCR.

Tenemos dos instrucciones para activar y desactivar el MCR. Dentro de estas instruccio-
nes, podemos abrir y cerrar hasta 8 parntesis. Los podemos hacer anidados o independientes.
Siempre, delante de cada parntesis tenemos que poner una condicin. Hace la funcin
del contacto E 0.0 del grfico anterior.
Vemos que cada parntesis funciona slo cuando tenemos activa su condicin. Cuando su
condicin no est activa el trozo de programa en cuestin deja de funcionar y las salidas se des-
activan. Es como si realmente quitsemos tensin a ese trozo de programa.
Esto no ocurre si el trozo de programa se deja de leer por cualquier otra causa. Si hace-
mos un salto o una meta, o programamos otros bloques, cuando no se ejecuta una parte del
programa, las salidas se quedan como estaban. Si estaban activas cuando dej de ejecutar-
se ese trozo de programa, continan activas. Esto no ocurre con el MCR.
En el ejemplo que hemos hecho, la ltima parte no est dentro de ningn parntesis, aun-
que si que est dentro de la activacin del MCR. Esta parte de programa si que funciona siempre.
Lo que podemos activar o desactivar es lo que tenemos dentro de los parntesis y siempre
va precedido de una condicin.
Igualmente esto lo podemos hacer en cualquiera de los otros dos lenguajes.

Solucin en KOP:

Solucin en FUP

2. OPERACIONES DE BYTE, PALABRA Y DOBLE PALABRA
2. 1. Instrucciones de carga y transferencia
Teora
Hasta ahora hemos trabajado con bits. Escribamos instrucciones del tipo:
U E 0.0
= A 4.0
Si quisisemos hacer esto mismo pero con todas las entradas y todas las salidas, podra-
mos hacerlo bit a bit, o trabajando directamente con la palabra de entradas y la palabra de salidas
en bloque.
Hemos visto como podemos acceder a los bits de entrada, salida o marcas.
E 0.0 A 4.0 M 0.0
Tambin podemos acceder a bytes (8 bits)
EB 0 AB 4 MB 0
Esto es el byte de entradas 0, el byte de salidas 4 y el byte de marcas 0.
Tambin podemos acceder a palabras (16 bits).
EW 0 AW 4 MW 0
Esto son la palabra de entradas 0, la palabra de salidas 4 y la palabra de marcas 0.
Tambin podemos trabajar con dobles palabras.
ED 0 AD 4 MD 0
Esto son la doble palabra de entradas 0, la doble palabra de salidas 4 y la doble palabra de
marcas 0.
Para trabajar con todo esto tenemos las instrucciones de carga y transferencia.
Instruccin de carga: L
Instruccin de transferencia: T
Cuando cargamos algo, lo cargamos en el acumulador 1. Cuando transferimos, lo que ha-

cemos es coger lo que hay en el acumulador 1 y llevarlo a donde le decimos. El acumulador 1 es
un registro interno del autmata de 32 bits.
o Ejercicio resuelto.
TEORA PREVIA: Instrucciones de carga y transferencia.

Vamos a hacer una prueba de lo que podemos hacer con est instruccin.
Queremos que lo que metamos por las entradas nos salga por las salidas.
Para ello tenemos dos formas de hacerlo. Una forma sera pasar los bits uno a uno. Por
ejemplo:
U E 0.0
= A 4.0
U E 0.1
= A 4.1
.....
.....
Otra forma de hacerlo sera utilizando las instrucciones de carga y transferencia.
El programa quedara del siguiente modo:
L EW 0
T AW 4
BE
Con esto lo que estamos haciendo es una copia de las entradas en las salidas.
Hay que tener en cuenta que las operaciones de carga y transferencia son incondicionales.
Esto quiere decir que no debemos hacer programas como el siguiente:
U E 0.0
L MW 0
T AW 4
En este caso el autmata no dara error pero no hara caso a la entrada. Tanto si estuviera
como si no, la operacin de carga y transferencia se ejecutara.
Esta operacin tambin la podemos hacer en KOP y en FUP con la instruccin MOVE.
Veamos como lo haramos:

Solucin en KOP
Solucin en FUP
En esta instruccin podemos encontrar alguna diferencia entre la programacin en AWL y

las programaciones grficas KOP y FUP.
En lista de instrucciones dijimos que las instrucciones L y T eran incondicionales.

Ahora en la programacin en KOP y en FUP, vemos que en las cajas de programacin
aparecen unos parmetros que se llaman EN y ENO. Lo que nosotros pongamos en EN
ser la condicin que habilite la funcin que estamos dibujando a continuacin. Esto nos
sirve igual para la instruccin MOVE que para cualquier otra. En KOP y en FUP todo lo
podemos hacer condicional. Slo tenemos que rellenar en el parmetro EN la condicin
que queramos.
Adems tenemos el parmetro ENO. Si rellenamos aquello con algn bit, ste se
activar cuando se est realizando correctamente la funcin que tenemos programada.
En este caso la carga y transferencia.

2. 2. Formatos de carga, operaciones de salto y metas
Teora
Nosotros podemos introducir valores en las palabras, bytes o dobles palabras. Veamos
como podemos cargar valores.
Para introducir datos en el acumulador, lo podemos hacer con diferentes formatos. Haga-
mos un repaso de los que hemos visto hasta ahora.
L C#...... Cargar una constante de contador.
L S5T#...... Cargar una constante de tiempo.
L .......... Cargar una constante decimal.
Veamos cuatro formatos nuevos:
L 2#........ Cargar una constante binaria.
L B#16#...... Cargar 8 bits en hexadecimal.
L W#16#....... Cargar 16 bits en hexadecimal.
L DW#16#......... Cargar 32 bits en hexadecimal.
El autmata por defecto, va leyendo una instruccin detrs de otra. Mientras no le digamos
lo contrario esto es lo que va a hacer. Nosotros podemos intercalar en nuestro programa instruc-
ciones de salto. De este modo le decimos al autmata que se vaya a ejecutar un trozo de progra-
ma determinado, al que nosotros le habremos puesto un nombre (metas). El nombre de las metas,
tiene que estar compuesto como mximo de cuatro dgitos de los cuales el primero necesariamen-
te tiene que ser una letra.
Para saltar, tenemos dos instrucciones:
SPA: Salto absoluto.
SPB: Salto condicional.
Estas instrucciones nos sirven para saltar a trozos de programa que se encuentren dentro
del mismo bloque en el que nos encontramos. Con estas instrucciones no podemos ir de un blo-
que a otro.
Nos sirven para todo tipo de bloques de programacin.

Ejercicio resuelto
TEORA PREVIA:Definicin de metas. Final BEA. Formatos binario y hexadecimal. Saltos.
Queremos hacer dos contadores. Si el contador n 1 tiene un valor ms grande que el con-
tador n 2, queremos que se enciendan todas las salidas. Si el contador n 1 tiene un valor ms
pequeo que el contador n 2, queremos que se enciendan solamente las salidas pares. Si los
dos contadores tienen el mismo valor queremos que se apaguen todas las salidas.
SOLUCIN EN AWL
U E 0.0
ZV Z 1
U E 0.1
ZR Z 1
U E 1.0
ZV Z 2
U E 1.1
ZR Z 2
L Z 1
L Z 2
<I
SPB MENO
>I
SPB MAYO
==I
SPB IGUA
BEA
MENO: L W#16#5555
T AW 4
BEA
MAYO: L W#16#FFFF

T AW 4
BEA
IGUA: L 0
T AW 4
BE
Hay que tener en cuenta siempre poner un BEA antes de empezar con las metas, y otro
BEA al final de cada una de las metas.
En la ltima meta dejamos slo el BE ya que es la ltima instruccin del programa y la fun-
cin del BE y la del BEA es la misma.
Veamos las soluciones en KOP y en FUP.

Solucin en KOP:




Solucin en FUP:



Hemos visto las soluciones en KOP y en FUP.
En estos dos lenguajes, no hubiera sido necesario el uso de las metas. La carga y la trans-
ferencia la podamos haber hecho condicional con los resultados de las comparaciones de los
valores de los contadores. El programa hubiera quedado ms corto. Lo que hemos hecho aqu ha
sido exactamente el mismo programa en cada uno de los tres lenguajes para ver como hacemos
lo mismo en los diferentes lenguajes.

2. 3. Bloques de datos (DBs)
Teora
Un bloque de datos es una tabla en la que almacenamos datos. Aqu no vamos a progra-
mar nada. Los datos los podemos almacenar en distintos formatos.
Para guardar un dato, tenemos que poner nombre a la variable, definir el formato en el
que lo queremos, y el valor inicial.
El valor inicial siempre es el mismo. Su propio nombre ya lo indica, es el valor inicial.

Cuando este valor cambie, se almacenar en otra columna que es el valor actual. Aunque al abrir
el DB no veamos esta columna, tenemos que tener en cuenta que tambin existe.
Para poderla ver, tenemos que ir al men Ver > datos.
Veremos los datos actuales de la programadora o del autmata dependiendo de si esta-
mos en ONLINE o en OFFLINE. Los datos actuales de la programadora siempre sern los mismos
que los iniciales. (Siempre y cuando no los cambiemos nosotros). La programadora no ejecuta el
programa. Los datos actuales del autmata, sern los ltimos datos que haya puesto la ejecucin
del programa.
Tenemos que tener en cuenta que esta columna de valor actual tambin la transferimos
tanto de ONLINE a OFFLINE como al contrario.

Ejercicio resuelto.
TEORA PREVIA: Saber crear un bloque de datos.
Vamos a crear un bloque nuevo. Vamos a hacer un bloque de datos. En estos bloques lo
nico que vamos a introducir son datos. No vamos a programar nada. Va a ser una tabla con da-
tos los cuales podemos leer y podemos escribir nuevos valores en los datos.
Para crear un DB vamos al administrador de SIMATIC. Nos situamos en la parte izquierda

encima de donde pone bloques. Lo podemos hacer tanto en ONLINE como en OFFLINE. En la
parte derecha tenemos todos los bloques que tenemos creados hasta ahora.
Tenemos que insertar un bloque nuevo. Pinchamos en la parte derecha con el botn dere-
cho del ratn y aparece una ventana donde le decimos que queremos insertar un nuevo objeto.
Tambin lo podemos hacer en el men de Insertar que tenemos en la barra de herra-

mientas.
Insertamos un bloque de datos.
Figura 26. Insercin de un bloque de datos

Cuando entramos en el nuevo DB vemos que nos ofrece tres posibilidades. Podemos hacer
un DB asociado a una FB, podemos hacer un DB asociado a un UDT, y podemos hacer un DB
simple.
Figura 27. Seleccin del tipo de DB.
En principio lo que queremos hacer es un DB simple.
Una vez lo tenemos creado veremos que sale el icono del DB junto con los dems blo-
ques.
Le podemos dar el nmero de DB que nosotros queramos. Por ejemplo podemos hacer el
DB 1.
Entramos en el DB y vamos a rellenarlo.
El DB es una tabla en la que tenemos que rellenar los datos. Tenemos varios campos para
rellenar.
Figura 28. Tabla de declaracin de variables de un DB.

El primer campo que tenemos es la direccin. De esto no nos tenemos que preocupar. Es
automtico. Conforme vayamos creando datos, se le van asignando las direcciones que corres-
ponden.
El siguiente campo es el nombre. Es obligatorio dar un nombre a cada dato que vayamos a
introducir.
A continuacin tenemos que definir el tipo de datos que va a ser. Si no sabemos como de-
finir un tipo de datos pinchamos en la casilla correspondiente con el botn derecho del ratn y
podemos elegir el tipo de datos que queremos.
Figura 29. Definicin del tipo de datos
A continuacin tenemos que definir el valor inicial. Tenemos que poner el valor en el for-
mato que corresponde. Si no sabemos el formato o no queremos ningn valor inicial, por defecto
nos pone un 0, pero escrito en el formato correcto.
Ya tenemos el primer dato definido.
Vamos a crear la siguiente tabla:
VALOR_1 INT 0
VALOR_2 REAL 3.0
VALOR_3 WORD W#16#0
Esto en un DB quedara de la siguiente manera:

Figura 30. Aspecto de DB con 3 variables declaradas
Ya tenemos un DB. Vamos a ver ahora como trabajamos con l.
Vamos a leer el valor 3.0, y vamos a escribir un valor en VALOR_3.
Para acceder a los datos de un DB tenemos dos posibilidades. Podemos abrir primero un
DB y luego acceder directamente a la palabra de datos, o podemos decir cada vez a que DB y a
que palabra de datos queremos acceder.
AUF DB 1 L DB1.DBW 0
L DBW 0 T MW 10
T MW 10 BE
BE
Para acceder a un dato, le llamamos DB.... Puede ser DBB si es un byte, DBW si es una
palabra, DBD si es una doble palabra o DBX 0.0 si es un bit.
Tambin podemos dar un nombre al DB y acceder a los datos por su nombre. Por ejemplo
en el DB que hemos creado antes podramos acceder a los datos del siguiente modo:
L DATOS.VALOR_1
DATOS es el nombre del DB y VALOR_1 es el nombre del dato.
Vamos a ver como leemos un valor y lo metemos en una marca, y como escribimos un va-
lor y luego lo vamos.
Vamos a leer el valor 3.0 que tenemos en VALOR_2 y vamos a ponerlo en la doble palabra
de marcas 100. Tiene que ser en una doble palabra de marcas porque es un nmero real.
AUF DB 1
L DBD 2
T MD 100

Ahora vamos a escribir un valor en VALOR_3.
L 8
T DB1.DBW6
BE
Hemos metido un 8 en este valor.
Vamos a entrar en el DB y vamos a ver como vemos este nuevo dato que hemos introdu-
cido.
Entramos en el DB y lo nico que vemos es la columna de valores iniciales. Aqu vamos

que sigue habiendo un 0.
Si vamos al men de Ver tenemos la opcin de Ver > datos.
Vemos que el DB tiene una nueva columna que es la de datos actuales. Aqu veremos que
tenemos el nuevo valor. Esta pantalla no refresca valores. Hace una lectura cuando abrimos la
ventana. Si hacemos algn cambio y queremos visualizarlo, tendremos que cerrar y abrir de nue-
vo la pantalla.
Para ver el dato que acabamos de introducir, tenemos que hacer la operacin en ONLINE.
Si vamos a ver datos en OFFLINE, veremos los datos actuales de la CPU del PC. El PC no ha
ejecutado programa. Veremos que los valores iniciales son los mismos que los actuales.
Tenemos que tener en cuenta que estos valores se guardan en disco duro. Cada vez que
transfiramos el programa bien de OFFLINE a ONLINE o viceversa, tambin se transfieren los valo-
res actuales.
Inicializacin de un DB.-
Si queremos dejar el DB como estaba al principio con sus valores iniciales para comenzar
el proceso de nuevo, vamos al men de edicin y tenemos la posibilidad de reinicializar bloque de
datos. Los valores actuales se cambian por los valores iniciales. A partir de ah hace lo que se le
diga por programa.
Si el DB ha adquirido unos valores distintos de los iniciales los guarda en esta columna de
valores actuales. Cada vez que transferimos al autmata el DB tambin estamos transfiriendo esta
columna de valores actuales aunque no la veamos.
Si queremos volver a los valores iniciales no tenemos ms remedio que reinicializar el DB y

transferir estos cambios al autmata.
Si estamos programando en KOP o en FUP, tendremos que utilizar la instruccin MOVE

para leer o escribir datos en el DB.


2. 4. Pesar productos dentro de unos lmites
Ejercicio resuelto
TEORA PREVIA: Creacin y manejo de DBs.
Tenemos una cinta transportadora que lleva los productos. Lo que queremos es que los
productos que se salgan del peso estipulado tanto por arriba como por abajo, se desechen.
Adems tenemos unas luces indicadoras de producto bueno o de producto malo. Quere-
mos que mientras est la pieza debajo de la clula detectora, se encienda la luz correspondiente.
E E 1.2 A 4.1
BUENA
E1.0 E1.1 MALA
A 4.2
A 4.0 A 4.7
Figura 31. Esquema de sistema de control de pesos.
Para ello vamos a tener en un mdulo de datos los lmites de peso tanto superior como in-
ferior.
Con el byte 0 de entradas vamos a simular los pesos de las piezas que circulan por la cin-
ta. Queremos que cuando la pieza tenga un peso comprendido entre los lmites correctos se en-
cienda una luz que nos indique que la pieza es correcta. Cuando pase una pieza que su peso se
salga de los lmites queremos que nos indique una luz que la pieza es mala y a la vez que se abra
una trampilla para que la pieza salga de la cinta.
SOLUCIN AWL

U E 1.0 //Cuando le demos al botn de marcha
S A 4.0 //Pon en marcha la cinta transportadora
U E 1.1 //Cuando le demos al botn de paro
R A 4.0 //Para la cinta
U E 1.2 //Cuando pase la pieza por la balanza
SPB M001
R A 4.1 // Si no hay pieza manten todo apagado.
R A 4.2
R A 4.7 //Salta a la meta 1
BEA //Si no hay pieza termina el programa
M001: L EB 0 //Carga el peso de la pieza
L DB1.DBW0 //Carga el lmite superior de peso
<I //Si la pieza pesa menos que el limite sup.
= M 0.0 //Activa la marca 0.0
L EB 0 //Carga el peso de la pieza
L DB1.DBW2 //Carga el lmite inferior
>I //Si la pieza pesa ms que el limite inf.
= M 0.1 //Activa la marca 0.1
U M 0.0 //Si est activa la marca 0.0
U M 0.1 //Y est activa la marca 0.1
S A 4.1 //Enciende la luz de pieza buena
R A 4.2 //Apaga la luz de pieza mala
NOT //En caso contrario
S A 4.2 //Enciende la luz de mala
R A 4.1 //Apaga la luz de buena
U A 4.2 //Si la pieza es mala
= A 4.7 //Abre la trampilla de desecho
BE

Hemos visto como hacer una carga y una transferencia condicionada por una entrada. Pa-
ra hacerlo condicional lo podemos hacer de dos maneras. Bien lo hacemos como en este ejemplo
utilizando metas, o bien lo hacemos con llamadas a otros mdulos de modo condicional.
Si se cumple la condicin salta al mdulo que le digamos y all tendremos la carga y la

transferencia. Si no se cumple la condicin no salta al mdulo en cuestin y por tanto no lee las
instrucciones de carga y transferencia.
Para completar el ejercicio, nos falta hacer el mdulo de datos donde vamos a guardar el
lmite superior y el lmite inferior de pesado para las piezas.
Vamos a crear el DB1.
En el DB1 vamos a crear dos palabras de datos. Tenemos que definir un tipo para cada
uno de los datos. En este caso van a ser dos nmeros enteros. Diremos que son de tipo (INT).
Tambin podemos suponer que son valores reales. Para ello lo deberamos haber tenido
en cuenta a la hora de programar.
Para comparar nmeros reales tenemos otra instruccin, y adems los nmeros reales se
guardan en dobles palabras, no en palabras simples.
Para guardar los datos deberamos haber utilizado la doble palabra de datos 0 y la doble
palabra de datos 4.
Veamos como quedara el DB.
Figura 32. Declaracin de DB de lmites de peso
Ejercicio propuesto: Hacer este mismo ejercicio en KOP y en FUP.
Todas las instrucciones necesarias se han visto en ejercicios anteriores.

2. 5. Introduccin a la programacin estructurada
Teora
Creacin de FCs sin parmetros.
Queremos que si la entrada E 0.0 est activa funcione una parte del programa. Y que si no
est activa funcione la otra parte del programa.
Para ello vamos a hacer dos mdulos FC y desde el OB indicaremos cuando tiene que ac-
ceder a uno y a otro.
Para crear las 2 FCs, lo hacemos del mismo modo que hicimos para crear un nuevo DB.
En este caso insertamos una funcin.
Figura 33. Insercin de bloques FC (Funciones)
Una vez tengamos creadas las dos FCs ya podemos entrar en ellas y hacer su programa.
SOLUCIN AWL:
OB1:
U E 0.0
CC FC 1 //Llamada condicional.
UN E 0.0
CC FC 2 //Llamada condicional.
BE

FC1:
U E 1.0
= A 4.0
BE
FC2:
U E 1.1
= A 4.1
Hemos visto que para hacer llamadas condicionales a FCs sin parmetros en AWL, tene-
mos la instruccin CC. Si quesiramos hacer una llamada a una FC sin parmetros pero de modo
incindicional, utilizaramos la instruccin UC.
Veamos como podramos hacer esto en KOP y en FUP.
Para hacer la llamada, tenemos que abrir el catlogo, y seleccionar la funcin a la que que-
remos llamar.
Figura 34. Seleccin de la FC a llamar en KOP

Si queremos hacer la llamada de modo condicional, solo tenemos que rellenar el parme-
tro EN con la condicin que queramos.
En FUP haramos exactamente lo mismo.
2. 6. Desplazamiento y rotacin de bits.
Teora
Tenemos 6 instrucciones para desplazar y rotar bits.
SLW Desplazar palabra a la izquierda.

SRW Desplazar palabra a la derecha.
SLD Desplazar doble palabra a la izquierda.
SRD Desplazar doble palabra a la derecha.
RLD Rotar doble palabra a la izquierda.
RRD Rotar doble palabra a la derecha.
Estas instrucciones se gastan seguidas de un nmero que indica la cantidad de posiciones

que se tienen que mover los bits.
Veamos un ejemplo y cmo funcionara:
L MW 0
SLW 2
T MW 2
Supongamos que en la MW 0 tenemos lo siguiente: 0001 1010 0011 0101
Al ejecutar este programa veamos lo que ocurrira en el acumulador:
Con la primera carga lo que tendramos en el acumulador sera:
0001 1010 0011 0101
La siguiente operacin que hacemos en el acumulador es el desplazamiento:

0001 1010 0011 0101
0110 1000 1101 0100 00
Figura 35. Desplazar una palabra a la izquierda dos bits
Al desplazar, se mueven todos los bits dos posiciones a la izquierda, y por la parte derecha
entran dos ceros.
Si en lugar de desplazar lo que hacemos es rotar, lo que ocurre es que lo que se

pierde por un lado entra por el lado contrario. Esta operacin la hace en el acumulador. Slo po-
demos rotar dobles palabras porque el acumulador es de 32 bits.

2. 7. Planta de embotellado
Ejercicio resuelto
TEORA PREVIA: Desplazamiento y rotacin de bits. Programacin estructurada.
Tenemos una planta de embotellado distribuida de la siguiente manera:
10.6 10.5 10.4 10.3 10.2 10.1 10.0 11.7 11.6 11.5 11.3 11.0
Figura 36. Esquema de planta de embotellado
Vemos que en la lnea tenemos tres mquinas. Una taponadora, una lacadora y una sella-
dora.
Queremos que cuando las botellas lleguen debajo de las mquinas, stas se pongan en
marcha, pero si llega un hueco no queremos que las mquinas acten.
Las botellas pasan de posicin a posicin cada segundo. Con la clula fotoelctrica que
tenemos detectamos cuando pasa una botella o cuando pasa un hueco.
Vamos a resolver el problema utilizando 4 FCs y una OB1.
En cada FC vamos a programar una de las operaciones que necesitamos realizar. Des-
pus desde la OB 1 diremos cuando necesitamos realizar cada una de la operaciones.
En la primera FC vamos a hacer un generador de pulsos de un segundo para poder mover

las botellas.

En la siguiente FC vamos a meter 1 en el lugar donde van las botellas. Es decir cada vez
que la clula fotoelctrica detecte que ha pasado una botella colocar un 1 en su lugar correspon-
diente. Luego desde otra FC ya veremos cmo tenemos que mover ese 1.
En otra FC vamos a programar el desplazamiento de los bits.
En otra FC vamos a hacer la activacin de las mquinas cuando lleguen las botellas deba-
jo de ellas

Ahora nos queda organizar cundo se tienen que efectuar cada una de estas FC. Desde el
OB1 diremos cuando se tiene que ejecutar cada una de las FC.

En la programacin estructurada, hacemos cada cosa en bloque. De este modo la progra-

macin se hace mucho ms sencilla.
Para programar cada una de las FCs slo nos preocupamos de programar la maniobra o
la accin que queremos hacer. No nos preocupamos de cuando la tiene que hacer.
Despus desde la OB1 ya pensaremos cuando se tiene que ejecutar cada una de las ope-
raciones que hemos definido.
Ejercicio propuesto: resolver este ejercicio en KOP y en FUP con las instrucciones que
hemos visto en ejercicios anteriores.

2. 8. FCs con y sin parmetros
Teora
Cuando programamos una FC tenemos que llamarla desde algn sitio para que se ejecu-
te.
A continuacin vamos a hacer una FC que sume 2 + 3, y otra FC que sume A + B.
Cuando estamos sumando 2 + 3, estamos haciendo una FC sin parmetros. Siempre su-
ma lo mismo y el resultado siempre ser 5.
Para llamar a esta FC podemos utilizar dos instrucciones:
UC FC 1 Llamada incondicional.
CC FC 1 Llamada condicional.
De este modo se ejecuta la funcin de manera condicional o incondicional, con los datos
que hemos definido dentro de la propia FC.
Cuando estamos sumando A + B, estamos haciendo una FC parametrizable. Cada vez que
la llamemos, tendremos que darle unos valores a A y a B para que el autmata sepa lo que tiene
que sumar.
Para darle estos valores, lo que tenemos que hacer es llamar a la FC con CALL FC 1.
Al hacer la llamada de este modo, el programa accede a la FC y nos pide todos los par-
metros de entrada y salida que hayamos definido. Entonces nosotros le damos los valores que
queremos que sume cada vez que le llamamos.
Una vez la tenemos programada, la podemos llamar tantas veces como queramos. La ins-
truccin CALL que utilizamos para llamar a las FC con parmetros, es siempre incondicional.
Veamos a continuacin un ejemplo de FC con parmetros.

Ejercicio resuelto
TEORA PREVIA: Diferencia entre llamadas a FC con y sin parmetros.
Vamos a hacer dos FC similares. Van a ser dos bloques que van a realizar la misma ope-
racin pero en una de ellas va a ser con unos valores fijos, y en la otra va a ser parametrizable.
Veamos el primero de los casos:
Para crear una FC nueva, vamos a la ventana del administrador de SIMATIC. Pinchamos
en la parte izquierda encima de bloques. En la parte derecha pinchamos con botn derecho y co-
gemos la opcin de insertar nuevo objeto. Insertamos una funcin.
Una vez tenemos la FC1 hecha, tenemos que programarla.
Esta funcin va a sumar 3 + 2 y el resultado nos lo va a dejar en la palabra de marcas

AW4.
Siempre que se ejecute est funcin nos sumar los mismos valores.
Para que la funcin se ejecute, alguien tendr que llamarla. Si no, la CPU slo ejecuta la
OB1.
Desde la OB1 tendremos que hacer una llamada a una FC sin parmetros.
Tenemos dos posibilidades de hacer la llamada. Podemos hacer una llamada condicional o
incondicional.
Podramos hacer lo siguiente:
OB1
U E 0.0
CC FC 1
BE
O bien hacer lo siguiente:

OB1
UC FC 1
BE
Son los dos tipos de llamada que tenemos para funciones sin parmetros. Con el primer
bloque accedera a la FC 1 siempre y cuando estuviera la entrada E 0.0 activa.
En el segundo caso, accedera siempre a la FC 1.
Vamos a ver como podramos hacer una FC parametrizable. Esto quiere decir que no
siempre tendra que sumar los mismos valores.
Cuando entramos en la FC vemos que en la parte superior hay una tabla. En esta tabla es
donde tenemos que definir los parmetros.
Figura 37. Tabla de declaracin de variables de una FC
Vemos que tenemos varios campos para definir cosas.
Tenemos una lnea de IN, otra de OUT, otra lnea de IN/OUT y otra lnea de TEMP.
La de IN sirve para definir los datos de entrada a la funcin.
La lnea de OUT sirve para definir las salidas de la funcin.
La lnea de IN/OUT sirve para definir los valores que dentro de la funcin pueden ser entradas y
salidas.
La lnea de TEMP sirve para definir valores intermedios. Son valores que no son entradas ni
salidas de la funcin. Son resultados intermedios que no nos interesa ver desde fuera de la fun-
cin.

En nuestro caso vamos a tener dos valores de entrada y un valor de salida.
Confeccionamos la tabla de la siguiente manera:
Figura 38. Datos de entrada/salida declarados en una FC
A cada una de las variables, tenemos que definirle un tipo. En este caso son todas de tipo
entero.
A la hora de programar haremos lo siguiente:
La almohadilla no la escribimos nosotros. Esto nos indica que es una variable local. Slo la
podemos utilizar con su nombre dentro de la FC 1 que es donde la hemos definido.
De este modo tenemos una funcin que suma nmeros enteros pero no le hemos dicho
qu nmeros. Cada vez que la utilicemos sern nmeros distintos.
A la hora de llamar a la funcin tendremos que decirle cuanto vale cada valor.

Vemos que para hacer una llamada a una FC con parmetros, hay que utilizar la instruc-
cin CALL.
Cuando utilizamos esta instruccin el programa va a ver los parmetros que tiene definidos
esa funcin y nos pide los valores de estos parmetros.
Slo nos pide los valores de lo que hayamos definido como entrada o como salida.
Lo que hayamos definido como temporal no nos lo pide. Lo que hemos definido como tem-
poral, son resultados intermedios que nosotros no tenemos que darles ningn valor.
Al hacer esta llamada, la FC 1 se ejecuta con los valores que le hemos dado. Hace la su-
ma correspondiente, y el resultado nos lo deja donde le hemos dicho.
Cuando sale de la FC 1, ya no se acuerda de los valores que le hemos dado. Cada vez
que tengamos que ejecutar la FC 1, tendremos que darle de nuevo unos valores.
Si tenemos una FC con parmetros y hacemos una llamada como si fuese una FC sin pa-
rmetros la CPU se ir a STOP. Si una FC tiene parmetros, le tendremos que decir en la llamada
cuanto valen los parmetros para que pueda ejecutar la operacin. Si no es as no puede ejecutar
nada.
Por ejemplo, en el caso que tenemos en este ejemplo, la FC realiza una suma. Si no le de-
cimos los valores que tiene que sumar y dnde me tiene que dejar el resultado, no lo podr hacer.
Veamos como hacemos una FC que sume en KOP y en FUP y vemos como la llamamos y
le rellenamos los parmetros.

Solucin en KOP
La solucin en FUP sera igual.
Como podemos observar, en KOP y en FUP todo puede ser condicional. Basta con poner
una condicin en el parmetro EN.

2. 9. Sistemas de numeracin
Teora
Los sistemas de numeracin ms usuales en la programacin son el sistema decimal, el

sistema binario, y el sistema hexadecimal. Tambin utilizaremos el sistema binario codificado en
BCD.
Veamos las razones por las cuales se gastan estos sistemas de numeracin.
El sistema decimal, lo utilizamos porque es el ms corriente para nosotros. Es el que ms

dominamos y el que ms fcil nos resulta de entender.
El sistema binario es el sistema que utilizan los PLC. Se compone de 1 y 0 que es real-
mente lo que ocurre en las mquinas. Hay tensin o no hay tensin.
El sistema hexadecimal lo utilizamos como sistema de paso. Traducir un nmero de binario

a decimal y viceversa, nos lleva un tiempo. No es una operacin inmediata para nmeros grandes.
En cambio para pasar de hexadecimal a binario y viceversa es una operacin inmediata. Muchas
veces sabemos lo que queremos en binario. Sabemos qu bits queremos que se activen pero no
sabemos a qu nmero corresponde en decimal. Para ello utilizamos el sistema hexadecimal que
tenemos que escribir menos y fcil de traducir y de entender.
Despus tenemos el sistema binario codificado en BCD. Es un sistema binario (ceros y

unos), pero tiene las ventajas del sistema hexadecimal a la hora de traducir a decimal que es lo
que a nosotros nos resulta ms cmodo.

o Sistema decimal:
Es el sistema al que estamos acostumbrados.
Se llama sistema decimal porque est hecho en base diez.
Veamos el significado de un nmero. Por ejemplo el 214.
2 1 4
102 101 100
El nmero 214 es: 2 * 100 + 1 * 10 + 4 * 1 = 214
Los dgitos 2, 1 y 4 corresponden a la cantidad de potencias de diez con el ndice del lugar
que ocupan, que tenemos que sumar.

o Sistema binario:
El sistema binario se forma exactamente igual que el sistema decimal slo que con poten-
cias de 2 y con dos dgitos.
Veamos a que nmero decimal corresponde el nmero binario 110.
1 1 0
22 21 20
Si hacemos la suma correspondiente nos queda:
1*4 + 1*2 + 0*1= 6
El 110 binario, representa el 6 decimal. Vemos que tenemos que calcular una serie de po-
tencias y despus efectuar la suma. Si tuviramos que traducir el nmero: 11101111000101011,
nos llevara un rato ver a qu nmero decimal corresponde.
Veamos cmo haramos la operacin inversa. Supongamos que tenemos el nmero 6 de-
cimal y queremos saber a qu nmero binario corresponde.
6 2
0 3 2
1 1 2
1 0
Vamos dividiendo por dos hasta que el resultado nos de cero. Los restos de abajo hacia
arriba son el nmero en binario. En este caso nos queda 110.
Vamos que tambin nos lleva un trabajo un poco costoso. Si quisisemos traducir el nme-
ro 29.856 nos llevara un rato de trabajo.
Por ello utilizamos el sistema hexadecimal.
o Sistema Hexadecimal

El sistema hexadecimal se forma a partir de potencias de 16 y con 16 dgitos.
Como no conocemos 16 nmeros para formar los 16 dgitos, utilizaremos letras. Los 16
smbolos del sistema hexadecimal son: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
Veamos a qu nmero decimal corresponde el nmero hexadecimal 2B1.
2 B 1
162 161 160
La suma a realizar sera: 2 * 162 + B * 16 + 1 * 1 = 2 * 256 + 11 * 16 + 1 = 689
Vemos que la sistemtica es la misma que para el sistema decimal y que para el sistema
binario.
Veamos cmo haramos la operacin inversa:
Tenemos el nmero 689 en decimal y queremos traducirlo a hexadecimal.
Hacemos lo mismo que con el sistema binario:
689 16
049 43 16
01 11 2 16
2 0

Vamos dividiendo sucesivamente entre dos hasta que el resultado de cero. Con los restos
de abajo hacia arriba tenemos el nmero hexadecimal.
En este caso tenemos: 2 11 1. Como estamos en hexadecimal tenemos 16 dgitos.

El 11 se representa por el dgito B. Luego el nmero hexadecimal que nos queda es 2B1 que es el
nmero inicial que tenamos.
Vemos que esto tambin nos lleva una faena.
Dnde est la ventaja del sistema hexadecimal?
La ventaja est en el paso de hexadecimal a binario y viceversa.
Veamos como escribiramos este mismo nmero en binario:
2 B 1
0010 1011 0001
El nmero en binario sera el 0010 1011 0001. Cmo hemos hecho la conversin? Vamos
traduciendo dgito a dgito. Cada dgito hexadecimal corresponde a 4 dgitos en binario.
Tenemos que componer una suma de las potencias 23, 22, 21 y 20
Nunca vamos a tener potencias mayores. Estos clculos los podemos hacer de cabeza.
Siempre son sencillos.
Veamos como haramos la operacin inversa.
Supongamos que tenemos el nmero binario 110010010 y queremos pasarlo a hexadeci-

mal. Lo primero que tenemos que hacer es dividirlo en grupetos de 4:
0001 1001 0010
Si nos faltan dgitos completar un grupeto de 4 aadimos ceros a la izquierda.
Ahora sabemos que cada grupeto de 4 corresponde a un dgito hexadecimal:
0001 1001 0010
1 9 2

Tenemos el nmero 192 hexadecimal. Vemos que la conversin es muy sencilla y por
grande que sea el nmero siempre la podemos hacer de cabeza.

o Sistema binario codificado en BCD:
Crear un nmero codificado en BCD es muy sencillo desde el sistema decimal. Es la mis-
ma sistemtica que pasar un nmero de hexadecimal a binario.
Veamos cmo pasamos el nmero decimal 27 a binario BCD.
2 7
0010 0111
El nmero 27 decimal es el nmero 0010 0111 en binario BCD.
Tenemos que tener en cuenta que no es lo mismo binario que binario BCD.
Por ejemplo veamos como traducimos el nmero 10 decimal a binario y a binario BCD.
Decimal 10 ----------------- Binario 1010 --------------- Binario BCD 0001 0000
En el cdigo BCD no existen todas las combinaciones de dgitos. En cambio en binario si.
Por ejemplo la combinacin 1101 no corresponde a ningn nmero en BCD.
Si intentsemos traducir quedara: 8 + 4 + 0 + 1 = 13
No podemos representar el nmero 13 en decimal con una sola cifra, luego 1101 no es
ningn nmero en cdigo BCD.
Si este nmero fuese binario normal correspondera al nmero 13 decimal.

2. 10. Carga codificada
Teora
o Carga de temporizadores y contadores codificada en BCD
Si nosotros queremos cargar el valor de un contador o de un temporizador, utilizaremos

instrucciones del tipo:
L T 1
L Z 3
Al ejecutarse este tipo de instrucciones, lo que ocurre es que se carga en el acumulador el

valor que en ese momento tengan los contadores o temporizadores en binario.
Existen otras instrucciones de carga como las que siguen:
L S5T#5S
L C#10
Que cargan el valor en el acumulador, pero codificado en BCD.
Si queremos comparar dos cosas, tendrn que estar en el mismo formato.
Para poder hacer esto, existen instrucciones como las que siguen:
LC T 1
LC Z 3
Estas instrucciones hacen una carga de los valores que tengan los contadores o tempori-
zadores, pero codificada en BCD.
Por ejemplo, si queremos comparar un temporizador con la cantidad de 10 segundos, ten-

dremos que cargar en el acumulador el temporizador en cuestin y los 10 segundos para poste-
riormente comparar.
Para ello tengo que tener en cuenta el formato en el que se carga en el acumulador cada
una de las cosas para comparar cosas iguales.

Ejercicio resuelto.
TEORA PREVIA: Carga de temporizadores y contadores. Binario codificado BCD.
Cuando nosotros hacemos un temporizador, escribimos las instrucciones siguientes:
U E 0.0
L S5T#5S
SE T 1
U T 1
= A 4.0
Posteriormente podemos utilizar la instruccin:
L T 1
Con esto estamos cargando el valor que tenga en ese instante el temporizador. Podemos
hacer lo que queramos con este valor.
Al escribir la instruccin L T 1, se carga en el acumulador el valor que tiene en ese

instante el temporizador. Se carga este valor en binario.
Si nosotros quisiramos comparar el temporizador con un valor de tiempo, haramos lo si-

guiente:
L T 1
L S5T#3S
<I
= A 4.1
Con esto lo que pretendemos hacer es que cuando el temporizador tenga un valor inferior
a 3 segundos, se active la salida 4.1.
Lo que ocurre si hacemos esto es que estamos mezclando formatos.
Al escribir la instruccin L S5T#3S, la carga se hace en BCD.
Veamos lo que ocurrira si quisisemos comparar un temporizador que va por 10 segundos

con el valor de 10 segundos. En realidad estamos comparando dos valores que son iguales.
Al poner L T 1, el valor que estaramos cargando sera:
10..........> 0000 0000 0000 1010
Esto es el nmero 10 en binario.

Al poner L S5T#10S, el valor que estaramos cargando sera:
10...........> BCD 0000 0000 0001 0000
Esto es un 10 en BCD. Si ahora escribimos la instruccin de comparar, el autmata no sa-

be que cada cosa est en un formato. Nosotros le hemos introducido dos series de ceros y unos y
ahora le preguntamos que si las series son iguales. Evidentemente nos dir que las series no son
iguales. La segunda serie nos dir que corresponde a un nmero mayor.
Para subsanar este problema, tenemos que decirle que haga las dos cargas en el mismo
formato.
Tendramos que programar de la siguiente manera:
L S5T#10S
LC T 1
=I
...........
De esta manera estamos haciendo una carga codificada del temporizador. El valor de los
10 segundos me lo hace por defecto en BCD. Ahora la carga del valor que tenga el temporizador
tambin me la va a hacer en BCD porque le he dicho que me haga una carga codificada.
Ahora ya estamos comparando dos cosas en el mismo formato.
Vamos a hacer un ejemplo. Vamos a hacer un temporizador que temporice 8 se-

gundos. Queremos que los primeros 3 segundos se active la salida 4.0 y los ltimos se-
gundos se active la salida 4.1.
SOLUCIN EN AWL
U E 0.0
L S5T#8S
SE T 1
L S5T#5S
LC T 1
<I
= A 4.0
>I
= A 4.1

BE
Esta instruccin no existe como tal en KOP ni en FUP. Veamos como podramos hacer es-
tas comparaciones en estos lenguajes.
Como podemos ver, el propio temporizador lleva dos parmetros de salida llamados DUAL
y DEZ. En este caso, en la MW20, tendremos el valor del temporizador codificado en BCD, y en la
MW30 tendremos el valor del temporizador en binario.

2. 11. Operaciones aritmticas con enteros
Ejercicio resuelto.
TEORA PREVIA: Instrucciones correspondientes a los nmeros enteros.

Vamos a hacer una FC en la que hagamos operaciones con nmeros enteros. Vamos a
hacer una FC parametrizable y le definiremos los parmetros que luego vayamos a utilizar en la
operacin. En la tabla de declaraciones le diremos de qu tipo son los valores
Tenemos que tener muy en cuenta el tipo de datos que estamos gastando y la operacin
que queremos realizar.
Por ejemplo, hay operaciones que son exclusivas de los nmeros reales. No podremos uti-
lizarlas con nmeros enteros. Por ejemplo no podremos utilizar la raz cuadrada, ni tampoco po-
dremos utilizar la divisin ni cualquier operacin tpica de nmeros reales.
Cuando realizamos una operacin, todos los operandos que intervienen tienen que tener el
mismo formato. Por ejemplo, si el resultado de una raz es un nmero real, lo que introduzcamos
para calcular la raz cuadrada tambin tendr que ser un nmero real.
Si no introducimos los datos en el formato correcto el autmata no realiza la operacin. No

se va a STOP.
Vamos a hacer una FC con varias operaciones con enteros.

Figura 39. FC con variables de entrada/salida
Este programa va a sumar lo que valga VALOR_A con lo que valga VALOR_B, al resultado
le va a resta el VALOR_C y el resultado final me lo va a dejar en la variable que se llama
RESULTADO.
Ahora tenemos que definirle cuanto vale cada valor.
Desde la OB 1 hacemos una llamada a la FC1

Si vamos a observar lo que tenemos en la MW 20, veremos que tenemos el valor 7. Es el
resultado de la suma.
Podemos probar toda clase de operaciones de nmeros enteros.
Lo que no podemos hacer son operaciones de nmeros reales. Por ejemplo, la divisin y
multiplicacin son operaciones de nmeros reales. Si nosotros queremos multiplicar dos por cua-
tro, tendremos que convertir primero estos nmeros a nmeros reales.
Todo este tipo de operaciones lo podemos hacer tambin en KOP o en FUP. Para poder
seleccionar las operaciones en estos otros lenguajes, abrimos el catlogo y vamos a ver las ope-
raciones de nmeros enteros. Este catlogo tambin nos sirve para acordarnos de como se escri-
ben las operaciones en AWL y saber las operaciones que tenemos disponibles.
Veamos las operaciones que podemos realizar. Las podemos realizar en cualquiera de los
tres lenguajes.
Figura 40. Operaciones aritmticas con enteros
Aqu vemos las operaciones que podemos realizar tanto en KOP como en FUP con nme-
ros enteros.

2. 12. Conversiones de formatos
Ejercicio resuelto.
TEORA PREVIA: Posibles formatos en STEP 7
Para realizar otro tipo de operaciones y sobre todo para mezclar operaciones de nmeros
reales con nmeros enteros, nos va a hacer falta muchas veces cambiar de formato las variables
que tengamos definidas.
Por ejemplo si queremos dividir 8 entre 4, tendremos que convertir estos nmeros enteros
en nmeros reales ya que la divisin es una operacin de nmeros reales.
Adems los nmeros enteros los tenemos en 16 bits y los nmeros reales los tengo en 32
bits. Tendremos que hacer una transformacin de longitud y luego una transformacin de formato.
Veamos las posibilidades que tenemos de cambio de formato:
BTI: Cambia de BCD a entero de 16 bits.
ITB: Cambia de entero de 16 bits a BCD.
DTB: Cambia de entero de 32 bits a BCD.
BTD: Cambia de BCD a entero de 32 bits.
DTR: Cambia de entero doble a real.
ITD: Cambia de entero a entero doble (32 bits).
Con estas operaciones, lo que hacemos son cambios de formato sin perder informacin. El
nmero que queda despus de la conversin es exactamente el mismo que antes de ella solo que
en otro formato.
Por ejemplo, con este tipo de operaciones no podramos convertir un nmero real en ente-
ro. Si tenemos el nmero 2.3, al pasarlo a entero tendramos que dejar un 2. Aqu si que estamos
perdiendo informacin. Las instrucciones ITR o RTB no existen. Estas operaciones en las que
despreciamos parte del valor las hacemos con estas otras instrucciones:
RND: Redondea al nmero ms cercano.
RND+: Redondea al nmero ms cercano por arriba. Queda en 32 bits.
RND-: Redondea al nmero ms cercano por abajo. Queda en 32 bits.
TRUNC: Corta la parte decimal. Queda un entero en 16 bits.
Para probar estas instrucciones haremos lo siguiente:

L 8
T MW 10
L MW 10
ITD
T MD 20
DTR
T MD 30
SQRT
T MD 40
TRUNC
T MW 50
Aqu estamos gastando instrucciones de ms, pero as podemos observar como se van si-
guiendo los pasos en las palabras de marcas.
Las operaciones las va realizando en el acumulador 1 y el resultado lo va dejando en el

acumulador 1. Podramos ejecutar todas las operaciones seguidas sin necesidad de transferir a
palabras de marcas. Esto lo hacemos para poder observar los valores que va guardando.
En la tabla de observar / forzar variables podemos ver cmo hace los cambios y en qu
se convierte el 8 inicial que hemos introducido.
Veamos donde tenemos todas estas operaciones en KOP y en FUP

Figura 41. Operaciones de conversin de formatos para enteros y reales

2. 13. Operaciones aritmticas con reales
Ejercicio resuelto
TEORA PREVIA: Instrucciones para realizar operaciones de nmeros reales.
Vamos a ver como realizamos las operaciones de nmeros reales.
Una forma de hacerlo es utilizar nmeros reales para todo. As no hay problemas de forma-
tos. Vamos a ver cmo haramos una divisin de reales.
Entraramos en una FC. En la tabla de declaracin definiramos los siguientes valores:
0.0 VALOR_A REAL
4.0 VALOR_B REAL
8.0 RESULTADO REAL
Si nos damos cuenta en las direcciones que nos ha asignado, veremos que cada real ocu-
pa una doble palabra.
Vamos a programar la FC:
L #VALOR_A
L #VALOR_B
/R // Ponemos R porque son reales.
T #RESULTADO
Ahora llamamos a esta FC desde el OB 1.
OB 1
CALL FC 1
VALOR_A:= 8.0
VALOR_B:= 4.0
RESULTADO:= MD 0
Los valores que le pongamos tienen que ser reales. Si queremos dividir 8 entre 4 como en
este caso, tenemos que escribir 8.0 y 4.0 para distinguir el 8 y 4 enteros del 8.0 y 4.0 reales.
El resultado lo tendr que dejar necesariamente en una doble palabra.

Ahora si queremos ver el resultado de la operacin, tendremos que ir a la tabla de obser-
var / forzar variable, y observar la MD 0 en formato real.
La MD 0 estar en el acumulador. Lo que habr all ser una serie de ceros y unos. Si no-
sotros observamos esto en binario veremos la serie de ceros y unos. Veremos algo parecido a
esto: 001111001...........
No sabemos a qu nmero corresponde. Nosotros sabemos que el resultado es 2. Para

nosotros es un entero pero en realidad el resultado de una divisin es siempre un nmero real. El
resultado es 2.0. Si observamos el resultado en formato decimal, veremos que sale un nmero
grandsimo que no corresponde al resultado. Lo que hace la tabla de observar es traducir literal-
mente la serie de ceros y unos a decimal. Esto no es lo que queremos ver.
Tendremos que decirle que queremos observarlo en formato real. As a la hora de traducir
ya sabe que una parte de los ceros y unos corresponde a la parte entera, y otra corresponde a la
parte decimal.
Si observamos en formato real, veremos que el resultado es 2.0
Si nos situamos con el cursor en el lugar donde tenemos que rellenar un parmetro, al pul-
sar F1 nos sale directamente la ayuda del tipo de datos que se nos est pidiendo en ese parme-
tro. Nos dice la longitud del tipo de datos, como se forma en el acumulador y un ejemplo de cmo
tenemos que escribirlo.
Veamos lo que haramos si quisisemos mezclar nmeros reales con nmeros enteros.
Ejemplo:
Por ejemplo, supongamos que queremos sumar 5+9 y hacer su raz cuadrada.
5 y 9 son dos nmeros enteros. En consecuencia el resultado de la suma ser un nmero

entero. Despus queremos hacer una raz que es una operacin de nmeros reales.
Vamos a programar una FC.

Figura 42. Programacin de FC con parmetros
Ahora hacemos la llamada desde el OB 1.
El resultado Es un nmero entero. Lo observamos en una palabra de marcas.
Hemos tenido que hacer dos cambios de formato. Tenamos que convertir un entero en un
real. En principio un entero est en 16 bits y un real son 32 bits. Primero hemos hecho un cambio
de tamao y luego un cambio de formato.
A la hora de sacar el resultado, lo hemos truncado para que nos vuelva a quedar un ente-
ro.
Ejercicio propuesto: Hacer varias de estas operaciones en KOP y en FUP con los instruc-
ciones que se han visto anteriormente.

2. 14. Control de un gallinero
Ejercicio resuelto.
TEORA PREVIA: Programacin estructurada, bloques de datos, flancos.
El PLC tiene que decidir las horas de luz y las horas de oscuridad que va a tener el galline-
ro.
Se trata de optimizar las horas de luz y las horas de oscuridad para obtener la mayor can-
tidad de huevos posible.
El funcionamiento del gallinero debe ser el siguiente:
Llevaremos el control de los huevos que ponen las gallinas.
En nuestro ejemplo, esto lo haremos con dos contadores.
Llevaremos la cuenta de los huevos que han puesto hoy en un contador, y los huevos que
pusieron ayer en otro contador.
Si hoy han puesto ms huevos que ayer, supondremos que las gallinas estn contentas.
Entonces lo que haremos ser disminuir en 8 los minutos de luz y los minutos de oscuridad. De
manera que les hacemos el da ms corto.
Si hoy han puesto menos huevos que ayer, supondremos que las gallinas estn tristes. En-
tonces lo que haremos ser aumentar en 5 los minutos de luz y los minutos de oscuridad. De ma-
nera que les hacemos el da ms largo.
Si hoy han puesto los mismos huevos que ayer, supondremos que las gallinas estn indife-
rentes. Entonces lo que haremos ser disminuir en 1 los minutos de luz y los minutos de oscuri-
dad. Iremos haciendo el da ms corto poco a poco hasta que pongan menos huevos.
Para estructurarnos la programacin haremos cada cosa en un bloque.
En principio haremos dos DBs para guardarnos los datos que luego vamos a utilizar. Ha-
remos un DB que se llame puestas, y all guardaremos los huevos que han puesto hoy y los hue-
vos que pusieron ayer.
A continuacin haremos una FC 1. All haremos los dos contadores para simular los hue-
vos que pusieron ayer y los huevos que han puesto hoy.
Desde esta FC, meteremos los valores en su correspondiente DB.

Haremos otro DB que se llame TIEMPOS. All meteremos los minutos iniciales de luz y de
oscuridad que van a tener las gallinas, y adems la cantidad de minutos de luz y de oscuridad que
tendramos que sumar o restar en su caso.
En otro FC haramos la comparacin de las puestas de huevos de ayer y de hoy, y efectua-

ramos la operacin correspondiente dependiendo de la comparacin.
Finalmente haramos una OB 1 para decidir cuando tenemos que acceder a cada uno de
los bloques que hemos hecho.
Veamos como quedara esto resuelto en AWL:
En el DB1 tendramos el control de la cantidad de huevos: DB DE PUESTAS
Figura 43. Declaracin DB de cantidad huevos
En el DB 2 tendramos el control del tiempo, DB DE TIEMPOS
Figura 44. Declaracin DB de control de tiempos

FC1
U E 0.0
ZV Z 1
U E 0.1
ZR Z 1
U E 1.0
ZV Z 2
U E 1.1
ZR Z 2
L Z 1
T PUESTAS.HUEVOS_HOY
L Z 2
T PUESTAS.HUEVOS_AYER
BE
FC2
L PUESTAS.PUESTAS_HOY
L PUESTAS.PUESTAS_AYER
>I
SPB CONT
<I
SPB TRIS
==I
SPB INDI
BEA
CONT: L TIEMPOS.MINUTOS_LUZ
L TIEMPOS.DATO_CONT
-I
T TIEMPOS.MINUTOS_LUZ
L TIEMPOS.MINUTOS_OSC
L TIEMPOS.DATO_CONT
-I
T TIEMPOS.MINUTOS_OSC
BEA
TRIS: L TIEMPOS.MINUTOS_LUZ
L TIEMPOS.DATO_TRIS
+I
L TIEMPOS.DATO_TRIS
+I
BEA
INDI: L TIEMPOS.MINUTOS_LUZ
L 1
-I
L 1
-I
BE

Ahora tenemos que hacer la OB1 para decir cuando tiene que acceder a cada una de las
FCs.
La FC1 la va a tener que estar haciendo siempre. Siempre tiene que estar vigilando si hay
un nuevo huevo y registrar la cuenta en su correspondiente DB.
La FC2 la tendr que hacer en realidad cada da. Tendramos que hacer un temporizador
con la suma de los minutos de luz y de oscuridad y cuando pase el da que haga la comparacin y
la suma o resta de los tiempos.
En nuestro caso haremos la comparacin cuando le demos a una entrada. As no

tendremos que esperar todo el da para comprobar si funciona.
OB1
UC FC 1
U E 0.5
FP M 0.0
CC FC 2
BE
Si no ponemos la instruccin de flanco, por deprisa que le demos a la entrada va a supo-

ner ms de un ciclo de scan, y la comparacin se va a hacer ms de una vez. Sumara o restara
en su caso ms de una vez y nos quedaramos sin tiempo en un instante.
Ejercicio propuesto: Resolver el problema en KOP y en FUP con las instrucciones vistas
anteriormente.

2. 15. Operaciones de salto
Ejercicio resuelto.
TEORA PREVIA: Explicacin de los saltos.

Tenemos muchos tipos de saltos. Vamos a probar unos cuantos tipos de saltos.
Hay algunos que coinciden con los que existan en S5. Hay otros que son nuevos.
Veamos los saltos que existen tanto en S5 como en S7.
SPA y SPB
En S5 son los saltos que utilizamos para saltar entre distintos bloques de programa. En S7
son los saltos que utilizamos para saltar a otros puntos de programa siempre dentro del mismo
bloque.
SPA y SPB no sirven en STEP 7 para saltar de unos bloques a otros. Para ello tenemos
las llamadas a otras FCs que hemos visto antes. Tenemos las llamadas condicionales y las lla-
madas incondicionales
El significado de los saltos es el mismo. El SPA es un salto absoluto, y el SPB es un salto

condicional, es decir, depende del RLO.
Veamos dos ejemplos:
U E 0.0 U E 0.0
= A 4.0 SPB M001
SPA M001 ..........
.......
En el primer caso siempre que se lea la instruccin se va a producir un salto a la meta 1.

En el segundo caso se saltar a la meta 1 si la E 0.0 est activa. En caso contrario no se produci-
r el salto.
Tenemos otros saltos como: SPB SPBN SPBB SPBNB SPO SPS
Si al salto SPB le aadimos una N, tenemos el salto SPBN. Estamos negando el significa-
do del salto SPB. Significa que saltara cuando no se cumpla la condicion.
Si al salto SPB le aadimos la letra B, tenemos el salto SPBB. Con este salto, saltamos
cuando se cumple la condicin y adems nos guardamos el valor del RLO en ese instante.
Tambin tenemos saltos combinados como el SPBNB.

Tambin tenemos los saltos que se refieren a operaciones matemticas.
SPZ Salta cuando el resultado es distinto de cero.
SPP Salta cuando el resultado es positivo.
SPO Salta cuando hay desbordamiento.
SPS Salta cuando hay desbordamiento.
SPZP Salta cuando el resultado es mayor o igual que cero.
SPU Salta cuando el resultado no es coherente.
Como salto nuevo en S7 que no exista en S5 tenemos el SPL.
El salto SPL es un seleccionador de posiciones.
Antes de utilizar el salto tenemos que cargar un nmero. Dependiendo del nmero que
pongamos aqu saltar a una meta o a otra. Si ponemos un nmero que se sale del rango, (canti-
dad de SPA que tenemos a continuacin del salto) saltar a una meta determinada. A la que indi-
camos en el salto SPL.
En el ejemplo que vamos a hacer, si nos salimos del rango no queremos que haga nada.
Haremos una meta en la que digamos que no haga nada.
Si nos vamos al catlogo de KOP o de FUP, veremos que no tenemos tantos tipos de sal-
tos. Slo tenemos el salto llamado JUMP. Con esta instruccin, saltaremos si se cumple la condi-
cin. En KOP y en FUP, siempre podemos poner delante de la instruccin que sea un contacto
con la condicin que queremos que se ejecute.
Nosotros saltaremos siempre con este salto y pondremos delante la condicin que quera-
mos.

Veamos en el catlogo dnde podemos encontrar los saltos en KOP / FUP.
Figura 45. Operaciones de salto en KOP
Tambin tenemos el salto JMPN. Esto significa que saltaremos cuando no se cumpla la
condicin precedente.
Para situar posteriormente las metas, tenemos LABEL.
En KOP y en FUP las metas las identificaremos por un nmero.

2. 16. Mezcla de pinturas
Ejercicio resuelto
TEPRA PREVIA: Saltos.
Queremos hacer una mezcla de pintura. Tenemos tres posibles colores para hacer.
El color ocre es el cdigo 1. El color verde es el cdigo 2. Y el color marrn es el cdigo 3.
Dependiendo del cdigo que introduzcamos queremos que la mezcla sea distinta.
Para formar el ocre queremos poner 60 gramos de amarillo, 20 gramos de azul y 20 gra-
mos de rojo.
Para formar el verde queremos 50 gramos de amarillo y 50 gramos de azul.
Para formar el marrn queremos 40 gramos de amarillo, 30 de azul y 30 de rojo.
Los colores los van a simular unas palabras de marcas. Es decir si queremos que se forme
el ocre, lo que queremos es que en la palabra de marcas 0 haya un 60, etc.
En el ejemplo, si seleccionamos como cdigo del color 0, saltar al primer SPA. En este
salto estamos diciendo que salte a la meta de ERRO. Si el cdigo del color es 1 saltar al segun-
do SPA. Es decir, saltar a la meta de OCRE. Si el cdigo del color es 2, saltar al tercer SPA. Es
decir, iremos a la meta de VERD. Por ltimo, si el cdigo de color es 3, saltaremos a la meta de
MARR.
SOLUCIN EN AWL
FC 1
0.0 COLOR INT
L #COLOR
SPL ERRO
SPA ERRO //Llegar aqu si el cdigo de color es 0
SPA OCRE //Llegar aqu si el cdigo de color es 1
SPA VERD //Llegar aqu si el cdigo de color es 2
SPA MARR //Llegar aqu si el cdigo de color es 3
ERRO: L 0 //Llegar aqu si el cdigo de color es otro valor

T MW 0
T MW 2
T MW 4
BEA
OCRE: L 60
T MW 0
L 20
T MW 2
L 20
T MW 4
BEA
VERD: L 50
T MW 0
L 50
T MW 2
L 0
T MW 4
BEA
MARR: L 40
T MW 0
L 30
T MW 2
L 30
T MW 4
BE
Cuando utilizamos el SPL no ponemos BEA antes de las metas. Directamente detrs de
los SPA que queramos poner, ponemos la meta a la que tiene que saltar en caso de que nos sal-

gamos de rango. A continuacin ponemos las metas que nosotros queremos definir para los sal-
tos SPA.
Ahora desde la OB 1 llamamos a la FC 1 y le decimos el color que queremos formar.
OB 1
CALL FC 1
COLOR:= 1
BE
Probaremos a formar los tres colores y en la tabla de observar/forzar variables veremos

como se van formando las mezclas dependiendo de los gramos que pongamos en cada una de
las palabras de marcas.
Veremos que si ponemos un cdigo de color que no existe, el programa no hace nada.
Estar haciendo lo que pone en la meta ERRO, que es finalizar el programa sin hacer nada.
Ejercicio propuesto: Realizar el programa en KOP y en FUP con las instrucciones vistas
anteriormente.

2. 17. Instrucciones NOT, CLR, SET y SAVE
Ejercicio resuelto
TEORA PREVIA: Introduccin sobre las instrucciones.
NOT: Invierte el RLO.
SET: Pone el RLO a 1 incondicionalmente. Cuando queremos que una instruccin condi-
cional se ejecute siempre, aadimos la instruccin SET justo antes de la instruccin en cuestin.
CLR: Pone el RLO a 0 incondicionalmente.
SAVE: Hace una copia en el registro BIE del valor actual del RLO.
Supongamos que tenemos el siguiente circuito:
La salida se activar si se cumple cualquiera de las tres condiciones. (Tres ramas)
En un momento determinado del programa nos puede interesar saber si la salida se activ
porque la condicin que se cumpla era la primera.
Despus de escribir las condiciones de la primera rama, escribiremos la instruccin SAVE.
Cuando queramos consultar si este bit est activo, escribiremos la instruccin: U BIE
Veamos como quedara el ejemplo resuelto en AWL.
U E 0.0
U E 0.1
SAVE
O(
U E 0.2

U E 0.3
O E 0.4
= A 4.0
U E 1.2
U E 1.3
= A 4.1
U A 4.0
U BIE
= A 4.7
BE
Si se activ la salida A 4.0 porque se cumpli la primera condicin, tambin se activar la

salida 4.7. Si la salida 4.0 se activ por cualquiera de las otras dos condiciones no se activar la A
4.7.
Estas instrucciones tambin las tenemos en KOP y en FUP. Lo que ocurre es que su utili-
zacin es diferente. El comando SAVE en KOP est definido como una bobina. Esto quiere decir
que tiene que ser un final de segmento. La rama por la que queremos controlar si pas la seal,
tenemos que dibujarla dos veces.
Tendremos que hacer tres segmentos.
En el primer segmento, dibujamos la primera rama y le asignamos el SAVE.
En el segundo segmento dibujamos el circuito que queremos resolver. Dibujamos las tres
ramas y la asignacin de la salida correspondiente.
En un tercer segmento, hacemos la consulta del bit guardado con el SAVE y le asignamos
la salida 4.7.
Si ahora traducimos esto a AWL veremos que tenemos ms cantidad de instrucciones. Si

queremos traducir lo que hemos hecho antes a KOP veremos que no es traducible.
Veamos como quedara resuelto en KOP.

KOP
En FUP se hara exactamente igual.

2. 18. Flancos
Ejercicio resuelto.
TEORA PREVIA: Concepto de flanco.

En ocasiones queremos detectar nicamente un flanco de subida o un flanco de bajada de
una seal. Queremos que solamente cuando se detecte uno de estos cambios sea cuando se
ejecute algo. No queremos que se est ejecutando la accin durante todo el tiempo que se cum-
ple la condicin.
Por ejemplo, tenemos una FC que hace un desplazamiento de bits. Queremos que haga el
desplazamiento cuando le demos a la entrada E 0.0.
Si escribimos:
U E 0.0
CC FC 1
BE
Mientras tengamos activa la E 0.0 estar saltando a la FC 1.Por rpido que hagamos el
cambio a la entrada seguro que se ejecuta ms de un ciclo de scan. Se har ms de un despla-
zamiento de bits.
Si queremos que slo lo haga una vez, deberamos utilizar los flancos.
U E 1.1
FP M 0.0
CC FC 1
BE
FC1
L EB 0
T MW 2
L MW 2
SRW 1
T AW 4
BE
Slo haremos el desplazamiento en el momento que pasemos la entrada de cero a uno.

La instruccin tambin la podemos gastar para cosas que no sean precisamente una en-
trada. Por ejemplo, queremos que se haga el desplazamiento cuando un contador pase a ser ma-
yor que otro.
La FC que tenamos seguir siendo la misma. En la OB 1 programaramos:
U E 1.0
ZV Z 1
U E 1.1
ZV Z 2
L Z 1
L Z 2
>I
FP M 0.0
CC FC 1
BE
En el momento en que Z1 pase a ser mayor que Z2 se har el desplazamiento de los bits.
Posteriormente aunque Z1 siga siendo mayor que Z2 ya no se har ms saltos.
Estas mismas instrucciones las tenemos en KOP y en FUP.
Para detectar un flanco positivo o negativo de la entrada E 0.0 lo haramos del siguiente
modo:
KOP


2. 19. Ajuste de valores analgicos
Teora
Vamos a hacer un ajuste de valores analgicos. Vamos a suponer que tenemos un tanque
de lquido que como mnimo va a contener 5 litros de lquido, y como mximo va a contener 400
litros.
Dentro del tanque vamos a tener una sonda de nivel con la que queremos saber los litros
de lquido que contiene.
400L
5L
Figura 45. Tanque
Por otro lado sabemos que nuestra sonda puede medir entre 0 y 27648 tericamente.
Lo primero que vamos a hacer es calcular el valor real al que podemos llegar con la entra-
da analgica que tenemos.
Vamos a transferir el valor de la entrada analgica a una palabra de marcas y vamos a ob-
servar el valor de la palabra de marcas.
L PEW 288
T MW 10
Una vez conozcamos el valor, vamos a hacer los clculos.
Lo nico que tenemos que hacer es una regla de tres. Para hacer los clculos tenemos
que tener en cuanta un par de cosas. Lo primero que tenemos que saber es que los valores reales
slo los podemos almacenar en dobles palabras.

Otra cosa importante que tenemos que saber es que no podemos hacer operaciones de
nmeros reales con nmeros enteros. Tenemos que tener mucho cuidado con los formatos. La
lectura de les entradas analgicas son nmeros enteros. Luego tendremos que hacer divisiones
que son operaciones de nmeros reales. Tendremos que cambiar de formato.
Vamos a ver como quedara el programa hecho:
SOLUCIN EN AWL
FC 3
IN VALOR_SONDA INT
IN NIVEL_SUPERIOR REAL
IN NIVEL_INFERIOR REAL
OUT VALOR_GRADUADO REAL
TEMP V_SONDA_REAL REAL
TEMP RANGO REAL
L #VALOR_SONDA
ITD
DTR
T #V_SONDA_REAL
L #NIVEL_SUPERIOR
L #NIVEL_INFERIOR
-R
T #RANGO
L #V_SONDA_REAL
L 27648.0
/R
L #RANGO
*R
L #NIVEL_INFERIOR

+R
T #VALOR_GRADUADO
BE
OB1
CALL FC 3
VALOR_SONDA:= #PEW288
NIVEL_SUPERIOR:= 400.0
NIVEL_INFERIOR:= 5.0
VALOR_GRADUADO:= MD 0
En la doble palabra de marcas podemos ver el valor graduado del nivel que est midiendo.
Es necesario que sea una doble palabra de marcas porque el valor que queremos observar es un
valor real. Es el resultado de operaciones reales.
Adems a la hora de observar el valor, lo vamos a tener que hacer en formato de nmero
real. Si lo intentamos ver en formato de nmero entero veremos un valor de algo que no sabemos
interpretar.
Veamos como resolveramos el mismo ejercicio en KOP y en FUP


Ahora tendramos que hacer la llamada desde el OB 1.
Ejercicio propuesto: Resolver el problema en FUP.

Ejercicio resuelto.
TEORA PREVIA: Manejo de analgicas.
Lo que hemos visto en el ejercicio anterior, tambin lo podemos hacer con unas FCs ya
programadas.
Estas FC las tenemos en una librera. Veamos como accedemos a ellas.
Primero vamos al men Archivo > Abrir > librera:
Figura 46. Abrir librera en STEP 7
Elegimos las Estndar Library de la versin 3
Figura 47. Tipo de librera a abrir

Vemos que la FC 105 se llama SCALE. Nos sirve para escalar valores analgicos. Esto es
lo mismo que hemos hecho en el ejercicio anterior.
Lo nico que tenemos que hacer es traer esta funcin a nuestro proyecto y hacer una lla-
mada. Rellenamos los parmetros que nos pide y ya tenemos la funcin hecha.
Al utilizar estas funciones ya hechas, tenemos una ventaja. Nos ofrecen informacin en
caso de producirse algn tipo de error en el escalado.

2. 20. UDTs en STEP 7 (USER DATA TYPE).
Ejercicio resuelto
TEORA PREVIA: Tipo de datos de usuario.

Vamos a suponer que tenemos que automatizar muchas mquinas de las cuales queremos
tener informacin de tres datos de cada una de ellas.
Queremos tener controlado su temperatura, el interruptor de marcha/paro, y la cantidad de
piezas que llevan hechas al da.
Para organizarnos los datos lo vamos a hacer utilizando los UDT.
Vamos a suponer que tenemos las mquinas distribuidas en dos polgonos. Dentro de ca-
da polgono tenemos tres plantas y dentro de cada planta tenemos 4 mquinas.
De cada una de esas mquinas tenemos que controlar los datos que hemos comentado
antes.
Para ello nos vamos a crear unos UDT del tipo que nos interese.
Para nosotros el UDT 1 va a ser el tipo de datos que asignaremos a cada una de las m-
quinas.
Para generar un UDT 1 tenemos que situarnos en el administrador de Simatic e insertar un

nuevo objeto tal y como lo habamos hecho antes para el resto de bloques.
En este caso insertamos un tipo de datos.
Figura 48. Insertar UDT
Veamos como quedara nuestro UDT 1.

Figura 49. Declaracin de estructura de UDT1
Ya tenemos definido un tipo de datos. Ahora cada mquina ser de tipo UDT 1.
Dentro de cada mquina estamos incluyendo implcitamente cada uno de los tres datos
que hemos dicho antes.
Ahora cada planta ser de tipo UDT 2.

Dentro de cada planta, estamos incluyendo implcitamente cuatro mquinas y sabemos
que dentro de cada mquina van sus tres datos.
Sin escribir demasiadas lneas tenemos un montn de datos acumulados.
Ahora tenemos que hacer el DB.
Primero vamos a la tabla de smbolos y le ponemos nombre al DB que vamos a gastar.
Le llamamos DATOS.
Dentro de datos ponemos:
Figura 52. Declaracin de estructura del DB
Dentro de cada una de estas lneas, estn implcitas tres plantas dentro de cada una de las
cuales hay cuatro mquinas, dentro de cada una de las cuales hay tres datos.
Ahora la ventaja que tenemos a parte de habernos ahorrado escribir muchos datos, es la
manera de acceder a los datos.
Si de memoria tenemos que saber en que direccin se encuentra cada uno de los datos,
tendramos que estar mirando cada vez el DB para saber a que direccin tenemos que acceder.
Ahora si dentro del DB seleccionamos el men Ver > datos veremos todos los datos que
hemos creado con el nombre que tienen.

Figura 53. Estructura del DB creado
Esto es parte del DB que hemos creado.
De este modo, podemos acceder por su nombre al dato que queramos. Por ejemplo, po-
demos acceder a la temperatura de la mquina dos de la planta tres del polgono 1 de la siguiente
manera:
DATOS.POLI1.PLANTA3.MAQ2.TEMP
De este modo no tengo por qu saber qu direccin tiene esta lnea dentro del DB. Accedo
a cada cosa por su nombre.
Vamos a ver como ejemplo cmo accederamos a dos de los datos que tenemos en el DB.
Por ejemplo vamos suponer que queremos poner en marcha una de las mquinas con la
entrada E0.0. (Mquina tres de la planta dos del polgono 1)
Esto corresponde a un bit. En consecuencia lo trataremos igual que cualquier bit.
U E 0.0
= DATOS.POLI1.PLANTA2.MAQ3.MARCHA
Si hacemos esto y luego vamos a observar el valor actual del mdulo de datos, veremos
que hemos introducido un uno en este bit.
Vamos a ver como leeramos una temperatura. Suponemos que la entrada analgica va a
ser la temperatura de la mquina.
L PEW 288

T DATOS.POLI1.PLANTA1.MAQ1.TEMP
Si quisiramos sacar este dato por la salida analgica, escribiramos:
L DATOS.POLI1.PLANTA1.MAQ1.TEMP
T PAW 288

2. 21. Operaciones lgicas con palabras
Ejercicio resuelto
TEORA PREVIA: Concepto de operacin lgica.
Podemos hacer operaciones lgicas con palabras. Las operaciones lgicas se realizan bit
a bit.
Las operaciones que podemos hacer son AND. OR y XOR.
Esto lo utilizaremos para hacer enmascaramientos de bits.
Las operaciones son las siguientes: UW, OW, XOW
Las utilizaremos de la siguiente manera:
L MW 0
L MW 2
UW
T MW 4
Tambin tenemos las instrucciones en el catlogo de KOP y de FUP.
Figura 54. Operaciones lgicas con palabras en KOP

A continuacin veremos un ejemplo en el que utilizaremos estas operaciones.

2. 22. Ejemplo de alarmas
Ejercicio resuelto
TEORA PREVIA: Concepto de operacin lgica.
Vamos a exponer un ejercicio en el que utilizaremos la operacin XOR. Si hacemos un
XOR entre dos palabras, el resultado que obtendremos ser:
Si los dos bits coinciden el resultado ser cero. Si los dos bits son distintos e, resultado
ser 1.
Veamos un ejemplo:
0001_1001_0101_0110
0101_0000_1110_1000
0100_1001_1011_1110
Si observamos el resultado, all donde veamos un 1 significa que en ese bit difieren las
dos palabras anteriores de las cuales hemos hecho una XOR
Supongamos que nosotros tenemos una serie de alarmas en la instalacin. Algunas de
ellas sern contactos normalmente cerrados y otros sern contactos normalmente abiertos. Unos
debern permanecer a uno para estar en estado correcto, y otros debern estar a cero para estar
correctamente.
Supongamos que la secuencia buena de las alarmas es la siguiente:
11100010
Lo que queremos es que en caso de que alguna alarma salte, parpadee la salida A4.0. y
adems nos indique la alarma que ha sido disparada en al byte de salidas 5.

Ejercicio propuesto: Resolver esto mismo en KOP y en FUP utilizando las instrucciones
vistas anteriormente.
Ejercicio propuesto: Hacer ejemplos utilizando las otras operaciones lgicas con palabras,
en cada uno de los tres lenguajes.

3. OPERACIONES DE SISTEMA.
3. 1. Deteccin de errores.
Teora.
Cuando el PLC se va a STOP o simplemente nos da un error, nos ofrece un men de in-
formacin donde nos dice cual es el problema por el cual se encuentra en este estado.
Vamos a hacer un ejemplo en el cual introduzcamos errores para que el PLC se vaya a
STOP y nos de un error y luego le pediremos informacin sobre el error.
OB 1
U E 0.0
CC FC 1
BE
FC 1
UC FC 2
BE
FC 2
U E 0.7
CC FC 4
BE
No le programamos la FC 4. Cuando est activa la E 0.0 y activemos la E 0.7, el PLC dar

un error y se ir a STOP.
Una vez lo tengamos en esta situacin vamos a ir al administrador de SIMATIC. Vamos a

pinchar en la parte izquierda encima de la CPU de ONLINE. En esta posicin vamos al men Sis-
tema destino y entramos en la opcin Informacin del mdulo.

Figura 55. Acceso al submen Informacin del mdulo
Se nos va a abrir una ventana con varias fichas.

Figura 56. Vista del bufer de diagnstico
Vamos a la ficha de Bufer de diagnstico. En esta ficha podremos ver las 100 ltimas
causas por las cuales el PLC se ha ido a STOP.
Como vemos se ha ido a stop porque le falta una FC.
A continuacin vamos a la ficha de Pilas. Aqu podemos ver el camino que ha seguido el
PLC antes de irse a STOP. En nuestro caso veremos que ha ejecutado el OB 1, ha saltado a la
FC 1, despus a la FC2, y se ha quedado colgado aqu.

Figura 57. Vista de la ficha Pilas
En la parte inferior izquierda, vemos que tenemos un botn que se llama USTACK. Si pin-
chamos all veremos el estado en el que estaba la CPU en el instante en el que se fue a Stop.

Figura 58. Vista de la pila USTACK
En la parte izquierda de la ficha nos da informacin del estado del PLC cuando se fue a
STOP. Adems tenemos un botn que dice Abrir bloque. Si pinchamos en este botn se abrir el
bloque que contena el error y nos sealar con el ratn la instruccin que contiene el error.
Adems tenemos otras fichas en las cuales nos da ms informacin del mdulo. Podemos
ver el tiempo mximo, el tiempo mnimo y el tiempo real del ciclo de scan.
Podemos ver la cantidad de memoria que estamos ocupando o el ciclo de scan que tena-
mos con nuestro programa, etc.

3. 2. Instruccin LOOP
Teora
Vamos a ver una instruccin nueva.
Es la instruccin LOOP. Esta instruccin permite hacer un pequeo bucle dentro de un

bloque. Permite repetir una serie de instrucciones varias veces sin terminar el bloque.
Veamos un ejemplo. Las instrucciones necesarias para utilizar la instruccin son las si-
guientes:
L 20
META: T MB 0
..............
..............
L MB 0
LOOP META
..........
Primero estamos cargando un 20. A continuacin viene la meta del LOOP. Cuando se lee
la instruccin LOOP, el PLC decrementa en una unidad lo que hay en el ACU 1. Si es distinto de
cero, salta a meta. En el momento en que al decrementar una unidad se encuentra con un cero,
ya no ejecuta ms saltos a la meta.
El byte de marcas cero, lo utilizamos por si dentro del bucle vamos a tocar lo que hay en el
ACU 1.
Antes de ejecutar ninguna instruccin en el bucle transferimos lo que hay en el acumulador

al byte de marcas cero. A continuacin trabajamos con el acumulador. Antes de la instruccin
LOOP, cargamos lo que hay en el byte de marcas cero. La propia instruccin LOOP decrementa
este nmero en uno. A continuacin cargamos de nuevo este nmero en el byte de marcas cero.
Si dentro del bucle no vamos a utilizar el acumulador, no son necesarias las instrucciones
de carga y transferencia.
Ejercicio resuelto
L 5
META: T MB 0
L 5
L MB 0
==I
S A 4.0
L 4
L MB 0
==I
S A 4.1
L 3
L MB 0
==I
S A 4.2
L 2
L MB 0
==I
S A 4.3
L 1
L MB 0
==I
S A 4.4
L 0
L MB 0
==I
S A 4.5
L MB 0
LOOP META
BE
Con esto veremos que se encienden las salidas 4.0, 4.1, 4.2 4.3 y 4.4. La 4.5 no se en-
ciende. Dentro del bucle la MB 0 nunca vale cero. Cuando vale cero ya no se ejecuta el bucle.
Con esto simplemente comprobamos que se ha ejecutado el bucle 5 veces.
Si en lugar de hacer 4 o 5 bucles le decimos que ejecute 50.000 bucles la CPU se ir a

stop. Si entramos en la informacin del mdulo veremos que se ha ido a buscar el OB 80 y al no
tenerlo se ha ido a stop.
Esta instruccin no la tenemos como tal en KOP ni en FUP. En caso de necesitar de una
instruccin as, tendremos que hacernos nosotros el funcionamiento a partir de las instrucciones
de salto que tenemos.
Veamos un listado de los OBs que tenemos disponibles y despus probamos a ejecutar-
los con ejemplos que contengan errores.
3. 3. Relacin de OBs. SFC's importantes
OBs
Los OBs son la comunicacin entre el sistema operativo de la CPU y el programa de
usuario. Con los OBs podemos:
o Arrancar la CPU.
o Ejecucin cclica o intermitente temporalmente.
o Ejecucin a determinadas horas del da.
o Ejecucin despus de transcurrir un tiempo preestablecido.
o Ejecucin al producirse errores.
o Ejecucin al producirse alarmas de proceso.
Cada uno de los OBs tienen una prioridad asignada.
Tenemos la posibilidad de cambiar nosotros esta prioridad. No se pueden ejecutar nunca

dos OBs a la vez.
Nmero OB Nombre OB

OB1 Principal.
OB10.........0B17 Alarmas horarias.
OB20.........OB23 Alarmas de retardo (SFC 32)
OB30.........OB38 Alarmas cclicas.
OB40.........OB47 Alarma de proceso.
OB80 Error de tiempo (SFC 43 redispara tiempo)
OB81 Fallo de alimentacin.
OB82 Alarma de diagnstico.
OB83 Alarma insertar/extraer mdulos.
OB84 Avera CPU.
OB85 Error de ejecucin.
OB86 Fallo de DP o en bastidor.
OB87 Error de comunicacin.
OB100 Rearranque completo.
OB101 Rearranque.
OB121 Error de programacin.
OB122 Error acceso a la periferia.
Tabla 1. Relacin de OBs
Comentarios sobre algunas OBs.
o OB 1: Programa cclico.
Cuando termina el OB 1 enva los datos globales.
S7 ofrece supervisin del tiempo de ciclo mximo.
o Alarmas horarias.
Se activan llamando a la SFC 30. Si no estn activadas la CPU no las lee.

Se programan con la SFC 28.
Cuando se ejecutan una vez se anulan. Tambin se pueden ejecutar peridicamente.
Si la CPU realiza un rearranque completo, cada OB de alarma horaria configurado median-

te una SFC adopta otra vez la configuracin ajustada con STEP 7. No puede ejecutar dos OBs de
alarma a la vez.
o OBs de alarma de retardo.
Arrancan mediante una llamada a la SFC 32. Arrancan despus de un tiempo preestable-
cido. Puede anularse una alarma que todava no ha sido arrancada. (SFC 33)
Un rearranque completo borra cualquier evento de arranque de un OB de alarma de retar-

do.
o OBs de alarma cclica.
Tienen un valor de tiempo prefijado.
No puede durar ms tiempo la ejecucin del OB que el tiempo de volver a arrancar.
o OBs de alarma de proceso.
Dentro de las alarmas de proceso, las prioridades se establecen con STEP 7. La activacin
se parametriza con STEP 7. No se pueden ejecutar dos a la vez.
Si el evento ocurre en otro canal del mismo mdulo, no puede activarse momentneamen-
te ninguna alarma de proceso. En S7 300 se pierden. En S7 400 no se pierden. Se ejecutan
cuando acaban.
o OBs de alarma de multiprocesamiento.
En caso de operacin en modo multiprocesador, la alarma de multiprocesamiento permite

que las CPUs asociadas puedan reaccionar de forma sincronizada a un evento. Al contrario de
las alarmas de proceso - que slo pueden ser desencadenadas por mdulo de seales - la alarma
de multiprocesamiento slo puede ser emitida exclusivamente por las CPUs.
Se activa llamando a la SFC 35.
o OB de error de tiempo

Si no es programada la CPU pasa a STOP cuando se produce un error de tiempo.
Si en un mismo ciclo se llama dos veces al OB 80 debido a la superacin del tiempo de ci-
clo, la CPU pasa a STOP. Es posible evitar esto llamando a la SFC 43 en un lugar adecuado.
o OB 81. Fallo de comunicacin.
Slo est permitida en el S7 400. Si no est programada y ocurre un fallo de alimentacin,

la CPU pasa a STOP.
En los prximos ejercicios vamos a probar algunos de estos OB.
SFCs
o Parmetros ms importantes
Evaluacin de errores con el parmetro de salida RET_VAL. Indica en el programa de

usuario si la CPU ha ejecutado la funcin SFC correctamente o no. La informacin de error co-
rrespondiente se obtiene de dos maneras:
- En el bit RB de la palabra de estado.
- En el parmetro de salida RET_VAL.
RB a cero significa que ha aparecido un error. Existe una tabla de cdigos de error genera-
les para los valores de RET_VAL.
o Funciones de copia con bloques
- Con SFC 20 podemos copiar. Se copia el contenido de un rea de memoria en otra.
Con esto NO se pueden copiar:
- FBs, SFBs, FCs, SFCs, OBs, SDBs.
- Contadores.
- Temporizadores.
- reas de memoria de la periferia.
Copia lo que cabe tanto si el campo destino es mayor o menor que el campo fuente. No
existen informaciones de error especficas.

- SFC 21: Es posible inicializar un rea de memoria (campo destino) con el contenido de
otra rea de memoria (campo fuente). La SFC copia en el campo de destino indicado, el contenido
hasta que el rea de memoria est escrita por completo.
La escritura se realiza por el orden sucesivo de direcciones ascendentes en el rea de

memoria
- SFC 22: Con esta funcin podemos crear un bloque de datos. Se hace con el parmetro
CREAT_DB. No contiene valores inicializados. La longitud de los DBs debe ser un nmero par.
- SFC 23: Con esta funcin podemos borrar un bloque de datos. DEL_DB.
- Podemos comprobar un bloque de datos con la SFC 24 TEST_DB.
- Podemos comprimir la memoria de usuario con la SFC 25 COMPRESS.
Al borrar y recargar repetidamente bloques, pueden surgir huecos, tanto en la memoria de

carga como tambin en la memoria interna, que reducen el rea de memoria aprovechable.
Con esta funcin podemos aprovechar el espacio. No hay control sobre si la compresin
se ha realizado correctamente. Se puede controlar llamando a la SFC 25 cclicamente.
- Transferir valor de sustitucin a ACU 1 con la SFC 44 REPL_VAL.
Con la SFC 44 REPL_VAL, se transfiere un valor al ACU 1 del nivel de programa causan-
te del error.
La SFC 44 slo debe ser llamada en el OB de error sncrono (OB 121, OB 122)
Puede continuar el programa en caso de error. Utiliza el nuevo valor que hay en el ACU 1.
o SFCs para control de programa.
- La SFC 43 redispara el tiempo de vigilancia.
No ofrece informaciones de error.
- La SFC 46 pone la CPU en STOP.
- La SFC 47 permite programar retardos o tiempos de espera en el programa de usuario.
Esta funcin se puede interrumpir con una OB de mayor prioridad.
- La SFC 35 dispara la alarma de multiprocesamiento. Esto conduce el arranque sincroni-

zado del OB 60 en todas las CPU asociadas.

El parmetro de entrada JOB permite identificar la causa definida por el usuario para la
alarma.
A la SFC 35 puede llamarse en cualquier punto del programa de usuario.
o SFCs para gestin del reloj.
- SFC 0 SET_CLK para ajustar la hora. Con esto se ajusta la fecha y la hora de la CPU.
Si el reloj es un maestro, la CPU arranca tambin la sincronizacin de la hora al llamar a la SFC 0.
Los intervalos de sincronizacin se ajustan con STEP 7.
La fecha y la hora se indican con el tipo de datos DT. Ej: DT#1998-01-15-10:30:30.
Se ha de tener en cuenta que el tipo de datos DT debe ser generado previamente con la
FC 3 D_TOD_DT antes de asignarlo al parmetro de entrada.
- SFC 1 READ_CLK lee la hora. Se obtienen la fecha y hora actuales.
No ofrece informaciones de error especficas.
- SFC 48: Sincronizacin de relojes esclavos. Transmite la fecha y la hora desde el reloj
maestro de un segmento de bus a todos los relojes esclavos de este mismo segmento de bus.
o SFCs para gestin del contador de horas de funcionamiento
Contador de horas de funcionamiento: Cuenta las horas de funcionamiento de la CPU.
- Ajustar el contador de horas de funcionamiento con la SFC 2. Con esto se ajusta el con-
tador de horas de funcionamiento de la CPU a un valor preestablecido. Es posible ajustar una
cantidad especfica de contadores para cada CPU.
- SFC 3 arranca y para el contador de horas de funcionamiento.
- SFC 4 lee el contador de horas de funcionamiento. La SFC 4 suministra como datos de

salida, la cantidad actual de horas de funcionamiento y el estado del contador, es decir, parado o
contando.
- SFC 64 lee el cronmetro del sistema de la CPU. Si se sobrepasa el cronmetro del sis-
tema, se comienza a contar desde cero.
o SFCs para transderir registros
- Escribir y leer registros:

Existen zonas de memoria en las que slo se puede escribir, o slo se puede leer.
- SFC 35 transfiere el registro RECORD al mdulo direccionado.
- SFC 56 transfiere el registro con el nmero RECNUM, desde el correspondiente SDB al

mdulo direccionado. Carece de significado si se trata de un registro esttico o dinmico.
- Parametrizar el mdulo con la SFC 57.
Con la SFC 57 se transfieren todos los registros de un mdulo que han sido configurados
con STEP 7 en el correspondiente SDB, al mdulo.
Carece de sentido si se trata de un registro esttico o dinmico.
- SFC 58 se transfiere el registro RECORD al mdulo direccionado.
- SFC 59 lee el registro con el nmero RECNUM del mdulo direccionado.
o SFCs para gestin de alarmas horarias.
Una alarma horaria es la causa de la llamada controlada por tiempo de un OB de alarma

horaria. La alarma horaria se puede parametrizar con STEP 7 y activar en el programa de usuario.
- SFC 28 Ajustar alarmas horarias.
- SFC 29 Anular alarmas horarias.
- SFC 30 Activar alarmas horarias.
- SFC 31 Consultar alarmas horarias.

3. 4. Programacin OB 80 (SFC 43).
Ejercicio resuelto.
TEORA PREVIA: Instruccin LOOP.
Vamos a hacer un programa con el cual la CPU se vaya a STOP por un error de tiempo.
Vamos a hacer el siguiente programa:
OB1
L 50000
META: U E 0.0
= A 4.0
LOOP META
BE
Como vemos este programa lo que hace es ejecutar 50000 veces este bucle. Si ponemos
un nmero suficientemente grande, no se podr ejecutar el bloque completo dentro del tiempo
definido como ciclo de scan. En cuanto esto ocurra, la CPU se ir a stop por un error de tiempo.
Qu podemos hacer para que la CPU no se vaya a STOP?
Podemos programar algo en la OB 80. De este modo, cuando ocurra un fallo de tiempo, en
lugar de irse la CPU a STOP, lo que har ser ejecutar lo que ponga en este bloque.
Si no tenemos programado el OB 80, cuando ocurre un error de tiempo, el PLC va a leer lo

que pone en el OB 80, y como no lo encuentra, se va a STOP. Si vamos a ver la informacin del
mdulo, el primer error que veremos ser OB no cargada.
Se ha ido a STOP porque le faltaba un mdulo. Si vamos a ver el segundo error veremos
que es un error de tiempo.
Si programamos el OB 80, cuando ocurra un error de tiempo ir al OB 80. Como ahora s

que lo encontrar, la CPU no se ir a STOP. Ejecutar lo que diga la OB 80.
Para probarlo, vamos al administrador de SIMATIC y nos creamos una OB 80.
Probamos ahora el programa. Veremos que el autmata sigue dando un error pero no se
va la CPU a STOP. Adems podemos comprobar que sigue funcionando.

Vemos que tarda mucho en reaccionar. Es el tiempo real que tarda la CPU en ejecutar el
OB 1.
Tenemos una solucin para que la CPU no nos de este fallo.
Dentro del bucle podemos hacer una llamada a la SFC 43. Esta funcin lo que hace es re-
lanzar el tiempo de ciclo.
Para ver lo que hace la SFC 43, podemos ir al administrador de SIMATIC y pinchar con el
interrogante de ayuda encima de la SFC 43. Se abrir una ventana en la que nos explica lo que
hace la SFC 43.
Esto no lo debemos hacer dentro de una instruccin de bucle.
Lo que estamos haciendo ahora es lo que no se debe hacer.
De este modo cada vez que se ejecuta el ciclo, tenemos ms tiempo de ciclo de scan. Po-
demos dejar el PLC bloqueado y que se quede durante varios minutos sin terminar el OB1.
Si hacemos lo que hemos dicho, conseguiramos que el OB1 tardara en ejecutarse mucho
tiempo y que no diera ningn error y que no se fuera a STOP.
Esto es peligroso porque se est leyendo el bloque cada varios segundos. Si tenemos
alarmas programadas u otras operaciones que tenga que ejecutar el PLC, slo se dar cuenta de
que lo tiene que ejecutar cada vez que lea la instruccin.
Puede darse el caso de que salte una alarma y hasta el cabo de unos segundos no reac-
cione el PLC.

3. 5. OBs 100, 101 . Retardo en el arranque
Ejercicio resuelto.
TEORA PREVIA: Relacin de OBs.
o OB 100.
Cuando la CPU realiza un rearranque completo, accede al OB 100.
Lee este bloque una sola vez y a continuacin pasa a leer el OB 1 de manera cclica. Has-
ta que no se ejecuta un nuevo rearranque no se vuelve a leer el OB 100.
Vamos a hacer una prueba de que esto es as.
Vamos a programar el OB 100. Vamos a decirle en el OB 100 que ponga unos valores a
unas palabras de marcas.
Luego haremos un OB 1 que utilice estos datos de las palabras de marcas y posteriormen-
te que los modifique. Veremos que cada vez que rearrancamos el autmata, toma los valores que
hemos definido como iniciales.
OB100
L 10
T MB 100
L 8
T MB 101
BE
OB 1
L MW 100
T AW 4
U E 0.0
SPB M001
BEA
M001: L W#16#FFFF

T MW 100
BE
Cada vez que activemos la E 0.0, estaremos cambiando el valor de la palabra de marcas
100. Se quedar con este valor hasta que rearranquemos el autmata.
Al rearrancar tomar el valor que le estamos dando con el OB100.
Este OB se suele utilizar para inicializar bloques de datos.
En l cargamos todos los datos importantes de inicializacin de proceso. Cada vez que
arranquemos de nuevo, se tomarn los valores iniciales.
Si no hacemos esto, los DB se guardan los valores actuales. Si por cualquier causa en un
DB hay datos que no son los iniciales, cada vez que transfiramos al autmata, estamos transfi-
riendo los valores actuales.
Si queremos transferir los iniciales tendremos que inicializar primero el DB.
o OB 101.
El OB 101, slo lo tenemos disponible en los S7 - 400.
Es similar al OB 100.
El OB 100 tambin es til para retardar el arranque. El tiempo de ciclo de scan slo afecta
al OB 1. Nosotros podemos programar un bucle con un temporizador de 3 segundos dentro del
OB 100, de manera que cuando ponemos la CPU en marcha, hasta los tres segundos no se em-
pieza a leer el OB 1 y por consiguiente no se empieza a ejecutar el programa.
Esto nos puede ser til en instalaciones en las que tengamos, por ejemplo, variadores de
frecuencia que necesiten unos segundos para estar a punto y empezar el programa.
Solucin en AWL
OB 100
M001: UN M 0.0
L S5T#3S
SE T 1
UN T 1

SPB M001
BE
A continuacin programaramos el OB 1.

3. 6. Programacin de alarmas cclicas
Teora.
Para programar este tipo de alarmas, vamos de nuevo al hardware. Pinchamos con el bo-
tn derecho encima de la CPU. Entramos en propiedades del objeto.
Figura 59. Acceso a las propiedades de la CPU en el Hardware.
Dentro de propiedades del objeto vamos a la ficha de alarmas cclicas.
Estas alarmas son similares a las alarmas horarias.
En este caso no tenemos que decirle que tenemos la alarma activa. Slo con programar el
OB correspondiente tenemos suficiente.
Tenemos que decirle cada cuanto tiempo queremos que se ejecute el OB de la alarma.

Figura 60. Ajuste de la periodicidad de los OB de alarma cclica
En este caso vamos a hacer un ejemplo que ejecute el OB 21 cada dos segundos.
El tiempo se lo damos en milisegundos.
Ahora hacemos como en las alarmas anteriores. Vamos al administrador de SIMATIC.

Creamos el OB 21.
Programamos algo all.
A continuacin programamos algo en el OB1.
Comprobaremos que cada dos segundos se ejecuta lo que pone en el OB 21.
Ejemplo de OB 21:
UN A 5.0
= A 5.0
De este modo tendremos un intermitente del tiempo que hayamos programado en la alar-
ma.

3. 7. Programacin de alarmas de retardo
Teora
Para programar este tipo de alarmas, acudimos de nuevo al hardware, y entramos con el
botn derecho en propiedades del objeto.
Vamos a la ficha de alarmas de retardo. Veremos que dependiendo de la CPU de la que

dispongamos, tenemos unos OBs disponibles. Por ejemplo, si tenemos una CPU 314, veremos
que el OB que tenemos disponible es el OB 20.
Figura 61. Ajuste de alarma de retardo
Para programar estas alarmas tenemos que llamar a la SFC 32.
El funcionamiento de las alarmas de retardo es el siguiente:
Nosotros programamos una accin (por ejemplo activar una entrada), y un tiempo. Al cabo
de este tiempo que definimos despus de haberse dado la accin, se ejecutar el OB que corres-
ponda.
Tenemos que tener cuidado de no programar este tipo de alarmas en un bloque que se
ejecute todos los ciclos. Si hacemos esto, nunca acabar de contar el tiempo definido, y por tanto
no se ejecutar el OB en cuestin.

Unicamente tenemos que programar en el OB 1 una llamada a la SFC 32. Hay que tener
en cuenta no volver a llamar a la SFC 32 antes de haber pasado en tiempo programado en la
alarma. De lo contrario nunca se ejecutara la accin que hayamos programado.

3. 8. Programacinde alarmas horarias por hardware.
Teora.
Para programar este tipo de alarmas, tenemos que hacerlo a travs del hardware. Vamos a
hacer un proyecto nuevo, y vamos a entrar en el hardware. Una vez lo tengamos definido, pin-
chamos encima de la CPU con el botn derecho, y entramos en propiedades de la CPU.
Veremos que tenemos varias fichas. Vamos a la ficha de alarmas horarias.
Dependiendo de la CPU que tengamos, tendremos unos OB disponibles para programar

alarmas. Por ejemplo, si tenemos una CPU 314, veremos que slo tenemos disponible el OB10.
Figura 62. Ajuste de alarmas horarias.
Nosotros vamos a programar la alarma. Para ello tendremos que decirle que la alarma est
activa. Adems tendremos que decirle cada cuanto tiempo queremos que se produzca, y desde
cuando queremos que se active.
Esto significa que cada cierto tiempo, se va a acceder a la OB 10. Se ejecutar lo que all
diga y el programa seguir luego por donde iba.
Luego tendremos que programar el OB10. Lo que no habr que hacer, ser programar una
llamada al OB 10. A los OB no se les llama.

Vamos a ver un ejemplo de este tipo de alarmas.
Vamos a decirle que se ejecute el OB 10 cada minuto Desde la hora actual.
En la OB 10 vamos a programar:
OB10
L W#16#FFFF
T AW 4
BE
Ahora tenemos que programar el OB1.
OB1
U A 4.7
L S5T#10S
SE T 1
U T 1
R A 4.7
R A 4.6
R A 4.5
R A 4.0
U E 0.0
= A 4.0
BE
De este modo podremos comprobar que cada minuto se ejecuta el OB 10, y que mientras
tanto, se est ejecutando el resto del programa.
El OB10, se ejecutar cada minuto desde la fecha y hora que le dimos de comienzo.

3. 9. Programacin de alarmas horarias por software
Teora
Estas alarmas tambin las podemos programar con las SFC 28 y 30.
Con una llamada a la SCF 30 activamos la alarma. Con una llamada a la SFC 28 le deci-
mos cada cuanto tiempo queremos que se active, y desde cuando queremos que se active.
Para decirle desde cuando queremos que se active, tenemos que darle un formato de fe-
cha y hora.
Nosotros no podemos manejar formatos de fecha y hora. Este formato es de 64 bits. No

podemos moverlo a travs del acumulador. Tendremos que hacer una llamada desde una FC.
Como parmetro de entrada por salida tampoco podemos poner un parmetro de formato
fecha y hora. Despus desde la OB 1 tendramos que introducir el parmetro y hemos dicho que
no podemos trabajar con 64 bits.
Desde la OB 1 slo podemos introducirle como parmetros formatos de 32 bits como m-

ximo.
A la FC que hagamos, le daremos como parmetros dos entradas. Una ser de formato fe-
cha y la otra ser de formato hora. Estos dos formatos son de 32 y 16 bits cada uno.
Despus, dentro de la FC tendremos que hacer una llamada a la FC 3 de la librera que

hamos visto antes para que nos genere la variable de fecha y hora.
Esta variable de formato fecha y hora, la definiremos en la tabla de la FC como TEMP. Es

preciso que sea una variable temporal porque no podemos moverla.
Con esta variable ya podemos parametrizar las alarmas horarias
El tiempo de periodicidad se lo damos a travs de un cdigo. La fecha y hora de arranque

se la damos con la variable que acabamos de generar.
Veamos como haramos esto:


3. 10. Crear archivos fuente y proteger bloques
Teora.
Tambin podemos crear un programa como archivo fuente o como archivo de texto en un
editor de texto.
Los programas de la CPU estn formados bsicamente por los bloques que programamos,
la configuracin y la conexin a las distintas redes que vayamos a utilizar.
Para programar archivos fuente disponemos en el administrador de SIMATIC de un editor

de textos con compilador.
Podemos hacer todos los bloques juntos y compilarlos de una sola pasada.
Con esto tenemos las siguientes ventajas:
o Podemos programar varios bloques en un archivo fuente.
o El archivo fuente se puede guardar aunque tenga errores.
o Hasta que no se compile no nos informa de los errores.
o Podemos crear el bloque con otros editores de texto e importarlo.
Hemos dicho que el programa se compone de los bloques + la configuracin. Con el editor
de textos podemos hacer los bloques, pero no la configuracin.
Para crear un proyecto completo, tendremos que hacer la configuracin normalmente con
el administrador de SIMATIC, y luego crear los bloque a parte en un editor de textos.
El programa lo podemos hacer directamente con el editor de textos. No nos hace falta para
nada el STEP 7. Pero a la hora de transferir el programa a la CPU, tendr que estar completo con
su configuracin y hecho en STEP 7.
Veamos como haramos un programa en el Word Pad por ejemplo:

Figura 63. Definicin de cdigo de programa en un editor de textos
Tenemos que tener en cuenta escribir un ; detrs de cada instruccin. Adems tenemos que
respetar los espacios que luego se nos van a requerir en Step 7.
Creamos un proyecto en STEP 7. Lo podemos crear sin decirle el equipo que tenemos.
Dentro de fuentes creamos una fuente nueva.
Figura 64. Insercin de cdigo fuente en Step 7
Desde esta fuente nueva podemos entrar en el editor haciendo doble clic en ellas
Dentro del editor de textos vamos a Archivo > nuevo.
Para crear los bloques en el editor de textos podemos utilizar plantillas ya existentes.

Figura 65. Insertar plantillas de bloques en el editor
Las plantillas las podemos modificar sin incluyen algo que no nos interesa.
En cualquier momento podemos guardar el archivo que hemos generado. No es preciso

que est compilado y correcto.
Usando el comando de men Archivo > comprobar consistencia, se puede comprobar en

cualquier momento la coherencia y la sintaxis del archivo fuente, sin que ello inicie la creacin de
bloques. Nos indicar el nmero de lneas compiladas y la cantidad de errores y advertencias.
Al compilar es cuando se generan los bloques. Slo se generan los que no contengan erro-
res.
Para generar un archivo fuente, tenemos que tener en cuenta las siguientes reglas genera-
les:
o La sintaxis de las instrucciones AWL es la misma que la del editor incremen-

tal. Una excepcin a esta regla son las llamadas a bloques y la declaracin
de Arrays y estructuras.
o El editor de textos no distingue generalmente entre maysculas y minsculas.

De esta regla quedan exceptuados los nombres de las variables.
o Se debe sealar el final de todas las instrucciones AWL y declaraciones de

variables escribiendo un punto y coma al final. Se puede introducir ms de
una instruccin por lnea.
o Los comentarios deben comenzar con dos barras inclinadas (//), y la entrada
de comentarios debe finalizarse con la tecla enter.

En lo que se refiere al orden que debe haber entre los distintos bloques, se deben tener en
cuenta las siguientes reglas:
o El OB1 que es el que llama a otros bloques tiene que estar al final. Cada
uno de los otros bloques tiene que estar detrs de los bloques a los que lla-
ma.
o Aquellos bloques que llame en el archivo fuente, pero que no programe en

ese mismo archivo fuente, ya tienen que haber sido creados en el programa
de usuario correspondiente cuando se vaya a compilar el archivo.
o Estructura bsica de los bloques:
o Comienzo del bloque con indicacin del bloque.
o Ttulo del bloque.
o Comentario del bloque.
o Atributos de sistema para los bloques.
o Propiedades del bloque.
o Tabla de declaracin.
o rea de instrucciones de bloques lgicos o asignacin de valores actuales en

bloques de datos.
o Fin de bloque.
Veamos como podemos proteger bloques.
Para ello tenemos que pasar obligatoriamente por el formato de fuente. Podemos hacer un
bloque a travs de una fuente y protegerlo o tener un bloque ya programado desde el Step 7 y
querer programarlo.
Para ello tenemos una opcin que convierte en bloque en fuente.
Veamos como haramos eso.
Supongamos que tenemos el siguiente bloque programado en Step 7.

Una vez tengamos el bloque programado, tenemos una opcin en el men de archivo que
nos genera la fuente.
Para poder acceder a esta opcin, tenemos que estar dentro del bloque del cual queremos
tener la fuente.
Figura 66. Generar fuente de un bloque previamente programado
Para crear la fuente, nos pide un nombre:

Figura 67. Asignar nombre a la fuente
Aqu le damos el nombre que queremos que tenga la fuente.
Una vez le ponemos nombre, nos permite seleccionar qu bloques de los que tenemos
creados, son los que queremos incluir en la fuente. En este caso hemos generado una fuente que
se llama ejemplo, y vamos a incluir solamente el OB 1.
En la hoja de seleccin de bloques solamente pasamos a la parte derecha el icono del OB

1. Veamos como queda la seleccin.

Figura 68. Seleccin de bloques sobre los que queremos generar la fuente
Una vez le digamos aceptar, ya tenemos la fuente generada.
Ahora entramos en la fuente.
Para proteger bloques, tenemos que estar en formato fuentes. Podemos llegar aqu bien
porque hemos creado directamente una fuente o porque hemos convertido un bloque como aca-
bamos de hacer en este caso.
Para que el bloque quede protegido en la fuente tenemos que aadir la palabra:
KNOW_HOW_PROTECT delante de la definicin de las variables del bloque.

Veamos como quedara:
Figura 69. Aspecto del archivo fuente generado
Ahora solo tenemos que compilar el bloque. Cuando compilamos bloques, se generan au-
tomticamente los bloques que tengamos en la fuente. Tenemos que tener en cuenta que no exis-
tan como bloques en el Step 7. Si existen, nos dar un error a la hora de compilar y no se genera-
r el bloque.
Cuando creemos el bloque con una plantilla de bloques, esta palabra de proteccin ya vie-
ne escrita. Veremos que aparece con // delante. De momento est como comentario. Si queremos
proteger estos bloques, slo tenemos que quitar esta doble barra.

3. 11. Ajustar la hora
Teora.
TEORA PREVIA: Conocimiento de las SFC de gestin del reloj.
Adems de las SFC de gestin del reloj que hemos visto anteriormente, tenemos una op-
cin en el men con la que podemos cambiar la hora de la CPU desde la maleta de programacin.
Estando dentro de un bloque de ONLINE o bien desde el administrador de SIMATIC pin-

chando encima de la CPU de ONLINE, vamos al men de Sistema destino y cogemos la opcin
Ajustar la hora. En las nuevas versiones lo podemos hacer desde cualquier punto del programa.
Figura 70. Forma de ajustar la hora desde STEP 7.
Veremos una ventana con la hora actual de la CPU. Situndonos encima con el ratn, po-
demos cambiar la hora y la fecha.
Adems esta operacin la podemos hacer por programa. Tenemos la funcin SFC 0 para
escribir la fecha y hora de la CPU. Como hemos visto anteriormente, no podemos mover un for-
mato de fecha y hora. Tendremos que hacer una FC en la llamemos a la SFC 0. Primero tenemos
que montarnos el formato de fecha y hora con la FC 3 de la librera. Como parmetros de la nueva
FC que estamos haciendo, tendremos dos palabras. Una ser de tipo fecha y la otra ser de tipo

hora. Ser lo que nos pida cuando hagamos la llamada desde el OB 1. Le daremos como parme-
tro dos datos de 32 bits.
3. 12. Formatos fecha y hora
Ejercicio resuelto.
DEFINICIN Y SOLUCIN
TEORA PREVIA: Introduccin de formatos de fecha y hora.
Vamos a activar una luz durante medio minuto todos los das
Como operacin final de este ejercicio tendremos que comparar si la hora actual es a la
vez mayor que la de inicio y menor que la de fin.
Para hacer este tipo de comparaciones tenemos unas funciones dentro de las libreras que
ya estn hechas y slo tenemos que utilizarlas.
Las funciones que estn hechas nos hacen esta comparacin pero no slo con la hora,
sino con formato de fecha + hora.
En consecuencia tendremos que fabricarnos unos formatos de fecha + hora para poder
compararlos.
Lo que vamos a hacer es en principio leer la fecha + hora de la CPU. Con esto tendremos
la fecha + hora actual. Esto lo hace la funcin SFC 1.
Vamos a separar este formato en fecha y hora y nos quedaremos con la fecha de hoy. Es-
to lo hace la FC 6 de la librera.
Esta fecha la juntaremos con la hora de inicio y con la hora de fin que nosotros queramos
para activar la salida.
De este modo ya tenemos la hora de inicio y la hora de fin con la fecha de cada da. He-
mos conseguido lo que queramos.
Vamos a comparar esta hora + fecha de inicio y de fin con la fecha + hora actual.
En los tres formatos la fecha siempre va a coincidir. Siempre ser la fecha de hoy. Lo que
en realidad estamos comparando es la hora.
Veamos como haramos esto en AWL.
Antes que nada vamos a ver las funciones que tenemos que gastar de las libreras.

Necesitamos la FC3, la FC6, la FC14 y la FC23.
Adems vamos a gastar la SCF 1 que la lleva integrada la CPU.
Primero vamos a entrar con la ayuda en cada una de estas funciones para ver los parme-
tros que me va a pedir cada una de ellas.
Vamos primero a la SFC 1. Vemos que como parmetros tiene:
RET_VAL: Nos va a pedir un valor entero donde nos dejar algn cdigo de error en caso
de producirse.
CDT: Ser una variable de formato fecha y hora donde nos dejar la fecha y la hora ledas
de la CPU.
Vamos a la FC3:
IN1: Nos va a pedir una entrada de tipo fecha.
IN2: Nos va a pedir una entrada de tipo hora.
RET_VAL: Nos va a devolver la fecha y la hora que le hemos dado juntas en un formato fe-
cha y hora.
Vamos a la FC6:
IN: Nos va a pedir una entrada de formato fecha y hora.
RET_VAL: Nos va a devolver la fecha sola del formato anterior.
Vamos a la FC14:
DT1: Nos pide una entrada de formato fecha y hora.
RET_VAL: Nos pide una salida de tipo binario. Este bit se activar si la primera entrada que
hemos metido es mayor que la segunda.
Vamos a la FC23:
RET_VAL: Nos pide una salida de tipo binario. Este bit se activar si la primera entrada es
ms pequea que la segunda entrada.
Para poder utilizar todas estas funciones tenemos que tenerlas dentro de nuestro proyecto.
La primera cosa que tenemos que hacer es traerlas a nuestro proyecto para poderlas llamar y
poderlas utilizar.

Ahora nosotros nos tenemos que crear una FC con todas las variables que nos van a ha-
cer falta para darlas como parmetros a las FC que vamos a llamar.
Vamos a crear una FC que no tenga el mismo nmero que las que tenemos que utilizar.
Vamos a hacer por ejemplo la FC2.
FC2
IN HORA_INICIO TIME_OF_DAY
IN HORA_FIN TIME_OF_DAY
OUT SALIDA BOOL
TEMP ERROR INT
TEMP FECHA_Y_HORA_ACTUAL DATE_AND_TIME
TEMP FECHA_ACTUAL DATE
TEMP F_H_INICIO DATE_AND_TIME
TEMP F_H_FIN DATE_AND_TIME
TEMP BIT_1 BOOL
TEMP BIT_2 BOOL
Segmento 1: Lectura del valor de la fecha y hora actual.
CALL SFC 1
RET_VAL:= #ERROR
CDT:= #FECHA_Y_HORA_ACTUAL
Segmento 2: Separa la fecha y hora actuales en slo fecha actual.
CALL FC 6
IN:= #FECHA_Y_HORA_ACTUAL
RET_VAL:= #FECHA_ACTUAL
Segmento 3: Une FECHA_ACTUAL a la hora de inicio y crea fecha y hora de inicio.
CALL FC 3
IN1:= #FECHA_ACTUAL

IN2:= #HORA_INICIO
RET_VAL:= F_H_INICIO
Segmento 4: Une FECHA_ACTUAL a la hora de fin y crea fecha y hora de fin.
CALL FC 3
IN1:= FECHA_ACTUAL
IN2:= #HORA_FIN
RET_VAL:= F_H_FIN
Segmento 5: Compara si fecha y hora actual > fecha y hora de inicio.
CALL FC 14
DT1:= #FECHA_Y_HORA_ACTUAL
DT2:= #F_H_INICIO
RET_VAL:= #BIT_1
Segmento 6: Compara si fecha y hora actual < fecha y hora de fin.
CALL FC 23
DT1:= #FECHA_Y_HORA_ACTUAL
DT2:= #F_H_FIN
RET_VAL:=#BIT_2
Segmento 7: Activacin de la salida.
U #BIT_1
U #BIT_2
= #SALIDA
BE
Ahora nos queda hacer una OB1 para decir cuando tiene que ejecutarse esta FC y ade-
ms con que valores tiene que ejecutarse.
OB1

CALL FC 2
HORA_INICIO:= TOD#8:23:00
HORA_FIN:= TOD#8:23:30
SALIDA:= A 4.0
BE
En estos parmetros le decimos a la hora que queremos que se active la salida y a la hora
que queramos que se desactive la salida, y adems la salida que queremos que se active.
El hacerlo como parmetro, nos da adems la ventaja de poder cambiar desde aqu estos
datos sin tener que entrar en la FC que hemos programado.
Si nos interesa guardar esta FC en una librera, lo que tenemos que hacer es el proceso
inverso al de antes. Abrimos o creamos una librera nueva, y arrastramos la FC a la librera que
nos interesa.
Ejercicio propuesto: Resolver esto en KOP y en FUP con las instrucciones vistas anterior-
mente.

3. 13. Hacer funcionar algo un da de la semana
Ejercicio resuelto.
TEORA PREVIA: Formatos de fecha y hora.
Vamos a hacer un programa en el que se active una salida un da de la semana determi-

nado que yo le diga desde un parmetro. Si yo en el parmetro le digo LUNES quiero que todos
los lunes se active la salida. Si yo le digo MARTES, quiero que todos los martes se active la sali-
da, etc.
El autmata tiene unos bits que nos indican el nmero de da dentro de la semana. Estos
bits contendrn 1 si es domingo, contendrn 2 si es lunes, 3 si es martes, 4 si es mircoles, 5 si es
jueves, 6 si es viernes y 7 si es sbado.
Luego lo que tenemos que hacer es una comparacin entre este cdigo interno y el par-
metro que yo le estoy introduciendo del da de la semana que yo quiero.
Estos bits son los cuatro ltimos del formato de fecha y hora.
Este formato est compuesto por 8 bytes. (64 bits).
Nosotros no podemos manejar 64 bits. No podemos pasar como parmetro 64 bits, ni po-
demos cargar y transferir. Los acumuladores son de 32 bits. Como mximo podemos mover for-
matos de 32 bits.
Para trabajar con este tipo de formatos tenemos unas FC hechas en unas libreras que nos
permiten cambiar este formato de 64 bits y transformarlo en formatos de 32 bits.
Tenemos una FC que nos corta el formato de fecha y hora y nos lo convierte en formato de
slo fecha.
Tenemos otra FC que nos corta el formato fecha y hora y nos devuelve slo la hora.
Tenemos otra FC que lee el formato fecha y hora y nos devuelve un nmero entero que co-
rresponde al da de la semana.
Esta es la FC 7 dentro de la librera IEC.
Veamos como encontramos esta FC y lo que hace.
Primero tenemos que ir al men de Archivo y abrir una librera. Esto lo hacemos desde el
Administrador de Simatic.
Una vez estemos all tenemos que seleccionar las Libreras estndar de la versin 3.

A continuacin vemos como abrimos esta librera.
Figura 71. Abrir librera Standard library en Step 7.
Aqu dentro encontramos varias carpetas de librera. Si vamos a los bloques de la librera
IEC vemos que la FC 7 se llama DT_DAY. Es la que nos convierte un formato fecha y hora en un
formato Da de la semana.
Figura 72. Seleccin de la FC7 dentro de la librera IEC Function Blocks
Si cogemos el interrogante que tenemos en el men superior de herramientas y nos situa-

mos encima de la FC, obtenemos la ayuda de lo que hace y de cmo funciona.

Figura 73. Ayuda asociada a la FC7.
Vemos que como parmetros nos va a pedir un formato fecha y hora y nos devuelve un en-
tero que es el da de la semana con el cdigo que podemos ver en la ayuda.
Ahora slo nos queda hacer el programa. Tendremos primero que llamar a la SFC 1 para
leer la fecha y la hora que tenemos en la CPU. Una vez tengamos la fecha y la hora, tendremos
que sacar de all el da de la semana.
Una vez tengamos el da de la semana, compararemos con un nmero entero para decirle
el da de la semana que queremos que haga algo.
Veamos como quedara el programa en AWL.
FC3
TEMP FECHA_HORA DATE_AND_TIME
TEMP ERROR WORD

TEMP DIA_SEMANAINT
OUT SALIDA BOOL
TEMP DIA INT
CALL SFC 1
SDT:= FECHA_HORA
RET_VAL:= ERROR
CALL FC 7
SDT:= FECHA_HORA
RET_VAL:= DIA_SEMANA
L DIA_SEMANA
L DIA
==I
= SALIDA
OB1
CALL FC 3
SALIDA:= A4.0
DIA:= 3

3. 14. Direccionamiento indirecto
Teora.
Vamos a ver varios tipos de direccionamiento indirecto:
Hasta ahora hemos utilizado instrucciones del tipo:
AUF DB 3
U T 2
CC FC 7
L Z 4
...........
En todas estas instrucciones estamos gastando nmeros que no tienen nada que ver con
los bits. Hacen referencia al DB n 3, o al temporizador n 2, etc.
Veamos como podemos sustituir estos nmeros por un direccionamiento indirecto. Vamos
a escribir en el lugar donde antes estaba el nmero, un registro que contenga el nmero que no-
sotros queremos.
Como vemos todos estos nmeros son nmeros enteros. Los sustituiremos por un registro
en el que tengamos un entero. Esto ser una palabra. La palabra podr ser de datos, de marcas,
de salidas, de variables locales, etc.
Veamos en unos ejemplos muy sencillos como hacemos esta sustitucin y comprobemos
que funciona.
L 5 AUF DB 10
T MW 2 L 20
AUF DB [MW2] T DBW 10
........... U T [DBW10]
..............
Vamos a programar unos temporizadores de la siguiente manera:
L EB 1
T MW 10
U E 0.0
L S5T#5S
SE T [MW10]
U T [MW10]
= A 4.0
Con esto tenemos programados 255 temporizadores. En la CPU 314 slo pueden funcio-
nar 128, pero nosotros tenemos programados 255 que son todas las combinaciones que podemos
poner en el byte de entradas 1.
Vamos a la tabla de observar/forzar variables y veremos en cada caso con el temporizador

que estamos contando.
Otras veces hemos utilizado instrucciones de este otro tipo:
L MW 10
T AB 4
L DBD 3
T EW 0
...............
En estos casos tambin estamos gastando nmeros enteros. Estamos accediendo a la pa-
labra de marcas 10 o al byte de salidas 4, etc. En estos casos si que nos estamos refiriendo a bits.
Por ejemplo, al hacer referencia a la palabra de marcas 10, nos referimos a los bits desde
el 10.0 hasta el 11.7.
A la hora de hacer un direccionamiento indirecto tenemos que tener en cuenta que esto
son bits. Tendremos que cambiar estos nmeros por uno registros en los que contenga la direc-
cin de los bits a partir de los cuales tenemos que tomar 8, 16 o 32 bits dependiendo de si quere-
mos acceder a un byte, palabra o doble palabra.
Para ello lo haremos con dobles palabras metiendo en ellas un formato puntero.
Veamos unos ejemplos:
Formato de puntero:

L P#4.7 L P#1.0
T MD 2 T MD 2
U E 0.0 L EB [MD2]
= A [MD2] T MW [MD2]
BE BE
L P#0.3 L P#0.0
LAR1 LAR2
U E [AR1,P#1.2] L EB [AR2,P#1.0]
= A 4.0 T MW [AR2,P#100.0]
BE BE
Aqu hemos visto varias formas de hacer direccionamiento indirecto.
Vamos a ver un ejemplo ms concreto.

3. 15. Control de fabricacin de piezas
Ejercicio resuelto.
TEORA PREVA: Direccionamiento indirecto.
Supongamos que queremos controlar la cantidad de piezas que lleva fabricada una em-
presa. La empresa abre a las ocho de la maana y queremos controlar la cantidad de piezas que
tenemos fabricadas cada dos horas, hasta las 6 de la tarde.
El control lo llevaremos en un DB. Nos haremos el DB 1 de la siguiente manera:
0.0 Variable no vlida
2.0 Piezas_ocho_horas INT 0
4.0 Piezas_diez_horas INT 0
6.0 Piezas_doce_horas INT 0
8.0 Piezas_catorce_horas INT 0
10.0 Piezas_dieciseis_horas INT 0
Figura 74. Aspecto del DB a crear
Queremos rellenar este DB con un direccionamiento indirecto. Vamos a hacer una sola
carga y transferencia para rellenar todas las posiciones.
Vamos a comenzar el programa. Primero tenemos que hacer un contador que nos cuente
la cantidad de piezas que llevamos hechas.
OB1
U E 0.0
ZV Z 1
Nosotros haremos que pasen los valores al DB cada 10 segundos en lugar de cada dos
horas para poderlo probar.
Para ello nos har falta un generador de pulsos de 10 segundos.
Continuamos con el OB:
UN M 20.0
L S5T#10S

SE T 1
U T 1
= M 20.0
Ahora, la escritura de las distintas casillas del DB las vamos a hacer en la FC 1. Entrare-
mos a la FC 1 cada vez que se active la marca 0.0. Adems tenemos que tener un control de la
cantidad de veces que hemos entrado a la FC para desde all dentro saber a qu casilla tenemos
que acceder.
Continuamos con el OB1.
U M 20.0
FP M 50.0
ZV Z 2
CC FC 1
BE
Ahora vamos a programar el FC 1.
Lo primero que tenemos que saber es la cantidad de veces que hemos entrado para saber
a que casilla tenemos que acceder. Si es la primera vez que entramos queremos acceder a la
casilla que tiene direccin 2. Si es la segunda vez que entramos, tenemos que acceder a la direc-
cin 4. Si es la tercera vez que entramos tenemos que acceder a la direccin 6, etc.
La cantidad de veces que hemos entrado la tenemos en el contador 2. Necesitamos tener

este dato multiplicado por dos.
FC 1
L Z 2
T MW 0
L MW 0
SLW 1
T MW 2
En la MW 2 tenemos 2, 4, 6, 8,..... dependiendo la vez que estemos entrando. Son las di-
recciones a las que queremos ir. En realidad las direcciones tienen formato de puntero. Es decir,
las direcciones a las que queremos ir son 2.0, 4.0, 6.0, .....
Para ello vamos a utilizar dobles palabras. Adems tendremos que utilizarlas en formato
puntero. Nosotros tenemos la parte entera. Nos falta el .0 de cada una de estas direcciones. Esto
lo conseguimos desplazando la doble palabra tres posiciones a la derecha.
L MW 2
T MD 4
SLD 3
T MD 8
En la MD 8 ya tenemos la direccin que queremos en cada caso. Continuamos la FC 1.
AUF DB 1
L Z 1
T DBW [MD8]
Si lo dejamos as, cuando acabe con las cinco posiciones que hemos definido, se ir a
stop, porque buscar la direccin 12.0 para escribir en el DB y no la encontrar.
Cuando llegue a la posicin 10, queremos que vuelva a empezar.
L Z 2
L 5
==I
R Z 1
R Z 2
BE

3. 16. Comparar dobles palabras
Teora
Hasta ahora hemos visto que para comparar valores tenamos las instrucciones compues-
tas por el smbolo de comparacin y a continuacin una I o una R dependiendo de si lo que vamos
a comparar son nmeros reales o son nmeros enteros.
Adems podemos comparar dos dobles palabras independientemente de que sean enteros
o reales.
Para ello utilizaremos el smbolo de la comparacin y a continuacin una D de doble pala-

bra.
Veamos un ejemplo.
L MD 0
L MD 4
>D
= A 4.0
BE
Con esto comparamos si la serie de ceros y unos que hay en una doble palabra es mayor
o menor que la serie que tenemos en la otra palabra. No importa el formato en el que tengamos
las palabras.

3. 17. Referencias cruzadas
Teora
Vamos a hacer un pequeo programa para poder ver despus las referencias cruzadas.
Vamos a programar los siguientes bloques:
OB1
U E 0.0
CC FC 1
BE
FC1
U E 0.1
CC FC 2
BE
FC2
U E 1.0
L S5T#3S
SE T 1
U T 1
= A 4.0
L EW 0
T MW 10
BE
Adems vamos a programar una FC a la que no llamemos desde ningn sitio.
Ahora vamos a ir a la tabla de smbolos globales y vamos a dar nombre a la E 0.0, a la E

0.1 y a la E 2.7.
Una vez tenemos esto, vamos al administrador de SIMATIC.

Pinchamos encima de bloques en la ventana de OFLINE. Estando aqu vamos al men de
herramientas y dentro de l vamos a referencias cruzadas.
Figura 75. Seleccionar referencias cruzadas
Dentro de referencias cruzadas, tenemos arriba una serie de botones. Si nos paramos en-
cima de ellos con el ratn, nos va indicando la funcin de cada uno de ellos.
Vamos a ir pinchando en todos y vamos a ir viendo lo que hace cada uno aprovechando el
programa que hemos hecho antes.
Figura 76. Vista global de referencias cruzadas.

Esto es la ventana de las referencias cruzadas. En ella podemos ver todos los elementos
que estamos gastando. Vemos en que bloque lo estamos gastando, si el datos es de lectura o de
escritura, e4n el lenguaje que lo estamos gastando, en el segmento en el que lo tenemos locali-
zado y la instruccin que realiza.
Si pulsamos el siguiente botn tenemos esta otra pantalla:
Figura 77. Vista de zona de memoria utilizada
Aqu podemos ver de los bits que estamos utilizando, los que estamos gastando como bits
sueltos, los que estamos gastando como byte completo y los que estamos gastando como pala-
bra.
Donde nos seala con un circulito, es un bit que lo estamos gastando suelto. En los bits
que vemos una cruz significa que los estamos utilizando dentro de un byte, palabra o doble pala-
bra. Esto nos lo indica en la columna que tenemos al lado.
Si vamos al siguiente men vemos lo siguiente:
Figura 78. Utilizacin de contadores y temporizadores
Aqu vemos los contadores y temporizadores que estamos gastando.

Si entramos en la siguiente opcin del men superior, vemos lo siguiente:
Figura 79. Vista de la estructura del proyecto
Aqu lo que vemos es la estructura en rbol del proyecto. Vemos los mdulos que son lla-
mados y desde qu mdulos son llamados. En este caso vemos que a la FC 1 se le llama de mo-
do condicional desde el OB 1. A la FC2 se le llama de modo condicional desde la FC 1.
Tambin vemos que tenemos una FC 4 que no la llama nadie en este proyecto.
En todas las ventanas que hemos ido entrando, vemos lo que tenemos seleccionado en el
filtro. El filtro es el botn que lleva dibujado un embudo y un lpiz. All le decimos lo que queremos
ver (entradas, salidas, marcas, etc.) y adems le decimos los bytes que queremos ver.
Veamos lo que podemos ver en la siguiente ventana.
Figura 80. Vista de smbolos no utilizados
Aqu vemos aquellos operandos a los que le hemos dado nombre, pero no hemos utilizado
en el proyecto. Esto se supone que ser un error. Si le he dado nombre se supone que lo debera
haber gastado en el programa.
Si vamos al men siguiente:

Figura 81. Vista de operandos sin smbolo
Aqu vemos lo contrario que en el men anterior. Vemos los operandos que hemos gasta-
do pero no le hemos dado nombre en el simblico.
Si lo que queremos es buscar un operando en concreto, tendremos que volver a la ventana

de referencias cruzadas.
Una vez que estemos all, tendremos que ir al men Edicin > buscar.
Figura 82. Bsqueda de un operando concreto

Aqu seleccionamos el operando que queremos buscar. Podemos escribir tanto el nombre
nemnico como el nombre simblico si es que lo tiene.
Si pulsamos en el botn de buscar, nos buscar en la lista de las referencias cruzadas en

todos los lugares donde aparezca el operando. Si queremos acceder a l slo tenemos que hacer
doble clic sobre l y se abre el bloque donde est contenido y con el ratn nos seala all donde lo
estamos utilizando.

STEP7 y Programacion Siemens PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

STEP7 y Programacion Siemens PDF

Cargado por

Copyright:

Formatos disponibles

STEP7CURSO

Curso STEP 7, nivel I y nivel II. Pg. 2 de 247

1. Operaciones de bit. Instrucciones binarias ................................................ .........6

1. 15. Contadores y comparaciones ............................................................................73

1. 16. Control de un parking.........................................................................................75

Curso STEP 7, nivel I y nivel II. Pg. 3 de 247

Curso STEP 7, nivel I y nivel II. Pg. 4 de 247

Curso STEP 7, nivel I y nivel II. Pg. 5 de 247

1. OPERACIONES DE BIT. INSTRUCCIONES BINARIAS

1.1. Creacin del primer proyecto.

Vamos a realizar el primer proyecto en STEP 7. Dentro de un proyecto de STEP 7 introdu-

Adems tendremos la posibilidad de ajustar desde el software propiedades del propio

Veamos como haramos esto prcticamente.

Abrimos el Administrador de SIMATIC. Tenemos disponible un asistente de nuevo proyec-

Curso STEP 7, nivel I y nivel II. Pg. 6 de 247

Figura 1. Asistente Step 7

Si hacemos el proyecto con el asistente, no tendremos en el proyecto las tarjetas de entra-

En nuestro caso decimos que queremos un proyecto nuevo.

Curso STEP 7, nivel I y nivel II. Pg. 7 de 247

Figura 2. Ajuste de nombre proyecto

Posteriormente podremos insertar tantas redes como nos haga falta.

Curso STEP 7, nivel I y nivel II. Pg. 8 de 247

Figura 3. Primera vista de proyecto nuevo

Curso STEP 7, nivel I y nivel II. Pg. 9 de 247

Figura 4. Vista del catlogo en configuracin HW

A continuacin tenemos que ir rellenando el resto de posiciones que tengamos ocupadas.

Nos situamos en la posicin 1 y vamos a insertar la fuente de alimentacin que es lo pri-

Desplegamos la cortina de las PS, y elegimos la que tengamos en cada caso.

A continuacin nos situamos en la posicin 2 para insertar la CPU. Desplegamos la cortina

Curso STEP 7, nivel I y nivel II. Pg. 10 de 247

El hardware que tenemos en el equipo didctico quedara de la siguiente manera:

Figura 5. Vista de configuracin HW del equipo didctico

Curso STEP 7, nivel I y nivel II. Pg. 11 de 247

Figura 6. Estructura del proyecto con bloque OB1 insertado

Figura 7. Iconos Online/Offline

En este momento tenemos apretado el icono de offline. Apretamos tambin el icono de

Curso STEP 7, nivel I y nivel II. Pg. 12 de 247

Figura 8. Vista conjunta del proyecto en Online/offline

Siempre que estemos en offline, estamos trabajando en la programadora. Estamos le-

Siempre que estemos en online, estamos trabajando directamente en el PLC. Estamos

Curso STEP 7, nivel I y nivel II. Pg. 13 de 247

Si volvemos a pinchar en bloques veremos que slo tenemos los de sistema.

Cuntos tipos de bloques podemos programar?

UDT Tipo de datos.

Veamos lo que podemos hacer con cada uno de estos bloques.

OB: Son bloques de organizacin. Cada OB tiene una funcin determinada. El OB 1

Curso STEP 7, nivel I y nivel II. Pg. 14 de 247

DB: Mdulos de datos. En estos bloques no realizamos programa. Son tablas en

Curso STEP 7, nivel I y nivel II. Pg. 15 de 247

1.2. Contactos en serie.

o Creacin del primer bloque

Vamos a programar nuestro primer OB 1. Entramos en el OB 1 de offline.

Tenemos 3 posibilidades: KOP, FUP y AWL.

o KOP: Esquema de contactos.

o AWL: Lista de instrucciones.

Circuito que queremos programar:

En principio elegimos lista de instrucciones. En STEP 7, podemos hacer toda la progra-

Vamos a programar dos contactos en serie.

El direccionamiento de tarjetas en un S7 - 300 es el siguiente:

Figura 9.Direccionamiento de tarjetas digitales

En el caso de tarjetas analgicas, el direccionamiento es el siguiente:

Curso STEP 7, nivel I y nivel II. Pg. 17 de 247

256 272 288 304