Beruflich Dokumente
Kultur Dokumente
SIMATIC
S7-SCL V5.3 para S7-300/400
Primeros pasos
El ejemplo que acompaa a este producto no es una descripcin aislada,
sino que forma parte del manual.
Consignas de seguridad para el usuario
Este manual contiene las informaciones necesarias para la seguridad personal as como para la
prevencin de daos materiales. Las informaciones estn puestas de relieve mediante seales de
precaucin. Las seales que figuran a continuacin representan distintos grados de peligro:
! Peligro
Significa que, si no se adoptan las medidas preventivas adecuadas, se producir la muerte, o bien
lesiones corporales graves o daos materiales considerables.
! Advertencia
Significa que, si no se adoptan las medidas preventivas adecuadas, puede producirse la muerte,
lesiones corporales graves o daos materiales considerables.
! Precaucin
Significa que, si no se adoptan las medidas preventivas adecuadas, pueden producirse lesiones
corporales.
Precaucin
Significa que, si no se adoptan las medidas preventivas adecuadas, pueden producirse daos
materiales.
Atencin
Se trata de una informacin importante, sobre el producto o sobre una parte determinada del manual,
sobre la que se desea llamar particularmente la atencin.
Personal cualificado
Slo est autorizado a intervenir en este equipo el personal cualificado. En el sentido del manual se
trata de personas que disponen de los conocimientos tcnicos necesarios para poner en
funcionamiento, conectar a tierra y marcar los aparatos, sistemas y circuitos de acuerdo con las normas
estndar de seguridad.
Uso conforme
Considere lo siguiente:
! Advertencia
El equipo o los componentes del sistema slo se podrn utilizar para los casos de aplicacin
previstos en el catlogo y en la descripcin tcnica, y slo con los equipos y componentes de
proveniencia tercera recomendados y homologados por Siemens.
El funcionamiento correcto y seguro del producto presupone un transporte, un almacenamiento, una
instalacin y un montaje conforme a las prcticas de la buena ingeniera, as como un manejo y un
mantenimiento rigurosos.
Marcas registradas
SIMATIC, SIMATIC NET y SIMATIC HMI son marcas registradas por SIEMENS AG.
Los restantes nombres y designaciones contenidos en el presente documento pueden ser marcas
registradas cuya utilizacin por terceros para sus propios fines puede violar los derechos de los
proprietarios.
Siemens AG
Bereich Automation and Drives
Geschaeftsgebiet Industrial Automation Systems Siemens AG 2004
Postfach 4848, D- 90327 Nuernberg Sujeto a cambios sin previo aviso.
Siemens Aktiengesellschaft A5E00290620-01
Disear un programa SCL
Qu aprender?
El ejemplo de iniciacin ilustra cmo configurar SCL de forma eficaz. Al principio, las
preguntas ms frecuentes son p. ej.:
Cmo se trabaja con SCL al disear programas?
Qu medios ofrece el lenguaje SCL para solucionar la tarea planteada?
De qu funciones de test dispongo?
En este captulo se dar respuesta a stas y otras preguntas.
Hardware necesario
El programa de ejemplo se puede ejecutar en un SIMATIC S7-300 o SIMATIC S7-400 con la
siguiente periferia:
un mdulo de entrada de 16 canales
un mdulo de salida de 16 canales
Planteamiento
Resumen
La tarea consiste en adquirir valores medidos a travs de un mdulo de entrada y
clasificarlos y procesarlos con un programa SCL. Los resultados deben visualizarse en el
mdulo de salida.
X 1 1 1 1 1 1 1 1 X
255
Raz Cuadrado
255 1 1 1
127 3 2 9
63 7 Clculos 3 49
31 15 4 225
15 31 6 961
7 63 8 3969
3 127 11 16129
1 255 16 *
(* = Desbordamiento)
Adquirir valores Clasificar valores
medidos medidos Calcular resultados
Salidas ajustables
En el mdulo de salida slo se puede mostrar un valor. Por eso se programarn las
siguientes opciones:
Seleccin de un elemento de una lista
Seleccin entre valor medido, raz y cuadrado
La seleccin del valor mostrado se realiza de la manera siguiente:
Con tres interruptores se ajusta una codificacin que se acepta al detectarse un flanco en
el cuarto interruptor, el interruptor de codificacin. A partir de aqu se calcula la direccin
con la que se direccionar la salida.
Con la misma direccin se ponen a disposicin tres valores para la salida: valor medido,
raz y cuadrado. Para seleccionar uno de estos valores, hay que programar dos
conmutadores.
1 1 1
3 Direccionar 2 9
salida
7 3 49
15 4 225
31 6 961
Conmutador
63 8 3969
Seleccionar
127 salida 11 16129
255 16 *
Direccin Direccin
Valores Resultados
clasificados
(* = Desbordamiento)
Salida de datos
Visualizacin en mdulos 4
de salida
Salida
Tipos de bloques
La mejor manera de solucionar la tarea planteada es mediante un programa SCL
estructurado. Dicho programa tiene estructura modular; es decir, se compone de bloques
que procesan una o varias tareas parciales. Al igual que los lenguajes de programacin de
STEP 7, SCL ofrece los siguientes tipos de bloques.
Los bloques de funcin son bloques lgicos con datos estticos. Dado que un
FB FB dispone de memoria, se puede acceder a sus parmetros (p.ej. salidas)
desde cualquier punto del programa de usuario.
Las funciones son bloques lgicos sin memoria. Dado que no existe memoria,
Bloques FC hay que procesar los valores calculados justo despus de llamar a la funcin.
de STEP 7
Los bloques de datos son reas de datos en las que se guardan los datos de
DB usuario. Existen bloques de datos globales, a los que se puede acceder
desde todos los bloques lgicos, y DB de instancia asignados a una
llamada a FB determinada.
Los tipos de datos definidos por el usuario son tipos de datos configurados
UDT que se pueden definir segn las necesidades del usuario y son de uso
mltiple. Estos datos se emplean para generar varios bloques de datos
con la misma configuracin. Los UDT se utilizan como bloques.
Tareas parciales
Las tareas parciales aparecen representadas en forma de cuadros en la siguiente figura.
Las rectngulos sobre fondo gris representan los bloques. La disposicin de los bloques
lgicos de izquierda a derecha se corresponde con la secuencia de llamada.
Guardar
ADQUISICION_DATOS datos
Bloque de datos (DB)
Flujo del programa Flujo de datos
Resumen
El interface de un bloque se crea mediante parmetros a los que se puede acceder desde
otros bloques.
Los parmetros declarados en el bloque son comodines cuyos valores se determinan al
efectuarse la llamada al bloque. Estos comodines se denominan parmetros formales y los
valores asignados al llamar el bloque, parmetros actuales. Cuando se llama a un bloque se
le transfieren datos de entrada en forma de parmetros actuales. Al retornar al bloque
invocante se ponen a disposicin los datos de salida para su transferencia. Una funcin
(FC) puede transferir su resultado como valor de la funcin.
Los parmetros de bloque se pueden dividir en las siguientes categoras:
OB Ciclo
El OB CICLO no dispone de ningn parmetro formal. Llama al FB ADQUISICION y le
asigna el valor medido y los datos de control para sus parmetros formales.
FB ADQUISICION
Evaluar
El FB ADQUISICION llama al FB EVALUACION. Ambos FB reciben como dato comn el
array del valor medido que se clasificar. Por ello se declara como parmetro de
entrada/salida. Para el resultado de clculo de la raz y del cuadrado se crea un array
estructurado en forma de parmetro de salida. En la siguiente tabla se indican los
parmetros formales:
SQRT y cuadrado
Las funciones se llaman desde EVALUACION. Necesitan un valor de entrada y proporcionan
un valor de funcin como resultado.
Byte 0 Byte 4
Sistema de automatizacin
Byte 1 Byte 5
Mdulo de Mdulo de
entrada digital salida digital
Mdulo de
entrada Byte 0
E 0.3
0 Aceptacin del valor medido
E 0.4 1 Inicio de clasificacin y clculo
2 Selec. resultado: raz o cuadrado
3 Selec. salida: Valor medido o resultado
4 Codificacin bit 0
5 Codificacin bit 1
6 Codificacin bit 2
7 Aceptacin de la codificacin
Byte 1
Mdulo de
salida Byte 4 0
0a7 Byte ms significativo de la palabra
1
de salida(bits 8 s 15)
2 slo necesario en el clculo del
3 cuadrado. En otros casos, 0.
4
5
6
7
0
1
2
0a7 Byte menos significativo de la palabra
3 de salida (bits 0 a 7):
4 valor medido o resultado:
5 raz o cuadrado.
6
Byte 5 7
CUADRADO FC
Llama a
EVALUAR FB
Llama a
REGISTRAR FB
Llama a
CICLO OB
rea de instrucciones
En primer lugar se comprueba si el valor de entrada excede el lmite en el que el resultado
es superior al rango permitido para enteros. En este caso se registrara el valor mximo
para Integer. En caso contrario, se efectuara la operacin de elevar al cuadrado. El
resultado se transfiere como valor de funcin.
EVALUACION
bloque de funcin Inicio
Inicio de la
instruccin REPEAT Cambio := FALSE
I := LIMITE
I significa ndice
Inicio de la
instruccin FOR No
I >= 1 ?
S
bufer_clasif [I-1] >
bufer_clasif [I]
? Intercambiar los valores de
bfer de clasificacin [I-1]
No
y bfer de clasificacin [I]
CAMBIO = TRUE
I := I-1
Fin de la
instruccin FOR
Fin de la
instruccin REPEAT
Cambiar ?
TRUE
FALSE
I := 0
Inicio de la
instruccin FOR
No
I <= LIMITE ?
Fin de la I := I+1
instruccin FOR
Fin
El rea de declaracin de este bloque est formada por las siguientes partes:
Constantes: entre CONST y END_CONST
Parmetros de entrada/salida: entre VAR_IN_OUT y END_VAR,
Parmetros de salida: entre VAR_OUTPUT y END_VAR
Declaracin de las variables temporales: entre VAR_TEMP y END_VAR
CONST
LIMITE := 7;
END_CONST
VAR_IN_OUT
bufer_clasif : ARRAY[0..LIMITE] OF INT;
END_VAR
VAR_OUTPUT
bufer_calculo : ARRAY[0..LIMITE] OF
STRUCT
raiz : INT;
cuadrado : INT;
END_STRUCT;
END_VAR
VAR_TEMP
cambiar : BOOL;
indice, ayuda : INT;
n_valor, n_resultado: REAL;
END_VAR
bufer_clasif
valores_medidos
bufer_calculo
EVALUACION
Este interface muestra el ncleo del intercambio de datos para procesar los valores
medidos. Los valores se guardan en el bloque de datos de instancia ADQUISICION_DATOS
ya que en el FB ADQUISICION invocante se ha creado una instancia local para el
FB EVALUACION.
BEGIN
(*******************************************************************
Parte 1 'Clasificacion' : Clasificacin segn el proceso "bubble
sort": intercambiar de dos en dos los valores hasta que el bfer de
valores medidos est clasificado
*******************************************************************)
REPEAT
cambiar := FALSE;
FOR indice := LIMITE TO 1 BY -1 DO
IF bufer_clasif[indice-1] > bufer_clasif[indice] THEN
ayuda := bufer_clasif[indice];
bufer_clasif[indice] := bufer_clasif[indice-1];
bufer_clasif[indice-1] := ayuda;
cambiar := TRUE;
END_IF;
END_FOR;
UNTIL NOT cambiar
END_REPEAT;
(*******************************************************************
Parte 2 'Calculo' : Clculo de la raz con la funcin estndar RAIZ
y obtencin del cuadrado con la funcion CUADRADO.
*******************************************************************)
FOR indice := 0 TO LIMITE BY 1 DO
n_valor := INT_TO_REAL(bufer_clasif[indice]);
n_resultado := SQRT(n_valor);
bufer_calculo[indice].raiz := REAL_TO_INT(n_resultado);
bufer_calculo[indice].cuadrado := CUADRADO(bufer_clasif[indice]);
END_FOR;
ADQUISICION
Bloque de funcin
Inicio
Cambio S
valor nuevo
? Con la operacin MOD se real
Leer valor medido en el bfer de iza el bfer de circulacin:
No circulacin, recalcular el puntero cuando se alcance el lmite,
iniciar desde el principio.
Cambio
S
clasificacin
nueva?
Clasificar bfer de circulacin y
No VALORACIO efectuar clculos (para hacerlo,
N crear rea de resultados)
Cambio S
cdigo nuevo
? Primero desplazar los bits rele vantes
Evaluar cdigo y determinar hasta el borde derecho, y despus
No
direccin de salida ocultar las posiciones no
necesarias con AND
Seleccin de TRUE
funcin?
FALSE
Cargar resultado de Cargar resultado de
RAIZ CUADRADO
Cargar:
escribir elementos de la lista en los
parme tros de salida junto con la
Cargar valor medido direccin de salida, para despus
indicar sus valores
Fin
CONST
LIMITE := 7;
NUMERO:= LIMITE + 1;
END_CONST
VAR_INPUT
intr_val_med: INT ; // Nuevo valor medido
nue_val : BOOL; // Aceptar valor medido en bfer de circulacin
// "valores_medidos"
nue_clas : BOOL; // Clasificar valores medidos
sel_funcion : BOOL; // Seleccionar la funcin de clculo
raiz/cuadrado
nue_sel : BOOL; // Aceptar direccin de salida
seleccion: WORD; // Direccin de salida
END_VAR
VAR_OUTPUT
sal_resultado: INT; // valor calculado
sal_v_med: INT; // valor medido correspondiente
END_VAR
VAR
valores_medidos : ARRAY[0..LIMITE] OF INT := 8(0);
bufer_resultado : ARRAY[0..LIMITE] OF
STRUCT
raiz : INT;
cuadrado : INT;
END_STRUCT;
puntero : INT := 0;
ant_val : BOOL := TRUE;
ant_clas : BOOL := TRUE;
ant_sel : BOOL := TRUE; // Direccin de salida convertida
valorar_instancia: evaluacion; //Declarar instancia local
END_VAR
Variables estticas
Se ha seleccionado el tipo de bloque FB porque hay datos que se deben mantener de un
ciclo de programa al siguiente. Estos datos son las variables estticas declaradas en el
bloque de declaracin "VAR, END_VAR".
Las variables estticas son variables locales cuyo valor se mantiene en todos los recorridos
del bloque. Sirven para guardar los valores de un bloque de funcin y se almacenan en el
bloque de datos de instancia.
Clculo de la direccin
La siguiente figura muestra el clculo de la direccin: la palabra de entrada EW0 contiene
en los bits 12 a 14 el cdigo que se acepta cuando en el interruptor de codificacin (bit 15)
se detecta un flanco. Desplazando a la derecha con la funcin estndar SHR e inhibiendo
los bits relevantes con una mscara AND se calcula la "direccin".
Con esta direccin se escriben los elementos de array (resultado de clculo y valor medido
correspondiente) en los parmetros de salida. Que la salida sea raz o cuadrado depende
de la "seleccin de funcin".
Un flanco en el interruptor de codificacin se detecta porque el "valor nuevo" cambia
respecto al "valor antiguo".
0 0 0 0
1 1 1 1 "direccin"
2 2 2 2
3 3 3 3
Interruptor 4 4 4 4
para valor de 5 5 5 5
codificacin
6 6 6 6
Interruptor 7 7 7 7
de codifi Byte0
cacin
0 8 8 8
1 9 9 9
2 10 10 10
3 11 11 11
4 12 12 12
5 13 13 13
6 14 14 14
7 15 15 15
Byte1 EW0
rea de instrucciones
El rea de instrucciones del bloque lgico presenta la siguiente estructura:
BEGIN
(*******************************************************************
Parte 1 : 'Adquisicion' de 'valores_medidos'
Al cambiar "nue_val" se produce la entrada del valor medido.
Con la operacin MOD se ejecuta un bfer de circulacin para valores
medidos.
*******************************************************************)
IF nue_val <> ant_val THEN
puntero := puntero MOD NUMERO;
valores_medidos[puntero] := Intr_val_med;
puntero := puntero + 1;
END_IF;
ant_val := nue_val;
(*******************************************************************
Parte 2 : Iniciar 'Clasificacin' y 'Clculo'
Al cambiar "nue_clas" se inicia la clasificacin del bfer de
circulacin y la ejecucin
de los clculos con los valores medidos. Los resultados se guardan
en un nuevo array, "bufer_calculo".
******************************************************************)
IF nue_clas <> ant_clas THEN
puntero := 0; //Inicializar puntero del bfer de
circulacin
valorar_instancia(bufer_clasif := valores_medidos); // Llamar
evaluacion
END_IF;
ant_clas := nue_clas;
bufer_resultado := valorar_instancia.bufer_calculo; //cuadrado y
raiz
(*******************************************************************
Parte 3 : Valorar cdigo y preparar salida:
Al cambiar "nue_sel" se determina de nuevo el cdigo para el
direccionamiento del elemento
de array para la salida: Los datos relevantes de 'seleccion' se
ocultan y se transformen en entero. Dependiendo de la posicin
del interruptor de "sel_funcion" en la salida se dispondr "RAIZ"
o "CUADRADO" *)
*******************************************************************)
IF nue_sel <> ant_sel THEN
direccion := WORD_TO_INT(SHR(IN := seleccion, N := 12) AND
16#0007);
END_IF;
ant_sel := nue_sel;
IF sel_funcion THEN
sal_resultado:= bufer_resultado[direccion].cuadrado;
ELSE
sal_resultado:= bufer_resultado[direccion].raiz;
END_IF;
sal_v_med := valores_medidos[direccion]; //indicacin del valor
medido
END_FUNCTION_BLOCK
ORGANIZATION_BLOCK CICLO
(*******************************************************************
CICLO equivale al OB1, es decir, el sistema S7 lo llama cclicamente
Parte 1 : llamada del bloque de funcin y transferencia de los
valores de entrada
Parte 2 : aceptacin de los valores de salida con conmutacin de
salida
*******************************************************************)
VAR_TEMP
datos_del_sistema : ARRAY[0..20] OF BYTE; // Area para OB1
END_VAR
BEGIN
(* Parte 1 :
*****************************************************)
ADQUISICION.ADQUISICION_DATOS(
intr_val_med := WORD_TO_INT(entrada),
nue_val := "entrada 0.0",//Interruptor de entrada como smbolo
nue_clas := "Interr_clasif",
sel_funcion := "Interr_funcion",
nue_sel := "Interr_codif",
seleccion := codificacion);
(* Parte 2 :
********************************************************)
IF Interr_salida THEN //Conmutacin de salida
salida := ADQUISICION_DATOS.sal_resultado; //Raz o cuadrado
ELSE
salida := ADQUISICION_DATOS.sal_v_med; //Valor medido
END_IF;
END_ORGANIZATION_BLOCK
Requisitos
Para el test se necesita un mdulo de entrada con la direccin 0 y un mdulo de salida con
la direccin 4.
Antes de efectuar el test, conmutar los 8 interruptores superiores del mdulo de entrada
hacia la izquierda ("0") y los 8 interruptores inferiores hacia la derecha ("1").
Cargue previamente los bloques en la CPU, ya que tambin se comprueban los valores
iniciales de las variables inmediatamente despus.
Test adicional
En las siguientes tablas aparecen los interruptores del mdulo de entrada y patrones de test
para la raz y el cuadrado. Adems, estas tablas le ayudarn a definir sus propios pasos de
test:
La entrada se realiza a travs de interruptores: el programa se puede controlar mediante
los 8 interruptores superiores y los valores medidos se pueden ajustar con los 8
inferiores.
La salida se realiza a travs de indicadores: en el grupo superior aparece el byte de
salida ms significativo, y en el grupo inferior el menos significativo.