Simatic Step 7 Nivel Basico

1.- CONFIGURACION NUEVO PROYECTO
 
1.1.- Cuando arranquemos STEP 7 se abre la ventana Asistente de STEP 7, esta ventana la cerramos ya que vamos a crear nosotros el nuevo proyecto. Tan pronto se haya cerrado el Asistente de STEP 7 aparecerá el Administrador SIMATIC.
Los proyectos se estructuran de tal modo que permiten ordenar todos los datos y programas que se necesitan durante la programación.



1.2.- Desde el Administrador crearemos un nuevo proyecto, para ello haremos clic en el icono nuevo.

En la ventana nueva que nos aparece rellenaremos el nombre del proyecto, también podemos crear una ubicación para nuestro proyecto o dejar la ruta por defecto.


1.3.- Una vez creada la carpeta curso nos situaremos encima y con el botón derecho seleccionaremos "insertar nuevo objeto" > "SIMATIC 300"


1.4.- Una vez creado el sistema haremos doble clic en el Hardware.
En la configuración del hardware se determinan la CPU y todos los módulos contenidos en su sistema de automatización, utilizando para ello un catálogo de hardware.



1.5.- Una vez dentro del Configurador de Hardware procederemos a montar nuestro PLC, para ello lo primero que tenemos que insertar es un bastidor.

Nota: Si no aparece en pantalla la librería, podemos seleccionarla en Ver >Catalogo


Un bastidor 300 es un perfil standard, que utiliza Siemens para sujetar sus tarjetas de Simatic 300



1.6.- Después de configurar el bastidor tenemos que empezar a definir las tarjetas que queremos montar en el.

La primera tarjeta que insertaremos será una fuente de alimentación. Nos desplazamos por el árbol de la librería y buscaremos un módulo PS-300



1.7.- Configuración de la CPU.

Nos desplazamos por el árbol de la librería y buscaremos un módulo CPU-300, nosotros para las pruebas insertaremos en el módulo 2 una CPU 315-2 DP.

En cuanto arrastremos la CPU al chasis nos aparecerá un menú donde nos permitirá elegir varias opciones pero nosotros las dejaremos por defecto aceptándolo.



1.8.- Seguimos definiendo tarjetas, ahora vamos a insertar una tarjeta de entrada digitales, estas tarjetas las encontraremos en la carpeta DI-300.



1.9.- Para nuestras pruebas de esta curso vamos a utilizar salidas digitales para ello insertaremos una tarjeta, la buscamos en la carpeta DO-300.


1.10.- Una vez añadidas las tarjetas de entras y salidas cambiaremos las direcciones que por defecto nos ha puesto. Para ello haremos doble clic sobre las direcciones para abrir el menú propiedades, seleccionado la pestaña "direcciones" y quitando la pestaña estándar podremos cambiar la dirección.



1.11.- Antes de salir del Hardware guardaremos y compilaremos.

El configurador nos generara una estructura con unas carpetas de fuentes y bloques, dentro de estas carpetas nosotros programaremos nuestros bloques.



Ir a página: Temario

-----------------------------------------------------------------------------------------------------------------------------------------

Capitulo 2

2.- BLOQUES DE PROGRAMA Y TABLA DE SIMBOLOS
2.1.-Para crear programas, seleccione la carpeta "Bloques" ya creado y elija el comando de menú "Insertar nuevos objetos > Bloque". En el menú siguiente podrá elegir el tipo de bloque (p. ej. Función, bloque de función, bloque de organización, tabla de variables (VAT)). Una vez abierto el bloque (vacío), podrá introducir el programa en AWL, KOP o FUP, respectivamente.




En esta tabla explico una breve descripción de los bloques y funciones.



2.2.- Bloques de organización. Los bloques de organización (OB) constituyen un enlace entre el sistema operativo y el programa de usuario. Son llamados por el sistema operativo y controlan el procesamiento cíclico y controlado por alarmas del programa, el comportamiento de arranque del sistema de automatización y el tratamiento de los errores. Programando los bloques de organización se define el comportamiento de la CPU.



Insertaremos varios bloques (p.ej.OB32,OB82 y OB121), estos bloques están establecidos por el sistema con lo que no hace falta ponerles ni símbolo ni comentario, ya que lo define el sistema.

Ponemos encontrar ayuda de los OBs pulsando F1, teniendo selecionado la OB



2.3.- Bloques de función (FB)

Los bloques de función son bloques programables. Un FB es un bloque "con memoria". Dispone de un bloque de datos asignado como memoria (bloque de datos de instancia). Los parámetros que se transfieren al FB, así como las variables estáticas, se memorizan en el DB de instancia. Las variables temporales se memorizan en la pila de datos locales. Los datos memorizados en el DB de instancia no se pierden al concluir el tratamiento del FB. Los datos memorizados en la pila de datos locales se pierden al concluir el tratamiento del FB.

En estos bloques si definiremos el símbolo y el comentario, ya que nos ayudara a la búsqueda posterior de nuestro programa.


2.4.- Funciones (FC)
Las funciones son bloques programables. Una función es un bloque lógico "sin memoria". Las variables temporales de las FCs se memorizan en la pila de datos locales. Estos datos se pierden tras el tratamiento de las FCs. Para fines de memorización de datos, las funciones pueden utilizar bloques de datos globales. Como una FC no tiene asignada ninguna memoria, se han de indicar siempre parámetros actuales. A los datos locales de una FC no se pueden asignar valores iniciales.

En todos los bloques menos en los OBs mencionados en el apartado anterior, deberíamos rellenar su símbolo y comentario.



2.5.- Bloques de datos globales (DB)
Al contrario de los bloques lógicos, los bloques de datos no contienen instrucciones STEP 7. En cambio, sirven para depositar datos de usuario, es decir que los bloques de datos contienen datos variables con los que trabaja el programa de usuario. Los bloques de datos globales contienen datos de usuario utilizables desde otros bloques. 



2.6.- Los tipos de datos de usuario (UDT) son estructuras de datos creadas por usted mismo y que, una vez definidas, pueden utilizarse en todo el programa de usuario S7 de dos formas:

Como tipos de datos simples o como tipos de datos compuestos.
Como plantilla para crear bloques de datos de estructura idéntica.


2.7.- Tabla de variables (VAT).
En esta tabla podemos observar y forzar variables, a fin de comprobar su programa. Las tablas de variables no se cargan en la CPU, estas tabla se quedan en el configurador.



2.8.- Después de crear los bloques definidos en los apartados anteriores deberíamos tener en la ventada derecha del configurador lo siguiente.


2.8.- Editor de símbolos
Con el editor de símbolos se gestionan todas las variables globales. Se definen los nombres simbólicos y comentarios para las señales del proceso (entradas y salidas), las marcas y los bloques.

Ir a página: Temario


-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 3.1

3.1.LOGICA CON BITs

1. - Introducción

Las operaciones lógicas con bits operan con dos dígitos, 1 y 0. Estos dos dígitos crean un sistema numérico denominado sistema binario.
En el entorno de los contactos y bobinas, un 1 significa activado (conduce) y un 0 significa desactivado ("no conduce").

En este capítulo trabajaremos con estas operaciones lógicas:

--|  |-- Contacto normalmente abierto
---( ) Bobina de relé, salida

2. - Contacto normalmente abierto

Símbolos habituales


Se cierra si el valor del bit es un 1


3. – Direccionamiento de entradas y salidas digitales

Los tipos de datos que vamos a utilizar son:
E -- Entradas
A -- Salidas

Las CPUs de Siemens trabajan en byte, con lo cual cada dirección podra definirse de 0 a 7 bits.


Cada uno de estos tipos se puede direccionar en 4 posibles modos

• Por defecto (X para DB): Bit.
• B: byte (8 bits).
• W: palabra (16 bits).
• D: palabra doble (32 bits).

4. Ejemplos conexión sin lógica

• Activación de bobina
En este ejemplo trabajaremos con un interruptor, un interruptor se mantiene enclavado una vez presionado.
Lo que quiere decir que la salida quedara activada mientras no se vuelva a presionar en el otro sentido.

Un interruptor es como los que tenemos en casa, que tiene dos posiciones que se quedan enclavadas manteniendo la luz apagada o encendida según la posición

Ingeniería


Lógica desde PLC


5. Ejemplos conexión serie

Función AND (Y)
Todas las entradas tienen que estar a 1 para que la salida se active.

Ingeniería


Lógica desde PLC


6. Ejemplos conexión paralelo

Función OR (O)
Activando cualquiera de las entradas a 1 la salida se active.

Ingeniería

Lógica desde PLC

7. Ejemplos conexión serie y paralelo

También se puede hacer combinaciones para realizar lógicas variadas.


Ir a página: Temario

-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 3.2

3.2. LOGICA CON BITs, EJEMPLOS SET/RESET
1. - Introducción
En este capítulo utilizaremos contactos normalmente cerrados y bobinas con memorias

Trabajaremos con estas operaciones lógicas:
---| / |--- Contacto normalmente cerrado
---( S ) Set, salida memorizada a 1
---( R ) Reset, poner salida memorizada a 0

2. - Contacto normalmente cerrado

       Símbolos habituales


El contacto normalmente cerrado en reposo el estado de la señal es 1


3. Ejemplos

Ingeniería


• Activación de bobina

En este ejemplo se activara la bobina cuando se pulsa S1 y se deja sin pulsar el S2.
Si pulsamos también el S2, la bobina no se activará ya que hemos abierto el circuito.

Lógica desde PLC


4. Set y Reset
Símbolos habituales


Cuando la bobina se activa a través del Set permanece memorizada hasta que se ejecute un 1 en el Reset.

Lógica desde PLC

Ir a página: Temario



-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 4.1

4.1. LOGICA CON COMPARACIONES

1. - Introducción
Las comparaciones comparar entre dos valores numéricos, según las operaciones siguientes:

x == y ( x es igual a y )
x <> y ( x no es igual a y )
x < y ( x es menor que y )
x > y ( x es mayor que y )
x <= y ( x es menor o igual que y )
x >= y ( x es mayor o igual que y )

Se dispone de las operaciones de comparación siguientes:

• CMP ? I Comparar enteros (16 Bit)
• CMP ? D Comparar enteros dobles (32 Bit)
• CMP ? R Comparar números en coma flotante

2. – Comparaciones con enteros


3.    – Comparaciones con doble entero


4.    – Comparaciones con reales

5. Para las entradas de las comparaciones podemos utilizar los siguientes tipos de datos byte, Word, doble Word y Reales y el resultado da la comparación es un digito binario (Bool).


6. Lógica desde PLC

Comparaciones con enteros
La salida booleana se activara cuando la variable MW10 sea mayor de 32


Comparaciones con doble entero

La salida booleana se activara cuando la variable MD12 sea igual a 32
Si ponemos un valor de comparación constante el valor se rellena anteponiendo L#.



Comparaciones con reales
La salida booleana se activara cuando la variable MD16 sea igual a 2.0
La entrada IN2 se rellena con decimales.




Ir a página: Temario



-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 4.2

4.2. EJEMPLO LOGICA CON COMPARACIONES


1. - Introducción

Ejemplo de comparaciones con un nivel analógico.
Haremos una serie de comparaciones para determinar el nivel bajo y muy bajo.


2. – Comparación nivel bajo

El nivel analógico lo leemos en la dirección EW20, esta entrada hay que convertirla de unidades internas a %, pero como todavía no hemos visto las conversiones analógicas, trabajaremos directamente en %.

El valor ira de 0-100%.


3.    – Comparación nivel muy bajo


4. – Aplicación de los niveles
Condicionaremos el arranque y paro de la bomba, según el nivel.


Marcha bomba
No dejaremos arrancar la bomba mientras el nivel no supere el 20%




Paro bomba
Pararemos la bomba si el nivel baja por debajo del 5%



Ir a página: Temario


-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 5

5. TEMPORIZADORES, CONTADORES Y PULSOS

1. – Introducción temporizadores

Existe un tipo de datos llamados temporizadores. Estos contienen variables de tiempo,
los temporizadores se denotan con la letra T, seguida de un número. El número de temporizadores que puede gestionar una CPU depende del modelo.

Valor de temporización predeterminado

• S5TIME#xH_xM_xS_xMS

- siendo: H (horas), M (minutos), S (segundos), MS (milisegundos);
x son los tiempo que define el usuario.

El valor de temporización máximo que puede introducirse es de 9 900 segundos ó
2H_46M_30S.

Ejemplos:

S5TIME#10S --> 10 segundos
También se puede abreviar la palabra TIME de la siguiente manera:
S5T#1H_10M --> 1 horas y 10 minutos
S5T#1H_10M_11S --> 1 hora 10 minutos y 11 segundos

2. – Diferentes tipos

S_IMPULS Temporizador como impulso
S_VIMP Temporizador como impulso prolongado
S_EVERZ Temporizador como retardo a la conexión
S_SEVERZ Temporizador como retardo a la conexión con memoria
S_AVERZ Temporizador como retardo a la desconexión

3. – Parámetros


4. – Descripción y ejemplos

• Temporizado como impulso

La salida del temporizado se activa en cuando se activa la entrada de arranque S, la salida estará activa mientras transcurra el tiempo predeterminado.


  • Temporizado como impulso prolongado

La salida del temporizado se activa transcurrido el tiempo predeterminado cuando hay un flanco de activación de la entrada de arranque S, aunque el estado de señal en la entrada S se ponga a "0" el temporizador continúa en marcha durante el tiempo predeterminado.


• Temporizado retardo conexión

La salida del temporizado se activa transcurrido el tiempo predeterminado cuando permanece activa la entrada de arranque S.

• Temporizado retardo conexión con memoria

La salida del temporizado se activa transcurrido el tiempo predeterminado cuando hay un flanco de activación de la entrada de arranque S. La salida permanecerá memorizada hasta que se active la entrada R.


• Temporizado retardo desconexión

La salida del temporizado se activa cuando hay un flanco de activación de la entrada de arranque S. La salida permanecerá memorizada hasta que transcurra el tiempo predeterminado..




Ir a página: Temario



-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 6

TRABAJAR CON BLOQUES DE DATOS (DBs)
 
6.1- Introducción bloque de datos

Los bloques de datos, también llamados DB’s, son áreas donde se almacenan datos. Un DB no contiene instrucciones S7.
Hay dos tipos de bloques de datos:
•  Bloques de datos globales: A sus datos pueden acceder todos los bloques.
•  Bloques de datos de instancia: Asociados a un bloque de función FB.

En este apartado veremos los bloques de datos globales.


6.2 – Definición de Tabla de datos

Dirección:
Indica la dirección que STEP 7 asigna automáticamente a la variable al terminar de introducir
una declaración.

Nombre:
Se asigna el nombre a cada variable.

Tipo:
Introduzca el tipo de datos de la variable (BOOL, INT, WORD, ARRAY, etc.). Las variables
pueden pertenecer a los tipos de datos simples, a los tipos de datos compuestos, o bien, a los
tipos de datos de usuario.

Valor inicial:
Indique el valor inicial, en caso de que el software no deba tomar el valor predeterminado del
tipo de datos introducido. Todos los valores introducidos deben ser compatibles con los tipos de
datos.
Cuando guarde por primera vez el bloque de datos, el valor inicial será adoptado como valor
actual de la variable, a menos que defina expresamente su valor actual.
Recuerde que los valores iniciales no pueden cargarse en la CPU.

Comentario:
En este campo puede introducir un comentario para documentar la variable. El comentario no
debe tener más de 80 caracteres.

6.3- Formato de datos

Datos Simples

Datos compuestos:

6.4- Ejemplo de Bloques de datos

Prepararemos una serie de bloques de datos para comunicar con el WinCC Flexible

En esta primera tabla una serie de bits de tipo booleanos, para las solicitudes que dibujemos en las pantallas (DB1)


Para la indicación de tipo booleano generamos esta tabla.(DB2)


Para las indicaciones analógicas de valores con decimales, se prepara esta tabla con variables de tipo real.


Lo mismo hacemos con las consignas que vamos a dibujar para introducir datos desde HMI(Wincc Flexible) al PLC.


Por ultimo vamos a preparar esta tabla con variables de tipo enteros(INT).
Estas variables las utilizaremos para las condiciones de diferentes sistemas.(Bombas, electroválvulas, secuencias, etc)


6.5- Llamada direccionamiento DBs

Ejemplo consulta de un bit

DB1.DBX0.0

Con esta consulta accedemos a DB1 a la dirección 0.0, que corresponde a la marcha alimentación bomba 1.

Ejemplo indicación de un bit

DB2.DBX0.0



-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 7

7.- EJEMPLO HIDRAULICO CONTROLADO CON WinCC FLEXIBLE
7.1.- Desarrollo del PLC Parte I

7.1.1.- Introducción

En este ejemplo se pretende controlar un hidráulico desde un panel de WinCC Flexible.
En esta parte prepararemos el control de la bomba de alimentación 1

7.1.2.- Pantallas

Pantalla Hidráulico

Pantalla Condiciones


7.1.3.- Desarrollo del PLC
Lo primero que tenemos que hacer es rellenar la tabla de símbolos y las DBs de comunicaciones con el WinCC Flexible.

Tabla de símbolos:
Nota: pinchar en las tablas para agrandarlas


Tabla de datos:

En la DB1 rellenaremos todas las solicitudes para arrancar y parar las bombas.



En la DB2 rellenaremos todas las indicaciones que vamos a poner en la pantalla del hidráulico.
En esta parte no rellenaremos las indicaciones de las condiciones ya que vamos a preparar otra DB para esta labor.



En la DB3 la utilizaremos para las dos indicaciones de forma analógica, que son la temperatura y el nivel.



En la DB5 rellenaremos todas las indicaciones que vamos a poner en la pantalla de condiciones.
La vamos a tratar como un integer para desglosar bit a bit cada condición




7.1.3.- Desarrollo PLC

Crearemos una función (FC10), donde prepararemos el programa para el control de la bomba 1 de alimentación

Lo primero que vamos a preparar son las condiciones iniciales de la bomba.
Una bomba de alimentación puede tener varias condiciones de arranque nosotros vamos a preparar cuatro.
1.- El tanque tiene que estar lleno, según el nivel hemos establecido un 20%
2.- La temperatura del aceite tiene que tener una temperatura mínima (5ºC) para que el aceite no este espesa.
3.- Un filtro en línea nos dirá si el aceite está sucio.
4.- También tenemos que tener la bomba de recirculación en marcha para poder arrancar



Seguimos con las condiciones permanentes de la bomba.
Una bomba de alimentación puede tener varias condiciones permanentes que provoquen la parada.

Las condiciones tienen que estar a 1, solo con perder cualquiera de ellas perderemos el resumen e inmediatamente pararemos la bomba
1.- Si el nivel del tanque es muy bajo, para que la condición sea 1, compararemos el nivel para que sea mayor de 5%
2.- La temperatura del aceite tiene que ser menor de 90ºC.
3.- Que no tengamos fallo del automático.
4.- Que no perdamos la presión.



Lógica de marcha de la bomba.
La solicitud de marcha lo realizamos con el pulsador que dibujaremos en el WinCC, y realizaremos la marcha siempre que tengamos todas las condiciones iniciales.



Lógica de paro de la bomba.
Resetearemos la marcha con el pulsador y por falta de condiciones permanentes


Indicaciones para reflejar en la pantalla hidráulico


Indicaciones para reflejar en la pantalla condiciones iniciales
Otra forma de comunicar con WinCC, es a través de entero (Interger).
Solo definimos una variable y podemos tener 16 condiciones, lo único que hay que tener en cuenta es que el Plc de Siemens trabaja con los bytes cambiados.




Indicaciones para reflejar en la pantalla condiciones permanentes



-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 7.2
7.2.Desarrollo del PLC Parte II

7.2.1.- Introducción

En esta segunda parte prepararemos el control de las otras dos bombas.

7.2.2.- Desarrollo PLC

Para realizar las otras dos bombas copiaremos FC10, renombrándolo con otra función



Una vez creada la copia, le cambiaremos el nombre del símbolo, seleccionando con el botón derecho las propiedades.


Después hay que entrar en la funciones FC11 y FC12 y modificar las variables.

La bomba 2 es idéntica a la bomba 1 en condiciones marcha y paro, pero las indicaciones son menos ya que en la primera bomba hemos indicado variables comunes como niveles, temperaturas, etc y no hay que volverlas a repetir.

Las indicaciones de la bomba 2 quedaran así:



La bomba 3, cambia las condiciones ya que esta bomba es de recirculación las condiciones son las indicadas en estos cuadros.


Las condiciones de la bomba 3 de recirculación son las siguientes.

Condiciones iniciales:
1.- El tanque tiene que estar lleno, según el nivel hemos establecido un 20%
2.- La temperatura del aceite tiene que tener una temperatura mínima (5ºC) para que el aceite no este espesa.



Condiciones permanentes:
1.- El tanque tiene que estar lleno, según el nivel hemos establecido un 20%
2.- La temperatura del aceite tiene que tener una temperatura mínima (5ºC) para que el aceite no este espesa.



-----------------------------------------------------------------------------------------------------------------------------------------
Capitulo 7.3
7.3. Desarrollo del Wincc Flexible

7.3.1.- Tabla de variables


7.3.2.- Simbológica



7.3.3.- Pantalla esquema hidráulico

Definición de bomba
Para indicación de las bombas utilizaremos las variables de tipo booleanos proveniente de la DB2.
La lógica que utilizaremos es:
Valor 0 color rojo, representa bomba parada.
Valor 1 color verde, representa bomba roja.



Definición de filtro, presostato y fallos
Para todos tipos de indicaciones booleanos utilizaremos la DB2. Y normalmente utilizaremos el rojo para indicar fallos y el verde para indicar estado ok.


Definición Nivel
Para indicación del nivel utilizaremos las variables de tipo real proveniente de la DB3.
Los valores se han establecido en tanto por cien.



Definición Temperatura
Para indicación de valores numéricos utilizaremos variables de tipo real.


Definición panel de control
Para los pulsadores generaremos eventos, al pulsar utilizaremos la función ActivarBit y al soltar utilizaremos DesactivarBit. Siempre utilizando la misma variable.
Las cuatro indicaciones que tiene este panel de control (marcha,paro, fallo y listo), se indicara de las misma manera que hemos definido la indicación de la bomba.


Para el pulsador de listo utilizaremos los eventos para hacer una llamada a otra pantalla.


Definición de pantalla de condiciones
Dibujaremos una pantalla con todas las condiciones iniciales y permanentes de las tres bombas.



Para definir las indicaciones seleccionaremos la variable de las condiciones “CI_HMI_00”
Elegiremos el tipo Bit, a partir de aquí tenemos que seleccionar el bit 0,1,2,etc..
Bit 0 Nivel bajo
Bit 1 Temperatura muy bajo
Bit 2 Filtro Ok
Bit 3 B.Recirc. en marcha.

Recordad que cada cuadro es una variable distinta.



Ir a página: Temario

-----------------------------------------------------------------------------------------------------------------------------------------

Capitulo 8

MANEJO DE TABLA DE VARIABLES Y REFERENCIAS CRUZADAS
8.- Tabla de variables

8.1.- Introducción

Estas tablas sirven para observar y forzar variables, este tipo de bloques no se cargan en la CPU.

8.2.- Acceso Tabla de variables

Hay diferente forma de acceder a este tipo de tablas.

Podemos crear una tabla insertando un nuevo objeto
Después de creado la tabla se puede abrir como un bloque normal, haciendo doble clic sobre él.



También podemos abrir una tabla de variables desde SIMATIC Manager, desplegaremos la opción Sistema de destino y seleccionando Observar/forzar variable, nos abre una tabla vacía y sin nombre.
Este mismo enlace se puede realizar estando dentro de los bloques de programa.



8.3.- Utilización Tabla de variables

8.3.1.- Insertar variables
Se puede escribir las variables a mano introduciendo la dirección en el campo Operador o escribir el símbolo.
Podemos separar las variables por grupos introduciendo un comentario, siempre que escriba dos barras de dividir seguidas lo interpretara como un comentario.



Hay muchas variables que nos interesara verlas en diferentes formatos, para ello podemos cambiar el formato situándonos encima del cuadro formato de visualización y pulsando el botón derecho nos dejara elegir diferentes formatos.


Se puede introducir varias variables a la vez utilizando insertar área.
Esta tabla aparece situándonos encima de la última línea libre, pulsando el botón derecho.
Podemos rellenar la primera variable que queremos visualizar y cuantas a partir de esta queremos que nos rellene. También podemos decirle de que tipo serán todas las variables que vamos a insertar en la tabla.


8.3.1.- Observar  y forzar variables

Para poder observar el estado de las variables, hay seleccionar Variables -> Observar, también pulsando el icono de las gafas observaremos las variables.


También podemos forzar variables.
Se puede escribir un valor de forzado y forzarlo pulsando el icono de forzar.



8.4.- Datos de referencias
Podemos abrir las referencias cruzadas desde Herramientas  Datos de referencias  Mostar, se pueden abrir desde los bloques y desde Manager




Podemos visualizar cinco vistas:
Referencias cruzadas
Nos dará todas las variables utilizados en programa, si pulsamos punto de aplicación nos abrirá los bloques donde esta utilizada la variable.



Ocupación de variables
En esta tabla podemos ver que variables están ocupadas y cual libres.
Es importante que cuando se empiece un programa ver en esta tabla que variables podemos utilizar.


Estructura del programa
La estructura del programa describe el orden de llamada de los bloques dentro de un programa.

Símbolos no utilizados
Con esta vista podemos ver todos los símbolos no utilizados en programa.

Operaciones sin símbolo
Podemos ver también si hay alguna variable sin símbolo.

Nota: Las dos primeras vistas son las importantes, no hay que olvidar que hay que utilizarlas muy a menudo en la realización de nuestros programas.


Ir a página: Temario

-----------------------------------------------------------------------------------------------------------------------------------------

Capitulo 9

9.- OPERACIONES ARITMÉTICAS     
9.1.- Introducción

En Step 7 se pueden realizar operaciones aritméticas con funciones estándar que dispone el software.
Existen varias funciones con números enteros y números con coma flotante.

9.2.- Funciones con números enteros

Suma enteros

Parámetro Tipo de datos    Área de memoria Descripción
IN1 INT                  E, A, M, L, D o constante Primer sumando
IN2 INT                  E, A, M, L, D o constante Segundo sumando
OUT INT                  E, A, M, L, D Resultado de la suma

Resta enteros


Parámetro Tipo de datos   Area de memoria Descripción
IN1 INT                 E, A, M, L, D o constante Sustraendo
IN2 INT                 E, A, M, L, D o constante Minuendo
OUT INT                 E, A, M, L, D Resultado de la sustracción


Multiplicar enteros

Parámetro Tipo de datos   Area de memoria Descripción
IN1 INT                 E, A, M, L, D o constante Multiplicando
IN2 INT                 E, A, M, L, D o constante Multiplicador
OUT INT                 E, A, M, L, D Resultado de la multiplicación

Dividir enteros


Parámetro Tipo de datos   Área de memoria Descripción
IN1               INT                  E, A, M, L, D o constante  Dividendo
IN2               INT                  E, A, M, L, D o constante Divisor
OUT             INT                  E, A, M, L, D Cociente la división


9.3.- Funciones con números doble enteros

Estas mismas operaciones se pueden realizar con variables tipo DINT
Las funciones son:
ADD_DI, SUB_DI, MUL_DI Y DIV_DI.


Hay una nueva función con este tipo de datos.

Obtener el resto de una división de enteros dobles


9.4.- Funciones con números reales

Estas mismas operaciones se pueden realizar con variables tipo REAL
Las funciones son:
ADD_R, SUB_R, MUL_R Y DIV_R.

En esta modalidad veremos algunas nuevas funciones nuevas

Valor absoluto

Parámetro Tipo de datos    Área de memoria Descripción
IN                REAL               E, A, M, L, D         Número en coma flotante
OUT           REAL               E, A, M, L, D         Valor absoluto del número en coma flotante


Raíz cuadrada


Parámetro Tipo de datos   Área de memoria Descripción
IN                REAL               E, A, M, L, D             Número en coma flotante
OUT           REAL               E, A, M, L, D Raíz cuadrada del número en coma flotante


Existe otra función de raíz “SQR”

También existen funciones de trigonometría.
Lista de funciones:
LN     >>> Logaritmo natural
EXP  >>> Exponente
SIN   >>> Seno
COS >>> Coseno
TAN  >>> Tangente
ASIN >>> Arcoseno
ACOS >> Arcocoseno
ATAN >> Arcotangente

Ir a página: Temario

-----------------------------------------------------------------------------------------------------------------------------------------

Capitulo 10

10.- Conversiones     
10.1.- Introducción

Hay varias funciones internas de conversión, estas funciones nos ayudaran a convertir diferentes tipos de datos.
Lista de operaciones de conversión


10.2.- Ejemplos Conversiones

Todas las funciones contienen estos dos parámetros

Parámetro  Tipo de datos    Área de memoria       Descripción
EN               BOOL                 E, A, M, L, D               Entrada de habilitación
ENO            BOOL                 E, A, M, L, D               Salida de habilitación


Conversión BCD en entero
Parámetro  Tipo de datos    Área de memoria       Descripción
IN                  WORD               E, A, M, L, D              Número BCD
OUT              INT                     E, A, M, L, D              Valor entero (16 bits) de un número BCD

También existe la conversión contraria, de entero a BCD. Y conversiones de BCD a doble entero, doble entero a BCD.

Conversión doble entero a real

Parámetro  Tipo de datos    Área de memoria        Descripción
IN                 DINT                 E, A, M, L, D                Entero doble
OUT            REAL                 E, A, M, L, D                Número real

Complemento a 1 de un entero





Parámetro   Tipo de datos    Área de memoria        Descripción
IN                  INT                    E, A, M, L, D               Valor entero (de 16 bits) de entrada
OUT              INT                    E, A, M, L, D              Complemento a 1 del entero (de 16 bits)

También existe complemento a 1 de un número doble entero (INV_DI).

Complemento a 2 de un entero

Parámetro Tipo de datos    Área de memoria    Descripción
IN                   INT                    E, A, M, L, D            Valor entero (de 16 bits) de entrada
OUT               INT                    E, A, M, L, D           Complemento a 2 del entero (de 16 bits)

También existe complemento a 2 de un número doble entero y real (NEG_DI,NEG_R).

Redondear a entero doble
 


Parámetro Tipo de datos    Área de memoria    Descripción
IN                   REAL                E, A, M, L, D           Valor a redondear
OUT               DINT                 E, A, M, L, D           IN, redondeado al próximo entero

El redondeo que realiza esta función es el siguiente:
Ejemplo: 
Valor 1.0 a 1.4 redondea a 1
Valor 1.5 a 1.9 redondea a 2

Truncar a entero doble

Parámetro Tipo de datos    Área de memoria   Descripción
IN                   REAL                E, A, M, L, D          Número real a convertir
OUT               DINT                E, A, M, L, D          Parte entera del valor de IN


Convertir número real en el entero doble más próximo

Parámetro Tipo de datos    Área de memoria   Descripción
IN                   REAL                 E, A, M, L, D Número real a convertir
OUT               DINT                 E, A, M, L, D Primer entero doble que es mayor 
                                                                              el número real

Redondear número real a entero doble inferior



Ir a página: Temario

-----------------------------------------------------------------------------------------------------------------------------------------

Capitulo 17.1

17.-TRATAMIENTO DE ALARMAS
17.1- Desarrollo Plc

Para el desarrollo de las alarmas vamos a generar un nuevo bloque de datos (DB7 AL_HMI)
El tipo que vamos a utilizar es entero (INT), con lo cual con este tag podemos tener 32 alarmas.


Las alarmas se pueden generar de muchas maneras, muchas de ellas suelen ser muy sencillas.
Por ejemplo las dos primeras que vamos a generar, solo vamos a igualar la entrada digital a una dirección de la DB7.
Recordar que Siemens trabaja con los bytes cambiados, para ello nosotros tenemos que hacer el swapeo, esto significa cruzar los bytes.
El bit 0 tiene a dirección DB7.DBX1.0, y el bit 8 su dirección es DB7.DBX0.0.

El fallo de la bomba y el fallo filtro la programaremos igualando la dirección a la alarma, pero para el fallo de presión lo vamos a generar un tiempo.



Para elaborar este último, aplicaremos un temporizado, si cualquiera de las bombas de alimentación esté en marcha, si el presostato no da señal a de 20 segundo activaremos una memoria que nos indicara que hay una fuga de aceite.



También vamos a sustituir la entrada digital E10.7 (Baja presión línea hco.) por el fallo que hemos generado, en todos los sitios del programa menos en la indicación.
Unas de las más importantes son las condiciones permanentes, ya que nada más arrancar las bombas no va a coger presión, como teníamos antes las condiciones se pararía las bombas nada más arrancar.


Como podéis comprobar hemos utilizado un SET para activar esta alarma, es recomendable utilizar memoria ya que cuando se active la alarma se apagara la bomba.
Si hubiéramos utilizado una bobina (=) en muchas ocasiones no se vería en el Wincc está alarma, ya que en el siguiente ciclo la bobina se pone a 0.

Recomiendo que en casi todas las alarmas se utilicé un SET.

Vamos a preparar un acuse de alarmas desde Wincc, este solicitud la utilizaremos para todas las alarmas que vayamos generando a lo largo del curso.



Capitulo 17.2


17.2- Desarrollo WinCC Flexible

Lo primero que tenemos que hacer es rellenar la variable nueva AL_HMI_00 en la tabla de variables.




Una vez hemos rellenado la variable hay que abrir la carpeta Gestión de avisos y hacer doble clic en Avisos de bit, aquí en esta tabla hay que rellenar los textos de la alarma.
Para empezar añadimos la variable AL_HMI_00 en “Variables de trigger”, por defecto nos añade el número 0 y la dirección DB7.DBX1.0.
Una vez rellenada la primera, seleccionamos un cuadro y pinchamos en el punto negro y desplazamos hacia abajo para crear los otros 15 bits




Rellenamos el texto, este texto es el que aparecerá en pantalla.



Hay que agregar una nueva imagen, donde añadiremos el cuadro de alarmas.



En la parte derecha en el cuadro de herramientas seleccionamos los objetos ampliados, arrastramos la vista de avisos a la pantalla. Ampliamos la imagen para que cubra toda la pantalla dejando sitio para el título y los pulsadores.
También colocaremos un pulsador para reset de las alarmas.




Ir a página: Temario


-----------------------------------------------------------------------------------------------------------------------------------------

Capitulo 18

18.- USO DE STRINGS
 
18.1- Introducción

El STRING es una cadena de caracteres, con un máximo de 254 caracteres, cada carácter utiliza un byte.
Un STRING consta de un cuerpo 254 Bytes  y una cabecera de 2 Bytes (Byte 0 y Byte 1). El Byte 0 define la longitud máxima y el Byte 1 define la longitud real del STRING.

Ejemplo;
Tipo de dato: Ejemplo Formato:
STRING[2] ‘ED’

Byte 0 = Longitud máximo del string = 4
Byte 1 = Longitud real del string = “ED” =2
Byte 2 = Valor ASCII de E
Byte 3 = Valor ASCII de D


18.2- Ejemplo

Crearemos una nueva tabla de datos (DB8), donde definiremos unas variables de tipo STRING.
El valor inicial puede ser un carácter o un espacio en blanco, como en el ejemplo.



Vamos a definir una tabla de variables donde definiremos los dos primeros string.
Para ello definiremos 20 bytes, los 10 primeros corresponde al STRING_00 de 0 a 9 y los 10 siguientes corresponde  al STRING_01 de 10 a 19 bytes.



En la tabla de variables del WinCC, insertaremos dos campos nuevos definidos como String.
En la dirección de cada string rellenaremos el inicio de cada string.



Después de definir las variables, insertaremos dos campos ES, el primero lo vamos a definir como modo “Entrada”, lo utilizaremos para introducir caracteres.
La variable que elegiremos es STRING_00 y seleccionaremos el formato “Secuencia de caracteres”, la longitud del campo será 8, que son los máximos caracteres que queremos reflejar en el campo.

Para el segundo, utilizaremos el STRING_01, colocando las mismas propiedades menos el modo que será de “Salida”.


Vista en Runtime, donde apreciamos los dos campos creados.


Ir a página: Temario

-----------------------------------------------------------------------------------------------------------------------------------------
EJERCICIOS DE REPASO

Ejercicio 1

1.- Inversión de sentido giro de un motor

En este ejercicio sencillo intentaremos aplicar varias cosas aprendidas en este temario.

La idea es definir una remota donde conectaremos el panel que controlara el motor.


Automatizar un motor para el control de dos sentidos.
Conectaremos un panel de mando con tres pulsadores y 2 lámparas.
Lógica del panel:
1.- Pulsador luminoso para marcha adelante y indicación
2.- Pulsador luminoso para marcha atrás y visualización
3.- Pulsador para paro




La conexión de este panel, lo realizaremos a través de una remota conectada a profibus.

Definiremos unas tarjetas de entradas digitales con dirección E300 y unas salidas digitales con dirección A300.


2.- Conexión eléctrica

Diagrama de fuerza y mando 220 voltios
Para invertir el sentido de giro de un motor trifásico solo es necesario invertir cualquiera de las fases.


Diagrama del PLC
En las entradas conectaremos los pulsadores del panel y las dos confirmaciones de los dos contactores.
En la salidas conectaremos dos relés de 24 voltios de continua y dos lámparas



Simbología de entradas y salidas

SOL_ADEL = E300.0 Solicitud giro adelante motor
SOL_ATRAS        = E300.1 Solicitud giro atrás motor
SOL_PARO = E300.2 Solicitud paro motor
AUTO_OK     = E300.3 Automático OK
CONF_ADEL = E301.0 Confirmación giro adelante motor
CONF_ATRAS = E301.1 Confirmación giro atrás motor

ORD_ADEL = A300.0 Orden giro adelante motor
ORD_ATRAS = A300.1 Orden giro atrás motor
IND_ADEL = A300.2 Indicación giro adelante motor
IND_ATRAS = A300.3 Indicación giro atras motor



Ir a página: Temario


-----------------------------------------------------------------------------------------------------------------------------------------

Ejercicio 1.1

1.1.- Desarrollo sin subrutina

Para empezar con el desarrollo de este ejercicio, vamos a definir una red de profibus donde insertaremos la remota ET200s

Vamos a definir las siguientes tarjetas:
Slot 1 => PM-E DC24V (Ref.6ES7 138-4CA00-0AA0)
Slot 2 => 4DI DC24V ST (Ref.6ES7 131-4BD01-0AA0) E300.0 a E300.3
Slot 3 => 4DI DC24V ST (Ref.6ES7 131-4BD01-0AA0) E301.0 a E301.3
Slot 4 => 4DO DC24V/0,5A ST (Ref.6ES7 132-4BD01-0AA0) A300.0 a A300.3
Slot 5 => 4DO DC24V/0,5A ST (Ref.6ES7 132-4BD01-0AA0) A301.0 a A301.3



El siguiente paso que realizaremos será rellenar la tabla de símbolos, con todas direcciones de entradas y salidas, según la hemos cableado.


Definimos una función nueva (FC14), en esta función programaremos las condiciones iniciales, permanentes, la marcha delante, marcha atrás, el paro y indicaciones.

Condiciones
Vamos a definir un segmento para cada condición.
Aunque no tenemos ninguna condición inicial la preparamos por defecto, para tenerlo preparado.
La única condición permanente que tenemos que añadir el contacto del automático o guardamotor.

Las marcas que vamos a utilizar la rellenaremos en la tabla de símbolos según vallamos necesitando.




Marcha adelante

Ejecutaremos la marcha adelante una vez tengo las condiciones iniciales (que en esta caso siempre a 1) y pulsemos a solicitud de adelante, en este caso daremos marcha a través de la salida A300.0 dejándola memorizada con un SET y reseteando (RESET) la orden contraria.
Esto es muy importante ya que si activaríamos las dos a la vez haríamos un corto 400V.
Existen en el mercado contactores en clavados para que no puedan meterse a la vez, pero este contactor es más caro que dos normales. Lo normal es encontrarse con contactores normales.


Marcha atrás
En la marcha atrás hacemos lo mismo que la anterior.
Normalmente nos interesaría tener condiciones de adelante y condiciones de atrás, en este ejemplo he utilizado solo una condición inicial y una permanente.


Paro del motor
Como las órdenes de marcha las hemos memorizado, hay que utilizar algo para desactivarlas, para ello utilizaremos el pulsador de paro y la perdida de condiciones permanentes.
Como he comentado en anteriores ocasiones el paro se suele cablear cerrado por seguridad.


Indicaciones panel

Con las confirmaciones de los contactores indicaremos cuando está en marcha adelante o marcha atrás.
Como podéis comprobar me gusta poner el uno permanente para utilizar varias cosas en el mismo segmento, es una forma de no utilizar tantos segmentos.



Ir a página: Temario


-----------------------------------------------------------------------------------------------------------------------------------------

Ejercicio 1.2

1.2.- Desarrollo con subrutina

Utilizaremos los símbolos ya rellenados en el apartado anterior.

Vamos a preparar las subrutinas, para la subrutina accionamiento dos sentidos de giro utilizaremos la que disponemos (FB10 SUB_ACCTO_2S).

Pero en este ejercicio vamos a preparar una que se encargué de las condiciones.
Insertamos un bloque de función nuevo (FB11 SUB_COND_8).

Preparación entradas (IN)
Esta subrutina va a tener 8 entradas de condiciones iniciales y 8 de condiciones permanentes

El valor inicial de todas estas variables la vamos a poner a TRUE, para si no rellenamos nada en la entrada que por defecto tenga un 1.


Preparación salidas (OUT)
Definiremos dos salidas que nos indicara el resumen de si todas las condiciones están a 1


Preparación de programa
Para la realización de la lógica, solo tenemos que poner en serie todas las entras de cada condición inicial y si todas están a 1 activaremos la bobina (RES_CI).
Igual con las condiciones permanentes.



Ahora crearemos el bloque para el control del accionamiento.
Insertaremos un bloque de función nuevo (FB152), para hacer las llamadas a las dos subrutinas.

Arrastraremos de los elementos de proyecto las dos subrutinas (FB11 SUB_COND y FB10 SUB_ACCTO_2S)

Para convertirla la subrutina en multiinstancia seleccionaremos la subrutina y haremos clic con el botón derecho, nos aparecerá un tabla donde seleccionaremos “Convertir en llamada multiinstancia”.
Esta acción nos rellenara en la parte de STAT, el tipo de dato necesario para trabajar.


Condiciones
Solo vamos a rellenar las condiciones necesarias ya que si dejamos sin rellenar nada en las patas de entrada, por defecto estarán a 1, necesario para tener el resumen a 1 para funcionar.
Como para este ejemplo solo tenemos el automatico, solo rellenaremos una condición permanente.
En la parte de salida la misma marca que hemos utilizados en el ejemplo anterior.
Nota: A la hora de probar hay que quitar el FC14 del bloque de organización para que no se machaquen las marchas.



Control del Accionamiento
Aquí vamos rellenando todas las entradas y salidas necesarias.
Esta subrutina tiene condiciones para cada movimiento, como para este ejemplo solo hemos utilizado las mismas condiciones de un sentido y del otro, rellenaremos las dos condiciones iniciales y permanentes con la misma.
Como solo tenemos dos indicaciones las de mas indicaciones las dejamos sin rellenar.


18 comentarios:

  1. Hoy empiezo el curso y estoy muy motivado. el material a estudiar esta muy interesante. en el transcurso del curso estaré comentando.

    Gracias

    ResponderEliminar
  2. Hoy termine el capitulo 3.1 y es muy bueno entre mas leo y practico mas me gusta
    Gracias profe, por tan buenos tutoriales

    ResponderEliminar
  3. El capitulo 3.2 fue muy bueno hoy lo termine, se me presento inconvenientes al simularlo pero al final el problema esta en compilar bien el programa. Profe gracias por esa explicación

    ResponderEliminar
  4. El capitulo 4.1 es muy bueno u hace que practiquemos lo aprendido en los capítulos anteriores.
    Profe una pregunta. Los comentarios respecto a lo realizado en cada punto del curso los sigo colocando a qui. Quiero que sepa como voy siguiendo los temas.

    Gracias

    ResponderEliminar
    Respuestas
    1. Hola Rigoberto, gracias por tus elogios
      No me importa que me mandes tus avances, pero esto es mejor que me lo mades al correo.
      Cuando te comente de escribir en el blog, me referia a las dudas.

      Eliminar
  5. hola amigo sobre los string , como hago para direccionarlo del DB1 UN FB2,
    por que e visto tu video que le pones las marcas, pero yo hago lo mismo y me sale herror

    ResponderEliminar
    Respuestas
    1. De que vídeo esta hablando, del capitulo 18.
      No te entiendo bien lo que quieres decir con DB1 un FB2

      Eliminar
  6. Hola, te felicito por el aporte que haces!!! Recien empiezo a leer tu blog y esta muy interesante.
    Tengo una consulta, como puedo hacer o que pasos debo de seguir para poder cargar un programa en la CPU S7-300 atraves de ethernet, ya que no cuento con el cable MPI?? Cuento con el cpu que te menciono y con un modulo CP-LEAN...
    Agradeceria mucho la ayuda!!

    ResponderEliminar
  7. Felicitaciones personas positivas que hacen del conocimiento una bandera de vida merecen lograr todo los parabienes que nos ofrece la vida. Estoy convencido que nos sorprenderás con conocimientos brillantes en el futuro.
    Gracias.

    ResponderEliminar
  8. Me estoy iniciando en el mundo del control y de la prograsmación electrónica y este material me parece muy interesante. Voy a dijerirlo poco a poco para poder entenderlo y ponerlo en práctica. Gracias por el aporte!!!

    ResponderEliminar
  9. muchas gracias por este tutorial, por compartir tu experiencia con nosotros,,saludos

    ResponderEliminar
  10. Muy buen material de estudio.

    Tengo una duda, que debo hacer si al momento de revsar las referencias cruzadas, aparece una ventana, me dice si debo actualizar o regenerar los datos. El step7 esta corriendo, SE ACTUALIZA O SE REGENERA, corro algún riesgo ?

    Saludos atte.
    Andres Herrera V. (hherreravidal@gmail.com)

    ResponderEliminar
  11. Muchas felicidades por este excelente curso.
    Disculpa me ha salido un pequeño problema, al yo dar marcha a cualquier bomba arrancan las bombas y en el FC1 (Simulador) la confirmación de las bombas se establece, el problema se presenta en los FC's 10, 11, 12 en los cuales la confirmación no se establece, es como si en estos FC's no se pudiera leer la confirmación del FC1, ¿Sabrás a qué se debe ese problema?, de antemano muchas gracias y saludos.

    ResponderEliminar
  12. Gracias profesor por esta aportación, para nosotros los simples mortales, saludos.

    ResponderEliminar
  13. CREO QUE ES UN BLOK EXCELENTE Y ESTOY MUY CONTENTO CON LOS PROGRESOS

    ResponderEliminar