Programación

Empecemos a programar.

El programa o la base de nuestro programa, se escribe en el bloque de organización (OB1), este programa se escribe en los segmentos del bloque, en lenguaje que hayamos elegido para ese segmento.

Podemos crear nuestro programa en este bloque, pero si este es extenso, lo mejor es estructurarlo en FBs o Fcs para una mayor y mejor compresión del programa. También podemos crear otros OBs para la atención de eventos, alarmas y errores de nuestro bloque principal.

Que son las FB y FC.

Son otros bloques lógicos, que son llamados por otros FB,FC o OB a modo de subrutinas, que cuando se ejecutan realizan las tareas asignadas y a su termino devuelven el control al bloque que realizo la llamada.

Como funciona una FB.

El bloque que efectúa la llamada transfiere parámetros al FB e identifica un bloque de datos determinado (DB) que almacena los datos de la llamada o instancia específica de este FB. La modificación del DB instancia permite a un FB genérico controlar el funcionamiento de un conjunto de dispositivos.

Como funciona una FC.

Una función (FC) es una subrutina que se ejecuta cuando se llama desde otro bloque lógico (OB, FB o FC). La FC no tiene un DB instancia asociado. El bloque que efectúa la llamada transfiere los parámetros a la FC. Los valores de salida de la FC deben escribirse en una dirección de la memoria o en un DB global.

Como puedes ver, este tipo de función es el mas parecido a las subrutinas, que se tratan con el S7 200.

instrucciones básicas.

Vamos a ver unas cuantas instrucciones básicas y mas utilizadas a la hora de crear un programa. Sin lugar a duda la mas utilizada va ser el contacto abierto o cerrado, que podremos arrastrar desde la carpeta, “operaciones lógicas de bits” en la pestaña de herramientas, o bien si tenemos montada la interfaz de bloque, desde allí, lo podemos arrastrar asta el segmento deseado y empezar a crear la lógica de ese segmento.

Los Temporizadores

En toda función, (OB,FB,FC) hay que declarar el temporilizador que vamos a usar, para ello ir al simbolo de cuadro vacio en la interfaz de bloque y arrastrar asta el segmento que nos interese, en el simbolo de cuadro vacio pulsar sobre "??" y en el menú contextual elegir función que va a realizar (TON, TOF, ...) pero, elegir el símbolo que es parecido a un enchufe de color azul y que no es otra cosa que un bloque de organización. Después se abre una ventana para dar nombre y orden a la base de datos, ya tenemos el bloque del temporizador, ahora nos queda dar valor a “PT” que lo debemos hacer como una variable de tipo TIME, constante o indirectamente y en el que vendrá reflejado el tiempo en milisegundos que nuestro temporizador estará poniendo o retrasando la puesta a nivel alto de la salida “Q”, en la que conectaremos lo que queramos activar.

La salida ET, no es otra cosa que el tiempo que nos queda de la temporalización, el dato de salida de la variable es de tipo TIME.

Las bases de datos de las temporizaciones, las podemos ver en la ventana del árbol de proyecto, iremos al menú del proyecto, opción, Bloques de programa > bloques del sistema > recursos del programa > y aparecerá un listado con las bases de datos que estamos utilizando.

Otra manera de colocar una temporización en un segmento de la ventana de programación es,

ir a la pestaña de “instrucciones” abrir carpeta de “temporizadores” y elegir el bloque temporizador (recuerda el que tiene forma de enchufe y es de color azul) que nos interesa y arrastrar asta el segmento.

Arrancar una temporización

Una vez ya hemos declarado la temporización, la podemos arrancar desde la misma declaración poniendo a uno la entrada “IN”. Pero si en otra parte del programa nos hace falta volver a arrancar la temporización no hace falta que la volvamos a declarar , simplemente iremos de nuevo a la pestaña instrucciones elegiremos la carpeta temporizadores y arrastraremos alguno de los símbolos que están poniendo entre paréntesis el tipo de temporalización que deseamos arrancar y lo arrastraremos al segmento que nos interese, una vez allí, lo configuraremos haciendo referencia al temporizador que deseamos arrancar.

descarga el programa en este enlace:
Temporizadores

Temporizadores del S7 1200, Casos prácticos.

A un que lo explicado con anterioridad en el tema de los temporizadores está en lo cierto, tengo que aclarar unas cuantas cosas. Cuando el dato de tipo “time” es colocado de manera directa en la entrada PT del temporizador este arrancara de forma inmediata una vez activada la entrada IN en caso de ser el temporizador del tipo TON este arranca y una vez trascurrido el tiempo que marca PT la salida Q pasa a nivel alto habiendo hecho correctamente su función.

Pues bien, esto mismo ocurre si PT recibe el dato de una variable tipo marca del autómata.

La cuestión cambia y bastante, cuando la variable es de una función FC o FB y el temporizador esta en la OB es decir el dato de tiempo de PT nos viene de una función. Aquí tendremos que actuar de otra manera por supuesto que tendremos que arrastrar la función del temporizador que queramos usar hasta su segmento en OB y ademas la instrucción de arranque correspondiente al tipo que usemos. Una vez la función de temporizador este en su sitio y la instrucción de arranque en el suyo, la forma de hacer que el temporizador funcione es la siguiente para los tipos TON y TOF.

1. Tenemos que arrancar el temporizador con la instrucción -(TON)- o -(TOF)- ,esta acción no disparara el temporizador.
2. Pondremos la entrada IN de la función del temporizador a nivel alto si es un temporizador TON provocara que este realice su función de activación de la salida Q trascurrido el tiempo de  PT. Si es un temporizador TOF después de arrancar debemos de poner a nivel alto la entrada IN y cuando la pongamos a nivel bajo se activara el temporizador, pasado el tiempo PT se desactivara la salida Q.

Hay que advertir que no podemos activar a la vez la o con la misma señal la entrada IN y el arranque por que si no el temporizador se bloquea y no realiza su función.

Con el temporizador TP ocurre algo bien distinto a lo narrado con anterioridad, pues este si que arrancara una vez hallamos activado la instrucción de arranque de TP sin necesidad de llevar la entrada IN de la función a nivel alto.

El Contacto de temporizador que vemos a la entrada IN del temporizador TP es el de la fotografía anterior y corresponde al temporizador IEC Timer 0 DB 12. Se puso hay para evitar la activación simultanea del arranque y puesta a nivel alto de IN, pero luego se pudo comprobar que no servia de nada puesto que con la llamada de la instrucción de arranque el temporizador TP ya realizaba su función.

Uso de temporizadores en programación SCL.

He creado un pequeño programa que creo que ayudara a aprender como usar las temporizaciones en programación SCL. Este programa lo que hace es uso de las tres temporizaciones mas usuales, TON, TOF y TP, su funcionamiento es el siguiente, en la entrada I0.0 tenemos un interruptor, cuando este es cerrado la entrada de disparo IN del temporizador TP pasa a nivel alto lo cual provoca el disparo de de la temporización pasando a nivel alto la salida Q de TP y permanecerá así hasta que termine el tiempo fijado en la entrada PT.

La temporización TOF se inicia o arranca cuando cuando la salida Q de TP pasa a nivel bajo, después del tiempo fijado en la entrada PT de TOF su salida pasara a nivel bajo también. Por si no queda claro, cabe indicar que la salida Q de TOF desde el primer momento que arranca el programa la salida Q de TOF a estado a nivel alto y que una vez pasa a nivel bajo la salida Q de TP es cuando se inicia la temporización, por eso se llama retardo a la des-conexión.

La temporización TON es arrancada cuando el interruptor de la entrada I0.0 es cerrado, pasando a nivel alto la entrada IN de TON y trascurrido el tiempo fijado en PT de TON la salida Q de TON pasara a nivel alto, quedándose así hasta que se reinicia la temporización mediante una instrucción

RESET_TIMER, si no hacemos uso de esta instrucción, las temporizaciones no vuelven a arrancar a un que abramos y volvamos a cerrar el interruptor de la entrada I0.0.

No se si os habéis dado cuenta de una cosa, sobretodo cuando he explicado el funcionamiento de TON, pero existe una diferencia de funcionamiento cuando se usa la temporización TON en lenguaje de programación SCL a KOP, sobretodo si el tiempo fijado en PT es de forma directa (T#2s), en programación KOP, cuando la entrada IN cambia de estado de alto a bajo y volvemos a alto la temporización TON se ha reiniciado sola. Si el tiempo en PT es fijado de forma indirecta mediante una variable funciona igual que en SCL.

Cosas a tener en cuenta a la hora de trabajar con las temporizaciones.

Como podéis observar en la imagen de bloques del programa el estado de la entrada I0.0 es la que dispara las temporizaciones TP y TON, a un que esto se vera mejor leyendo el programa del bloque, si la entrada esta a nivel bajo, retorna del bloque sin hacer nada. Si la entrada esta a nivel alto, dispara las temporalizaciones, estando estas temporalizaciones activas volvemos a poner la entrada a nivel bajo durante un breve instante sin que llegue a superar el tiempo de PT, volvemos a poner la entrada a nivel alto no ocurrirá nada. Pero si una vez activadas las temporalizaciones dejamos en nivel bajo la entrada I0.0, por tiempo superior al de PT o indefinido las salidas Q de las temporalizaciones podríamos decir que se quedan “congeladas”, es decir si las salidas las teníamos activas a nivel alto así se quedan de forma permanente aunque halla trascurrido el tiempo de PT. Solo se actualizaran los estados de las salidas cuando la entrada I0.0 vuelva a estado alto entonces se actualizaran.

Esto es importante a tener en cuenta, por que si se nos ocurre poner una temporalización dentro de una sentencia WHILE_DO o como en el programa una IF esta tendrá que mantener la condición, hasta que la temporalización halla acabado por que de lo contrario ya sabemos que la salida Q de la temporalización se puede quedar congelada.

Si quieres puedes descargarte el programa en el siguiente enlace:

https://drive.google.com/folderview?id=0B_H6mOzK5877fkhVZHlzY1ZIQUlTMzN6MnluaGhOaWsxZExHR2tTU0dIWGI2clYxZkQxaDg&usp=sharing

Contadores básicos en el S7 1200

Al igual que ocurre con las temporizaciónes los contadores son también un “objeto” por lo tanto también tienen una base de datos. El proceso para crear el contador es idéntico al del temporizador, los dos caminos explicados para colocar una temprización en el segmento, es hacer lo mismo para el contador.

La diferencia entre el contador y el temporizador a parte de su función propia, es a la hora de activar su tarea o marcha, mientras en la temporización tenemos que declarar el objeto y que este mismo ya realizara su trabajo, pero, si posteriormente queremos volver a utilizar esa misma temporización debemos utilizar una instrucción propia de arranque para volver a usarla. El contador no tiene instrucciones de arranque a parte del propio objeto por lo tanto debemos de usar un objeto contador cada vez que nos haga falta.

Puesta en marcha de un contador

Una vez colocado el contador en el segmento deseado debemos de conectarlo.

• CU es la entrada que nos registra los pulsos que va a contar el contador.
• R es el borrado del contador “reset”.
• PV es el valor máximo que deseamos que cuente y que provocara la activación de la salida Q, el tipo de dato siempre entero (int o Dint).
• Q como ya e dicho es una salida de tipo binario que pasa a estado alto una vez se a alcanzado o superado el valor de PV.
• CV es el dato que nos indica cuanto nos falta para llegar a el valor tope indicado en PV.

Los dos tipos de contadores que nos quedan son el, descontador y contador-descontador. El descontador es lo mismo que el contador, pero con la diferencia que PV tiene el valor a partir del cual empezara a descontar y desaparece R y tenemos LD, que lo que hace es volver a cargar el valor de PV he iniciar de nuevo el descontaje.

El contador-decontador no es otra cosa que un contador reversible es decir la suma de los dos anteriores si los pulsos los recibe la entrada CU el contador cuenta y una vez alcanzado el valor de PV activa QU. Si los pulsos los recibe CD descuenta y cuando llega a cero activa la salida QD.

Descarga el programa desde este enlace:
Contador

Crear una Función FC

Crear un FC es sencillo, tenemos que ir a la ventana del árbol de proyecto, pulsar dos veces seguidas sobre la opción de menú “Agregar nuevo bloque”, se nos abre una ventana nueva donde tenemos que elegir, bloque, función o DB, evidentemente tenemos que elegir función FC, posteriormente tenemos que dar nombre a la función, numerar y aceptar. Dicha función nos aparecerá en el árbol de proyecto y si queremos trabajar dentro de ella solo tenemos que pulsar dos veces seguidas sobre la misma y en la ventana, interfaz de bloque nos aparece el primer segmento de la función listo para ser escrito.

Para realizar la llamada de la función desde OB, tenemos que proceder de la siguiente forma , nos dirigiremos nuevamente al árbol de proyecto situaremos el cursor sobre el bloque FC 1 y lo arrastraremos asta el segmento que nos interesa de la ventana de interfaz de bloque y soltaremos el cursor. Si la llamada va a ser condicionada evidentemente la lógica programada tendrá que ir delante del bloque FC1.

Como interactua FC con OB

Lo puede hacer de dos maneras diferentes usando las marcas de memoria o mediante una base de datos global.

Mediante las marcas lo que hace FC cuando se ejecuta es leer las que le hacen falta para su ejecución y vuelca el resultado en otra marca de las variables del PLC así de sencillo.

En cuanto a la DB global es que en esta introduciremos todos los datos o variables en la DB, menos, las variables que hagan referencia a entradas y salidas del autómata por que estas no funcionaran.

Lo que la DB hace es de intermediario entre FC y OB, la DB puede ser leída y escrita por otras funciones que harán uso de los datos a su antojo. Otras ventajas de usar DB es que estas se pueden copiar, guardar o enviar fácilmente en otros dispositivos.

Un ejemplo podría ser, un autómata recibe información de unos dispositivos externos que mandan una DB con información conformada entre ambos, esta información es procesada por el autómata y devuelve el resultado al dispositivo solicitante mediante una DB de respuesta. Si esto lo hiciéramos con variables del PLC cada dispositivo tendría que tener sus variables reservadas en el PLC con el consiguiente ocupación de memoria que ello tendría al igual que cada dispositivo le tocaría tener una FC propia por lo tanto mas consumo de memoria del PLC.

Descarga los programas de los siguientes enlaces:
programa con una FC

FC con DB global

Crear una Función FB

Quisiera poder seguir con el tema de las funciones y ahora le tocaba a las FB, pero, a surgido un problema y es que aunque TIAportal, deja que las creemos no podemos programarlas ni en KOP ni FUP solo en SCL, intentarlo vosotros y veréis, que cuando indicáis un lenguaje distinto al SCL, creamos el bloque de FB y después creamos y abrimos la DB no os deja meter ninguna variable en la DB.

Por lo tanto, no nos queda otra que meternos con la programación en SCL.
sirva como ejemplo, los programas de ajuste de reloj que se trata a continuación.

Copiar funciones.

Puede ocurrir que necesitemos crear una función idéntica a otra que ya tenemos en el mismo programa, por ejemplo una función controla las horas que esta funcionando un motor y resulta que tenemos dos motores mas que controlar, como lo hacemos?. Volvemos a escribir nuevas funciones idénticas a la anterior ?. No es necesario, podemos hacer una copia de la primera función, pero, con una serie de cosas a tener en cuenta pues esto no es solamente hacer click con el ratón y elegir la opción de copiar.

1. Situaremos el cursor sobre la función a copiar en el árbol de proyecto haremos click con el botón derecho del ratón se abre un menú elegimos la opción copiar y aparece debajo de la actual la función copiada.
2. Ahora nos situaremos sobre la función copiada, seleccionamos, click con el botón derecho del ratón, se abre el menú y elegimos propiedades, se nos abre otro menú el la opción de General, nos aparecen varias entradas por si queremos cambiar los datos de alguna, en la entrada “Nombre” nos aparece el nombre de la función copiada guión mas un numero, este sera el nombre de la nueva función y el que si debemos de cambiar es el de la entrada que tenemos de bajo de “Tipo” que es “numero” y pondremos si es la primera copia un “dos” e iremos aumentando el numero según las copias que hagamos de la primera función.

Con los pasos anteriores tenemos copiada la función primera, si queremos mas copias de la función original tenemos que repetir estos pasos.

Pero no hemos terminado, si dentro de la función copiada hay instrucciones que usan DB (como es el caso de temporizadores, contadores, etc.). Tendremos que buscarlas en las funciones copiadas y volverlas a escribir para que se genere una DB nueva para esa instrucción, de lo contrario la función no funcionara correctamente cuando la probemos.

Con las variables o “Tag” no hay problema, pueden usar el mismo nombre que la función original.

El reloj del Siemens S7 1200.

Con el reloj del autómata podemos hacer bastantes cosas. Lo primero que tenemos que aprender es a ponerlo en hora, para seguir, con diferencias de tiempo, contadores de funcionamiento y cambios de horarios.

Tipos de datos de fecha y hora que manejamos.

Tipo de dato	Tamaño	Rango	Ejemplos
Time	32bits	T#-24d_20h_31m_23s_648ms a T#24d_20h_31m_23s_647ms Almacenado como: -2.147.483.648 ms hasta +2.147.483.647 ms	T#5m_30s T#1d_2h_15m_30s_45ms TIME#10d20h30m20s630ms 500h10000ms 10d20h30m20s630ms
Date	16bits	D#1990-1-1 a D#2168-12-31	D#2009-12-31 DATE#2009-12-31 2009-12-31
Hora	32bits	TOD#0:0:0.0 a TOD#23:59:59.999	TOD#10:20:30.400 TIME_OF_DAY#10:20:30.400 23:10:1
DTL	12bits	Mín.: DTL#1970-01-01-00:00:00.0 Máx.: DTL#2554-12-31-23:59:59.999 999 999	DTL#2008-12-16-20:30:20.250

Creo que con esta tabla quedan muchas cosas claras de como utilizar los datos del reloj y sus posibles usos.

Falta añadir, que el tipo de dato DTL solo es posible su utilización a través de la programación en SCL, no es posible su utilización ni en FOB ni KOP. Si queremos poner el reloj en hora mediante un programa este tendrá que estar escrito en SCL, la otra opción es a través de TIAPortal en la configuración de la CPU.

Para terminar y que no decaiga la moral, si queremos trabajar con el reloj en hora local lo tendremos que hacer con la instrucción RD_LOC, que utiliza la información de la zona horaria (GMT+1) para proporcionar la hora correcta de nuestro país. La instrucción RD_SYS proporciona la hora del sistema, esto quiere decir que GMT+0 siempre. Estas instrucciones solo se pueden utilizar en programación SCL.

Leer la hora del reloj.

Para hacer una lectura del reloj podemos usar dos instrucciones RD_SYS y RD_LOC, ya explicado con anterioridad la diferencia entre las dos, ambas funcionan igual salvo el tema de la zona horaria RD_SYS no la usa y RD_LOC si. He hecho un pequeño programa que podéis descargar, esta escrito en SCL y a continuación paso a explicar.

El programa a sido escrito dentro de una FC. La primera linea carga en la variable “Terror” el dato de tipo INT que devuelve la función RD_LOC, este dato es una indicación del funcionamiento del reloj, si su valor es cero quiere decir que los datos presentes a la salida de la función son validos, en dicha salida tendremos un tipo de dato DTL. Posteriormente comprobamos mediante una sentencia IF-THEN que los datos son correctos, si es así activamos la salida binaria de la FC “HoraOK” y la descomposición del tipo de dato DTL en tipos de dato Usint y Time_Of_Day o TOD. en la que las primeras tendremos una salida en la FC para la hora, minuto, día, mes y año, todas por separado y en la segunda el tipo de dato TOD con hora, minuto y segundo todo en una misma salida.

Si la variable “Terror” es distinta del valor “0” es decir se a producido un error en el reloj la salida “HoraOK” vale “0” al igual que el resto de salidas.

Listado de variables.

Fijaros en el detalle HoraDeCPU es una variable de tipo DTL que en realidad es una variable de tipo compuesta.

Enlace de descarga del Programa:

Ejercicio manejo del reloj 1

Nota: en la explicación digo que el programa se ha hecho sobre una FB pero el ejercicio lo he modificado sobre el original y esta hecho sobre una FC.

Pongamos el reloj en hora.

Como he escrito con anterioridad hay dos formas de poner el reloj en hora, una a través de la instrucción WR_SYS que comentare mas a delante, la otra mediante la configuración de la CPU, para ello iremos al, árbol de proyecto>> Dispositivo CPU >> Online y Diagnostico >> Establecer Conexión >> Desplegar Funciones >> Ajustar hora >> Aplicar.

Mediante la función WR_SYS, ajustamos solamente la hora y fecha del sistema, recordad que hora del sistema, no es la hora local; (H. Sistema GMT+0 y H. Local GMT+n).

Al igual que en la lectura del reloj empleamos una variable DTL, para escribir haremos lo mismo. Como ya sabemos el tipo de variable DTL, es una variable compuesta y no es necesario escribir en todo los términos, por ejemplo solo queremos escribir los que hacen referencia a la hora, minuto y segundo e ignorar los de la fecha, esto se puede hacer.

 

Descargar desde el enlace:
Ejercicio del manejo del reloj 2

Ver También:
Poner en hora el reloj del panel

Conversión analógica a digital con S7 1200.

En el S7 1200 tenemos dos entradas analógicas, en la parte superior de la CPU en el conector X11,

estas entradas solo leen valores en tensión de 0 voltios a 10 voltios suficiente para poder realizar algún que otro ejercicio interesante.

El ejercicio que he realizado consiste en leer la entrada analógica 0 y en función de su valor activar o desactivar las cinco salidas a relé que tiene la CPU. Para ello, utilizo un divisor de tensión compuesto por una resistencia de 15Kohm y un potenciómetro de 10Kohm, la salida intermedia del potenciómetro es la que va conectada a la entrada analógica de la CPU y en función de la posición del potenciómetro, tendremos un valor u otro de tensión a la entrada analógica 0.

La programación la he realizado nuevamente en SCL (para ir practicando), y utilizo las instrucciones NORM_X y SCALE_X, primero tenemos que normalizar el valor de la entrada entre dos valores uno MIN y otro MAX existente entre 0 y 27648. El valor de entrada tiene que ser del tipo real y la función nos devuelve otro valor normalizado entre el mínimo y máximo del tipo real, también a pesar de lo que dice el manual a mi no me ha dejado cambiar de tipo de variable por lo menos en programación SCL.

Una vez ya tenemos el valor de la entrada normalizado procedemos a escalarlo en este caso de 0 a 6

es decir los 27648 valores posibles estarán divididos en 6 partes. SCALE_X funciona de la misma forma que NORM_X tiene una entrada de valor y otras dos para el máximo y el mínimo de la escala

(ver fotografía de panel).

El programa sigue con una instrucción CASE, en la que, en función del valor devuelto por SCALE, activaremos unas salidas u otras yendo de estar todas desconectadas a conectadas en en función de como movamos el potenciómetro.

Descargare el programa en el siguiente enlace:

Ejercicio conversor analogico a digital

Como crear un programa en SCL.

Cosas a tener en cuenta si queremos que nuestro programa no genere fallos de ciclo.

Lo primero que tengo que deciros, es que la ejecución se realiza de forma lineal, linea por linea, es decir y para dejarlo de una manera muy clara, lee el programa en SCL igual que si estuviese escrito en FOP o KOP, no como un programa normal escrito en un lenguaje de programación tipo C+ o VB. Ademas tenemos que tener cuidado con los saltos dentro del programa por que se pueden quedar variables sin cambiar de estado por culpa del salto.

Voy a poneros un ejemplo, imaginaros que tenemos una variable tipo booleana, que llamaremos Var

esta variable si esta a 1 activa una temporización, pero antes de llegar a la linea que la activa tenemos una instrucción IF, que en función del valor de esa variable u otra puede provocar un salto a otra linea del programa sin pasar por la linea que activa la temporización. Que es lo que ocurre? Pues que aunque Var halla cambiado de valor, al haberse producido el salto, en esa linea en concreto donde se activa la temporización Var sigue valiendo 1.

Tened esto en cuenta, por que en otros lenguajes de programación esto no ocurre y si estáis acostumbrados a que sea así puede traeros problemas, a la hora de poner el programa en funcionamiento.

El sistema operativo del autómata realiza una lectura cíclica de nuestro programa ese ciclo se puede controlar su tiempo de duración (mínimo 150ms y máximo 6000ms) esto se hace así para evitar bloqueos del programa si trascurrido el tiempo máximo que le hemos configurado a la CPU el sistema operativo genera una alarma que hace que el sistema operativo busque la OB 80 es la encargada de registrar el fallo que ha realizado el programa y evitar el bloqueo de la CPU pero trascurridos unos pocos ciclos mas si el fallo persiste acaba bloqueándo la CPU.

Os cuento esto por que ciertas instrucciones pueden provocar fallos de ciclo si no son usadas correctamente.

Instrucciones FOR NEXT, WHILE DO, REPEAT-UNTIL.

Estas instrucciones pueden provocar fallos de ciclo y consecuentemente bloqueo de la CPU sino se usan correctamente, que quiere decir esto?

Voy a poneros un ejemplo, ya que en el manual de programación del S7 1200 trae a bastante confusión debido pienso yo a una mala traducción que se ha podido hacer del original.

WHILE (#RiegoDomingo = TRUE)DO

IF (#EHoraCalendario.HOUR >= #IRDomingo AND #EHoraCalendario.HOUR <= (#IRDomingo + #TRDomingo)) THEN #Sector1 := true;#BombaRiego:= true;

ELSIF (#EHoraCalendario.HOUR > (#IRDomingo + #TRDomingo)) THEN #BombaRiego := FALSE; #Sector1 := false;

END_IF;

#VisInicioReg := #IRDomingo; #VisiTiempoReg := #TRDomingo;

EXIT;

END_WHILE;

Aquí os pongo un ejemplo con una instrucción WHILE, fijaros bien donde esta situada la instrucción EXIT. Por que esta situada ahí y para que sirve?.

Si olvidamos de poner la instrucción EXIT lo que ocurrirá es que si la condición de WHILE es cierta se ejecuta de forma permanente esta rutina hasta que salta la alarma de tiempo de ciclo excedido. EXIT lo que hace es que una vez ejecutada la rutina el programa continué su marcha por eso se coloca al final de la rutina.

En las de mas instrucciones hay que hacer lo mismo. 

Capturar un momento, en programación SCL y las instrucciones

R_TRIG y F_TRIG.

A quien no le interesa capturar un momento o instante en función de la activación o desactivación de una señal de entrada, salida o variable y no estoy hablado de usar eventos (interrupciones) no!!.

Vamos hacer algo más sencillo y creo que muy útil para ciertos casos, por ejemplo, cuando se activa una entrada del PLC queremos saber a que hora se ha activado y a que hora se ha vuelto a desactivar y que estos datos, queden registrados para una posterior consulta. Si esto lo intentamos hacer sin usar estas instrucciones os digo que es prácticamente imposible, o nos sale un programa muy complicado.

Como funciona R_TRIG, cuando la entrada clok de la instrucción que sera una variable (Tag), cambia de estado de 0 a 1, en este flanco de subida se dispara la salida Q de R_TRIG y queda activa durante ese ciclo de la maquina en el que ha ocurrido el cambio de estado, en los siguientes ya no permanece activo. Esto ya se que choca con lo que dice la ayuda de TIA portal e incluso el manual, pero si miráis los ejemplos que pongo en este texto podéis juzgar por vosotros mismo y si creéis que me equivoco hacedme lo saber.

Como iba diciendo la salida Q permanece activa durante el ciclo en el que se produce el cambio de estado, circunstancia que aprovecharemos para realizar la captura de algún dato que nos interese, en este caso registrar la hora en que se activa una salida. Para ello nos ayudaremos de la instrucción WHILE DO dentro de esta sentencia colocaremos las instrucciones necesarias para leer el reloj y guardar esa lectura en una variable para su registro. Una vez terminado el ciclo del flaco la condición de WHILE cambia y ya no vuelve a leer ni registrar el dato.

El funcionamiento de F_TRIG es igual que el de R_TRIG pero para el flanco de bajada.

Un ejemplo de uso de lo que aquí digo, lo tenéis en la pagina del blog, Mis programas, control de llenado de fosa, si os descargáis el proyecto en la pagina 39 a la 42 tenéis un ejemplo de uso de R_TRIG y FTRIG.

Si el ejemplo anterior os sabe a poco aquí os dejo otro es un desplazamiento de salida activa cada cinco segundos usando la R_TRIG y SHL que es la instrucción que hace el registro de desplazamiento.

ir al enlace:

https://drive.google.com/folderview?id=0B_H6mOzK5877ejZUWmI1dmVhd1k&usp=sharing