Cómo programar Step 7 y no morir en el intento Aviso Legal Este libro se ha producido con pasión y esfuerzo por Iñigo Gútiez, dueño de los derechos de autor del mismo, Copyright 2014 Todos los derechos reservados. En este momento de finalizar el eBook, son incontables las horas que ha llevado confeccionarlo. El libro no es nada más que el compendio de un montón de entradas del blog http://programacionsiemens.com donde he dejado a lo largo de estos dos últimos años gran parte de mi tiempo libre de forma gratuita. Pero no es el caso de este libro electrónico. Te pido por ello que: No copies partes de este eBook ni lo publiques con o sin atribución o créditos. No publique este eBook en plataformas gratuitas. No es un libro cualquiera. Para empezar porque está en formato electrónico que si bien puedes imprimirlo, perdería toda su esencia al tener incrustados un montón de links a vídeos explicativos con ejemplos de programación. En segundo lugar porque los capítulos probablemente no sigan un orden teórico lógico ni lo pretenden. Son las transcripciones más o menos fidedignas de lo escrito en el blog y de ahí su singularidad. Finalmente porque toda la información aquí recogida ya ha sido publicada en el blog, por lo que no hay conocimiento nuevo expuesto a lo largo de las próximas ciento y pico páginas. Ni que decir tiene que Simatic Step 7 es una marca registrada por Siemens Agradecimientos y dedicatoria Mi primer agradecimiento es para ti por haber adquirido este ejemplar pudiendo haber seguido bebiendo exclusivamente del blog. Si no tuvieras interés por el blog y apreciaras el esfuerzo que supone su publicación difícilmente este libro hubiera visto la luz. Mi segundo agradecimiento es para Carlos de www.masvoltaje.com por las innumerables horas que hemos pasado charlando de lo humano y lo divino… hasta hemos buscado tiempo para hablar del blog. Aún lo seguimos haciendo. Por último, pero la primera en importancia, se lo dedico a mi mujer Susana por su infinita paciencia conmigo, que no siempre es fácil. Por sus consejos. Por su cariño y su dulzura. Por ser la mujer de mi vida. 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 OB101 rearranque ............................................................................................... 26 Programación del OB100 ........................................................................................ 26 3. El entorno de desarrollo de Step 7 ....................................................................... 28 El entorno de desarrollo de Step 7 Simatic Manager ............................................... 28 El configurador de hardware ................................................................................... 29 El configurador de redes ......................................................................................... 29 El editor de símbolos ............................................................................................... 30 El editor de código................................................................................................... 30 Nuestro primer proyecto en Step 7 “HELLO WORLD!!” ........................................... 31 4. Álgebra booleana (lógica binaria) ........................................................................ 32 ¿Qué es el Álgebra booleana en Step 7? ............................................................... 32 ¿No hay más? ......................................................................................................... 32 Al grano................................................................................................................... 33 ¿Cómo se hace un AND y un OR?.......................................................................... 33 5. Puertas lógicas NOR y NAND en S7 ................................................................... 34 NAND ...................................................................................................................... 34 NOR ........................................................................................................................ 34 6. FB en Step 7 - Ejemplo de una bomba de agua................................................... 36 FB en Step 7 ........................................................................................................... 36 Ejemplo de maniobra de una Bomba de agua ......................................................... 36 Resolución del ejercicio ........................................................................................... 38 7. Multiinstancias en Step 7 ..................................................................................... 39 ¿Qué son multiinstancias en Step 7? ...................................................................... 39 Mucho rollo esto de las multiinstancias en Step 7 ¿no? .......................................... 39 Video sobre multiinstancias en Step 7 ..................................................................... 40 8. Funciones en PLC Siemens con ejemplo de semáforo ........................................ 41 ¿Qué son los FC en Step 7? ................................................................................... 41 FC Vs. FB ............................................................................................................... 41 Muy bien, pero ¿qué vamos a ver en este capítulo? ............................................... 41 ¿En qué va a consistir el ejemplo del semáforo? .................................................... 42 ¿Qué herramientas vamos a necesitar para crear este FC en Step 7? ................... 42 9. FC o FB ¿Cuál de los dos usar? .......................................................................... 44 FC o FB................................................................................................................... 44 10. Cómo crear la estructura de un programa en ladder ........................................ 46 ¿Qué ventajas tiene una programación en ladder para estructurar un programa en Step 7?.................................................................................................................... 46 ¿Cómo funciona este tipo de programación en ladder? ....................................... 46 El vídeo ................................................................................................................... 48 Cómo programar Step 7 y no morir en el intento 11. Formas de crear marcas cíclicas en Step 7 ...................................................... 49 Marcas cíclicas del PLC .......................................................................................... 49 ¿Cómo se activa? ................................................................................................... 50 ¿Y ahora? ............................................................................................................... 51 Marcas cíclicas usando temporizadores .................................................................. 51 Marcas cíclicas usando un OB cíclico ..................................................................... 51 Teniendo OB cíclicos, ¿no hay más formas? .......................................................... 53 12. Algebra booleana (II) – AWL en Step 7 ............................................................ 54 AWL en Step 7 ........................................................................................................ 54 ¿Ensamblador? Ya me estas asustando… ............................................................. 54 Instrucciones básicas para programar AWL en Step 7 ............................................ 55 ¿No hay negadas? .............................................................................................. 55 ¿No hay más? ..................................................................................................... 56 Operaciones de Y lógica. ........................................................................................ 56 Ya bien, pero estooo, una cosita que te quería comentar… .................................... 56 ¿Qué es el RLO? .................................................................................................... 56 La definición ha quedado chulísima pero no he entendido ni papa. ..................... 56 Operación O lógica.................................................................................................. 57 ¿Por qué? ............................................................................................................... 57 Paréntesis en AWL en Step 7 ................................................................................. 58 Operandos de cierre de consulta............................................................................. 59 13. Step 7… AWL, FUP o KOP ¿Cuál elijo? .......................................................... 60 FUP ......................................................................................................................... 60 KOP ........................................................................................................................ 60 AWL ........................................................................................................................ 61 14. SET y RESET en AWL y alguna cosilla más. ................................................... 63 ¿Ya sólo nos queda ver SET y RESET en AWL en lógica binaria? ......................... 63 ¿Qué es un set y reset en AWL?............................................................................. 63 ¿Qué pasa si se dan ambas condiciones, SET y RESET en AWL? ..................... 63 ¿Puede darse ese caso? ..................................................................................... 63 ¿Es grave? .......................................................................................................... 63 ¿Qué pasa si se da? ............................................................................................ 64 ¿De qué depende? .............................................................................................. 64 ¿Esto sólo se puede dar en AWL?....................................................................... 64 ¿Qué pasa si mezclo Set, Reset e igualaciones? ................................................ 64 Vale, vale… pero ¿qué hay del SET y RESET en AWL? ........................................ 64 ¿Chupado no? ..................................................................................................... 64 Cómo programar Step 7 y no morir en el intento Forzado del RLO – SET y CLR ............................................................................... 65 ¿Cuánto valdrá A1.0? .......................................................................................... 65 Flancos en AWL ...................................................................................................... 65 15. Función MOVE en Step 7 ................................................................................. 67 MOVE en Step 7 (en cristiano) ................................................................................ 68 ¿Ahora bien, y si hago un MD4 a MW10?............................................................ 68 ¿Y ya está? ......................................................................................................... 68 16. Cómo usar los acumuladores en AWL ............................................................. 70 Acumuladores en AWL............................................................................................ 70 Pero si los acumuladores en AWL son dos, ¿qué pasa con el ACU2? .................... 70 ¿Qué tendrían entonces el ACU1 y el ACU2? ......................................................... 71 ¿Qué más operaciones se pueden hacer? .......................................................... 71 ¿Qué seguridades hay a la hora de realizar operaciones matemáticas? ............. 71 Guay. Pues lo sumo en AWL. .............................................................................. 71 ¿Valor de MW10? ................................................................................................ 71 Forma en que carga y se transfiere al ACU1 ....................................................... 72 ¿Qué ocurre cuando lees el ACU1? .................................................................... 72 ¿Menudo lío no? .................................................................................................. 72 Operaciones con los acumuladores que afectan al RLO ......................................... 72 ¿Cuántas operaciones con los acumuladores hay? ................................................ 73 17. Operaciones - Calculadora científica ................................................................ 74 Ejemplo en Step 7 de calculadora científica ............................................................ 74 ¿Qué vamos a repasar con este ejemplo en Step 7? .............................................. 74 ¿Qué requerimientos va a tener? ............................................................................ 75 ¿Tampoco es para tanto no? ............................................................................... 75 ¿Me lo explicas? ..................................................................................................... 75 18. Palabra de estado en Step7 ............................................................................. 76 La palabra de estado en Step 7 ¿qué es? ............................................................... 76 Los bits de la palabra de estado .............................................................................. 76 Vale, nombres chulos, pero quitando al RLO y el STA, los demás como que…... 77 Bit 0 -/FC ............................................................................................................. 77 Bit 1 – RLO. ......................................................................................................... 77 Bit 2 – STA .......................................................................................................... 77 Bit 3 – OR ............................................................................................................ 77 Bit 4 y 5 – OS y OV.............................................................................................. 77 Bit 6 y 7 – CCO y CC1 ........................................................................................ 78 Bit 8 – BR ............................................................................................................ 79 Cómo programar Step 7 y no morir en el intento 19. Control del reloj del sistema en Step 7 ............................................................. 80 ¿En qué consiste el ejemplo? ................................................................................. 80 ¿Cómo vamos a leer el reloj del sistema? ........................................................... 80 ¿Cómo calcularemos el día del año? ................................................................... 81 ¿Y si estamos en marzo… o en septiembre? ...................................................... 81 ¿Qué es lo que falta? Pues saber si es bisiesto................................................... 81 ¿Cómo calculamos si es un día bisiesto? ............................................................ 81 20. Codificación de un display de 7 segmentos...................................................... 83 ¿Qué es un display de 7 segmentos? .................................................................... 83 ¿Cómo tratamos los datos? .................................................................................... 84 ¿Qué es un número BCD? .................................................................................. 84 ¿Y el 10? ............................................................................................................. 84 Tratar y filtrar un número de 3 cifras ........................................................................ 84 Perdona, pero... que ¿qué? ................................................................................. 85 Vale. Más o menos lo pillo… pero ¿para qué? .................................................... 85 Ya si eso, igual con un ejemplo… ........................................................................ 85 ¿Cómo se te ha quedado el cuerpo? ................................................................... 85 Mmmmm y ¿cómo lo soluciono yo ahora? ........................................................... 85 Desplazar los bits a la derecha................................................................................ 86 ¿Qué es lo que hace la operación SHR_W?........................................................ 86 ¿Y las centenas? ................................................................................................. 86 Representación en un display de 7 segmentos ....................................................... 86 ¿Una palabra a una doble? ................................................................................. 87 Un momento, ¡¡ tú me has estado tomando el pelo todo el rato!!… ......................... 87 21. Temporizadores S7 .......................................................................................... 89 S_IMPULS S_VIMP Temporizadores como impulso .......................................................... 89 Temporizadores como impulso prolongado ............................................ 90 S_EVERZ Temporizadores como retardo a la conexión ....................................... 90 S_AVERZ Temporizadores como retardo a la desconexión ................................. 91 S_SEVERZ Temporizadores como retardo a la conexión con memoria .................. 91 22. Ejemplos prácticos de temporizadores S7........................................................ 92 Filtrado de señales. ................................................................................................. 92 Filtro de guiños positivos. ........................................................................................ 92 ¿Cómo? ............................................................................................................... 92 Filtro de guiños negativos........................................................................................ 92 Filtro combinado ...................................................................................................... 93 Crear un tren de pulsos ........................................................................................... 93 Cómo programar Step 7 y no morir en el intento Destellos por un tiempo fijo de una señal ................................................................ 94 Reset de un relé de forma segura ........................................................................... 94 23. Cómo crear un cronómetro en Step 7 .............................................................. 96 Cronómetro en Step 7 ............................................................................................. 96 WinCC Flexible ....................................................................................................... 96 ¿Cómo? ............................................................................................................... 96 Ya, ya… ¿pero cómo calculas la posición?.......................................................... 96 24. Filtrado y enmascarado de bits en Step 7 ........................................................ 98 Cómo saber si hay una alarma activa (usando todas las alarmas) .......................... 98 ¿No valdría con sumar y ya está? ........................................................................... 99 Ummmm en general sí…. en particular… no. ...................................................... 99 ¿Descubres la razón? .......................................................................................... 99 Filtrado y enmascarado de bits................................................................................ 99 Vale. Ahora sí que sí hago un cojo-OR eligiendo los bits. ................................. 100 ¿Cómo lo hacemos? .......................................................................................... 100 Vale. ¿Cómo podemos saber que hay una alarma descartando el M32.1 cómo queremos?......................................................................................................... 100 ¿Se podría hacer con words en vez de con bytes? ............................................ 102 25. Cómo realizar un tracking de datos en Step7 ................................................. 103 Tracking de datos en Step7................................................................................... 103 El "conceto" ....................................................................................................... 103 ¿Qué es lo que vamos a hacer? ........................................................................ 103 Bien, vale... ¿pero cómo? .................................................................................. 104 Y el SFC21 ¿para qué lo quieres? ..................................................................... 104 Y claro, vamos a usar DB... ............................................................................... 104 ¿Cuál es mejor? ................................................................................................ 104 ¿Por qué dices eso? .......................................................................................... 104 ¿Solución?......................................................................................................... 105 ¿Qué ventaja tiene usar un DB por posición? .................................................... 105 Pues siempre uso DB separados y ya está... ..................................................... 105 Vayamos con un ejemplo práctico ..................................................................... 106 26. Contadores en Step 7 .................................................................................... 107 Contadores en Step 7 usando un entero ............................................................... 107 Contadores en Step 7 usando INC y DEC ............................................................. 107 Contadores en Step 7 usando contadores S5 ....................................................... 108 Cómo cargar un valor a contadores en Step 7 ................................................... 108 Sumar y restar sobre contadores en Step 7 ....................................................... 108 Poner a cero un contador .................................................................................. 109 Cómo programar Step 7 y no morir en el intento ¿Y en KOP? ...................................................................................................... 109 27. Saltos: SPA, SPB y SPBN (If-Then-Else) ....................................................... 111 ¿Qué son los saltos en Step 7?............................................................................. 111 SPA se usa para saltos incondicionales. ............................................................... 111 SPB y SPBN se usan para saltos condicionados al valor del RLO ........................ 112 ¿Qué pasa si no se realiza el salto? ...................................................................... 112 ¿Vale, vale… pero como construyo un IF-THEN-ELSE? ....................................... 113 ¿Cómo lo hago con saltos en Step 7? ................................................................... 113 ¿Lo vemos con un ejemplo? ................................................................................. 113 ¿Pero esto no se puede hacer con FUP o KOP? .................................................. 114 28. Cómo anular partes de un programa. ............................................................. 115 Anular parte de un programa comentando líneas .................................................. 115 Anular parte de un programa realizando saltos. .................................................... 115 Anular parte de un programa usando una marca nula ........................................... 116 Anular parte de un programa usando BEA ............................................................ 116 29. Instrucción LOOP – El For /Next del PLC ....................................................... 117 Loop en Step 7 ...................................................................................................... 117 ¿Y cómo hago un FOR NEXT con LOOP en Step 7? ........................................ 117 Filtrado de una señal analógica ............................................................................. 118 30. Saltos SPL en Step 7. El Select Case en AWL............................................... 119 ¿En qué consiste el SPL en Step 7? ..................................................................... 119 31. Otros saltos .................................................................................................... 121 ¿Estado del RB? ¿Lo qué? ................................................................................... 121 Bit 8 – BR .......................................................................................................... 121 Saltos en Step 7 con errores y resultados matemáticos..................................... 121 32. Desplazamiento y giro de bits en Step7 ......................................................... 123 Vale. Hasta ahí lo entiendo, pero ¿qué diferencia hay desplazar entero o un Word a la derecha? ........................................................................................................... 123 ¿Lo qué? ........................................................................................................... 123 En principio no hay diferencia ¿no? ................................................................... 124 Y el giro de dobles palabras............................................................................... 124 ¿Podrías poner un ejemplo real de desplazamiento y giro de bits en Step7? ........ 125 33. Giro de bits en step 7: el coche fantástico ...................................................... 126 El vídeo sobre el giro de bits en step 7 .................................................................. 127 34. Direccionamiento indirecto – Memoria y punteros a área ............................... 128 Direccionamiento indirecto .................................................................................... 128 Direccionamiento Indirecto por Memoria ............................................................... 129 Formato palabra – número (indexados)................................................................. 129 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 Asigna rangos a las I/O ......................................................................................... 147 ¿Qué ganamos con ello? ................................................................................... 147 ¿Pero habría algún problema por ello? .............................................................. 148 ¿Qué pasa con las marcas, temporizadores etc.? ............................................. 148 Asigna nombres a las cosas.................................................................................. 148 Buenas prácticas de programación en S7 ............................................................. 148 Asigna una marca de ciclo al principio del proyecto ........................................... 149 Crear un Always_On y un Always_Off ............................................................... 150 Deja espacio, sé generoso con el que venga detrás… ...................................... 150 No seas un talibán de ningún lenguaje. Usa todos a tu antojo, pero con orden. 150 Alarmas ................................................................................................................. 151 Pantallas del HMI .................................................................................................. 151 ¿Qué quiero decir con esto? .............................................................................. 151 40. 4 formas de hacer una copia de seguridad de un proyecto de step7 .............. 153 Copia de seguridad de un proyecto de step7 offline .............................................. 153 ¿Con eso es suficiente? .................................................................................... 153 Crear una copia de seguridad de un proyecto de step7 mediante archivado. ........ 153 Crear una copia de seguridad de un proyecto de step7 online exacta. .................. 154 Crear una copia de seguridad de un proyecto de step7 online por carpetas ......... 154 41. Cómo proteger bloques en Step 7… si puedes. ............................................. 156 ¿Proteger bloques en Step 7? ¿Para qué? ........................................................... 156 42. Conectar un LOGO 8 con un PLC en Step 7 ................................................. 158 ¿Por qué usar un LOGO 8 como remota? ............................................................. 158 Conectar un logo 8 con un PLC en Step 7 ............................................................ 158 El vídeo de la lección ............................................................................................ 159 43. PID en Step7: Ejemplo de control de temperatura .......................................... 160 ¿Qué hardware vamos a necesitar? ...................................................................... 160 ¿Por qué un relé estático? ................................................................................. 160 La tarjeta de analógicas ..................................................................................... 161 ¿Y qué hay del software? ...................................................................................... 161 PID en Step7 ..................................................................................................... 161 ¿Cómo vamos a hacer ese reparto de tiempos?................................................ 162 44. Configuración de un variador Micromaster 420 .............................................. 163 Configuración básica de un variador Micromaster – El variador ........................... 163 Configuración de la dirección Profibus ............................................................... 163 Puesta en servicio del variador.............................................................................. 164 Configuración básica de un variador Micromaster – El proyecto. ......................... 165 Cómo programar Step 7 y no morir en el intento Bits de mando .................................................................................................... 165 La palabra de estado ......................................................................................... 166 45. Entradas analógicas 4-20mA en S7 ............................................................... 169 Programación de la alarma ................................................................................... 171 Graficar la señal .................................................................................................... 171 46. Cómo observar y forzar variables en Step 7 ................................................... 172 ¿Qué se puede hacer?.......................................................................................... 172 El punto de disparo ............................................................................................... 173 Otras opciones ...................................................................................................... 173 El vídeo ................................................................................................................. 175 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. ¿Qué es este libro? Es un libro para aprender a programar en Step 7 desde cuasi cero. Esto significa que se darán por sentados conceptos como qué es un PLC y para qué sirve. Si has llegado hasta aquí entiendo que sería una pérdida de tiempo por tu parte y por la mía empezar desde más abajo. No quiero que este libro sea “de relleno”, sino que sea lo más didáctico y práctico que sepa lograr, introduciendo la teoría y conceptos mínimos para poder comenzar a trabajar. En cuanto al contenido veremos juntos la mayoría de las funciones y bloques que dispone S7 con los que comenzar de una forma razonablemente solvente a programar en un entorno S7. ¿Qué NO es este libro? Lo primero y más importante, no es palabra de Dios. No es, ni pretende ser, un libro formal y reglado. No hay ni título ni nada por el estilo. Voy a intentar transmitir mis conocimientos para empezar a trabajar y programar un PLC de Siemens. Será tan completo como pueda hacerlo, pero nada más. No es un libro sobre TIA portal. No te quiero engañar: aún apenas lo he usado como para dar consejos sobre ello a nadie. En cuanto al hardware no entraré a evaluar cada tarjeta que hay en el mercado ni cada PLC. Se verá en el libro lo básico y necesario. No es objetivo de este el conocimiento profundo del hardware sino de realizar programas. El resto vendrá con el tiempo y la experiencia. Tampoco me hago responsable de posibles fallos que pueda acometer durante el libro. La buena fe te la puedo garantizar pero no la infalibilidad que se la dejo a seres superiores (no, no me refiero a los funcionarios). Por tanto no me hago responsable de que un programa no funcione bien, ni de los terremotos, ni de que te puedan despedir porque la máquina le escupa aceite a tu jefe, ni de una guerra termonuclear. ¿Necesitaré papel y pinturillas de colores? Pues hombre, como puedes imaginar, vas a necesitar un ordenador (portátil o de sobremesa) con Step 7 instalado junto con PLCSIM y WinCC Flexible. Además de eso, vas a necesitar una conexión a internet para poder reproducir los vídeos de ya que el PDF enlazará con los vídeos publicados. 12 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: Step 7 V5.5 +SP1 WinCC 2008 SP3 S7-PLCSIM Professional 2010 V5.4 +SP5 ¿Qué temas contendrá el libro? Vayamos al meollo de la cuestión… Vamos a ver juntos todos los temas relacionados con lo que propiamente es la programación del software de una forma más tranquila y espero que extensa y profunda para asentar tan bien como pueda explicarme (que tampoco es que se me dé del todo bien, seamos sinceros). Así, veremos con detenimiento todo lo relacionado con la memoria, variables, los módulos y todos los bloques que considere que tienes que conocer para que una vez termines el libro tengas unos mimbres para realizar programas de una complejidad notable. Además intentaré transmitirte todos los trucos y prácticas que ya he comentado en parte y otros que puede que aún estén en el tintero. Este tipo de truquillos seguramente sean más difícil de que los encuentres en otros cursos y libros. Todo irá acompañado como ya he comentado con los vídeos que considere pertinente además de explicar mediante ejemplos prácticos. ¿Garantía? Pues como puedes imaginar más bien escasa. Sólo te puedo ofrecer el compromiso: De poner lo mejor de mi parte para poder resolver dudas dentro de mis conocimientos. De haberlo hecho con mimo para sea lo más instructivo y ameno posible. 13 Cómo programar Step 7 y no morir en el intento 1. Introducción a la programación en Step 7 Vamos a repasar una serie de conceptos generales de programación aplicados en un entorno de Simatic S7. Lamento que la primera lección sea una pequeña chapa teórica y que no vayas a ver ni una línea de código, pero por muchas vueltas que le he dado, es necesario unos mínimos. Pero míralo de una forma positiva, así ya lo damos por zanjado y pronto comenzaremos a escribir líneas y líneas de código (el que no se conforma es porque no quiere). Empecemos... Los elementos de un autómata como bien sabes son dos: el hardware (el aparato en sí con sus tarjetas, cableado etc.) y el software (los programas). Dentro de los programas tendremos dos partes a su vez: El SO del autómata El programa de usuario que tú vas a desarrollar y que desempeñará las funciones para las cuales se ha ideado. El SO del autómata será el que se encargue por un lado de interpretar y ejecutar el programa que has diseñado además de otras funcionalidades como pueden ser el diagnóstico de alarmas y errores, administrar la memoria, comunicación con otros elementos, exploración de las entradas y la transmisión de órdenes a las salidas entre otras muchas que sabemos qué hace, pero poco nos importa ahora el saber cómo. Programación en Step 7 El programa de usuario es sobre lo que versa este libro. En este programa vas a poder determinar las condiciones con las que arrancará el autómata, tratará datos y señales del proceso para finalmente dar unas órdenes de actuación sobre los diferentes actuadores y elementos de la instalación. Estructura de la memoria. A grandes rasgos la memoria del autómata va a ser dividida en las siguientes partes: Imagen de las E/S. E/S de la periferia Marcas Valor y estado de temporizadores y contadores Módulos de datos (DB) Datos temporales que se pierden al final de cada ciclo. 14 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. La programación en Step7 tiene la peculiaridad de tener temporizadores de dos tipos: por software (IEC) y temporizadores S7 (o llamados también de S5 ya que existían ya en la versión anterior). Estos últimos son temporizadores hardware y son limitados dependiendo de la CPU (por ser hardware), no así los IEC que por ser creados por software la limitación es la propia memoria disponible, pero no hay un número determinado de ellos. 15 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. Módulos de datos (DB). Son áreas de memoria que a diferencia de las marcas, está definidas por el usuario. Pueden ser de longitudes dispares y con contenidos de todo tipo. Las variables contenidas en los DB son remanentes al apagado del PLC. Variables temporales. Son variables que se declaran dentro de los módulos que sirven para realizar cálculos intermedios y locales que no necesitan ser usados más allá del módulo en cuestión y en el ciclo en el que son llamadas o tratadas. ¡OJO! Las variables temporales no se re-inicializan como yo he comentado en el vídeo. El valor inicial de la variable temporal es el valor último que tomó esa variable, lo cual no deja de ser tremendamente peligroso ya que si no le das valor antes de leerla el contenido de dicha variable es indeterminado, especialmente si la función es llamada varias veces a lo largo del programa y la variable va tomando valores dispares. 16 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 (OB) Funciones (FC). Bloques de función (FB). Bloques de memoria (DB) Módulos de sistema (SFC,SFB,SDB) Módulos de organización Lo primero que has de saber de estos módulos es su especialización, sólo sirven para lo que han sido diseñados y no se llamarán desde otros bloques sino que será el propio autómata quien gestiona las llamadas a estos módulos en función de sus características. Hay varios tipos de módulos de organización: OB de arranque (OB100-102): Son bloques con los que se arranca el PLC en función del tipo de arranque y depende del tipo de CPU para que tenga todos los tipos o solamente el OB100, que es el arranque completo. Sólo se ejecuta una vez, en el arranque. Una vez terminado pasa al principal. El OB1: Es un tipo es sí mismo y es el principal. Se ejecuta de forma recurrente y desde él se hace llamadas a los FC y FB del programa OB cíclicos: También se pueden hacer llamadas a otros FC o ejecutar código desde estos OB. Tienen la peculiaridad frente al OB1 que se ejecutan a tiempo fijo (por ejemplo el OB35). OB Horarios: Son OB que dependen de la fecha y hora. Se pueden realizar tareas desde en un momento concreto a ser cíclicos cada x tiempo (desde minutos a todos los años en un momento concreto) OB de fallo (OB85, OB86, OB121 etc.). Son OB predefinidos para cada tipo de fallo y son llamados cuando el fallo es detectado. Dentro de cada OB se puede tratar el fallo y tomar las decisiones pertinentes en cada caso. Todos los OB tienen la peculiaridad de tener reservados 20bytes de memoria local donde podrás hallar variables específicas de cada OB. Así podrás tener información de en qué momento ha sido llamado o la frecuencia de llamada en el caso del OB35 por poner un ejemplo. 17 Cómo programar Step 7 y no morir en el intento Los más usados con una diferencia notable con el resto: OB100: Arranque desde cero. En el daremos las condiciones y valores iniciales (si procede) en el arranque. OB1: Programa principal (lógico) OB35: Programa cíclico por excelencia ya que hay otros pero que no están disponibles en todas las CPU. Puedes programar tareas a tiempo fijo facilitando contajes y mediciones que sean necesarias conocer su periodicidad. Luego están los de fallo que dependiendo de la aplicación usarás unos u otros o ninguno. Pero con estos 3 tienes el 80% de las necesidades de los OB cubiertos. Funciones (FC) Las funciones son bloques que pueden ser llamados desde OB, FC o FB y se usan fundamentalmente para: Estructurar el código de tal forma que no esté todo metido en el OB1 sino que se hace de forma arbórea e inteligible dividiendo el programa por zonas, máquinas, submáquinas... Usarlos como funciones que traten unos valores de entrada y den como resultado unos valores de salida. Lógicamente la idea de esto es por un lado dar claridad y por otro lado permite la reutilización de la función. Tienen la peculiaridad de poder definir de forma interna variables temporales con las que jugar dentro del bloque. Ya se ha comentado hay que tener cuidado con el tema de 18 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. Bloques de función (FB) Los bloques de función son parecidos a los anteriores con la particularidad que tienen variables internas llamadas estáticas que dan remanencia de ciclo a ciclo. Para lograr esta remanencia tendrán asociado un bloque de memoria (DB) llamados para estos casos de instancia. Los FB pueden ser llamados desde los OB, FC o FB además de poder ser usados dentro de las estáticas de otros FB (multiinstancias). En definitiva son los módulos que usaremos para una programación orientada a objetos de otros lenguajes ya que podremos realizar un módulo que nos gestione por ejemplo un transportador y podremos crear tantos transportadores como queramos pudiendo 19 Cómo programar Step 7 y no morir en el intento desentendernos de cómo funcionan internamente una vez sepamos depurado el código del FB. 20 Cómo programar Step 7 y no morir en el intento Módulos de datos (DB) Los módulos de datos pueden ser der de tipo global o de instancia. Los de instancia los hemos visto que son necesarios para la ejecución de los FB y toman la estructura de la declaración de las variables del propio FB. Los DB globales son módulos declarados por el usuario y pueden contener variables de todo tipo definiendo estructuras complejas. En ambos casos el acceso a la información es global ya que incluso se puede acceder a la información de un DB de instancia desde otro bloque. 21 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 Ciclo del programa Como ya he ido adelantando existen unos módulos que son los encargados de ejecutar los programas de usuario. En el siguiente esquema puedes ver de forma gráfica cómo es la ejecución cíclico del programa. Procesamiento cíclico Como puedes imaginar, ejecutar todas las instrucciones conllevará un tiempo denominado tiempo de ciclo. El tiempo de ciclo es el tiempo medido en ms que se necesita para ejecutar completamente todas las instrucciones y llamadas realizada desde el OB1, la ejecución de otros OB llamados (si fuera el caso) y actividades del SO (actualizar las imágenes de E/S por ejemplo). El tiempo no es constante ya que no todos los ciclos tienen la misma carga de trabajo bien porque no siembre se hacen las llamadas de OB cíclicos o porque no se hacen llamadas a todos los bloques en función de las circunstancias y valores de las diferentes variables. Este tiempo está vigilado por un watchdog (típicamente fijado en 150ms fijado en la configuración del hardware) y si se supera, el PLC se irá a estado de STOP. 23 Cómo programar Step 7 y no morir en el intento ¿Cómo se puede superar este tiempo? Pueden ser por varias causas, pero una típica es programar mal un bloque haciéndolo sin salida (un lazo infinito) con lo que irremediablemente se va a STOP aunque hay otras como pueden ser un programa excesivamente largo. También se puede ir el PLC a STOP debido a los tiempos de ejecución por llamadas a OB cíclicos en tiempos muy cortos con cargas de trabajo muy altas. Por ejemplo, programando el OB35 a 2ms y si su carga de trabajo es muy alta, puede que con la siguiente llamada aún no haya terminado las operaciones del ciclo anterior, y el PLC se coja la baja. Bromas aparte, veamos más en concreto en qué orden ejecuta las diferentes tareas durante este tiempo de scan. En primer lugar cuando arranca el PLC ejecuta los OB de arranque. El más habitual es el OB100. 24 Cómo programar Step 7 y no morir en el intento 2. Métodos de arranque: OB100, OB101 y OB102 ¿Qué es un OB de arranque? Un OB de arranque es un módulo que podemos programar para que se ejecute una única vez al arranque del sistema. El programa de arranque puede ser tan largo como se quiera, no tiene límite de tiempo y la vigilancia del tiempo de ciclo no está activa. La ejecución controlada por tiempo o por alarma no es posible en el programa de arranque. En el arranque, todas las salidas digitales tienen el estado de señal 0. El OB de arranque (OB100, OB101 u OB102) se ejecuta dependiendo del arranque, de la CPU existente y de los parámetros ajustados en la misma. OB100:Arranque completo OB101: Rearranque OB102: Arranque en frío Ahora sí, que la hemos liado.. quee ¿qué? Bien, lo primero que hay que saber es unos conceptos para que cuando lo leamos en los sesudos libros de Siemens no pongamos cara de pocker por no saber qué carajo significa cada término. Arranque completo (arranque en caliente) La elaboración del programa comienza de nuevo. Se mantienen los datos remanentes. Arranque en frío Los datos actuales se pierden y la elaboración del programa comienza de nuevo con los valores iniciales. Rearranque Tras la vuelta de la alimentación, el programa sigue desde el punto interrumpido. 25 Cómo programar Step 7 y no morir en el intento 3 métodos de arranque en Step7 OB100 para el arranque completo En nuevo arranque (arranque en caliente), el programa comienza desde el principio: Las marcas, temporizadores etc. no remanentes se resetean. Los módulos de datos con la propiedad no remanente, toman de nuevo el valor inicial. Las variables remanentes se mantienen con el último valor juntos. Los módulos remanentes mantienen el último valor. OB102 para el arranque en frío En el arranque en frío, los módulos de datos creados por SFC se borran de la memoria de trabajo, el resto de módulos de datos tienen el valor pre ajustado en la memoria de carga. La imagen de proceso, los temporizadores, los contadores y las marcas se resetean a los valores iniciales guardados en el programa (memoria de carga), independientemente de si se han parametrizado como remanentes. Se lee la imagen de proceso de las entradas y el programa de usuario de STEP 7 comienza de nuevo desde el principio (OB 102 ó OB 1). Una cosa que hay que tener en cuenta, es que este modo sólo se puede realizar desde el PG salvo algunas CPU de la serie 400 que tienen interruptores que permiten hacerlo sobre el propio PLC. OB101 rearranque Tras la vuelta de un corte de tensión las CPU de la serie 400 realizan un rearranque. Este se realiza desde el punto en el que se interrumpió. Esto implica que las variables, temporizadores etc. no se resetean. En definitiva: Todos los datos mantienen su último valor válido (incluyendo los datos de la imagen de proceso). La elaboración del programa continúa exactamente en la instrucción en la que se produjo la interrupción. Las salidas no se modifican hasta el final del ciclo actual. Al interrumpir la tensión de alimentación, el rearranque sólo está disponible en el modo de servicio con batería tampón. Programación del OB100 He de decir que el más utilizado es el OB100, compatible con todas las CPU. Además tampoco he tenido la necesidad de programar el resto. Aunque supongo que habrá casos en los que sean necesarios. 26 Cómo programar Step 7 y no morir en el intento El uso que se le da al OB100 es fundamentalmente para dar valores iniciales a variables cuando arrancas desde cero el PLC y para ejecutar acciones que sólo son necesarias ejecutar una vez. Una cosa que puede valer por ejemplo, es hacer que una variable se ponga a TRUE que será un trigger a lo largo del programa y que al terminar, resetees dicha variable para que no se ejecute en el segunda y sucesivas ejecuciones del OB1. Así, dentro del OB100 podemos hacer SET = M0.0 Y al final del OB1 CLR = M0.0 Si necesitas más información, te dejo las referencias para que sigas leyendo sobre el tema. Referencias: http://cache.automation.siemens.com/dnl/jExNDU0NwAA_18652056_HB/S7prv 54_s.pdf Diferencias entre tipos de arranque 27 Cómo programar Step 7 y no morir en el intento 3. El entorno de desarrollo de Step 7 Todo lenguaje de programación tiene un entorno de desarrollo. El entorno de desarrollo de Step 7 se divide en varias partes: Simatic Manager. Configurador del hardware Configurador de Red Editor de programación Editor de símbolos El núcleo desde el que normalmente se llama a todos los demás es el Simatic Manager aunque se pueden acceder y lanzar los programas por separado desde la carpeta de Simatic dentro de los programas disponibles en tu PC. Vamos a ver como es el entorno de un modo general ya que no te interesa ni a ti ni a mi profundizar en estos momentos. Pienso que si no conoces bien Simatic ni Step 7 te puedo aburrir dándote un montón de detalles que te van a sonar a chino y que realmente no vas a necesitar de momento. Por tanto veremos un barniz de lo que es el entorno de desarrollo en Step 7 y nada más. Finalmente terminaremos creando una vez conozcamos estas generalidades nuestro primer proyecto en Step 7sobre el que trabajaremos en capítulos posteriores. El entorno de desarrollo de Step 7 Simatic Manager 28 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 Nuestro primer proyecto en Step 7 “HELLO WORLD!!” 31 Cómo programar Step 7 y no morir en el intento 4. Álgebra booleana (lógica binaria) Bueno. Basta de ver vídeos donde se explican muchas cosas bastante aburridas y aún sin programar ni una línea de código... el álgebra booleana en Step 7 is here. Vamos a comenzar a teclear. No mucho, pero vamos a realizar nuestros primeros pinitos. Primero vamos a empezar a programar en Ladder, escalera o KOP. Es una forma dinámica de empezar a hacer cositas y nos va a servir para la en siguientes capítulos ver sobre lo aprendido, cómo se haría en AWL ya que se va a entender creo que mejor. ¿Qué es el Álgebra booleana en Step 7? Bueno, en Step 7 y en cualquier lenguaje. No se trata más que de entender y poner en práctica el álgebra de Boole. No te voy a aburrir sobre que es un OR y un AND, ya que entiendo que todo el mundo sabe qué es. Si no lo sabes, échale un vistazo a: Algebra de Boole (Wikipedia) Algebra booleana (Monografías.com) Álgebra de Boole (uhu.es) En definitiva, qué mejor para un PLC que se mueve con ceros y unos, que programar en base a puertas OR, AND y NOT. ¿No hay más? Estrictamente hablando no, ya que el resto de las operaciones binarias se basan en las anteriores... son, por así decirlo, los colores primarios del álgebra de Boole. Por cierto, el señor tan estirado y con pinta de listo es el señor George Boole, el padre de la criatura la cual data de mediados del siglo XIX. Sí, no les servía para gran cosa entonces, pero ya le daban al rosco por entonces a estas cosas. Como construir todos nuestros programas a base de AND y OR sería un trabajo que acabaría con la salud de más de uno (entre los que me incluyo) hay otros operadores más elaborados que permiten realizar funciones más complejas como son el xor, set, 32 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... La programación en escalera o ladder es la más común en la mayoría de los lenguajes de programación de PLC. En el caso de Siemens, esta programación se llama KOP (Kontaktplan) o diagrama de contactos en la lengua de Cervantes. La idea básica es dibujar diagramas eléctricos como si con contactos de relés se tratara. ¿Cómo se hace un AND y un OR? Básicamente un AND lo harás mediante dos contactos en serie de tal forma que sólo se active la bobina si ambos contactos están cerrados. Análogamente un OR lo realizarás colocando dos contactos en paralelo de tal forma que la bobina se active si uno de los contactos O el otro se activa. ¿Brillante eh? Pero, lo mejor como siempre es ver... Contactos en serie y paralelo, negaciones, set/reset y pulsos en un bonito video donde veamos cómo usar todos los elementos además de un pequeño ejemplo de cómo crear un telerruptor en Step 7. 33 Cómo programar Step 7 y no morir en el intento 5. Puertas lógicas NOR y NAND en S7 NAND Una puerta lógica NAND no es más que hacer un AND normal y su resultado, darle la vuelta (negarlo) La fórmula, es la que tienes a la derecha, que lo que viene a decir es que la negada de un AND es lo mismo que hacer un OR de las negadas. Es decir U M200.0 U M300.0 NOT = M400.0 Es lo mismo que hacer ON M200.0 ON M300.0 = M400.0 En resumen, que el resultado siempre será TRUE salvo que ambas marcas (M200.0 y M300.0) estén a 1. NOR Análogamente, diremos que hacer un NOR no es más que hacer un OR, y su resultado darle la vuelta (negarlo). Como veis en la fórmula, es muy similar. La negada de la suma es igual al producto de sus negadas… o en castellano de andar por casa, un NOR equivale a hacer un AND de las negadas de las señales. 34 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 6. FB en Step 7 - Ejemplo de una bomba de agua Para ir creciendo un poco más en la lógica binaria antes de entrar en lógica binaria en AWL, vamos a ver un par de ejemplos después de haber visto los primeros fundamentos con el álgebra de Boole. El primero será crear FB en Step 7 y el siguiente será crear FC. La idea es ir introduciendo conceptos nuevos, y no se puede programar en Step 7 si no se conocen los FB y los FC. FB en Step 7 Comenzamos con los FB. Son más completos que los FC ya que como vamos a ver, van a tener remanencia a diferencia de los FC que nos servirán para otros menesteres como veremos pronto. Como ya dijimos en la introducción los FB no son más que unos bloques que nosotros vamos a construir y que va a poder tener una serie de variables (ninguna de ellas obligatoria): Variables de entrada Variables de salida Variables de entrada/salida Variables temporales Variables estáticas (remanentes) Como bien digo, no es obligatorio el uso de ninguna de ellas ya que se puede hacer la llamada al FB y dentro de este usar variables globales (marcas u otros DBs). Lo único que es obligatorio es crear un DB de instancia asociado al FB. Este DB nos servirá para almacenar la información remanente aunque veremos que todas las variables quedan reflejadas en él (todas las que se declaren, claro). No hay que declarar ninguna variable dentro del DB ya que Step 7 lo va a hacer por ti a la hora de hacer la llamada o al crearlo desde el Simatic Manager. Ejemplo de maniobra de una Bomba de agua Para ver cómo crear FB en Step 7 de forma práctica vamos a hacerlo a través de un ejemplo de manejo de una bomba de agua. Se trata de un tanque que tiene un mínimo y un máximo que es abastecido entre estos límites a través de una bomba. Esta bomba toma el agua de una fuente sin determinar y que no viene al caso. 36 Cómo programar Step 7 y no morir en el intento La cuestión es que hay que hacer: A través de una maneta de OFF/ON, poner el sistema en posibilidad de trabajar. Cuando se pasa al estado ON, la máquina se pone en modo manual. El modo manual es simple. Si se activa el botón de marcha de la bomba, esta bombea sin límites. Si se vuelve a pulsar se para. El modo automático se pone cuando se pulsa el botón de auto/man. Tras pasar a auto hay que pulsar el botón de marcha de la bomba y esta trabajará entre el mínimo y el máximo. Cuando pierde el mínimo se activa y cuando llega al máximo se para. Si se vuelve a pulsar el botón de auto/man se pasa de nuevo a manual y la bomba se para. Hay una serie de leds para indicar los estados de auto, manual, marcha y paro de la bomba. Para visualizar todo esto mejor, te he preparado un vídeo donde se explica el ejercicio (sin solución). 37 Cómo programar Step 7 y no morir en el intento Resolución del ejercicio En el siguiente vídeo puedes ver la resolución del ejercicio. 38 Cómo programar Step 7 y no morir en el intento 7. Multiinstancias en Step 7 ¿Qué son multiinstancias en Step 7? Empezaremos definiendo qué es una instancia en programación. De Step 7 o de Visual Basic. Eso es lo de menos. El vocablo instancia proviene de la programación orientada a objetos y de las clases. Sin meterme en berenjenales que no domino es mejor explicarlo mediante un ejemplo: Una clase podríamos definirla como el concepto fantasma del Pacman con todas sus cualidades, propiedades y funcionalidades. Una instancia sería uno de los fantasmas en concreto sin tener en cuenta el color. Al pertenecer a la clase fantasma, tendrán las mismas propiedades y funcionalidades entre ellos, pero no los mismos valores en cada uno de los campos, por así decirlo. Así por ejemplo pueden tener diferente color pero siguen perteneciendo a la misma clase. Llevándolo a nuestro campo, crear multiinstancias en Step 7 va a ser crear nuevos objetos que hagan referencia a la clase a la que pertenecen. Así, la clase puede ser TON (un temporizador IEC como retardo a la conexión) y lo que haremos será crear tantas instancias de ese TON como necesitemos. Es decir, crearemos esos temporizadores de verdad dentro de nuestros FB. Como la creación de estos TON puede ser múltiple o conjugada con la creación de otras instancias diferentes, se denominarán multiinstancia. Mucho rollo esto de las multiinstancias en Step 7 ¿no? Bueno. Si lo resumimos y no nos andamos con tantas tonterías... multiinstancia en Step 7 es que puedes incrustar en las variables STAT de un FB otros FB más pequeños como por ejemplo el TON o TOF de los que hemos hablado. ¿A que ahora lo has entendido a la primera? Seguro que sí. Como vas a ver a continuación, lo más típico es incrustar instancias de temporizadores IEC. Digo lo típico por veces que sucede esto respecto a otro tipo de instancias, no porque no se puedan hacer de otro tipo. 39 Cómo programar Step 7 y no morir en el intento Video sobre multiinstancias en Step 7 Como siempre, lo mejor es verlo en un vídeo porque es como mejor se va a entender el concepto que es sencillo pero hay que haberlo visto antes. 40 Cómo programar Step 7 y no morir en el intento 8. Funciones en PLC Siemens con ejemplo de semáforo ¿Qué son los FC en Step 7? Las funciones en PLC Siemens son similares a las funciones en otros lenguajes de programación. En los FC en Step 7 se hace la llamada con unas variables de entrada y tras su ejecución nos devuelve unos valores para las variables de salida. Nada nuevo en el firmamento. Pero los FC en Step 7 no se usan exclusivamente para calcular una salida, sino para la organización del programa dentro del proyecto. Es decir, se realizarán llamadas a los FC sin valores de entrada ni valores de salida si bien adicionalmente puede que se usen las variables temporales para uso interno dentro del FC. FC Vs. FB El FC en Step 7 en general se usa más que los FB por par de razones: no necesita asociar un DB (y por tanto ahorras memoria y es más limpio el programa) y no siempre es necesario la re-utilización del código. Si es necesario almacenar datos, podemos hacerlo en marcas o en DB globales. Por tanto, los FC en Step 7 no presentan grandes desventajas frente a los FB más allá que los FB son para una programación orientada a objetos, en los que el bloque FB represente un objeto genérico (por ejemplo, un transportador o un variador) y se pueda reutilizar ese bloque infinidad de veces a lo largo del programa con la peculiaridad de necesitar almacenar datos de esos objetos. En este caso, sí que el FB es más indicado que el FC. Muy bien, pero ¿qué vamos a ver en este capítulo? Evidentemente algo tenemos que hacer porque definir un poco lo que hace un FC de poco o nada sirve si no avanzamos en el conocimiento de las funcionalidades de los PLC de Siemens, que es de lo que se trata. Como habrás visto en el título vamos a realizar un ejemplo de semáforo en Step 7. Normalmente este programa es de los primeros que se hacen con temporizadores… pero ya haremos otros ejemplos cuando veamos los temporizadores de S7. Lo vamos a hacer mediante una función y contando tiempo, que también sabe muy bien el PLC. 41 Cómo programar Step 7 y no morir en el intento ¿En qué va a consistir el ejemplo del semáforo? Básicamente vamos a tener un semáforo para los vehículos rodados el cual va a tener sus tres colores (rojo, verde y ámbar) y otro para los peatones de color rojo y verde. Además, el verde parpadeará cuando se vaya a acabar el tiempo en verde y tendrá un botón de solicitud que si es pulsado, cambiará a verde para los peatones previo paso del asociado a los vehículos por el amarillo. La pulsación del botón hará que se ilumine el letrero de solicitud que se mantendrá iluminado hasta que se ponga en verde para el peatón. ¿Qué herramientas vamos a necesitar para crear este FC en Step 7? Para realizar este ejemplo vamos a ver algunos conceptos nuevos en Step 7 como son: Comparación Transferencia Conversión Marcas de ciclo Durante las explicaciones del vídeo vas a poder ver cómo usar estos elementos en nuestro ejemplo de FC en Step 7, que como verás es casi trivial. El único que tiene un poco más de miga es el de conversión ya que sirve para tomar una variable y pasarla a otra variable de otro formato. Me explico. No es lo mismo tener un “-2″ en entero, que un “-2″ en doble entero, lo mismo que no es que tener un “-2″ en real. Para empezar, porque en entero ocupa un Word mientras que en doble entero y en real ocupan 4 bytes (doble Word). Para continuar, porque en real, no tienes un “-2″, sino que tienes un “-2.0″, que es igual, pero no es lo mismo que dirían Martes y Trece. Cada tipo de variable además de ocupar una serie de bytes, (2, 4 o los que sean) tienen un formato en particular (hay que poner la mantisa, el signo etc.), por lo que para poder hacer operaciones matemáticas entre dos variables, tienen que estar en el mismo formato ya que si no, pueden pasar dos cosas: En FUP o KOP no te dejará realizar la operación matemática ya que no son variables con el mismo formato. En AWL sí que podrás, pero la que puedes montar con el PLC si no lo haces bien la recordarás durante tiempo. Como nosotros estamos empezando y estamos programando nuestro PLC en KOP, no vamos a poder cometer errores a la hora de sumar, ya que el propio Step 7, no nos lo va a permitir. Finalmente, sobre la marca de ciclo puedes encontrar más información además de en el vídeo en 3 formas de crear marcas cíclicas en Step 7 del capítulo siguiente. 42 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 9. FC o FB ¿Cuál de los dos usar? Cuando empiezas a programar tal vez te surja una duda cuasi existencial… ¿Qué es mejor usar? ¿FC o FB?… pues básicamente, depende. En general con ambos se pueden hacer lo mismo. Cambia la forma. Pero digamos que no están pensados para lo mismo. Los FC serán ideales para generar resultados que no tengamos que almacenar. Dentro de la automatización lo usaremos en la lógica general de los programas. Pueden ser usados en líneas generales de actuación de las máquinas, secuencias e interrelación entre ellas. Los FB son como los FC, pero vitaminados. No solamente podremos hacer lo que hacemos con los FC sino que además podremos almacenar valores ya que tienen asociados DB. Además podremos usar los temporizadores IEC de forma muy sencilla evitando complicarnos con los temporizadores de S5 para nuestros propósitos. Serán adecuados para el manejo de motores, variadores etc. ya que podremos juntar similares funcionalidades bajo el mismo FB usando DB para cada uno de ellos. FC o FB Está claro entonces… uso FB siempre y ya está. Esta es la conclusión a la que fácilmente podrías llegar tras lo expuesto. Antes de dar este paso hay que tener en cuenta que los FB siempre han de tener un DB asociado. Eso en sí mismo no es un problema, pero puede serlo si el programa es extenso y has de tener muchas funciones para una correcta organización del programa. El uso innecesario de FB hacen que se ocupe memoria de forma innecesaria ya que generarás un DB lo necesites o no. Si todo lo haces con FB, y el proyecto es suficientemente complejo, tendrás un sinfín de DB. Hay que elegir por tanto los FB en general cuando: El FB controle un actuador o motor y tengas varios del mismo tipo de tal forma que puedas reutilizar el FB no necesitando usar marcas. Esto hace que sea más fácil de mantener y más difícil de cometer errores ya que no necesitarás tener en cuenta qué marcas están usadas y cuáles no. Necesitas guardar datos de forma permanente. Qué mejor hacerlo a través de un FB ya que así tienes un DB asociado donde guardar estos datos. Si vas a usar el FB con diferentes motores por ejemplo, y necesitas temporizadores. Puedes usar los temporizadores IEC y usarlos como multiinstancias. ¿Cuándo usaremos los FC entonces? Para planteamientos generales de las aplicaciones, o para actuadores que no necesiten ser reutilizados. 44 Cómo programar Step 7 y no morir en el intento Funciones aritméticas, trigonométricas o de otra índole que no necesiten almacenar los datos y que simplemente nos devuelva un valor o que se utilicen marcas globales. En definitiva, habrá que evaluar cada caso para saber qué usar. Por lo general personalmente uso más los FC que FB, pero dependerá del proyecto en concreto. Para finalizar adjunto un video en el cual presento las diferencias entre los FB y los FC en ejemplos muy sencillos: un sumador, un totalizador de tiempo y el uso de temporizadores. Ahí quiero mostrarte las diferencias entre ambos para que puedas intuir con más facilidad cuál es el concepto para cada caso. 45 Cómo programar Step 7 y no morir en el intento 10. Cómo crear la estructura de un programa en ladder La programación en ladder es sin duda la programación de autómatas programables más extendida, incluidos los PLC Siemens. Esta entrada va a ser más de estilo de programación que de herramientas disponibles dentro de step 7. Hay muchos programadores que son defensores y enamorados de Grafcet. A mí personalmente como programador y mantenedor de las instalaciones no me gusta. Puede ser que por desconocimiento, por falta de uso ya que trabajo con ello pero muy muy poco, o por una manía personal. La cuestión es que para el grado de automatización en el que me muevo dentro de este sector de la automoción no he encontrado aún una razón por la que usar Grafcet ya que con un ladder bien estructurado es más que suficiente. ¿Qué ventajas tiene una programación en ladder para estructurar un programa en Step 7? Es universal. Lo va a entender todo el mundo y todo es estándar con la programación de escalera normal. No necesita un software especial de pago como es Grafcet. A mi juicio más fácil de seguir si está bien estructurado. Muy compacto. Más que los diagramas de bloques, por ejemplo. ¿Cómo funciona este tipo de programación en ladder? Lo primero que he de decir es que todo esto entra dentro de la forma de programar de cada uno. Yo te voy a contar esta forma, que la puedes adaptar, copiar literalmente o crear una nueva desde cero. Es una forma de hacerlo, nada más. No es palabra de Dios, ni mucho menos. Básicamente la idea es coger tu máquina y dividirla en movimientos lo más sencillos posibles pero que tengan una entidad suficiente como para ser merecedor de dedicarle un par de FC sólo para él. Nada nuevo. Lo siguiente es asignar una palabra o una doble palabra para este FC. Finalmente la idea es establecer unas condiciones iniciales de arranque de la secuencia. Cuando se cumpla, haremos un SET del primer bit. Imaginemos la M0.0. Esto arrancaría la secuencia. Una vez iniciada esta M0.0 realizará una acción simple. Cuando se cumpla la acción asociada y las condiciones de control de esta M0.0, haremos un SET de la M0.1 y haremos un RESET de M0.0. 46 Cómo programar Step 7 y no morir en el intento Sucesivamente, con las condiciones del siguiente estado, activaremos la M0.2 y resetearemos el M0.1 y así sucesivamente. Ahora bien, para que este sistema funcione bien, sea claro y no se complique más de lo necesario la programación en ladder, las condiciones deben estar lo más resumidas posibles (usando variables intermedias) y no se deben activar las salidas. Para ello vamos a dividir esta parte de la automatización en dos: Un FC para la lógica explicada y las condiciones de inicio/finalización de los segmentos Un FC/FB para las salidas de los actuadores con una pequeña lógica de la parte auto con la de manual. 47 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 Como siempre, te dejo con un vídeo explicativo donde se ve mejor lo ya comentado. 48 Cómo programar Step 7 y no morir en el intento 11. Formas de crear marcas cíclicas en Step 7 En este capítulo vamos a ver formas fáciles para crear marcas cíclicas que luego podamos usar a lo largo y ancho de nuestro programa. Así podremos usar: Las marcas de ciclo Temporizadores Crear la marca en OB cíclicos Como digo la idea es que podamos hacer llamadas o acciones a tiempos fijos. Normalmente, y si necesitamos una precisión alta, tendremos que realizar la acción o llamadas desde OB cíclicos cuya frecuencia habremos fijado de antemano al configurar el HW. Pero no es la única forma de realizar acciones a tiempos fijos. Claro que tiempos fijos, más o menos, porque lo que te voy a mostrar a continuación es para ser usado desde el OB1 o FC/FB que dependan del OB1 y por tanto el error que vamos a introducir es del orden del tiempo de ciclo total del PLC. Esto implica que si queremos flancos cíclicos a tiempos de 100ms, no uses jamás el OB1 ya que el error que estás cometiendo el del orden de magnitud que la periodicidad deseada, es decir, si quieres tiempos fijos y la llamada es del OB1 cuyo tiempo de ciclo varía entre 10 y 30ms, pues hombre, menos preciso, es cualquier cosa. Ahora bien, si tus marcas cíclicas van a ser del orden de segundos, la cosa cambia ya que el error que vas a cometer es pequeño. En cualquier caso, usaras este tiempo de marcas cíclicas en acciones en el que la precisión no sea crucial. Creo que está claro el concepto. Marcas cíclicas del PLC Haciendo un corta y pega de la ayuda de Siemens, esta dice lo siguiente sobre las marcas de ciclo: Las marcas de ciclo son marcas que cambian periódicamente su valor binario (relación impulso – pausa: 1:1) ¿A que ahora te has quedado más tranquilo? Yo también. Afortunadamente, tiene una segunda ayuda en la cual muestra una tabla con los periodos de estas marcas. 49 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? Configurándolo desde el configurador de hardware. Tendrás que abrir el configurador de HW, abrir la CPU e ir a la pestaña de Ciclo /Marca de ciclo. Abajo tienes que seleccionar el checkbox de marca y seleccionar el número de marca que quieres usar. Ojo porque es un byte, no un Word. Tenlo en cuenta. Hay 8 marcas de ciclo. 50 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: Siempre que empieces un proyecto en Step 7, selecciona y configura un byte para tu marca de ciclo No cuesta nada, y así no tendrás el pequeño inconveniente de que cuando lo quieras usar, pues no podrás porque la máquina estará en marcha y no la puedes parar hasta dentro de no sé cuántos millones de horas… y todo por no haber elegido una marca cuando configuraste el hardware. ¿Adivinas a quién le ha podido pasar algo así alguna vez? Pues eso. Marcas cíclicas usando temporizadores Otra forma común de realizar ondas cuadradas es con dos temporizadores. La forma de construirlo es muy sencillo como muestra en la imagen. Ambos temporizadores se irán alternando en el contaje del segundo. El temporizador T2 tendrá un periodo de 1s su salida a cero y un periodo de su salida a 1. El T1 por su parte estará siempre a cero salvo un instante (un ciclo de scan) que será el desencadenante de tirar el T2 y que vuelva a empezar. Así, haciendo la lectura del T2, tendremos una marca cíclica de periodo 1segundo en este caso. La ventaja de este, es que se puede variar la relación de tiempo ON/OFF jugando con los tiempos del T1 y del T2. Marcas cíclicas usando un OB cíclico Una forma de crear una marca cíclica es usar un OB cíclico. Imaginemos que queremos cada 0,5 segundos. Cargaremos un OB cíclico que fijaremos a 500ms. Luego haremos un súper código. Imaginemos que queremos hacerlo con la M50.0: UN M50.0 51 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 Teniendo OB cíclicos, ¿no hay más formas? Pues hombre, sí. Por ejemplo, creando contadores de 1 a 10 en el OB35 y si está fijado a 100ms por ejemplo, poniendo a uno una marca cuando el contador sea superior o igual a 5 y reseteando cuando sea igual o superior a 10. Bueno, como ves hay muchas formas de crear marcas cíclicas. Espero que te haya sido de utilidad y que lo uses mucho en tus proyectos. 53 Cómo programar Step 7 y no morir en el intento 12. Algebra booleana (II) – AWL en Step 7 ¿Recuerdas al señor de la izquierda? Lo vimos en el capítulo de álgebra de Boole. Hoy vamos a ver un poco de lógica binaria de AWL en Step 7. Sí. Antes de ver los temporizadores. ¿Por qué antes? Pues porque cuando veamos los temporizadores, habrá que verlos también en AWL y hombre, no quiero que te dé un derrame cerebral así de primeras. Pero lo veremos enseguida. AWL en Step 7 Deberíamos empezar por ver qué es el AWL. El AWL no es más que uno de los tres lenguajes básicos de Step 7. Es la mamá de todos los lenguajes en Step 7. Todos finalmente se van a traducir a AWL y todo aquello que no se pueda programar en AWL es que simplemente no lo vas a poder programar. Otra cosa es los sudores que te costaría hacer directamente en AWL tareas complejas, pero por poder, se podría. Con AWL en Step 7 se pueden hacer auténticas filigranas ahorrando código a más no poder. Digamos que es la forma de programar más compacta de todas (en general). Si hiciéramos una comparación con otros lenguajes, tendríamos lenguajes de alto nivel como el Pascal (SCL en nuestro caso) y luego tendríamos lenguajes de bajo nivel como Ensamblador, que en nuestro caso sería el AWL. Puede que la comparación no sea lo más acertada del mundo, pero suficientemente buena a mi juicio para que te hagas una idea. ¿Ensamblador? Ya me estas asustando… No te asustes, que no es para tanto. Digo que es similar a ensamblador en el sentido de que es un lenguaje básico, con instrucciones primarias que se ejecutan “a pelo” le pongas lo que le pongas por delante. Por poner un ejemplo. Ya hemos dicho con anterioridad que no puedes comparar en FUP y en KOP valores enteros con reales, por poner un ejemplo. En AWL sí se puede. 54 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: El AWL es el lenguaje base del resto. Todo es traducible a AWL, pero no al revés. La primera parte creo que ha quedado clara. La segunda, la vas a ver clara enseguida. Los lenguajes FUP y KOP cuando lo traduces a AWL crean instrucciones que a veces son inservibles de cara a la ejecución del programa pero necesarios para la propia integridad del lenguaje FUP y KOP. Necesitan de esas instrucciones para dar consistencia a lo que estás dibujando y de ahí que creen líneas que en principio no serían necesarias para un funcionamiento idéntico realizando el programa directamente en AWL. El problema está que si realizas el programa en AWL directamente, si quieres traducirlo a KOP, por decir uno, el editor no va a tener la capacidad de entender qué diantre quieres hacer. Y por tanto, no podrá traducirlo. Por tanto siempre podrás traducir FUP y KOP a AWL (más o menos depurado) pero en general, no podrás traducir código AWL a FUP y a KOP. Es así. Asúmelo. Así que empecemos con las cosas básicas que debes tener claras antes de empezar a programar en AWL. Instrucciones básicas para programar AWL en Step 7 Las instrucciones básicas van a ser: U para hacer un AND O para hacer un OR X para hacer una O exclusiva = para igualación ¿No hay negadas? Veo que estás despierto. Efectivamente. También tendremos: UN para hacer un AND negado ON para hacer un OR negado XN para hacer una O exclusiva negada. Luego lógicamente tendremos paréntesis (). Pero eso más tarde. 55 Cómo programar Step 7 y no morir en el intento ¿No hay más? Sí que hay más. El Set, Reset, flancos… pero de momento, quédate con los básicos que son los de ahí arriba. Operaciones de Y lógica. Esto lo vas a pillar enseguida verás. Imagina que tienes dos entradas que cuando están las dos a true (1), tenemos que activar una salida. La lógica sería así: U E 0.0 U E 0.1 = A 1.0 Es decir, iniciamos el segmento leyendo lo que hay en el E0.0 y le hacemos un AND con el E0.1 y su resultado se lo asignamos a la salida A1.0. O de otra forma, cargamos el E0.0 en el RLO y luego hacemos un AND de la E0.1 con el RLO y se lo asignamos a la A1.0 Ya bien, pero estooo, una cosita que te quería comentar… ¿Qué es el RLO? ¿Siglas chulas eh? ¿De alguna organización? Pues no. El RLO no es más que una variable que almacena el valor de una operación binaria. Es especialmente relevante en la programación de AWL en Step 7. La definición ha quedado chulísima pero no he entendido ni papa. A ver. En el ejemplo de la Y lógica hemos visto primero una U E0.0 Bien. Como hemos dicho que la U es un AND con lo que tenga el RLO (V ó F). Como no hay operación previa, entonces lo que hace es leer el valor de la E0.0 y la transfiere al RLO. Imaginemos que tiene un cero. Luego el RLO valdrá cero. Luego imaginemos que la E0.1 está a uno y hace un U E0.1 Es decir, hace un AND con lo que tenga el RLO tras haber ejecutado la operación anterior. La E0.1 está a uno, pero el RLO está a cero, luego el resultado nuevo será cero y se lo cargará nuevamente al RLO. = A1.0 Finalmente, toma el valor del RLO y se lo transfiere a la A1.0 Imaginemos que ambas señales estuvieran a uno. 56 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 Y eso estaría bien. Pero la forma más mejó sería haciendo: O E0.0 O E0.1 = A1.0 ¿Por qué? Lógicamente hacen lo mismo. Pero me gusta más hacerlo así porque de hecho, cuando traduces un OR de KOP a AWL así lo representa. Mejor que escribamos todos de la misma manera ¿no? Bueno, al grano. ¿Adivinas como actuaría no? Inicialmente haría un: U E0.0 // O E0.0 Como en el caso anterior leería el estado del E0.0 y lo volcaría en el RLO (imaginemos un cero). Luego un: O E0.1 Y aquí haría un OR con el RLO. Imaginemos que el E0.1 estuviera a uno. El resultado del OR sería un bonito uno. = A1.0 E igualamos el uno a la salida A1.0. ¿Sencillo no? Vayamos ahora con los paréntesis. 57 Cómo programar Step 7 y no morir en el intento Paréntesis en AWL en Step 7 Como puedes imaginar, en cuanto queramos realizar combinaciones un poco más elaboradas necesitaremos paréntesis para poder realizar estas lógicas. Así, dispondremos de las siguientes operaciones: U( ..) //UN(..) que valdrá para realizar un (N)AND con el contenido interior al paréntesis O(..) // ON(..) que valdrá para realizar un (N)OR con el contenido interior del paréntesis. X(..) // XN(..) que valdrá para realizar una (N)XOR con el contenido interior del paréntesis En definitiva en lo que se basa es en realizar la combinatoria interior del paréntesis y luego ejecutar la operación asociada al paréntesis. Los paréntesis pueden anidarse metiendo paréntesis dentro de otros paréntesis. Así, podríamos hacer algo similar a lo anteriores ejemplos: U( U E0.0 O E0.1 ) O( U E0.2 U E0.3 ) = A1.0 En este caso primero resolvería la combinatoria interior de los paréntesis por separado y luego realizaría el OR entre el resultado de los paréntesis. Hay que añadir que el caso del OR es un poco especial ya que si dentro del paréntesis del OR la combinatoria es de AND exclusivamente, el paréntesis se podría haber obviado quedando esa parte así: O U E0.2 U E0.3 Y funcionaría exactamente igual. 58 Cómo programar Step 7 y no morir en el intento Operandos de cierre de consulta A estas alturas de la película te estarás preguntando… si los resultados de la combinatoria se van almacenando en el RLO, ¿qué pasa después de una igualación si quiero empezar a realizar una nueva combinatoria? Pues efectivamente después de los operandos: Igualación (=) Set (S) Reset (R) Con esos operandos, se cierra la consulta actual y se abre una nueva (además del inicio del programa). Da igual por tanto lo siguiente que hagas (U, O, UN…) porque lo que se hará es una lectura del operando en el RLO. Es decir, si la siguiente a una igualación es … = A1.0 UN E1.0 U E1.1 = A1.2 Lo que hará es leer el estado de la E1.0, le cambiará el signo y lo cargará en el RLO. No hará un NAND con nadie. Simplemente realizará la carga en el RLO. Ojo. Un cambio de segmento no es un inicio de programa. Por tanto si la última instrucción de un segmento es la lectura de un bit haciendo un U E0.7, este afecta al siguiente segmento. A efectos prácticos es como si lo hubieras escrito al principio del nuevo segmento. Finalmente vamos a ver un vídeo como siempre, explicando lo visto hasta ahora. 59 Cómo programar Step 7 y no morir en el intento 13. Step 7… AWL, FUP o KOP ¿Cuál elijo? Antes de responder a la pregunta de qué lenguaje escoger en Step 7, repasemos un poco de qué lenguajes disponemos. FUP KOP AWL FUP Es un lenguaje de Step7 gráfico que utiliza los cuadros del álgebra booleana para representar la lógica. Asimismo, permite representar funciones complejas (p.ej. funciones matemáticas) mediante cuadros lógicos. Tiene la ventaja de ver agrupados por bloques las diferentes lógicas y tener bloques complejos. Cuando hay mucha lógica booleana en serie suele ser más compacto y más fácil de ver el segmento completo. KOP Es un esquema de contactos, escalera o ladder. Es un lenguaje de Step 7 gráfico y probablemente el más extendido en todos los lenguajes de programación y por tanto el más similar a otros. Probablemente es el más fácil de entender por personal proveniente de la industria eléctrica y técnicos eléctricos. En definitiva, es la representación que habría que cablear si se quisiera hacer el mismo programa que realizas con el PLC. 60 Cómo programar Step 7 y no morir en el intento AWL Es un lenguaje de programación textual orientado a la máquina. En un programa creado en AWL, las instrucciones equivalen en gran medida a los pasos con los que la CPU ejecuta el programa. Para facilitar la programación, AWL se ha ampliado con estructuras de lenguajes de alto nivel (tales como accesos estructurados a datos y parámetros de bloques). Es el más completo y el más complejo visualmente de seguir. Para instrucciones sencillas es muy útil pero cuando se quiere hacer una lógica un poco compleja el trabajo de seguimiento y de depuración es complicado y fácilmente susceptible de cometer errores. En su haber, si lo que necesitas no lo puedes programar en AWL, es que no se puede programar con ninguno de los 3. Por otra parte ambos lenguajes gráficos son traducibles a AWL, pero no al revés y no necesariamente entre ellos. Si bien normalmente KOP y FUP son traducibles entre sí, no siempre es así. Dependerá de la construcción del segmento en cuestión para que se pueda. Como se aprecia en el gráfico, todo lo que se programe en KOP y FUP puede ser programado en AWL. Pero no solamente no todo no será traducido entre el lenguaje gráfico y AWL, sino que además habrá procedimientos que sólo podamos realizarlos en AWL y en ningún caso en FUP o en KOP. Por ejemplo, el uso de punteros será exclusivo del lenguaje AWL. Es decir, AWL será el lenguaje universal dentro del Step 7 y el equivalente de programación en un PC sería como un lenguaje ensamblador (salvando las distancias, claro está). Respondiendo a la pregunta... ¿Cuál es el mejor? Pues ya siento que hayas leído hasta aquí porque no tengo una respuesta a ello. Depende. A título personal te diré que en mis inicios y por provenir del ámbito académico y de programación para PC, me gustaba más los diagramas de bloques (FUP). Hoy he de decir que sin duda me parece más práctico el lenguaje KOP ya que me permite visualizar más segmentos del código como norma general. 61 Cómo programar Step 7 y no morir en el intento El lenguaje AWL es totalmente necesario como ya veremos en su momento para multitud de tareas que sólo así se pueden hacer o porque, aunque parezca mentira, es más fácil de usar. Por tanto, puedes usar indistintamente cualquiera de ellos, si bien lo normal y lógico es usar uno de los lenguajes gráficos acompañado por AWL cuando no quede más remedio. 62 Cómo programar Step 7 y no morir en el intento 14. SET y RESET en AWL y alguna cosilla más. ¿Ya sólo nos queda ver SET y RESET en AWL en lógica binaria? Bueno, a decir verdad… no. Queda también ver los pulsos o flancos, además de cosas que afectan al RLO. Pero a decir verdad, poco más vamos a ver de momento. Tampoco se trata de pegarse un atracón de lógica booleana en AWL. Se trata fundamentalmente de entender muy bien que es el RLO, para qué sirve y cómo se utiliza. Si en estas dos lecciones aprendes a entenderlo podemos darnos por satisfecho. La destreza del uso de la lógica booleana la cogerás programando nuevos PLC de Siemens, por eso no te preocupes. ¿Qué es un set y reset en AWL? Buceando con el amigo Google, he encontrado la imagen de arriba. La verdad es que está muy bien para explicar lo que hace si no lo tienes aún claro. Un SET no es más que fijar a uno una variable booleana. Como la has fijado, esta variable seguirá a uno aun cuando las condiciones de ponerla a uno desaparezcan. Se diferencia de una igualación en que en esta, el resultado final es dependiente en todo momento de las condiciones para estar a uno o a cero. Mientras que las condiciones se cumplen la variable está a uno. Cuando una de las condiciones falla, la señal cae. Aquí no. Una vez dadas las condiciones la señal estará a uno indefinidamente… o hasta que se le haga un RESET. Y es que el RESET lo que hace es fijar a cero la variable. Como en el caso anterior, aunque las condiciones de reset desaparezcan, la señal seguirá a cero y no recobrará su estado de uno hasta un nuevo SET. ¿Qué pasa si se dan ambas condiciones, SET y RESET en AWL? Pues lo primero que habría que darte un capón por hacer un programa en el que el set y reset se den simultáneamente. ¿Puede darse ese caso? Por supuestísimo que sí. ¿Es grave? No conozco a nadie que haya enfermado de ello, pero mejor evitarlo. 63 Cómo programar Step 7 y no morir en el intento ¿Qué pasa si se da? La respuesta seguro que la sabes. Depende. ¿De qué depende? De según como se ejecute todo depende… (Léase a lo Pau Donés). Como bien sabes, si ambas condiciones se dan simultáneamente y seguidas una de otra, la que sobrevivirá del envite será la segunda. Ahora bien, si hay distancia en el programa, imaginemos el SET al principio del programa, el RESET a eso de la mitad, la cosa puede hacer cosas pintorescas ya que la variable entre el SET y el RESET estará a uno con lo que ello pueda conllevar en lo que haya en el programa entre estos dos puntos. A partir del RESET se pondrá a cero hasta el siguiente ciclo de scan que se volverá a poner a uno si las condiciones se mantienen. Tendríamos por tanto la variable la mitad del ciclo a uno y la otra mitad a cero… una fiesta. Por tanto, mejor evitar estas circunstancias y a ser posible, el set y el reset que estén seguidos siempre que sea posible. Por este posible problema y porque será más fácil de seguir el programa. ¿Esto sólo se puede dar en AWL? No. Ahora vamos a ver cómo se activan y se desactivan, pero lo dicho anteriormente vale para todos los lenguajes disponibles. Por tanto tendrás que tener cuidado con el Set y Reset en AWL, en FUP o en KOP ¿Qué pasa si mezclo Set, Reset e igualaciones? Espero que esto no se te haya pasado siquiera por la cabeza… cárcel directamente. Punto. Y sin galletas en el desayuno hasta nuevo aviso. Vale, vale… pero ¿qué hay del SET y RESET en AWL? Bien. Te lo voy a explicar con un ejemplo sencillo: O E0.0 O E0.1 S A 1.0 U E0.2 U E0.3 R A1.0 ¿Chupado no? Como bien imaginarás, la señal A1.0 se pondrá a uno, cuando el OR formado por la E0.0 y E0.1 dé como resultado un uno poniendo el RLO a uno. Igualmente, la A1.0 se podrá a cero, cuando el AND de la E0.2 y E0.3 se ponga a uno poniendo el RLO también a uno haciendo por tanto el reset. 64 Cómo programar Step 7 y no morir en el intento En definitiva, el Set y el Reset se ejecutarán forzando la marca o salida en una dirección u otra, cuando el RLO esté a uno y pasando olímpicamente del Set o Reset cuando el RLO esté a cero. ¿Fácil no? Forzado del RLO – SET y CLR Unas instrucciones muy interesantes son las de forzar el RLO, es decir, cargar en el RLO un cero o un uno de forma incondicional hasta que haya una nueva operación de combinatoria booleana: SET: Fijaremos con ello el RLO a uno CLR: Fijaremos con ello el RLO a cero Por ejemplo: U E0.1 U E0.2 SET = A1.0 ¿Cuánto valdrá A1.0? Pues efectivamente, la salida A1.0 estará forzada a uno ya que da igual lo que pase con la combinación de las dos entradas ya que luego se fuerza el RLO a uno y se iguala su valor a la A1.0 Flancos en AWL Finalmente vamos a ver los pulsos. Hay dos: Positivo (FP) Negativo (FN) Los pulsos como bien sabes son instrucciones que ponen el RLO a uno cuando se cumple el escalón de subida de cero a uno (el positivo) o que el RLO previo pase de uno a cero (el negativo). Necesitan una marca auxiliar que es la que almacena la información de cómo estaba el RLO en el ciclo anterior. Mejor con un ejemplo: U E0.0 FP M1.0 = A1.0 65 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 15. Función MOVE en Step 7 Este capítulo es sobre una función muy sencilla pero muy útil por lo que hay que conocer bien. Según la ayuda del propio Step 7 la función move hace lo siguiente: MOVE (Asignar un valor) es activada por la entrada de habilitación EN. El valor indicado por la entrada IN se copia en la dirección que la salida OUT. La salida de habilitación ENO tiene el mismo estado de señal que la entrada de habilitación EN. La operación MOVE sólo puede copiar los objetos de datos que tengan las longitudes de BYTE, WORD o de DWORD. Los tipos de datos de usuario tales como los arrays o las estructuras han de copiarse con SFC 20 „BLKMOV“. Entiendo que hasta aquí todos hemos llegado ya que sabemos leer. En resumidas cuentas, una transferencia: y viéndolo en AWL lo que hace es una lectura y L MW0 T MW2 Siendo la lectura según la ayuda de S7: L <operando> carga en el ACU 1 el contenido del byte, de la palabra o de la doble palabra direccionado, después de haberse almacenado el anterior contenido del ACU 1 en el ACU 2 y de haber puesto el ACU 1 a “0”. Y la transferencia: T <operando> transfiere (copia) el contenido del ACU 1 a la dirección de destino si está conectado el Master Control Relay (MCR = 1). Si el MCR es 0, en la dirección de destino se escribe el valor “0”. El número de bytes que se copia del ACU 1 dependerá del tamaño indicado en la dirección de destino. El ACU 1 también almacena los datos después de la operación de transferencia. La operación de transferencia a un área de periferia directa (área de memoria PA) también transfiere el contenido del ACU 1 ó “0” (si el MCR es 0) a la dirección correspondiente en la imagen del proceso de las salidas (área de memoria A). La operación se ejecuta sin tener en cuenta ni afectar a los bits de la palabra de estado. Vamos, que se explican como un libro cerrado. Así que aclaremos las cosas. 67 Cómo programar Step 7 y no morir en el intento MOVE en Step 7 (en cristiano) Si haces un MOVE entre cosas iguales (byte, Word, Dword) etc… es hacer una copia exacta del origen en el destino Si haces un MOVE entre cosas heterogéneas (de DINT a INT por ejemplo) has de andarte con pies de plomo. La primera parte está clara. Si tengo un real en un MD4 y hago un MOVE a MD8, pues simplemente he copiado su valor de uno a otro. ¿Ahora bien, y si hago un MD4 a MW10? Imaginemos que tenemos un DINT a INT… si os fijáis no hay una instrucción para pasar de doble entero a entero… ¿cómo lo hago? Pues simplemente haciendo un move (o una transferencia, que como digo, es la misma cosa): L MD4 T MW10 ¿Y ya está? Sí, pero con un pequeño matiz: El valor del MD4 tiene que “caber” en el MW10. Es decir, si tomamos un número mayor que el que nos entra en un MW, pues básicamente la estaremos liando parda. Es decir, si hago: L MD4 (siendo su contenido imaginemos 1000) T MW10 No habrá problema y el contenido del MW10 contendrá este 1000 Por lógica, no podremos cargar un valor que supere la capacidad del entero ya que si bien la transferencia se realizará, el MW10 no contendrá lo que tú esperas que contenga. La tabla que indica la ayuda es la siguiente: 68 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 Es básicamente lo mismo que hacer un: L MB13 T MB20 Ya que el resto de bytes (MB10, MB11 y MB12) como si no existieran ya que contengan lo que contengan, no los va a hacer ni caso. En cambio, al revés no es lo mismo: L MB20 T MD10 No es lo mismo que hacer un L MB20 T MB 13 Porque en el primer caso, copiará el contenido del MB20 en el MB13 y el resto de bytes (Mb10, 11 y 12) los rellenará con ceros. En el segundo caso, sólo copiamos el valor del MB20 en el MB13 y el resto contendrá lo que contenga sin variarlo, con lo que el valor del MD10 puede ser cualquier otra cosa. 69 Cómo programar Step 7 y no morir en el intento 16. Cómo usar los acumuladores en AWL Acumuladores en AWL Los acumuladores son dos: ACU 1 ACU 2 Ambos son dos áreas de memoria de 4 bytes (doble palabra) cada uno. Se usan fundamentalmente para realizar cálculos matemáticos y para transferir información de un área de memoria a otra (por ejemplo de marcas a zonas de DB, entradas, salidas…) La forma de trabajar básica con ellos son la lectura y la transferencia Lectura (L): Lees la marca, dw, pew o lo que sea y lo transfieres al ACU 1 Transferencia (T): Lees lo que tiene el ACU 1 y lo copias en la marca, paw, etc. Como ejemplo: L 67 -> Leemos el valor 67 y lo transferimos al ACU1 T MW 10 -> Leemos lo que tenga el ACU1 (en este caso un 67) y se lo transferimos a la marca MW10. ¿Sencillo no? Pero si los acumuladores en AWL son dos, ¿qué pasa con el ACU2? Bien. La idea de tener dos acumuladores es básicamente para realizar operaciones matemáticas (entre otras cosas que veremos a continuación). La forma en la que trabaja es en forma de pila, es decir: Cuando leemos algo y se lo transferimos al ACU1, previamente el PLC ha realizado la operación de transferir el ACU1 al ACU2. Posteriormente transfiere lo leído al ACU1. Imaginemos que queremos sumar dos valores enteros. Para ello actuaríamos de la siguiente manera: L 8 -> Cargamos el ACU1 en el ACU2 (nos da igual que tenga), y cargamos el 8 en el ACU1 L 7 -> Copiamos el ACU1 al ACU2 (el 8) y cargamos el 7 en el ACU1. +I -> Hace la suma entera entre el ACU1 y el ACU2 y el resultado lo transfiere al ACU 1 T MW 10 -> Copiamos el valor del ACU1 a la marca MW10 (15) 70 Cómo programar Step 7 y no morir en el intento ¿Qué tendrían entonces el ACU1 y el ACU2? ACU1 = 15 ACU2 = 8 Sí. 8. No 7 que es el último valor leído. Tras hacer la suma, ha transferido el valor de la suma al ACU1 (ha machacado el 7 con el 15). El acumulador 2 como veremos en el vídeo se pone a cero (aunque realmente poco o nada importa tenga ya que no lo vas a utilizar). ¿Qué más operaciones se pueden hacer? Como puedes intuir, además de sumar enteros, podrás restar, multiplicar, dividir, entre otras muchas operaciones en todas sus variantes: Enteros Dobles enteros Reales ¿Qué seguridades hay a la hora de realizar operaciones matemáticas? Pues así, como resumen, y para no alargarme demasiado: NINGUNA Como bien sabes en FUP o KOP, el editor del PLC no te deja realizar ideas felices como sumar un entero con un real, por mucho que te guste y lo intentes. En AWL sí vas a poder. Guay. Pues lo sumo en AWL. Pequeño saltamontes, he dicho que deja, no que el resultado sea el esperado. Es más, te daría resultados interesantes y variopintos para que estés entretenido durante unas cuantas horas como no te percates en el momento de la chapuza realizada. Imagina que sumas, haciendo ya el burro del todo: L L#50000 L 50000.0 +I T MW10 ¿Valor de MW10? Chupado: 50 mil más 50 mil, cien mil. Sí. Sí por lo coj… No sé ni lo que daría. Para empezar, porque 100 mil no se puede cargar en 16 bits. Como bien sabes, los enteros van desde -32767 a 32768. Para continuar, porque mezclar reales con doble enteros no pega ni con cola. 71 Cómo programar Step 7 y no morir en el intento Forma en que carga y se transfiere al ACU1 Para dejarlo aún más claro: el ACU1 tiene 4 bytes, lo que viene siendo dos palabras. Cuando tú transfieres un número entero positivo inferior a 256 (un byte), este se carga en el byte alto de la palabra alta. Es decir, en el byte 3 del ACU1. El resto de los bytes se ponen a cero. Cuando transfieres un entero más grande que no entra en 8 bits, (imaginemos 12345), este valor se carga en la palabra alta (bytes 3 y 4). Los bytes 1 y dos se ponen a cero. Finalmente cuando cargo un número real (el -1234,5), se usan los 4 bytes (si es pertinente) ¿Qué ocurre cuando lees el ACU1? Pues que depende de la variable sobre la que escribas. Si haces un T MB 8, pues estarás cogiendo el byte alto, de la palabra alta. Tenga lo que tenga el resto, sólo leerás el byte 3 del ACU1 y se lo transferirás al MB8. Si haces un T MW8, pues cogerás la palabra alta y se la transferirás al MW8. Finalmente si haces un T MD10, tomarás el valor completo del ACU1 y se lo transferirás al MD10. ¿Menudo lío no? Pues en realidad, no tanto. Si simplemente haces operaciones con variables coherentes entre sí (reales con reales, enteros con enteros), no te deberás preocupar qué es lo que se está cargando o transfiriendo en el ACU1, porque simplemente estará bien. Simplemente ten cuidado y no mezcles churras con merinas y todo irá bien. Pero quiero que entiendas qué es lo que estás haciendo y porqué funciona (o no). Como ves, en ningún momento he hablado de nuestro nuevo mejor amigo el RLO. Hasta ahora. Operaciones con los acumuladores que afectan al RLO Hasta ahora sólo hemos hablado de operaciones que son aritméticas. Estas no afectan al RLO. Ahora bien, hay operaciones en las cuales el resultado sí cambia el RLO como son las de comparación, por ejemplo. Así, por poner un ejemplo: L MW 10 L MW20 ==I = A1.0 72 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 ¿Cuántas operaciones con los acumuladores hay? Imagino que querrás sabes qué operaciones puedes realizar. Bien, en el blog tenemos un listado que encontré en su día con todas las operaciones que se pueden realizar en AWL. Échale un vistazo y verás que el abanico es bastante amplio. En esos listados hay instrucciones que aún no hemos visto, pero que veremos más adelante. Que te vayan sonando. Finalmente, el vídeo de este capítulo: 73 Cómo programar Step 7 y no morir en el intento 17. Operaciones - Calculadora científica Para explicar las operaciones aritméticas vamos a ver un nuevo ejemplo en Step 7: una calculadora científica. Sí, nada de teoría… en parte. He pensado que ya hemos visto suficiente teoría como para empezar a programar un poco más en serio. Y digo un poco más, porque una calculadora con un PLC no es precisamente ingeniería aplicada que digamos. Pero sí nos va a permitir repasar cosas aprendidas y comenzar a ver otras nuevas cosas que van a ser de gran utilidad y uso como son saltos condicionados (e incondicionales). Ejemplo en Step 7 de calculadora científica Como digo, antes de meternos a contar tiempo, quería repasar un poco las instrucciones que hemos visto y algunas nuevas especialmente aritméticas y trigonométricas… y qué mejor que ello que realizar un ejemplo en Step 7 de una calculadora como la que tienes sobre estas líneas. Sí, no es precisamente Deep Blue, pero verás que funciona razonablemente bien. El estilo que he usado para el ejemplo es de pila o stacker simulando un poco lo que haríamos con el ACU1 y el ACU2. Este método era el usado por ejemplo en las calculadoras HP 48 que tantos exámenes hizo conmigo cuando estudiaba en la Escuela de Ingenieros de Bilbao. ¿Qué vamos a repasar con este ejemplo en Step 7? Si bien no es un ejemplo de programación industrial, si va a ser bastante didáctico y nos va a permitir: Comenzar a realizar programas usando FC para estructurar el código y como funciones puramente dichas. Ejercitar nuestros conocimientos de lógica booleana. Ver operaciones de comparación Ver operaciones aritméticas Ver operaciones trigonométricas Comenzar a ver operaciones de salto. Entremezclar KOP y AWL y ver que no se muerden entre ellos. 74 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). ¿Qué requerimientos va a tener? Como decía John Hammond en Parque Jurásico, “no hemos reparado en gastos” y tiene todas estas funcionalidades: Operaciones aritméticas (suma, resta, producto y división). Trigonométricas (seno, coseno, tangente y los arcos correspondientes). Potencias y logaritmos naturales. Otras cosillas: Inversa, TAK, Pasar de radianes a grados o gradianes. ¿Tampoco es para tanto no? Pues no, pero tampoco es tan fácil. Si te fijas, tiene un teclado, con sus dígitos, y su punto para realizar número reales con su mantisa incluida... su borrado total y su borrado del último dígito… Además tendrá que hacer que cuando se ejecute una operación, véase por ejemplo la suma, tiene si introduces un nuevo dígito, debe desplazar el último resultado al acumulador 2 y empezar de nuevo. Como digo, no hemos reparado en gastos. ¿Me lo explicas? La verdad es que pensaba meterte un bonito rollo sobre cómo está hecho cada parte del programa, pero cogería tendinitis en los dedos y dudo que me lograra explicar del todo bien. Es por ello que casi que te voy a dejar con un vídeo en el que te voy a explicar al detalle cómo está realizado el programa ¿te parece? Te dejo con el vídeo. 75 Cómo programar Step 7 y no morir en el intento 18. Palabra de estado en Step7 Tal vez esperabas que en este capítulo empezáramos con los temporizadores, pero se va a retrasar un poco. Como vas a ver, tampoco hay un vídeo acompañando este capítulo. Es sólo lectura. Un rollo. Pero está bien al menos como cultura general aunque a efectos prácticos hay poco que rascar más allá de un par de cosillas. La palabra de estado en Step 7 ¿qué es? Lo primero que hay que decir es que la palabra de estado en Step 7 es un registro donde se almacenan una serie de bits sobre el procesamiento y estado de las operaciones que están teniendo lugar. Para empezar, mal empezamos llamándola palabra… ¿por qué? Pues porque son 9 bits y no 16, pero se llama así, y tampoco nos vamos a rasgar las vestiduras ¿no? Entiendo que los 7 restantes los tendrán a buen recaudo y se llama palabra porque al ser 9 no lo podían hacer con un byte. Sin más. Cada bit dentro de la palabra tiene una función para mantener una trazabilidad de qué está sucediendo, desde resultados de álgebra booleana hasta si ha sucedido un overflow. Los bits de la palabra de estado Los Ocean’s Nine son estos: Bit 0 – /FC Bit 1 – RLO Bit 2 – STA Bit 3 – OR Bit 4 – OS Bit 5 – OV Bit 6 – CC1 Bit 7 – CC0 Bit 8 – BR 76 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. Valor 0: la siguiente instrucción va a ser procesada como la primera instrucción. Ya lo vimos anteriormente con las operaciones de cierre de consulta. Valor 1: Es que la combinatoria está en marcha Así, cuando se haga un set, reset o una asignación (=) la señal se pondrá a cero. Una vez después de puesta a cero si se hace un U o un OR (por ejemplo), la señal se pondrá a 1 comenzando a realizar la combinatoria. Bit 1 – RLO. Espero que no tenga que sacar la vara de avellano para castigar a aquellos que aún pregunten que es el RLO. Me niego a explicarlo. Bit 2 – STA Como bien sabes, es el estado de la dirección booleana de la memoria. Si está a uno es que la marca o entrada está a uno, si está a cero, pues al revés. Bit 3 – OR Sirve para conocer el valor de la combinatoria de un AND antes de hacer un OR. Recuerda que puedes hacer una combinatoria de este pelo: U E0.0 O U E1.0 U E2.0 = A1.0 Vale. Pues lo que hace este bit es almacenar la combinatoria del AND entre la E1.0 y la E2.0. Se guarda el resultado intermedio en este bit antes de acometer el OR de este resultado con la E0.0. Bit 4 y 5 – OS y OV OS almacena que ha habido un overflow. Cuando hay un OV (overflow) porque has dividido por cero o porque has sumado dos enteros que se salen de los 32768 la señal de OV y OS se ponen a 1. Luego el OV puede desaparecer porque la siguiente 77 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). Bit 6 y 7 – CCO y CC1 Son bits usados para las operaciones de comparación, matemáticas, de giro… Instrucciones de comparación CC 1 CC 0 0 0 ACCU 2 = ACCU 1 0 1 ACCU 2 < ACCU 1 1 0 ACCU 2 > ACCU 1 1 1 Desordenadas. Solo para coma flotante. Operaciones matemáticas con OV CC 1 CC 0 0 0 Resultado = 0 0 1 Resultado < 0 1 0 Resultado > 0 Operaciones matemáticas enteras con OV CC 1 CC 0 0 0 Rango negativo de OV en ADD_I y ADD_DI 0 1 Rango negativo de OB en MUL_I y MUL_DI 1 0 Rango negativo de OV en ADD_I, ADD_DI, SUB_I, y SUB_DI 1 1 División por 0 en DIV_I, DIV_DI, y MOD_DI 78 Cómo programar Step 7 y no morir en el intento Instrucciones en punto flotantes con Overflow CC 1 CC 0 0 0 Underflow 0 1 Rango negativo de OV 1 0 Rango positivo de OV 1 1 Número de coma flotante no válido Instrucciones de giro y salto CC 1 CC 0 0 0 Bit saliente estaba a cero 1 0 Bit saliente estaba a uno Instrucciones lógicas CC 1 CC 0 0 0 Resultado = 0 1 0 Resultado <> 0 Bit 8 – BR Proviene de Binary Result y es el resultado de las operaciones binarias. Cuando el BR está a uno, activa la salida de ENO habilitando en bloques concatenados que se ejecute el siguiente bloque. Las operaciones SAVE, SPB y SPBB ponen a uno el BR (más información aquí). 79 Cómo programar Step 7 y no morir en el intento 19. Control del reloj del sistema en Step 7 Con este capítulo vamos a comenzar a tratar el tiempo en Step 7. Qué mejor que con el reloj del sistema. Además, vamos a ver un nuevo adelanto de siguientes capítulos viéndolo de forma práctica. ¿En qué consiste el ejemplo? Bueno, la idea es en función de la hora del sistema, calculemos por un lado el día del año en el que estamos y los minutos transcurridos del día actual. Hay que tener en cuenta que el día del año puede variar en función del día del calendario y si es un año bisiesto. ¿Cómo vamos a leer el reloj del sistema? Bueno, lo primero que tienes que saber, si es que no lo sabes ya, es que hay dos SFC, el SFC0 y el SFC1 para leer y escribir la hora en el PLC. El SFC0, que es con el que vamos a trabajar, lee la hora del PLC y nos lo devuelve así: Byte Contenido Ejemplo 0 Año B#16#04 1 Mes B#16#08 2 Día B#16#05 3 Hora B#16#08 4 Minuto B#16#05 5 Segundo B#16#05 6 Los dos dígitos superiores de los milisegundos B#16#25 7 (4 MSB) Los dos dígitos inferiores de los milisegundos B#16#0 7 (4 LSB) Día 1: 2: 3: 4: 5: 6: 7: Sábado de la semana: Domingo, Lunes, Martes, Miércoles, Jueves, Viernes, B#16#5 80 Cómo programar Step 7 y no morir en el intento Esta información proviene de esta página de soporte de Siemens. Por tanto, leeremos el reloj del sistema con el SFC0 y volcaremos esa información en un DB para leerlo cuando deseemos. Tened en cuenta que toda la información está dada en BCD. Para más información sobre qué es BCD tenéis el capítulo con el ejemplo de un display de 7 segmentos. ¿Cómo calcularemos el día del año? Aquí vamos a introducir el nuevo concepto: el CASE en Step 7. Puedes leer más información sobre ello en el capítulo al respecto situado más adelante. La idea es que en función del mes, hagamos una precarga de días. Es decir, si estamos en febrero, nuestro día será = 31 de enero + los días de febrero. ¿Y si estamos en marzo… o en septiembre? En principio podría parecer que es igual... y lo es. Casi. ¿Qué es lo que falta? Pues saber si es bisiesto. Por tanto miraremos si es bisiesto y si el mes es superior a febrero. Si es así, sumaremos un día más del 29 de febrero. Si estamos en febrero, no haría falta ya que si es el día 29 estará en el valor del día, no del mes. ¿Cómo calculamos si es un día bisiesto? Lo primero es saber cuándo es un año bisiesto: tiene que ser divisible entre 4 ¿no? Sí, pero además no debe ser divisible entre 100, salvo que sea además de 100, por 400. La razón de esta norma es que la Tierra tarda 365 días y casi 6 horas. Para eliminar el error cometido, cada 100 años, no se hace bisiesto pero cada 400 sí. En definitiva, la fórmula que vamos a usar es: If (Año Mod 4 = 0) And ((Año Mod 100 <> 0) Or (Año Mod 400 = 0)) Then''' Año Bisiesto else Año No Bisiesto end if 81 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 20. Codificación de un display de 7 segmentos Para resolver este ejemplo vamos a tocar una serie de conceptos y funciones, como hacer un AND entre bytes y palabras, mover bits a la derecha y la función SEG. Vamos a ver los conceptos teóricos necesarios y como siempre terminaremos viendo un vídeo explicativo de la solución en Step 7. Pero para eso, hagamos por un momento de profesor y redactemos el enunciado del problema: Realizar un programa que dado un número de 3 cifras, obtengamos cada segundo las centenas, decenas y unidades en un único display de 7 segmentos. Bien, para ir paso a paso, enumeremos los ingredientes necesarios: Saber qué es un display de 7 segmentos y cómo funciona Tratar el número de 3 cifras y poder obtener cada una de ellas por separado Tomar esa cifra y sacarla de tal forma que el display lo entienda. ¿Qué es un display de 7 segmentos? Haciendo una copia descarada de la wikipedia: El visualizador de siete segmentos (llamado también display) es una forma de representar números en equipos eléctronicos. Está compuesto de siete segmentos que se pueden encender o apagar individualmente. Cada segmento tiene la forma de una pequeña línea. Se podría comparar a escribir números con cerillas o fósforos de madera. Sigamos leyendo: A cada uno de los segmentos que forman el display se les denomina a, b, c, d, e, f y g y están ensamblados de forma que se permita activar cada segmento por separado consiguiendo formar cualquier dígito numérico. A continuación se muestran algunos ejemplos: Si se activan o encienden todos los segmentos se forma el número “8”. Si se activan sólo los segmentos: “a, b, c, d, e, f,” se forma el número “0”. Si se activan sólo los segmentos: “a, b, g, e, d,” se forma el número “2”. Si se activan sólo los segmentos: “b, c, f, g,” se forma el número “4”. Bien, nos hacemos una idea ¿verdad? 83 Cómo programar Step 7 y no morir en el intento ¿Cómo tratamos los datos? Inicialmente vamos a disponer de un número de 3 cifras como dice el enunciado, lo que viene siendo un entero de 0 a 999. Ahora bien, para poderlo tratar va a ser pasar este número entero a BCD. He elegido un número de 3 cifras porque la conversión de entero a BCD (operación ITB) sólo es válida para números entre +- 999. ¿Qué es un número BCD? Hoy es el día de la Wikipedia: En sistemas de computación, Binary-Coded Decimal (BCD) o Decimal codificado en binario es un estándar para representar números decimales en el sistema binario, en donde cada dígito decimal es codificado con una secuencia de 4 bits. Esto en cristiano, y para lo que nos interesa, es que con un byte vamos a poder representar dos dígitos, desde 00 a 99. Usaremos por tanto 4 bits para cada dígito. Es decir, y poniendo ejemplos para los primeros 4 bits: El 0 en binario se representa con 0 0 0 0 El 1 en binario se representa con 0 0 0 1 el 2 en binario se representa con 0 0 1 0 el 3 en binario se representa con 0 0 1 1 Y así sucesivamente hasta... el 8 en binario se representa con 1 0 0 0 el 9 en binario se representa con 1 0 0 1 ¿Y el 10? Pues pasaremos el testigo (a llevada) a los siguientes 4 bits, poniendo a cero los primeros 4 bits. Puedes comprobar que no existe el número BCD 1 1 1 1 por poner un ejemplo. No se usan todos los que se podrían usar para codificar un número (como puede ser en un entero donde 1 1 1 1 es 127). En definitiva, se codifica en binario normal con esos 4 bits hasta llegar al 9, a partir del cual ya no hay más. Para construir un número de 2 dígitos necesitamos otros 4 bits. Y así sucesivamente claro. Espero que no te hayas quedado dormido, así que sigamos. Tratar y filtrar un número de 3 cifras Una vez comprendido qué es un display de 7 segmentos, y qué es un número en BCD (gracias de nuevo a la Wikipedia), vamos a tratar el siguiente punto, que es filtrar nuestro número para ir quedándonos con cada cifra. 84 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) Perdona, pero... que ¿qué? Bien sabes lo que es hacer un AND entre dos bits: si ambos están a 1, el resultado es 1. Si no lo son, un rosco. Pues hacer un filtrado con un WAND no es más que hacer lo mismo, pero en vez de con un bit, con 16. En AWL la operación WAND se llama UW. Vale. Más o menos lo pillo… pero ¿para qué? Aquí viene lo interesante: puedo filtrar (quedarme) con la parte de un WORD que yo quiera. ¿Cómo? Pues haciendo un WAND de mi palabra con una palabra donde los bits que me quiero quedar, son 1. Ya si eso, igual con un ejemplo… Imagina que tenemos una palabra, la MW0 cuyo valor en bits es: 0101 1101 1000 1101 Y quiero quedarme solamente con los 4 primeros bits, los marcados en azul Bilbao (la tierra tira). ¿Cómo lo hago? Pues muy sencillo. Hago un WAND de mi MWO con un 0000 0000 0000 1111 es decir, en hexadecimal W#16#000F o simplemente W#16#F Haciéndolo, lo que nos da como resultado es curiosamente todo ceros, salvo lo que queremos filtrar: 0000 0000 0000 1101 ¿Cómo se te ha quedado el cuerpo? Ahora viene lo mejor: como nuestro número está en BCD y cada 4 bits es un dígito, haciendo este tipo de filtrado, obtenemos nuestras unidades, decenas… en función de dónde pongamos el filtro... ¿Si? Pero hay una pega a solventar: después de nuestro éxito sin parangón filtrando las unidades queremos filtrar además las decenas, te vas a decir a ti mismo... esto está chupado… el filtro será W#16#00F0 o W#16#F0 y mi resultado serán las decena… Pues lamentablemente, no. Si hacemos ese filtro, ojito lo que tendríamos: MW0 = 0000 0101 1000 0101 W#16#F0 = 0000 0000 1111 0000 WAND = 0000 0000 1000 0000 Correcto, pero eso no es un 8, sino un 80 en BCD. Mmmmm y ¿cómo lo soluciono yo ahora? Tampoco es que estemos muy lejos de la solución ¿no? Sólo son unos cuantos ceros que nos sobran. 85 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… Desplazar los bits a la derecha Existen varias funciones de desplazamiento y rotación en Step 7. Hoy vamos a tocar solamente 1, que es la de rotar X bits a la derecha. Otro día veremos más en profundidad tanto las rotaciones como el tema de las operaciones lógicas con palabras. Pero al grano: Tenemos nuestro 80 en BCD del cual nos queremos cepillar el cero… si fuéramos capaces de eliminar los 4 bits iniciales, la cosa estaba hecha... y como estos alemanes piensan en CASI todo, tenemos la operación SHR_W.. ¿Qué es lo que hace la operación SHR_W? Pues resumiendo, desplazar los N bits que le indiquemos hacia la derecha (eliminando los que estaban) y metiendo O por la izquierda para completar la palabra. En nuestro caso, lo que va a hacer: Nuestra palabra sin rotar: 0000 0000 1000 0000 Nuestra palabra rotada : 0000 0000 0000 1000 0000 Es decir, elimina los 4 bits que teníamos en marrón, desplazando el resto, introduciendo 4 flamantes y nuevecitos bits a cero por la izquierda. Pues ¡tachán! ya tenemos nuestro 80 en BCD convertido en un 8 bien chulo (como no podía ser menos). ¿Y las centenas? Estoy convencido que ahora ya sabrías hacer el resto. Como bien imaginas: Filtrar con W#16#F00 Girar 8 bits en vez de 4 para obtener las centenas. Tú que estás al loro, seguro que te has dado cuenta de un pequeño detalle: Las centenas no hace falta filtrarlas, con girar los 8 bits es suficiente puesto que no hay cifras a la izquierda… pues sí. No hace falta porque es un número positivo ya que en caso de un número negativo los 4 bits más altos son todo unos... Por tanto, digamos que para estandarizar el procedimiento sería como lo comentado. Representación en un display de 7 segmentos Una vez que tengamos cada dígito, tenemos que sacarlo en un display de 7 segmentos… ¿cómo? Habría dos formas: Un codificador hardware de BCD a 7 segmentos (por ejemplo el 7447) Codificar por software y dar la salida de los 7 segmentos. 86 Cómo programar Step 7 y no morir en el intento Lógicamente, y ya que estamos, pues lo codificamos nosotros ¿no? Para eso S7 dispone una función de codificación de un display de 7 segmentos, el FC93 “SEG” dentro de Standard Library /TI-S7 Converting blocks La descripción de la ayuda de Step 7 dice lo siguiente: La función “Crear el patrón de bits para el display de siete segmentos” (SEG) convierte los cuatro dígitos hexadecimales de una determinada palabra fuente (IN) en cuatro códigos equivalentes para hacer posible el display de siete segmentos, y escribe el resultado en la palabra doble de salida (OUT). ¿Una palabra a una doble? Piénsalo bien. Introducimos un Word (16 bits), es decir, 4 dígitos en BCD. Si lo queremos sacar en 7 segmentos, necesitamos una doble palabra, o sea, 4 bytes, un byte por cada número de tal forma que cada bit ilumine una patita del display de 7 segmentos (sobrándonos un bit, que es de regalo). El cuadro sería el siguiente: Como puedes ver, además de números como es el caso, podríamos representar caracteres en función de la activación de unos u otros bits según la codificación indicada. Un momento, ¡¡ tú me has estado tomando el pelo todo el rato!!… Un poco sí. Perdón. Me he equivocado. No volverá a suced… ejem. Como hemos dicho, la función SEG toma un valor en BCD de 16 bits y lo transforma en su salida binaria, volcándolo en 4 bytes, y por tanto, no hacía falta filtrar ni rotar absolutamente nada, simplemente con elegir el byte de las unidades, decenas, centenas y millares, hubiera bastado ¿no? Pues sí. Imaginemos que volcamos la información en el MD0, así tendremos MB0: Signo del número MB1: Centenas 87 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 Veamos los diferentes temporizadores de los que dispone Step: S_IMPULS Temporizador como impulso S_VIMP Temporizador como S_EVERZ Temporizador como retardo a la conexión impulso prolongado S_SEVERZ Temporizador como retardo a la conexión con memoria S_AVERZ Temporizador como retardo a la desconexión Por cambiar, primero te ofrezco el vídeo, y luego el texto (además, así me puedes poner cara, ya que es de los primero vídeos que grabé). S_IMPULS Temporizadores como impulso 89 Cómo programar Step 7 y no morir en el intento El temporizador como impulso se comporta como se ve en la figura adjunta. En resumen cuando se activa el temporizador, se da un flanco de un tiempo determinado mientras que la habilitación exista. Mientras que el temporizador corre, la salida está activa. La salida caerá por tres motivos: cuando el tiempo haya finalizado o bien cuando aún con tiempo pendiente, la habilitación del temporizador desaparezca en cuyo caso, la salida caerá con él. También caerá si se activa el reseteo del temporizador. S_VIMP Temporizadores como impulso prolongado Este temporizador se comporta diferente al anterior ya que como puedes observar una vez que el RLO se pone a Set, el temporizador funcionará hasta completar el tiempo independientemente de si el RLO sigue estando a uno o no. Solamente se puede resetear o no activar si el reset del temporizador está activo. S_EVERZ Temporizadores como retardo a la conexión El retardo a la conexión como bien indica, retarda (filtra) la señal que activa el temporizador. Lo más típico es usarlo para filtrar señales a la detección. Así por ejemplo podemos filtrar la señal de una fotocélula que pueda hacer un guiño en un momento 90 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. S_AVERZ Temporizadores como retardo a la desconexión Este temporizador como el anterior es muy utilizado. En este caso lo que hace este temporizador es alargar la señal que arranca el temporizador. Es decir, filtra la señal en caso de pérdidas de señal por guiños. Puede usarse por ejemplo para detectores como fotocélulas o detectores inductivos que pueden perder la señal de lo detectado durante unas milésimas de segundo. Este temporizador ayuda a filtrar la señal manteniéndola en alto. S_SEVERZ Temporizadores como retardo a la conexión con memoria Este temporizador funciona de la siguiente manera: cuando el flaco positivo de la señal que lo habilita pasa a uno el temporizador comienza a contar y una vez agotado el tiempo la salida se pone a uno independientemente de si la señal de entrada ha caído. La señal de salida estará en uno hasta que de nuevo vuelva a haber un nuevo flanco positivo de la señal de entrada y por tanto el temporizador comience de nuevo a contar. 91 Cómo programar Step 7 y no morir en el intento 22. Ejemplos prácticos de temporizadores S7 Vamos a ver unos ejemplos sencillos para ver el uso de los temporizadores S7: Filtrado de señales (el más típico seguramente) Crear trenes de pulso Destellos por un tiempo fijo de una señal Crear un reset de un relé de forma segura. Lógicamente hay muchas aplicaciones más, pero digamos que estas nos valen suficientemente como ejemplo. Filtrado de señales. La idea de filtrar señales es muy típica, especialmente en señales que no dadas por sensores de proximidad por contacto. Un final de carrera es complicado que de un guiño debido a la histéresis que tiene. Ahora bien, un detector inductivo o una fotocélula son susceptibles de dar o perder la señal en un momento dado durante un instante. Así tendremos 3 tipos de filtros: Filtro de guiños positivos Filtro de guiños negativos Ambos filtros combinados Filtro de guiños positivos. Con este filtrado lo que queremos conseguir es eliminar los reflejos o detecciones de un sensor que no son tal. Imagínate una fotocélula que se ve influenciada por el reflejo de un objeto que realmente no se quiere detectar. En el sector en el que yo me muevo, el del vidrio para automoción suele suceder de vez en cuando y por ello normalmente las células suelen estar filtradas. ¿Cómo? Mediante un temporizador con retardo a la conexión. Este temporizador hará que un pequeño guiño haga que la lectura del sensor siga siendo cero salvo que se supere un cierto umbral de tiempo detectando el objeto. El tiempo de detección se verá mermado el tiempo programado. Filtro de guiños negativos Podría pasar justo lo contrario, que detectando el objeto instantáneamente dejes de detectar el objeto para volverlo a detectar. Para evitar este guiño negativo puedes usar 92 Cómo programar Step 7 y no morir en el intento un temporizador con retardo a la desconexión. Con este temporizador alargarás la detección del objeto haciendo que si en medio de la detección hay un hueco en la medida, esta quede filtrada. Lógicamente el tiempo de detección se verá alargado el tiempo programado. Filtro combinado Si lo que quieres es filtrar en uno u otro sentido, tanto a guiños positivos como negativos, puedes usar dos temporizadores con retardo a la conexión que hagan: Un retardo a la conexión de la señal (E0.0) a uno poniendo a set una marca (M10.0) que representará la señal. Un retardo a la conexión de la caída de la señal (E0.0) reseteando dicha marca (M10.0). De esta forma tendrás la señal E0.0 representada por la M0.0 filtrada tanto contra filtros positivos como negativos. Si los tiempos de los temporizadores son iguales, el tiempo de detección no varía, pero sí está desplazado el tiempo configurado. Crear un tren de pulsos Para generar una marca pulsante (M1.0), lo haremos como figura en la siguiente captura mediante dos temporizadores s7 (T2 y T3). Lo que haremos será ponerlos en serie y que el primero se active con retardo a la conexión de que el segundo esté parado. El segundo estará como retardo a la conexión de la activación del primero. Entremedias, a la salida del primero, ponemos la marca como conector (podríamos usar como variable también la propia marca). 93 Cómo programar Step 7 y no morir en el intento Destellos por un tiempo fijo de una señal Imagina que quieres hacer un tren que con una señal, dure un determinado tiempo. Imaginemos 30 segundos. Lo que haremos será combinar: El tren de pulsos anterior Un temporizador de impulso prolongado. Reset de un relé de forma segura La siguiente aplicación está implementada en la mayoría de los relés de seguridad un poco modernos y complejos. Pero imaginemos que no tenemos más que un relé que rearma si das una señal y si se queda dada la señal, pues intentaría rearmar de forma continua logrando por tanto un sistema de autorrearme, cosa que pone los pelos de punta solo de pensarlo. Hay veces que por malfuncionamiento, otras por picaresca, imaginemos que el botón de reset se queda metido. Vamos a evitar que pueda rearmarse el relé si es así. Para ello, el rearme no lo dará directamente el botón, sino el PLC de forma controlada. 94 Cómo programar Step 7 y no morir en el intento Las condiciones van a ser: Que pulses un tiempo mínimo de dos segundos Que el tiempo pulsado sea como máximo de 5 segundos. Lo que haremos entonces es con la señal de reset poner a correr dos temporizadores. Con la caída de la señal, evaluaremos si el temporizador de mínimo se ha cumplido y si se no se ha cumplido el tiempo máximo. Solo entonces, generaremos un pulso de un segundo como salida que reseteará el relé de seguridad. Para terminar, el vídeo. 95 Cómo programar Step 7 y no morir en el intento 23. Cómo crear un cronómetro en Step 7 Esta semana respondiendo a una duda/petición de uno de los lectores vamos a crear un cronómetro en Step 7. La verdad es que no tiene mucha ciencia, y por eso le he querido dar un poco más de gracia al invento haciendo que se muestre en el Wincc Flexible mediante discos concéntricos a modo de diana. Como verás en el vídeo los segundos, minutos y horas describen perfectamente una circunferencia según va pasando el tiempo. Cronómetro en Step 7 El cronómetro tal y como está la verdad es que no lo he usado nunca, pero no es menos cierto que en más de una ocasión he calculado tiempos de forma similar a la que se describe en el vídeo usando: El OB35 Una variable a modo de contador La idea es muy simple: aprovechando la frecuencia sabida de ejecución del OB35, aprovechamos para contar. En este caso, cada 100ms. Por tanto, cada 10 ejecuciones, tendremos 1 segundo. Sacar los minutos y segundos, será trivial. Iremos pasando la información hacia arriba: cada 10 ejecuciones tendremos un segundo, y por cada sesenta segundos, pues un minuto… ¿Fácil no? WinCC Flexible Para aderezar el problema he introducido la variable del WinCC. Para ello, he pensado que qué mejor que hacer que tener partes móviles en la pantalla. ¿Cómo? Realmente es sencillo. A cada elemento en una pantalla de WinCC puedes moverlo de forma dinámica mediante unos offset. Estos Offset en el eje X como en el Y son variable que lógicamente puede tomar diferentes valores. Ya, ya… ¿pero cómo calculas la posición? Pues usando la trigonometría de segundo de bachiller… con senos y cosenos. Lo que sabemos de nuestro reloj es la posición relativa dentro de la esfera del reloj. Sabiendo eso, podemos saber qué ángulo formaría la aguja y por tanto su seno y su coseno. 96 Cómo programar Step 7 y no morir en el intento Teniendo la longitud de la aguja (el radio) y el ángulo podremos calcular en coordenadas cartesianas muy fácilmente la posición X e Y ya que: X = Radio *Cos (ángulo) Y = Radio *Sen (ángulo) ¿A que parece mentira que esto de las funciones trigonométricas que estudiaste hace la tira de años sirvan para algo? Pues sí, sirven para muchas cosas, entre ellas dibujar relojes... ¿qué te parece? Para que esto tenga un poco más de sentido práctico, pues el video de casi todas las semanas donde vas a poder ver de qué diantre te estoy hablando. 97 Cómo programar Step 7 y no morir en el intento 24. Filtrado y enmascarado de bits en Step 7 Esta semana la entrada va a ser corta pero espero que interesante sobre el filtrado y enmascarado de bits. Recientemente me he visto en la necesidad de realizar lo siguiente: tengo una serie de alarmas de una máquina A, y quiero pasar una única señal booleana a otra máquina B por Profibus que indique que hay una alarma activa en la máquina A. Podríamos hacer un OR bit a bit, pero sería un poco hacerlo a lo burro. Porque si son unas pocas bien, pero como sean unas cuantas el OR va a ser como la torre de Iberdrola de Bilbao (hay que tirar para casa). Hasta ahí ningún problema. Las alarmas comienzan imaginemos en la M32.0 y terminan en la M37.7. Con ir haciendo OR de palabras sería suficiente. Cómo saber si hay una alarma activa (usando todas las alarmas) SET –> Pongo a uno el RLO R M100.0 –> Resteo el valor de la marca M100.0 que es la que voy a mandar a la máquina B. Inicialmente no hay alarma. L MW32 –> Leo los primeros 16 bits L MW34 –> Leo los siguientes 16 bits OW –> Hago un OR de palabra con lo cual el resultado cargará en el ACU1 todos los bits que estén a uno haciendo OR bit a bit L MW36 –> Cargo los últimos 16 bits OW –> Hago un OR entre el contenido del ACU1 y la MW36 y lo transfiero nuevamente al ACU1 L 0 –> Cargo un cero en el ACU1 y por tanto el resultado del OR pasa al ACU2 ==I –> Hago una comparación entre el cero del ACU1 y el contenido del ACU2 SPB EXIT –> Si es cero (el RLO está a 1), salto y no hago nada SET –> Pongo el RLO a uno S M100.0 –> Pongo a uno la marca M100.0 que será la que envíe a la máquina B EXIT: NOP 0 98 Cómo programar Step 7 y no morir en el intento ¿No valdría con sumar y ya está? Otra aparente fácil solución sería usando la misma estructura: SET R M100.0 L MW32 L Mw34 +I L MW36 +I L0 <>0 SPB EXIT SET S M100.0 EXIT NOP 0 Tanto rollo con low OW… una suma y listo… Ummmm en general sí…. en particular… no. Este último ejemplo funcionará CASI siempre. ¿Descubres la razón? Es realmente sencillo. Estamos sumando valores enteros…pero pueden ser positivos o negativos. Por tanto, en general funcionaría pero al hacer la suma, puede haber valores que hagan que MW32+MW34+MW36 = 0 ya que estos valores pueden tomar valores positivos o negativos. El ejemplo de comparar con cero valdría si por ejemplo son 16 alarmas. Ahí no habría problema ya que no hay sumas, ni restas ni comparaciones ni nada de nada. Lo comparas con cero, y si no es cero, es que hay una alarma tocando los coj... ejem. Que hay una alarma activa. Filtrado y enmascarado de bits Vale. Ya hemos visto cómo podríamos saber si hay una alarma activa teniendo en cuenta todas las alarmas. 99 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. Vale. Ahora sí que sí hago un cojo-OR eligiendo los bits. Hombre… no. Son unas cuantas. Imaginemos que no queremos tener en cuentas los bits: 32.1, 35.7, 36.0, 36.1, 36.2 y 37.3 (por poner un ejemplo). El primer método está claro que no me sirve. Las sumas, mucho menos… hacer un OR de cada bit dejando estas sin meter es un poco remedio básico… y aquí queremos ser los más chulos del barrio programando S7. ¿Cómo lo hacemos? Pues creando máscaras… usando enmascarado de bits. Vale, la idea es sencilla: crear un grupo de bits que sean los bits que nos queremos quedar y hacer un AND con las señales de tal forma, que el AND resultante, si es distinto de cero, es porque hay alarma. Ejemplo: Imagina que tienes la M32.1 y la M32.3 a uno y el resto del byte está a cero ¿Ok? Tendríamos que MB32 = 0 0 0 0 1 0 1 0 ¿Sí? Solamente el bit 1 y 4 empezando por la derecha sería unos (los 0.1 y .3 ya que empezamos en .0), y se lee de derecha a izquierda. Vale. ¿Cómo podemos saber que hay una alarma descartando el M32.1 cómo queremos? Pues haciendo un AND con el siguiente byte: MB32 =00001010 Mascara = 1 1 1 1 1 1 0 1 Resultado = 0 0 0 0 1 0 0 0 ¿No se te eriza el bello? Ya claro… pero ¿cómo cargo el enmascarado de bits? porque si tengo que calcular cuánto es el resultado de cada máscara en decimal pasándolo de binario, me dan las uvas… pero está claro que no de este año. 100 Cómo programar Step 7 y no morir en el intento Muy fácil. Así: L MB32 –> Cargo el primer byte L 2#1 1 1 1 1 1 0 1 –> Cargo en binario mi número usando base 2. Vale. Deja ya de aplaudir y prosigamos… que ahora estarás conmigo que es trivial: SET R M100.0 –> Como antes empezamos reseteando la señal L MB32 –> Cargamos el primer byte L 2#1 1 1 1 1 1 0 1 –> Cargamos el enmascarado de bits para el byte 32 UW --> Hacemos el AND L MB33 –> Cargamos el Byte 33 OW –> Hacemos un OR entre el resultado y el byte 33 que no hay que filtrar L MB34 –> Cargamos el byte 34 OW –> Hacemos un OR entre el resultado del OR y el byte 34 que no hay que filtrar T MW20 –> Una marca intermedia ya que vamos a necesitar almacenar el resultado L MB33 –> Cargamos el byte 35 L 2#0 1 1 1 1 1 1 1 –> Cargamos la máscara para despreciar el 35.7 UW –> Hacemos el AND para quedarme con todo menos con el 35.7 L MW20 –> Cargamos el resultado hasta ahora OW –> Hacemos un OR con el resultado T MW20 –> Lo transferimos a la marca intermedia nuevamente L MB36 –> Cargamos el Byte 36 L 2#1 1 1 1 1 0 0 0 –> Cargamos la máscara para el 36.0, 36.1 y 36.2 UW –>Realizamos el enmascarado de bits L MW20 –> Cargamos lo que tenemos hasta ahora OW –> Hacemos un OR L MB 37 –> Cargamos el último byte L 2#1 1 1 1 0 1 1 1 –> Cargamos la máscara del 37.3 UW –> Realizamos el enmascarado de bits L MW20 –> Cargamos el temporal OW –> Hacemos un OR T MW20 –> Hacemos la última transferencia al MW20 101 Cómo programar Step 7 y no morir en el intento L MW20 –> Cargamos el temporal con el resultado L0 –> Cargamos un cero ==I –> Los comparamos SPB EXIT -> Si el MW20 = 0, saltamos al final ya que no hay alarmas. SET S M100.0 –> EXIT: NOP 0 Si no es cero, ponemos la señal de alarma a 1. ¿Se podría hacer con words en vez de con bytes? La respuesta es sí, pero no te lo recomiendo ya que vas a tener que manejar 16 cero o unos y además recuerda que hay que poner de derecha a izquierda los bits y primero el byte alto y luego el byte bajo… igual te lías un rato. Son más instrucciones que con words, pero mucho más claro y mantenible sin llegar a tener que poner un OR de todos los bits cada uno por separado. En racimos de 8 creo que es razonable. 102 Cómo programar Step 7 y no morir en el intento 25. Cómo realizar un tracking de datos en Step7 Con este ejemplo vamos a ver cómo realizar un tracking de datos en step7 usando dos funciones integradas: SFC20 y SFC21. El tracking de datos no va a ser nada más que arrastrar a lo largo de las posiciones de nuestra línea la información del objeto que está circulando por ella, desde la receta (o pauta) que sea, recorrido que ha de llevar, y cualquier característica o información que sea deseable que arrastre desde el principio hasta el final (o que se vaya añadiendo por el camino). Una cosa importante que has de tener en cuenta a la hora de realizar tu automatización es el grado de importancia que va a tener el arrastrar esta información. Digo esto porque para realizar una buena trazabilidad y saber qué información lleva qué pieza, has de saber en todo momento donde está qué, de tal forma que no haya posibilidad de error a la hora de arrastrar la información. Normalmente esto lo vas a realizar mediante la detección y transporte de las piezas, posicionamiento por encóder etc. Pero de alguna forma has de saber cómo detectar o calcular dónde está cada pieza de tal forma que no cometas errores a la hora de arrastrar la información. Tracking de datos en Step7 A la hora de realizar nuestra trazabilidad, puede ser que sólo necesitemos un bit de estado (lleno/vacío, bueno/malo). En tal caso puede que te sirva las operaciones de desplazamiento como ya veremos en desplazamiento y giro de bits. Pero lo que vamos a descubrir juntos es como arrastrar una cantidad ingente de información (ingente, es relativo, pero más de un byte vaya). Para ello vamos a necesitar conocer las siguientes herramientas: SFC20: Block Move con el que vamos a poder copiar bloques completos de información. SFC21: Fill. Con el que podremos rellenar zonas de memoria con la información que queramos (por ejemplo ceros). UDT: ¿te acuerdas? Esta vez le vamos a dar un uso práctico. El "conceto" Como decía el gran Manquiñas en Air Bag , lo importante es el conceto. ¿Qué es lo que vamos a hacer? Pues básicamente, pasar la información de una posición a la siguiente y borraremos la que tenemos en la estación anterior. 103 Cómo programar Step 7 y no morir en el intento Bien, vale... ¿pero cómo? Vamos a usar las funciones SFC20 y 21. La primera, SFC20 nos va a permitir copiar volúmenes de datos grandes de un origen A a un destino B. Por ejemplo, podemos copiar el contenido completo de un DB a otro DB ¿entiendes por dónde voy? Y el SFC21 ¿para qué lo quieres? Una vez que hayamos copiado la información, lo suyo es que borremos la información de la estación origen. Para ello usaremos la función llenar SFC21 "Fill". Tomaremos una zona de memoria que tenga todo ceros y con ella rellenaremos el DB origen (o el área que sea). Y claro, vamos a usar DB... Correcto. Si el volumen de datos es importante y/o tenemos diferentes estaciones, tenemos varias opciones: Usar un único DB de tracking. Usar un DB de tracking por posición. Si usamos un único DB de tracking crearemos típicamente un array de posiciones (por ejemplo con números de transportador). Cada array contendrá la información de cada uno de los transportadores (o lo que sea) y pasaremos los datos de una zona a la siguiente. En el segundo caso, cada transportador tendrá su propio DB pasando la información de un DB a otro. ¿Cuál es mejor? Pues ni uno ni el otro, ni todo lo contrario. Dependerá de cada caso. Contener todo en un DB tiene una gran ventaja, que es mucho más compacto y fácil de saber dónde encontrar toda la información ya que sólo hay un sitio que la contenga. Pero tiene un gran pero... que más te vale que hayas hecho bien los deberes y tengas claro qué información vas a intercambiar y que hayas dejado suficiente espacio libre de no tenerlo muy claro. ¿Por qué dices eso? Porque si después de haber estado muchas horas trabajando sobre el proyecto llegan nuevos requerimientos y has de aumentar el volumen en el tracking y no has dejado espacio suficiente te vas a cag.. en lo más barrido. Tendrás toda la información del tracking difuminada y usada por medio programa y a la hora de elegir los datos, ya no coincidirán los punteros porque tienes que añadir nuevos datos y por tanto, has de cambiar los índices de las lecturas y/o escrituras. Por ejemplo. Imagina que has reservado exclusivamente el código de la pieza que tiene 8 caracteres en un string (10 bytes en total) de tal forma que la posición 1 empieza en la 0.0 la dos en la 10.0 la tres en la 20.0 etcétera... Has programado, leído el código donde has querido o lo que sea que hayas hecho a lo largo del programa... y ahora no solamente has de arrastrar ese código sino también el 104 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. ¿Qué ventaja tiene usar un DB por posición? Pues que básicamente el ampliar los DB es simplemente añadir la información nueva al final y volver a cargar los DB en caso de que hayas superado la longitud máxima. También te recomiendo que aun usando los DB así, dejes espacio libre al final. Esto evitará que en una ampliación tengas que cambiar los valores de cuántos bytes arrastras. Un 20%-25% puede estar bien (más o menos dependiendo del tamaño que coja y previsión de necesidades). Así por ejemplo si mis datos son 80 bytes, pues sin duda yo dejaría libre hasta completar los 100 bytes. Otro motivo por el que usar los DB separados puede ser porque sean pocas posiciones de tracking con un volumen algo elevado. Digamos que porque cada posición tiene entidad suficiente como para tener sus propios DB. Pues siempre uso DB separados y ya está... Pues puede ser un gran error... Porque si tu línea va a tener muchas estaciones y vas a arrastrar poca información, generas mucho ruido en el proyecto. Imagina que tienes 30 estaciones para arrastrar poco más que un par de bytes. Siempre será mejor crear un DB más grande, dejando 20 bytes para cada posición (por decir algo) que no generar un DB para cada uno. Vamos, que uses la pelota que tienes encima de los hombros antes de decidir uno u otro. 105 Cómo programar Step 7 y no morir en el intento Vayamos con un ejemplo práctico Como casi siempre, vamos a poner todo esto en práctica mediante un ejemplo. En este caso vamos a hacer algo un tanto abstracto, pero que lo que va a querer simular es una línea con 5 posiciones. En el ejemplo vamos a tener dos botones. Uno para cargar los nuevos datos Un botón para generar el tracking Lógicamente en la vida real no se produce como en el ejemplo, pero con lo que quiero que te quedes es con cómo se mueve la información de un sitio a otro. En una automatización de verdad, habrá condiciones para pasar la información de un lado a otro y no se hará completamente en cascada. Para darle una pequeña gracia lo que vamos a hacer es que la información se arrastre siempre que la siguiente posición esté libre, pudiendo moverse siempre la última para dar por finalizado sumando uno a un contador de piezas buenas. Además le vamos a poner una salida intermedia en la cual, si la información dice que la pieza es mala, salga lateralmente y desaparezca del tracking sumando una al contador de piezas malas. Como siempre, es más fácil de ver que de explicar con palabras, así que te dejo con el siguiente vídeo donde puedes ver el pequeño ejemplo. 106 Cómo programar Step 7 y no morir en el intento 26. Contadores en Step 7 Para ir terminando la primera parte del libro (la más sencilla pero la más importante por su relevancia dentro de los proyectos), vamos a ver cómo trabajar con los contadores en Step 7. Vamos a ver varias formas de cómo trabajar con contadores: Sumar y restar sobre una variable Usar los comandos INC /DEC Usar los contadores S5 Contadores en Step 7 usando un entero Poco le vamos a dedicar a este contador: se trata de sumar y restar sobre una pobre e inofensiva palabra. Si queremos sumar, pues usaremos +I, si queremos restar, pues -I. Lo hemos usado con anterioridad y no tiene mayor complicación: L MW10 –> Cargamos lo que tengamos L 1 –> Cargamos la cantidad que queremos sumar +I –> Sumamos ambas cantidades y lo almacenamos en el ACU1 (-I para restar) T MW10 –> Lo transferimos de nuevo en el contador MW10 Como ves, nada nuevo que no sepas ya. Contadores en Step 7 usando INC y DEC Podemos también usar, en vez de una palabra, un byte (Con la limitación de contaje que ello conlleva al ser sólo un byte). Existen dos instrucciones para este tipo de contadores: INC N#_8_bits para incrementar el contador DEC N#_8_bits para decrementar el contador Así, para usarlo tan sólo deberemos usar de esta forma las operaciones: L MB100 –> Cargamos el contador en el ACU1 INC 1 –> Sumamos 1 al ACU1 T MB10 –> Lo volvemos a cargar en el MB10 Análogamente, para descontar: L MB100 –> Cargamos el byte que lleva el contaje en el ACU1 DEC 2 –> Restamos dos unidades al ACU1 107 Cómo programar Step 7 y no morir en el intento T MB100 –> Transferimos el resultado de nuevo al MB100 ¿Fácil no? Muy parecido al caso anterior pero ligeramente más compacto. Contadores en Step 7 usando contadores S5 Los contadores S5 (Z) son contadores al igual que los temporizadores S5 una reminiscencia de antiguos autómatas (quién lo iba a decir con ese nombre ¿eh?). Son de tipo hardware también como los temporizadores S5 y la cantidad depende de cada CPU. El uso de este tipo de contadores depende de cada proyecto y de cada programador. Personalmente no los uso porque me siento más cómodo con la primera opción de las vistas. Además, este tipo de contadores tienen una limitación de contaje que llega hasta las 999 unidades. Las operaciones que se pueden realizar sobre estas operaciones son: Cargar un valor de contaje Borrar el valor de contaje Contar y descontar Consultar su valor tanto como cantidad como operación booleana Cómo cargar un valor a contadores en Step 7 Para cargar un valor en un contador, cargaremos el valor usando el prefijo C# y luego haciendo un S Z1 (por ejemplo) si el RLO está a uno. Por ejemplo: U M0.0 –> Leemos el valor de la marca M0.0 L C#12 –> Cargamos el valor en el ACU1 S Z 1 –> Si la M0.0 fijamos el valor “12” en el contador Z1 Sumar y restar sobre contadores en Step 7 Con las instrucciones ZV y ZR podrás incrementar o decrementar el contador en función del estado del RLO Así y siguiendo con el Z1: U M0.1 –> Leemos el estado de la marca M0.1 ZV Z1 –> Si la señal está a 1, incrementamos en uno el valor del Z1 U M0.2 –> Leemos el estado de la marca M0.2 ZR Z1 –> Si el RLO está a uno, restamos una unidad al Z1. 108 Cómo programar Step 7 y no morir en el intento Poner a cero un contador Hemos visto, que para cargar un valor de contaje, lo hemos hecho, con un Set, pues para ponerlo a cero, será con un Reset: U M0.3 –> Leemos el valor de la marca M0.3 R Z1 –> Si está a uno, ponemos a cero el contador Leer el valor del contador y su estado Al igual que pasa con los temporizadores S5, podemos leer directamente el estado del contador y hacer lógica booleana con ello. Es decir, podemos hacer un: U Z1 = A1.0 Esto significa que mientras el contador sea cero, el valor de A1.0 será cero y se pondrá a uno cuando el Z1 > 0. Por otro lado, puede que queramos saber cuánto va valiendo el contador. Para ello, haremos una lectura de este estilo: L Z1 –> Si queremos leer en valor decimal T MW10 –> Se lo transferimos al MW0 por ejemplo LC Z1 –> Leemos el valor del Z1 en BCD. T MW20 –> Lo transferimos. ¿Y en KOP? En resumen de lo visto, podemos verlo en KOP como en la figura adjunta. En el tienes todas las instrucciones vistas en un único bloque que se puede usar en FUP o KOP. 109 Cómo programar Step 7 y no morir en el intento Si vemos este bloque en AWL, lo que tendríamos sería: U M 0.1 ZV Z 1 U M 0.2 ZR Z 1 U M 0.0 L C#12 SZ1 U M 0.3 RZ1 LZ1 T MW 10 LC Z 1 T MW 20 UZ1 = A 1.0 Los diferentes colores son las instrucciones arriba vistas. Como ves, cada parte está bien diferenciada. Vamos a dar un pequeño repaso a lo visto con un vídeo muy sencillo en el que puedas ver cómo funciona lo visto hasta ahora. 110 Cómo programar Step 7 y no morir en el intento 27. Saltos: SPA, SPB y SPBN (If-Then-Else) ¿Qué son los saltos en Step 7? Como en cualquier lenguaje de programación, los saltos en Step 7 no son más que interrupciones de la ejecución lineal del código, posicionándose en un nuevo punto (en general indicado por una etiqueta o meta) continuando normalmente con el programa desde este nuevo punto. En el caso de los PLC estos saltos nos sirven para simular decisiones que en lenguajes de alto nivel se resuelven de otra forma, como por ejemplo con los IF/THEN-ELSE por poner un ejemplo. Estas estructuras como tal no existen en AWL/FUP/KOP, sino que hay que fabricarlas por decirlo de alguna manera. La forma más sencilla de hacerlo es mediante el uso de saltos. Los más importantes por su uso a mi juicio son SPA, SPB y SPBN. SPA se usa para saltos incondicionales. Es decir, cuando se ejecuta esta sentencia, la ejecución continua en la etiqueta que acompaña al operando de forma fija e incondicionada. No depende de nada. Salta y continúa. La forma de ejecución será la siguiente: SPA META <<Código que no se ejecuta>> META: <<continua el código>> Tal y como está representado, si se ejecuta la sentencia SPA META, el código entre esta sentencia y la META en sí, no se ejecutará nunca. ¿Entonces para qué sirve? Bueno, enseguida veremos cómo gestionar este tipo de cosas. De momento quédate con la idea de que SPA es un salto incondicional al META indicado. 111 Cómo programar Step 7 y no morir en el intento SPB y SPBN se usan para saltos condicionados al valor del RLO La diferencia fundamental entre ellos es que si usas SPB el salto se producirá si el RLO = 1, mientras que el salto usando SPBN se producirá si el RLO = 0. Por tanto, y análogamente su uso será de esta forma: <<Condición del salto>> SPB META (o SPBN META) <<Código que no se ejecuta>> META: <<continua el código>> Es decir, tras evaluar el resultado de la condición de salto (cero o uno), en función de este. Y del tipo de salto elegido (SPB o SPBN), se realizará el salto o no. ¿Qué pasa si no se realiza el salto? Buenísima pregunta. ¿Qué crees que sucederá? Efectivamente, que la ejecución del código continuará normalmente. Pongamos un mini ejemplo. L MW0 L MW2 ==I SPB IGUA L1 L MW4 +I IGUA: NOP 0 <<Resto del programa>> Veamos. Lo que estamos haciendo es lo siguiente: cargamos el contenido del MW0 y MW2 en el ACU1 y ACU2. Luego hacemos una operación de comparación de igualdad. Es decir, preguntamos si estos dos valores son iguales. El resultado de esta comparación será binaria (cero o uno) y estará cargado en el RLO. Bien, una vez tengamos el resultado de esta comparación decimos que si el RLO = 1, salte al meta IGUA. Entonces continuará con el resto del programa. Ahora bien, si no se cumple la igualdad, se ejecutará el código que hace que la marca MW4 se incremente en una unidad… y seguirá con el resto del programa. 112 Cómo programar Step 7 y no morir en el intento ¿Vale, vale… pero como construyo un IF-THEN-ELSE? Pues haciendo una combinación de los saltos podemos hacer la lógica: IF Condición THEN Código si se cumple la condición ELSE Código si no se cumple la condición END IF ¿Cómo lo hago con saltos en Step 7? Pues usando los saltos así: Condición de salto SPBN ELSE Código si se cumple la condición SPA EXIT ELSE: NOP 0 Código si no se cumple la condición EXIT: NOP 0 Continuar con el código. ¿Lo vemos con un ejemplo? Siguiendo con el ejemplo inicial: L MW0 L Mw2 ==I SPBN ELSE L MW4 L1 -I T MW4 ELSE: NOP 0 113 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. ¿Pero esto no se puede hacer con FUP o KOP? La mayoría de las veces, las situaciones de aplicar operaciones de comparación irá asociada y combinada con lógica booleana, por lo que sí será aplicable hacerlo con KOP o FUP si el resultado es por ejemplo poner una marca a Set. La idea de usar AWL y este tipo de soluciones cuando vas a realizar muchas operaciones aritméticas, punteros etc. No para programación booleana. 114 Cómo programar Step 7 y no morir en el intento 28. Cómo anular partes de un programa. Aprovechando que ya hemos visto los principales saltos de Step 7, vamos a ver métodos para anular parte de un programa entre los cuales están los saltos. Anular parte de un programa comentando líneas Una forma muy sencilla de eliminar parte de la ejecución de un programa es comentar las líneas que te interesen borrar. Así, para anular parte de un programa harás algo así: U E 0.0 U E 0.1 U E 0.2 = A 1.0 Imaginemos que queremos eliminar la U E0.1 Pues sencillamente: U E 0.0 // U E 0.1 U E 0.2 = A 1.0 La ventaja es que queda reflejado lo que has anulado por si quisieras volver hacia atrás. Pero hay que tener en cuenta que eso solo se ve en el proyecto offline, ya que esas líneas comentadas no se cargan en el PLC Siemens. Anular parte de un programa realizando saltos. Otra forma de anular parte de un programa es realizando un salto con SPA: U E 0.0 SPA BORR U E 0.1 BORR: NOP 0 U E 0.2 = A 1.0 115 Cómo programar Step 7 y no morir en el intento Lógicamente esto es medianamente útil si el código a anular es temporal y es suficientemente grande para que salga a cuenta incluir un salto. La parte positiva es que este tipo de anulación sí se carga en el PLC para futuros cambios. Anular parte de un programa usando una marca nula ¿Cómo hacer esto en FUP o en KOP? Pues creando un Always Off, es decir, una marca que siempre está a cero y poniéndola en serie si es KOP o dentro de un AND si es en FUP, haremos que esta parte no de señal. OJO AL PARCHE. Esto solo es válido si lo que se quiere anular una salida o una marca (que sea cero) o que no se realice una operación aritmética o de comparación. Pero si es lógica booleana con una salida, ejecutarse, se ejecuta, solo que obligamos a que en ese momento, la salida sea cero. Anular parte de un programa usando BEA Si quieres anular parte de un programa, y este esta parte es la parte final, con colocar un BEA al final, hará que lo que venga detrás, ya no se ejecute. Así U M 0.0 O M 0.1 = M 1.1 BEA U E 0.0 U E 0.1 U E 0.2 = A 1.0 La parte en negrita, no se ejecutará al encontrarse detrás del BEA. 116 Cómo programar Step 7 y no morir en el intento 29. Instrucción LOOP – El For /Next del PLC Una de las instrucciones más habituales en un lenguaje de programación de alto nivel, es la sentencia FOR-NEXT. Para nuestros autómatas, tenemos la instrucción LOOP en Step 7. Este tema, al igual que los que quedan del curso ya los hemos visto, pero además de volverlo a explicar, vamos a ver un nuevo ejemplo. Loop en Step 7 La forma de operar es la siguiente: LOOP META. Ya está, no hay más… más o menos. La idea es que cuando llega la ejecución de la operación se lee el contenido del ACU1, se le resta uno, y si aún hay algo que rascar (es decir, no es cero), se realiza un salto hasta la META. ¿Y cómo hago un FOR NEXT con LOOP en Step 7? Bien, la fórmula de la Coca-Cola esta vez es muy sencilla: L Numero_Iteraciones –> Cargamos cuántas veces queremos hacer el loop NEXT: T Indice_Iteraciones –> Lo transferimos a la variable auxiliar que lleva la cuenta de vueltas <<<Código que queremos que se ejecute N veces>>> L Indice_Iteraciones –> Leemos el número de vueltas que llevamos y lo cargamos en el ACU1 LOOP NEXT –> Restamos una unidad a lo cargado en el ACU1, es decir, al número de iteraciones y saltamos a la meta NEXT si el resultado no es cero. Vamos, que lo que hacemos es inicialmente cargar a tope con el número de iteraciones a una variable auxiliar que será nuestro índice. Por ejemplo 10. Ejecutamos el código repetitivo y lo último que hacemos es cargar este índice nuevamente. Luego, al ejecutar la operación LOOP, restaremos una unidad a ese 10 inicial, teniendo en el acumulador entonces 9 y salta a la meta NEXT. Si te fijas, lo primero que hacemos es volcar nuevamente este 9 al índice… ejecutaremos, cargamos el 9, restamos uno en el loop y saltamos a NEXT, teniendo un 8… y así sucesivamente. . 117 Cómo programar Step 7 y no morir en el intento El vídeo con el ejemplo sobre el tema: Filtrado de una señal analógica Se trata de realizar un filtrado de una señal analógica de esta forma: Tomaremos la señal cada 100 ms. Pasaremos como entrada el valor analógico en tipo entero Realizaremos un filtrado de los “n” últimos ciclos donde “n” puede ser como mucho 200. Nos devolverá la media de los “n” últimos ciclos como valor real Nos devolverá la medida de los 200 últimos ciclos si hemos puesto n>20 y una señal booleana de alarma indicando que el número de ciclos es demasiado grande y que por tanto devolvemos solamente la media del máximo número de ciclos. 118 Cómo programar Step 7 y no morir en el intento 30. Saltos SPL en Step 7. El Select Case en AWL Esta semana vamos a ver el salto SPL en Step 7. Se trata de un salto de metas estilo Select Case que podríamos encontrar en lenguajes de programación de alto nivel. Junto con los ejemplos vistos de cómo hacer los IF/THEN/ELSE y el FOR-NEXT, tendríamos elementos suficientes para realizar programas bastante sofisticados ya que estas tres operaciones son básicas en un lenguaje de alto nivel, pero que permiten realizar operaciones complejas. ¿En qué consiste el SPL en Step 7? Básicamente lo que vamos a realizar es un salto a una meta en función del valor numérico de una variable que hemos volcado en el ACU1 antes de realizar la llamada a la instrucción SPL. La estructura sería como sigue: L MB0 //Cargar el número de la meta del salto en el ACU1-L-L. SPL ELSE //Meta del salto si el ACU1-L-L es > 3. SPA SEG0 //Meta del salto si ACU1-L-L = 0. 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 31. Otros saltos Para terminar las entradas referidas a los saltos, vamos a ver sin entrar en mucho detalle, que también existen otros saltos en Step 7 como son: Saltos en función del estado del RB Saltos en caso de error ¿Estado del RB? ¿Lo qué? Vamos a hacer memoria. ¿Recuerdas que hay una palabra de estado que ya lo hemos visto en un capítulo anterior? Bueno, pues si extraemos un trocito de esa entrada, vemos que: Bit 8 – BR Proviene de Binary Result y es el resultado de las operaciones binarias. Cuando el BR está a uno, activa la salida de ENO habilitando en bloques concatenados que se ejecute el siguiente bloque. Las operaciones SAVE, SPB y SPBB ponen a uno el BR En general, se puede usar el estado del BR para saber si ha habido un error ejecutando un bloque y el siguiente está habilitado para poderse ejecutar. En el caso de FUP/KOP no tiene mucho sentido ya que si concatenas los bloques, ya estás condicionando la ejecución del segundo a que el primero no haya tenido problemas. Como se puede observar fácilmente, al concatenar los bloques, la ejecución de un bloque depende del ENO = 1 del bloque que lo precede (que todo esté OK, por decirlo de alguna manera). En AWL puedes hacer una llamada a un bloque y luego mediante saltos, decidir qué hacer: SPBI Saltar si RB = 1 SPBIN Saltar si RB = 0 Saltos en Step 7 con errores y resultados matemáticos Como en lenguajes de alto nivel, existe una serie de operaciones de salto para cuando hay un error y además, en este caso, evaluando el resultado de una operación: SPO Saltar si OV = 1 SPS Saltar si OS = 1 SPZ Saltar si el resultado = 0 121 Cómo programar Step 7 y no morir en el intento SPN SPP SPM SPPZ SPMZ SPU Saltar si resultado <> 0 Saltar si el resultado > 0 Saltar si resultado < 0 Saltar si el resultado >= 0 Saltar si el resultado <= 0 Saltar si el resultado no es válido Como puedes ver, hay unos cuantos saltos disponibles. La forma de usarlo es como otros saltos. Como ves, todos dependen del estado de los bits de estado. Te recomiendo que eches un vistazo a qué significa cada uno. A decir verdad, yo estos saltos no los he usado creo que nunca, aunque no está de más saber que existen. Si quieres tener más información sobre cada uno de estos saltos, puedes teclear el salto en AWL en el editor y estando sobre el, pulsar F1. Te aparecerá la ayuda donde aparecerá un poco más de información. 122 Cómo programar Step 7 y no morir en el intento 32. Desplazamiento y giro de bits en Step7 Aunque ya vimos algo sobre el desplazamiento de bits cuando jugamos con el display de 7 segmentos, ahora vamos a ver todas las operaciones disponibles de desplazamiento y giro de bits en Step7 además de un par de vídeos para ilustrar lo expuesto. SHR_I Desplazar entero a la derecha SHR_DI Desplazar entero doble a la derecha SHL_W Desplazar 16 bits a la izquierda SHR_W Desplazar 16 bits a la derecha SHL_DW Desplazar 32 bits a la izquierda SHR_DW Desplazar 32 bits a la derecha Además, hay operaciones de rotación: ROL_DW Rotar 32 bits a la izquierda ROR_DW Rotar 32 bits a la derecha Desplazan el contenido de ACU1 bit a bit. Son incondicionales, no dependen del RLO. Podemos desplazar, tanto a la derecha como a la izquierda, palabras, doble palabras, enteros y dobles enteros. En general, lo que se harán en todas las instrucciones es dar la palabra o doble palabra a desplazar y un número de bits a ser desplazado. Vale. Hasta ahí lo entiendo, pero ¿qué diferencia hay desplazar entero o un Word a la derecha? Básicamente funcionan igual. La diferencia fundamental es que al desplazar los enteros, arrastramos también el signo. ¿Lo qué? Bien. Además de simplemente arrastrar bits de izquierda a derecha o de derecha a izquierda, esto implícitamente lleva consigo operaciones de multiplicación y división en base 2. Es decir, desplazar a la derecha 1 bit significa dividir entre dos el número que tengamos. La diferencia entre hacerlo con enteros o con words, es que en enteros (SHR_I ) podemos hacer divisiones con signo. Así si tenemos: Valor a dividir: MW 102 = 1000 (tanto en entero o decimal) Desplazar a derecha: MW200 = 1 Si hacemos SHR_I: MW104 = 500 (en entero o en decimal) Si hacemos SHR_W: MW106 = 500 (en entero o en decimal) 123 Cómo programar Step 7 y no morir en el intento En principio no hay diferencia ¿no? La cosa es que si ahora hacemos Valor a dividir: MW 102 = (-1000) o 64536 en decimal Desplazar a derecha: MW200 = 1 Si hacemos SHR_I: MW104 = -500 en entero o en 65036 visto en decimal Si hacemos SHR_W: MW106 = 32268 en entero o 32268 visto en decimal) Como puedes observar, la diferencia es notable dependiendo de si tenemos un valor entero positivo o no. Análogamente si desplazamos a la izquierda en vez de a la derecha sucederá lo mismo, pero multiplicando en vez de dividiendo… salvo por un pequeño detalle, que sólo existe el SHL_W. Entiendo que la razón por la que no existe desplazamiento a la izquierda de enteros es porque no tiene sentido ya que no se va a guardar el signo, por lo que no existe tal cosa. Si tuviéramos el último bit con signo menos, lo perderíamos, por lo que de ahí entiendo la inexistencia de dicha operación. En cualquier caso, la forma de hacerlo en AWL será de la siguiente forma: L MW 200 -> Cargamos el número de bits a desplazar L MW 102 -> Cargamos la palabra a desplazar SLW –> Operación de desplazamiento (en este caso Word a la izquierda) T MW 104 -> Transferimos el resultado a cualquier otra palabra Análogamente sería con las dobles palabras (SHR_DI, SHL_DW, SHL_DW). Pero ojo, cuando tenemos los bits bien estirados uno detrás de otro, recordad que en una doble palabra, el bit más a la derecha es el bit .0 del byte alto de la palabra alta. Es decir, del MD0, el bit más a la derecha será el M3.0, y el más a la izquierda, el bit .7 del byte bajo de la palabra baja… el M0.7. Y el giro de dobles palabras El caso de giro de las dobles palabras es más sencillo aún de entender: daremos el número de bits a girar y desplazaremos los bits a la izquierda (por ejemplo). Los bits que quedan fuera por la izquierda, son reintroducidos por la derecha. Si se gira al revés, pues funciona al revés. Y como es más fácil de entender viéndolo, pues qué mejor que un video que lo muestre. 124 Cómo programar Step 7 y no morir en el intento ¿Podrías poner un ejemplo real de desplazamiento y giro de bits en Step7? Pues sí. Se trata de un ejemplo de embotelladora. La cosa es arrastrar una señal a lo largo de un camino paso a paso, a modo de tracking. El problema es el siguiente: detectamos a lo largo de una cinta la presencia o no de las botellas, pero el embotellado no es in situ, sino que se produce como 10 posiciones más adelante. Se trata de arrastrar la información de la fotocélula hasta la posición donde debe ser rellenada la botella. Pero como siempre, es más fácil de entender viendo el vídeo que con palabras. Así que te dejo con el segundo vídeo (ración doble). 125 Cómo programar Step 7 y no morir en el intento 33. Giro de bits en step 7: el coche fantástico Vamos a usar dos instrucciones para realizar el giro de bits en step 7: RLD Rotar doble palabra a la izquierda (32 bits) RRD Rotar doble palabra a la derecha (32 bits) Básicamente lo que vamos a hacer es que un bit que lanzaremos desde el OB100 va a ir desde la marca M1.0 (la más a la derecha de la MW0) hasta la M0.7 (La más a la izquierda de la marca Mw0) Rotaremos a tiempo fijo (usando las marcas de ciclo configurada en el PLC) de izquierda a derecha y de derecha a izquierda moviendo en cada tick un único bit. Además de eso, añadiremos un FB con el que haremos que cada bit esté en estado 1 un poco más tiempo que el establecido haciendo el barrido más largo o más corto en el tiempo como veremos más adelante. El programa básicamente va a estar realizado en dos partes. Los dos primeros segmentos para realizar el giro de un lado a otro... El segundo segmento lo haremos para realizar el cambio de sentido. La razón de realizarlo en un segmento separado es para que cuando haya que cambiar de sentido se complete correctamente y no se ejecuten dos pasos en el mismo ciclo de scan. 126 Cómo programar Step 7 y no morir en el intento Finalmente realizaremos la llamada para realizar el barrido con tiempo volcado en salidas digitales. El código del FB no lo inserto aquí porque es mucho más largo y tampoco es necesario para el propósito sobre el giro de bits en step 7. El vídeo sobre el giro de bits en step 7 127 Cómo programar Step 7 y no morir en el intento 34. Direccionamiento indirecto – Memoria y punteros a área Para empezar con el tema del direccionamiento indirecto, vamos a explicar una serie de conceptos básicos y luego nos pondremos con las formas más básicas de direccionamientos indirectos. Los tipos de direccionamientos son tres: Direccionamiento Inmediato Direccionamiento Directo Direccionamiento Indirecto Los dos primeros, son los que conocemos muy bien: El direccionamiento inmediato es cargar directamente el valor del operando (de cualquier tipo), por ejemplo L 32. El direccionamiento directo será del tipo L MW10 (donde el valor de MW10 sea el 32 anterior) es decir, en la carga se apunta directamente al sitio de la memoria donde reside el valor que queremos cargar. Nada nuevo bajo el sol. Ahora bien, ¿qué pasa cuando queremos recorrer áreas de memoria de forma recursiva o leer un área dinámicamente? Direccionamiento indirecto Como decimos, podemos acceder a los valores de la memoria de una forma indirecta.. Vamos a querer saber el contenido de una variable (o área de memoria) usando otra variable que se referirá a esta área de la que queremos saber su valor. Parece un poco enrevesado pero es bastante fácil de entender mediante un ejemplo: podemos abrir el DB10 con AUF de dos formas: AUF DB10 O bien: AUF DB[MW20], teniendo la marca MW20 el valor 10. Esta última forma de cargar el valor de la marca MW10 es uno de los tipos de direccionamiento indirecto, pero hay varios: Direccionamiento Indirecto por Memoria con Número Direccionamiento Indirecto por Memoria con Puntero de Área Direccionamiento Indirecto por Registro e Intraárea (área interna) Direccionamiento Indirecto por Registro e Interárea (área cruzada) 128 Cómo programar Step 7 y no morir en el intento El caso anterior, el usado es el primero, mediante número. Direccionamiento Indirecto por Memoria Dentro de los direccionamientos indirectos por memoria con número a su vez, podemos usar MW (o DW de un DB) o MD (o DD de un DB) para acceder: Usando formato palabra: accederemos a temporizadores, contadores, abriremos DB y accederemos a FB y FC. Usando formato doble palabra: accederemos a datos de tipo bit, byte, palabra y doble palabra. Formato palabra – número (indexados) Es el más fácil de entender: en un número entero (palabra) introducimos el valor de DB, FB, temporizador etc. que queramos leer. Así podemos hacer un L 10 T MW 10 U T[MW10] Con lo que estaremos leyendo el estado del temporizador T10. Digamos que nos sirve para valores operando que están indexados mediante un número como son los DB, los contadores etc. Para hacer referencia a ellos, nos servimos de un número ya que existe una lista de estos elementos. Direccionamiento Indirecto con formato doble palabra – Punteros a área Aquí ya se introduce el concepto estrella del direccionamiento indirecto… el puntero. Hagamos un pequeño paréntesis para ver este concepto. Un puntero no es más que una dirección. Nada más. No tiene un valor, sólo apunta con el dedo como un niño pequeño dónde mirar, pero no dice qué está viendo. Los punteros pueden ser: Interárea (Área cruzada) : Por ejemplo P#M10.0, o P#E10.0 o P#DBX10.0 Intraárea (Área interna): Por ejemplo P#10.0 Como ves hay una gran diferencia. Los que tienen área de memoria se posicionan, dentro de todas las áreas la memoria en una en concreta, y de esa, en una posición definida (siguen sin decir lo que vale, pero la dirección es completa). En cambio, los que no llevan área de memoria, simplemente es una dirección. ¡Pero no sabemos de qué área de memoria! 129 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… ¿Se puede cargar los punteros de otra forma? Pues sí. Resumiendo diremos que le damos la dirección bien mediante el puntero (P#10.0) o contando con los dedos cuántos bits tiene la dirección. Es decir: Podemos hacer, al igual que en el caso de arriba: L 80 (porque la dirección 10.0 son 80 bits) T MD10 U E[MD10] = A [MD10] ¿Es lo mismo? Estrictamente lo mismo. Hemos creado el puntero de la misma forma. Por tanto, de forma numérica, un puntero se verá como el número de bits de ese puntero. 130 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 35. Direccionamiento indirecto – Registros y áreas En esta nueva entrada sobre direccionamiento indirecto es con la que terminamos el curso. En ella vamos a ver la segunda parte de cómo automatizar y recorrer zonas de memoria para trabajar con ellas de forma indirecta y recursiva. Registro de direcciones Como sabes, cuando se carga un valor, hay dos registros, el ACU1 y el ACU2. Pues también existen dos registros de direcciones, el AR1 y el AR2 para usarlos en el direccionamiento indirecto. La forma de cargar y transferir los valores a los registros es de las siguientes 3 maneras: Cargar directamente el puntero en el AR1 Cargar el puntero y transferírselo al AR1 Cargar el valor numérico de bits y transferírselo al AR1 Cargar directamente el puntero Es el más rápido si se sabe qué hay que cargar: LAR1 P#1.0 Lo que cargará en el AR1 el puntero 1.0 Cargar el puntero y transferirlo al AR1 L P#1.0 LAR1 Al igual que el anterior, cargamos el puntero P#1.0 en el AR1 Cargar el valor numérico de bits y transferirlo al AR1 O, como dijimos en direccionamiento indirecto (I), podemos crear al puntero diciendo cuántos bits tiene la dirección L8 LAR1 Hará exactamente lo mismo que los casos anteriores. Hay que puntualizar que si queremos acceder a una dirección que tenga más de 32768 bits (16 bits) la carga debería ser del estilo: L L#80000 TAR1 De tal forma que cargaremos la dirección 10000.0 132 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. Direccionamiento Indirecto por Registro e Intraárea/Interárea La diferencia fundamental entre el registro e Intraárea y registro e Interárea es: Intraárea: No se especifica el área de memoria Interárea: Vamos a especificar el área de memoria (el tipo, por así decirlo) ¿Y esto qué significa en cristiano? Pues a la hora de la verdad, y para nosotros, no mucha cosa. En resumen, y que permitan los puristas, lo que vamos a hacer es o bien: LAR1 P#50.0 // Cargar el puntero L MW [AR1, P#10.0] // Decir el operando (en este caso de carga), el tipo de área (marcas) y la dirección. O también podemos hacer: LAR1 P#M50.0 // Cargar el puntero CON la zona de memoria L W [AR1, P#10.0] // Decir el operando y la dirección. ¿Resultado? Pues básicamente el mismo. La diferencia es que en el direccionamiento de tipo intraárea, el contenido del AR1 va a tener la misma pinta que el direccionamiento por memoria que veíamos en el capítulo I. No tiene el área de memoria asignado (marcas en nuestro caso). ¿Qué se usa más? Personalmente intraárea, pero supongo que es cuestión de gustos. Además imaginemos que mezclamos las cosas y hacemos lo siguiente: LAR1 P#E50.0 L MW[AR1,P#10.0] Como veis hemos indicado el área en la carga del registro AR1 y luego hacemos una carga de MW… ¿vamos a mandar la CPU a Stop o crearemos un agujero espaciotiempo? Pues no. No sé si lamentablemente, pero no. Simplemente del AR1 tomaremos la dirección, pero no la zona de memoria y ejecutaremos el operando de carga MW. 133 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. Muy bien, me parece estupendo… pero me he perdido en el L MW [AR1, P#10.0]… ¿qué significa? Muy sencillo. Lo que hay entre corchetes es la dirección inicial más un desplazamiento. De tal forma que en nuestro ejemplo, realmente estamos leyendo la MW60 (50 del AR1 +10 del offset por así decirlo). ¿Es obligatorio poner ese offset siempre? Si. Siempre. Sin excepción. Pones un P#0.0 si no lo quieres y listo. ¿Qué pasa si cargo un P#50.0 en el AR1, cargo un offset P#0.1 y hago una lectura MB, MW o MD? Pues que estarías provocando un bonito error de runtime. Ya que para hacer una lectura de byte, Word o doble Word, necesitas que el bit del puntero sea 0 (ojo, el bit, no el byte). No puedes crear un MW50.1 cómo puedes imaginar. Así que cuidadín con eso. ¿Qué más puedo hacer con los registros? Como no solamente del AR1 vive el hombre, existe también un segundo registro, el AR2. Con esta pareja, podemos jugar indistintamente para cargar nuestros punteros e incluso combinarlos en las operaciones. Así, para seguir con el ejemplo anterior, podríamos hacer: LAR1 P#50.0 LAR2 P#10.0 L MW[AR1,AR2] : No se puede usar ambos AR para hacer este tipo de direccionamiento L MW[AR1,p#0.0] T MW[AR2,P#10.0] ¿Qué operaciones puedo hacer con los registros? LARn : Cargar el contenido del ACU1 en el registro ARn, siendo n=1 o 2. Offtopic: Y no, no es un 102, es un 1 O 2. A la RAE le ha parecido buena idea no tener que acentuar desde hace un tiempo la O entre números. Qué país. TARn: Transferir desde el registro n, su contenido al ACU1. +ARn: Sumar al contenido del ARn, el contenido del ACU1. Pero como hemos visto, podemos hacer cargas y transferencias directas: 134 Cómo programar Step 7 y no morir en el intento LARn <Dirección>: Cargamos la dirección al ARn. Por ejemolo LAR1 P#50.0 TARn <Dirección>: Cargamos el contenido del ARn en la dirección. Por ejemplo TAR1 MD50 +ARn <Puntero>: Añadimos al ARn el puntero que queramos. Por ejemplo, +AR1 P#10.0 Para rizar el rizo, podemos copiar la información entre los AR haciendo: LAR1 AR2, con lo que cargaremos en el AR1 el contenido del AR2 TAR1 AR2, con lo que recuperamos el contenido del AR1 y se lo cargamos en el AR2. Como ves las combinaciones son unas cuantas si bien se pueden resumir en asignación y suma. ¿Y todo esto, ya sirve para algo? Pues aunque pueda parecer lo contrario, el direccionamiento indirecto sirve para muchas cosas, pero sobre todo para recorrer información y tratarla. En el siguiente video os voy a mostrar cómo se usa el direccionamiento indirecto, especialmente con bucles LOOP (for-next), como ya vimos. 135 Cómo programar Step 7 y no morir en el intento 36. Comparar dos cadenas de caracteres En este capítulo vamos a realizar un ejercicio práctico de cómo comparar dos cadenas de caracteres en Step 7 bien que sean alfanuméricos o dos cadenas cualesquiera de datos. Si lo que queremos comparar son dos strings como tal, Step 7 proporciona de origen un FC con el que poder comparar cadenas de caracteres en forma de string. Se trata del bloque FC 10 EQ_STRNG que puedes encontrar desde el editor en Librerías-> Standard Library -> IEC Function Blocks. Bien. Lo lógico es usar esta función o cualquier otra de las que te ofrece Step 7 si se ajusta a tus necesidades. Pero lo que vamos a realizar hoy es poder comparar cualquier cadena de bytes de dos DB y ver si son iguales o no. Da igual el tipo de datos que tengamos en ese área de memoria. Comparar dos cadenas de caracteres en Step 7 La idea es simple: poder comparar dos áreas de memoria consecutiva de dos DB (o del mismo) y saber si ambas áreas son iguales. ¿Para qué sirve eso? Pues por ejemplo si tienes una comunicación en la cual envías X bytes a otro PLC, Scada o lo que sea y quieres saber que realmente lo que envías y lo que el interlocutor está leyendo es lo mismo por ejemplo para activar una orden de actuación. Entonces, la forma de operar es que un PLC escribe en un DB digamos DB1 y el interlocutor copia ese DB a un DB2 que te lo envía de vuelta. La forma de saber que lo que uno escribe, el otro lo recibe es comparando ambos DB, cosa que puede ser muy simple si intercambias digamos un DW, pero bastante engorrosa si estás intercambiando 100 bytes. ¿Qué necesitaremos para comparar las cadenas de caracteres? Pues vamos a necesitar tener ciertos conocimientos de: Punteros y direccionamiento en Step 7 Hacer un FOR – NEXT en Step 7 Saltos condicionales Un poco de XOR que nos servirá para la comparación Usar los acumuladores AR1 y AR2 Como ves, nada que no hayamos visto con anterioridad en el libro. 136 Cómo programar Step 7 y no morir en el intento ¿Y cómo vamos a hacer la comparación de las cadenas de caracteres en step7? Básicamente vamos a realizar un FC donde pasaremos como variables de entrada: Los números de los DB Los números de byte de origen de los datos de ambos DB La longitud a comparar en bytes Por otra parte, y como salida del FC, obtendremos una salida booleana indicativa de si ambas cadenas son iguales o no. En cuanto al programa en sí, y como referencia, la idea sería la siguiente: Poner una marca booleana a cero indicando inicialmente que ambas cadenas originalmente son iguales Hacer un FOR-NEXT con el número de bytes a comparar Crear los punteros correspondientes a cada posición Comparar cada byte entre ambos DB haciendo un XOR Si el resultado es mayor que cero, hacer un SET de la booleana indicando que no son iguales Si el resultado es cero, no hacemos nada. Continuamos con el FOR Finalmente igualamos la booleana a la salida del bloque. Seguidamente te dejo con el código fuente del FC para que le vayas echando un vistazo: FUNCTION “Comparador de cadenas” : VOID TITLE = VERSION : 0.1 VAR_INPUT NumDB1 : INT ; //Número del primer DB a comparar NumDB2 : INT ; //Número del segundo DB a comparar Byte1 : INT ; //Número del primer byte de la cadena del DB1 Byte2 : INT ; //Número del primer byte de la cadena el DB2 Longitud : INT ; //Longitud de bytes a comparar END_VAR VAR_OUTPUT Resultado : BOOL ; //Resultado final de la comparación. END_VAR VAR_TEMP Comparacion : BOOL ; //Resultado temporal de la comparación IndiceForNext : INT ; PunteroOffSet : DWORD ; DBNum1 : INT ; DBNum2 : INT ; ResultadoXOW : INT ; END_VAR BEGIN NETWORK TITLE = //Inicializamos la variable Comparacion SET ; R #Comparacion; 137 Cómo programar Step 7 y no morir en el intento // Transferimos los valores de los DB a las variables. // Hay que hacerlo así porque no se puede leer directamente como IN L #NumDB1; T #DBNum1; L #NumDB2; T #DBNum2; NETWORK TITLE = //Hacemos un for-next con el número de bytes de longitud ya que vamos a comparar //byte a byte. L #Longitud; NEXT: T #IndiceForNext; // Generamos un puntero OffSet L #IndiceForNext; // Cargamos el indice ITD ; // Lo pasamos a doble L P#1.0; // Cargamos un puntero de un byte *D ; // Multiplicamos en doble para general el puntero origen T #PunteroOffSet; // Obtenemos el OffSet // Generamos el puntero del DB1 L #Byte1; // Cargamos el byte de inicio ITD ; // Pasamos a doble (como los punteros) L P#1.0; // Cargamos un puntero de un byte *D ; // Multiplicamos en doble para generar el puntero origen LAR1 ; // Lo cargamos en el AR1 L #PunteroOffSet; //Cargamos el offset de este loop +AR1 ; // Se lo sumamos al AR1 // Generamos el puntero del DB2 L #Byte2; // Cargamos el byte de inicio ITD ; // Pasamos a doble (como los punteros) L P#1.0; // Cargamos un puntero de un byte *D ; // Multiplicamos en doble para generar el puntero origen LAR2 ; // Lo cargamos en el AR2 L #PunteroOffSet; //Cargamos el offset de este loop +AR2 ; // Se lo sumamos al AR2 AUF DB [#DBNum1]; // Abrimos el DB1 AUF DI [#DBNum2]; // Abrimos el DB2 L DBB [AR1,P#0.0]; //Cargamos el valor del primer puntero L DIB [AR2,P#0.0]; //Cargaos el vaor del segundo puntero XOW ; //Hacemos un XOR de palabra T #ResultadoXOW; // Toma de decisión L #ResultadoXOW; // Si el resultado es cero, no hacemos nada porque de momento son iguales L 0; // Comparamos con cero, si son iguales, saltamos sin hacer nada ==I ; SPB EXIT; SET ; // Si no son iguales, continuamos y ponemos a uno la variable S #Comparacion; 138 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 37. Qué es un OB de fallo Un OB de fallo es un bloque de función que tiene las siguientes características: Puede existir en nuestro proyecto o no. Sólo depende de ti a la hora de programar el proyecto. Son específicos. Cada uno de ellos hace referencia a un fallo en concreto. No se ejecutan salvo cuando se da el fallo en cuestión (y exista lógicamente). Si no existen en el programa del PLC, este puede irse a STOP en función de la severidad del fallo. No todos los OB de fallo están presentes en todas las CPU (aunque sí la mayoría). Vale. Ya ves que son unos bloques un tanto especiales. Listado de OB de fallo. OB 80 – Error de tiempo OB 81 – Error de la fuente de alimentación OB82 – Alarma de diagnóstico Ob83 – Alarma de insercción/extracción OB84 – Error de hardware CPU OB85 – Error de ejecución de programa. OB86 – Fallo de un aparato de ampliación, sistema maestro DP o periferia descentralizada OB87 – Error de comunicación OB88 – Ejecución interrumpida OB121 – Error de programación OB122 – Error de acceso a la periferia Además de estos OB de fallo existen otros como son el OB70 al 73 que son para CPU H redundantes. En las referencias te dejo un PDF con toda la documentación. En él podrás saciar tus ansias de conocimiento más en profundidad. Pero este post no va de eso. Quiero que veas para qué sirven en general. Luego tú serás el que busque el OB adecuado para cada ocasión. La parte fundamental es que si se produce un error y el PLC hace una llamada al OB correspondiente, puede suceder: Que el error no sea grave y exista el OB o no, la CPU no se vaya a STOP Que el error sea grave y el OB no exista con lo cual la CPU se irá a STOP Que el error sea grave y el OB sí exista, con lo cual, salvo que tu lo programes, la CPU no se irá a STOP. Los OB de fallo típicos son el OB80, el Ob85, el OB86, el OB122… y poco más. El OB80 es muy típico cuando estás programando en la puesta en marcha. Haces un bucle que no tiene salida y zas… a STOP. Lógico. Superas el tiempo de watchdog y de 140 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 38. Alarmas: Cómo activar y desactivar la baliza En este capítulo vamos a tratar una cosa fundamental en nuestros proyectos: la gestión de alarmas en S7. Antes o después, nuestra automatización va a tener algún tipo de problema, por ejemplo, de mal funcionamiento. Esto en principio no es un problema ya que por lo general vamos a tener una pantalla asociada donde vamos a poder mostrar en cada caso qué alarma es la que ha saltado y si fuera necesario su tratamiento o puntos a comprobar para poder resolverla. Por otro lado, además de la indicación en la pantalla de la alarma, hay que llamar la atención del operario para indicarle que algo no va como debiera. Así, tendremos casi siempre: Una bonita baliza luminosa Una sirena que deje medio sordo a los que estén alrededor. La primera no suele molestar mucho. A mí el rojo me gusta a pesar de no ser mi color favorito… pero que una sirena me esté taladrando el oído cuando ya me he enterado de que la alarma está activa y que además el problema no es resoluble a corto plazo, me hace estar un tanto inquieto. Por tanto, lo que vamos a ver a continuación es: Activar la baliza roja de forma parpadeante cuando surja una nueva alarma. Que la alarma se quede fija una vez que la alarma haya sido reconocida. Cómo activar la sirena cuando surja una nueva alarma aunque haya sido reconocida previamente. Cómo parar la sirena cuando se reconozca la alarma. Cómo resetear todas las alarmas (si se puede porque las causas hayan desaparecido) Cómo lanzar de nuevo la sirena en caso de transcurrido un tiempo, las alarmas no han desaparecido (si fuera necesario) Gestión de alarmas en S7 Como veis no es nada que sea extraño. La idea es que suene la sirena y la podamos apagar. Esto en sí mismo es fácilmente resoluble. El problema puede surgir si salta una nueva alarma, que también queremos que la sirena suene de nuevo o para determinadas alarmas, aunque hayan sido acusadas, suenen de nuevo al de dos horas por ejemplo recordando que el problema no se ha solventado. 142 Cómo programar Step 7 y no morir en el intento ¿Cómo hacerlo? Pues los ingredientes que vamos a usar son los siguientes: Un FC donde realizar la gestión de las alarmas con sus variables de entrada y salida Un FC donde programar las alarmas Un DB donde almacenar el estado de las alarmas y su significado Unas pocas marcas y salidas El FC Vamos a usar un FC reutilizable para todos nuestros proyectos. O casi todos. Algo que podamos usar más adelante, en otra automatización. Esto nos va a obligar a que todos los datos que usemos hayan sido introducidos como entrada y los generados los saquemos como salidas. Las tareas que vamos a realizar en este FC van a ser: Comprobar cuántas alarmas activas hay Comprobar si hay más alarmas activas que en el ciclo anterior. Si las hay, activar una salida que indique que hay una nueva alarma. Comprobar si han sido acusadas las alarmas. Si lo han sido, tirar la señal de nueva alarma. Resetear las alarmas si tenemos una entrada que así lo indique. Dar intermitencia o no a una salida que indique si de las alarmas activas existentes hay nuevas o están todas acusadas. Tener una entrada que nos rearranque la bocina y la baliza si hemos programado que al de un tiemp0 del apagado de la bocina, la causa que generó la alarma no ha desaparecido. En un segundo FC programaremos nuestras alarmas. A decir verdad podemos concentrar la programación de todas las alarmas en un único FC o bien en cada parte o bloque donde se estén generando las acciones de nuestra automatización, generar ahí la alarma pertinente. It’s up to you. El DB El DB no va a ser más que un listado de booleanas donde activaremos nuestras alarmas. ¿Por qué eliges un DB en vez de hacerlo con marcas? Pues por costumbre, lo primero. Y lo segundo, y más importante por practicidad. Puedo ver en un sólo sitio dentro de S7 las alarmas de las que dispongo y cuáles estoy usando. Sé cuáles uso porque comento qué hace cada alarma No corro riesgo de machacar una dirección. Puedo dejar espacios grandes sin usar sin miedo que en un futuro use una dirección intermedia para una cosa que no sea una alarma. 143 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 39. Buenas prácticas de programación en S7 Siempre que comenzamos a programar, tenemos la incertidumbre de si la forma en la que trabajamos es la más adecuada o no. En la entrada que recupero del ostracismo (y que añado alguna cosa nueva) te voy a contar unas pequeñas pautas que puedes seguir, aunque estas buenas prácticas de programación en S7 no son palabra de Dios, y por supuesto, pueden ser discutibles y/o matizables. Son unas recomendaciones que te doy, y puede que a lo mejor te encajen en tu forma de estructurar un proyecto o al menos que te sirva para reflexionar sobre cómo has de afrontar los primeros proyectos que desarrolles. Tengo una hoja en blanco ¿Por dónde empiezo para realizar buenas prácticas de programación en S7? Lo primero que tienes que hacer cuando comienzas un proyecto es respirar hondo y no agobiarte. Te puede pasar que si miras el proyecto en su conjunto pueda ser un tanto mareante al principio… y lo es. Supongo que todos hemos pasado por ello. Lo bueno que tiene la automatización seguramente junto con otro tipo de programas y software es que es muy modulable ya que la instalación está siempre dividida en máquinas, y estas a su vez en sub-máquinas y estas finalmente en un conjunto de señales y actuadores. Por tanto, podemos abstraernos a la hora de programar del resto de la máquina y centrarnos en muchos casos solamente en una pequeña parte de la máquina. Pero ojo, no estoy diciendo que comiences a programar con una pequeña porción de la máquina sin pensar en el resto. Estoy diciendo que el problema global que es que la dichosa instalación funcione, la vas a poder cortar en cachitos y que cada cachito por separado no es tan fiero. Por tanto lo primero que tienes que pensar es en qué máquinas se divide tu instalación y cómo interactúan entre ellas. Lo que deberías hacer en un primer estadio del proyecto es: Comprender muy bien la instalación. Qué debe hacer (y qué no). Hacer un listado con las posibles divisiones de la instalación o máquina, como máquinas (o submáquinas) independientes. De cada máquina y submáquina qué detectores vas a necesitar y qué actuadores. Una vez comprendas que es lo que debe hacer, podrás dividir la instalación (o máquina) en trozos más pequeños e independientes. Esto nos va a ser útil a la hora de definir los bloques en los que se va a dividir nuestro proyecto. Por otro lado, la enumeración parcial de cada señal y cada actuador, nos va a dar una idea global del volumen de entradas y salidas del proyecto. Esto te va a ayudar a su vez a valorar entre otras cosas si merece la pena centralizar todo en el armario eléctrico, o si va a ser mejor colocar por la instalación diferentes armarios remotos, por ejemplo. 145 Cómo programar Step 7 y no morir en el intento Vale, ya tengo más o menos claro qué hace y qué necesito… ¿y ahora? Ya tienes el qué, vayamos ahora en el cómo: Estructura tus bloques Asigna rangos de I/O Da nombres a las cosas Un buen listado de alarmas Bocetos de las pantallas del HMI Cuando digo que estructures los bloques quiero decir que des rangos a tus FC, FB y DB. Imagínate que tienes 3 zonas bien diferenciadas de la máquina, pues una forma de estructurar tus bloques podría ser: Del 0 al 99 para bloques genéricos Del 100 al 199 a la zona 1 Del 200 al 299 a la zona 2 Del 300 al 399 a la zona 3 Así, por poner un ejemplo: imagina que dentro de las zona 1 tienes un transportador. Pues puedes hacer: FC110 “Transportador 1” para la lógica booleana que maneje todo lo que haya sobre ese transportador, sus marchas y paros, manual, automático etc. FB110 “Motor Transportador 1″ Para el manejo del variador de dicho transportador, la gestión de las consignas que puede que le mandes por profibus, alarmas etc. DB110 “DB Motor Transportador 1″, pues como DB de instancia del FB110 Esto como digo es un ejemplo. La idea que quiero que pienses es que todo lo referente al transportador 1, estará asociado con el concepto numérico “110” como cosa global. Si tienes un segundo transportador, dentro de la zona 1, pues le asignas el 120. ¿Por qué no el 111? Dependerá de cada proyecto, pero siempre que puedas, y para mi gusto, separa los bloques. Imagina que encima del transportador 1 tienes un par actuadores neumático que hacen algo, lo que sea. Yo le daría en ese caso: FC 111 “Actuador #1 Transp. 1″ FC 112 “Actuador #2 Transp. 1″ Todo esto suponiendo que tengan suficiente entidad como para que tengan su propio FC y no puedan ser agrupados en un único FC 111 “Actuadores Trans. 1″. Espero que cojas el concepto. ¿Qué nos va a permitir esto? Pues básicamente, un poco de orden. Porque como te acostumbres a poner todos los bloques seguidos, va a ser un caos. Por el simple hecho es que la vida del proyecto es larga, y seguro que vas a tener que insertar nuevos actuadores sobre partes de las máquinas. 146 Cómo programar Step 7 y no morir en el intento Como hayas puesto: 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. Asigna rangos a las I/O Al igual que has hecho con los bloques, la idea sería la misma para las entradas y salidas. Intenta dar rangos a las zonas de las máquinas. De tal forma y siguiendo con nuestro ejemplo, imagina que has decidido poner 3 remotas, una por cada zona de tu instalación. Asigna rangos a las I/O: EB100 – EB199 para la zona 1 EB200 -EB299 para la zona 2 EB300 – EB399 para la zona 3 ¿Qué ganamos con ello? Como antes, claridad y orden. Pero algo más… orden de cara a futuro. Si vas a montar 3 periferias remotas y asignas las direcciones de I/O según te las asigna Step7 de forma automática, vas a tener todas las entradas y salidas seguidas como un paso doble Hasta ahí no habría mucho problema más allá de que como digo, queda más limpio saber que si te digo E 212.0 automáticamente sabes que te estoy hablando de una entrada de la zona 2 sin mirar absolutamente nada. Pero no solamente eso. En un futuro, puede que tengas que ampliar una de las periferias con una nueva tarjeta… pues como no hayas pensado en espaciarlas, no solamente no tendrás coherencia entre la numeración entre zonas, sino que dentro del mismo rack tendrás numeraciones altas y bajas ya que al añadir una nueva tarjeta, tendrás forzosamente que asignar un número más alto que el último que Step7 le asignó a la zona 3… que si es esta zona, no pasa nada, pero si es la zona 1 queda horrible. 147 Cómo programar Step 7 y no morir en el intento ¿Pero habría algún problema por ello? Ninguno, pero hombre, ya que estamos, además de que funcione, que parezca que le hemos dedicado 10 minutos a pensar cómo asignar las entradas y salidas ¿no? ¿Qué pasa con las marcas, temporizadores etc.? Análogamente, asigna rangos para el resto de elementos. Por ejemplo: Si estas en el transportador 1, que es el FC 110, pues asigna las marcas 110.0 – 119.7 para dicho transportador, si con ello te va a ser suficiente. Puedes dar un rango de marcas para las palabras, otro para las dobles palabras… etc. Dale al coco y haz tu propio esquema. Asigna nombres a las cosas Y donde digo cosas, me refiero a FC, FB, DB, Entradas, salidas, marcas, temporizadores… Si no pones nombre a las marcas e I/O va a ser muy complicado el mantener el programa, por no decir imposible. Es una locura encontrarte programas que no están comentados… pero nada comentados. Es para echarse a llorar cuando el programa es complejo. No hay forma de seguirlo muchas veces con comentarios, como para seguirlo sin una triste indicación de qué hace qué. Lleva mucho tiempo, y no siempre es fácil mantener la tensión de comentar todo, pero hay que intentar que todo esté razonablemente comentado. Una forma que yo suelo usar (y aquí cada maestrillo tiene su librillo) es la siguiente: Para las entradas y salidas, como nombre simbólico suelo poner el nombre del elemento de campo que es, por ejemplo el “25B3″ y como comentario qué es con palabras. Puedes poner el IME completo por ejemplo “+ZonaA25B3″ mientras que te entre en el campo de descripción de la variable. Las marcas/temporizadores etc. auxiliares las marco con su propia dirección “M17.5″ y en la descripción pongo “auxiliar”. Así indico que la marca es necesaria como un auxiliar pero que no sale de ese bloque y que no está usada de forma global en el programa. Buenas prácticas de programación en S7 Ya hemos visto las cosas que tenemos que tener en cuenta a la hora de organizar el programa, pero aún no hemos programado ni un segmento. Ahora van las propiamente dichas de qué hábitos debes adquirir. Apunta esta, grábala en letras de oro o haz lo que estimes oportuno pero: Sólo da valor a una variable/salida en un sitio 148 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: Sólo asignaré una salida en un sitio Asigna una marca de ciclo al principio del proyecto Como ya hemos visto es bastante práctico seleccionar la marca de ciclo al principio del proyecto de cara a que si en la puesta en marcha, o con la máquina ya funcionando te hace falta un tren de pulsos, dispongas de una forma sencilla de estos, sin tener que volver a compilar el proyecto y mandárselo al PLC pasando la CPU a stop, cosa que siempre no es posible en el momento que lo quieres hacer. 149 Cómo programar Step 7 y no morir en el intento Crear un Always_On y un Always_Off Esto más que una buena práctica, es un truquillo: si tienes una marca que esté siempre a cero y otra que esté siempre a uno, te ayudará a la hora de hacer pruebas, y desarrollar el programa en la línea ya que podrás hacer un bypass fácilmente a alguna condición, evitar que un segmento no se ejecute etc. También puedes coger el byte entero lleno de ceros, que te servirá para borrar datos usando el Sfc21 FILL. Para ello, simplemente tendrás que hacer un L0 T Mb0 O M1.0 ON M1.0 = M1.0 De tal forma que el byte 0 contendrás siempre ceros y el bit 1.0 estará siempre a 1. Tonto, pero útil. Deja espacio, sé generoso con el que venga detrás… Que muy probablemente puedas ser tú. Si vas a crear un DB donde almacenar datos para registro o intercambio con otros PLC por ejemplo, deja espacio libre para que en una eventual ampliación no haya que replantear nada ni hacer grandes modificaciones, sino que con tomar parte del espacio que este libre, sea suficiente. Lo mismo digo a la hora de asignar las entradas y las salidas, deja espacio para posibles nuevos actuadores o señales, de tal forma que una futura ampliación no provoque la ampliación de un bastidor porque en su día las entradas estaban usadas. Todo cuesta dinero, pero es necesario hacer ese esfuerzo porque a la larga, es más barato si luego no hay que echar nuevas mangueras, instalar más tarjetas etc. No seas un talibán de ningún lenguaje. Usa todos a tu antojo, pero con orden. Una de las entradas que más consultas recibe el blog es la de qué lenguaje elegir a la a hora de programar en Step 7. Lo que no saben, es que no hay respuesta absoluta para esa pregunta… pues depende. Acostúmbrate a usar todos los que quieras, cuando quieras. Personalmente no mezclaría en un bloque FUP con KOP, aunque sí cualquiera de ellos con AWL. No los mezclaría porque muchas veces no son traducibles entre sí, y al pasar de uno al otro, puede que el que dejas no sea traducible y se quede en un AWL difícil de digerir así de repente, obligándote a pasar de uno al otro para seguir fácilmente el programa. Pero por lo demás, cambia cuando quieras, prueba y disfruta de la variedad que ofrece Siemens en ese sentido. 150 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. Pantallas del HMI Decía Albert Einstein algo así como “si no puedo dibujarlo, es que no lo entiendo”. Además de una cita genial, me da pie a comentarte una cosa fundamental y que por ello lo he dejado para el final. A ver si me queda lo más claro posible: No programas para ti Las normas son para cumplirlas Intenta tener un poco de gusto ¡No programas para ti! No. No es un error. He puesto que ¡No programas para ti! dos veces. Con esta tres. ¿Qué quiero decir con esto? Pues eso, que el tipo que va a usar tu máquina probablemente no haya visto un programa en su vida (más que probable) y sinceramente, ni es relevante, ni le importa. Lo importante es lo que puede ver y hacer desde la pantalla. Mandos claros Información clara y completa, pero no excesiva Fácil de entender la navegación entre pantallas. Estéticamente agradable a la vista (dentro de lo que se pueda) Piensa que la persona que va a manejar la máquina, en general un operario de producción, no le importa ni cuantos motores tiene tu máquina, ni detectores, ni las filigranas que hayas hecho en el código. Hablando groseramente… se la pela. 151 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 40. 4 formas de hacer una copia de seguridad de un proyecto de step7 Realizar una copia de seguridad de un proyecto de step7 es una tarea común y simple. Pero parece que hay ciertas dudas al respecto. En un principio no hubiera hecho esta entrada ya que pensaba que todo el mundo sabe cómo salvaguardar el proyecto que tenemos entre manos… pues parece que no siempre es así, o hay al menos, ciertas dudas. Vamos por tanto a disipar dichas dudas, o al menos intentarlo viendo cómo hacer copias de nuestros proyectos, dos offline y 2 online. Copia de seguridad de un proyecto de step7 offline La primera es la más sencilla y la que estoy seguro que el 99,99% de la gente sabe (vamos a dejar un ínfimo porcentaje de gente realmente despistada)… que cómo no, es copiar a pelo el directorio del proyecto. ¿Con eso es suficiente? Sí. Si haces una copia del directorio del proyecto (con el proyecto cerrado completamente por si las moscas), y lo pegas en otro sitio, tienes una copia offline de tu proyecto. Fin. Bien vale. Te habrás escocido con esto. ¿Alguna forma más? Ummm sí. Hay una segunda forma, más políticamente correcta. Crear una copia de seguridad de un proyecto de step7 mediante archivado. Esta vamos a decir, que baja el porcentaje al 99%. La forma correcta a la par que elegante de hacer una copia de seguridad de tu proyecto que tienes entre manos, es archivando el proyecto. La forma es muy sencilla. Cerramos por seguridad todos los proyectos abiertos, y desde Archivo->Archivar. Ahí elegimos el proyecto a archivar. Luego nos preguntará si queremos dividir en trozos. Hoy en día no tiene mucho sentido por lo que decimos que no. Y ya está. Nos generará un archivo ZIP con nuestro proyecto. 153 Cómo programar Step 7 y no morir en el intento Crear una copia de seguridad de un proyecto de step7 online exacta. Una vez conectado al PLC, puedo crear un nuevo proyecto y borro el contenido que viene por defecto (generalmente la red MPI). Entonces, ahora Sistema destino ->Copiar en PG. Esto nos hará una copia idéntica del contenido actual del PLC, tanto de bloques como de la configuración de HW. Ahora bien, estamos perdiendo: Los comentarios de los segmentos. Nombres simbólicos de marcas y FC,FB etc. Nombres simbólicos de las variables del DB. Pero por otro lado, tenemos una copia exacta incluyendo los valores actuales de los DB (no de las marcas lógicamente). Crear una copia de seguridad de un proyecto de step7 online por carpetas La última forma de hacer una copia de lo que tenemos online, es crear desde la raíz del proyecto un nuevo programa Step7. (Botón derecho, Insertar nuevo objeto->Programa S7 Luego, nos ponemos online, y copiamos todos los bloques y los pegamos dentro de esa carpeta que hemos creado nueva. Tendremos que machacar el OB1 ya que lo incluye por defecto. Adicionalmente, copiaremos el archivo de símbolos y lo pegaremos en la nueva carpeta machacando el existente. De esta forma tenemos el contenido del PLC con el máximo información. 154 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 41. Cómo proteger bloques en Step 7… si puedes. Para terminar el libro quiero contarte cómo hacer para proteger bloques en Step 7. Como ves en el título he añadido la coletilla, si puedes. ¿Por qué digo esto? Porque te voy a enseñar cómo proteger tus bloques y también te voy a enseñar cómo esta protección la revienta un niño de seis años con conocimientos medios de informática. No te voy a enseñar a usar cualquiera de los programas que pululan por la red para desproteger los bloques. Vas a ver cómo con un programa de bases de datos (típicamente Access) puedes hacerlo en un minuto. Con ello no estoy alentado a la piratería, simplemente te enseño lo estúpido que es pensar que por proteger los bloques estos son invulnerables. ¿Proteger bloques en Step 7? ¿Para qué? Una de las cosas como cliente y sufridor de las máquinas que no llego a comprender en general es la actitud y empeño de ciertas empresas en proteger los bloques. Ya sé que puede que me vaya a meter en un jardín, pero no me importa compartir mi punto de vista contigo. Si no compartes mi visión lo respeto, pero esta es la mía, al menos a día de hoy. Por lo general las empresas que compran la maquinaria son clientes finales cuyo mercado dista bastante del fabricar y comercializar máquinas como las compradas. Por otro lado, y a poco grande que sea la empresa, serán sus técnicos cualificados quienes mantendrán las máquinas y tendrán que pelearse con el programa en caso de fallo o mal funcionamiento. Proteger los bloques implica que quieres ocultar el funcionamiento de la máquina ¿en serio? ¿En serio crees que habiendo comprado la máquina, el problema de replicarla va a ser el no tener el código del PLC? Tengo la máquina funcionando la cual puedo observar cada detalle y desguazarla si quiero Veo cada paso que da, cómo funciona y lo que hace. Tengo los esquemas eléctricos ¿Crees que con ello si una empresa quiere replicarte la máquina el problema es que no tiene el código fuente? 156 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: Si la tienes, sólo necesita saber cómo funciona para replicar el comportamiento Si no la tienes, por mucho que tengas el código fuente es como si me das un manual en marciano. Bajo mi punto de vista a ti como creador de nuevas máquinas no te van a contratar por tus conocimientos en sector X. Te van a contratar y comprar tus máquinas por los conocimientos, tu buen hacer y tu tiempo. Imagina que tu cliente tiene una fábrica de cementos. ¿Crees que le vas a enseñar algo en ese sector tanto en su proceso como en cómo deben ser sus máquinas que él te está pidiendo? Si él no las construye es porque o no tiene la gente capacitada para ello o no disponen del tiempo para hacerlo. En ninguno de los casos es un enemigo para tus intereses, y el compartir tu programa de tu máquina no hará más que mejorar las relaciones, no empeorarlas con discusiones absurdas que no van a ninguna parte. Como puedes imaginar como cliente y mantenedor quiero la disponibilidad de las fuentes para conocer mi máquina y poder solucionar los problemas que seguramente tiene. Aún no he conocido ninguna máquina que no se pare y que al pararse siempre sepas qué le pasa y todo esté bien documentado y con las alarmas pertinentes. A veces, hay que conectarse y ver qué le pasa y porqué hace o no hace tal o cual cosa. Eso no significa ni que esté mal programada ni que no esté bien documentada, pero es que todas las causas por las que se puede parar una máquina compleja es difícil de prever y por tanto es necesario conectarte y ver que diantre sucede. Y por último, como puedes imaginar, si estuviera de acuerdo con proteger a toda costa e know how, no estarías leyendo este blog, porque simplemente no existiría y feliz de mi, pensaría que por no compartir mis conocimientos, el resto de la Humanidad es tonta de baba y el más listo soy yo… En fin, que como digo no hace falta que estés de acuerdo conmigo, sólo quiero que veas, que en el caso de Siemens, cómo hacerlo sirve más bien para bien poco. Te dejo con el vídeo. 157 Cómo programar Step 7 y no morir en el intento 42. Conectar un LOGO 8 con un PLC en Step 7 Vamos a conectar un logo 8 con un PLC en step 7. Para ello, vamos a usar: Un Logo 8. Se trata del modelo LOGO 8 230 RCE (6ED1052-1FB00-0BA8) Un PLC 315-2 PN/DP (6ES7315-2EH14-0AB0) Logosoft V8 Step 7. La idea es simplemente enseñarte que puedes usar un LOGO como remota de un PLC y mandar o recibir instrucciones a un PLC o desde este de una forma sencilla. ¿Por qué usar un LOGO 8 como remota? Pues porque puede ser una solución enormemente económica en un entorno industrial (o no) si quieres controlar actuadores o señales analógicas y los quieres manejar desde un PLC. Piensa que el logo que te propongo puede conectase directamente a la red eléctrica y su precio es inferior a 150 euros. Conectar un logo 8 con un PLC en Step 7 La conexión va a ser sencilla. Vamos a crean un enlace S7 en la configuración de redes de la CPU 315 y por otro lado vamos a configurar la conexión en el logo para establecer esta misma conexión. Además, en el lado del logo vamos a definir las variables que queremos intercambiar ya que la conexión va a ser de tipo cliente. Es decir, será el logo el que establezca la conexión con el PLC (servidor) independientemente de que el logo envíe o reciba datos por parte de este. 158 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 43. PID en Step7: Ejemplo de control de temperatura Una de las aplicaciones típicas es hacer un control PID en Step7. Para ello en este capítulo vamos a ver qué elementos hardware vamos a necesitar, y qué bloques de S7 tenemos para dar forma a la solución del problema. Pero primero planteemos el problema: Queremos controlar la temperatura de una plancha la cual tiene para su calentamiento una resistencia y para su control una Pt100. La aplicación como ves es muy sencilla. Simplemente quiero controlar la temperatura de una placa que vamos a tener a XºC, por ejemplo a 85ºC. Para ello, vamos a hacer lo siguiente: Leer la temperatura de la placa Realizar la regulación PID y que me dé como salida un porcentaje entre 0 y 100% de potencia de la resistencia. Transformar ese porcentaje en un tiempo ON/OFF de la resistencia ¿Qué hardware vamos a necesitar? Para realizar esta sencilla aplicación vamos a tener que usar una tarjeta de entradas analógicas de tal forma que podamos leer. Yo he elegido una para la serie 300 que es con lo que vamos a hacer nuestro ejemplo (6ES7 331-7KF02-2AB0) Además, vamos a necesitar una salida digital que active nuestro contactor estático con el que activar y desactivar la resistencia. ¿Por qué un relé estático? Por una sencilla razón… vamos a hacer miles de maniobras al día. Además, vamos a hacerlo de tal forma que el periodo sea 1 segundo, de tal forma que el 100% esté siempre encendida, 50% medio segundo ON medio OFF y 0% pues apagada lógicamente. Estos requerimientos no hay relé mecánico que lo aguante sin pedir la baja voluntaria el primer día. 160 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. ¿Y qué hay del software? PID en Step7 En cuanto al programa, la verdad es que no tienen mayor historia. La idea como te he comentado es transformar la lectura de la temperatura en una salida digital que irá encendiendo y apagando la resistencias. Le meteremos impulsos más o menos largos en función de cómo de lejos estemos del Set Point elegido. Pero no nos tenemos que preocupar, porque del porcentaje de encendido/apagado se encargará el PID. Claro que un PID hay que configurarlo y es necesario dar la ganancia y las constantes derivativas e integral. Esto corre de vuestra cuenta averiguar qué constantes os van bien ya que la configuración del PID es harina de otro costal y no voy a entrar a ello. Lo que si te quiero comentar es que existe la herramienta de parametrización que puedes encontrar en: Inicio > Simatic > STEP 7 > Parametrizar Regulación PID. Como te decía, el cálculo del PID lo va a hacer el PLC ya que tenemos el bloque SFB 41/FB 41 “CONT_C” con el que podremos calcular la salida porcentual del encendido/apagado de la resistencia. Para echarlo a andar necesitaremos: El valor del Set-point de temperatura en real El valor de la temperatura leída en real Las constantes de ganancia, derivativa e integral Los márgenes de salida, que en nuestro caso serán de 0% a 100% Una variable de salida en real que nos dará el porcentaje de la salida. Una vez que tengamos cuánto tiene que estar encendida/apagada la resistencia, vamos a tener que transformar ese porcentaje en una salida digital de 0 ó 1. Imaginemos que el porcentaje de salida es un 68%. Eso significa y dado que el ciclo lo vamos a fijar en 1 segundo, que 68 centésimas de segundo estará a TRUE la salida, y 32 estará apagada. Esto suscita la siguiente pregunta 161 Cómo programar Step 7 y no morir en el intento ¿Cómo vamos a hacer ese reparto de tiempos? Fácil. Vamos a crear un índice que se mueva entre 1 y 100. Entonces comparamos la salida de potencia con este índice, y mientras que la potencia sea igual o superior, ponemos la salida a 1. En fin, que para una mejor comprensión, te dejo con un video como siempre. Referencias: Proporcional integral derivativo PID Theory Explained Practical Process Control Regulación PID qué es y como se ajusta PDF de cómo ajustar el PID: EnergéticaXXI_Octubre_2005 162 Cómo programar Step 7 y no morir en el intento 44. Configuración de un variador Micromaster 420 Una de las cosas que no suele faltar en una automatización suele ser un variador. Unas veces cableado, otras veces, como en el ejemplo de hoy conectado vía Profibus. Para poner un variador de este tipo conectado por Profibus se va a necesitar el siguiente hardware: Un variador Micromaster 420 (410, 430 o 440 también nos vale) Una tarjeta de red Profibus para estos variadores. Una BOP al menos básica (Basic Operator Panel) Por otra parte, vamos a necesitar al menos el GSD en la parte del software para poderlo configurar. Si no lo tienes, lo puedes bajar de la página de Siemens, aunque debe venir un CD con el variador con toda la documentación y el software Starter con el que poder configurar el variador, lecturas etc. Pero obviando este software, vamos a configurarlo simplemente con nuestro GSD y una pequeña configuración del propio aparato, ya que poner el aparato en marcha no va a ser tan inmediato como conectar el variador en red y ya, sino que vas a tener que configurar el aparato al ponerlo en servicio y decirle que lo vas a conectar por Profibus. Pero no te preocupes. Estás de suerte, te voy a contar cómo ;) Configuración básica de un variador Micromaster – El variador Configuración de la dirección Profibus Lo primero que tenemos que hacer es montar todas las partes, el convertidor propiamente, la tarjeta Profibus y el display (BOP). Después de montar la tarjeta Profibus, lo mejor es darle la dirección Profibus usando los DIP de la imagen (las pestañitas naranjas) Digo esto, porque a pesar de que se puede configurar la dirección Profibus a través de los menús (parámetro P0918), a mi juicio es mejor ya que te despreocupas de la configuración en este aspecto. Siempre tendrá la dirección DP asignada aunque cambies el convertidor. Hay que tener en cuenta la advertencia del manual: La modificación de los interruptores DIP se debe realizar con el convertidor desconectado (sin tensión) (en un módulo de comunicación ya montado). 163 Cómo programar Step 7 y no morir en el intento La modificación de los interruptores DIP sólo es efectiva tras arrancar de nuevo el módulo PROFIBUS. Este reinicio se realiza desconectando y conectando la red,siendo válido esto tanto para alimentación por convertidor como por cableado separado a 24V. Puesta en servicio del variador Lo primero que debemos hacer para poner el variador en servicio es ajustar el parámetro P0010 = 1. Una vez hecho esto, realizaremos los ajustes en los parámetros. Os adjunto un ejemplo con el listado: Introduciremos todos los parámetros necesarios del motor, aceleraciones, velocidades etc y nos aseguraremos de que los parámetros P0700 y P1000 tienen valor = 6, ya que le vamos a dar la consigna vía profibus. Una vez terminada la secuencia de puesta en servicio ajustaremos P3900 = 1 para llevar a cabo los cálculos del motor y borrar todos los demás parámetros (no incluidos en el P0010=1) a sus valores por defecto. Una vez hecho esto, ajustaremos otros parámetros que no estén incluidos en el listado, como la configuración del relé de freno (P0731), por poner un ejemplo. Con esto el variador estaría preparado para trabajar. 164 Cómo programar Step 7 y no morir en el intento Configuración básica de un variador Micromaster – El proyecto. Bien, ya tenemos todo preparado para mandar al estrellato a nuestro variador. El problema ahora es solamente de meter dicho variador en nuestro proyecto. Es fácil. En el configurador de HW hacemos lo siguiente: Añadimos el variador. El GSD lo encontraremos en nuestra biblitoteca, cambiando el perfil a DriveES y dentro de este, en SIMOVERT-> Micromaster 4 Una vez introducido, pincharemos dos veces sobre él y nos aseguramos que en la configuración tenemos seleccionado Telegrama PPO3 sin PKW Miramos la dirección asignada del byte de entradas y el de salidas ya que nos va a hacer falta. Bien, he de decir que vamos a hacer una configuración básica del variador. Esto implica que por defecto, le vamos a mandar dos palabras de mando y nos va a devolver dos palabras de estado. Las palabras de mando van a ser: Una serie de booleanas con marcha, sentido de giro, acuse de alarmas etc. Una palabra con la velocidad seleccionada. Por su parte, el variador nos va a devolver dos palabras: Una serie de booleanas con los estados básicos de listo, marcha, fallo, alarma etc. Una palabra con la velocidad real. Es posible configurar el variador para mandar más parámetros y poder cambiarlos. En las referencias os dejo los manuales para que practiquéis con ello ya que la idea es poner el variador en marcha en su forma más básica. Bits de mando Os dejo la palabra de mando aunque en el manual lo tenéis también. Ojo porque como siempre primero es el byte alto y luego el byte bajo. Así, suponiendo que la palabra de mando fuera el AW256, la señal de marcha (bit 0) sería la A257.0 165 Cómo programar Step 7 y no morir en el intento La palabra de estado Igualmente, suponiendo que la palabra de estado fuera el EW256, el bit 0 será la E257.0. También está en el manual. 166 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: Módulo adicional profibus Parámetros Micromaster 420 168 Cómo programar Step 7 y no morir en el intento 45. Entradas analógicas 4-20mA en S7 La situación de partida sobre un problema sería algo así como… (..) Es un transductor Danfoss de 4 a 20 mA 2 hilos. La idea es hacer que se dispare una alarma si la presión del aire disminuye a menos de 100 psi y si sube a más de 120 psi, es decir la presión siempre debe estar entre 100 y 120 psi. (..) y también me gustaría que la podamos visualizar en WIN CC… Vamos a ver los siguientes conceptos para resolverlo: Elegir y configurar la tarjeta de entradas analógicas Programar la alarma pertinente de alta y baja Graficar la presión en nuestro HMI usando WinCC Hay diversos modelos de entradas analógicas. La que yo he elegido para este caso es 6ES7-331-7KF02-0AB0, o lo que viene siendo una tarjeta de entradas analógicas con aislamiento galvánico de 9/12/14bits. Lo primero que vamos a hacer es configurar la tarjeta. Para ello, vamos a elegir como muestra en la figura: TM2H ya que es entrada en corriente 4..20mA a dos hilos, que son los requerimientos planteados. Por otro lado, como bien indica la imagen adjunta, habrá que cambiar la posición del adaptador trasero de la tarjeta de tal forma que esté configurado en su posición D. 169 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 Para programar la alarma, simplemente vamos a leer la señal recibida y si es inferior al valor parametrizado dará alarma de baja y si se superior al valor superior establecido dará alarma de alta. Además, configuraremos una tercera alarma que es que la lectura debe estar entre 4000 y 20000 ya que de no ser así es que algo pasa en la instalación. A la hora de programar las alarmas de alta y de baja, y aunque no sea el caso, es conveniente filtrar dichas alarmas, esto es, temporizarlas de tal forma que un pico bien por arriba o por abajo, no de alarma ya que podemos considerarlo como un transitorio o un pequeño ruido en la señal que hay que tratar como tal y por tanto que no nos dé una falsa alarma. Este tiempo ya es para gustos y necesidades y puede variar desde tiempos muy cortitos hasta de varios minutos en función de qué estemos hablando. Graficar la señal Una vez tengamos todo preparado, sólo nos quedará graficar dicha señal. Para ello vamos a usar la variable de la presión y dos constantes, que serán los límites superior e inferior. No me voy a extender más en la explicación de cómo hacerlo ya que lo mejor es que lo veas en el siguiente vídeo. 171 Cómo programar Step 7 y no morir en el intento 46. Cómo observar y forzar variables en Step 7 Para poder acceder a esta ventana, accederemos desde el editor como se indica en la figura: Sistema destino –> Observar/forzar variables ¿Qué se puede hacer? Pues el propio Siemens lo indica en la ayuda. Con las funciones de “Observar/forzar variables” es posible: Observar los valores actuales de variables concretas de un programa de usuario o de una CPU en la PG/en el PC: Observar variables Asignar valores fijos a variables concretas de un programa de usuario o de una CPU: Forzar variables Asignar valores fijos a salidas de periferia concretas de un programa de usuario o de una CPU en estado operativo STOP: Desbloquear salidas y Activar valores de forzado. Ocupar con carácter fijo variables concretas de un programa de usuario o de una CPU con un valor que el programa de usuario no pueda sobrescribir: Forzado permanente de variables En general, para lo que se va a usar es para ver el estado de las variables y poder forzar el estado de marcas o asignar valores. Ojo, porque estos valores puede que los fuerces e inmediatamente tomen el valor que el programa les asigna. Esto va a hacer que parezca que no ha sucedido nada como veremos en el vídeo. 172 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 Además de lo dicho, se puede: Colocar comentarios usando como en el editor en AWL dos barras (//).observar y forzar variables en step7 173 Cómo programar Step 7 y no morir en el intento Añadir áreas de memoria de forma rápida (botón derecho-> Añadir área) Finalmente decir que puedes guardar estas simulaciones dentro del proyecto mediante archivos VAT. Esto deberás hacerlo en la misma carpeta que tengas el proyecto con los bloques. 174 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
