Programa Académico: Mayo 3 de 2022

Guía para el controlador en lenguaje SCL: con redes neuronales
autoajustable.
Lenguaje SCL en el TIA portal
Asignatura Automatización de Procesos Industriales
PROGRAMA INGENIERIA EN INSTRUMENTACION Y CONTROL INDUSTRIAL

ACADÉMICO
ASIGNATURA: Automatización de Procesos Industriales
CÓDIGO: ING00280 CREDITOS:
INTENSIDAD HORARIA 6 Distribución HDD 6 HTI 12

SEMANAL: horaria:
HTD 0
PRERREQUISITOS
CORREQUISITOS:
ULTIMA ACTUALIZACIÓN: Mayo 3 de 2022
MATERIALES
 Acceso al módulo multivariable del Politécnico JIC o algún modulo de control de nivel con
PLC siemens CPU 1214 DC/DC/DC o similar.
 Computador conexión Ethernet.
 Instalado el software de TIA portal.
autoajustable.
DESCRIPCIÓN DEL INSTRUMENTO
 TIA portal:
TIA Portal es la clave para liberar todo el potencial de Totally Integrated Automation. El
software optimiza todos sus procedimientos de procesamiento, operación de máquinas y
planificación. Siemens está apoyando a la industria a capitalizar las oportunidades que
ofrece la digitalización. Productos y sistemas para la Empresa Digital entregan a los
fabricantes de máquinas y operadores de planta ventajas competitivas a lo largo de toda la
cadena de valor. En el campo de ingeniería de producción, la plataforma de software TIA
Portal es la puerta de entrada a la automatización en la Empresa Digital.
TIA Portal apoya a los fabricantes de máquinas y operadores de planta en este proceso con
ingeniería consistente, operación transparente y ejecución perfecta de los procedimientos
de trabajo digitales, reduciendo así el tiempo al mercado, a través de la coordinación entre
los equipos interdisciplinarios mediante la generación automática de soluciones de
automatización para reemplazar la programación manual. Todo esto hace de TIA Portal un
elemento central en el camino a la Empresa Digital, con nuevas funciones para los procesos
digitales. Las nuevas funciones incluyen la puesta en servicio virtual, redes virtuales con
soluciones flexibles en la nube, e interfaces abiertas para una mayor conectividad, así como
la consistencia de los datos y la transparencia en la producción. Adicionalmente, con el
aumento de la digitalización, la seguridad integral en la automatización se vuelve cada día
más importante.
 Lenguaje SCL:
Podemos definir el SCL como un lenguaje de alto nivel en el que Siemens lo define como
sigue: Lenguaje estructurado de control basado en líneas de texto, se corresponde con la
norma IEC 61131-3 (ST) Certificado de acuerdo con PLC open, ejecución de cálculos
complejos y algoritmos, Operaciones con datos, como por ejemplo ordenar los datos.
Código de programa intercambiable con las distintas plataformas de Siemens: S7-1200, S7-
300. S7-400 y WinAC.
Se caracteriza por su editor basado en texto, con resaltado, finalización automática, soporte
para pasar parámetros a una función a otra, optimizado para los algoritmos más complejos
y para las manipulaciones de datos, acceso al conjunto de comandos de los controladores
SIMATIC, Intercambio de fuentes ASCII mediante la importación – exportación.
utilización del lenguaje dentro de un bloque, pudiendo utilizar marcas o variables ya creadas
en el proyecto, con información de las mismas desplazando el cursor por encima, con la
posibilidad de añadir comentarios con la doble barra “//”, tal y como se haría en un lenguaje
de alto nivel.
autoajustable.
OBJETIVO
Durante este ejercicio se desarrollará la aplicación de un controlador autoajustable usando redes

neuronales en el lenguaje de programación SCL para PLC siemens en el TIA.
PROCEDIMIENTO.
1. Iniciaremos agregando la CPU con la cual estamos conectados en este caso agregamos el
siemens CPU 1214 DC/DC/DC en el cual agregamos un nuevo bloque de función en el que
codificaremos nuestro controlador neuronal que lo realizaremos en lenguaje SCL, lo
creamos como se ve en la Fig. 1. El cual lo llamamos ‘controlNeuronal’
Fig. 1. Creación del bloque para el controlador neuronal
2. Para desarrollar el controlador neuronal autoajustable vamos a implementar una

estructura de red neuronal sencilla la cual costa de cuatro neuronas, las cuales tres se
encuentran en la capa de entrada y una en la capa de salida como se ve en la Fig. 2. En la
cual los atributos de entrada a nuestra red van a ser tres los cuales son el error actual que
es la diferencia entre set point y la variable a controlar, y los dos errores anteriores
almacenados.
Fig. 2. Estructura de la red neuronal

autoajustable.
La función de activación que vamos a consideraremos en nuestro algoritmo para cada una
de las neuronas es conocida como función sigmoidal, y está definida como:
1
𝑓(𝑟) = 1+ℯ (−𝑟) (1)
En la ecuación (1) la ‘r’ se refiere a la sumatoria de cada una de las entradas de la neurona
multiplicada por su peso correspondiente. esta función además de ser diferenciable, tiene
la particularidad de que su derivada se puede expresar en términos de sí misma:
𝜕𝑓(𝑟)
= 𝑓(𝑟) ∗ [1 − 𝑓(𝑟)] (2)
𝜕𝑟
La ecuación (2) nos servirá para simplificar los cálculos en el algoritmo de aprendizaje para
hacer la BACKPROPAGATION y realizar la actualización de pesos en línea, para autoajustar
nuestro controlador.
3. Agregamos las siguientes variables globales en una tabla de variables estándar en la cual
colocaremos las variables correspondientes a los pesos de la red neuronal, a los errores
respecto a la variable con el set point, la variable de entrada del nivel y las necesarias para
escarizarlo como la salida para la válvula neumática como se ve en la Fig. 3.
Fig. 3. Tabla de variable en el PLC

autoajustable.
4. Crearemos un nuevo bloque del programa para que se ejecute solo una vez cuando
coloquemos en RUN el PLC, el cual va a ser el encargado de asignar los valores iniciales a
las variables correspondientes a los pesos a la red neurona como se muestra en la Fig. 4.
En el cual le cargamos los valores deseados a inicializar a cada uno de los pesos de la red
neuronal.
Fig. 4. Bloque Startup inicialización de pesos
5. Luego de crear e inicializar todas las variables que vamos a necesitar en la implementación
del controlador nos dirigimos a nuestro bloque de función ‘controlNeuronal’ donde vamos
a codificar todo nuestro código para la actualización y encontrar la salida del controlador
para la válvula. Inicialmente vamos a configurar los parámetros de entrada de nuestra
función en la cual vamos a recibir los pesos actuales de nuestra red neuronal, también los
atributos de entrada a nuestra red junto con la variable a controlar en el estado actual y el
set point al que queremos llegar como se muestra en la Fig. 5.
Fig. 5. Variables de entrada a la función del controlador neuronal

autoajustable.
6. También configuramos los parámetros de salida de nuestra función para seleccionar que
valores va a retornar después de ejecutar sus líneas de código en la cual saldrán los pesos
actualizados de la red junto con el error actual y el error anterior actualizado junto con la
salida del controlador como se ve en la Fig. 6.
Fig. 6. Variables de salida de la función del controlador neuronal
7. Para el desarrollo de nuestro código vamos a necesitar algunas variables temporales las
cuales también hay que especificar en su tabla de variables correspondiente dentro de la
función creada donde posterior mente vamos a codificar las líneas de código pertinente
para el controlador neuronal, las variables temporales se contemplan en la Fig. 7
Fig.7. variables temporales en el controlador neuronal

autoajustable.
8. Después de definir tanto nuestras variables de entrada de salida como las temporales que
vamos a utilizar en el controlador neuronal se procede a codificar el código pertinente
para hace el controlador neuronal. Inicialmente hallamos el error actual que corresponde
a la diferencia entre el set point y la variable a controlar en el cual actualizamos el error
actual y los errores pasados y los almacenamos de forma ordenada para después
introducirlos a la red neuronal como se muestra en la Fig. 8.
Fig. 8. Actualización del error
9. En esta red utilizaremos un alfa o rata de aprendizaje la cual va a estar variando respecto
al valor absoluto del error actual el cual va a comportarse directamente proporcional al
error el cual se multiplica por un factor de 0.98 observada en la Fig. 9.
Fig. 9. Rata de aprendizaje de la red neuronal
10. Procedemos a hallar las salidas de la capa de entrada de la red, para cada una de nuestras
neuronas en la cual cogemos nuestros atributos de entrada que son los errores, hacemos
la sumatoria de la multiplicación de los errores por sus pesos respectivamente, a dicha
suma se le aplica la función de activación implementada en las neuronas par hallar la
salida correspondiente a cada una, como en la Fig. 10.
Fig. 10. Valor de salida de la capa de entrada de la red neuronal

autoajustable.
11. Así mismo como en el paso anterior procedemos a obtener la salida de la neurona de la
capa de salida de nuestra red la cual es el resultante de nuestro controlador como se ve en
la Fig. 11.
Fig. 11. Valor de salida de la capa de salida de la red neuronal
12. Para proceder a la actualización de los pesos hay que hacer la BACKPROPAGATION del
error la cual la almacenamos en unas variables para simplificar las ecuaciones de
actualización de pesos mas adelante como se ve en la Fig. 12. En la cual se aplican las
derivadas parciales del error respecto a la función de activación (1), usando la
simplificación de su derivada parcial (2), en la cual para la primera propagación es
respecto a la última neurona de la red, es respecto con el error y la salida actual de la red,
y las otras tres neuronas son respecto al porcentaje del error que les corresponde de
acuerdo a su peso actual y al valor de su salida anteriormente encontrado.
Fig. 12 BACKPROPAGATION del error para cada neurona
13. Al obtener el factor de corrección a aplicar a cada uno de los pesos, procedemos a la
actualización de estos la cual involucra tanto el peso actual como el resultado obtenido de
la BACKPROPAGATION y también involucra la rata de aprendizaje ‘alfa’ con la entrada
correspondiente al peso que se esta actualizando como se ve en la Fig. 13.
Fig. 13. Actualización de pesos de la red neuronal

autoajustable.
14. Como nuestra red neuronal nos da una salida de 0 a 1 la multiplicamos por 100 para
después hacerle la escalización respectiva para llevarla a la salida de la variable a
manipular en este caso en una válvula neumática como en la Fig. 14.
Fig. 14. Ecualización de la variable a manipular en el proceso
15. En el bloque principal MAIN agregamos toda la parte que tiene que ver con la escalización
de la variable que se va a controlar en este caso es nivel la cual primero la normalizamos
de 0 a 1 respecto al valor de nuestro sensor con sus limites tanto inferior como superior y
posteriormente esta variable la llevamos a la escala entre 0.0 y 100.0 y se limita para que
no sobrepase o disminuya estos valores el cual vamos a introducir a el controlador
neuronal como esta en la Fig. 15.
Fig. 15. escalización variable a controlar en el bloque MAIN
16. Por último, tenemos que agregar la función que acabamos de crear ‘controlNeuronal’ al
bloque principal MAIN para que lo ejecute cíclicamente, en este en el lado izquierdo del
bloque agregado le tenemos que dar las referencias de cada una de las variables que
inicializamos y creamos anteriormente en su ubicación respectiva, dentro de estas
variables están los pesos de nuestra red neuronal, los retrasos en los errores, el set
point(dt) y la variable a controlar que es el nivel en este caso. Así mismo hay que colocarle
a lado derecho las referencias de todas las variables para que se actualicen cada vez que
ejecute este bloque como se ve en la Fig. 16.
autoajustable.
Fig. 16. bloque del controlador neuronas agregada al bloque MAIN
17. Para llevar la acción de control a la válvula usamos el bloque move el cual llevamos el valor
de la marca a la salida análoga del PLC visto en la Fig. 17.
Fig.17. acción de control a salida análoga
DESAFÍOS
 Hacerle las modificaciones pertinentes para agregarles el sesgo a cada una de a las
neuronas y su posterior actualización de pesos, junto con un SCADA en una HMI.
 Implementar métricas de desempeño al controlador neuronal.
 Hacer un controlador PID auto sintonizable y sacarle métricas de desempeño y
compararlas con las obtenidas con el controlador neuronal.
autoajustable.
RECOMENDACIÓN IMPORTANTE:
Se comparte código realizado en Python, el cual mostró un muy buen desempeño. Se aclara que
este código implementa la comunicación PLC-Python utilizando la librería Snap7, además en el PLC
no se realizó ninguna escalización, por lo tanto se implementa la misma en Python. Se recomienda
tomar como referencia, si desea también probarlo en el lenguaje SCL, o probarlo directamente en
Python, para lo cual necesitará cargar en el PLC un proyecto completamente vacío. También en el
programa se implementa una escritura en un archivo de texto tipo CSV, el cual debe ser creado vacío
en la misma carpeta donde se incluya el archivo de Python.
import snap7.client as c
from snap7.util import *
from snap7.snap7types import *
import time
import keyboard # using module keyboard
import os
import math
import csv
#Variables del controlador

y = [0.0, 0.0] #Salida del la planta [0:actual,
1:anterior]
xe = [0.0, 0.0, 0.0, 0.0] #primera capa con errores de entrada
sp = 0 #set-point
alfa1 = 0.1
alfa=0.1
u = 0.2
#Inicialización de pesos
we11 = we21 = we31 = we12 = we22 = we32 = \
we13 = we23 = we33 = 0.1
we11a = we21a = we31a = we12a = we22a = we32a = \
we13a = we23a = we33a = 0.1
v1 = v1a = v2 = v2a = v3 = v3a = 0.1
clear = lambda: os.system('cls')
plc = c.Client()
plc.connect('192.168.0.1',0,1)
print("Conectado")
#Presión IW96
#Flujo IW98
#Nivel IW100
#Run Bomba Q0.5
#Bomba QW80
autoajustable.
#Válvula H20 QW96
#ESCRIBIR SALIDA BOOLEANA

def escr_sal_bool(byte, bit, valor):
lectura = plc.ab_read(byte, bit)
set_bool(lectura, byte, bit, valor)
plc.ab_write(0, lectura)
return
#escr_sal_bool(0,1,1)
#ESCRIBIR SALIDA ENTERO

def escr_sal_ent(byte,valor):
lectura = plc.read_area(areas['PA'], 0, byte, 2) #PA: salidas, 0:
bloque de datos, dirección, # bytes.
set_int(lectura, 0, valor) # se da formato al valor deseado, en
este caso entero
plc.write_area(areas['PA'], 0, byte, lectura) # Escribe en la
dirección definida
#escr_sal_ent(90,9000)
#LEER SALIDA ENTERO

def leer_sal_ent(byte):
leer = plc.read_area(areas['PA'],0,byte,2) #Se lee la dirección
10, 2 bytes (este 2 podría ser
leer_ent = get_int(leer,0) #Comando get_int(_bytearray,
byte_index)
return leer_ent
#lectura = leer_sal_ent(90)
#print(lectura)
#LEER MARCA ENTERA

def leer_ent_ent(byte):
leer = plc.read_area(areas['PE'],0,byte,2) #PE: entradas, 0:
bloque de datos, dirección, # bytes.
leer_ent = get_int(leer,0) #Comando get_int(_bytearray,
byte_index)
return leer_ent
#lectura = leer_mk_ent(90)
#print(lectura)
#INICIO DEL PROGRAMA

#Activar Bomba (salida Q0.5)
escr_sal_bool(0,5,1) #Habilitar RUN motobomba
#Poner bomba en 60Hz salida QW80
motobombaHz = 60
motobomba = motobombaHz * (22118 / 60) + 5530
escr_sal_ent(80,motobomba)
#Abrir válvula al 100% salida QW96
autoajustable.
valvulap = 0
valvula = ((7800 / 71.5) * (valvulap - 7.4)) + 6200
escr_sal_ent(96,valvula)
#INTERFAZ DE VISUALIZACIÓN Y CONTROL

#Motobomba: W incrementa, S decrementa
#Valvula: E incrementa, D decrementa
f = open('log.csv', 'w', encoding='UTF8')

writer = csv.writer(f)
writer.writerow(['sp', 'y', 'u'])
while True: # making a loop

try: # used try so that if user pressed other than the given key
error will not be shown
if keyboard.is_pressed('q'): # if key 'q' is pressed
print('You Pressed Q which means "Exit"!')
break # finishing the loop
elif keyboard.is_pressed('w'):
sp += 40
elif keyboard.is_pressed('s'):
sp -= 40
if sp > 80:
sp = 80
elif sp < 0:
sp = 0
# Cálculo de errores (entradas a la NN)
nivelplc = leer_ent_ent(100)
y = ((60 / 15105) * (nivelplc - 10125)) + 20
ey = (sp) - (y)
xe[3] = xe[2] # Error trasanterior e(t-2) xe3 = xe[3]
xe[2] = xe[1] # Error anterior e(t-1) xe2 = xe[2]
xe[1] = ey # Error actual e(t) xe1 = xe[1]
# Cálculo de capa oculta

he1 = (we11 * xe[1]) + (we21 * xe[2]) + (we31 * xe[3])
he1 = 1 / (1 + math.exp(-he1))
he2 = (we12 * xe[1]) + (we22 * xe[2]) + (we32 * xe[3])
he2 = 1 / (1 + math.exp(-he2))
he3 = (we13 * xe[1]) + (we23 * xe[2]) + (we33 * xe[3])
he3 = 1 / (1 + math.exp(-he3))
# Cálculo de la salida
u1 = (v1 * he1) + (v2 * he2) + (v3 * he3)
u = 1 / (1 + math.exp(-u1))
u = (u - 0.5) * 2.0
#u = (math.exp(u1) - math.exp(-u1)) / (math.exp(u1) +
math.exp(-u1)) #tanh(u)
autoajustable.
if u > 1.0:
u = 1.0
elif u < 0:
u = 0.0
valvulap = u * 100
valvula = ((7800 / 71.5) * (valvulap - 7.4)) + 6200
escr_sal_ent(96, valvula)
# Cálculo de S
s = ey * u *(1-u) # u / (math.sinh(u1) * math.sinh(u1))
s1 = s * v1 * he1 * (1 - he1)
s2 = s * v2 * he2 * (1 - he2)
s3 = s * v3 * he3 * (1 - he3)
# Actualización de pesos de salida V

v1 = v1 + (alfa * s * he1)
v2 = v2 + (alfa * s * he2)
v3 = v3 + (alfa * s * he3)
# Actualización de pesos de entrada we

we11 = we11 + (alfa * s1 * xe[1])
we12 = we12 + (alfa * s2 * xe[1])
we13 = we13 + (alfa * s3 * xe[1])
we21 = we21 + (alfa * s1 * xe[2])

we22 = we22 + (alfa * s2 * xe[2])
we23 = we23 + (alfa * s3 * xe[2])
we31 = we31 + (alfa * s1 * xe[3])

we32 = we32 + (alfa * s2 * xe[3])
we33 = we33 + (alfa * s3 * xe[3])
alfa = 0.1+(alfa1*abs(ey))
#alfa = 1.0
except:
break
time.sleep(0.5)
clear() #Se limpia la pantalla para presentar los datos
organizados.
print("SetPoint: W incrementa, S decrementa -- Q: Salir")
print("SetPoint: {}".format(sp))
print("Ley Control: {0:.4f}".format(u))
print("Nivel: {0:.2f}".format(y))
print("Error: {0:.6f}".format(ey))
print("Peso W: {0:.6f}".format(we11))
print("Peso V: {0:.6f}".format(v1))
print("Alfa: {0:.6f}".format(alfa))
print("Xe1: {0:.6f}".format(xe[1]))
autoajustable.
datocsv = ["{:.4f}".format(sp), "{:.4f}".format(y),
"{:.4f}".format(u)]
writer.writerow(datocsv)
f.close()
BIBLIOGRAFÍA
Electro industria, (2016). TIA PORTAL V14 DE SIEMENS. La puerta de entrada a la automatización de
la Empresa Digital. Recuperado de http://www.emb.cl/electroindustria/articulo.mvc?xid=2857&ni=
tia-portal-v14-de-siemens-la-puerta-de-entrada-a-la-automatizacion-de-la-empresa-digital.
tecnoplc, (2016). SCL LENGUAJE ESTRUCTURADO DE SIEMENS. recuperado de

http://www.tecnoplc.com/scl-lenguaje-estructurado/
Noriega Ponce, A. Aguado Behar, A. Ordaz Hernández, V. Rauch Sitar, (2004). Neural Networks for
Self-tuning Control Systems
Fuentes-Silva C., Noriega-Ponce A., Ocampo-Mortera M.A. y Serroukh I. (2011). Control neuronal
auto-ajustable en tiempo real de un proceso de producción de fibra óptica polimérica. Ingeniería
Investigación y Tecnología.
Elaborado por: Santiago Barrera Marín

Versión: 1
Fecha: Mayo 3 de 2022

Programa Académico: Mayo 3 de 2022

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programa Académico: Mayo 3 de 2022

Cargado por

Copyright:

Formatos disponibles

Guía para el controlador en lenguaje SCL: con redes neuronales

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

PROGRAMA INGENIERIA EN INSTRUMENTACION Y CONTROL INDUSTRIAL

CÓDIGO: ING00280 CREDITOS:

INTENSIDAD HORARIA 6 Distribución HDD 6 HTI 12

ULTIMA ACTUALIZACIÓN: Mayo 3 de 2022

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

DESCRIPCIÓN DEL INSTRUMENTO

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Durante este ejercicio se desarrollará la aplicación de un controlador autoajustable usando redes

Fig. 1. Creación del bloque para el controlador neuronal

2. Para desarrollar el controlador neuronal autoajustable vamos a implementar una

Fig. 2. Estructura de la red neuronal

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Fig. 3. Tabla de variable en el PLC

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Fig. 4. Bloque Startup inicialización de pesos

Fig. 5. Variables de entrada a la función del controlador neuronal

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Fig. 6. Variables de salida de la función del controlador neuronal

Fig.7. variables temporales en el controlador neuronal

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Fig. 8. Actualización del error

Fig. 9. Rata de aprendizaje de la red neuronal

Fig. 10. Valor de salida de la capa de entrada de la red neuronal

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Fig. 11. Valor de salida de la capa de salida de la red neuronal

Fig. 12 BACKPROPAGATION del error para cada neurona

Fig. 13. Actualización de pesos de la red neuronal

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Fig. 14. Ecualización de la variable a manipular en el proceso

Fig. 15. escalización variable a controlar en el bloque MAIN

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

Fig. 16. bloque del controlador neuronas agregada al bloque MAIN

Fig.17. acción de control a salida análoga

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

#Variables del controlador

clear = lambda: os.system('cls')

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

#Válvula H20 QW96

#ESCRIBIR SALIDA BOOLEANA

#ESCRIBIR SALIDA ENTERO

#LEER SALIDA ENTERO

#LEER MARCA ENTERA

#INICIO DEL PROGRAMA

Lenguaje SCL en el TIA portal

Asignatura Automatización de Procesos Industriales

#INTERFAZ DE VISUALIZACIÓN Y CONTROL

f = open('log.csv', 'w', encoding='UTF8')

while True: # making a loop