Documente Academic
Documente Profesional
Documente Cultură
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:
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.
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
0. Prefacio.
Antes de empezar este libro me gustaría compartir contigo en qué va a consistir y cuál
es su finalidad.
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.
12
Cómo programar Step 7 y no morir en el intento
¿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:
¿Garantía?
Pues como puedes imaginar más bien escasa. Sólo te puedo ofrecer el compromiso:
13
Cómo programar Step 7 y no morir en el intento
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:
14
Cómo programar Step 7 y no morir en el intento
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.
15
Cómo programar Step 7 y no morir en el intento
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.
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!
16
Cómo programar Step 7 y no morir en el intento
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
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 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.
17
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
20
Cómo programar Step 7 y no morir en el intento
21
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
23
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
¿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.
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 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
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
27
Cómo programar Step 7 y no morir en el intento
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.
28
Cómo programar Step 7 y no morir en el intento
El configurador de hardware
El configurador de redes
29
Cómo programar Step 7 y no morir en el intento
El editor de símbolos
El editor de código
30
Cómo programar Step 7 y no morir en el intento
31
Cómo programar Step 7 y no morir en el intento
Bueno. Basta de ver vídeos donde se explican muchas cosas bastante aburridas y aún
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
Cómo programar Step 7 y no morir en el intento
reset, pulsos … que nos ayudarán a realizar programas eficientes en plazos de tiempo
razonables.
Al grano...
33
Cómo programar Step 7 y no morir en el intento
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
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).
34
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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.
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.
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
Cómo programar Step 7 y no morir en el intento
37
Cómo programar Step 7 y no morir en el intento
38
Cómo programar Step 7 y no morir en el intento
7. Multiinstancias en Step 7
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
Cómo programar Step 7 y no morir en el intento
40
Cómo programar Step 7 y no morir en el intento
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.
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.
41
Cómo programar Step 7 y no morir en el intento
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.
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:
42
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
44
Cómo programar Step 7 y no morir en el intento
45
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
48
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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?
50
Cómo programar Step 7 y no morir en el intento
¿Y ahora?
Pues tienes que guardarlo, compilar y cargárselo al PLC. Ojo porque el PLC va a pasar
a STOP, así que:
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.
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
Cómo programar Step 7 y no morir en el intento
= 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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
AWL en Step 7
54
Cómo programar Step 7 y no morir en el intento
¿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:
55
Cómo programar Step 7 y no morir en el intento
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
56
Cómo programar Step 7 y no morir en el intento
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
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
60
Cómo programar Step 7 y no morir en el intento
AWL
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
Cómo programar Step 7 y no morir en el intento
62
Cómo programar Step 7 y no morir en el intento
¿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.
¿Es grave?
No conozco a nadie que haya enfermado de ello, pero mejor evitarlo.
63
Cómo programar Step 7 y no morir en el intento
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.
¿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
Cómo programar Step 7 y no morir en el intento
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:
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
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
Vamos, que se explican como un libro cerrado. Así que aclaremos las cosas.
67
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
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.
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
Cómo programar Step 7 y no morir en el intento
Acumuladores en AWL
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?
70
Cómo programar Step 7 y no morir en el intento
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).
Enteros
Dobles enteros
Reales
¿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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
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.
73
Cómo programar Step 7 y no morir en el intento
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.
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.
74
Cómo programar Step 7 y no morir en el intento
Y cómo no, tener una cara y friki calculadora (entre la pantalla y la CPU con
2500€ lo hacemos fácil).
¿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
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
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).
CC 1 CC 0
0 0 ACCU 2 = ACCU 1
CC 1 CC 0
0 0 Resultado = 0
0 1 Resultado < 0
1 0 Resultado > 0
CC 1 CC 0
78
Cómo programar Step 7 y no morir en el intento
CC 1 CC 0
0 0 Underflow
0 1 Rango negativo de OV
1 0 Rango positivo de OV
CC 1 CC 0
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
Cómo programar Step 7 y no morir en el intento
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.
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
80
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
Pues ya está. Veamos el vídeo donde vemos cada uno de estos puntos y damos
solución al problema.
82
Cómo programar Step 7 y no morir en el intento
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:
83
Cómo programar Step 7 y no morir en el intento
¿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.
84
Cómo programar Step 7 y no morir en el intento
Para ello vamos a usar una operación AND. Pero no una cualquiera, sino una operación
con palabra (WAND)
85
Cómo programar Step 7 y no morir en el intento
Para eliminar esos ceros, y pasar nuestro 80 a un 8, que es lo que nos interesa,
necesitamos…
¿Y las centenas?
Estoy convencido que ahora ya sabrías hacer el resto. Como bien imaginas:
Una vez que tengamos cada dígito, tenemos que sacarlo en un display de 7
segmentos… ¿cómo?
Habría dos formas:
86
Cómo programar Step 7 y no morir en el intento
87
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
21. Temporizadores S7
89
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
dado. La salida cae cuando cae la señal que arranca el temporizador. Es muy utilizado
junto con el siguiente temporizador.
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.
91
Cómo programar Step 7 y no morir en el intento
Vamos a ver unos ejemplos sencillos para ver el uso de los temporizadores S7:
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:
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.
92
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
Imagina que quieres hacer un tren que con una señal, dure un determinado tiempo.
Imaginemos 30 segundos.
Lo que haremos será combinar:
94
Cómo programar Step 7 y no morir en el intento
95
Cómo programar Step 7 y no morir en el intento
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.
96
Cómo programar Step 7 y no morir en el intento
97
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
¿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.
Vale. Ya hemos visto cómo podríamos saber si hay una alarma activa teniendo en
cuenta todas las alarmas.
99
Cómo programar Step 7 y no morir en el intento
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.
¿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
Cómo programar Step 7 y no morir en el intento
101
Cómo programar Step 7 y no morir en el intento
102
Cómo programar Step 7 y no morir en el intento
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.
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.
103
Cómo programar Step 7 y no morir en el intento
¿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.
104
Cómo programar Step 7 y no morir en el intento
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.
105
Cómo programar Step 7 y no morir en el intento
106
Cómo programar Step 7 y no morir en el intento
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.
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:
107
Cómo programar Step 7 y no morir en el intento
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:
108
Cómo programar Step 7 y no morir en el intento
¿Y en KOP?
109
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
111
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
L Mw2
==I
SPBN ELSE
L MW4
L1
-I
T MW4
ELSE: NOP 0
113
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
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.
115
Cómo programar Step 7 y no morir en el intento
¿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.
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
116
Cómo programar Step 7 y no morir en el intento
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.
117
Cómo programar Step 7 y no morir en el intento
118
Cómo programar Step 7 y no morir en el intento
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.
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.
SPA SEG1 //Meta del salto si ACU1-L-L = 1.
SPA SEG2 //Meta del salto si ACU1-L-L = 2.
SPA SEG3 //Meta del salto si ACU1-L-L = 3.
ELSE: SPA END0
SEG0: * //Instrucción permitida.
*
SPA END0
SEG1: * //Instrucción permitida.
*
SPA END0
SEG2: * //Instrucción permitida.
*
SPA END0
SEG3: * //Instrucción permitida.
*
SPA END0
END0: NOP 0
119
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
SPO Saltar si OV = 1
SPS Saltar si OS = 1
SPZ Saltar si el resultado = 0
121
Cómo programar Step 7 y no morir en el intento
122
Cómo programar Step 7 y no morir en el intento
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.
¿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
Cómo programar Step 7 y no morir en el intento
124
Cómo programar Step 7 y no morir en el intento
125
Cómo programar Step 7 y no morir en el intento
126
Cómo programar Step 7 y no morir en el intento
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.
127
Cómo programar Step 7 y no morir en el intento
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:
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:
128
Cómo programar Step 7 y no morir en el intento
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:
129
Cómo programar Step 7 y no morir en el intento
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…
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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:
132
Cómo programar Step 7 y no morir en el intento
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.
¿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).
133
Cómo programar Step 7 y no morir en el intento
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.
¿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.
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]
134
Cómo programar Step 7 y no morir en el intento
135
Cómo programar Step 7 y no morir en el intento
La idea es simple: poder comparar dos áreas de memoria consecutiva de dos DB (o del
mismo) y saber si ambas áreas son iguales.
136
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
138
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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:
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 programar Step 7 y no morir en el intento
¿Cómo hacerlo?
Pues los ingredientes que vamos a usar son los siguientes:
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.
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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:
145
Cómo programar Step 7 y no morir en el intento
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.
146
Cómo programar Step 7 y no morir en el intento
FC 110 Transportador 1
FC 111 Transportador 2
FC 112 Transportador 3
FC 113 Transportador 4
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.
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:
147
Cómo programar Step 7 y no morir en el intento
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.
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:
148
Cómo programar Step 7 y no morir en el intento
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:
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
Cómo programar Step 7 y no morir en el intento
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.
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
Cómo programar Step 7 y no morir en el intento
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.
151
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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.
153
Cómo programar Step 7 y no morir en el intento
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:
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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.
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?
156
Cómo programar Step 7 y no morir en el intento
A mi modo de ver, el único problema es tener la gente cualificada que pueda programar
una máquina similar. Por tanto:
157
Cómo programar Step 7 y no morir en el intento
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.
158
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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.
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 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
Cómo programar Step 7 y no morir en el intento
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.
PID en Step7
161
Cómo programar Step 7 y no morir en el intento
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:
162
Cómo programar Step 7 y no morir en el intento
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.
163
Cómo programar Step 7 y no morir en el intento
164
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
La palabra de estado
166
Cómo programar Step 7 y no morir en el intento
167
Cómo programar Step 7 y no morir en el intento
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:
168
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
Programación de la alarma
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
Cómo programar Step 7 y no morir en el intento
Para poder acceder a esta ventana, accederemos desde el editor como se indica en la
figura: Sistema destino –> Observar/forzar variables
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
Cómo programar Step 7 y no morir en el intento
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
173
Cómo programar Step 7 y no morir en el intento
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
Cómo programar Step 7 y no morir en el intento
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