Cómo Programar Step 7 y No Morir en El Intento V2015 02 PDF

Cómo programar Step 7 y no morir en el intento
Aviso Legal
Este libro se ha producido con pasión y esfuerzo por Iñigo Gútiez, dueño de los derechos
de autor del mismo, Copyright 2014 Todos los derechos reservados.
En este momento de finalizar el eBook, son incontables las horas que ha llevado
confeccionarlo. El libro no es nada más que el compendio de un montón de entradas del
blog http://programacionsiemens.com donde he dejado a lo largo de estos dos últimos
años gran parte de mi tiempo libre de forma gratuita. Pero no es el caso de este libro
electrónico. Te pido por ello que:
 No copies partes de este eBook ni lo publiques con o sin atribución o créditos.

 No publique este eBook en plataformas gratuitas.
No es un libro cualquiera. Para empezar porque está en formato electrónico que si bien
puedes imprimirlo, perdería toda su esencia al tener incrustados un montón de links a
vídeos explicativos con ejemplos de programación.
En segundo lugar porque los capítulos probablemente no sigan un orden teórico lógico
ni lo pretenden. Son las transcripciones más o menos fidedignas de lo escrito en el blog
y de ahí su singularidad.
Finalmente porque toda la información aquí recogida ya ha sido publicada en el blog,
por lo que no hay conocimiento nuevo expuesto a lo largo de las próximas ciento y pico
páginas.
Ni que decir tiene que Simatic Step 7 es una marca registrada por Siemens
Agradecimientos y dedicatoria
Mi primer agradecimiento es para ti por haber adquirido este ejemplar pudiendo haber
seguido bebiendo exclusivamente del blog. Si no tuvieras interés por el blog y apreciaras
el esfuerzo que supone su publicación difícilmente este libro hubiera visto la luz.
Mi segundo agradecimiento es para Carlos de www.masvoltaje.com por las
innumerables horas que hemos pasado charlando de lo humano y lo divino… hasta
hemos buscado tiempo para hablar del blog. Aún lo seguimos haciendo.
Por último, pero la primera en importancia, se lo dedico a mi mujer Susana por su infinita
paciencia conmigo, que no siempre es fácil. Por sus consejos. Por su cariño y su dulzura.
Por ser la mujer de mi vida.
Contenido
Aviso Legal ................................................................................................................... 1
Agradecimientos y dedicatoria ...................................................................................... 1
0. Prefacio. .............................................................................................................. 12
¿Qué es este libro? ................................................................................................. 12
¿Qué NO es este libro? ........................................................................................... 12
¿Necesitaré papel y pinturillas de colores? ............................................................. 12
¿También WinCC? .................................................................................................. 13
¿Qué temas contendrá el libro? .............................................................................. 13
¿Garantía? .............................................................................................................. 13
1. Introducción a la programación en Step 7 ............................................................ 14
Programación en Step 7 .......................................................................................... 14
Estructura de la memoria. ....................................................................................... 14
Imagen de E/S ........................................................................................................ 15
E/S de la periferia. ................................................................................................... 15
Marcas .................................................................................................................... 15
Temporizadores y contadores. ................................................................................ 15
Módulos de datos (DB). ........................................................................................... 16
Variables temporales............................................................................................... 16
Módulos .................................................................................................................. 17
Módulos de organización......................................................................................... 17
Funciones (FC) ....................................................................................................... 18
Bloques de función (FB) .......................................................................................... 19
Módulos de datos (DB) ............................................................................................ 21
Módulos de sistema. ............................................................................................... 22
Ciclo del programa .................................................................................................. 23
¿Cómo se puede superar este tiempo?................................................................... 24
2. Métodos de arranque: OB100, OB101 y OB102 .................................................. 25
¿Qué es un OB de arranque? ................................................................................. 25
Ahora sí, que la hemos liado.. quee ¿qué? ............................................................. 25
Arranque completo (arranque en caliente) ........................................................... 25
Arranque en frío ................................................................................................... 25
Rearranque.......................................................................................................... 25
3 métodos de arranque en Step7 ............................................................................ 26
OB100 para el arranque completo ....................................................................... 26
OB102 para el arranque en frío ........................................................................... 26
OB101 rearranque ............................................................................................... 26

Programación del OB100 ........................................................................................ 26
3. El entorno de desarrollo de Step 7 ....................................................................... 28
El entorno de desarrollo de Step 7 Simatic Manager ............................................... 28
El configurador de hardware ................................................................................... 29
El configurador de redes ......................................................................................... 29
El editor de símbolos ............................................................................................... 30
El editor de código................................................................................................... 30
Nuestro primer proyecto en Step 7 “HELLO WORLD!!” ........................................... 31
4. Álgebra booleana (lógica binaria) ........................................................................ 32
¿Qué es el Álgebra booleana en Step 7? ............................................................... 32
¿No hay más? ......................................................................................................... 32
Al grano................................................................................................................... 33
¿Cómo se hace un AND y un OR?.......................................................................... 33
5. Puertas lógicas NOR y NAND en S7 ................................................................... 34
NAND ...................................................................................................................... 34
NOR ........................................................................................................................ 34
6. FB en Step 7 - Ejemplo de una bomba de agua................................................... 36
FB en Step 7 ........................................................................................................... 36
Ejemplo de maniobra de una Bomba de agua ......................................................... 36
Resolución del ejercicio ........................................................................................... 38
7. Multiinstancias en Step 7 ..................................................................................... 39
¿Qué son multiinstancias en Step 7? ...................................................................... 39
Mucho rollo esto de las multiinstancias en Step 7 ¿no? .......................................... 39
Video sobre multiinstancias en Step 7 ..................................................................... 40
8. Funciones en PLC Siemens con ejemplo de semáforo ........................................ 41
¿Qué son los FC en Step 7? ................................................................................... 41
FC Vs. FB ............................................................................................................... 41
Muy bien, pero ¿qué vamos a ver en este capítulo? ............................................... 41
¿En qué va a consistir el ejemplo del semáforo? .................................................... 42
¿Qué herramientas vamos a necesitar para crear este FC en Step 7? ................... 42
9. FC o FB ¿Cuál de los dos usar? .......................................................................... 44
FC o FB................................................................................................................... 44
10. Cómo crear la estructura de un programa en ladder ........................................ 46
¿Qué ventajas tiene una programación en ladder para estructurar un programa en
Step 7?.................................................................................................................... 46
¿Cómo funciona este tipo de programación en ladder? ....................................... 46
El vídeo ................................................................................................................... 48
11. Formas de crear marcas cíclicas en Step 7 ...................................................... 49

Marcas cíclicas del PLC .......................................................................................... 49
¿Cómo se activa? ................................................................................................... 50
¿Y ahora? ............................................................................................................... 51
Marcas cíclicas usando temporizadores .................................................................. 51
Marcas cíclicas usando un OB cíclico ..................................................................... 51
Teniendo OB cíclicos, ¿no hay más formas? .......................................................... 53
12. Algebra booleana (II) – AWL en Step 7 ............................................................ 54
AWL en Step 7 ........................................................................................................ 54
¿Ensamblador? Ya me estas asustando… ............................................................. 54
Instrucciones básicas para programar AWL en Step 7 ............................................ 55
¿No hay negadas? .............................................................................................. 55
¿No hay más? ..................................................................................................... 56
Operaciones de Y lógica. ........................................................................................ 56
Ya bien, pero estooo, una cosita que te quería comentar… .................................... 56
¿Qué es el RLO? .................................................................................................... 56
La definición ha quedado chulísima pero no he entendido ni papa. ..................... 56
Operación O lógica.................................................................................................. 57
¿Por qué? ............................................................................................................... 57
Paréntesis en AWL en Step 7 ................................................................................. 58
Operandos de cierre de consulta............................................................................. 59
13. Step 7… AWL, FUP o KOP ¿Cuál elijo? .......................................................... 60
FUP ......................................................................................................................... 60
KOP ........................................................................................................................ 60
AWL ........................................................................................................................ 61
14. SET y RESET en AWL y alguna cosilla más. ................................................... 63
¿Ya sólo nos queda ver SET y RESET en AWL en lógica binaria? ......................... 63
¿Qué es un set y reset en AWL?............................................................................. 63
¿Qué pasa si se dan ambas condiciones, SET y RESET en AWL? ..................... 63
¿Puede darse ese caso? ..................................................................................... 63
¿Es grave? .......................................................................................................... 63
¿Qué pasa si se da? ............................................................................................ 64
¿De qué depende? .............................................................................................. 64
¿Esto sólo se puede dar en AWL?....................................................................... 64
¿Qué pasa si mezclo Set, Reset e igualaciones? ................................................ 64
Vale, vale… pero ¿qué hay del SET y RESET en AWL? ........................................ 64
¿Chupado no? ..................................................................................................... 64
Forzado del RLO – SET y CLR ............................................................................... 65

¿Cuánto valdrá A1.0? .......................................................................................... 65
Flancos en AWL ...................................................................................................... 65
15. Función MOVE en Step 7 ................................................................................. 67
MOVE en Step 7 (en cristiano) ................................................................................ 68
¿Ahora bien, y si hago un MD4 a MW10?............................................................ 68
¿Y ya está? ......................................................................................................... 68
16. Cómo usar los acumuladores en AWL ............................................................. 70
Acumuladores en AWL............................................................................................ 70
Pero si los acumuladores en AWL son dos, ¿qué pasa con el ACU2? .................... 70
¿Qué tendrían entonces el ACU1 y el ACU2? ......................................................... 71
¿Qué más operaciones se pueden hacer? .......................................................... 71
¿Qué seguridades hay a la hora de realizar operaciones matemáticas? ............. 71
Guay. Pues lo sumo en AWL. .............................................................................. 71
¿Valor de MW10? ................................................................................................ 71
Forma en que carga y se transfiere al ACU1 ....................................................... 72
¿Qué ocurre cuando lees el ACU1? .................................................................... 72
¿Menudo lío no? .................................................................................................. 72
Operaciones con los acumuladores que afectan al RLO ......................................... 72
¿Cuántas operaciones con los acumuladores hay? ................................................ 73
17. Operaciones - Calculadora científica ................................................................ 74
Ejemplo en Step 7 de calculadora científica ............................................................ 74
¿Qué vamos a repasar con este ejemplo en Step 7? .............................................. 74
¿Qué requerimientos va a tener? ............................................................................ 75
¿Tampoco es para tanto no? ............................................................................... 75
¿Me lo explicas? ..................................................................................................... 75
18. Palabra de estado en Step7 ............................................................................. 76
La palabra de estado en Step 7 ¿qué es? ............................................................... 76
Los bits de la palabra de estado .............................................................................. 76
Vale, nombres chulos, pero quitando al RLO y el STA, los demás como que…... 77
Bit 0 -/FC ............................................................................................................. 77
Bit 1 – RLO. ......................................................................................................... 77
Bit 2 – STA .......................................................................................................... 77
Bit 3 – OR ............................................................................................................ 77
Bit 4 y 5 – OS y OV.............................................................................................. 77
Bit 6 y 7 – CCO y CC1 ........................................................................................ 78
Bit 8 – BR ............................................................................................................ 79
19. Control del reloj del sistema en Step 7 ............................................................. 80

¿En qué consiste el ejemplo? ................................................................................. 80
¿Cómo vamos a leer el reloj del sistema? ........................................................... 80
¿Cómo calcularemos el día del año? ................................................................... 81
¿Y si estamos en marzo… o en septiembre? ...................................................... 81
¿Qué es lo que falta? Pues saber si es bisiesto................................................... 81
¿Cómo calculamos si es un día bisiesto? ............................................................ 81
20. Codificación de un display de 7 segmentos...................................................... 83
¿Qué es un display de 7 segmentos? .................................................................... 83
¿Cómo tratamos los datos? .................................................................................... 84
¿Qué es un número BCD? .................................................................................. 84
¿Y el 10? ............................................................................................................. 84
Tratar y filtrar un número de 3 cifras ........................................................................ 84
Perdona, pero... que ¿qué? ................................................................................. 85
Vale. Más o menos lo pillo… pero ¿para qué? .................................................... 85
Ya si eso, igual con un ejemplo… ........................................................................ 85
¿Cómo se te ha quedado el cuerpo? ................................................................... 85
Mmmmm y ¿cómo lo soluciono yo ahora? ........................................................... 85
Desplazar los bits a la derecha................................................................................ 86
¿Qué es lo que hace la operación SHR_W?........................................................ 86
¿Y las centenas? ................................................................................................. 86
Representación en un display de 7 segmentos ....................................................... 86
¿Una palabra a una doble? ................................................................................. 87
Un momento, ¡¡ tú me has estado tomando el pelo todo el rato!!… ......................... 87
21. Temporizadores S7 .......................................................................................... 89
S_IMPULS Temporizadores como impulso .......................................................... 89
S_VIMP Temporizadores como impulso prolongado ............................................ 90
S_EVERZ Temporizadores como retardo a la conexión ....................................... 90
S_AVERZ Temporizadores como retardo a la desconexión ................................. 91
S_SEVERZ Temporizadores como retardo a la conexión con memoria .................. 91
22. Ejemplos prácticos de temporizadores S7........................................................ 92
Filtrado de señales. ................................................................................................. 92
Filtro de guiños positivos. ........................................................................................ 92
¿Cómo? ............................................................................................................... 92
Filtro de guiños negativos........................................................................................ 92
Filtro combinado ...................................................................................................... 93
Crear un tren de pulsos ........................................................................................... 93
Destellos por un tiempo fijo de una señal ................................................................ 94

Reset de un relé de forma segura ........................................................................... 94
23. Cómo crear un cronómetro en Step 7 .............................................................. 96
Cronómetro en Step 7 ............................................................................................. 96
WinCC Flexible ....................................................................................................... 96
¿Cómo? ............................................................................................................... 96
Ya, ya… ¿pero cómo calculas la posición?.......................................................... 96
24. Filtrado y enmascarado de bits en Step 7 ........................................................ 98
Cómo saber si hay una alarma activa (usando todas las alarmas) .......................... 98
¿No valdría con sumar y ya está? ........................................................................... 99
Ummmm en general sí…. en particular… no. ...................................................... 99
¿Descubres la razón? .......................................................................................... 99
Filtrado y enmascarado de bits................................................................................ 99
Vale. Ahora sí que sí hago un cojo-OR eligiendo los bits. ................................. 100
¿Cómo lo hacemos? .......................................................................................... 100
Vale. ¿Cómo podemos saber que hay una alarma descartando el M32.1 cómo
queremos?......................................................................................................... 100
¿Se podría hacer con words en vez de con bytes? ............................................ 102
25. Cómo realizar un tracking de datos en Step7 ................................................. 103
Tracking de datos en Step7................................................................................... 103
El "conceto" ....................................................................................................... 103
¿Qué es lo que vamos a hacer? ........................................................................ 103
Bien, vale... ¿pero cómo? .................................................................................. 104
Y el SFC21 ¿para qué lo quieres? ..................................................................... 104
Y claro, vamos a usar DB... ............................................................................... 104
¿Cuál es mejor? ................................................................................................ 104
¿Por qué dices eso? .......................................................................................... 104
¿Solución?......................................................................................................... 105
¿Qué ventaja tiene usar un DB por posición? .................................................... 105
Pues siempre uso DB separados y ya está... ..................................................... 105
Vayamos con un ejemplo práctico ..................................................................... 106
26. Contadores en Step 7 .................................................................................... 107
Contadores en Step 7 usando un entero ............................................................... 107
Contadores en Step 7 usando INC y DEC ............................................................. 107
Contadores en Step 7 usando contadores S5 ....................................................... 108
Cómo cargar un valor a contadores en Step 7 ................................................... 108
Sumar y restar sobre contadores en Step 7 ....................................................... 108
Poner a cero un contador .................................................................................. 109
¿Y en KOP? ...................................................................................................... 109

27. Saltos: SPA, SPB y SPBN (If-Then-Else) ....................................................... 111
¿Qué son los saltos en Step 7?............................................................................. 111
SPA se usa para saltos incondicionales. ............................................................... 111
SPB y SPBN se usan para saltos condicionados al valor del RLO ........................ 112
¿Qué pasa si no se realiza el salto? ...................................................................... 112
¿Vale, vale… pero como construyo un IF-THEN-ELSE? ....................................... 113
¿Cómo lo hago con saltos en Step 7? ................................................................... 113
¿Lo vemos con un ejemplo? ................................................................................. 113
¿Pero esto no se puede hacer con FUP o KOP? .................................................. 114
28. Cómo anular partes de un programa. ............................................................. 115
Anular parte de un programa comentando líneas .................................................. 115
Anular parte de un programa realizando saltos. .................................................... 115
Anular parte de un programa usando una marca nula ........................................... 116
Anular parte de un programa usando BEA ............................................................ 116
29. Instrucción LOOP – El For /Next del PLC ....................................................... 117
Loop en Step 7 ...................................................................................................... 117
¿Y cómo hago un FOR NEXT con LOOP en Step 7? ........................................ 117
Filtrado de una señal analógica ............................................................................. 118
30. Saltos SPL en Step 7. El Select Case en AWL............................................... 119
¿En qué consiste el SPL en Step 7? ..................................................................... 119
31. Otros saltos .................................................................................................... 121
¿Estado del RB? ¿Lo qué? ................................................................................... 121
Bit 8 – BR .......................................................................................................... 121
Saltos en Step 7 con errores y resultados matemáticos..................................... 121
32. Desplazamiento y giro de bits en Step7 ......................................................... 123
Vale. Hasta ahí lo entiendo, pero ¿qué diferencia hay desplazar entero o un Word a
la derecha? ........................................................................................................... 123
¿Lo qué? ........................................................................................................... 123
En principio no hay diferencia ¿no? ................................................................... 124
Y el giro de dobles palabras............................................................................... 124
¿Podrías poner un ejemplo real de desplazamiento y giro de bits en Step7? ........ 125
33. Giro de bits en step 7: el coche fantástico ...................................................... 126
El vídeo sobre el giro de bits en step 7 .................................................................. 127
34. Direccionamiento indirecto – Memoria y punteros a área ............................... 128
Direccionamiento indirecto .................................................................................... 128
Direccionamiento Indirecto por Memoria ............................................................... 129
Formato palabra – número (indexados)................................................................. 129
Direccionamiento Indirecto con formato doble palabra – Punteros a área ............. 129
¿Se puede cargar los punteros de otra forma? ..................................................... 130
35. Direccionamiento indirecto – Registros y áreas .............................................. 132
Registro de direcciones ......................................................................................... 132
Cargar directamente el puntero ......................................................................... 132
Cargar el puntero y transferirlo al AR1 ............................................................... 132
Cargar el valor numérico de bits y transferirlo al AR1 ........................................ 132
Direccionamiento Indirecto por Registro e Intraárea/Interárea ............................... 133
¿Y esto qué significa en cristiano?..................................................................... 133
¿Resultado? ...................................................................................................... 133
¿Qué se usa más? ............................................................................................ 133
Muy bien, me parece estupendo… pero me he perdido en el L MW [AR1, P#10.0]…
¿qué significa? .................................................................................................. 134
¿Es obligatorio poner ese offset siempre? ......................................................... 134
¿Qué pasa si cargo un P#50.0 en el AR1, cargo un offset P#0.1 y hago una lectura
MB, MW o MD? ................................................................................................. 134
¿Qué más puedo hacer con los registros? ............................................................ 134
¿Qué operaciones puedo hacer con los registros? ............................................ 134
¿Y todo esto, ya sirve para algo? .......................................................................... 135
36. Comparar dos cadenas de caracteres ............................................................ 136
Comparar dos cadenas de caracteres en Step 7 ................................................... 136
¿Para qué sirve eso? ......................................................................................... 136
¿Qué necesitaremos para comparar las cadenas de caracteres? ..................... 136
¿Y cómo vamos a hacer la comparación de las cadenas de caracteres en step7?
.......................................................................................................................... 137
37. Qué es un OB de fallo .................................................................................... 140
Listado de OB de fallo. .......................................................................................... 140
38. Alarmas: Cómo activar y desactivar la baliza ................................................. 142
Gestión de alarmas en S7 ..................................................................................... 142
¿Cómo hacerlo? ................................................................................................ 143
El FC ..................................................................................................................... 143
El DB ..................................................................................................................... 143
39. Buenas prácticas de programación en S7 ...................................................... 145
Tengo una hoja en blanco ¿Por dónde empiezo para realizar buenas prácticas de
programación en S7? ............................................................................................ 145
Vale, ya tengo más o menos claro qué hace y qué necesito… ¿y ahora? ............. 146
¿Por qué no el 111? .......................................................................................... 146
¿Qué nos va a permitir esto? ............................................................................. 146
Asigna rangos a las I/O ......................................................................................... 147

¿Qué ganamos con ello? ................................................................................... 147
¿Pero habría algún problema por ello? .............................................................. 148
¿Qué pasa con las marcas, temporizadores etc.? ............................................. 148
Asigna nombres a las cosas.................................................................................. 148
Buenas prácticas de programación en S7 ............................................................. 148
Asigna una marca de ciclo al principio del proyecto ........................................... 149
Crear un Always_On y un Always_Off ............................................................... 150
Deja espacio, sé generoso con el que venga detrás… ...................................... 150
No seas un talibán de ningún lenguaje. Usa todos a tu antojo, pero con orden. 150
Alarmas ................................................................................................................. 151
Pantallas del HMI .................................................................................................. 151
¿Qué quiero decir con esto? .............................................................................. 151
40. 4 formas de hacer una copia de seguridad de un proyecto de step7 .............. 153
Copia de seguridad de un proyecto de step7 offline .............................................. 153
¿Con eso es suficiente? .................................................................................... 153
Crear una copia de seguridad de un proyecto de step7 mediante archivado. ........ 153
Crear una copia de seguridad de un proyecto de step7 online exacta. .................. 154
Crear una copia de seguridad de un proyecto de step7 online por carpetas ......... 154
41. Cómo proteger bloques en Step 7… si puedes. ............................................. 156
¿Proteger bloques en Step 7? ¿Para qué? ........................................................... 156
42. Conectar un LOGO 8 con un PLC en Step 7 ................................................. 158
¿Por qué usar un LOGO 8 como remota? ............................................................. 158
Conectar un logo 8 con un PLC en Step 7 ............................................................ 158
El vídeo de la lección ............................................................................................ 159
43. PID en Step7: Ejemplo de control de temperatura .......................................... 160
¿Qué hardware vamos a necesitar? ...................................................................... 160
¿Por qué un relé estático? ................................................................................. 160
La tarjeta de analógicas ..................................................................................... 161
¿Y qué hay del software? ...................................................................................... 161
PID en Step7 ..................................................................................................... 161
¿Cómo vamos a hacer ese reparto de tiempos?................................................ 162
44. Configuración de un variador Micromaster 420 .............................................. 163
Configuración básica de un variador Micromaster – El variador ........................... 163
Configuración de la dirección Profibus ............................................................... 163
Puesta en servicio del variador.............................................................................. 164
Configuración básica de un variador Micromaster – El proyecto. ......................... 165
Bits de mando .................................................................................................... 165

La palabra de estado ......................................................................................... 166
45. Entradas analógicas 4-20mA en S7 ............................................................... 169
Programación de la alarma ................................................................................... 171
Graficar la señal .................................................................................................... 171
46. Cómo observar y forzar variables en Step 7 ................................................... 172
¿Qué se puede hacer?.......................................................................................... 172
El punto de disparo ............................................................................................... 173
Otras opciones ...................................................................................................... 173
El vídeo ................................................................................................................. 175
0. Prefacio.
Antes de empezar este libro me gustaría compartir contigo en qué va a consistir y cuál
es su finalidad.
¿Qué es este libro?
Es un libro para aprender a programar en Step 7 desde cuasi cero. Esto significa que
se darán por sentados conceptos como qué es un PLC y para qué sirve. Si has llegado
hasta aquí entiendo que sería una pérdida de tiempo por tu parte y por la mía empezar
desde más abajo. No quiero que este libro sea “de relleno”, sino que sea lo más didáctico
y práctico que sepa lograr, introduciendo la teoría y conceptos mínimos para poder
comenzar a trabajar.
En cuanto al contenido veremos juntos la mayoría de las funciones y bloques que
dispone S7 con los que comenzar de una forma razonablemente solvente a programar
en un entorno S7.
¿Qué NO es este libro?
Lo primero y más importante, no es palabra de Dios. No es, ni pretende ser, un libro

formal y reglado. No hay ni título ni nada por el estilo. Voy a intentar transmitir mis
conocimientos para empezar a trabajar y programar un PLC de Siemens. Será tan
completo como pueda hacerlo, pero nada más.
No es un libro sobre TIA portal. No te quiero engañar: aún apenas lo he usado como
para dar consejos sobre ello a nadie.
En cuanto al hardware no entraré a evaluar cada tarjeta que hay en el mercado ni cada
PLC. Se verá en el libro lo básico y necesario. No es objetivo de este el conocimiento
profundo del hardware sino de realizar programas. El resto vendrá con el tiempo y la
experiencia.
Tampoco me hago responsable de posibles fallos que pueda acometer durante el libro.
La buena fe te la puedo garantizar pero no la infalibilidad que se la dejo a seres
superiores (no, no me refiero a los funcionarios). Por tanto no me hago responsable de
que un programa no funcione bien, ni de los terremotos, ni de que te puedan despedir
porque la máquina le escupa aceite a tu jefe, ni de una guerra termonuclear.
¿Necesitaré papel y pinturillas de colores?
Pues hombre, como puedes imaginar, vas a necesitar un ordenador (portátil o de

sobremesa) con Step 7 instalado junto con PLCSIM y WinCC Flexible.
Además de eso, vas a necesitar una conexión a internet para poder reproducir los
vídeos de ya que el PDF enlazará con los vídeos publicados.
12
¿También WinCC?
Sí. Para poder abrir los ejemplo que creemos, ya que el libro también contendrá
pinceladas del WinCC.
Las versiones que yo voy a usar son las siguientes:
 Step 7 V5.5 +SP1

 WinCC 2008 SP3
 S7-PLCSIM Professional 2010 V5.4 +SP5
¿Qué temas contendrá el libro?

Vayamos al meollo de la cuestión…
Vamos a ver juntos todos los temas relacionados con lo que propiamente es la
programación del software de una forma más tranquila y espero que extensa y profunda
para asentar tan bien como pueda explicarme (que tampoco es que se me dé del todo
bien, seamos sinceros).
Así, veremos con detenimiento todo lo relacionado con la memoria, variables, los
módulos y todos los bloques que considere que tienes que conocer para que una vez
termines el libro tengas unos mimbres para realizar programas de una complejidad
notable.
Además intentaré transmitirte todos los trucos y prácticas que ya he comentado en parte
y otros que puede que aún estén en el tintero. Este tipo de truquillos seguramente sean
más difícil de que los encuentres en otros cursos y libros.
Todo irá acompañado como ya he comentado con los vídeos que considere pertinente
además de explicar mediante ejemplos prácticos.
¿Garantía?
Pues como puedes imaginar más bien escasa. Sólo te puedo ofrecer el compromiso:
 De poner lo mejor de mi parte para poder resolver dudas dentro de mis

conocimientos.
 De haberlo hecho con mimo para sea lo más instructivo y ameno posible.
13
1. Introducción a la programación en Step 7
Vamos a repasar una serie de conceptos generales de programación aplicados en un

entorno de Simatic S7. Lamento que la primera lección sea una pequeña chapa teórica
y que no vayas a ver ni una línea de código, pero por muchas vueltas que le he dado,
es necesario unos mínimos. Pero míralo de una forma positiva, así ya lo damos por
zanjado y pronto comenzaremos a escribir líneas y líneas de código (el que no se
conforma es porque no quiere).
Empecemos...
Los elementos de un autómata como bien sabes son dos: el hardware (el aparato en sí
con sus tarjetas, cableado etc.) y el software (los programas).
Dentro de los programas tendremos dos partes a su vez:
El SO del autómata
El programa de usuario que tú vas a desarrollar y que desempeñará las funciones para
las cuales se ha ideado.
El SO del autómata será el que se encargue por un lado de interpretar y ejecutar el
programa que has diseñado además de otras funcionalidades como pueden ser el
diagnóstico de alarmas y errores, administrar la memoria, comunicación con otros
elementos, exploración de las entradas y la transmisión de órdenes a las salidas entre
otras muchas que sabemos qué hace, pero poco nos importa ahora el saber cómo.
Programación en Step 7
El programa de usuario es sobre lo que versa este libro. En este programa vas a poder
determinar las condiciones con las que arrancará el autómata, tratará datos y señales
del proceso para finalmente dar unas órdenes de actuación sobre los diferentes
actuadores y elementos de la instalación.
Estructura de la memoria.
A grandes rasgos la memoria del autómata va a ser dividida en las siguientes partes:
 Imagen de las E/S.

 E/S de la periferia
 Marcas
 Valor y estado de temporizadores y contadores
 Módulos de datos (DB)
 Datos temporales que se pierden al final de cada ciclo.
14
Imagen de E/S
Las imágenes de las entradas y las salidas no son más que las señales E o A que se
usan en el programa. Pero son eso, imágenes, ya que no leemos el valor instantáneo
de la entrada o forzamos instantáneamente la salida, sino que leemos en el caso de las
entradas el valor de la entrada física cuando se refrescó la imagen de las entradas antes
de comenzar el nuevo ciclo del OB1 (programa principal).
Igualmente en el caso de las salidas, cuando el programa pone a uno o a cero una salida
no lo está haciendo inmediatamente sino que está dando valor a la imagen de la salida,
y esta imagen de la salida será volcada a las salidas reales antes de comenzar un nuevo
ciclo del OB1.
E/S de la periferia.
A diferencia del caso anterior, se puede leer directamente el valor actual de cualquier
sensor. Para ello debemos leerlos en bytes (PEB), Word (PEW) o doble Word (PED) ya
que el acceso no puede ser directo a un bit en concreto (a diferencia de las imágenes
de E/S).
Igualmente pasa con las salidas, que podemos forzar el estado de las salidas de forma
inmediata accediendo a las salidas de periferia (PAB, PAW, PAD)
Marcas
Las marcas son variables indexadas y globales, por tanto no hay que declararlas, pero
si es conveniente darles un nombre y tipo (entero, doble, real…). Se les puede dar valor
dentro de cualquier parte del programa. Dependiendo de la CPU esta área es mayor o
menor.
Los valores pueden ser remanentes tras el apagado del PLC o volátiles (se pierden tras
apagar el PLC).
Su acceso puede ser desde bit hasta un ancho indeterminado si se usan punteros de
área (que veremos más adelante).
Temporizadores y contadores.
La programación en Step7 tiene la peculiaridad de tener temporizadores de dos tipos:

por software (IEC) y temporizadores S7 (o llamados también de S5 ya que existían ya
en la versión anterior).
Estos últimos son temporizadores hardware y son limitados dependiendo de la CPU (por
ser hardware), no así los IEC que por ser creados por software la limitación es la propia
memoria disponible, pero no hay un número determinado de ellos.
15
Los contadores pues son eso, elementos usados para contar o descontar cantidades.
Veremos con detenimiento en su momento las peculiaridades de cada uno de ellos.
Módulos de datos (DB).
Son áreas de memoria que a diferencia de las marcas, está definidas por el usuario.
Pueden ser de longitudes dispares y con contenidos de todo tipo. Las variables
contenidas en los DB son remanentes al apagado del PLC.
Variables temporales.
Son variables que se declaran dentro de los módulos que sirven para realizar cálculos
intermedios y locales que no necesitan ser usados más allá del módulo en cuestión y en
el ciclo en el que son llamadas o tratadas.
¡OJO!
Las variables temporales no se re-inicializan como yo he comentado en el vídeo. El valor

inicial de la variable temporal es el valor último que tomó esa variable, lo cual no deja
de ser tremendamente peligroso ya que si no le das valor antes de leerla el contenido
de dicha variable es indeterminado, especialmente si la función es llamada varias veces
a lo largo del programa y la variable va tomando valores dispares.
16
Módulos
Para acceder y tratar los datos almacenados en las áreas de memoria, existen diferentes
tipos de módulos cuyas características serán diferentes para cada requerimiento que
sea necesario:
 Módulos de organización (OB)

 Funciones (FC).
 Bloques de función (FB).
 Bloques de memoria (DB)
 Módulos de sistema (SFC,SFB,SDB)
Módulos de organización
Lo primero que has de saber de estos módulos es su especialización, sólo sirven para
lo que han sido diseñados y no se llamarán desde otros bloques sino que será el propio
autómata quien gestiona las llamadas a estos módulos en función de sus características.
Hay varios tipos de módulos de organización:
 OB de arranque (OB100-102): Son bloques con los que se arranca el PLC en

función del tipo de arranque y depende del tipo de CPU para que tenga todos los
tipos o solamente el OB100, que es el arranque completo. Sólo se ejecuta una
vez, en el arranque. Una vez terminado pasa al principal.
 El OB1: Es un tipo es sí mismo y es el principal. Se ejecuta de forma recurrente

y desde él se hace llamadas a los FC y FB del programa
 OB cíclicos: También se pueden hacer llamadas a otros FC o ejecutar código

desde estos OB. Tienen la peculiaridad frente al OB1 que se ejecutan a tiempo
fijo (por ejemplo el OB35).
 OB Horarios: Son OB que dependen de la fecha y hora. Se pueden realizar

tareas desde en un momento concreto a ser cíclicos cada x tiempo (desde
minutos a todos los años en un momento concreto)
 OB de fallo (OB85, OB86, OB121 etc.). Son OB predefinidos para cada tipo de
fallo y son llamados cuando el fallo es detectado. Dentro de cada OB se puede
tratar el fallo y tomar las decisiones pertinentes en cada caso.
Todos los OB tienen la peculiaridad de tener reservados 20bytes de memoria local

donde podrás hallar variables específicas de cada OB. Así podrás tener información de
en qué momento ha sido llamado o la frecuencia de llamada en el caso del OB35 por
poner un ejemplo.
17
Los más usados con una diferencia notable con el resto:
 OB100: Arranque desde cero. En el daremos las condiciones y valores iniciales

(si procede) en el arranque.
 OB1: Programa principal (lógico)
 OB35: Programa cíclico por excelencia ya que hay otros pero que no están
disponibles en todas las CPU. Puedes programar tareas a tiempo fijo facilitando
contajes y mediciones que sean necesarias conocer su periodicidad.
Luego están los de fallo que dependiendo de la aplicación usarás unos u otros o
ninguno. Pero con estos 3 tienes el 80% de las necesidades de los OB cubiertos.
Funciones (FC)
Las funciones son bloques que pueden ser llamados desde OB, FC o FB y se usan
fundamentalmente para:
Estructurar el código de tal forma que no esté todo metido en el OB1 sino que se hace
de forma arbórea e inteligible dividiendo el programa por zonas, máquinas,
submáquinas...
Usarlos como funciones que traten unos valores de entrada y den como resultado unos
valores de salida. Lógicamente la idea de esto es por un lado dar claridad y por otro lado
permite la reutilización de la función.
Tienen la peculiaridad de poder definir de forma interna variables temporales con las
que jugar dentro del bloque. Ya se ha comentado hay que tener cuidado con el tema de
18
la remanencia entre ciclos. Lo mejor es darle valor nulo (o el que sea) al inicio del bloque
o bien asegurarse de que siempre toma algún valor a lo largo del bloque antes de usarla.
Teniendo esto en cuenta, podemos crear un FC1 y un FC2. En el FC1 desarrollar un
programa que sume a +b y nos devuelva c. En el FC2, hacer varias llamadas al FC1
para que nos haga varias sumas.
El bloque FC1 denominado "sumar" lo reutilizamos y contendrá variables de entrada y
salida mientras que el FC2 simplemente lo usaremos llamándolo desde el OB1 y lo
denominaremos "todas las sumas" haciendo una única llamada desde el OB1 a este
bloque.
No tiene ninguna importancia la falta de remanencia de las variables intermedias ya que
lo que realiza es un cálculo matemático en cada ciclo.
Bloques de función (FB)
Los bloques de función son parecidos a los anteriores con la particularidad que tienen
variables internas llamadas estáticas que dan remanencia de ciclo a ciclo.
Para lograr esta remanencia tendrán asociado un bloque de memoria (DB) llamados
para estos casos de instancia.
Los FB pueden ser llamados desde los OB, FC o FB además de poder ser usados dentro
de las estáticas de otros FB (multiinstancias).
En definitiva son los módulos que usaremos para una programación orientada a objetos
de otros lenguajes ya que podremos realizar un módulo que nos gestione por ejemplo
un transportador y podremos crear tantos transportadores como queramos pudiendo
19
desentendernos de cómo funcionan internamente una vez sepamos depurado el código

del FB.
20
Módulos de datos (DB)

Los módulos de datos pueden ser der de tipo global o de instancia. Los de instancia los
hemos visto que son necesarios para la ejecución de los FB y toman la estructura de la
declaración de las variables del propio FB.
Los DB globales son módulos declarados por el usuario y pueden contener variables de
todo tipo definiendo estructuras complejas.
En ambos casos el acceso a la información es global ya que incluso se puede acceder
a la información de un DB de instancia desde otro bloque.
21
Módulos de sistema.
Al igual que en los casos anteriores existen una serie de FC y FB que están integrados
en el propio sistema operativo del PLC. Pueden ser llamados y consultados para obtener
o tratar información. Al igual que pasa con los FB, los SFB necesitan de su
correspondiente SDB.
Por ejemplo con el SFC0 podrás consultar la hora del reloj del PLC.
22
Ciclo del programa
Como ya he ido adelantando existen unos módulos que son los encargados de ejecutar
los programas de usuario. En el siguiente esquema puedes ver de forma gráfica cómo
es la ejecución cíclico del programa.
Procesamiento cíclico
Como puedes imaginar, ejecutar todas las instrucciones conllevará un tiempo

denominado tiempo de ciclo.
El tiempo de ciclo es el tiempo medido en ms que se necesita para ejecutar
completamente todas las instrucciones y llamadas realizada desde el OB1, la ejecución
de otros OB llamados (si fuera el caso) y actividades del SO (actualizar las imágenes de
E/S por ejemplo).
El tiempo no es constante ya que no todos los ciclos tienen la misma carga de trabajo
bien porque no siembre se hacen las llamadas de OB cíclicos o porque no se hacen
llamadas a todos los bloques en función de las circunstancias y valores de las diferentes
variables.
Este tiempo está vigilado por un watchdog (típicamente fijado en 150ms fijado en la
configuración del hardware) y si se supera, el PLC se irá a estado de STOP.
23
¿Cómo se puede superar este tiempo?
Pueden ser por varias causas, pero una típica es programar mal un bloque haciéndolo
sin salida (un lazo infinito) con lo que irremediablemente se va a STOP aunque hay otras
como pueden ser un programa excesivamente largo.
También se puede ir el PLC a STOP debido a los tiempos de ejecución por llamadas a
OB cíclicos en tiempos muy cortos con cargas de trabajo muy altas. Por ejemplo,
programando el OB35 a 2ms y si su carga de trabajo es muy alta, puede que con la
siguiente llamada aún no haya terminado las operaciones del ciclo anterior, y el PLC se
coja la baja.
Bromas aparte, veamos más en concreto en qué orden ejecuta las diferentes tareas
durante este tiempo de scan.
En primer lugar cuando arranca el PLC ejecuta los OB de arranque. El más habitual es
el OB100.
24
2. Métodos de arranque: OB100, OB101 y OB102
¿Qué es un OB de arranque?
Un OB de arranque es un módulo que
podemos programar para que se ejecute
una única vez al arranque del sistema.
El programa de arranque puede ser tan

largo como se quiera, no tiene límite de
tiempo y la vigilancia del tiempo de ciclo no
está activa. La ejecución controlada por
tiempo o por alarma no es posible en el
programa de arranque. En el arranque, todas las salidas digitales tienen el estado de
señal 0.
El OB de arranque (OB100, OB101 u OB102) se ejecuta dependiendo del arranque, de
la CPU existente y de los parámetros ajustados en la misma.
 OB100:Arranque completo
 OB101: Rearranque
 OB102: Arranque en frío
Ahora sí, que la hemos liado.. quee ¿qué?
Bien, lo primero que hay que saber es unos conceptos para que cuando lo leamos en
los sesudos libros de Siemens no pongamos cara de pocker por no saber qué carajo
significa cada término.
Arranque completo (arranque en caliente)

La elaboración del programa comienza de nuevo. Se mantienen los datos remanentes.
Arranque en frío
Los datos actuales se pierden y la elaboración del programa comienza de nuevo con los
valores iniciales.
Rearranque
Tras la vuelta de la alimentación, el programa sigue desde el punto interrumpido.
25
3 métodos de arranque en Step7
OB100 para el arranque completo

En nuevo arranque (arranque en caliente), el programa comienza desde el principio:
 Las marcas, temporizadores etc. no remanentes se resetean. Los módulos de
datos con la propiedad no remanente, toman de nuevo el valor inicial.
 Las variables remanentes se mantienen con el último valor juntos. Los módulos
remanentes mantienen el último valor.
OB102 para el arranque en frío

 En el arranque en frío, los módulos de datos creados por SFC se borran de la
memoria de trabajo, el resto de módulos de datos tienen el valor pre ajustado en
la memoria de carga.
 La imagen de proceso, los temporizadores, los contadores y las marcas se
resetean a los valores iniciales guardados en el programa (memoria de carga),
independientemente de si se han parametrizado como remanentes.
 Se lee la imagen de proceso de las entradas y el programa de usuario de STEP
7 comienza de nuevo desde el principio (OB 102 ó OB 1).
Una cosa que hay que tener en cuenta, es que este modo sólo se puede realizar desde
el PG salvo algunas CPU de la serie 400 que tienen interruptores que permiten hacerlo
sobre el propio PLC.
OB101 rearranque
Tras la vuelta de un corte de tensión las CPU de la serie 400 realizan un rearranque.
Este se realiza desde el punto en el que se interrumpió. Esto implica que las variables,
temporizadores etc. no se resetean. En definitiva:
Todos los datos mantienen su último valor válido (incluyendo los datos de la imagen de
proceso).
 La elaboración del programa continúa exactamente en la instrucción en la que
se produjo la interrupción.
 Las salidas no se modifican hasta el final del ciclo actual.
 Al interrumpir la tensión de alimentación, el rearranque sólo está disponible en
el modo de servicio con batería tampón.
Programación del OB100
He de decir que el más utilizado es el OB100, compatible con todas las CPU. Además
tampoco he tenido la necesidad de programar el resto. Aunque supongo que habrá
casos en los que sean necesarios.
26
El uso que se le da al OB100 es fundamentalmente para dar valores iniciales a variables

cuando arrancas desde cero el PLC y para ejecutar acciones que sólo son necesarias
ejecutar una vez.
Una cosa que puede valer por ejemplo, es hacer que una variable se ponga a TRUE
que será un trigger a lo largo del programa y que al terminar, resetees dicha variable
para que no se ejecute en el segunda y sucesivas ejecuciones del OB1.
Así, dentro del OB100 podemos hacer
SET
= M0.0
Y al final del OB1
CLR
= M0.0
Si necesitas más información, te dejo las referencias para que sigas leyendo sobre el
tema.
Referencias:
 http://cache.automation.siemens.com/dnl/jExNDU0NwAA_18652056_HB/S7prv
54_s.pdf
 Diferencias entre tipos de arranque
27
3. El entorno de desarrollo de Step 7
Todo lenguaje de programación tiene un entorno de desarrollo. El entorno de desarrollo

de Step 7 se divide en varias partes:
 Simatic Manager.
 Configurador del hardware
 Configurador de Red
 Editor de programación
 Editor de símbolos
El núcleo desde el que normalmente se llama a todos los demás es el Simatic Manager
aunque se pueden acceder y lanzar los programas por separado desde la carpeta de
Simatic dentro de los programas disponibles en tu PC.
Vamos a ver como es el entorno de un modo general ya que no te interesa ni a ti ni a mi
profundizar en estos momentos. Pienso que si no conoces bien Simatic ni Step 7 te
puedo aburrir dándote un montón de detalles que te van a sonar a chino y que realmente
no vas a necesitar de momento.
Por tanto veremos un barniz de lo que es el entorno de desarrollo en Step 7 y nada más.
Finalmente terminaremos creando una vez conozcamos estas generalidades nuestro
primer proyecto en Step 7sobre el que trabajaremos en capítulos posteriores.
El entorno de desarrollo de Step 7 Simatic Manager
28
El configurador de hardware
El configurador de redes
29
El editor de símbolos
El editor de código
30
Nuestro primer proyecto en Step 7 “HELLO WORLD!!”
31
4. Álgebra booleana (lógica binaria)
Bueno. Basta de ver vídeos donde se explican muchas cosas bastante aburridas y aún
sin programar ni una línea de código... el álgebra booleana en Step 7 is here.

Vamos a comenzar a teclear. No mucho, pero
vamos a realizar nuestros primeros pinitos.
Primero vamos a empezar a programar en Ladder,
escalera o KOP. Es una forma dinámica de
empezar a hacer cositas y nos va a servir para la
en siguientes capítulos ver sobre lo aprendido,
cómo se haría en AWL ya que se va a entender
creo que mejor.
¿Qué es el Álgebra booleana en Step 7?
Bueno, en Step 7 y en cualquier lenguaje.

No se trata más que de entender y poner en práctica el álgebra de Boole. No te voy a
aburrir sobre que es un OR y un AND, ya que entiendo que todo el mundo sabe qué es.
Si no lo sabes, échale un vistazo a:
 Algebra de Boole (Wikipedia)

 Algebra booleana (Monografías.com)
 Álgebra de Boole (uhu.es)
En definitiva, qué mejor para un PLC que se mueve con ceros y unos, que programar
en base a puertas OR, AND y NOT.
¿No hay más?
Estrictamente hablando no, ya que el resto de las operaciones binarias se basan en las
anteriores... son, por así decirlo, los colores primarios del álgebra de Boole.
Por cierto, el señor tan estirado y con pinta de listo es el señor George Boole, el padre
de la criatura la cual data de mediados del siglo XIX. Sí, no les servía para gran cosa
entonces, pero ya le daban al rosco por entonces a estas cosas.
Como construir todos nuestros programas a base de AND y OR sería un trabajo que
acabaría con la salud de más de uno (entre los que me incluyo) hay otros operadores
más elaborados que permiten realizar funciones más complejas como son el xor, set,
32
reset, pulsos … que nos ayudarán a realizar programas eficientes en plazos de tiempo
razonables.
Al grano...
La programación en escalera o ladder es la más común en la mayoría de los lenguajes

de programación de PLC. En el caso de Siemens, esta programación se llama KOP
(Kontaktplan) o diagrama de contactos en la lengua de Cervantes.
La idea básica es dibujar diagramas eléctricos como si con contactos de relés se tratara.
¿Cómo se hace un AND y un OR?
Básicamente un AND lo harás mediante dos contactos

en serie de tal forma que sólo se active la bobina si
ambos contactos están cerrados. Análogamente un OR
lo realizarás colocando dos contactos en paralelo de tal
forma que la bobina se active si uno de los contactos O
el otro se activa. ¿Brillante eh?
Pero, lo mejor como siempre es ver... Contactos en serie y paralelo, negaciones,
set/reset y pulsos en un bonito video donde veamos cómo usar todos los elementos
además de un pequeño ejemplo de cómo crear un telerruptor en Step 7.
33
5. Puertas lógicas NOR y NAND en S7
NAND
Una puerta lógica NAND no es más que hacer un AND normal y su resultado, darle la
vuelta (negarlo)
La fórmula, es la que tienes a la derecha, que lo que viene a decir es que la negada de
un AND es lo mismo que hacer un OR de las negadas.
Es decir
U M200.0
U M300.0
NOT
= M400.0
Es lo mismo que hacer

ON M200.0
ON M300.0
= M400.0
En resumen, que el resultado siempre será TRUE salvo que ambas marcas (M200.0 y
M300.0) estén a 1.
NOR
Análogamente, diremos que hacer un NOR no es más que hacer un OR, y su resultado
darle la vuelta (negarlo).
Como veis en la fórmula, es muy similar. La negada de la suma es igual al producto de

sus negadas… o en castellano de andar por casa, un NOR equivale a hacer un AND de
las negadas de las señales.
34
En AWL tendríamos:
U(
O M 200.0
O M 300.0
)
NOT
= M 400.0
O lo que es lo mismo:
UN M200.0
UN M300.0
= M400.0
Ojo con los paréntesis ya que el NOT ha de ser del OR completo. En un AND no es
necesario, pero al hacer un OR sí lo es porque de otra forma sólo tendría en cuenta el
segundo operando.
Al contrario que en el caso anterior, el resultado siempre será FALSE salvo cuando
ambas señales estén en FALSE, dando en este caso, el único caso donde el resultado
es TRUE.
Dar las explicaciones y comentarios, se lo dejo al interesado para que lo diga con sus
propias palabras.
Adicionalmente echa un vistazo a la wikipedia donde lo explica perfectamente e incluye
las tablas de la verdad. Yo sólo colaboro con el mini ejemplo de programación en AWL.
35
6. FB en Step 7 - Ejemplo de una bomba de agua
Para ir creciendo un poco más en la lógica binaria antes de entrar en lógica binaria en
AWL, vamos a ver un par de ejemplos después de haber visto los primeros fundamentos
con el álgebra de Boole.
El primero será crear FB en Step 7 y el siguiente será crear FC.

La idea es ir introduciendo conceptos nuevos, y no se puede programar en Step 7 si no
se conocen los FB y los FC.
FB en Step 7
Comenzamos con los FB. Son más completos que los FC ya que como vamos a ver,
van a tener remanencia a diferencia de los FC que nos servirán para otros menesteres
como veremos pronto.
Como ya dijimos en la introducción los FB no son más que unos bloques que nosotros
vamos a construir y que va a poder tener una serie de variables (ninguna de ellas
obligatoria):
 Variables de entrada
 Variables de salida
 Variables de entrada/salida
 Variables temporales
 Variables estáticas (remanentes)
Como bien digo, no es obligatorio el uso de ninguna de ellas ya que se puede hacer la
llamada al FB y dentro de este usar variables globales (marcas u otros DBs).
Lo único que es obligatorio es crear un DB de instancia asociado al FB. Este DB nos
servirá para almacenar la información remanente aunque veremos que todas las
variables quedan reflejadas en él (todas las que se declaren, claro).
No hay que declarar ninguna variable dentro del DB ya que Step 7 lo va a hacer por ti a
la hora de hacer la llamada o al crearlo desde el Simatic Manager.
Ejemplo de maniobra de una Bomba de agua
Para ver cómo crear FB en Step 7 de forma práctica vamos a hacerlo a través de un
ejemplo de manejo de una bomba de agua.
Se trata de un tanque que tiene un mínimo y un máximo que es abastecido entre estos
límites a través de una bomba. Esta bomba toma el agua de una fuente sin determinar
y que no viene al caso.
36
La cuestión es que hay que hacer:
 A través de una maneta de OFF/ON, poner el sistema en posibilidad de trabajar.

Cuando se pasa al estado ON, la máquina se pone en modo manual.
 El modo manual es simple. Si se activa el botón de marcha de la bomba, esta
bombea sin límites. Si se vuelve a pulsar se para.
 El modo automático se pone cuando se pulsa el botón de auto/man. Tras pasar
a auto hay que pulsar el botón de marcha de la bomba y esta trabajará entre el
mínimo y el máximo. Cuando pierde el mínimo se activa y cuando llega al
máximo se para.
 Si se vuelve a pulsar el botón de auto/man se pasa de nuevo a manual y la
bomba se para.
 Hay una serie de leds para indicar los estados de auto, manual, marcha y paro
de la bomba.
Para visualizar todo esto mejor, te he preparado un vídeo donde se explica el ejercicio
(sin solución).
37
Resolución del ejercicio
En el siguiente vídeo puedes ver la resolución del ejercicio.
38
7. Multiinstancias en Step 7
¿Qué son multiinstancias en Step 7?
Empezaremos definiendo qué es una instancia en programación. De Step 7 o de Visual

Basic. Eso es lo de menos.
El vocablo instancia proviene de la programación orientada a objetos y de las clases.
Sin meterme en berenjenales que no domino es mejor explicarlo mediante un ejemplo:
Una clase podríamos definirla como el concepto fantasma del Pacman con todas sus
cualidades, propiedades y funcionalidades.
Una instancia sería uno de los fantasmas en concreto sin tener en cuenta el color. Al
pertenecer a la clase fantasma, tendrán las mismas propiedades y funcionalidades entre
ellos, pero no los mismos valores en cada uno de los campos, por así decirlo. Así por
ejemplo pueden tener diferente color pero siguen perteneciendo a la misma clase.
Llevándolo a nuestro campo, crear multiinstancias en Step 7 va a ser crear nuevos
objetos que hagan referencia a la clase a la que pertenecen.
Así, la clase puede ser TON (un temporizador IEC como retardo a la conexión) y lo que
haremos será crear tantas instancias de ese TON como necesitemos. Es decir,
crearemos esos temporizadores de verdad dentro de nuestros FB.
Como la creación de estos TON puede ser múltiple o conjugada con la creación de otras
instancias diferentes, se denominarán multiinstancia.
Mucho rollo esto de las multiinstancias en Step 7 ¿no?
Bueno.
Si lo resumimos y no nos andamos con tantas tonterías... multiinstancia en Step 7 es
que puedes incrustar en las variables STAT de un FB otros FB más pequeños como por
ejemplo el TON o TOF de los que hemos hablado.
¿A que ahora lo has entendido a la primera? Seguro que sí.
Como vas a ver a continuación, lo más típico es incrustar instancias de temporizadores
IEC. Digo lo típico por veces que sucede esto respecto a otro tipo de instancias, no
porque no se puedan hacer de otro tipo.
39
Video sobre multiinstancias en Step 7
Como siempre, lo mejor es verlo en un vídeo porque es como mejor se va a entender el

concepto que es sencillo pero hay que haberlo visto antes.
40
8. Funciones en PLC Siemens con ejemplo de semáforo
¿Qué son los FC en Step 7?

Las funciones en PLC Siemens son similares a las funciones en otros lenguajes de
programación. En los FC en Step 7 se hace la llamada con unas variables de entrada y
tras su ejecución nos devuelve unos valores para las variables de salida. Nada nuevo
en el firmamento.
Pero los FC en Step 7 no se usan exclusivamente para calcular una salida, sino para
la organización del programa dentro del proyecto. Es decir, se realizarán llamadas a los
FC sin valores de entrada ni valores de salida si bien adicionalmente puede que se usen
las variables temporales para uso interno dentro del FC.
FC Vs. FB
El FC en Step 7 en general se usa más que los FB por par de razones: no necesita
asociar un DB (y por tanto ahorras memoria y es más limpio el programa) y no siempre
es necesario la re-utilización del código. Si es necesario almacenar datos, podemos
hacerlo en marcas o en DB globales.
Por tanto, los FC en Step 7 no presentan grandes desventajas frente a los FB más allá
que los FB son para una programación orientada a objetos, en los que el bloque FB
represente un objeto genérico (por ejemplo, un transportador o un variador) y se pueda
reutilizar ese bloque infinidad de veces a lo largo del programa con la peculiaridad de
necesitar almacenar datos de esos objetos. En este caso, sí que el FB es más indicado
que el FC.
Muy bien, pero ¿qué vamos a ver en este capítulo?
Evidentemente algo tenemos que hacer porque definir un poco lo que hace un FC de
poco o nada sirve si no avanzamos en el conocimiento de las funcionalidades de los
PLC de Siemens, que es de lo que se trata.
Como habrás visto en el título vamos a realizar un ejemplo de semáforo en Step

7. Normalmente este programa es de los primeros que se hacen con temporizadores…
pero ya haremos otros ejemplos cuando veamos los temporizadores de S7.
Lo vamos a hacer mediante una función y contando tiempo, que también sabe muy bien
el PLC.
41
¿En qué va a consistir el ejemplo del semáforo?
Básicamente vamos a tener un semáforo para los vehículos rodados el cual va a tener
sus tres colores (rojo, verde y ámbar) y otro para los peatones de color rojo y verde.
Además, el verde parpadeará cuando se vaya a acabar el tiempo en verde y tendrá un
botón de solicitud que si es pulsado, cambiará a verde para los peatones previo paso
del asociado a los vehículos por el amarillo. La pulsación del botón hará que se ilumine
el letrero de solicitud que se mantendrá iluminado hasta que se ponga en verde para el
peatón.
¿Qué herramientas vamos a necesitar para crear este FC en Step 7?
Para realizar este ejemplo vamos a ver algunos conceptos nuevos en Step 7 como son:
 Comparación
 Transferencia
 Conversión
 Marcas de ciclo
Durante las explicaciones del vídeo vas a poder ver cómo usar estos elementos
en nuestro ejemplo de FC en Step 7, que como verás es casi trivial. El único que tiene
un poco más de miga es el de conversión ya que sirve para tomar una variable y pasarla
a otra variable de otro formato. Me explico.
No es lo mismo tener un “-2″ en entero, que un “-2″ en doble entero, lo mismo que no
es que tener un “-2″ en real. Para empezar, porque en entero ocupa un Word mientras
que en doble entero y en real ocupan 4 bytes (doble Word). Para continuar, porque en
real, no tienes un “-2″, sino que tienes un “-2.0″, que es igual, pero no es lo mismo que
dirían Martes y Trece.
Cada tipo de variable además de ocupar una serie de bytes, (2, 4 o los que sean) tienen
un formato en particular (hay que poner la mantisa, el signo etc.), por lo que para poder
hacer operaciones matemáticas entre dos variables, tienen que estar en el mismo
formato ya que si no, pueden pasar dos cosas:
 En FUP o KOP no te dejará realizar la operación matemática ya que no son

variables con el mismo formato.
 En AWL sí que podrás, pero la que puedes montar con el PLC si no lo haces
bien la recordarás durante tiempo.
Como nosotros estamos empezando y estamos programando nuestro PLC en KOP, no
vamos a poder cometer errores a la hora de sumar, ya que el propio Step 7, no nos lo
va a permitir.
Finalmente, sobre la marca de ciclo puedes encontrar más información además de en
el vídeo en 3 formas de crear marcas cíclicas en Step 7 del capítulo siguiente.
42
Veamos el vídeo para finalizar donde crearemos nuestro proyecto en WinCC y vamos
a poner los requerimientos y dar con la solución.
43
9. FC o FB ¿Cuál de los dos usar?
Cuando empiezas a programar tal vez te surja una duda cuasi existencial… ¿Qué es
mejor usar? ¿FC o FB?… pues básicamente, depende.
En general con ambos se pueden hacer lo mismo. Cambia la forma. Pero digamos que
no están pensados para lo mismo.
Los FC serán ideales para generar resultados que no tengamos que almacenar. Dentro
de la automatización lo usaremos en la lógica general de los programas. Pueden ser
usados en líneas generales de actuación de las máquinas, secuencias e interrelación
entre ellas.
Los FB son como los FC, pero vitaminados. No solamente podremos hacer lo que
hacemos con los FC sino que además podremos almacenar valores ya que tienen
asociados DB. Además podremos usar los temporizadores IEC de forma muy sencilla
evitando complicarnos con los temporizadores de S5 para nuestros propósitos. Serán
adecuados para el manejo de motores, variadores etc. ya que podremos juntar similares
funcionalidades bajo el mismo FB usando DB para cada uno de ellos.
FC o FB
Está claro entonces… uso FB siempre y ya está.

Esta es la conclusión a la que fácilmente podrías llegar tras lo expuesto. Antes de dar
este paso hay que tener en cuenta que los FB siempre han de tener un DB asociado.
Eso en sí mismo no es un problema, pero puede serlo si el programa es extenso y has

de tener muchas funciones para una correcta organización del programa. El uso
innecesario de FB hacen que se ocupe memoria de forma innecesaria ya que generarás
un DB lo necesites o no.
Si todo lo haces con FB, y el proyecto es suficientemente complejo, tendrás un sinfín de
DB. Hay que elegir por tanto los FB en general cuando:
El FB controle un actuador o motor y tengas varios del mismo tipo de tal forma que
puedas reutilizar el FB no necesitando usar marcas. Esto hace que sea más fácil de
mantener y más difícil de cometer errores ya que no necesitarás tener en cuenta qué
marcas están usadas y cuáles no.
Necesitas guardar datos de forma permanente. Qué mejor hacerlo a través de un FB ya
que así tienes un DB asociado donde guardar estos datos.
Si vas a usar el FB con diferentes motores por ejemplo, y necesitas temporizadores.
Puedes usar los temporizadores IEC y usarlos como multiinstancias.
¿Cuándo usaremos los FC entonces?
Para planteamientos generales de las aplicaciones, o para actuadores que no necesiten
ser reutilizados.
44
Funciones aritméticas, trigonométricas o de otra índole que no necesiten almacenar los

datos y que simplemente nos devuelva un valor o que se utilicen marcas globales.
En definitiva, habrá que evaluar cada caso para saber qué usar. Por lo general
personalmente uso más los FC que FB, pero dependerá del proyecto en concreto.
Para finalizar adjunto un video en el cual presento las diferencias entre los FB y los FC
en ejemplos muy sencillos: un sumador, un totalizador de tiempo y el uso de
temporizadores. Ahí quiero mostrarte las diferencias entre ambos para que puedas intuir
con más facilidad cuál es el concepto para cada caso.
45
10. Cómo crear la estructura de un programa en

ladder
La programación en ladder es sin duda la programación de autómatas programables

más extendida, incluidos los PLC Siemens.
Esta entrada va a ser más de estilo de programación que de herramientas disponibles
dentro de step 7.
Hay muchos programadores que son defensores y enamorados de Grafcet. A mí
personalmente como programador y mantenedor de las instalaciones no me gusta.
Puede ser que por desconocimiento, por falta de uso ya que trabajo con ello pero muy
muy poco, o por una manía personal.
La cuestión es que para el grado de automatización en el que me muevo dentro de este
sector de la automoción no he encontrado aún una razón por la que usar Grafcet ya que
con un ladder bien estructurado es más que suficiente.
¿Qué ventajas tiene una programación en ladder para estructurar un

programa en Step 7?
 Es universal. Lo va a entender todo el mundo y todo es estándar con la programación

de escalera normal.
 No necesita un software especial de pago como es Grafcet.
 A mi juicio más fácil de seguir si está bien estructurado.
 Muy compacto. Más que los diagramas de bloques, por ejemplo.
¿Cómo funciona este tipo de programación en ladder?
Lo primero que he de decir es que todo esto entra dentro de la forma de programar de
cada uno. Yo te voy a contar esta forma, que la puedes adaptar, copiar literalmente o
crear una nueva desde cero. Es una forma de hacerlo, nada más. No es palabra de
Dios, ni mucho menos.
Básicamente la idea es coger tu máquina y dividirla en movimientos lo más sencillos
posibles pero que tengan una entidad suficiente como para ser merecedor de dedicarle
un par de FC sólo para él. Nada nuevo.
Lo siguiente es asignar una palabra o una doble palabra para este FC.
Finalmente la idea es establecer unas condiciones iniciales de arranque de la secuencia.
Cuando se cumpla, haremos un SET del primer bit. Imaginemos la M0.0.
Esto arrancaría la secuencia. Una vez iniciada esta M0.0 realizará una acción simple.
Cuando se cumpla la acción asociada y las condiciones de control de esta M0.0,
haremos un SET de la M0.1 y haremos un RESET de M0.0.
46
Sucesivamente, con las condiciones del siguiente estado, activaremos la M0.2 y

resetearemos el M0.1 y así sucesivamente.
Ahora bien, para que este sistema funcione bien, sea claro y no se complique más de
lo necesario la programación en ladder, las condiciones deben estar lo más resumidas
posibles (usando variables intermedias) y no se deben activar las salidas.
Para ello vamos a dividir esta parte de la automatización en dos:
Un FC para la lógica explicada y las condiciones de inicio/finalización de los segmentos
Un FC/FB para las salidas de los actuadores con una pequeña lógica de la parte auto
con la de manual.
47
Lógicamente, y dependiendo de cada caso, puede que haya varios FC para la lógica
pero solo una para las salidas, por ejemplo. Lo importante es el concepto de separar la
lógica por un lado y las salidas por otro.
El vídeo
Como siempre, te dejo con un vídeo explicativo donde se ve mejor lo ya comentado.
48
11. Formas de crear marcas cíclicas en Step 7

En este capítulo vamos a ver formas fáciles para crear marcas cíclicas que luego
podamos usar a lo largo y ancho de nuestro programa. Así podremos usar:
 Las marcas de ciclo

 Temporizadores
 Crear la marca en OB cíclicos
Como digo la idea es que podamos hacer llamadas o acciones a tiempos
fijos. Normalmente, y si necesitamos una precisión alta, tendremos que realizar la
acción o llamadas desde OB cíclicos cuya frecuencia habremos fijado de antemano al
configurar el HW. Pero no es la única forma de realizar acciones a tiempos fijos.
Claro que tiempos fijos, más o menos, porque lo que te voy a mostrar a continuación es
para ser usado desde el OB1 o FC/FB que dependan del OB1 y por tanto el error que
vamos a introducir es del orden del tiempo de ciclo total del PLC.
Esto implica que si queremos flancos cíclicos a tiempos de 100ms, no uses jamás el
OB1 ya que el error que estás cometiendo el del orden de magnitud que la periodicidad
deseada, es decir, si quieres tiempos fijos y la llamada es del OB1 cuyo tiempo de ciclo
varía entre 10 y 30ms, pues hombre, menos preciso, es cualquier cosa.
Ahora bien, si tus marcas cíclicas van a ser del orden de segundos, la cosa cambia ya
que el error que vas a cometer es pequeño. En cualquier caso, usaras este tiempo de
marcas cíclicas en acciones en el que la precisión no sea crucial. Creo que está claro el
concepto.
Marcas cíclicas del PLC
Haciendo un corta y pega de la ayuda de Siemens, esta dice lo siguiente sobre las
marcas de ciclo:
Las marcas de ciclo son marcas que cambian periódicamente su valor binario (relación
impulso – pausa: 1:1)
¿A que ahora te has quedado más tranquilo? Yo también.
Afortunadamente, tiene una segunda ayuda en la cual muestra una tabla con los
periodos de estas marcas.
49
Como veis va desde una frecuencia de 0,5Hz hasta los 10Hz pasando por valores
intermedios. Visto desde el lado del periodo, va desde valores de 0,1 segundos hasta
los 2 segundos.
¿Cómo se activa?
Configurándolo desde el configurador de hardware. Tendrás que abrir el configurador

de HW, abrir la CPU e ir a la pestaña de Ciclo /Marca de ciclo. Abajo tienes que
seleccionar el checkbox de marca y seleccionar el número de marca que quieres usar.
Ojo porque es un byte, no un Word. Tenlo en cuenta. Hay 8 marcas de ciclo.
50
¿Y ahora?
Pues tienes que guardarlo, compilar y cargárselo al PLC. Ojo porque el PLC va a pasar
a STOP, así que:
Siempre que empieces un proyecto en Step 7, selecciona y configura

un byte para tu marca de ciclo
No cuesta nada, y así no tendrás el pequeño inconveniente de que cuando lo quieras

usar, pues no podrás porque la máquina estará en marcha y no la puedes parar hasta
dentro de no sé cuántos millones de horas… y todo por no haber elegido una marca
cuando configuraste el hardware.
¿Adivinas a quién le ha podido pasar algo así alguna vez? Pues eso.
Marcas cíclicas usando temporizadores
Otra forma común de realizar ondas cuadradas es con dos temporizadores. La forma de
construirlo es muy sencillo como muestra en la imagen. Ambos temporizadores se irán
alternando en el contaje del segundo.
El temporizador T2 tendrá un periodo de 1s su salida a cero y un periodo de su salida a
1. El T1 por su parte estará siempre a cero salvo un instante (un ciclo de scan) que será
el desencadenante de tirar el T2 y que vuelva a empezar.
Así, haciendo la lectura del T2, tendremos una marca cíclica de periodo 1segundo en
este caso. La ventaja de este, es que se puede variar la relación de tiempo ON/OFF
jugando con los tiempos del T1 y del T2.
Marcas cíclicas usando un OB cíclico
Una forma de crear una marca cíclica es usar un OB cíclico. Imaginemos que queremos
cada 0,5 segundos. Cargaremos un OB cíclico que fijaremos a 500ms. Luego haremos
un súper código. Imaginemos que queremos hacerlo con la M50.0:
UN M50.0
51
= M50.0
Escalofriante ¿eh? Es tan simple que da miedo. Cada 500 ms irá cambiando de estado.
Brillante.
Hombre, usaremos los OB cíclicos aprovechando que ya exista, pero si te quieres pegar
un lujo, es una forma de hacerlo.
52
Teniendo OB cíclicos, ¿no hay más formas?
Pues hombre, sí. Por ejemplo, creando contadores de 1 a 10 en el OB35 y si está fijado
a 100ms por ejemplo, poniendo a uno una marca cuando el contador sea superior o
igual a 5 y reseteando cuando sea igual o superior a 10.
Bueno, como ves hay muchas formas de crear marcas cíclicas. Espero que te haya sido
de utilidad y que lo uses mucho en tus proyectos.
53
12. Algebra booleana (II) – AWL en Step 7
¿Recuerdas al señor de la izquierda? Lo vimos en

el capítulo de álgebra de Boole. Hoy vamos a ver
un poco de lógica binaria de AWL en Step 7.
Sí. Antes de ver los temporizadores.
¿Por qué antes?
Pues porque cuando veamos los temporizadores,
habrá que verlos también en AWL y hombre, no
quiero que te dé un derrame cerebral así de
primeras. Pero lo veremos enseguida.
AWL en Step 7
Deberíamos empezar por ver qué es el AWL.

El AWL no es más que uno de los tres lenguajes básicos de Step 7.
Es la mamá de todos los lenguajes en Step 7. Todos finalmente se van a traducir a AWL
y todo aquello que no se pueda programar en AWL es que simplemente no lo vas
a poder programar. Otra cosa es los sudores que te costaría hacer directamente en
AWL tareas complejas, pero por poder, se podría.
Con AWL en Step 7 se pueden hacer auténticas filigranas ahorrando código a más no
poder. Digamos que es la forma de programar más compacta de todas (en general).
Si hiciéramos una comparación con otros lenguajes, tendríamos lenguajes de alto nivel
como el Pascal (SCL en nuestro caso) y luego tendríamos lenguajes de bajo nivel como
Ensamblador, que en nuestro caso sería el AWL.
Puede que la comparación no sea lo más acertada del mundo, pero suficientemente
buena a mi juicio para que te hagas una idea.
¿Ensamblador? Ya me estas asustando…
No te asustes, que no es para tanto. Digo que es similar a ensamblador en el sentido de

que es un lenguaje básico, con instrucciones primarias que se ejecutan “a pelo” le
pongas lo que le pongas por delante.
Por poner un ejemplo. Ya hemos dicho con anterioridad que no puedes comparar en
FUP y en KOP valores enteros con reales, por poner un ejemplo. En AWL sí se puede.
54
¿Tiene sentido?
Ninguno.
Pero AWL no entiende de variables enteras, entiende de bits. Y si tú le indicas que haga
una suma entera de dos variables, lo hará. Si el formato de estas variables está correcto
todo irá bien. Si está mal pues el PLC hará cosas muy pintorescas y divertidas… los
primeros dos minutos.
Después de 15 minutos sin tener ni pajolera idea de qué pasa, deja de tenerla. Con el
tiempo te darás cuenta de que no tiene nada de gracia ya desde el principio.
Frustraciones personales a parte, con todo esto quiero que te quedes con dos cosas:
 El AWL es el lenguaje base del resto.

 Todo es traducible a AWL, pero no al revés.
La primera parte creo que ha quedado clara. La segunda, la vas a ver clara enseguida.
Los lenguajes FUP y KOP cuando lo traduces a AWL crean instrucciones que a veces
son inservibles de cara a la ejecución del programa pero necesarios para la propia
integridad del lenguaje FUP y KOP. Necesitan de esas instrucciones para dar
consistencia a lo que estás dibujando y de ahí que creen líneas que en principio no
serían necesarias para un funcionamiento idéntico realizando el programa directamente
en AWL.
El problema está que si realizas el programa en AWL directamente, si quieres traducirlo
a KOP, por decir uno, el editor no va a tener la capacidad de entender qué diantre
quieres hacer. Y por tanto, no podrá traducirlo.
Por tanto siempre podrás traducir FUP y KOP a AWL (más o menos depurado) pero en
general, no podrás traducir código AWL a FUP y a KOP. Es así. Asúmelo.
Así que empecemos con las cosas básicas que debes tener claras antes de empezar a
programar en AWL.
Instrucciones básicas para programar AWL en Step 7
Las instrucciones básicas van a ser:
 U para hacer un AND

 O para hacer un OR
 X para hacer una O exclusiva
 = para igualación
¿No hay negadas?

Veo que estás despierto. Efectivamente. También tendremos:
 UN para hacer un AND negado

 ON para hacer un OR negado
 XN para hacer una O exclusiva negada.
Luego lógicamente tendremos paréntesis (). Pero eso más tarde.
55
¿No hay más?

Sí que hay más. El Set, Reset, flancos… pero de momento, quédate con los básicos
que son los de ahí arriba.
Operaciones de Y lógica.
Esto lo vas a pillar enseguida verás. Imagina que tienes dos entradas que cuando están
las dos a true (1), tenemos que activar una salida. La lógica sería así:
U E 0.0
U E 0.1
= A 1.0
Es decir, iniciamos el segmento leyendo lo que hay en el E0.0 y le hacemos un AND
con el E0.1 y su resultado se lo asignamos a la salida A1.0.
O de otra forma, cargamos el E0.0 en el RLO y luego hacemos un AND de la E0.1 con
el RLO y se lo asignamos a la A1.0
Ya bien, pero estooo, una cosita que te quería comentar…

¿Qué es el RLO?
¿Siglas chulas eh? ¿De alguna organización?
Pues no. El RLO no es más que una variable que almacena el valor de una
operación binaria. Es especialmente relevante en la programación de AWL en Step 7.
La definición ha quedado chulísima pero no he entendido ni papa.

A ver. En el ejemplo de la Y lógica hemos visto primero una
U E0.0
Bien. Como hemos dicho que la U es un AND con lo que tenga el RLO (V ó F). Como
no hay operación previa, entonces lo que hace es leer el valor de la E0.0 y la transfiere
al RLO. Imaginemos que tiene un cero. Luego el RLO valdrá cero.
Luego imaginemos que la E0.1 está a uno y hace un
U E0.1
Es decir, hace un AND con lo que tenga el RLO tras haber ejecutado la operación
anterior. La E0.1 está a uno, pero el RLO está a cero, luego el resultado nuevo será cero
y se lo cargará nuevamente al RLO.
= A1.0
Finalmente, toma el valor del RLO y se lo transfiere a la A1.0
Imaginemos que ambas señales estuvieran a uno.
56
Entonces, inicialmente al leer la E0.0 el RLO pasaría a valer uno. Luego haría un AND
entre el RLO y la E0.1. Como ambas están a uno, el resultado lógico sería uno, que
sería nuevamente almacenado en el RLO. Finalmente, cargaría ese uno en la salida
A1.0
¿Capito?
Operación O lógica
En buena lógica (nunca mejor dicho), podrías pensar que la forma correcta de hacer un
OR sería:
U E0.0
O E0.1
= A1.0
Y eso estaría bien. Pero la forma más mejó sería haciendo:
O E0.0
O E0.1
= A1.0
¿Por qué?
Lógicamente hacen lo mismo. Pero me gusta más hacerlo así porque de hecho, cuando
traduces un OR de KOP a AWL así lo representa. Mejor que escribamos todos de la
misma manera ¿no?
Bueno, al grano. ¿Adivinas como actuaría no?
Inicialmente haría un:
U E0.0 // O E0.0
Como en el caso anterior leería el estado del E0.0 y lo volcaría en el RLO (imaginemos
un cero).
Luego un:
O E0.1
Y aquí haría un OR con el RLO. Imaginemos que el E0.1 estuviera a uno. El resultado
del OR sería un bonito uno.
= A1.0
E igualamos el uno a la salida A1.0.
¿Sencillo no? Vayamos ahora con los paréntesis.
57
Paréntesis en AWL en Step 7
Como puedes imaginar, en cuanto queramos realizar combinaciones un poco más

elaboradas necesitaremos paréntesis para poder realizar estas lógicas.
Así, dispondremos de las siguientes operaciones:
 U( ..) //UN(..) que valdrá para realizar un (N)AND con el contenido interior al
paréntesis
 O(..) // ON(..) que valdrá para realizar un (N)OR con el contenido interior del
paréntesis.
 X(..) // XN(..) que valdrá para realizar una (N)XOR con el contenido interior del
paréntesis
En definitiva en lo que se basa es en realizar la combinatoria interior del paréntesis y
luego ejecutar la operación asociada al paréntesis.
Los paréntesis pueden anidarse metiendo paréntesis dentro de otros paréntesis.
Así, podríamos hacer algo similar a lo anteriores ejemplos:
U(
U E0.0
O E0.1
)
O(
U E0.2
U E0.3
)
= A1.0
En este caso primero resolvería la combinatoria interior de los paréntesis por separado
y luego realizaría el OR entre el resultado de los paréntesis.
Hay que añadir que el caso del OR es un poco especial ya que si dentro del paréntesis
del OR la combinatoria es de AND exclusivamente, el paréntesis se podría haber
obviado quedando esa parte así:
O
U E0.2
U E0.3
Y funcionaría exactamente igual.
58
Operandos de cierre de consulta
A estas alturas de la película te estarás preguntando… si los resultados de la

combinatoria se van almacenando en el RLO, ¿qué pasa después de una igualación si
quiero empezar a realizar una nueva combinatoria? Pues efectivamente después de los
operandos:
 Igualación (=)
 Set (S)
 Reset (R)
Con esos operandos, se cierra la consulta actual y se abre una nueva (además del
inicio del programa).
Da igual por tanto lo siguiente que hagas (U, O, UN…) porque lo que se hará es una
lectura del operando en el RLO. Es decir, si la siguiente a una igualación es
…
= A1.0
UN E1.0
U E1.1
= A1.2
Lo que hará es leer el estado de la E1.0, le cambiará el signo y lo cargará en el RLO.
No hará un NAND con nadie. Simplemente realizará la carga en el RLO.
Ojo. Un cambio de segmento no es un inicio de programa. Por tanto si la última
instrucción de un segmento es la lectura de un bit haciendo un U E0.7, este afecta al
siguiente segmento. A efectos prácticos es como si lo hubieras escrito al principio del
nuevo segmento.
Finalmente vamos a ver un vídeo como siempre, explicando lo visto hasta ahora.
59
13. Step 7… AWL, FUP o KOP ¿Cuál elijo?
Antes de responder a la pregunta de qué lenguaje escoger en Step 7, repasemos un

poco de qué lenguajes disponemos.
 FUP
 KOP
 AWL
FUP
Es un lenguaje de Step7 gráfico que utiliza los cuadros del álgebra booleana para
representar la lógica. Asimismo, permite representar funciones complejas (p.ej.
funciones matemáticas) mediante cuadros lógicos.
Tiene la ventaja de ver agrupados por bloques las diferentes lógicas y tener bloques
complejos. Cuando hay mucha lógica booleana en serie suele ser más compacto y más
fácil de ver el segmento completo.
KOP
Es un esquema de contactos, escalera o ladder. Es un lenguaje de Step 7 gráfico

y probablemente el más extendido en todos los lenguajes de programación y por tanto
el más similar a otros.
Probablemente es el más fácil de entender por personal proveniente de la industria
eléctrica y técnicos eléctricos.
En definitiva, es la representación que habría que cablear si se quisiera hacer el mismo
programa que realizas con el PLC.
60
AWL
Es un lenguaje de programación textual orientado a la máquina. En un programa creado

en AWL, las instrucciones equivalen en gran medida a los pasos con los que la CPU
ejecuta el programa. Para facilitar la programación, AWL se ha ampliado con estructuras
de lenguajes de alto nivel (tales como accesos estructurados a datos y parámetros de
bloques).
Es el más completo y el más complejo visualmente de seguir. Para instrucciones
sencillas es muy útil pero cuando se quiere hacer una lógica un poco compleja el trabajo
de seguimiento y de depuración es complicado y fácilmente susceptible de cometer
errores.
En su haber, si lo que necesitas no lo puedes programar en AWL, es que no se puede
programar con ninguno de los 3.
Por otra parte ambos lenguajes gráficos son traducibles a AWL, pero no al revés y no
necesariamente entre ellos.
Si bien normalmente KOP y FUP son traducibles entre sí, no siempre es así. Dependerá
de la construcción del segmento en cuestión para que se pueda.
Como se aprecia en el gráfico, todo lo que se programe en KOP y FUP puede ser
programado en AWL. Pero no solamente no todo no será traducido entre el lenguaje
gráfico y AWL, sino que además habrá procedimientos que sólo podamos realizarlos en
AWL y en ningún caso en FUP o en KOP. Por ejemplo, el uso de punteros será exclusivo
del lenguaje AWL.
Es decir, AWL será el lenguaje universal dentro del Step 7 y el equivalente de
programación en un PC sería como un lenguaje ensamblador (salvando las distancias,
claro está).
Respondiendo a la pregunta... ¿Cuál es el mejor? Pues ya siento que hayas leído hasta
aquí porque no tengo una respuesta a ello. Depende.
A título personal te diré que en mis inicios y por provenir del ámbito académico y de
programación para PC, me gustaba más los diagramas de bloques (FUP). Hoy he de
decir que sin duda me parece más práctico el lenguaje KOP ya que me permite visualizar
más segmentos del código como norma general.
61
El lenguaje AWL es totalmente necesario como ya veremos en su momento para

multitud de tareas que sólo así se pueden hacer o porque, aunque parezca mentira, es
más fácil de usar.
Por tanto, puedes usar indistintamente cualquiera de ellos, si bien lo normal y lógico es
usar uno de los lenguajes gráficos acompañado por AWL cuando no quede más
remedio.
62
14. SET y RESET en AWL y alguna cosilla más.
¿Ya sólo nos queda ver SET y RESET en AWL en lógica binaria?
Bueno, a decir verdad… no. Queda también ver los pulsos o flancos, además de cosas
que afectan al RLO.
Pero a decir verdad, poco más vamos a ver de
momento. Tampoco se trata de pegarse un atracón
de lógica booleana en AWL. Se trata
fundamentalmente de entender muy bien que es el
RLO, para qué sirve y cómo se utiliza. Si en estas
dos lecciones aprendes a entenderlo podemos
darnos por satisfecho. La destreza del uso de la
lógica booleana la cogerás programando nuevos
PLC de Siemens, por eso no te preocupes.
¿Qué es un set y reset en AWL?
Buceando con el amigo Google, he encontrado la imagen de arriba. La verdad es que

está muy bien para explicar lo que hace si no lo tienes aún claro.
Un SET no es más que fijar a uno una variable booleana. Como la has fijado, esta
variable seguirá a uno aun cuando las condiciones de ponerla a uno desaparezcan.
Se diferencia de una igualación en que en esta, el resultado final es dependiente en
todo momento de las condiciones para estar a uno o a cero. Mientras que las
condiciones se cumplen la variable está a uno. Cuando una de las condiciones falla, la
señal cae.
Aquí no. Una vez dadas las condiciones la señal estará a uno indefinidamente… o hasta
que se le haga un RESET.
Y es que el RESET lo que hace es fijar a cero la variable. Como en el caso anterior,
aunque las condiciones de reset desaparezcan, la señal seguirá a cero y no recobrará
su estado de uno hasta un nuevo SET.
¿Qué pasa si se dan ambas condiciones, SET y RESET en AWL?

Pues lo primero que habría que darte un capón por hacer un programa en el que el set
y reset se den simultáneamente.
¿Puede darse ese caso?

Por supuestísimo que sí.
¿Es grave?
No conozco a nadie que haya enfermado de ello, pero mejor evitarlo.
63
¿Qué pasa si se da?

La respuesta seguro que la sabes. Depende.
¿De qué depende?

De según como se ejecute todo depende… (Léase a lo Pau Donés).
Como bien sabes, si ambas condiciones se dan simultáneamente y seguidas una de

otra, la que sobrevivirá del envite será la segunda.
Ahora bien, si hay distancia en el programa, imaginemos el SET al principio del

programa, el RESET a eso de la mitad, la cosa puede hacer cosas pintorescas ya que
la variable entre el SET y el RESET estará a uno con lo que ello pueda conllevar en lo
que haya en el programa entre estos dos puntos.
A partir del RESET se pondrá a cero hasta el siguiente ciclo de scan que se volverá a
poner a uno si las condiciones se mantienen. Tendríamos por tanto la variable la mitad
del ciclo a uno y la otra mitad a cero… una fiesta.
Por tanto, mejor evitar estas circunstancias y a ser posible, el set y el reset que estén
seguidos siempre que sea posible. Por este posible problema y porque será más fácil
de seguir el programa.
¿Esto sólo se puede dar en AWL?

No. Ahora vamos a ver cómo se activan y se desactivan, pero lo dicho anteriormente
vale para todos los lenguajes disponibles. Por tanto tendrás que tener cuidado con el
Set y Reset en AWL, en FUP o en KOP
¿Qué pasa si mezclo Set, Reset e igualaciones?

Espero que esto no se te haya pasado siquiera por la cabeza… cárcel directamente.
Punto. Y sin galletas en el desayuno hasta nuevo aviso.
Vale, vale… pero ¿qué hay del SET y RESET en AWL?
Bien. Te lo voy a explicar con un ejemplo sencillo:

O E0.0
O E0.1
S A 1.0
U E0.2
U E0.3
R A1.0
¿Chupado no?
Como bien imaginarás, la señal A1.0 se pondrá a uno, cuando el OR formado por la
E0.0 y E0.1 dé como resultado un uno poniendo el RLO a uno.
Igualmente, la A1.0 se podrá a cero, cuando el AND de la E0.2 y E0.3 se ponga a uno
poniendo el RLO también a uno haciendo por tanto el reset.
64
En definitiva, el Set y el Reset se ejecutarán forzando la marca o salida en una dirección

u otra, cuando el RLO esté a uno y pasando olímpicamente del Set o Reset cuando el
RLO esté a cero. ¿Fácil no?
Forzado del RLO – SET y CLR
Unas instrucciones muy interesantes son las de forzar el RLO, es decir, cargar en el
RLO un cero o un uno de forma incondicional hasta que haya una nueva operación de
combinatoria booleana:
 SET: Fijaremos con ello el RLO a uno

 CLR: Fijaremos con ello el RLO a cero
Por ejemplo:
U E0.1
U E0.2
SET
= A1.0
¿Cuánto valdrá A1.0?
Pues efectivamente, la salida A1.0 estará forzada a uno ya que da igual lo que pase con
la combinación de las dos entradas ya que luego se fuerza el RLO a uno y se iguala su
valor a la A1.0
Flancos en AWL
Finalmente vamos a ver los pulsos. Hay dos:
 Positivo (FP)
 Negativo (FN)
Los pulsos como bien sabes son instrucciones que ponen el RLO a uno cuando se
cumple el escalón de subida de cero a uno (el positivo) o que el RLO previo pase de
uno a cero (el negativo).
Necesitan una marca auxiliar que es la que almacena la información de cómo estaba el
RLO en el ciclo anterior.
Mejor con un ejemplo:
U E0.0
FP M1.0
= A1.0
65
Lo que hará este mini ejemplo será: Mientras que la marca E0.0 esté a cero, la el RLO
tras el pulso estará a cero. Cuando la entrada pase a uno, entonces en ese ciclo de scan
el pulso pondrá el RLO a 1 haciendo que la salida A1.0 se active en ese ciclo de scan.
En el ciclo siguiente aun estando la entrada a uno, la salida volverá a cero ya que el
RLO a la salida del pulso estará a cero.
Si hiciéramos un ejemplo similar con el flanco negativo:
U E0.0
FN M1.0
= A1.0
El comportamiento sería igual salvo que esta vez, el RLO después del FN se pondrá a
uno cuando la señal de la E0.0 pase de estar a uno a estar a cero. Análogamente al
caso anterior sólo estará a uno en ese ciclo de scan, volviendo a cero en los sucesivos
con independencia de que la salida siga a cero en este caso.
Como siempre, te dejo con un vídeo donde vamos a ver una forma más gráfica lo que
acabas de leer:
66
15. Función MOVE en Step 7

Este capítulo es sobre una función muy sencilla pero muy útil por lo que hay que conocer
bien.
Según la ayuda del propio Step 7 la función move hace lo
siguiente:
MOVE (Asignar un valor) es activada por la entrada de
habilitación EN. El valor indicado por la entrada IN se copia en
la dirección que la salida OUT. La salida de habilitación ENO
tiene el mismo estado de señal que la entrada de habilitación
EN. La operación MOVE sólo puede copiar los objetos de datos que tengan las
longitudes de BYTE, WORD o de DWORD. Los tipos de datos de usuario tales como
los arrays o las estructuras han de copiarse con SFC 20 „BLKMOV“.
Entiendo que hasta aquí todos hemos llegado ya que sabemos leer.
En resumidas cuentas, y viéndolo en AWL lo que hace es una lectura y
una transferencia:
L MW0
T MW2
Siendo la lectura según la ayuda de S7:
L <operando> carga en el ACU 1 el contenido del byte, de la palabra o de la doble
palabra direccionado, después de haberse almacenado el anterior contenido del ACU 1
en el ACU 2 y de haber puesto el ACU 1 a “0”.
Y la transferencia:
T <operando> transfiere (copia) el contenido del ACU 1 a la dirección de destino si está
conectado el Master Control Relay (MCR = 1). Si el MCR es 0, en la dirección de destino
se escribe el valor “0”. El número de bytes que se copia del ACU 1 dependerá del tamaño
indicado en la dirección de destino. El ACU 1 también almacena los datos después de
la operación de transferencia. La operación de transferencia a un área de periferia
directa (área de memoria PA) también transfiere el contenido del ACU 1 ó “0” (si el MCR
es 0) a la dirección correspondiente en la imagen del proceso de las salidas (área de
memoria A). La operación se ejecuta sin tener en cuenta ni afectar a los bits de la palabra
de estado.
Vamos, que se explican como un libro cerrado. Así que aclaremos las cosas.
67
MOVE en Step 7 (en cristiano)

 Si haces un MOVE entre cosas iguales (byte, Word, Dword) etc… es hacer una
copia exacta del origen en el destino
 Si haces un MOVE entre cosas heterogéneas (de DINT a INT por ejemplo) has
de andarte con pies de plomo.
La primera parte está clara. Si tengo un real en un MD4 y hago un MOVE a MD8, pues
simplemente he copiado su valor de uno a otro.
¿Ahora bien, y si hago un MD4 a MW10?

Imaginemos que tenemos un DINT a INT… si os fijáis no hay una instrucción para pasar
de doble entero a entero… ¿cómo lo hago?
Pues simplemente haciendo un move (o una transferencia, que como digo, es la misma
cosa):
L MD4
T MW10
¿Y ya está?
Sí, pero con un pequeño matiz: El valor del MD4 tiene que “caber” en el MW10. Es decir,
si tomamos un número mayor que el que nos entra en un MW, pues básicamente la
estaremos liando parda.
Es decir, si hago:
L MD4 (siendo su contenido imaginemos 1000)
T MW10
No habrá problema y el contenido del MW10 contendrá este 1000
Por lógica, no podremos cargar un valor que supere la capacidad del entero ya que si
bien la transferencia se realizará, el MW10 no contendrá lo que tú esperas que
contenga.
La tabla que indica la ayuda es la siguiente:
68
Como ves, se queda con los bytes más significativos en función del tamaño de la salida,
por lo que si hago un
L MD10
T MB20
Es básicamente lo mismo que hacer un:

L MB13
T MB20
Ya que el resto de bytes (MB10, MB11 y MB12) como si no existieran ya que contengan
lo que contengan, no los va a hacer ni caso.
En cambio, al revés no es lo mismo:

L MB20
T MD10
No es lo mismo que hacer un

L MB20
T MB 13
Porque en el primer caso, copiará el contenido del MB20 en el MB13 y el resto de bytes
(Mb10, 11 y 12) los rellenará con ceros.
En el segundo caso, sólo copiamos el valor del MB20 en el MB13 y el resto contendrá
lo que contenga sin variarlo, con lo que el valor del MD10 puede ser cualquier otra cosa.
69
16. Cómo usar los acumuladores en AWL
Acumuladores en AWL
Los acumuladores son dos:
 ACU 1
 ACU 2
Ambos son dos áreas de memoria de 4 bytes (doble palabra) cada uno.
Se usan fundamentalmente para realizar cálculos matemáticos y para transferir
información de un área de memoria a otra (por ejemplo de marcas a zonas de DB,
entradas, salidas…)
La forma de trabajar básica con ellos son la lectura y la transferencia
 Lectura (L): Lees la marca, dw, pew o lo que sea y lo transfieres al ACU 1
 Transferencia (T): Lees lo que tiene el ACU 1 y lo copias en la marca, paw, etc.
Como ejemplo:
L 67 -> Leemos el valor 67 y lo transferimos al ACU1
T MW 10 -> Leemos lo que tenga el ACU1 (en este caso un 67) y se lo transferimos a
la marca MW10.
¿Sencillo no?
Pero si los acumuladores en AWL son dos, ¿qué pasa con el ACU2?
Bien. La idea de tener dos acumuladores es básicamente para realizar operaciones

matemáticas (entre otras cosas que veremos a continuación). La forma en la que trabaja
es en forma de pila, es decir:
Cuando leemos algo y se lo transferimos al ACU1, previamente el PLC ha realizado la
operación de transferir el ACU1 al ACU2. Posteriormente transfiere lo leído al ACU1.
Imaginemos que queremos sumar dos valores enteros. Para ello actuaríamos de la
siguiente manera:
L 8 -> Cargamos el ACU1 en el ACU2 (nos da igual que tenga), y cargamos el 8 en el
ACU1
L 7 -> Copiamos el ACU1 al ACU2 (el 8) y cargamos el 7 en el ACU1.
+I -> Hace la suma entera entre el ACU1 y el ACU2 y el resultado lo transfiere al ACU 1
T MW 10 -> Copiamos el valor del ACU1 a la marca MW10 (15)
70
¿Qué tendrían entonces el ACU1 y el ACU2?
ACU1 = 15
ACU2 = 8
Sí. 8. No 7 que es el último valor leído. Tras hacer la suma, ha transferido el valor de la
suma al ACU1 (ha machacado el 7 con el 15). El acumulador 2 como veremos en el
vídeo se pone a cero (aunque realmente poco o nada importa tenga ya que no lo vas a
utilizar).
¿Qué más operaciones se pueden hacer?

Como puedes intuir, además de sumar enteros, podrás restar, multiplicar, dividir, entre
otras muchas operaciones en todas sus variantes:
 Enteros
 Dobles enteros
 Reales
¿Qué seguridades hay a la hora de realizar operaciones matemáticas?

Pues así, como resumen, y para no alargarme demasiado: NINGUNA
Como bien sabes en FUP o KOP, el editor del PLC no te deja realizar ideas felices como
sumar un entero con un real, por mucho que te guste y lo intentes.
En AWL sí vas a poder.
Guay. Pues lo sumo en AWL.

Pequeño saltamontes, he dicho que deja, no que el resultado sea el esperado. Es más,
te daría resultados interesantes y variopintos para que estés entretenido durante unas
cuantas horas como no te percates en el momento de la chapuza realizada.
Imagina que sumas, haciendo ya el burro del todo:
L L#50000
L 50000.0
+I
T MW10
¿Valor de MW10?
Chupado: 50 mil más 50 mil, cien mil. Sí. Sí por lo coj…
No sé ni lo que daría.
Para empezar, porque 100 mil no se puede cargar en 16 bits. Como bien sabes, los
enteros van desde -32767 a 32768. Para continuar, porque mezclar reales con doble
enteros no pega ni con cola.
71
Forma en que carga y se transfiere al ACU1

Para dejarlo aún más claro: el ACU1 tiene 4 bytes, lo que viene siendo dos palabras.
Cuando tú transfieres un número entero positivo inferior a 256 (un byte), este se carga
en el byte alto de la palabra alta. Es decir, en el byte 3 del ACU1. El resto de los bytes
se ponen a cero.
Cuando transfieres un entero más grande que no entra en 8 bits, (imaginemos 12345),
este valor se carga en la palabra alta (bytes 3 y 4). Los bytes 1 y dos se ponen a cero.
Finalmente cuando cargo un número real (el -1234,5), se usan los 4 bytes (si es
pertinente)
¿Qué ocurre cuando lees el ACU1?

Pues que depende de la variable sobre la que escribas.
Si haces un T MB 8, pues estarás cogiendo el byte alto, de la palabra alta. Tenga lo
que tenga el resto, sólo leerás el byte 3 del ACU1 y se lo transferirás al MB8.
Si haces un T MW8, pues cogerás la palabra alta y se la transferirás al MW8.
Finalmente si haces un T MD10, tomarás el valor completo del ACU1 y se lo transferirás
al MD10.
¿Menudo lío no?

Pues en realidad, no tanto. Si simplemente haces operaciones con variables coherentes
entre sí (reales con reales, enteros con enteros), no te deberás preocupar qué es lo que
se está cargando o transfiriendo en el ACU1, porque simplemente estará bien.
Simplemente ten cuidado y no mezcles churras con merinas y todo irá bien. Pero quiero
que entiendas qué es lo que estás haciendo y porqué funciona (o no).
Como ves, en ningún momento he hablado de nuestro nuevo mejor amigo el RLO. Hasta
ahora.
Operaciones con los acumuladores que afectan al RLO
Hasta ahora sólo hemos hablado de operaciones que son aritméticas. Estas no afectan
al RLO.
Ahora bien, hay operaciones en las cuales el resultado sí cambia el RLO como son las
de comparación, por ejemplo.
Así, por poner un ejemplo:
L MW 10
L MW20
==I
= A1.0
72
Lo que estaremos será cargar el contenido del MW 10 y MW20 en los ACU2 y ACU1
respectivamente y ejecutar la operación de comparación de igualdad. El resultado es
booleano (sí o no) y se carga en el RLO.
Por tanto, si ambos números son iguales, activaremos el A1.0 y si son diferentes,
apagaremos la A1.0
¿Cuántas operaciones con los acumuladores hay?
Imagino que querrás sabes qué operaciones puedes realizar. Bien, en el blog tenemos
un listado que encontré en su día con todas las operaciones que se pueden realizar en
AWL.
Échale un vistazo y verás que el abanico es bastante amplio. En esos listados hay
instrucciones que aún no hemos visto, pero que veremos más adelante. Que te vayan
sonando.
Finalmente, el vídeo de este capítulo:
73
17. Operaciones - Calculadora científica
Para explicar las operaciones aritméticas vamos a ver un nuevo ejemplo en Step 7: una
calculadora científica. Sí, nada de teoría… en parte.
He pensado que ya hemos visto

suficiente teoría como para empezar a
programar un poco más en serio. Y digo
un poco más, porque una calculadora
con un PLC no es precisamente
ingeniería aplicada que digamos.
Pero sí nos va a permitir repasar cosas
aprendidas y comenzar a ver otras
nuevas cosas que van a ser de gran
utilidad y uso como son saltos
condicionados (e incondicionales).
Ejemplo en Step 7 de calculadora científica
Como digo, antes de meternos a contar tiempo, quería repasar un poco las instrucciones
que hemos visto y algunas nuevas especialmente aritméticas y trigonométricas… y qué
mejor que ello que realizar un ejemplo en Step 7 de una calculadora como la que tienes
sobre estas líneas.
Sí, no es precisamente Deep Blue, pero verás que funciona razonablemente bien.
El estilo que he usado para el ejemplo es de pila o stacker simulando un poco lo que
haríamos con el ACU1 y el ACU2. Este método era el usado por ejemplo en las
calculadoras HP 48 que tantos exámenes hizo conmigo cuando estudiaba en la Escuela
de Ingenieros de Bilbao.
¿Qué vamos a repasar con este ejemplo en Step 7?
Si bien no es un ejemplo de programación industrial, si va a ser bastante didáctico y nos

va a permitir:
 Comenzar a realizar programas usando FC para estructurar el código y como

funciones puramente dichas.
 Ejercitar nuestros conocimientos de lógica booleana.
 Ver operaciones de comparación
 Ver operaciones aritméticas
 Ver operaciones trigonométricas
 Comenzar a ver operaciones de salto.
 Entremezclar KOP y AWL y ver que no se muerden entre ellos.
74
 Y cómo no, tener una cara y friki calculadora (entre la pantalla y la CPU con
2500€ lo hacemos fácil).
¿Qué requerimientos va a tener?

Como decía John Hammond en Parque Jurásico, “no hemos reparado en gastos” y tiene
todas estas funcionalidades:
 Operaciones aritméticas (suma, resta, producto y división).

 Trigonométricas (seno, coseno, tangente y los arcos correspondientes).
 Potencias y logaritmos naturales.
 Otras cosillas: Inversa, TAK, Pasar de radianes a grados o gradianes.
¿Tampoco es para tanto no?

Pues no, pero tampoco es tan fácil. Si te fijas, tiene un teclado, con sus dígitos, y su
punto para realizar número reales con su mantisa incluida... su borrado total y su borrado
del último dígito…
Además tendrá que hacer que cuando se ejecute una operación, véase por ejemplo la
suma, tiene si introduces un nuevo dígito, debe desplazar el último resultado al
acumulador 2 y empezar de nuevo. Como digo, no hemos reparado en gastos.
¿Me lo explicas?
La verdad es que pensaba meterte un bonito rollo sobre cómo está hecho cada parte
del programa, pero cogería tendinitis en los dedos y dudo que me lograra explicar del
todo bien.
Es por ello que casi que te voy a dejar con un vídeo en el que te voy a explicar al detalle
cómo está realizado el programa ¿te parece?
Te dejo con el vídeo.
75
18. Palabra de estado en Step7

Tal vez esperabas que en este capítulo
empezáramos con los temporizadores,
pero se va a retrasar un poco. Como
vas a ver, tampoco hay un vídeo
acompañando este capítulo.
Es sólo lectura. Un rollo. Pero está bien
al menos como cultura general aunque
a efectos prácticos hay poco que rascar
más allá de un par de cosillas.
La palabra de estado en Step 7 ¿qué es?
Lo primero que hay que decir es que la palabra de estado en Step 7 es un registro donde
se almacenan una serie de bits sobre el procesamiento y estado de las operaciones que
están teniendo lugar.
Para empezar, mal empezamos llamándola palabra… ¿por qué? Pues porque son 9 bits
y no 16, pero se llama así, y tampoco nos vamos a rasgar las vestiduras ¿no? Entiendo
que los 7 restantes los tendrán a buen recaudo y se llama palabra porque al ser 9 no lo
podían hacer con un byte. Sin más.
Cada bit dentro de la palabra tiene una función para mantener una trazabilidad de qué
está sucediendo, desde resultados de álgebra booleana hasta si ha sucedido un
overflow.
Los bits de la palabra de estado
Los Ocean’s Nine son estos:
 Bit 0 – /FC
 Bit 1 – RLO
 Bit 2 – STA
 Bit 3 – OR
 Bit 4 – OS
 Bit 5 – OV
 Bit 6 – CC1
 Bit 7 – CC0
 Bit 8 – BR
76
Vale, nombres chulos, pero quitando al RLO y el STA, los demás como que…
Sí, sí… ya voy. Repasemos para que vale cada uno.
Bit 0 -/FC
Este bit es el que almacena si la siguiente instrucción de la una combinación booleana
va a ser la primera o no.
 Valor 0: la siguiente instrucción va a ser procesada como la primera

instrucción. Ya lo vimos anteriormente con las operaciones de cierre de consulta.
 Valor 1: Es que la combinatoria está en marcha
Así, cuando se haga un set, reset o una asignación (=) la señal se pondrá a cero. Una
vez después de puesta a cero si se hace un U o un OR (por ejemplo), la señal se pondrá
a 1 comenzando a realizar la combinatoria.
Bit 1 – RLO.
Espero que no tenga que sacar la vara de avellano para castigar a aquellos que aún
pregunten que es el RLO. Me niego a explicarlo.
Bit 2 – STA
Como bien sabes, es el estado de la dirección booleana de la memoria. Si está a uno
es que la marca o entrada está a uno, si está a cero, pues al revés.
Bit 3 – OR
Sirve para conocer el valor de la combinatoria de un AND antes de hacer un OR.
Recuerda que puedes hacer una combinatoria de este pelo:
U E0.0
O
U E1.0
U E2.0
= A1.0
Vale. Pues lo que hace este bit es almacenar la combinatoria del AND entre la E1.0 y la
E2.0. Se guarda el resultado intermedio en este bit antes de acometer el OR de este
resultado con la E0.0.
Bit 4 y 5 – OS y OV
OS almacena que ha habido un overflow. Cuando hay un OV (overflow) porque has
dividido por cero o porque has sumado dos enteros que se salen de los 32768 la señal
de OV y OS se ponen a 1. Luego el OV puede desaparecer porque la siguiente
77
operación sea correcta, pero el OS queda con valor uno hasta que se realice un SPS
(Salta si OS=1), una llamada a otro bloque, o final de bloque.
Así puede que hagas una operación matemática que da OV. Luego puedes hacer un
SPO (salta si OV=1) o un SPS (salta si OS=1) para tratar el error y así pones a cero el
bit 4 (el 5 se quitará él solito cuando haya una nueva operación correcta).
Bit 6 y 7 – CCO y CC1

Son bits usados para las operaciones de comparación, matemáticas, de giro…
Instrucciones de comparación
CC 1 CC 0
0 0 ACCU 2 = ACCU 1
0 1 ACCU 2 < ACCU 1
1 0 ACCU 2 > ACCU 1
1 1 Desordenadas. Solo para coma flotante.
Operaciones matemáticas con OV
CC 1 CC 0
0 0 Resultado = 0
0 1 Resultado < 0
1 0 Resultado > 0
Operaciones matemáticas enteras con OV
CC 1 CC 0
0 0 Rango negativo de OV en ADD_I y ADD_DI
0 1 Rango negativo de OB en MUL_I y MUL_DI
1 0 Rango negativo de OV en ADD_I, ADD_DI, SUB_I, y SUB_DI
1 1 División por 0 en DIV_I, DIV_DI, y MOD_DI
78
Instrucciones en punto flotantes con Overflow
CC 1 CC 0
0 0 Underflow
0 1 Rango negativo de OV
1 0 Rango positivo de OV
1 1 Número de coma flotante no válido
Instrucciones de giro y salto
CC 1 CC 0
0 0 Bit saliente estaba a cero
1 0 Bit saliente estaba a uno
Instrucciones lógicas
CC 1 CC 0
0 0 Resultado = 0
1 0 Resultado <> 0
Bit 8 – BR
Proviene de Binary Result y es el resultado de las operaciones binarias. Cuando el BR
está a uno, activa la salida de ENO habilitando en bloques concatenados que se ejecute
el siguiente bloque.
Las operaciones SAVE, SPB y SPBB ponen a uno el BR (más información aquí).
79
19. Control del reloj del sistema en Step 7
Con este capítulo vamos a comenzar a tratar el tiempo en Step 7. Qué mejor que con el
reloj del sistema. Además, vamos a ver un nuevo adelanto de siguientes capítulos
viéndolo de forma práctica.
¿En qué consiste el ejemplo?

Bueno, la idea es en función de la hora del sistema, calculemos por un lado el día del
año en el que estamos y los minutos transcurridos del día actual.
Hay que tener en cuenta que el día del año puede variar en función del día del calendario
y si es un año bisiesto.
¿Cómo vamos a leer el reloj del sistema?

Bueno, lo primero que tienes que saber, si es que no lo sabes ya, es que hay dos SFC,
el SFC0 y el SFC1 para leer y escribir la hora en el PLC.
El SFC0, que es con el que vamos a trabajar, lee la hora del PLC y nos lo devuelve así:
Byte Contenido Ejemplo
0 Año B#16#04
1 Mes B#16#08
2 Día B#16#05
3 Hora B#16#08
4 Minuto B#16#05
5 Segundo B#16#05
6 Los dos dígitos superiores de los milisegundos B#16#25
7 (4 MSB) Los dos dígitos inferiores de los milisegundos B#16#0
7 (4 LSB) Día de la semana: B#16#5

1: Domingo,
2: Lunes,
3: Martes,
4: Miércoles,
5: Jueves,
6: Viernes,
7: Sábado
80
Esta información proviene de esta página de soporte de Siemens.

Por tanto, leeremos el reloj del sistema con el SFC0 y volcaremos esa información en
un DB para leerlo cuando deseemos.
Tened en cuenta que toda la información está dada en BCD. Para más información
sobre qué es BCD tenéis el capítulo con el ejemplo de un display de 7 segmentos.
¿Cómo calcularemos el día del año?

Aquí vamos a introducir el nuevo concepto: el CASE en Step 7. Puedes leer más
información sobre ello en el capítulo al respecto situado más adelante.
La idea es que en función del mes, hagamos una precarga de días.
Es decir, si estamos en febrero, nuestro día será = 31 de enero + los días de febrero.
¿Y si estamos en marzo… o en septiembre?

En principio podría parecer que es igual... y lo es. Casi.
¿Qué es lo que falta? Pues saber si es bisiesto.

Por tanto miraremos si es bisiesto y si el mes es superior a febrero. Si es así, sumaremos
un día más del 29 de febrero. Si estamos en febrero, no haría falta ya que si es el día
29 estará en el valor del día, no del mes.
¿Cómo calculamos si es un día bisiesto?

Lo primero es saber cuándo es un año bisiesto: tiene que ser divisible entre 4 ¿no?
Sí, pero además no debe ser divisible entre 100, salvo que sea además de 100, por 400.
La razón de esta norma es que la Tierra tarda 365 días y casi 6 horas. Para eliminar el
error cometido, cada 100 años, no se hace bisiesto pero cada 400 sí.
En definitiva, la fórmula que vamos a usar es:
If (Año Mod 4 = 0) And ((Año Mod 100 <> 0) Or (Año Mod 400 = 0)) Then'''
Año Bisiesto
else
Año No Bisiesto
end if
81
Pues ya está. Veamos el vídeo donde vemos cada uno de estos puntos y damos
solución al problema.
82
20. Codificación de un display de 7 segmentos
Para resolver este ejemplo vamos a tocar una serie

de conceptos y funciones, como hacer un AND
entre bytes y palabras, mover bits a la derecha y la
función SEG.
Vamos a ver los conceptos teóricos necesarios y
como siempre terminaremos viendo un vídeo
explicativo de la solución en Step 7.
Pero para eso, hagamos por un momento de
profesor y redactemos el enunciado del problema:
Realizar un programa que dado un número de 3 cifras, obtengamos cada segundo las
centenas, decenas y unidades en un único display de 7 segmentos.
Bien, para ir paso a paso, enumeremos los ingredientes necesarios:
 Saber qué es un display de 7 segmentos y cómo funciona

 Tratar el número de 3 cifras y poder obtener cada una de ellas por separado
 Tomar esa cifra y sacarla de tal forma que el display lo entienda.
¿Qué es un display de 7 segmentos?
Haciendo una copia descarada de la wikipedia:

El visualizador de siete segmentos (llamado también display) es
una forma de representar números en equipos eléctronicos. Está
compuesto de siete segmentos que se pueden encender o
apagar individualmente. Cada segmento tiene la forma de una
pequeña línea. Se podría comparar a escribir números
con cerillas o fósforos de madera.
Sigamos leyendo:
A cada uno de los segmentos que forman el display se les
denomina a, b, c, d, e, f y g y están ensamblados de forma que se permita activar cada
segmento por separado consiguiendo formar cualquier dígito numérico. A continuación
se muestran algunos ejemplos:
 Si se activan o encienden todos los segmentos se forma el número “8”.

 Si se activan sólo los segmentos: “a, b, c, d, e, f,” se forma el número “0”.
 Si se activan sólo los segmentos: “a, b, g, e, d,” se forma el número “2”.
 Si se activan sólo los segmentos: “b, c, f, g,” se forma el número “4”.
Bien, nos hacemos una idea ¿verdad?
83
¿Cómo tratamos los datos?
Inicialmente vamos a disponer de un número de 3 cifras como dice el enunciado, lo que

viene siendo un entero de 0 a 999. Ahora bien, para poderlo tratar va a ser pasar este
número entero a BCD. He elegido un número de 3 cifras porque la conversión de entero
a BCD (operación ITB) sólo es válida para números entre +- 999.
¿Qué es un número BCD?

Hoy es el día de la Wikipedia:
En sistemas de computación, Binary-Coded Decimal (BCD) o Decimal codificado en
binario es un estándar para representar números decimales en el sistema binario, en
donde cada dígito decimal es codificado con una secuencia de 4 bits.
Esto en cristiano, y para lo que nos interesa, es que con un byte vamos a poder
representar dos dígitos, desde 00 a 99. Usaremos por tanto 4 bits para cada dígito.
Es decir, y poniendo ejemplos para los primeros 4 bits:
 El 0 en binario se representa con 0 0 0 0

 El 1 en binario se representa con 0 0 0 1
 el 2 en binario se representa con 0 0 1 0
Y así sucesivamente hasta...

¿Y el 10?
Pues pasaremos el testigo (a llevada) a los siguientes 4 bits, poniendo a cero los
primeros 4 bits.
Puedes comprobar que no existe el número BCD 1 1 1 1 por poner un ejemplo. No se
usan todos los que se podrían usar para codificar un número (como puede ser en un
entero donde 1 1 1 1 es 127).
En definitiva, se codifica en binario normal con esos 4 bits hasta llegar al 9, a partir del
cual ya no hay más. Para construir un número de 2 dígitos necesitamos otros 4 bits. Y
así sucesivamente claro.
Espero que no te hayas quedado dormido, así que sigamos.
Tratar y filtrar un número de 3 cifras
Una vez comprendido qué es un display de 7 segmentos, y qué es un número en BCD

(gracias de nuevo a la Wikipedia), vamos a tratar el siguiente punto, que es filtrar nuestro
número para ir quedándonos con cada cifra.
84
Para ello vamos a usar una operación AND. Pero no una cualquiera, sino una operación
con palabra (WAND)
Perdona, pero... que ¿qué?

Bien sabes lo que es hacer un AND entre dos bits: si ambos están a 1, el resultado es
1. Si no lo son, un rosco.
Pues hacer un filtrado con un WAND no es más que hacer lo mismo, pero en vez de con
un bit, con 16. En AWL la operación WAND se llama UW.
Vale. Más o menos lo pillo… pero ¿para qué?

Aquí viene lo interesante: puedo filtrar (quedarme) con la parte de un WORD que yo
quiera. ¿Cómo? Pues haciendo un WAND de mi palabra con una palabra donde los bits
que me quiero quedar, son 1.
Ya si eso, igual con un ejemplo…

Imagina que tenemos una palabra, la MW0 cuyo valor en bits es: 0101 1101 1000 1101
Y quiero quedarme solamente con los 4 primeros bits, los marcados en azul Bilbao (la
tierra tira). ¿Cómo lo hago?
Pues muy sencillo. Hago un WAND de mi MWO con un 0000 0000 0000 1111 es decir,
en hexadecimal W#16#000F o simplemente W#16#F
Haciéndolo, lo que nos da como resultado es curiosamente todo ceros, salvo lo que
queremos filtrar: 0000 0000 0000 1101
¿Cómo se te ha quedado el cuerpo?

Ahora viene lo mejor: como nuestro número está en BCD y cada 4 bits es un dígito,
haciendo este tipo de filtrado, obtenemos nuestras unidades, decenas… en función de
dónde pongamos el filtro... ¿Si?
Pero hay una pega a solventar: después de nuestro éxito sin parangón filtrando las
unidades queremos filtrar además las decenas, te vas a decir a ti mismo... esto está
chupado… el filtro será W#16#00F0 o W#16#F0 y mi resultado serán las decena…
Pues lamentablemente, no. Si hacemos ese filtro, ojito lo que tendríamos:
MW0 = 0000 0101 1000 0101
W#16#F0 = 0000 0000 1111 0000
WAND = 0000 0000 1000 0000
Correcto, pero eso no es un 8, sino un 80 en BCD.
Mmmmm y ¿cómo lo soluciono yo ahora?

Tampoco es que estemos muy lejos de la solución ¿no? Sólo son unos cuantos ceros
que nos sobran.
85
Para eliminar esos ceros, y pasar nuestro 80 a un 8, que es lo que nos interesa,
necesitamos…
Desplazar los bits a la derecha
Existen varias funciones de desplazamiento y rotación en Step 7. Hoy vamos a tocar

solamente 1, que es la de rotar X bits a la derecha. Otro día veremos más en profundidad
tanto las rotaciones como el tema de las operaciones lógicas con palabras.
Pero al grano: Tenemos nuestro 80 en BCD del cual nos queremos cepillar el cero… si
fuéramos capaces de eliminar los 4 bits iniciales, la cosa estaba hecha... y como estos
alemanes piensan en CASI todo, tenemos la operación SHR_W..
¿Qué es lo que hace la operación SHR_W?

Pues resumiendo, desplazar los N bits que le indiquemos hacia la derecha (eliminando
los que estaban) y metiendo O por la izquierda para completar la palabra. En nuestro
caso, lo que va a hacer:
Nuestra palabra sin rotar: 0000 0000 1000 0000
Nuestra palabra rotada : 0000 0000 0000 1000 0000
Es decir, elimina los 4 bits que teníamos en marrón, desplazando el resto, introduciendo
4 flamantes y nuevecitos bits a cero por la izquierda.
Pues ¡tachán! ya tenemos nuestro 80 en BCD convertido en un 8 bien chulo (como no
podía ser menos).
¿Y las centenas?
Estoy convencido que ahora ya sabrías hacer el resto. Como bien imaginas:
 Filtrar con W#16#F00

 Girar 8 bits en vez de 4 para obtener las centenas.
Tú que estás al loro, seguro que te has dado cuenta de un pequeño detalle: Las
centenas no hace falta filtrarlas, con girar los 8 bits es suficiente puesto que no hay cifras
a la izquierda… pues sí. No hace falta porque es un número positivo ya que en caso de
un número negativo los 4 bits más altos son todo unos... Por tanto, digamos que para
estandarizar el procedimiento sería como lo comentado.
Representación en un display de 7 segmentos
Una vez que tengamos cada dígito, tenemos que sacarlo en un display de 7
segmentos… ¿cómo?
Habría dos formas:
 Un codificador hardware de BCD a 7 segmentos (por ejemplo el 7447)

 Codificar por software y dar la salida de los 7 segmentos.
86
Lógicamente, y ya que estamos, pues lo codificamos nosotros ¿no?

Para eso S7 dispone una función de codificación de un display de 7 segmentos, el FC93
“SEG” dentro de Standard Library /TI-S7 Converting blocks
La descripción de la ayuda de Step 7 dice lo siguiente:
La función “Crear el patrón de bits para el display de siete segmentos” (SEG) convierte
los cuatro dígitos hexadecimales de una determinada palabra fuente (IN) en cuatro
códigos equivalentes para hacer posible el display de siete segmentos, y escribe el
resultado en la palabra doble de salida (OUT).
¿Una palabra a una doble?

Piénsalo bien. Introducimos un Word (16 bits), es decir, 4 dígitos en BCD. Si lo queremos
sacar en 7 segmentos, necesitamos una doble palabra, o sea, 4 bytes, un byte por cada
número de tal forma que cada bit ilumine una patita del display de 7 segmentos
(sobrándonos un bit, que es de regalo).
El cuadro sería el siguiente:

Como puedes ver, además de números como es el caso, podríamos representar
caracteres en función de la activación de unos u otros bits según la codificación indicada.
Un momento, ¡¡ tú me has estado tomando el pelo todo el rato!!…
Un poco sí. Perdón. Me he equivocado. No volverá a suced… ejem.

Como hemos dicho, la función SEG toma un valor en BCD de 16 bits y lo transforma en
su salida binaria, volcándolo en 4 bytes, y por tanto, no hacía falta filtrar ni rotar
absolutamente nada, simplemente con elegir el byte de las unidades, decenas, centenas
y millares, hubiera bastado ¿no?
Pues sí. Imaginemos que volcamos la información en el MD0, así tendremos
MB0: Signo del número
MB1: Centenas
87
MB2: Decenas
MB3: Unidades
Ya. Pero no hubieras aprendido:
 A usar en WAND
 A desplazar bits.
…por no decir lo bien que lo hemos pasado… o ¿no?
Mientras te baja la inflamación del cuello, si te apetece, puedes ver el resultado en el
siguiente vídeo
88
21. Temporizadores S7
Veamos los diferentes temporizadores de los que dispone Step:
 S_IMPULS Temporizador como impulso

 S_VIMP Temporizador como
 S_EVERZ Temporizador como retardo a la conexión impulso prolongado
 S_SEVERZ Temporizador como retardo a la conexión con memoria
 S_AVERZ Temporizador como retardo a la desconexión
Por cambiar, primero te ofrezco el vídeo, y luego el texto (además, así me puedes poner
cara, ya que es de los primero vídeos que grabé).
S_IMPULS Temporizadores como impulso
89
El temporizador como impulso se comporta como se ve en la figura adjunta. En resumen

cuando se activa el temporizador, se da un flanco de un tiempo determinado mientras
que la habilitación exista.
Mientras que el temporizador corre, la salida está activa.
La salida caerá por tres motivos: cuando el tiempo haya finalizado o bien cuando aún
con tiempo pendiente, la habilitación del temporizador desaparezca en cuyo caso, la
salida caerá con él. También caerá si se activa el reseteo del temporizador.
S_VIMP Temporizadores como impulso prolongado
Este temporizador se comporta diferente al anterior ya que como puedes observar una
vez que el RLO se pone a Set, el temporizador funcionará hasta completar el tiempo
independientemente de si el RLO sigue estando a uno o no. Solamente se puede
resetear o no activar si el reset del temporizador está activo.
S_EVERZ Temporizadores como retardo a la conexión
El retardo a la conexión como bien indica, retarda (filtra) la señal que activa el
temporizador. Lo más típico es usarlo para filtrar señales a la detección. Así por ejemplo
podemos filtrar la señal de una fotocélula que pueda hacer un guiño en un momento
90
dado. La salida cae cuando cae la señal que arranca el temporizador. Es muy utilizado
junto con el siguiente temporizador.
S_AVERZ Temporizadores como retardo a la desconexión
Este temporizador como el anterior es muy utilizado. En este caso lo que hace este
temporizador es alargar la señal que arranca el temporizador. Es decir, filtra la señal en
caso de pérdidas de señal por guiños. Puede usarse por ejemplo para detectores como
fotocélulas o detectores inductivos que pueden perder la señal de lo detectado durante
unas milésimas de segundo. Este temporizador ayuda a filtrar la señal manteniéndola en
alto.
S_SEVERZ Temporizadores como retardo a la conexión con

memoria
Este temporizador funciona de la siguiente manera: cuando el flaco positivo de la señal

que lo habilita pasa a uno el temporizador comienza a contar y una vez agotado el
tiempo la salida se pone a uno independientemente de si la señal de entrada ha caído.
La señal de salida estará en uno hasta que de nuevo vuelva a haber un nuevo flanco
positivo de la señal de entrada y por tanto el temporizador comience de nuevo a contar.
91
22. Ejemplos prácticos de temporizadores S7
Vamos a ver unos ejemplos sencillos para ver el uso de los temporizadores S7:
 Filtrado de señales (el más típico seguramente)

 Crear trenes de pulso
 Destellos por un tiempo fijo de una señal
 Crear un reset de un relé de forma segura.
Lógicamente hay muchas aplicaciones más, pero digamos que estas nos valen
suficientemente como ejemplo.
Filtrado de señales.
La idea de filtrar señales es muy típica, especialmente en señales que no dadas por
sensores de proximidad por contacto. Un final de carrera es complicado que de un guiño
debido a la histéresis que tiene.
Ahora bien, un detector inductivo o una fotocélula son susceptibles de dar o perder la
señal en un momento dado durante un instante.
Así tendremos 3 tipos de filtros:
 Filtro de guiños positivos

 Filtro de guiños negativos
 Ambos filtros combinados
Filtro de guiños positivos.
Con este filtrado lo que queremos conseguir es eliminar los reflejos o detecciones de un
sensor que no son tal. Imagínate una fotocélula que se ve influenciada por el reflejo de
un objeto que realmente no se quiere detectar. En el sector en el que yo me muevo, el
del vidrio para automoción suele suceder de vez en cuando y por ello normalmente las
células suelen estar filtradas.
¿Cómo?
Mediante un temporizador con retardo a la conexión. Este temporizador hará que un
pequeño guiño haga que la lectura del sensor siga siendo cero salvo que se supere un
cierto umbral de tiempo detectando el objeto. El tiempo de detección se verá mermado
el tiempo programado.
Filtro de guiños negativos
Podría pasar justo lo contrario, que detectando el objeto instantáneamente dejes de

detectar el objeto para volverlo a detectar. Para evitar este guiño negativo puedes usar
92
un temporizador con retardo a la desconexión. Con este temporizador alargarás la

detección del objeto haciendo que si en medio de la detección hay un hueco en la
medida, esta quede filtrada. Lógicamente el tiempo de detección se verá alargado el
tiempo programado.
Filtro combinado
Si lo que quieres es filtrar en uno u otro sentido, tanto a guiños positivos como negativos,
puedes usar dos temporizadores con retardo a la conexión que hagan:
Un retardo a la conexión de la señal (E0.0) a uno poniendo a set una marca (M10.0) que
representará la señal.
Un retardo a la conexión de la caída de la señal (E0.0) reseteando dicha marca (M10.0).
De esta forma tendrás la señal E0.0 representada por la M0.0 filtrada tanto contra filtros
positivos como negativos.
Si los tiempos de los temporizadores son iguales, el tiempo de detección no varía, pero
sí está desplazado el tiempo configurado.
Crear un tren de pulsos
Para generar una marca pulsante (M1.0), lo haremos como figura en la siguiente captura
mediante dos temporizadores s7 (T2 y T3).
Lo que haremos será ponerlos en serie y que el primero se active con retardo a la
conexión de que el segundo esté parado. El segundo estará como retardo a la conexión
de la activación del primero. Entremedias, a la salida del primero, ponemos la marca
como conector (podríamos usar como variable también la propia marca).
93
Destellos por un tiempo fijo de una señal
Imagina que quieres hacer un tren que con una señal, dure un determinado tiempo.
Imaginemos 30 segundos.
Lo que haremos será combinar:
 El tren de pulsos anterior

 Un temporizador de impulso prolongado.
Reset de un relé de forma segura
La siguiente aplicación está implementada en la mayoría de los relés de seguridad un

poco modernos y complejos.
Pero imaginemos que no tenemos más que un relé que rearma si das una señal y si se
queda dada la señal, pues intentaría rearmar de forma continua logrando por tanto un
sistema de autorrearme, cosa que pone los pelos de punta solo de pensarlo.
Hay veces que por malfuncionamiento, otras por picaresca, imaginemos que el botón
de reset se queda metido. Vamos a evitar que pueda rearmarse el relé si es así.
Para ello, el rearme no lo dará directamente el botón, sino el PLC de forma controlada.
94
Las condiciones van a ser:
 Que pulses un tiempo mínimo de dos segundos

 Que el tiempo pulsado sea como máximo de 5 segundos.
Lo que haremos entonces es con la señal de reset poner a correr dos temporizadores.
Con la caída de la señal, evaluaremos si el temporizador de mínimo se ha cumplido y si
se no se ha cumplido el tiempo máximo. Solo entonces, generaremos un pulso de un
segundo como salida que reseteará el relé de seguridad.
Para terminar, el vídeo.
95
23. Cómo crear un cronómetro en Step 7

Esta semana respondiendo a una duda/petición de uno de los lectores vamos a crear
un cronómetro en Step 7.
La verdad es que no tiene mucha ciencia, y por eso le he querido dar un poco más de
gracia al invento haciendo que se muestre en el Wincc Flexible mediante discos
concéntricos a modo de diana.
Como verás en el vídeo los segundos, minutos y horas describen perfectamente una
circunferencia según va pasando el tiempo.
Cronómetro en Step 7
El cronómetro tal y como está la verdad es que no lo he usado nunca, pero no es menos
cierto que en más de una ocasión he calculado tiempos de forma similar a la que se
describe en el vídeo usando:
 El OB35
 Una variable a modo de contador
La idea es muy simple: aprovechando la frecuencia sabida de ejecución del OB35,
aprovechamos para contar. En este caso, cada 100ms. Por tanto, cada 10 ejecuciones,
tendremos 1 segundo.
Sacar los minutos y segundos, será trivial. Iremos pasando la información hacia arriba:
cada 10 ejecuciones tendremos un segundo, y por cada sesenta segundos, pues un
minuto…
¿Fácil no?
WinCC Flexible
Para aderezar el problema he introducido la variable del WinCC. Para ello, he pensado
que qué mejor que hacer que tener partes móviles en la pantalla.
¿Cómo?
Realmente es sencillo. A cada elemento en una pantalla de WinCC puedes moverlo de
forma dinámica mediante unos offset. Estos Offset en el eje X como en el Y son variable
que lógicamente puede tomar diferentes valores.
Ya, ya… ¿pero cómo calculas la posición?

Pues usando la trigonometría de segundo de bachiller… con senos y cosenos.
Lo que sabemos de nuestro reloj es la posición relativa dentro de la esfera del reloj.
Sabiendo eso, podemos saber qué ángulo formaría la aguja y por tanto su seno y su
coseno.
96
Teniendo la longitud de la aguja (el radio) y el ángulo podremos calcular en coordenadas

cartesianas muy fácilmente la posición X e Y ya que:
 X = Radio *Cos (ángulo)

 Y = Radio *Sen (ángulo)
¿A que parece mentira que esto de las funciones trigonométricas que estudiaste hace
la tira de años sirvan para algo?
Pues sí, sirven para muchas cosas, entre ellas dibujar relojes... ¿qué te parece?
Para que esto tenga un poco más de sentido práctico, pues el video de casi todas las
semanas donde vas a poder ver de qué diantre te estoy hablando.
97
24. Filtrado y enmascarado de bits en Step 7

Esta semana la entrada va a ser corta pero espero que interesante sobre el filtrado y
enmascarado de bits.
Recientemente me he visto en la necesidad de realizar lo siguiente: tengo una serie de
alarmas de una máquina A, y quiero pasar una única señal booleana a otra máquina B
por Profibus que indique que hay una alarma activa en la máquina A.
Podríamos hacer un OR bit a bit, pero sería un poco hacerlo a lo burro. Porque si son
unas pocas bien, pero como sean unas cuantas el OR va a ser como la torre de Iberdrola
de Bilbao (hay que tirar para casa).
Hasta ahí ningún problema. Las alarmas comienzan imaginemos en la M32.0 y terminan
en la M37.7. Con ir haciendo OR de palabras sería suficiente.
Cómo saber si hay una alarma activa (usando todas las alarmas)
SET –> Pongo a uno el RLO
R M100.0 –> Resteo el valor de la marca M100.0 que es la que voy a mandar a la
máquina B. Inicialmente no hay alarma.
L MW32 –> Leo los primeros 16 bits
L MW34 –> Leo los siguientes 16 bits
OW –> Hago un OR de palabra con lo cual el resultado cargará en el ACU1 todos los
bits que estén a uno haciendo OR bit a bit
L MW36 –> Cargo los últimos 16 bits
OW –> Hago un OR entre el contenido del ACU1 y la MW36 y lo transfiero nuevamente
al ACU1
L 0 –> Cargo un cero en el ACU1 y por tanto el resultado del OR pasa al ACU2
==I –> Hago una comparación entre el cero del ACU1 y el contenido del ACU2
SPB EXIT –> Si es cero (el RLO está a 1), salto y no hago nada
SET –> Pongo el RLO a uno
S M100.0 –> Pongo a uno la marca M100.0 que será la que envíe a la máquina B
EXIT: NOP 0
98
¿No valdría con sumar y ya está?
Otra aparente fácil solución sería usando la misma estructura:

SET
R M100.0
L MW32
L Mw34
+I
L MW36
+I
L0
<>0
SPB EXIT
SET
S M100.0
EXIT NOP 0
Tanto rollo con low OW… una suma y listo…
Ummmm en general sí…. en particular… no.

Este último ejemplo funcionará CASI siempre.
¿Descubres la razón?
Es realmente sencillo. Estamos sumando valores enteros…pero pueden ser positivos o
negativos. Por tanto, en general funcionaría pero al hacer la suma, puede haber valores
que hagan que MW32+MW34+MW36 = 0 ya que estos valores pueden tomar valores
positivos o negativos.
El ejemplo de comparar con cero valdría si por ejemplo son 16 alarmas. Ahí no habría
problema ya que no hay sumas, ni restas ni comparaciones ni nada de nada. Lo
comparas con cero, y si no es cero, es que hay una alarma tocando los coj... ejem. Que
hay una alarma activa.
Filtrado y enmascarado de bits
Vale. Ya hemos visto cómo podríamos saber si hay una alarma activa teniendo en
cuenta todas las alarmas.
99
Pero imaginemos que no es el caso. Quiero pasar todas las alarmas salvo media docena
que son alarmas que no interfieren con el proceso de la máquina B y por tanto no las
quiero enviar.
Vale. Ahora sí que sí hago un cojo-OR eligiendo los bits.

Hombre… no. Son unas cuantas.
Imaginemos que no queremos tener en cuentas los bits: 32.1, 35.7, 36.0, 36.1, 36.2 y
37.3 (por poner un ejemplo).
El primer método está claro que no me sirve. Las sumas, mucho menos… hacer un OR
de cada bit dejando estas sin meter es un poco remedio básico… y aquí queremos ser
los más chulos del barrio programando S7.
¿Cómo lo hacemos?
Pues creando máscaras… usando enmascarado de bits.
Vale, la idea es sencilla: crear un grupo de bits que sean los bits que nos queremos
quedar y hacer un AND con las señales de tal forma, que el AND resultante, si es distinto
de cero, es porque hay alarma.
Ejemplo:
Imagina que tienes la M32.1 y la M32.3 a uno y el resto del byte está a cero ¿Ok?
Tendríamos que
MB32 = 0 0 0 0 1 0 1 0
¿Sí?
Solamente el bit 1 y 4 empezando por la derecha sería unos (los 0.1 y .3 ya que
empezamos en .0), y se lee de derecha a izquierda.
Vale. ¿Cómo podemos saber que hay una alarma descartando el M32.1 cómo
queremos?
Pues haciendo un AND con el siguiente byte:
MB32 =00001010
Mascara = 1 1 1 1 1 1 0 1
Resultado = 0 0 0 0 1 0 0 0
¿No se te eriza el bello?
Ya claro… pero ¿cómo cargo el enmascarado de bits? porque si tengo que calcular
cuánto es el resultado de cada máscara en decimal pasándolo de binario, me dan las
uvas… pero está claro que no de este año.
100
Muy fácil. Así:

L MB32 –> Cargo el primer byte
L 2#1 1 1 1 1 1 0 1 –> Cargo en binario mi número usando base 2.
Vale. Deja ya de aplaudir y prosigamos… que ahora estarás conmigo que es trivial:
SET
R M100.0 –> Como antes empezamos reseteando la señal
L MB32 –> Cargamos el primer byte
L 2#1 1 1 1 1 1 0 1 –> Cargamos el enmascarado de bits para el byte 32
UW --> Hacemos el AND
L MB33 –> Cargamos el Byte 33
OW –> Hacemos un OR entre el resultado y el byte 33 que no hay que filtrar
L MB34 –> Cargamos el byte 34
OW –> Hacemos un OR entre el resultado del OR y el byte 34 que no hay que filtrar
T MW20 –> Una marca intermedia ya que vamos a necesitar almacenar el resultado
L MB33 –> Cargamos el byte 35
L 2#0 1 1 1 1 1 1 1 –> Cargamos la máscara para despreciar el 35.7
UW –> Hacemos el AND para quedarme con todo menos con el 35.7
L MW20 –> Cargamos el resultado hasta ahora
OW –> Hacemos un OR con el resultado
T MW20 –> Lo transferimos a la marca intermedia nuevamente
L MB36 –> Cargamos el Byte 36
L 2#1 1 1 1 1 0 0 0 –> Cargamos la máscara para el 36.0, 36.1 y 36.2
UW –>Realizamos el enmascarado de bits
L MW20 –> Cargamos lo que tenemos hasta ahora
OW –> Hacemos un OR
L MB 37 –> Cargamos el último byte
L 2#1 1 1 1 0 1 1 1 –> Cargamos la máscara del 37.3
UW –> Realizamos el enmascarado de bits
L MW20 –> Cargamos el temporal
OW –> Hacemos un OR
T MW20 –> Hacemos la última transferencia al MW20
101
L MW20 –> Cargamos el temporal con el resultado

L0 –> Cargamos un cero
==I –> Los comparamos
SPB EXIT -> Si el MW20 = 0, saltamos al final ya que no hay alarmas.
SET
S M100.0 –> Si no es cero, ponemos la señal de alarma a 1.
EXIT: NOP 0
¿Se podría hacer con words en vez de con bytes?

La respuesta es sí, pero no te lo recomiendo ya que vas a tener que manejar 16 cero o
unos y además recuerda que hay que poner de derecha a izquierda los bits y primero el
byte alto y luego el byte bajo… igual te lías un rato.
Son más instrucciones que con words, pero mucho más claro y mantenible sin llegar a
tener que poner un OR de todos los bits cada uno por separado. En racimos de 8 creo
que es razonable.
102
25. Cómo realizar un tracking de datos en Step7
Con este ejemplo vamos a ver cómo realizar un tracking de datos en step7 usando dos
funciones integradas: SFC20 y SFC21.
El tracking de datos no va a ser nada más que arrastrar a lo largo de las posiciones de
nuestra línea la información del objeto que está circulando por ella, desde la receta (o
pauta) que sea, recorrido que ha de llevar, y cualquier característica o información que
sea deseable que arrastre desde el principio hasta el final (o que se vaya añadiendo por
el camino).
Una cosa importante que has de tener en cuenta a la hora de realizar tu automatización
es el grado de importancia que va a tener el arrastrar esta información.
Digo esto porque para realizar una buena trazabilidad y saber qué información lleva qué
pieza, has de saber en todo momento donde está qué, de tal forma que no haya
posibilidad de error a la hora de arrastrar la información.
Normalmente esto lo vas a realizar mediante la detección y transporte de las piezas,
posicionamiento por encóder etc. Pero de alguna forma has de saber cómo detectar o
calcular dónde está cada pieza de tal forma que no cometas errores a la hora de
arrastrar la información.
Tracking de datos en Step7
A la hora de realizar nuestra trazabilidad, puede ser que sólo necesitemos un bit de
estado (lleno/vacío, bueno/malo). En tal caso puede que te sirva las operaciones de
desplazamiento como ya veremos en desplazamiento y giro de bits.
Pero lo que vamos a descubrir juntos es como arrastrar una cantidad ingente de
información (ingente, es relativo, pero más de un byte vaya).
Para ello vamos a necesitar conocer las siguientes herramientas:
 SFC20: Block Move con el que vamos a poder copiar bloques completos de
información.
 SFC21: Fill. Con el que podremos rellenar zonas de memoria con la información
que queramos (por ejemplo ceros).
 UDT: ¿te acuerdas? Esta vez le vamos a dar un uso práctico.
El "conceto"
Como decía el gran Manquiñas en Air Bag , lo importante es el conceto.
¿Qué es lo que vamos a hacer?

Pues básicamente, pasar la información de una posición a la siguiente y borraremos la
que tenemos en la estación anterior.
103
Bien, vale... ¿pero cómo?

Vamos a usar las funciones SFC20 y 21. La primera, SFC20 nos va a permitir
copiar volúmenes de datos grandes de un origen A a un destino B. Por ejemplo,
podemos copiar el contenido completo de un DB a otro DB ¿entiendes por dónde voy?
Y el SFC21 ¿para qué lo quieres?

Una vez que hayamos copiado la información, lo suyo es que borremos la información
de la estación origen. Para ello usaremos la función llenar SFC21 "Fill". Tomaremos una
zona de memoria que tenga todo ceros y con ella rellenaremos el DB origen (o el área
que sea).
Y claro, vamos a usar DB...

Correcto. Si el volumen de datos es importante y/o tenemos diferentes estaciones,
tenemos varias opciones:
 Usar un único DB de tracking.

 Usar un DB de tracking por posición.
Si usamos un único DB de tracking crearemos típicamente un array de posiciones (por
ejemplo con números de transportador). Cada array contendrá la información de cada
uno de los transportadores (o lo que sea) y pasaremos los datos de una zona a la
siguiente.
En el segundo caso, cada transportador tendrá su propio DB pasando la información de
un DB a otro.
¿Cuál es mejor?
Pues ni uno ni el otro, ni todo lo contrario. Dependerá de cada caso.
Contener todo en un DB tiene una gran ventaja, que es mucho más compacto y fácil de
saber dónde encontrar toda la información ya que sólo hay un sitio que la contenga.
Pero tiene un gran pero... que más te vale que hayas hecho bien los deberes y tengas
claro qué información vas a intercambiar y que hayas dejado suficiente espacio libre de
no tenerlo muy claro.
¿Por qué dices eso?

Porque si después de haber estado muchas horas trabajando sobre el proyecto llegan
nuevos requerimientos y has de aumentar el volumen en el tracking y no has dejado
espacio suficiente te vas a cag.. en lo más barrido.
Tendrás toda la información del tracking difuminada y usada por medio programa y a la
hora de elegir los datos, ya no coincidirán los punteros porque tienes que añadir nuevos
datos y por tanto, has de cambiar los índices de las lecturas y/o escrituras.
Por ejemplo. Imagina que has reservado exclusivamente el código de la pieza que tiene
8 caracteres en un string (10 bytes en total) de tal forma que la posición 1 empieza en
la 0.0 la dos en la 10.0 la tres en la 20.0 etcétera...
Has programado, leído el código donde has querido o lo que sea que hayas hecho a lo
largo del programa... y ahora no solamente has de arrastrar ese código sino también el
104
número de pieza desde el inicio de turno... ¿entiendes el tamaño melocotón que van a
coger las lágrimas que van a recorrer tus mejillas?
Ahora, suponiendo que el número de pieza sea un entero, el índice del código de la
pieza dos no empieza en el 10.0 sino en el 12.0, la tres en la 24.0... ¿Entiendes la broma
de mal gusto?
¿Solución?
Pues dejar más espacio o si es una cantidad importante de datos (o porque el tracking
no sea muy largo) hacer para cada posición, un DB.
Si has dejado suficiente espacio, fin del problema. Acomodas los nuevos valores a
transferir y listo.
Ojo, porque cuando hagas el tracking, arrastra la información completa, sea espacio
libre o no. Es decir, si para cada posición tienes 20 bytes aunque sólo uses 12, arrastra
los 20. Esto hará que las futuras ampliaciones sean triviales ya que se estará
arrastrando todo siempre, lo usado y el espacio libre. Es obvio, pero mejor dejarlo claro.
Por otro lado, como te comento, puedes asignar un DB para cada posición.
¿Qué ventaja tiene usar un DB por posición?

Pues que básicamente el ampliar los DB es simplemente añadir la información nueva al
final y volver a cargar los DB en caso de que hayas superado la longitud máxima.
También te recomiendo que aun usando los DB así, dejes espacio libre al final. Esto
evitará que en una ampliación tengas que cambiar los valores de cuántos bytes
arrastras. Un 20%-25% puede estar bien (más o menos dependiendo del tamaño que
coja y previsión de necesidades). Así por ejemplo si mis datos son 80 bytes, pues sin
duda yo dejaría libre hasta completar los 100 bytes.
Otro motivo por el que usar los DB separados puede ser porque sean pocas posiciones
de tracking con un volumen algo elevado. Digamos que porque cada posición tiene
entidad suficiente como para tener sus propios DB.
Pues siempre uso DB separados y ya está...

Pues puede ser un gran error... Porque si tu línea va a tener muchas estaciones y vas
a arrastrar poca información, generas mucho ruido en el proyecto. Imagina que tienes
30 estaciones para arrastrar poco más que un par de bytes. Siempre será mejor crear
un DB más grande, dejando 20 bytes para cada posición (por decir algo) que no generar
un DB para cada uno.
Vamos, que uses la pelota que tienes encima de los hombros antes de decidir uno u
otro.
105
Vayamos con un ejemplo práctico

Como casi siempre, vamos a poner todo esto en práctica mediante un ejemplo. En este
caso vamos a hacer algo un tanto abstracto, pero que lo que va a querer simular es una
línea con 5 posiciones.
En el ejemplo vamos a tener dos botones.
 Uno para cargar los nuevos datos

 Un botón para generar el tracking
Lógicamente en la vida real no se produce como en el ejemplo, pero con lo que quiero
que te quedes es con cómo se mueve la información de un sitio a otro.
En una automatización de verdad, habrá condiciones para pasar la información de un
lado a otro y no se hará completamente en cascada.
Para darle una pequeña gracia lo que vamos a hacer es que la información se arrastre
siempre que la siguiente posición esté libre, pudiendo moverse siempre la última para
dar por finalizado sumando uno a un contador de piezas buenas.
Además le vamos a poner una salida intermedia en la cual, si la información dice que la
pieza es mala, salga lateralmente y desaparezca del tracking sumando una al contador
de piezas malas.
Como siempre, es más fácil de ver que de explicar con palabras, así que te dejo con el
siguiente vídeo donde puedes ver el pequeño ejemplo.
106
26. Contadores en Step 7

Para ir terminando la primera parte del libro (la más sencilla pero la más importante por
su relevancia dentro de los proyectos), vamos a ver cómo trabajar con los contadores
en Step 7. Vamos a ver varias formas de cómo trabajar con contadores:
 Sumar y restar sobre una variable

 Usar los comandos INC /DEC
 Usar los contadores S5
Contadores en Step 7 usando un entero
Poco le vamos a dedicar a este contador: se trata de sumar y restar sobre una pobre e
inofensiva palabra.
Si queremos sumar, pues usaremos +I, si queremos restar, pues -I. Lo hemos usado
con anterioridad y no tiene mayor complicación:
L MW10 –> Cargamos lo que tengamos
L 1 –> Cargamos la cantidad que queremos sumar
+I –> Sumamos ambas cantidades y lo almacenamos en el ACU1 (-I para restar)
T MW10 –> Lo transferimos de nuevo en el contador MW10
Como ves, nada nuevo que no sepas ya.
Contadores en Step 7 usando INC y DEC
Podemos también usar, en vez de una palabra, un byte (Con la limitación de contaje
que ello conlleva al ser sólo un byte).
Existen dos instrucciones para este tipo de contadores:
 INC N#_8_bits para incrementar el contador

 DEC N#_8_bits para decrementar el contador
Así, para usarlo tan sólo deberemos usar de esta forma las operaciones:
L MB100 –> Cargamos el contador en el ACU1
INC 1 –> Sumamos 1 al ACU1
T MB10 –> Lo volvemos a cargar en el MB10
Análogamente, para descontar:
L MB100 –> Cargamos el byte que lleva el contaje en el ACU1
DEC 2 –> Restamos dos unidades al ACU1
107
T MB100 –> Transferimos el resultado de nuevo al MB100

¿Fácil no? Muy parecido al caso anterior pero ligeramente más compacto.
Contadores en Step 7 usando contadores S5
Los contadores S5 (Z) son contadores al igual que los temporizadores S5 una
reminiscencia de antiguos autómatas (quién lo iba a decir con ese nombre ¿eh?).
Son de tipo hardware también como los temporizadores S5 y la cantidad depende de
cada CPU.
El uso de este tipo de contadores depende de cada proyecto y de cada programador.
Personalmente no los uso porque me siento más cómodo con la primera opción de las
vistas. Además, este tipo de contadores tienen una limitación de contaje que llega hasta
las 999 unidades.
Las operaciones que se pueden realizar sobre estas operaciones son:
 Cargar un valor de contaje

 Borrar el valor de contaje
 Contar y descontar
 Consultar su valor tanto como cantidad como operación booleana
Cómo cargar un valor a contadores en Step 7

Para cargar un valor en un contador, cargaremos el valor usando el prefijo C# y luego
haciendo un S Z1 (por ejemplo) si el RLO está a uno. Por ejemplo:
U M0.0 –> Leemos el valor de la marca M0.0
L C#12 –> Cargamos el valor en el ACU1
S Z 1 –> Si la M0.0 fijamos el valor “12” en el contador Z1
Sumar y restar sobre contadores en Step 7

Con las instrucciones ZV y ZR podrás incrementar o decrementar el contador en función
del estado del RLO
Así y siguiendo con el Z1:
U M0.1 –> Leemos el estado de la marca M0.1
ZV Z1 –> Si la señal está a 1, incrementamos en uno el valor del Z1
U M0.2 –> Leemos el estado de la marca M0.2
ZR Z1 –> Si el RLO está a uno, restamos una unidad al Z1.
108
Poner a cero un contador

Hemos visto, que para cargar un valor de contaje, lo hemos hecho, con un Set, pues
para ponerlo a cero, será con un Reset:
U M0.3 –> Leemos el valor de la marca M0.3
R Z1 –> Si está a uno, ponemos a cero el contador
Leer el valor del contador y su estado
Al igual que pasa con los temporizadores S5, podemos leer directamente el estado del
contador y hacer lógica booleana con ello. Es decir, podemos hacer un:
U Z1
= A1.0
Esto significa que mientras el contador sea cero, el valor de A1.0 será cero y se pondrá
a uno cuando el Z1 > 0.
Por otro lado, puede que queramos saber cuánto va valiendo el contador. Para ello,
haremos una lectura de este estilo:
L Z1 –> Si queremos leer en valor decimal
T MW10 –> Se lo transferimos al MW0 por ejemplo
LC Z1 –> Leemos el valor del Z1 en BCD.
T MW20 –> Lo transferimos.
¿Y en KOP?
En resumen de lo visto, podemos verlo en KOP como en la figura adjunta. En el tienes

todas las instrucciones vistas en un único bloque que se puede usar en FUP o KOP.
109
Si vemos este bloque en AWL, lo que tendríamos sería:

U M 0.1
ZV Z 1
U M 0.2
ZR Z 1
U M 0.0
L C#12
SZ1
U M 0.3
RZ1
LZ1
T MW 10
LC Z 1
T MW 20
UZ1
= A 1.0
Los diferentes colores son las instrucciones arriba vistas. Como ves, cada parte está
bien diferenciada.
Vamos a dar un pequeño repaso a lo visto con un vídeo muy sencillo en el que puedas
ver cómo funciona lo visto hasta ahora.
110
27. Saltos: SPA, SPB y SPBN (If-Then-Else)
¿Qué son los saltos en Step 7?
Como en cualquier lenguaje de

programación, los saltos en Step 7 no
son más que interrupciones de la
ejecución lineal del código,
posicionándose en un nuevo punto (en
general indicado por una etiqueta o
meta) continuando normalmente con el
programa desde este nuevo punto.
En el caso de los PLC estos saltos nos
sirven para simular decisiones que en
lenguajes de alto nivel se resuelven de
otra forma, como por ejemplo con los IF/THEN-ELSE por poner un ejemplo.
Estas estructuras como tal no existen en AWL/FUP/KOP, sino que hay que fabricarlas
por decirlo de alguna manera. La forma más sencilla de hacerlo es mediante el uso de
saltos.
Los más importantes por su uso a mi juicio son SPA, SPB y SPBN.
SPA se usa para saltos incondicionales.
Es decir, cuando se ejecuta esta sentencia, la ejecución continua en la etiqueta que

acompaña al operando de forma fija e incondicionada. No depende de nada. Salta y
continúa.
La forma de ejecución será la siguiente:
SPA META
<<Código que no se ejecuta>>
META: <<continua el código>>
Tal y como está representado, si se ejecuta la sentencia SPA META, el código entre
esta sentencia y la META en sí, no se ejecutará nunca.
¿Entonces para qué sirve?
Bueno, enseguida veremos cómo gestionar este tipo de cosas. De momento quédate
con la idea de que SPA es un salto incondicional al META indicado.
111
SPB y SPBN se usan para saltos condicionados al valor del RLO
La diferencia fundamental entre ellos es que si usas SPB el salto se producirá si el RLO
= 1, mientras que el salto usando SPBN se producirá si el RLO = 0.
Por tanto, y análogamente su uso será de esta forma:
<<Condición del salto>>
SPB META (o SPBN META)
<<Código que no se ejecuta>>
META: <<continua el código>>
Es decir, tras evaluar el resultado de la condición de salto (cero o uno), en función de
este. Y del tipo de salto elegido (SPB o SPBN), se realizará el salto o no.
¿Qué pasa si no se realiza el salto?
Buenísima pregunta. ¿Qué crees que sucederá? Efectivamente, que la ejecución del
código continuará normalmente. Pongamos un mini ejemplo.
L MW0
L MW2
==I
SPB IGUA
L1
L MW4
+I
IGUA: NOP 0
<<Resto del programa>>
Veamos. Lo que estamos haciendo es lo siguiente: cargamos el contenido del MW0 y
MW2 en el ACU1 y ACU2. Luego hacemos una operación de comparación de igualdad.
Es decir, preguntamos si estos dos valores son iguales. El resultado de esta
comparación será binaria (cero o uno) y estará cargado en el RLO.
Bien, una vez tengamos el resultado de esta comparación decimos que si el RLO = 1,
salte al meta IGUA. Entonces continuará con el resto del programa.
Ahora bien, si no se cumple la igualdad, se ejecutará el código que hace que la marca
MW4 se incremente en una unidad… y seguirá con el resto del programa.
112
¿Vale, vale… pero como construyo un IF-THEN-ELSE?
Pues haciendo una combinación de los saltos podemos hacer la lógica:

IF Condición THEN
Código si se cumple la condición
ELSE
Código si no se cumple la condición
END IF
¿Cómo lo hago con saltos en Step 7?
Pues usando los saltos así:

Condición de salto
SPBN ELSE
Código si se cumple la condición
SPA EXIT
ELSE: NOP 0
Código si no se cumple la condición
EXIT: NOP 0
Continuar con el código.
¿Lo vemos con un ejemplo?
Siguiendo con el ejemplo inicial:

L MW0
L Mw2
==I
SPBN ELSE
L MW4
L1
-I
T MW4
ELSE: NOP 0
113
L MW4
L1
+I
T MW 4
EXIT: NOP 0
Es decir, cargamos MW0 y MW2. Evaluamos si son iguales o no. En función del
resultado:
 Si es igual, el resultado será RLO=1, y por tanto no hará el salto a la meta ELSE.
Restará una unidad a MW4 y realizará un salto incondicional a la meta EXIT.
 Si no es igual, el resultado será RLO = 0, y por tanto SI hará el salto a la meta
ELSE. Sumará una unidad a MW4 y continuará el programa.
¿Pero esto no se puede hacer con FUP o KOP?
La mayoría de las veces, las situaciones de aplicar operaciones de comparación irá

asociada y combinada con lógica booleana, por lo que sí será aplicable hacerlo con KOP
o FUP si el resultado es por ejemplo poner una marca a Set.
La idea de usar AWL y este tipo de soluciones cuando vas a realizar muchas
operaciones aritméticas, punteros etc. No para programación booleana.
114
28. Cómo anular partes de un programa.
Aprovechando que ya hemos visto los principales saltos de Step 7, vamos a ver métodos
para anular parte de un programa entre los cuales están los saltos.
Anular parte de un programa comentando líneas
Una forma muy sencilla de eliminar parte de la ejecución de un programa es comentar

las líneas que te interesen borrar. Así, para anular parte de un programa harás algo así:
U E 0.0
U E 0.1
U E 0.2
= A 1.0
Imaginemos que queremos eliminar la U E0.1
Pues sencillamente:
U E 0.0
// U E 0.1
U E 0.2
= A 1.0
La ventaja es que queda reflejado lo que has anulado por si quisieras volver hacia atrás.
Pero hay que tener en cuenta que eso solo se ve en el proyecto offline, ya que esas
líneas comentadas no se cargan en el PLC Siemens.
Anular parte de un programa realizando saltos.
Otra forma de anular parte de un programa es realizando un salto con SPA:

U E 0.0
SPA BORR
U E 0.1
BORR: NOP 0
U E 0.2
= A 1.0
115
Lógicamente esto es medianamente útil si el código a anular es temporal y es

suficientemente grande para que salga a cuenta incluir un salto. La parte positiva es que
este tipo de anulación sí se carga en el PLC para futuros cambios.
Anular parte de un programa usando una marca nula
¿Cómo hacer esto en FUP o en KOP? Pues creando un Always Off, es decir, una marca
que siempre está a cero y poniéndola en serie si es KOP o dentro de un AND si es en
FUP, haremos que esta parte no de señal.
OJO AL PARCHE. Esto solo es válido si lo que se quiere anular una salida o una marca
(que sea cero) o que no se realice una operación aritmética o de comparación. Pero si
es lógica booleana con una salida, ejecutarse, se ejecuta, solo que obligamos a que en
ese momento, la salida sea cero.
Anular parte de un programa usando BEA
Si quieres anular parte de un programa, y este esta parte es la parte final, con colocar
un BEA al final, hará que lo que venga detrás, ya no se ejecute.
Así
U M 0.0
O M 0.1
= M 1.1
BEA
U E 0.0
U E 0.1
U E 0.2
= A 1.0
La parte en negrita, no se ejecutará al encontrarse detrás del BEA.
116
29. Instrucción LOOP – El For /Next del PLC
Una de las instrucciones más habituales en un lenguaje de programación de alto nivel,

es la sentencia FOR-NEXT. Para nuestros autómatas, tenemos la instrucción LOOP en
Step 7.
Este tema, al igual que los que quedan del curso ya los hemos visto, pero además de
volverlo a explicar, vamos a ver un nuevo ejemplo.
Loop en Step 7
La forma de operar es la siguiente: LOOP META. Ya está, no hay más… más o menos.
La idea es que cuando llega la ejecución de la operación se lee el contenido del ACU1,
se le resta uno, y si aún hay algo que rascar (es decir, no es cero), se realiza un salto
hasta la META.
¿Y cómo hago un FOR NEXT con LOOP en Step 7?

Bien, la fórmula de la Coca-Cola esta vez es muy sencilla:
L Numero_Iteraciones –> Cargamos cuántas veces queremos hacer el loop
NEXT: T Indice_Iteraciones –> Lo transferimos a la variable auxiliar que lleva la cuenta
de vueltas
<<<Código que queremos que se ejecute N veces>>>
L Indice_Iteraciones –> Leemos el número de vueltas que llevamos y lo cargamos en el
ACU1
LOOP NEXT –> Restamos una unidad a lo cargado en el ACU1, es decir, al número de
iteraciones y saltamos a la meta NEXT si el resultado no es cero.
Vamos, que lo que hacemos es inicialmente cargar a tope con el número de iteraciones
a una variable auxiliar que será nuestro índice. Por ejemplo 10.
Ejecutamos el código repetitivo y lo último que hacemos es cargar este índice
nuevamente. Luego, al ejecutar la operación LOOP, restaremos una unidad a ese 10
inicial, teniendo en el acumulador entonces 9 y salta a la meta NEXT.
Si te fijas, lo primero que hacemos es volcar nuevamente este 9 al índice…
ejecutaremos, cargamos el 9, restamos uno en el loop y saltamos a NEXT, teniendo un
8… y así sucesivamente.
117
El vídeo con el ejemplo sobre el tema:
Filtrado de una señal analógica
Se trata de realizar un filtrado de una señal analógica de esta forma:
 Tomaremos la señal cada 100 ms.

 Pasaremos como entrada el valor analógico en tipo entero
 Realizaremos un filtrado de los “n” últimos ciclos donde “n” puede ser como
mucho 200.
 Nos devolverá la media de los “n” últimos ciclos como valor real
 Nos devolverá la medida de los 200 últimos ciclos si hemos puesto n>20 y una
señal booleana de alarma indicando que el número de ciclos es demasiado
grande y que por tanto devolvemos solamente la media del máximo número de
ciclos.
118
30. Saltos SPL en Step 7. El Select Case en AWL
Esta semana vamos a ver el salto SPL en Step 7. Se trata de un salto de metas
estilo Select Case que podríamos encontrar en lenguajes de programación de alto nivel.
Junto con los ejemplos vistos de cómo hacer los IF/THEN/ELSE y el FOR-NEXT,
tendríamos elementos suficientes para realizar programas bastante sofisticados ya que
estas tres operaciones son básicas en un lenguaje de alto nivel, pero que permiten
realizar operaciones complejas.
¿En qué consiste el SPL en Step 7?
Básicamente lo que vamos a realizar es un salto a una meta en función del valor
numérico de una variable que hemos volcado en el ACU1 antes de realizar la llamada a
la instrucción SPL.
La estructura sería como sigue:
L MB0 //Cargar el número de la meta del salto en el ACU1-L-L.
SPL ELSE //Meta del salto si el ACU1-L-L es > 3.
SPA SEG0 //Meta del salto si ACU1-L-L = 0.
ELSE: SPA END0
SEG0: * //Instrucción permitida.
*
SPA END0
*
SPA END0
*
SPA END0
*
SPA END0
END0: NOP 0
119
Me vas a permitir que te lo cuente un poco más en cristiano. La idea es que cargas un
valor numérico entero en el MB0 en este caso en cualquier parte del programa y cuando
quieras evaluarlo lo cargas en el ACU1 (haces un L MB0).
Bien. En función de ese valor, con el SPL en Step 7 saltaremos a un meta diferente que
están ordenados en orden creciente para valores 0, 1, 2, 3… etc.
La primera instrucción curiosamente es definir la condición de CASE ELSE, es decir,
qué hacer si no hay un meta definido para el valor en concreto (en nuestro caso si MB0
vale más de 3). En este caso, simplemente estamos haciendo que salte
incondicionalmente a la salida del bucle, pero podríamos realizar algún tipo de
instrucción antes de salirnos.
Como observarás todos tienen al final del meta un SPA ENDO. La razón es sencilla:
una vez ejecutado el código que corresponde a imaginemos MB=1, no queremos que
ejecute lo correspondiente a otros valores de MB, y no podemos depender del valor del
RLO, por lo que realizamos un salto incondicional a la salida.
Lógicamente es aplicable a todos los metas. Yo incluso se lo suelo poner al último
aunque estrictamente no es necesario ya que hacer un:
SPA END0
END0: NOP 0
O quitar el SPA END0, viene haciendo lo mismo. La ventaja es que si añado en un futuro
valores para MB=4 por ejemplo, no corro riesgo de dejarme el salto, que entonces si
sería necesario para este meta al haber uno nuevo bajo el.
120
31. Otros saltos
Para terminar las entradas referidas a los saltos,

vamos a ver sin entrar en mucho detalle, que
también existen otros saltos en Step 7 como son:
 Saltos en función del estado del RB

 Saltos en caso de error
¿Estado del RB? ¿Lo qué?
Vamos a hacer memoria. ¿Recuerdas que hay una palabra de estado que ya lo hemos
visto en un capítulo anterior?
Bueno, pues si extraemos un trocito de esa entrada, vemos que:
Bit 8 – BR
Proviene de Binary Result y es el resultado de las operaciones binarias. Cuando el BR
está a uno, activa la salida de ENO habilitando en bloques concatenados que se ejecute
el siguiente bloque.
Las operaciones SAVE, SPB y SPBB ponen a uno el BR
En general, se puede usar el estado del BR para saber si ha habido un error ejecutando
un bloque y el siguiente está habilitado para poderse ejecutar.
En el caso de FUP/KOP no tiene mucho sentido ya que si concatenas los bloques, ya
estás condicionando la ejecución del segundo a que el primero no haya tenido
problemas. Como se puede observar fácilmente, al concatenar los bloques, la ejecución
de un bloque depende del ENO = 1 del bloque que lo precede (que todo esté OK, por
decirlo de alguna manera).
En AWL puedes hacer una llamada a un bloque y luego mediante saltos, decidir qué
hacer:
 SPBI Saltar si RB = 1
 SPBIN Saltar si RB = 0
Saltos en Step 7 con errores y resultados matemáticos

Como en lenguajes de alto nivel, existe una serie de operaciones de salto para cuando
hay un error y además, en este caso, evaluando el resultado de una operación:
 SPO Saltar si OV = 1
 SPS Saltar si OS = 1
 SPZ Saltar si el resultado = 0
121
 SPN Saltar si resultado <> 0

 SPP Saltar si el resultado > 0
 SPM Saltar si resultado < 0
 SPPZ Saltar si el resultado >= 0
 SPMZ Saltar si el resultado <= 0
 SPU Saltar si el resultado no es válido
Como puedes ver, hay unos cuantos saltos disponibles. La forma de usarlo es como
otros saltos.
Como ves, todos dependen del estado de los bits de estado. Te recomiendo que eches
un vistazo a qué significa cada uno.
A decir verdad, yo estos saltos no los he usado creo que nunca, aunque no está de más
saber que existen.
Si quieres tener más información sobre cada uno de estos saltos, puedes teclear el salto
en AWL en el editor y estando sobre el, pulsar F1. Te aparecerá la ayuda donde
aparecerá un poco más de información.
122
32. Desplazamiento y giro de bits en Step7
Aunque ya vimos algo sobre el desplazamiento de bits cuando jugamos con el display
de 7 segmentos, ahora vamos a ver todas las operaciones disponibles de
desplazamiento y giro de bits en Step7 además de un par de vídeos para ilustrar lo
expuesto.
SHR_I Desplazar entero a la derecha
SHR_DI Desplazar entero doble a la derecha
SHL_W Desplazar 16 bits a la izquierda
SHR_W Desplazar 16 bits a la derecha
SHL_DW Desplazar 32 bits a la izquierda
SHR_DW Desplazar 32 bits a la derecha
Además, hay operaciones de rotación:
ROL_DW Rotar 32 bits a la izquierda
ROR_DW Rotar 32 bits a la derecha
Desplazan el contenido de ACU1 bit a bit. Son incondicionales, no dependen del
RLO. Podemos desplazar, tanto a la derecha como a la izquierda, palabras, doble
palabras, enteros y dobles enteros.
En general, lo que se harán en todas las instrucciones es dar la palabra o doble palabra
a desplazar y un número de bits a ser desplazado.
Vale. Hasta ahí lo entiendo, pero ¿qué diferencia hay desplazar

entero o un Word a la derecha?
Básicamente funcionan igual. La diferencia fundamental es que al desplazar los enteros,

arrastramos también el signo.
¿Lo qué?
Bien. Además de simplemente arrastrar bits de izquierda a derecha o de derecha a
izquierda, esto implícitamente lleva consigo operaciones de multiplicación y división en
base 2. Es decir, desplazar a la derecha 1 bit significa dividir entre dos el número que
tengamos. La diferencia entre hacerlo con enteros o con words, es que en
enteros (SHR_I ) podemos hacer divisiones con signo.
Así si tenemos:
Valor a dividir: MW 102 = 1000 (tanto en entero o decimal)
Desplazar a derecha: MW200 = 1
Si hacemos SHR_I: MW104 = 500 (en entero o en decimal)
Si hacemos SHR_W: MW106 = 500 (en entero o en decimal)
123
En principio no hay diferencia ¿no?

La cosa es que si ahora hacemos
Valor a dividir: MW 102 = (-1000) o 64536 en decimal
Desplazar a derecha: MW200 = 1
Si hacemos SHR_I: MW104 = -500 en entero o en 65036 visto en decimal
Si hacemos SHR_W: MW106 = 32268 en entero o 32268 visto en decimal)
Como puedes observar, la diferencia es notable dependiendo de si tenemos un valor
entero positivo o no. Análogamente si desplazamos a la izquierda en vez de a la derecha
sucederá lo mismo, pero multiplicando en vez de dividiendo… salvo por un pequeño
detalle, que sólo existe el SHL_W.
Entiendo que la razón por la que no existe desplazamiento a la izquierda de enteros es
porque no tiene sentido ya que no se va a guardar el signo, por lo que no existe tal cosa.
Si tuviéramos el último bit con signo menos, lo perderíamos, por lo que de ahí entiendo
la inexistencia de dicha operación.
En cualquier caso, la forma de hacerlo en AWL será de la siguiente forma:
L MW 200 -> Cargamos el número de bits a desplazar
L MW 102 -> Cargamos la palabra a desplazar
SLW –> Operación de desplazamiento (en este caso Word a la izquierda)
T MW 104 -> Transferimos el resultado a cualquier otra palabra
Análogamente sería con las dobles palabras (SHR_DI, SHL_DW, SHL_DW). Pero ojo,
cuando tenemos los bits bien estirados uno detrás de otro, recordad que en una doble
palabra, el bit más a la derecha es el bit .0 del byte alto de la palabra alta. Es decir, del
MD0, el bit más a la derecha será el M3.0, y el más a la izquierda, el bit .7 del byte bajo
de la palabra baja… el M0.7.
Y el giro de dobles palabras

El caso de giro de las dobles palabras es más sencillo aún de entender: daremos el
número de bits a girar y desplazaremos los bits a la izquierda (por ejemplo). Los bits que
quedan fuera por la izquierda, son reintroducidos por la derecha. Si se gira al revés,
pues funciona al revés.
Y como es más fácil de entender viéndolo, pues qué mejor que un video que lo muestre.
124
¿Podrías poner un ejemplo real de desplazamiento y giro de bits en

Step7?
Pues sí. Se trata de un ejemplo de embotelladora. La cosa es arrastrar una señal a lo

largo de un camino paso a paso, a modo de tracking.
El problema es el siguiente: detectamos a lo largo de una cinta la presencia o no de las
botellas, pero el embotellado no es in situ, sino que se produce como 10 posiciones más
adelante. Se trata de arrastrar la información de la fotocélula hasta la posición donde
debe ser rellenada la botella.
Pero como siempre, es más fácil de entender viendo el vídeo que con palabras. Así que
te dejo con el segundo vídeo (ración doble).
125
33. Giro de bits en step 7: el coche fantástico
Vamos a usar dos instrucciones para realizar el giro de bits en step 7:

RLD Rotar doble palabra a la izquierda (32 bits)
RRD Rotar doble palabra a la derecha (32 bits)
Básicamente lo que vamos a hacer es que un bit que lanzaremos desde el OB100 va a
ir desde la marca M1.0 (la más a la derecha de la MW0) hasta la M0.7 (La más a la
izquierda de la marca Mw0)
Rotaremos a tiempo fijo (usando las marcas de ciclo configurada en el PLC) de izquierda
a derecha y de derecha a izquierda moviendo en cada tick un único bit.
Además de eso, añadiremos un FB con el que haremos que cada bit esté en estado 1
un poco más tiempo que el establecido haciendo el barrido más largo o más corto en el
tiempo como veremos más adelante.
El programa básicamente va a estar realizado en dos partes. Los dos primeros
segmentos para realizar el giro de un lado a otro...
El segundo segmento lo haremos para realizar el cambio de sentido. La razón de

realizarlo en un segmento separado es para que cuando haya que cambiar de sentido
se complete correctamente y no se ejecuten dos pasos en el mismo ciclo de scan.
126
Finalmente realizaremos la llamada para realizar el barrido con tiempo volcado en

salidas digitales.
El código del FB no lo inserto aquí porque es mucho más largo y tampoco es necesario
para el propósito sobre el giro de bits en step 7.
El vídeo sobre el giro de bits en step 7
127
34. Direccionamiento indirecto – Memoria y punteros

a área
Para empezar con el tema del direccionamiento indirecto, vamos a explicar una serie de
conceptos básicos y luego nos pondremos con las formas más básicas de
direccionamientos indirectos.
Los tipos de direccionamientos son tres:
 Direccionamiento Inmediato
 Direccionamiento Directo
 Direccionamiento Indirecto
Los dos primeros, son los que conocemos muy bien:
El direccionamiento inmediato es cargar

directamente el valor del operando (de
cualquier tipo), por ejemplo L 32.
El direccionamiento directo será del tipo L
MW10 (donde el valor de MW10 sea el 32
anterior) es decir, en la carga se apunta
directamente al sitio de la memoria donde
reside el valor que queremos cargar.
Nada nuevo bajo el sol.
Ahora bien, ¿qué pasa cuando queremos recorrer áreas de memoria de forma recursiva
o leer un área dinámicamente?
Direccionamiento indirecto
Como decimos, podemos acceder a los valores de la memoria de una forma indirecta..
Vamos a querer saber el contenido de una variable (o área de memoria) usando otra
variable que se referirá a esta área de la que queremos saber su valor.
Parece un poco enrevesado pero es bastante fácil de entender mediante un ejemplo:
podemos abrir el DB10 con AUF de dos formas:
AUF DB10
O bien:
AUF DB[MW20], teniendo la marca MW20 el valor 10.
Esta última forma de cargar el valor de la marca MW10 es uno de los tipos de
direccionamiento indirecto, pero hay varios:
 Direccionamiento Indirecto por Memoria con Número

 Direccionamiento Indirecto por Memoria con Puntero de Área
 Direccionamiento Indirecto por Registro e Intraárea (área interna)
 Direccionamiento Indirecto por Registro e Interárea (área cruzada)
128
El caso anterior, el usado es el primero, mediante número.
Direccionamiento Indirecto por Memoria
Dentro de los direccionamientos indirectos por memoria con número a su vez, podemos
usar MW (o DW de un DB) o MD (o DD de un DB) para acceder:
 Usando formato palabra: accederemos a temporizadores, contadores, abriremos

DB y accederemos a FB y FC.
 Usando formato doble palabra: accederemos a datos de tipo bit, byte, palabra y
doble palabra.
Formato palabra – número (indexados)

Es el más fácil de entender: en un número entero (palabra) introducimos el valor de DB,
FB, temporizador etc. que queramos leer.
Así podemos hacer un
L 10
T MW 10
U T[MW10]
Con lo que estaremos leyendo el estado del temporizador T10.
Digamos que nos sirve para valores operando que están indexados mediante un número
como son los DB, los contadores etc. Para hacer referencia a ellos, nos servimos de un
número ya que existe una lista de estos elementos.
Direccionamiento Indirecto con formato doble palabra – Punteros a

área
Aquí ya se introduce el concepto estrella del direccionamiento indirecto… el puntero.

Hagamos un pequeño paréntesis para ver este concepto.
Un puntero no es más que una dirección. Nada más. No tiene un valor, sólo apunta con
el dedo como un niño pequeño dónde mirar, pero no dice qué está viendo.
Los punteros pueden ser:
 Interárea (Área cruzada) : Por ejemplo P#M10.0, o P#E10.0 o P#DBX10.0

 Intraárea (Área interna): Por ejemplo P#10.0
Como ves hay una gran diferencia. Los que tienen área de memoria se posicionan,
dentro de todas las áreas la memoria en una en concreta, y de esa, en una posición
definida (siguen sin decir lo que vale, pero la dirección es completa).
En cambio, los que no llevan área de memoria, simplemente es una dirección. ¡Pero no
sabemos de qué área de memoria!
129
En nuestro caso, y siguiendo con los direccionamientos indirectos, vamos a usar los
punteros SIN área de memoria.
Así podremos hacer esto:
L P#10.0
T MD10
U E[MD10]
= A [MD10]
En este ejemplo de una imaginación sin parangón, lo que hemos hecho es cargar un
puntero (en el área de direcciones de la que ya hablaremos AR1) y se lo hemos
transferido a la marca MD10. Por tanto, el código de arriba sería lo mismo que escribir:
U E10.0
= A10.0
¿Ves a dónde te puede llevar esto y las posibilidades que ofrece? ¿También se te ha
erizado el bello?
Sigamos…
¿Se puede cargar los punteros de otra forma?
Pues sí.
Resumiendo diremos que le damos la dirección bien mediante el puntero (P#10.0) o
contando con los dedos cuántos bits tiene la dirección. Es decir:
Podemos hacer, al igual que en el caso de arriba:
L 80 (porque la dirección 10.0 son 80 bits)
T MD10
U E[MD10]
= A [MD10]
¿Es lo mismo? Estrictamente lo mismo. Hemos creado el puntero de la misma forma.
Por tanto, de forma numérica, un puntero se verá como el número de bits de ese puntero.
130
Para terminar, y como siempre, os dejo un pequeño video en el cual se explica todo lo
anterior. Espero que os sea de utilidad.
131
35. Direccionamiento indirecto – Registros y áreas
En esta nueva entrada sobre direccionamiento indirecto es con la que terminamos el

curso. En ella vamos a ver la segunda parte de cómo automatizar y recorrer zonas de
memoria para trabajar con ellas de forma indirecta y recursiva.
Registro de direcciones
Como sabes, cuando se carga un valor, hay dos registros, el ACU1 y el ACU2. Pues
también existen dos registros de direcciones, el AR1 y el AR2 para usarlos en el
direccionamiento indirecto.
La forma de cargar y transferir los valores a los registros es de las siguientes 3 maneras:
 Cargar directamente el puntero en el AR1

 Cargar el puntero y transferírselo al AR1
 Cargar el valor numérico de bits y transferírselo al AR1
Cargar directamente el puntero

Es el más rápido si se sabe qué hay que cargar:
LAR1 P#1.0
Lo que cargará en el AR1 el puntero 1.0
Cargar el puntero y transferirlo al AR1

L P#1.0
LAR1
Al igual que el anterior, cargamos el puntero P#1.0 en el AR1
Cargar el valor numérico de bits y transferirlo al AR1

O, como dijimos en direccionamiento indirecto (I), podemos crear al puntero diciendo
cuántos bits tiene la dirección
L8
LAR1
Hará exactamente lo mismo que los casos anteriores. Hay que puntualizar que si
queremos acceder a una dirección que tenga más de 32768 bits (16 bits) la carga
debería ser del estilo:
L L#80000
TAR1
De tal forma que cargaremos la dirección 10000.0
132
Un poco altita la dirección aunque esa sería la forma. A decir verdad, lo suyo es jugar
siempre con números en doble palabra como ya veremos más adelante aunque hacerlo
como enteros también es válido aunque limitado a la capacidad de una palabra frente a
la doble.
Direccionamiento Indirecto por Registro e Intraárea/Interárea
La diferencia fundamental entre el registro e Intraárea y registro e Interárea es:
 Intraárea: No se especifica el área de memoria

 Interárea: Vamos a especificar el área de memoria (el tipo, por así decirlo)
¿Y esto qué significa en cristiano?

Pues a la hora de la verdad, y para nosotros, no mucha cosa. En resumen, y que
permitan los puristas, lo que vamos a hacer es o bien:
LAR1 P#50.0 // Cargar el puntero
L MW [AR1, P#10.0] // Decir el operando (en este caso de carga), el tipo de área
(marcas) y la dirección.
O también podemos hacer:
LAR1 P#M50.0 // Cargar el puntero CON la zona de memoria
L W [AR1, P#10.0] // Decir el operando y la dirección.
¿Resultado?
Pues básicamente el mismo. La diferencia es que en el direccionamiento de tipo
intraárea, el contenido del AR1 va a tener la misma pinta que el direccionamiento por
memoria que veíamos en el capítulo I. No tiene el área de memoria asignado (marcas
en nuestro caso).
¿Qué se usa más?

Personalmente intraárea, pero supongo que es cuestión de gustos. Además
imaginemos que mezclamos las cosas y hacemos lo siguiente:
LAR1 P#E50.0
L MW[AR1,P#10.0]
Como veis hemos indicado el área en la carga del registro AR1 y luego hacemos una
carga de MW… ¿vamos a mandar la CPU a Stop o crearemos un agujero espacio-
tiempo?
Pues no. No sé si lamentablemente, pero no.
Simplemente del AR1 tomaremos la dirección, pero no la zona de memoria y
ejecutaremos el operando de carga MW.
133
Por tanto, y a mi juicio, es mejor siempre usar el intraárea. Me parece más metódico ya
que siempre vas a construir los punteros de la misma forma, independientemente del
uso que le vayas a dar posteriormente.
Muy bien, me parece estupendo… pero me he perdido en el L MW [AR1,

P#10.0]… ¿qué significa?
Muy sencillo. Lo que hay entre corchetes es la dirección inicial más un desplazamiento.
De tal forma que en nuestro ejemplo, realmente estamos leyendo la MW60 (50 del AR1
+10 del offset por así decirlo).
¿Es obligatorio poner ese offset siempre?

Si. Siempre. Sin excepción. Pones un P#0.0 si no lo quieres y listo.
¿Qué pasa si cargo un P#50.0 en el AR1, cargo un offset P#0.1 y hago una
lectura MB, MW o MD?
Pues que estarías provocando un bonito error de runtime. Ya que para hacer una lectura
de byte, Word o doble Word, necesitas que el bit del puntero sea 0 (ojo, el bit, no el
byte). No puedes crear un MW50.1 cómo puedes imaginar. Así que cuidadín con eso.
¿Qué más puedo hacer con los registros?
Como no solamente del AR1 vive el hombre, existe también un segundo registro, el AR2.
Con esta pareja, podemos jugar indistintamente para cargar nuestros punteros e incluso
combinarlos en las operaciones.
Así, para seguir con el ejemplo anterior, podríamos hacer:
LAR1 P#50.0
LAR2 P#10.0
L MW[AR1,AR2] : No se puede usar ambos AR para hacer este tipo de direccionamiento
L MW[AR1,p#0.0]
T MW[AR2,P#10.0]
¿Qué operaciones puedo hacer con los registros?

LARn : Cargar el contenido del ACU1 en el registro ARn, siendo n=1 o 2.
Offtopic: Y no, no es un 102, es un 1 O 2. A la RAE le ha parecido buena idea no tener
que acentuar desde hace un tiempo la O entre números. Qué país.
TARn: Transferir desde el registro n, su contenido al ACU1.
+ARn: Sumar al contenido del ARn, el contenido del ACU1.
Pero como hemos visto, podemos hacer cargas y transferencias directas:
134
LARn <Dirección>: Cargamos la dirección al ARn. Por ejemolo LAR1 P#50.0

TARn <Dirección>: Cargamos el contenido del ARn en la dirección. Por ejemplo TAR1
MD50
+ARn <Puntero>: Añadimos al ARn el puntero que queramos. Por ejemplo, +AR1
P#10.0
Para rizar el rizo, podemos copiar la información entre los AR haciendo:
LAR1 AR2, con lo que cargaremos en el AR1 el contenido del AR2
TAR1 AR2, con lo que recuperamos el contenido del AR1 y se lo cargamos en el AR2.
Como ves las combinaciones son unas cuantas si bien se pueden resumir en asignación
y suma.
¿Y todo esto, ya sirve para algo?
Pues aunque pueda parecer lo contrario, el direccionamiento indirecto sirve para

muchas cosas, pero sobre todo para recorrer información y tratarla.
En el siguiente video os voy a mostrar cómo se usa el direccionamiento indirecto,
especialmente con bucles LOOP (for-next), como ya vimos.
135
36. Comparar dos cadenas de caracteres

En este capítulo vamos a realizar un ejercicio práctico de cómo comparar dos cadenas
de caracteres en Step 7 bien que sean alfanuméricos o dos cadenas cualesquiera de
datos.
Si lo que queremos comparar son dos strings como tal, Step 7 proporciona de origen un
FC con el que poder comparar cadenas de caracteres en forma de string. Se trata del
bloque FC 10 EQ_STRNG que puedes encontrar desde el editor en Librerías-> Standard
Library -> IEC Function Blocks.
Bien. Lo lógico es usar esta función o cualquier otra de las que te ofrece Step 7 si se
ajusta a tus necesidades.
Pero lo que vamos a realizar hoy es poder comparar cualquier cadena de bytes de dos
DB y ver si son iguales o no. Da igual el tipo de datos que tengamos en ese área de
memoria.
Comparar dos cadenas de caracteres en Step 7
La idea es simple: poder comparar dos áreas de memoria consecutiva de dos DB (o del
mismo) y saber si ambas áreas son iguales.
¿Para qué sirve eso?

Pues por ejemplo si tienes una comunicación en la cual envías X bytes a otro PLC,
Scada o lo que sea y quieres saber que realmente lo que envías y lo que el interlocutor
está leyendo es lo mismo por ejemplo para activar una orden de actuación.
Entonces, la forma de operar es que un PLC escribe en un DB digamos DB1 y el
interlocutor copia ese DB a un DB2 que te lo envía de vuelta.
La forma de saber que lo que uno escribe, el otro lo recibe es comparando ambos DB,
cosa que puede ser muy simple si intercambias digamos un DW, pero bastante
engorrosa si estás intercambiando 100 bytes.
¿Qué necesitaremos para comparar las cadenas de caracteres?

Pues vamos a necesitar tener ciertos conocimientos de:
 Punteros y direccionamiento en Step 7

 Hacer un FOR – NEXT en Step 7
 Saltos condicionales
 Un poco de XOR que nos servirá para la comparación
 Usar los acumuladores AR1 y AR2
Como ves, nada que no hayamos visto con anterioridad en el libro.
136
¿Y cómo vamos a hacer la comparación de las cadenas de caracteres en step7?

Básicamente vamos a realizar un FC donde pasaremos como variables de entrada:
 Los números de los DB

 Los números de byte de origen de los datos de ambos DB
 La longitud a comparar en bytes
Por otra parte, y como salida del FC, obtendremos una salida booleana indicativa de si
ambas cadenas son iguales o no.
En cuanto al programa en sí, y como referencia, la idea sería la siguiente:
 Poner una marca booleana a cero indicando inicialmente que ambas cadenas
originalmente son iguales
 Hacer un FOR-NEXT con el número de bytes a comparar
 Crear los punteros correspondientes a cada posición
 Comparar cada byte entre ambos DB haciendo un XOR
 Si el resultado es mayor que cero, hacer un SET de la booleana indicando que
no son iguales
 Si el resultado es cero, no hacemos nada.
 Continuamos con el FOR
 Finalmente igualamos la booleana a la salida del bloque.
Seguidamente te dejo con el código fuente del FC para que le vayas echando un
vistazo:
FUNCTION “Comparador de cadenas” : VOID
TITLE =
VERSION : 0.1
VAR_INPUT
NumDB1 : INT ; //Número del primer DB a comparar
NumDB2 : INT ; //Número del segundo DB a comparar
Byte1 : INT ; //Número del primer byte de la cadena del DB1
Byte2 : INT ; //Número del primer byte de la cadena el DB2
Longitud : INT ; //Longitud de bytes a comparar
END_VAR
VAR_OUTPUT
Resultado : BOOL ; //Resultado final de la comparación.
END_VAR
VAR_TEMP
Comparacion : BOOL ; //Resultado temporal de la comparación
IndiceForNext : INT ;
PunteroOffSet : DWORD ;
DBNum1 : INT ;
DBNum2 : INT ;
ResultadoXOW : INT ;
END_VAR
BEGIN
NETWORK
TITLE =
//Inicializamos la variable Comparacion
SET ;
R #Comparacion;
137
// Transferimos los valores de los DB a las variables.

// Hay que hacerlo así porque no se puede leer directamente como IN
L #NumDB1;
T #DBNum1;
L #NumDB2;
T #DBNum2;
NETWORK
TITLE =
//Hacemos un for-next con el número de bytes de longitud ya que vamos a comparar
//byte a byte.
L #Longitud;
NEXT: T #IndiceForNext;
// Generamos un puntero OffSet
L #IndiceForNext; // Cargamos el indice
ITD ; // Lo pasamos a doble
L P#1.0; // Cargamos un puntero de un byte
*D ; // Multiplicamos en doble para general el puntero origen
T #PunteroOffSet; // Obtenemos el OffSet
// Generamos el puntero del DB1
L #Byte1; // Cargamos el byte de inicio
ITD ; // Pasamos a doble (como los punteros)
*D ; // Multiplicamos en doble para generar el puntero origen
LAR1 ; // Lo cargamos en el AR1
L #PunteroOffSet; //Cargamos el offset de este loop
+AR1 ; // Se lo sumamos al AR1
// Generamos el puntero del DB2
L #Byte2; // Cargamos el byte de inicio
ITD ; // Pasamos a doble (como los punteros)
*D ; // Multiplicamos en doble para generar el puntero origen
LAR2 ; // Lo cargamos en el AR2
L #PunteroOffSet; //Cargamos el offset de este loop
+AR2 ; // Se lo sumamos al AR2
AUF DB [#DBNum1]; // Abrimos el DB1
AUF DI [#DBNum2]; // Abrimos el DB2
L DBB [AR1,P#0.0]; //Cargamos el valor del primer puntero
L DIB [AR2,P#0.0]; //Cargaos el vaor del segundo puntero
XOW ; //Hacemos un XOR de palabra
T #ResultadoXOW;
// Toma de decisión
L #ResultadoXOW; // Si el resultado es cero, no hacemos nada porque de momento
son iguales
L 0; // Comparamos con cero, si son iguales, saltamos sin hacer nada
==I ;
SPB EXIT;
SET ; // Si no son iguales, continuamos y ponemos a uno la variable
S #Comparacion;
138
EXIT: NOP 0;
L #IndiceForNext; // Hacemos el next cargando el valor del indice
LOOP NEXT;
UN #Comparacion; // tomamos el valor de la comparacion y le cambiamos el signo
= #Resultado; // Igualamos a la salida
END_FUNCTION
Todo esto, será llamado desde el OB1:
CALL “Comparador de cadenas”
NumDB1 :=1
NumDB2 :=2
Byte1 :=0
Byte2 :=0
Longitud :=10
Resultado:=M100.0
Bien, no quiero que te agobies porque tengo preparado como siempre el vídeo
explicativo:
139
37. Qué es un OB de fallo
Un OB de fallo es un bloque de función que tiene las siguientes características:
 Puede existir en nuestro proyecto o no. Sólo depende de ti a la hora de

programar el proyecto.
 Son específicos. Cada uno de ellos hace referencia a un fallo en concreto.
 No se ejecutan salvo cuando se da el fallo en cuestión (y exista lógicamente).
 Si no existen en el programa del PLC, este puede irse a STOP en función de la
severidad del fallo.
 No todos los OB de fallo están presentes en todas las CPU (aunque sí la
mayoría).
Vale. Ya ves que son unos bloques un tanto especiales.
Listado de OB de fallo.
 OB 80 – Error de tiempo
 OB 81 – Error de la fuente de alimentación
 OB82 – Alarma de diagnóstico
 Ob83 – Alarma de insercción/extracción
 OB84 – Error de hardware CPU
 OB85 – Error de ejecución de programa.
 OB86 – Fallo de un aparato de ampliación, sistema maestro DP o periferia
descentralizada
 OB87 – Error de comunicación
 OB88 – Ejecución interrumpida
 OB121 – Error de programación
 OB122 – Error de acceso a la periferia
Además de estos OB de fallo existen otros como son el OB70 al 73 que son para CPU
H redundantes.
En las referencias te dejo un PDF con toda la documentación. En él podrás saciar tus
ansias de conocimiento más en profundidad.
Pero este post no va de eso. Quiero que veas para qué sirven en general. Luego tú
serás el que busque el OB adecuado para cada ocasión.
La parte fundamental es que si se produce un error y el PLC hace una llamada al OB
correspondiente, puede suceder:
 Que el error no sea grave y exista el OB o no, la CPU no se vaya a STOP
 Que el error sea grave y el OB no exista con lo cual la CPU se irá a STOP
 Que el error sea grave y el OB sí exista, con lo cual, salvo que tu lo programes,
la CPU no se irá a STOP.
Los OB de fallo típicos son el OB80, el Ob85, el OB86, el OB122… y poco más.
El OB80 es muy típico cuando estás programando en la puesta en marcha. Haces un
bucle que no tiene salida y zas… a STOP. Lógico. Superas el tiempo de watchdog y de
140
ahí que se vaya a STOP. No es bueno que lo cargues ya que si se va a STOP porque
estas programando un bucle que por una mala programación se vuelve infinito, mejor
saberlo ¿no? Porque la que se puede liar es importante.
El OB85 se da en general cuando haces una llamada a un bloque que no existe…
típicamente cargas el FB y se te olvida que este chiquitín lleva consigo un DB.
Más típicos de cargar pueden ser por ejemplo el OB86 y OB122. Imagina que tu red
Profibus está compuesta por varias máquinas, alguna de ellas no es digamos crítica.
Puede que te interese tirar la tensión esa parte de la máquina y apagar la periferia que
tengas ahí. Entonces, tendrás que cargar estos módulos para cuando quieras mantener
esta parte de la instalación, la CPU no se vaya a STOP.
Al contrario, si es peligroso que un esclavo se pueda ir a fallo, es interesante que la CPU
vaya a STOP siempre, con lo cual, no cargarás dichos módulos.
Vamos, que lo de la carga de estos módulos, ni sí ni no, ni todo lo contrario: depende
de la aplicación.
Para que la CPU no se vaya a STOP, simplemente tiene que existir el OB. Por ejemplo
digamos el OB122. Dentro de ese OB122 no tienes porqué programar absolutamente
nada salvo que lo desees. La simple existencia de dicho OB hará que la CPU no se vaya
a STOP por el motivo por el que fue llamado este módulo.
Además, cada bloque tiene asociado una serie de variables que te van a servir para
identificar el problema y así vas a poder tomar decisiones, como llevar a STOP el PLC
o no.
Para finalizar te ofrezco un nuevo video explicando un poco su uso y alguna cosilla
interesante.
141
38. Alarmas: Cómo activar y desactivar la baliza
En este capítulo vamos a tratar una cosa fundamental en nuestros proyectos: la gestión
de alarmas en S7.
Antes o después, nuestra automatización va a tener algún tipo de problema, por
ejemplo, de mal funcionamiento. Esto en principio no es un problema ya que por lo
general vamos a tener una pantalla asociada donde vamos a poder mostrar en cada
caso qué alarma es la que ha saltado y si fuera necesario su tratamiento o puntos a
comprobar para poder resolverla.
Por otro lado, además de la indicación en la pantalla de la
alarma, hay que llamar la atención del operario para
indicarle que algo no va como debiera. Así, tendremos
casi siempre:
 Una bonita baliza luminosa

 Una sirena que deje medio sordo a los que estén
alrededor.
La primera no suele molestar mucho. A mí el rojo me

gusta a pesar de no ser mi color favorito… pero que una
sirena me esté taladrando el oído cuando ya me he
enterado de que la alarma está activa y que además el
problema no es resoluble a corto plazo, me hace estar un
tanto inquieto.
Por tanto, lo que vamos a ver a continuación es:
 Activar la baliza roja de forma parpadeante cuando surja una nueva alarma.
 Que la alarma se quede fija una vez que la alarma haya sido reconocida.
 Cómo activar la sirena cuando surja una nueva alarma aunque haya sido
reconocida previamente.
 Cómo parar la sirena cuando se reconozca la alarma.
 Cómo resetear todas las alarmas (si se puede porque las causas hayan
desaparecido)
 Cómo lanzar de nuevo la sirena en caso de transcurrido un tiempo, las alarmas
no han desaparecido (si fuera necesario)
Gestión de alarmas en S7
Como veis no es nada que sea extraño. La idea es que suene la sirena y la podamos
apagar. Esto en sí mismo es fácilmente resoluble.
El problema puede surgir si salta una nueva alarma, que también queremos que la
sirena suene de nuevo o para determinadas alarmas, aunque hayan sido acusadas,
suenen de nuevo al de dos horas por ejemplo recordando que el problema no se ha
solventado.
142
¿Cómo hacerlo?
Pues los ingredientes que vamos a usar son los siguientes:
 Un FC donde realizar la gestión de las alarmas con sus variables de entrada y

salida
 Un FC donde programar las alarmas
 Un DB donde almacenar el estado de las alarmas y su significado
 Unas pocas marcas y salidas
El FC
Vamos a usar un FC reutilizable para todos nuestros proyectos. O casi todos. Algo que
podamos usar más adelante, en otra automatización. Esto nos va a obligar a que todos
los datos que usemos hayan sido introducidos como entrada y los generados los
saquemos como salidas.
Las tareas que vamos a realizar en este FC van a ser:

 Comprobar cuántas alarmas activas hay
 Comprobar si hay más alarmas activas que en el ciclo anterior. Si las hay, activar
una salida que indique que hay una nueva alarma.
 Comprobar si han sido acusadas las alarmas. Si lo han sido, tirar la señal de nueva
alarma.
 Resetear las alarmas si tenemos una entrada que así lo indique.
 Dar intermitencia o no a una salida que indique si de las alarmas activas existentes
hay nuevas o están todas acusadas.
 Tener una entrada que nos rearranque la bocina y la baliza si hemos programado
que al de un tiemp0 del apagado de la bocina, la causa que generó la alarma no ha
desaparecido.
En un segundo FC programaremos nuestras alarmas. A decir verdad podemos

concentrar la programación de todas las alarmas en un único FC o bien en cada parte
o bloque donde se estén generando las acciones de nuestra automatización, generar
ahí la alarma pertinente. It’s up to you.
El DB
El DB no va a ser más que un listado de booleanas donde activaremos nuestras alarmas.
¿Por qué eliges un DB en vez de hacerlo con marcas?
Pues por costumbre, lo primero. Y lo segundo, y más importante por practicidad.
 Puedo ver en un sólo sitio dentro de S7 las alarmas de las que dispongo y cuáles
estoy usando.
 Sé cuáles uso porque comento qué hace cada alarma
 No corro riesgo de machacar una dirección.
 Puedo dejar espacios grandes sin usar sin miedo que en un futuro use una
dirección intermedia para una cosa que no sea una alarma.
143
Es cierto que todo lo dicho es más o menos aplicable a las marcas, pero a mi juicio es
más efectivo y sostenible con los DB.
Y poco más. Casi que lo mejor es que veas el vídeo que te he preparado con una
simulación de cómo funcionaría y una explicación del programa. Son 16 minutos de
nada... ejem (cada día me enrollo más).
144
39. Buenas prácticas de programación en S7
Siempre que comenzamos a programar, tenemos la incertidumbre de si la forma en la

que trabajamos es la más adecuada o no. En la entrada que recupero del ostracismo (y
que añado alguna cosa nueva) te voy a contar unas pequeñas pautas que puedes
seguir, aunque estas buenas prácticas de programación en S7 no son palabra de Dios,
y por supuesto, pueden ser discutibles y/o matizables.
Son unas recomendaciones que te doy, y puede que a lo mejor te encajen en tu forma
de estructurar un proyecto o al menos que te sirva para reflexionar sobre cómo has de
afrontar los primeros proyectos que desarrolles.
Tengo una hoja en blanco ¿Por dónde empiezo para realizar buenas
prácticas de programación en S7?
Lo primero que tienes que hacer cuando comienzas un proyecto es respirar hondo y no
agobiarte. Te puede pasar que si miras el proyecto en su conjunto pueda ser un tanto
mareante al principio… y lo es. Supongo que todos hemos pasado por ello.
Lo bueno que tiene la automatización seguramente junto con otro tipo de programas y
software es que es muy modulable ya que la instalación está siempre dividida en
máquinas, y estas a su vez en sub-máquinas y estas finalmente en un conjunto de
señales y actuadores. Por tanto, podemos abstraernos a la hora de programar del resto
de la máquina y centrarnos en muchos casos solamente en una pequeña parte de la
máquina.
Pero ojo, no estoy diciendo que comiences a programar con una pequeña porción de la
máquina sin pensar en el resto. Estoy diciendo que el problema global que es que la
dichosa instalación funcione, la vas a poder cortar en cachitos y que cada cachito por
separado no es tan fiero.
Por tanto lo primero que tienes que pensar es en qué máquinas se divide tu instalación
y cómo interactúan entre ellas. Lo que deberías hacer en un primer estadio del proyecto
es:
 Comprender muy bien la instalación. Qué debe hacer (y qué no).

 Hacer un listado con las posibles divisiones de la instalación o máquina, como
máquinas (o submáquinas) independientes.
 De cada máquina y submáquina qué detectores vas a necesitar y qué
actuadores.
Una vez comprendas que es lo que debe hacer, podrás dividir la instalación (o máquina)
en trozos más pequeños e independientes. Esto nos va a ser útil a la hora de definir los
bloques en los que se va a dividir nuestro proyecto.
Por otro lado, la enumeración parcial de cada señal y cada actuador, nos va a dar una
idea global del volumen de entradas y salidas del proyecto. Esto te va a ayudar a su vez
a valorar entre otras cosas si merece la pena centralizar todo en el armario eléctrico, o
si va a ser mejor colocar por la instalación diferentes armarios remotos, por ejemplo.
145
Vale, ya tengo más o menos claro qué hace y qué necesito… ¿y

ahora?
Ya tienes el qué, vayamos ahora en el cómo:
 Estructura tus bloques

 Asigna rangos de I/O
 Da nombres a las cosas
 Un buen listado de alarmas
 Bocetos de las pantallas del HMI
Cuando digo que estructures los bloques quiero decir que des rangos a tus FC, FB y
DB. Imagínate que tienes 3 zonas bien diferenciadas de la máquina, pues una forma de
estructurar tus bloques podría ser:
 Del 0 al 99 para bloques genéricos

 Del 100 al 199 a la zona 1
Así, por poner un ejemplo: imagina que dentro de las zona 1 tienes un transportador.
Pues puedes hacer:
 FC110 “Transportador 1” para la lógica booleana que maneje todo lo que haya
sobre ese transportador, sus marchas y paros, manual, automático etc.
 FB110 “Motor Transportador 1″ Para el manejo del variador de dicho
transportador, la gestión de las consignas que puede que le mandes por profibus,
alarmas etc.
 DB110 “DB Motor Transportador 1″, pues como DB de instancia del FB110
Esto como digo es un ejemplo. La idea que quiero que pienses es que todo lo referente
al transportador 1, estará asociado con el concepto numérico “110” como cosa global.
Si tienes un segundo transportador, dentro de la zona 1, pues le asignas el 120.
¿Por qué no el 111?

Dependerá de cada proyecto, pero siempre que puedas, y para mi gusto, separa los
bloques. Imagina que encima del transportador 1 tienes un par actuadores neumático
que hacen algo, lo que sea. Yo le daría en ese caso:
 FC 111 “Actuador #1 Transp. 1″

 FC 112 “Actuador #2 Transp. 1″
Todo esto suponiendo que tengan suficiente entidad como para que tengan su propio
FC y no puedan ser agrupados en un único FC 111 “Actuadores Trans. 1″. Espero que
cojas el concepto.
¿Qué nos va a permitir esto?

Pues básicamente, un poco de orden. Porque como te acostumbres a poner todos los
bloques seguidos, va a ser un caos. Por el simple hecho es que la vida del proyecto es
larga, y seguro que vas a tener que insertar nuevos actuadores sobre partes de las
máquinas.
146
Como hayas puesto:
 FC 110 Transportador 1
Ahora imagina que los actuadores de los que hablamos, no estaban contemplados en
el proyecto inicialmente, y ahora hay que añadirlos… tú lo has dicho, vaya mierd..
Además de eso, en nuestro ejemplo, puede que unos transportadores lleven unos
actuadores tipo A, otros transportadores no lleven, otros sean tipo B... etc.
En cambio, si divides a espaciado fijo, sabes que todo lo que hay en los FC 11x
pertenecen a la misma parte de la máquina, el transportador 1 en nuestro caso. Creo
que la idea queda suficientemente clara.
Asigna rangos a las I/O
Al igual que has hecho con los bloques, la idea sería la misma para las entradas y
salidas. Intenta dar rangos a las zonas de las máquinas. De tal forma y siguiendo con
nuestro ejemplo, imagina que has decidido poner 3 remotas, una por cada zona de tu
instalación.
Asigna rangos a las I/O:
 EB100 – EB199 para la zona 1

 EB200 -EB299 para la zona 2
 EB300 – EB399 para la zona 3
¿Qué ganamos con ello?

Como antes, claridad y orden. Pero algo más… orden de cara a futuro.
Si vas a montar 3 periferias remotas y asignas las direcciones de I/O según te las asigna
Step7 de forma automática, vas a tener todas las entradas y salidas seguidas como un
paso doble Hasta ahí no habría mucho problema más allá de que como digo, queda
más limpio saber que si te digo E 212.0 automáticamente sabes que te estoy hablando
de una entrada de la zona 2 sin mirar absolutamente nada.
Pero no solamente eso. En un futuro, puede que tengas que ampliar una de las periferias
con una nueva tarjeta… pues como no hayas pensado en espaciarlas, no solamente no
tendrás coherencia entre la numeración entre zonas, sino que dentro del mismo rack
tendrás numeraciones altas y bajas ya que al añadir una nueva tarjeta, tendrás
forzosamente que asignar un número más alto que el último que Step7 le asignó a la
zona 3… que si es esta zona, no pasa nada, pero si es la zona 1 queda horrible.
147
¿Pero habría algún problema por ello?

Ninguno, pero hombre, ya que estamos, además de que funcione, que parezca que le
hemos dedicado 10 minutos a pensar cómo asignar las entradas y salidas ¿no?
¿Qué pasa con las marcas, temporizadores etc.?

Análogamente, asigna rangos para el resto de elementos. Por ejemplo: Si estas en el
transportador 1, que es el FC 110, pues asigna las marcas 110.0 – 119.7 para dicho
transportador, si con ello te va a ser suficiente.
Puedes dar un rango de marcas para las palabras, otro para las dobles palabras… etc.
Dale al coco y haz tu propio esquema.
Asigna nombres a las cosas
Y donde digo cosas, me refiero a FC, FB, DB, Entradas, salidas, marcas,
temporizadores…
Si no pones nombre a las marcas e I/O va a ser muy complicado el mantener el
programa, por no decir imposible. Es una locura encontrarte programas que no están
comentados… pero nada comentados. Es para echarse a llorar cuando el programa es
complejo. No hay forma de seguirlo muchas veces con comentarios, como para seguirlo
sin una triste indicación de qué hace qué.
Lleva mucho tiempo, y no siempre es fácil mantener la tensión de comentar todo, pero
hay que intentar que todo esté razonablemente comentado.
Una forma que yo suelo usar (y aquí cada maestrillo tiene su librillo) es la siguiente:
 Para las entradas y salidas, como nombre simbólico suelo poner el nombre del
elemento de campo que es, por ejemplo el “25B3″ y como comentario qué es
con palabras. Puedes poner el IME completo por ejemplo “+ZonaA-
25B3″ mientras que te entre en el campo de descripción de la variable.
 Las marcas/temporizadores etc. auxiliares las marco con su propia dirección
“M17.5″ y en la descripción pongo “auxiliar”. Así indico que la marca es
necesaria como un auxiliar pero que no sale de ese bloque y que no está usada
de forma global en el programa.
Buenas prácticas de programación en S7
Ya hemos visto las cosas que tenemos que tener en cuenta a la hora de organizar el
programa, pero aún no hemos programado ni un segmento. Ahora van las propiamente
dichas de qué hábitos debes adquirir.
Apunta esta, grábala en letras de oro o haz lo que estimes oportuno pero:
Sólo da valor a una variable/salida en un sitio
148
Hacer un =A1.0 en dos sitios diferentes del programa es de cárcel. Jamás lo hagas. Si
tienes que declarar 8 marcas y hacer la lógica que sea, la haces, pero nunca, nunca,
nunca, nunca, nunca, asignes dos veces una salida. Y quien dice una salida, dice una
marca. ¿Por qué?
Porque siempre tomará el valor de la última vez que le diste valor. Si cambias el orden
de ejecución, cambiará la forma de ejecutarse.
Imagina que has puesto en una parte del programa (FC1) un
U M0.0
S A1.0
Y en otro bloque (FC2)
U M1.0
S A 1.0
Y en otro, pues un reset (FC3)
U M2.0
R A1.0
Vale. ¿Cuánto valdrá A 1.0? Pues más menos npi. Dependerá de cómo estén las
marcas que los hacen un Set o Reset y en qué orden han sido llamados los bloques…
y eso, siempre y cuando dentro de un año, no se te ocurra que en el bloque FC2, en vez
de un set, es mejor un
U M1.0
= A1.o
Que entonces la fiesta ya es completa.
Si hay varias condiciones que activan y desactivan la A1.0, las asignas una marca, y
luego agrupas todas para hacer un set, y por otro lado las que tenga que hacer un reset,
o un igual o lo que haya que hacer… pero UNA ÚNICA ASIGNACIÓN ¿Está claro?
Repite conmigo:
Sólo asignaré una salida en un sitio
Asigna una marca de ciclo al principio del proyecto
Como ya hemos visto es bastante práctico seleccionar la marca de ciclo al principio del
proyecto de cara a que si en la puesta en marcha, o con la máquina ya funcionando te
hace falta un tren de pulsos, dispongas de una forma sencilla de estos, sin tener que
volver a compilar el proyecto y mandárselo al PLC pasando la CPU a stop, cosa que
siempre no es posible en el momento que lo quieres hacer.
149
Crear un Always_On y un Always_Off

Esto más que una buena práctica, es un truquillo: si tienes una marca que esté siempre
a cero y otra que esté siempre a uno, te ayudará a la hora de hacer pruebas, y desarrollar
el programa en la línea ya que podrás hacer un bypass fácilmente a alguna condición,
evitar que un segmento no se ejecute etc.
También puedes coger el byte entero lleno de ceros, que te servirá para borrar datos
usando el Sfc21 FILL. Para ello, simplemente tendrás que hacer un
L0
T Mb0
O M1.0
ON M1.0
= M1.0
De tal forma que el byte 0 contendrás siempre ceros y el bit 1.0 estará siempre a 1.
Tonto, pero útil.
Deja espacio, sé generoso con el que venga detrás…

Que muy probablemente puedas ser tú. Si vas a crear un DB donde almacenar datos
para registro o intercambio con otros PLC por ejemplo, deja espacio libre para que en
una eventual ampliación no haya que replantear nada ni hacer grandes modificaciones,
sino que con tomar parte del espacio que este libre, sea suficiente.
Lo mismo digo a la hora de asignar las entradas y las salidas, deja espacio para posibles
nuevos actuadores o señales, de tal forma que una futura ampliación no provoque la
ampliación de un bastidor porque en su día las entradas estaban usadas. Todo cuesta
dinero, pero es necesario hacer ese esfuerzo porque a la larga, es más barato si luego
no hay que echar nuevas mangueras, instalar más tarjetas etc.
No seas un talibán de ningún lenguaje. Usa todos a tu antojo, pero con orden.
Una de las entradas que más consultas recibe el blog es la de qué lenguaje elegir a la
a hora de programar en Step 7.
Lo que no saben, es que no hay respuesta absoluta para esa pregunta… pues depende.
Acostúmbrate a usar todos los que quieras, cuando quieras. Personalmente no
mezclaría en un bloque FUP con KOP, aunque sí cualquiera de ellos con AWL. No los
mezclaría porque muchas veces no son traducibles entre sí, y al pasar de uno al otro,
puede que el que dejas no sea traducible y se quede en un AWL difícil de digerir así de
repente, obligándote a pasar de uno al otro para seguir fácilmente el programa.
Pero por lo demás, cambia cuando quieras, prueba y disfruta de la variedad que ofrece
Siemens en ese sentido.
150
Alarmas
Una de las cosas más importantes en una buena automatización es la colección de
alarmas. Puede parecer trivial, pero para nada lo es. Crear un listado de alarmas
relevantes, que aporten fácilmente qué es lo que está fallando y sobre todo no dejarte
nada en el tintero, es casi imposible.
Pero puedes seguir una serie de pautas:
 Puedes usar marcas o un DB sólo para alarmas. A mi juicio mejor usar un DB
con BOOL ya que las verás todas juntas además de poder comentar cada una
dando mayor información a simple vista.
 Enumerar los pasos automáticos y coloca timeouts con los que saber en qué
paso se ha parado la línea.
 Lista los finales de carrera de seguridad, presostatos, temperaturas etc. y decide
qué valores son extremos para que salte una alarma.
 Establece dos grupos: los que pararán la máquina (si las hay) y las que
simplemente serán indicativas de un malfuncionamiento. Reserva memoria en el
DB para ambos grupos de cara a su ampliación.
 Piensa cada texto que va a acompañar a cada alarma. Intenta pensar que
cuando salte, lo va a leer alguien que no tiene ni idea de cómo está programado
el PLC. Sé todo lo user friendly que puedas.
Pantallas del HMI

Decía Albert Einstein algo así como “si no puedo dibujarlo, es que no lo entiendo”. Además
de una cita genial, me da pie a comentarte una cosa fundamental y que por ello lo he
dejado para el final.
A ver si me queda lo más claro posible:
 No programas para ti
 Las normas son para cumplirlas
 Intenta tener un poco de gusto
 ¡No programas para ti!
No. No es un error. He puesto que ¡No programas para ti! dos veces. Con esta tres.
¿Qué quiero decir con esto?

Pues eso, que el tipo que va a usar tu máquina probablemente no haya visto un
programa en su vida (más que probable) y sinceramente, ni es relevante, ni le importa.
Lo importante es lo que puede ver y hacer desde la pantalla.
 Mandos claros
 Información clara y completa, pero no excesiva
 Fácil de entender la navegación entre pantallas.
 Estéticamente agradable a la vista (dentro de lo que se pueda)
Piensa que la persona que va a manejar la máquina, en general un operario de
producción, no le importa ni cuantos motores tiene tu máquina, ni detectores, ni las
filigranas que hayas hecho en el código. Hablando groseramente… se la pela.
151
Lo que le importa, sin duda, es lo que puede hacer desde su pantalla, desde sus mandos
y qué información devuelve para que él esté informado.
Por eso es importante que los mandos sean claros, que no haya que leerse mil páginas
de manual para entender cómo funciona la máquina y que sea lo más intuitiva posible.
La navegación entre páginas ha de ser lo más coherente posible: los botones y el
comportamiento de estos sean previsibles. Es decir, que si los botones de las páginas
están abajo, estén siempre abajo, del mismo tamaño, si son con dibujos sean todos
coherentes etc.
Por otra parte, las normas especialmente a los colores y modos de trabajo, han de
cumplirse. Es pecado capital poner un botón verde como reset o rojo como cycle start.
Finalmente, un cojo-programa con unas pantallas poco cuidadas parecerá que está
cogido con pinzas. Ten un poco de gusto, que tampoco cuesta tanto.
152
40. 4 formas de hacer una copia de seguridad de un

proyecto de step7
Realizar una copia de seguridad de un proyecto de step7 es una tarea común y simple.
Pero parece que hay ciertas dudas al respecto.
En un principio no hubiera hecho esta entrada ya que pensaba que todo el mundo sabe
cómo salvaguardar el proyecto que tenemos entre manos… pues parece que no
siempre es así, o hay al menos, ciertas dudas.
Vamos por tanto a disipar dichas dudas, o al menos intentarlo viendo cómo hacer copias
de nuestros proyectos, dos offline y 2 online.
Copia de seguridad de un proyecto de step7 offline
La primera es la más sencilla y la que estoy seguro que el 99,99% de la gente sabe
(vamos a dejar un ínfimo porcentaje de gente realmente despistada)… que cómo no, es
copiar a pelo el directorio del proyecto.
¿Con eso es suficiente?

Sí. Si haces una copia del directorio del proyecto (con el proyecto cerrado
completamente por si las moscas), y lo pegas en otro sitio, tienes una copia offline de tu
proyecto.
Fin.
Bien vale. Te habrás escocido con esto. ¿Alguna forma más?
Ummm sí. Hay una segunda forma, más políticamente correcta.
Crear una copia de seguridad de un proyecto de step7 mediante

archivado.
Esta vamos a decir, que baja el porcentaje al 99%.

La forma correcta a la par que elegante de hacer una copia de seguridad de tu proyecto
que tienes entre manos, es archivando el proyecto.
La forma es muy sencilla. Cerramos por seguridad todos los proyectos abiertos, y
desde Archivo->Archivar.
Ahí elegimos el proyecto a archivar. Luego nos preguntará si queremos dividir en trozos.
Hoy en día no tiene mucho sentido por lo que decimos que no.
Y ya está. Nos generará un archivo ZIP con nuestro proyecto.
153
Crear una copia de seguridad de un proyecto de step7 online exacta.
Una vez conectado al PLC, puedo crear un nuevo proyecto y borro el contenido que
viene por defecto (generalmente la red MPI).
Entonces, ahora Sistema destino ->Copiar en PG.
Esto nos hará una copia idéntica del contenido actual del PLC, tanto de bloques como
de la configuración de HW.
Ahora bien, estamos perdiendo:
 Los comentarios de los segmentos.

 Nombres simbólicos de marcas y FC,FB etc.
 Nombres simbólicos de las variables del DB.
Pero por otro lado, tenemos una copia exacta incluyendo los valores actuales de los DB
(no de las marcas lógicamente).
Crear una copia de seguridad de un proyecto de step7 online por

carpetas
La última forma de hacer una copia de lo que tenemos online, es crear desde la raíz del
proyecto un nuevo programa Step7. (Botón derecho, Insertar nuevo objeto->Programa
S7
Luego, nos ponemos online, y copiamos todos los bloques y los pegamos dentro de esa
carpeta que hemos creado nueva. Tendremos que machacar el OB1 ya que lo incluye
por defecto.
Adicionalmente, copiaremos el archivo de símbolos y lo pegaremos en la nueva carpeta
machacando el existente.
De esta forma tenemos el contenido del PLC con el máximo información.
154
Pues estas son las formas que yo sé. Como siempre os dejo con un video donde lo
podéis ver de una forma más gráfica.
155
41. Cómo proteger bloques en Step 7… si puedes.
Para terminar el libro quiero contarte cómo hacer para proteger bloques en Step 7. Como
ves en el título he añadido la coletilla, si puedes. ¿Por qué digo esto? Porque te voy a
enseñar cómo proteger tus bloques y también te voy a enseñar cómo esta protección la
revienta un niño de seis años con conocimientos medios de informática.
No te voy a enseñar a usar cualquiera
de los programas que pululan por la red
para desproteger los bloques. Vas a ver
cómo con un programa de bases de
datos (típicamente Access) puedes
hacerlo en un minuto.
Con ello no estoy alentado a la
piratería, simplemente te enseño lo
estúpido que es pensar que por
proteger los bloques estos son
invulnerables.
¿Proteger bloques en Step 7?

¿Para qué?
Una de las cosas como cliente y sufridor de las máquinas que no llego a comprender en
general es la actitud y empeño de ciertas empresas en proteger los bloques.
Ya sé que puede que me vaya a meter en un jardín, pero no me importa compartir mi
punto de vista contigo. Si no compartes mi visión lo respeto, pero esta es la mía, al
menos a día de hoy.
Por lo general las empresas que compran la maquinaria son clientes finales cuyo
mercado dista bastante del fabricar y comercializar máquinas como las compradas. Por
otro lado, y a poco grande que sea la empresa, serán sus técnicos cualificados quienes
mantendrán las máquinas y tendrán que pelearse con el programa en caso de fallo o
mal funcionamiento.
Proteger los bloques implica que quieres ocultar el funcionamiento de la máquina ¿en
serio? ¿En serio crees que habiendo comprado la máquina, el problema de replicarla va
a ser el no tener el código del PLC?
 Tengo la máquina funcionando la cual puedo observar cada detalle y

desguazarla si quiero
 Veo cada paso que da, cómo funciona y lo que hace.
 Tengo los esquemas eléctricos
¿Crees que con ello si una empresa quiere replicarte la máquina el problema es que no
tiene el código fuente?
156
A mi modo de ver, el único problema es tener la gente cualificada que pueda programar
una máquina similar. Por tanto:
 Si la tienes, sólo necesita saber cómo funciona para replicar el comportamiento

 Si no la tienes, por mucho que tengas el código fuente es como si me das un
manual en marciano.
Bajo mi punto de vista a ti como creador de nuevas máquinas no te van a contratar por
tus conocimientos en sector X. Te van a contratar y comprar tus máquinas por los
conocimientos, tu buen hacer y tu tiempo.
Imagina que tu cliente tiene una fábrica de cementos. ¿Crees que le vas a enseñar algo
en ese sector tanto en su proceso como en cómo deben ser sus máquinas que él te está
pidiendo? Si él no las construye es porque o no tiene la gente capacitada para ello o no
disponen del tiempo para hacerlo. En ninguno de los casos es un enemigo para tus
intereses, y el compartir tu programa de tu máquina no hará más que mejorar las
relaciones, no empeorarlas con discusiones absurdas que no van a ninguna parte.
Como puedes imaginar como cliente y mantenedor quiero la disponibilidad de las
fuentes para conocer mi máquina y poder solucionar los problemas que seguramente
tiene. Aún no he conocido ninguna máquina que no se pare y que al pararse siempre
sepas qué le pasa y todo esté bien documentado y con las alarmas pertinentes. A veces,
hay que conectarse y ver qué le pasa y porqué hace o no hace tal o cual cosa. Eso no
significa ni que esté mal programada ni que no esté bien documentada, pero es que
todas las causas por las que se puede parar una máquina compleja es difícil de prever
y por tanto es necesario conectarte y ver que diantre sucede.
Y por último, como puedes imaginar, si estuviera de acuerdo con proteger a toda costa
e know how, no estarías leyendo este blog, porque simplemente no existiría y feliz de
mi, pensaría que por no compartir mis conocimientos, el resto de la Humanidad es tonta
de baba y el más listo soy yo…
En fin, que como digo no hace falta que estés de acuerdo conmigo, sólo quiero que
veas, que en el caso de Siemens, cómo hacerlo sirve más bien para bien poco.
Te dejo con el vídeo.
157
42. Conectar un LOGO 8 con un PLC en Step 7
Vamos a conectar un logo 8 con un PLC en step 7.
Para ello, vamos a usar:
 Un Logo 8. Se trata del modelo LOGO 8 230 RCE (6ED1052-1FB00-0BA8)

 Un PLC 315-2 PN/DP (6ES7315-2EH14-0AB0)
 Logosoft V8
 Step 7.
La idea es simplemente enseñarte que puedes usar un LOGO como remota de un PLC
y mandar o recibir instrucciones a un PLC o desde este de una forma sencilla.
¿Por qué usar un LOGO 8 como remota?
Pues porque puede ser una solución enormemente económica en un entorno industrial
(o no) si quieres controlar actuadores o señales analógicas y los quieres manejar desde
un PLC. Piensa que el logo que te propongo puede conectase directamente a la red
eléctrica y su precio es inferior a 150 euros.
Conectar un logo 8 con un PLC en Step 7
La conexión va a ser sencilla. Vamos a crean un enlace S7 en la configuración de redes

de la CPU 315 y por otro lado vamos a configurar la conexión en el logo para establecer
esta misma conexión.
Además, en el lado del logo vamos a definir las variables que queremos intercambiar ya
que la conexión va a ser de tipo cliente. Es decir, será el logo el que establezca la
conexión con el PLC (servidor) independientemente de que el logo envíe o reciba datos
por parte de este.
158
El vídeo de la lección
Había pensado en meterte aquí un tostón de fotos y de texto para explicarte la conexión,
pero como en muchos otros casos anteriores, la mejor forma de enseñarte cómo
conectar un logo 8 con un PLC en Step 7 va a ser a través de un video del canal de
youtube.
159
43. PID en Step7: Ejemplo de control de temperatura
Una de las aplicaciones típicas es hacer un control PID en Step7. Para ello en este
capítulo vamos a ver qué elementos hardware vamos a necesitar, y qué bloques de S7
tenemos para dar forma a la solución del problema.
Pero primero planteemos el problema:

Queremos controlar la temperatura de una plancha la cual tiene para su calentamiento
una resistencia y para su control una Pt100.
La aplicación como ves es muy sencilla. Simplemente quiero controlar la temperatura
de una placa que vamos a tener a XºC, por ejemplo a 85ºC. Para ello, vamos a hacer lo
siguiente:
Leer la temperatura de la placa
Realizar la regulación PID y que me dé como salida un porcentaje entre 0 y 100% de
potencia de la resistencia.
Transformar ese porcentaje en un tiempo ON/OFF de la resistencia
¿Qué hardware vamos a necesitar?
Para realizar esta sencilla aplicación vamos a tener que usar una tarjeta de entradas
analógicas de tal forma que podamos leer. Yo he elegido una para la serie 300 que es
con lo que vamos a hacer nuestro ejemplo (6ES7 331-7KF02-2AB0)
Además, vamos a necesitar una salida digital que active nuestro contactor estático con
el que activar y desactivar la resistencia.
¿Por qué un relé estático?
Por una sencilla razón… vamos a hacer miles de maniobras al día. Además, vamos a
hacerlo de tal forma que el periodo sea 1 segundo, de tal forma que el 100% esté
siempre encendida, 50% medio segundo ON medio OFF y 0% pues apagada
lógicamente. Estos requerimientos no hay relé mecánico que lo aguante sin pedir la baja
voluntaria el primer día.
160
La tarjeta de analógicas
Hay diferentes tipos de tarjeta de entradas analógicas. En nuestro caso, vamos a elegir
el modelo citado anteriormente por tener configurada la opción de elegir que la lectura
va a ser una lectura de una Pt100 de 4 hilos. Tan sólo deberemos seleccionar lo que
queremos en nuestro administrador de hardware que en el canal 1 vamos a usar como
tipo en nuestro caso RTD-4H y como margen una Pt100 estándar.
Finalmente no nos tenemos que olvidar de que en la parte trasera de la tarjeta tenemos
que configurar el adaptador en la posición A.
¿Y qué hay del software?
PID en Step7
En cuanto al programa, la verdad es que no tienen mayor historia. La idea como te he

comentado es transformar la lectura de la temperatura en una salida digital que irá
encendiendo y apagando la resistencias. Le meteremos impulsos más o menos largos
en función de cómo de lejos estemos del Set Point elegido.
Pero no nos tenemos que preocupar, porque del porcentaje de encendido/apagado se
encargará el PID.
Claro que un PID hay que configurarlo y es necesario dar la ganancia y las constantes
derivativas e integral. Esto corre de vuestra cuenta averiguar qué constantes os van bien
ya que la configuración del PID es harina de otro costal y no voy a entrar a ello.
Lo que si te quiero comentar es que existe la herramienta de parametrización que
puedes encontrar en: Inicio > Simatic > STEP 7 > Parametrizar Regulación PID.
Como te decía, el cálculo del PID lo va a hacer el PLC ya que tenemos el bloque SFB
41/FB 41 “CONT_C” con el que podremos calcular la salida porcentual del
encendido/apagado de la resistencia.
Para echarlo a andar necesitaremos:
 El valor del Set-point de temperatura en real

 El valor de la temperatura leída en real
 Las constantes de ganancia, derivativa e integral
 Los márgenes de salida, que en nuestro caso serán de 0% a 100%
 Una variable de salida en real que nos dará el porcentaje de la salida.
Una vez que tengamos cuánto tiene que estar encendida/apagada la resistencia, vamos
a tener que transformar ese porcentaje en una salida digital de 0 ó 1.
Imaginemos que el porcentaje de salida es un 68%. Eso significa y dado que el ciclo lo
vamos a fijar en 1 segundo, que 68 centésimas de segundo estará a TRUE la salida, y
32 estará apagada.
Esto suscita la siguiente pregunta
161
¿Cómo vamos a hacer ese reparto de tiempos?
Fácil. Vamos a crear un índice que se mueva entre 1 y 100. Entonces comparamos la
salida de potencia con este índice, y mientras que la potencia sea igual o superior,
ponemos la salida a 1.
En fin, que para una mejor comprensión, te dejo con un video como siempre.
Referencias:
 Proporcional integral derivativo

 PID Theory Explained
 Practical Process Control
 Regulación PID qué es y como se ajusta
 PDF de cómo ajustar el PID: EnergéticaXXI_Octubre_2005
162
44. Configuración de un variador Micromaster 420
Una de las cosas que no suele faltar en una automatización suele ser un variador. Unas
veces cableado, otras veces, como en el ejemplo de hoy conectado vía Profibus.
Para poner un variador de este tipo conectado por

Profibus se va a necesitar el siguiente hardware:
Un variador Micromaster 420 (410, 430 o 440 también
nos vale)
Una tarjeta de red Profibus para estos variadores.
Una BOP al menos básica (Basic Operator Panel)
Por otra parte, vamos a necesitar al menos el GSD en
la parte del software para poderlo configurar. Si no lo
tienes, lo puedes bajar de la página de Siemens,
aunque debe venir un CD con el variador con toda la
documentación y el software Starter con el que poder configurar el variador, lecturas etc.
Pero obviando este software, vamos a configurarlo simplemente con nuestro GSD y una
pequeña configuración del propio aparato, ya que poner el aparato en marcha no va a
ser tan inmediato como conectar el variador en red y ya, sino que vas a tener que
configurar el aparato al ponerlo en servicio y decirle que lo vas a conectar por Profibus.
Pero no te preocupes. Estás de suerte, te voy a contar cómo ;)
Configuración básica de un variador Micromaster – El variador
Configuración de la dirección Profibus

Lo primero que tenemos que hacer es
montar todas las partes, el convertidor
propiamente, la tarjeta Profibus y el display
(BOP). Después de montar la tarjeta
Profibus, lo mejor es darle la dirección
Profibus usando los DIP de la imagen (las
pestañitas naranjas)
Digo esto, porque a pesar de que se puede
configurar la dirección Profibus a través de
los menús (parámetro P0918), a mi juicio es
mejor ya que te despreocupas de la
configuración en este aspecto. Siempre
tendrá la dirección DP asignada aunque cambies el convertidor.
Hay que tener en cuenta la advertencia del manual:
La modificación de los interruptores DIP se debe realizar con el
convertidor desconectado (sin tensión) (en un módulo de comunicación ya montado).
163
La modificación de los interruptores DIP sólo es efectiva tras arrancar de nuevo

el módulo PROFIBUS. Este reinicio se realiza desconectando y conectando la
red,siendo válido esto tanto para alimentación por convertidor como por
cableado separado a 24V.
Puesta en servicio del variador
Lo primero que debemos hacer para poner el variador en servicio es ajustar el

parámetro P0010 = 1.
Una vez hecho esto, realizaremos los ajustes en los parámetros. Os adjunto un ejemplo
con el listado:
Introduciremos todos los parámetros necesarios del motor, aceleraciones, velocidades

etc y nos aseguraremos de que los parámetros P0700 y P1000 tienen valor = 6, ya que
le vamos a dar la consigna vía profibus.
Una vez terminada la secuencia de puesta en servicio ajustaremos P3900 = 1 para llevar
a cabo los cálculos del motor y borrar todos los demás parámetros (no incluidos en el
P0010=1) a sus valores por defecto.
Una vez hecho esto, ajustaremos otros parámetros que no estén incluidos en el listado,
como la configuración del relé de freno (P0731), por poner un ejemplo.
Con esto el variador estaría preparado para trabajar.
164
Configuración básica de un variador Micromaster – El proyecto.
Bien, ya tenemos todo preparado para mandar al estrellato a nuestro variador. El

problema ahora es solamente de meter dicho variador en nuestro proyecto. Es fácil. En
el configurador de HW hacemos lo siguiente:
Añadimos el variador. El GSD lo
encontraremos en nuestra biblitoteca,
cambiando el perfil a DriveES y dentro de
este, en SIMOVERT-> Micromaster 4
Una vez introducido, pincharemos dos
veces sobre él y nos aseguramos que en la
configuración tenemos seleccionado
Telegrama PPO3 sin PKW
Miramos la dirección asignada del byte de
entradas y el de salidas ya que nos va a
hacer falta.
Bien, he de decir que vamos a hacer una
configuración básica del variador. Esto
implica que por defecto, le vamos a mandar
dos palabras de mando y nos va a devolver
dos palabras de estado.
Las palabras de mando van a ser:
 Una serie de booleanas con marcha, sentido de giro, acuse de alarmas etc.
 Una palabra con la velocidad seleccionada.
 Por su parte, el variador nos va a devolver dos palabras:
 Una serie de booleanas con los estados básicos de listo, marcha, fallo, alarma
etc.
 Una palabra con la velocidad real.
Es posible configurar el variador para mandar más parámetros y poder cambiarlos. En
las referencias os dejo los manuales para que practiquéis con ello ya que la idea es
poner el variador en marcha en su forma más básica.
Bits de mando
Os dejo la palabra de mando aunque en el manual lo tenéis también. Ojo porque como
siempre primero es el byte alto y luego el byte bajo. Así, suponiendo que la palabra de
mando fuera el AW256, la señal de marcha (bit 0) sería la A257.0
165
La palabra de estado
Igualmente, suponiendo que la palabra de estado fuera el EW256, el bit 0 será la

E257.0. También está en el manual.
166
167
Y como lo mejor es ver un ejemplo que acompañe la parte teórica, he preparado como
siempre un video que puedes ver a continuación. Esta vez, a diferencia de otras veces,
no lo podemos simular. Pero créeme cuando te digo que el proyecto de ejemplo con el
variador bien configurado funciona correctamente.
Referencias:
 Módulo adicional profibus
 Parámetros Micromaster 420
168
45. Entradas analógicas 4-20mA en S7
La situación de partida sobre un problema sería algo así como…

(..) Es un transductor Danfoss de 4 a 20 mA 2 hilos. La idea es hacer que se dispare
una alarma si la presión del aire disminuye a menos de 100 psi y si sube a más de 120
psi, es decir la presión siempre debe estar entre 100 y 120 psi. (..) y también me gustaría
que la podamos visualizar en WIN CC…
Vamos a ver los siguientes conceptos para resolverlo:
 Elegir y configurar la tarjeta de entradas analógicas
 Programar la alarma pertinente de alta y baja
 Graficar la presión en nuestro HMI usando WinCC
Hay diversos modelos de entradas analógicas. La que yo

he elegido para este caso es 6ES7-331-7KF02-0AB0, o lo
que viene siendo una tarjeta de entradas analógicas con
aislamiento galvánico de 9/12/14bits.
Lo primero que vamos a hacer es configurar la tarjeta. Para ello, vamos a elegir como
muestra en la figura: TM2H ya que es entrada en corriente 4..20mA a dos hilos, que son
los requerimientos planteados.
Por otro lado, como bien indica la imagen adjunta, habrá que cambiar la posición del
adaptador trasero de la tarjeta de tal forma que esté configurado en su posición D.
169
Por otro lado debemos saber, que la lectura de 4-20mA será una lectura que en el
programa la vamos a ver como un valor entre 4000 y 20000.
Finalmente, el transductor nos dará 4mA cuando la señal esté al 0% de la escala y 20mA
cuando esté al 100% de la escala (como supongo ya imaginabas). Por cómo plantea la
consulta, vamos a elegir el modelo que da de 0 a 200psi.
En general, la fórmula que usaremos será: (Preal – Pmin) /(Pmax-Pmin) = (Señal_mA
– 4mA) /(20mA – 4mA) que es la ecuación de una recta que pasa por dos puntos
conocidos (Pmin, 4mA) y (Pmax, 20mA).
Esto es para que desempolves tus conocimientos de geometría de hace unos cuantos
lustros ( ¿o no tanto?)
Por tanto, tendremos que nuestra recta vendrá dada: (Preal – 0psi)/(200psi – 0psi) =
(Señal_mA – 4mA)/(20mA-4mA), o lo que es lo mismo:
Presión_Real (psi) = (Señal_mA-4mA)*(200psi)/(16mA)
A este valor luego lo tendremos que dividir por 1000 ya que la señal vendrá dada entre
4000 y 20000 como ya hemos comentado. Pero esto lo veremos a la hora de hacer el
ejemplo.
También se puede usar la función de escalado FC105 Scale Convert, que lo podéis
encontrar en Standard Library->TI S7 Converting Blocks. La info que aporta la ayuda de
siemens dice lo siguiente
Descripción
La función “Escalar valores” (SCALE) toma un valor entero en la entrada IN y lo convierte
en un valor real, convirtiéndolo a escala en un rango comprendido entre un límite inferior
y un límite superior (LO_LIM y HI_LIM). El resultado se escribe en la salida OUT. La
función SCALE aplica la fórmula siguiente:
OUT = [((FLOAT (IN) – K1)/(K2–K1)) * (HI_LIM–LO_LIM)] + LO_LIM
Las constantes K1 y K2 se aplican de forma diferente, dependiendo de si el valor de
entrada es BIPOLAR o UNIPOLAR.
· BIPOLAR: Se supone que el valor entero de entrada debe estar entre -27648 y 27648,
por lo tanto, K1 = -27648.0 y K2 = +27648.0
· UNIPOLAR: Se supone que el valor entero de entrada debe estar entre 0 y 27648, por
lo tanto, K1 = 0.0 y K2 = +27648.0
Si el valor entero de entrada es mayor que K2, la salida (OUT) se une a HI_LIM y se
indica un error. Si el valor entero de entrada es menor que K1, la salida se une a LO_LIM
y se indica un error.
Se puede efectuar la conversión escalar inversa programando los límites de tal forma
que el límite inferior sea mayor que el límite superior (LO_LIM > HI_LIM). En la
conversión escalar inversa el valor de la salida disminuye cuando aumenta el valor de
la entrada.
170
Programación de la alarma
Para programar la alarma, simplemente vamos a leer la señal recibida y si es inferior al

valor parametrizado dará alarma de baja y si se superior al valor superior establecido
dará alarma de alta.
Además, configuraremos una tercera alarma que es que la lectura debe estar entre 4000
y 20000 ya que de no ser así es que algo pasa en la instalación.
A la hora de programar las alarmas de alta y de baja, y aunque no sea el caso, es
conveniente filtrar dichas alarmas, esto es, temporizarlas de tal forma que un pico bien
por arriba o por abajo, no de alarma ya que podemos considerarlo como un transitorio
o un pequeño ruido en la señal que hay que tratar como tal y por tanto que no nos dé
una falsa alarma.
Este tiempo ya es para gustos y necesidades y puede variar desde tiempos muy cortitos
hasta de varios minutos en función de qué estemos hablando.
Graficar la señal
Una vez tengamos todo preparado, sólo nos quedará graficar dicha señal. Para ello
vamos a usar la variable de la presión y dos constantes, que serán los límites superior
e inferior.
No me voy a extender más en la explicación de cómo hacerlo ya que lo mejor es que lo
veas en el siguiente vídeo.
171
46. Cómo observar y forzar variables en Step 7
Para poder acceder a esta ventana, accederemos desde el editor como se indica en la
figura: Sistema destino –> Observar/forzar variables
¿Qué se puede hacer?
Pues el propio Siemens lo indica en la ayuda. Con las funciones de “Observar/forzar

variables” es posible:
 Observar los valores actuales de variables concretas de un programa de usuario

o de una CPU en la PG/en el PC: Observar variables
 Asignar valores fijos a variables concretas de un programa de usuario o de una
CPU: Forzar variables
 Asignar valores fijos a salidas de periferia concretas de un programa de usuario
o de una CPU en estado operativo STOP: Desbloquear salidas y Activar valores
de forzado.
 Ocupar con carácter fijo variables concretas de un programa de usuario o de
una CPU con un valor que el programa de usuario no pueda sobrescribir:
Forzado permanente de variables
En general, para lo que se va a usar es para ver el estado de las variables y poder forzar
el estado de marcas o asignar valores.
Ojo, porque estos valores puede que los fuerces e inmediatamente tomen el valor que
el programa les asigna. Esto va a hacer que parezca que no ha sucedido nada como
veremos en el vídeo.
172
El punto de disparo
Una cosa que has de tener en cuenta, es cómo funciona el PLC y cuándo vas a realizar
el forzado (el punto de disparo).
Se puede hacer bien al inicio del OB1, después de que las PEW se han volcado sobre
las EW o bien después de que las AW se vuelcan en las PAW.
Si no sabes de qué estoy hablando, deberías repasar el funcionamiento cíclico del PLC.
Así, lo lógico es que si queremos:
 Forzar una entrada –> pondremos el punto de disparo al inicio del ciclo
 Forzar salidas –> pondremos el punto de disparo al final del ciclo
Otras opciones
Además de lo dicho, se puede:

Colocar comentarios usando como en el editor en AWL dos barras (//).observar y forzar
variables en step7
173
Añadir áreas de memoria de forma rápida (botón derecho-> Añadir área)
Finalmente decir que puedes guardar estas simulaciones dentro del proyecto mediante
archivos VAT. Esto deberás hacerlo en la misma carpeta que tengas el proyecto con los
bloques.
174
El vídeo
Lo más interesante es ver el vídeo para la parte de cómo hay que forzar las entradas y
salidas. Te dejo con él.
175

Cómo Programar Step 7 y No Morir en El Intento V2015 02 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cómo Programar Step 7 y No Morir en El Intento V2015 02 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Cómo programar Step 7 y no morir en el intento

 No copies partes de este eBook ni lo publiques con o sin atribución o créditos.

OB101 rearranque ............................................................................................... 26

11. Formas de crear marcas cíclicas en Step 7 ...................................................... 49

Forzado del RLO – SET y CLR ............................................................................... 65

19. Control del reloj del sistema en Step 7 ............................................................. 80

Destellos por un tiempo fijo de una señal ................................................................ 94

¿Y en KOP? ...................................................................................................... 109

Asigna rangos a las I/O ......................................................................................... 147

Bits de mando .................................................................................................... 165

¿Qué es este libro?

¿Qué NO es este libro?

Lo primero y más importante, no es palabra de Dios. No es, ni pretende ser, un libro

¿Necesitaré papel y pinturillas de colores?

Pues hombre, como puedes imaginar, vas a necesitar un ordenador (portátil o de

 Step 7 V5.5 +SP1

¿Qué temas contendrá el libro?

 De poner lo mejor de mi parte para poder resolver dudas dentro de mis

1. Introducción a la programación en Step 7

Vamos a repasar una serie de conceptos generales de programación aplicados en un

 Imagen de las E/S.

La programación en Step7 tiene la peculiaridad de tener temporizadores de dos tipos:

Módulos de datos (DB).

Las variables temporales no se re-inicializan como yo he comentado en el vídeo. El valor

 Módulos de organización (OB)

 OB de arranque (OB100-102): Son bloques con los que se arranca el PLC en

 El OB1: Es un tipo es sí mismo y es el principal. Se ejecuta de forma recurrente

 OB cíclicos: También se pueden hacer llamadas a otros FC o ejecutar código

 OB Horarios: Son OB que dependen de la fecha y hora. Se pueden realizar

Todos los OB tienen la peculiaridad de tener reservados 20bytes de memoria local

Los más usados con una diferencia notable con el resto:

 OB100: Arranque desde cero. En el daremos las condiciones y valores iniciales

Bloques de función (FB)

desentendernos de cómo funcionan internamente una vez sepamos depurado el código

Módulos de datos (DB)

Ciclo del programa

Como puedes imaginar, ejecutar todas las instrucciones conllevará un tiempo

¿Cómo se puede superar este tiempo?

2. Métodos de arranque: OB100, OB101 y OB102

El programa de arranque puede ser tan

Ahora sí, que la hemos liado.. quee ¿qué?

Arranque completo (arranque en caliente)

3 métodos de arranque en Step7

OB100 para el arranque completo

OB102 para el arranque en frío

Programación del OB100

El uso que se le da al OB100 es fundamentalmente para dar valores iniciales a variables

3. El entorno de desarrollo de Step 7

Todo lenguaje de programación tiene un entorno de desarrollo. El entorno de desarrollo

El entorno de desarrollo de Step 7 Simatic Manager

Nuestro primer proyecto en Step 7 “HELLO WORLD!!”

4. Álgebra booleana (lógica binaria)

sin programar ni una línea de código... el álgebra booleana en Step 7 is here.

¿Qué es el Álgebra booleana en Step 7?

Bueno, en Step 7 y en cualquier lenguaje.

 Algebra de Boole (Wikipedia)

¿No hay más?

La programación en escalera o ladder es la más común en la mayoría de los lenguajes

¿Cómo se hace un AND y un OR?

Básicamente un AND lo harás mediante dos contactos

5. Puertas lógicas NOR y NAND en S7

Es lo mismo que hacer

Como veis en la fórmula, es muy similar. La negada de la suma es igual al producto de