Brandon Engineer

Plantillas de generación automática de paginas en QElectroTech

Brandon — Fri, 28 Nov 2025 22:39:07 +0000

Introduction

QElectroTech is an open-source electrical schematic design software created by Laurent Trinques

First of all, my thanks to Laurent for such an amazing piece of software, and to everyone who has contributed to this project. Here you have the software in case you feel like giving it a try. It’s not more powerful than Eplan, but it rivals it like a true champion!

https://qelectrotech.org

How to generate an automatic table?

First of all, we need to know how to generate automatic tables in QElectroTech. For this, there are two cases: if we want to add automation based on project data or on elements in the schematic: Project > Add a summary and Project > Add a nomenclature.

Once inside, we will be able to make custom SQL queries:

Page Index

To automate the page index, we will do it from ‘Add a summary,’ and I recommend the following SQL:

				
					SELECT
    pos,
    title,
    author,
    date,
    indexrev
FROM
    project_summary_view
ORDER BY
    pos,
    title,
    author,
    date,
    indexrev;

With this query, we will automatically obtain the following table:

List of elements

To automate the list of elements, we will do it from ‘Add a nomenclature,’ and I recommend the following SQL:

				
					SELECT
    label,
    diagram_position,
    position,
    designation
FROM
    element_nomenclature_view
WHERE
    (
        element_type = 'terminal'
        OR element_type = 'thumbnail'
        OR element_type = 'simple'
        OR element_sub_type = 'commutator'
        OR element_sub_type = 'coil'
        OR element_sub_type = 'protection'
    )
    AND designation IS NOT NULL
    AND designation <> ''
    AND label IS NOT NULL
    AND label <> ''
ORDER BY
    diagram_position;

With this query, we will automatically obtain the following table:

As an alternative, instead of using position and diagram position, we can use the page so that it’s easier to read.

The SQL query would look like this:

				
					SELECT
    label,
    title,
    diagram_position,
    position,
    designation
FROM
    element_nomenclature_view
WHERE
    (
        element_type = 'terminal'
        OR element_type = 'thumbnail'
        OR element_type = 'simple'
        OR element_sub_type = 'commutator'
        OR element_sub_type = 'coil'
        OR element_sub_type = 'protection'
    )
    AND designation IS NOT NULL
    AND designation <> ''
    AND label IS NOT NULL
    AND label <> ''
ORDER BY
    diagram_position;

With this query, we will automatically obtain the following table:

Summary of elements

To automate the summary of elements, we will do it from ‘Add a nomenclature,’ and I recommend the following SQL:

				
					SELECT 
    designation,
    COUNT(*) AS Total
FROM 
    element_nomenclature_view
WHERE 
    designation IS NOT NULL
GROUP BY 
    designation;

With this query, we will obtain an automatic table of all the references we have placed in the elements under the concept ‘Article number.’

With this, we will get a pretty good list to give to our purchasing colleague, saving them a few hours of counting and, most importantly, reducing human error ^^.

I hope I’ve saved you many hours of engineering work, since a good engineer doesn’t charge by the hour but by knowledge.

La entrada Plantillas de generación automática de paginas en QElectroTech se publicó primero en Brandon Engineer.

Como guardar y visualizar datos en base de datos GRATIS

Brandon — Tue, 12 Nov 2024 18:16:10 +0000

Introduction

Hace poco una persona tenia dudas de como almacenar datos del consumo de la red en una base de datos y yo le comentaba que se puede hacer con costes muy reducidos o incluso gratuitos

Hardware

Para este ejercicio práctico se usará un dispositivo de domótica por su reducido coste

https://amzn.to/3CjvGMA

Si necesitas varios siempre puedes comprar un pack para ahorrar dinero:

https://amzn.to/3Oq3VoF

Para la inserción en base de datos usaremos un servidor en red con linux aunque yo recomiendo un IPC con procesador ARM por tener diversificado las funciones de cada dispositivo

Software

Como instalar Docker en ubuntu

Para la instalación del software empezaremos por instalar el gestor de contenedores de Docker en servidor linux basado en ubuntu

				
					sudo apt update
sudo apt upgrade
sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt upgrade
sudo apt install docker-ce docker-ce-cli containerd.io

Por ultimo verificamos que esta instalado correctamente

				
					sudo docker --version

Como instalar Node Red en Docker

Para el software de inserción en base de datos instalaremos Node Red que es un software de open source que nos permitiré conectar con infinidad de protocolos de comunicación e insertar en base de datos

				
					docker run -d --name mynodered -p 1880:1880 --restart unless-stopped nodered/node-red

Una vez ya instalado podemos proceder a acceder a los datos que nos comparte el dispositivo de Tasmota con su servidor web en mi caso esta almacenada en esta dirección IP (se recomienda usar la guía de configuración de la conexión por wifi del dispositivo para configurarlo correctamente):

http://192.168.0.34

El cual nos dará la información sobre el enchufe:

Para obtener los datos nos podemos dirigir a la siguiente:

http://192.168.0.34/cm?cmnd=STATUS%200

El cual podemos ver que esta toda la información en un JSON

				
					   "ENERGY": {
      "TotalStartTime": "2024-11-06T09:10:05",
      "Total": 1.058,
      "Yesterday": 0.268,
      "Today": 0.206,
      "Power": 0,
      "ApparentPower": 0,
      "ReactivePower": 0,
      "Factor": 0,
      "Voltage": 208,
      "Current": 0
    },

Ahora procederemos a programar la función ciclica que recopilará la información para insertarla en la base de datos para ello haremos lo siguiente:

-Añadimos nodo que se ejecuta cada 3 segundos

-Normalizamos la hora para poder insertarla en la base de datos

-Obtenemos los datos mediante una petición HTTP mediante el método “GET”

-Extraemos los datos que nos interesa del JSON

-Creamos la consulta con los datos extraídos

-Insertamos en nuestro servidor

-Mostramos en consola para comprobar que todo funciona correctamente

				
					[
    {
        "id": "72594c6cf3e187c5",
        "type": "debug",
        "z": "a7cda68e269cad0e",
        "name": "debug 25",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "true",
        "targetType": "full",
        "statusVal": "",
        "statusType": "auto",
        "x": 720,
        "y": 940,
        "wires": []
    },
    {
        "id": "e49938d64834e868",
        "type": "http request",
        "z": "a7cda68e269cad0e",
        "name": "",
        "method": "GET",
        "ret": "txt",
        "paytoqs": "ignore",
        "url": "http://192.168.0.34/cm?cmnd=STATUS%200",
        "tls": "",
        "persist": false,
        "proxy": "",
        "insecureHTTPParser": false,
        "authType": "",
        "senderr": false,
        "headers": [],
        "x": 530,
        "y": 880,
        "wires": [
            [
                "273d22936082a16a"
            ]
        ]
    },
    {
        "id": "7957f9fe99d9eee6",
        "type": "inject",
        "z": "a7cda68e269cad0e",
        "name": "",
        "props": [
            {
                "p": "date",
                "v": "iso",
                "vt": "date"
            }
        ],
        "repeat": "3",
        "crontab": "",
        "once": true,
        "onceDelay": "3",
        "topic": "",
        "x": 200,
        "y": 880,
        "wires": [
            [
                "23d3e98baab1ce6a"
            ]
        ]
    },
    {
        "id": "273d22936082a16a",
        "type": "function",
        "z": "a7cda68e269cad0e",
        "name": "Extraer datos del JSON",
        "func": "// Convierte msg.payload a string si no lo es\nvar payloadStr = msg.payload.toString();\n\n// Elimina espacios en blanco al inicio y al final\npayloadStr = payloadStr.trim();\n\n// Si el payload comienza y termina con comillas dobles, las elimina\nif (payloadStr.startsWith('\"') && payloadStr.endsWith('\"')) {\n    payloadStr = payloadStr.substring(1, payloadStr.length - 1);\n}\n\n// Reemplaza las comillas dobles escapadas por comillas dobles reales\npayloadStr = payloadStr.replace(/\\\\\"/g, '\"');\n\ntry {\n    // Parsea el string a objeto JSON\n    var payloadObj = JSON.parse(payloadStr);\n\n    // Verifica si existen los datos de ENERGY\n    if (payloadObj.StatusSNS && payloadObj.StatusSNS.ENERGY) {\n        // Asigna los valores de ENERGY al payload\n        msg.payload = payloadObj.StatusSNS.ENERGY;\n    } else {\n        node.error(\"No se encontró 'StatusSNS.ENERGY' en el payload\", msg);\n        return null;\n    }\n} catch (e) {\n    // Maneja errores de parseo\n    node.error(\"Error al parsear JSON: \" + e.message, msg);\n    return null;\n}\n\nreturn msg;\n",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 250,
        "y": 940,
        "wires": [
            [
                "456e7462c5d896e9"
            ]
        ]
    },
    {
        "id": "4086d7eafeeaf2bd",
        "type": "mysql-r2",
        "z": "a7cda68e269cad0e",
        "name": "",
        "host": "192.168.0.125",
        "database": "****",
        "username": "****",
        "password": "****",
        "sql": "",
        "port": "****",
        "pooling": false,
        "waitForConnections": true,
        "connectionLimit": "10",
        "queueTimeout": "10000",
        "x": 580,
        "y": 940,
        "wires": [
            [
                "72594c6cf3e187c5"
            ]
        ]
    },
    {
        "id": "456e7462c5d896e9",
        "type": "template",
        "z": "a7cda68e269cad0e",
        "name": "",
        "field": "sql",
        "fieldType": "msg",
        "format": "handlebars",
        "syntax": "mustache",
        "template": "INSERT INTO `Grafana`.`Consume` (`con_date`, `con_voltage`, `con_current`, `con_power`, `con_AppPower`, `con_ReactPower`, `con_PowerFactor`, `con_EnergyToday`) VALUES ('{{date}}', '{{payload.Voltage}}', {{payload.Current}}, {{payload.Power}}, {{payload.ApparentPower}}, {{payload.ReactivePower}}, {{payload.Factor}}, {{payload.Today}});",
        "output": "str",
        "x": 440,
        "y": 940,
        "wires": [
            [
                "4086d7eafeeaf2bd"
            ]
        ]
    },
    {
        "id": "23d3e98baab1ce6a",
        "type": "function",
        "z": "a7cda68e269cad0e",
        "name": "Normalizar hora",
        "func": "// Obtiene la fecha original de msg.date\nvar originalDate = msg.date;\n\n// Verifica si msg.date está definido\nif (!originalDate) {\n    node.error(\"msg.date no está definido.\", msg);\n    return null;\n}\n\n// Convierte la cadena de fecha a un objeto Date\nvar dateObj = new Date(originalDate);\n\n// Verifica si la fecha es válida\nif (isNaN(dateObj.getTime())) {\n    node.error(\"La fecha proporcionada no es válida: \" + originalDate, msg);\n    return null;\n}\n\n// Extrae los componentes de la fecha y hora en UTC\nvar year = dateObj.getUTCFullYear();\nvar month = ('0' + (dateObj.getUTCMonth() + 1)).slice(-2);\nvar day = ('0' + dateObj.getUTCDate()).slice(-2);\nvar hours = ('0' + dateObj.getUTCHours()).slice(-2);\nvar minutes = ('0' + dateObj.getUTCMinutes()).slice(-2);\nvar seconds = ('0' + dateObj.getUTCSeconds()).slice(-2);\n\n// Formatea la fecha al formato deseado\nmsg.date = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;\n\nreturn msg;\n",
        "outputs": 1,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 360,
        "y": 880,
        "wires": [
            [
                "e49938d64834e868"
            ]
        ]
    }
]

Como instalar Grafana

Para la visualización utilizaremos Grafana el cual tiene una gran variedad de herramientas de visualización en mi caso hare que sea accesible por el puerto 1882

				
					docker run -d --name mygrafana -p 1882:3000 --restart unless-stopped grafana/grafana

Una vez listo yo recomiendo realizar las siguientes configuraciones para poder acceder a los gráficos sin tener que iniciar sesión cada vez que se arranque el visualizador

				
					docker exec -it -u root mygrafana /bin/sh
vi /etc/grafana/grafana.ini

Ahora habilitaremos la visualización de forma anonima modificando estas lineas:

				
					[auth.anonymous]
enabled = true
org_role = Viewer

Por último habilitaremos el uso de graficas en iframes

				
					[security]
allow_embedding = true

Una vez listo configuraremos nuestras gráficas como deseemos en mi caso tengo estas gráficas

Como instalar FUXA

Para la instalación de Fuxa como SCADA de código abierto al tener ya instalado docker es tan sencillo como hacer una pull del repositorio de github y hacer que se autoarranque al iniciar el servidor

				
					docker run -d \
  --name fuxa \
  -p 1881:1881 \
  -v fuxa_appdata:/usr/src/app/FUXA/server/_appdata \
  -v fuxa_db:/usr/src/app/FUXA/server/_db \
  -v fuxa_logs:/usr/src/app/FUXA/server/_logs \
  -v fuxa_shapes:/usr/src/app/FUXA/client/assets/lib/svgeditor/shapes \
  -v fuxa_images:/usr/src/app/FUXA/server/_images \
  --restart unless-stopped \
  frangoteam/fuxa:latest

Ya tenemos listo ahora es tan facil como crear un proyecto usar el objeto “iFrame” de Fuxa y ya podemos empezar a visualizar los datos

La entrada Como guardar y visualizar datos en base de datos GRATIS se publicó primero en Brandon Engineer.

Instalar Fuxa en Raspberry pi

Brandon — Sun, 20 Oct 2024 16:39:43 +0000

				
					sudo apt-get update
sudo apt-get upgrade

Instalar docker en raspberry pi

Para la instalación de docker deberemos seguir los siguientes pasos

				
					sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/raspbian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/raspbian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Instalar y configurar Fuxa en Raspberry pi

Para la instalación de Fuxa he seguido el manual que tienen en la wiki

				
					sudo docker pull frangoteam/fuxa:latest

Si leemos la wiki veremos que nos recomiendan para que al volver a arrancar se mantengan los datos guardados usar este comando:

				
					sudo docker run -d -p 1881:1881 -v fuxa_appdata:/usr/src/app/FUXA/server/_appdata -v fuxa_db:/usr/src/app/FUXA/server/_db -v fuxa_logs:/usr/src/app/FUXA/server/_logs -v fuxa_shapes:/usr/src/app/FUXA/client/assets/lib/svgeditor/shapes -v fuxa_images:/usr/src/app/FUXA/server/_images frangoteam/fuxa:latest

Pero como yo quiero que el SCADA se ejecute automáticamente al arrancar el sistema operativo he decidido añadirlo como servicio que se auto ejecute al inicio. Para ello deberemos teclear

				
					sudo nano /etc/rc.local

Y agregaremos el comando el fichero por ejemplo a mi se me queda el archivo así:

				
					#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Your command here
sudo docker run -d -p 1881:1881 -v fuxa_appdata:/usr/src/app/FUXA/server/_appdata -v fuxa_db:/usr/src/app/FUXA/server/_db -v fuxa_logs:/usr/src/app/FUXA/server/_logs -v fuxa_shapes:/usr/src/app/FUXA/client/assets/lib/svgeditor/shapes -v fuxa_images:/usr/src/app/FUXA/server/_images frangoteam/fuxa:latest


exit 0

La entrada Instalar Fuxa en Raspberry pi se publicó primero en Brandon Engineer.

No me detecta el PLC de Beckhoff

Brandon — Sun, 07 Apr 2024 11:39:34 +0000

Introduction

Con windows 11 estoy detectando algunos problemas con twincat a la hora de detectar los IPC de beckhoff y quería compartir con vosotros como lo he solucionado:

Comprobar si lo detecta twincat

Al buscar el adaptador de red no me sale el adaptador de red por cable.

El problema es que no tenemos una ip en el adaptador de red de nuestro portátil para poner una ip en el rango lo que hice fue meterme en el PLC y ver en que rango esta con el comando ipconfig en el cmd de windows:

Como ya tengo la ip del adaptador de red en el que estoy conectado ya puedo configurar mi adaptador de red:

Una vez ya hecho volvéis a buscar la red y os mostrará el adaptador correctamente

La entrada No me detecta el PLC de Beckhoff se publicó primero en Brandon Engineer.

Como optimizar tu código en SCL

Brandon — Wed, 20 Mar 2024 21:49:59 +0000

Introduction

Esta tarde estaba aburrido en casa y puse a prueba una idea que lleva tiempo rondándome la cabeza: “¿Es más optimo usar una máquina de estados que un sistema tradicional?” Mi suposición es que al usar una máquina de estados esta saltará el código que no se usa y permitirá ignorar el código que no se utilizará por lo que podrías optimizarlo para no tener a tu maquina ahogándose.

¿Cómo se ha realizado?

Para esta prueba decidí ejecutarla en el entorno de Twincat de Beckhoff Automation, que me da control del conocimiento de cada núcleo y compararlo en el mismo instante de tiempo. Preparé los FB, al final llamé a 300 FB por cada una de las tareas con un tiempo de ejecución de 0.5ms y comparé los rendimientos.

Llamada de las tareas

Para hacer una carga grande de recursos se ha llamado a 300 FB para que sea apreciable los consumos

bSwitching(bStart=>bStart);

FOR counter:=1 TO 299 BY 1 DO

    fb[counter](bInputDown:=bStart);

END_FOR;

“bStart” es un booleano que cambia de true a false cada segundo

Con estados

El código para la function block

FUNCTION_BLOCK FB_WaitandWriteState
VAR_INPUT
	bInputUp : BOOL; // Entrada para subir
    bInputDown : BOOL; // Entrada para bajar
END_VAR
VAR_OUTPUT
	bOutputUp : BOOL := FALSE; // Salida para subir
    bOutputDown : BOOL := FALSE; // Salida para bajar
END_VAR
VAR
    Temporizador : TON := (PT:= T#60S); // Temporizador de 60 segundos
    TemporizadorEspera : TON := (PT:= T#1S); // Temporizador de espera de 1 segundo
    EstadoMaquinaActual : INT:=0;
END_VAR

El código usado para el programa ha sido:

CASE EstadoMaquinaActual OF
    // Estado inicial, esperando la entrada
    0:
        IF bInputUp THEN
            EstadoMaquinaActual := 10; // Cambiar al estado de subir
        ELSIF bInputDown THEN
            EstadoMaquinaActual := 20; // Cambiar al estado de bajar
        END_IF
    // Estado de subir
    10:
        bOutputUp := TRUE; // Activar la salida de subir
        Temporizador(IN:= TRUE); // Iniciar temporizador de 60 segundos
        IF Temporizador.Q THEN
            EstadoMaquinaActual := 30; // Cambiar al estado de espera
        END_IF
    // Estado de bajar
    20:
        bOutputDown := TRUE; // Activar la salida de bajar
        Temporizador(IN:= TRUE); // Iniciar temporizador de 60 segundos
        IF Temporizador.Q THEN
            EstadoMaquinaActual := 30; // Cambiar al estado de espera
        END_IF
    // Estado de espera
    30:
	TemporizadorEspera(IN:= TRUE);
        IF TemporizadorEspera.Q THEN
            // Reiniciar salidas y temporizadores
            bOutputUp := FALSE;
            bOutputDown := FALSE;
            Temporizador(IN:= FALSE);
            TemporizadorEspera(IN:= FALSE);
            // Volver al estado inicial
            EstadoMaquinaActual := 0;
        END_IF
END_CASE

Sin estados

Este es el código de la tarea:

FUNCTION_BLOCK FB_Wait_andWrite_NON_State
VAR_INPUT
	bInputUp : BOOL; // Entrada para subir
    bInputDown : BOOL; // Entrada para bajar
END_VAR
VAR_OUTPUT
	bOutputUp : BOOL := FALSE; // Salida para subir
    bOutputDown : BOOL := FALSE; // Salida para bajar
END_VAR
VAR
    Temporizador : TOF := (PT:= T#60S); // Temporizador de 60 segundos
    TemporizadorEspera : TON := (PT:= T#1s); // Temporizador de espera de 1 segundo
	
	bBajando: BOOL;
	bSubiendo: BOOL;
END_VAR

El código para la function block

Temporizador(IN:= bSubiendo OR bBajando); // Iniciar temporizador si se está subiendo o bajando

bSubiendo := bInputUp AND NOT bSubiendo; // Marcar subida si no estaba subiendo antes
bBajando := bInputDown AND NOT bBajando; // Marcar bajada si no estaba bajando antes

bOutputUp := bSubiendo AND NOT Temporizador.Q; // Activar salida de subir mientras no se exceda el temporizador
bOutputDown := bBajando AND NOT Temporizador.Q; // Activar salida de bajar mientras no se exceda el temporizador

IF Temporizador.Q THEN
    bSubiendo := FALSE; // Reiniciar flag de subir
    bBajando := FALSE; // Reiniciar flag de bajar
    TemporizadorEspera(IN:= TRUE); // Iniciar temporizador de espera de 1 segundo
END_IF

TemporizadorEspera(IN:= TemporizadorEspera.Q); // Reiniciar temporizador de espera si se completó

Conclusión

Como supuse es un aumento de rendimiento considerable (el software sin máquina de estados consume 3 veces más). Adjunto las fotos de los FB, el programa y las gráficas de los rendimientos.

¿Y ustedes? ¿Lo sabían ya? ¿Se imaginaban el resultado como yo? ¿Creéis que algo ha fallado en mi evaluación?

Yo la verdad es que me ha sorprendido los resultados, no me esperaba tanto y menos para una aplicación tan sencilla, son unos temporizadores y unos IF

Espero sus comentarios, chicos.

La entrada Como optimizar tu código en SCL se publicó primero en Brandon Engineer.

SCL VS KOP ¿Cuál tiene mayor rendimiento?

Brandon — Tue, 19 Mar 2024 21:30:22 +0000

Introduction

Esta tarde estaba aburrido en casa y puse a prueba una idea que lleva tiempo rondándome la cabeza: “¿El mismo código tiene mejor rendimiento en KOP o en SCL?” Al final, KOP tiene equivalente en todas sus funciones en SCL y quería poner a prueba si las funciones consumen los mismos recursos en SCL que en KOP. Yo, la verdad, es que imaginaba que eran iguales, pero como dice un compañero de trabajo a quien aprecio mucho, “los imagino, los espero y supongo son un cuchillo envenenado”, así que me arremangué las mangas de la camiseta y decidí hacer un pequeño temporizador tonto que no hace nada, pero la idea es que active una salida continuamente cada 1 segundo y comprobar si consume recursos.

¿Cómo se ha realizado?

Para esta prueba decidí ejecutarla en el entorno de Twincat de Beckhoff Automation, que me da control del conocimiento de cada núcleo y compararlo en el mismo instante de tiempo. Preparé los FB, al final llamé a 21 FB por cada una de las tareas con un tiempo de ejecución de 0.05ms y comparé los rendimientos.

SCL

El código para la function block

FUNCTION_BLOCK FB_WaitAndWriteSCL
VAR_INPUT
END_VAR
VAR_OUTPUT
	bStart: BOOL;
END_VAR
VAR

	temp1: TOF;
	temp2: TON;
END_VAR


	temp1(IN:= temp2.Q, PT:= T#1S,);
	
	temp2(IN:= NOT temp1.Q, PT:= T#1S,Q=>bStart);

El código usado para el programa ha sido:

PROGRAM MainSCL
VAR
	fbwait0 : FB_WaitAndWriteSCL;
	fbwait1 : FB_WaitAndWriteSCL;
	fbwait2 : FB_WaitAndWriteSCL;
	fbwait3 : FB_WaitAndWriteSCL;
	fbwait4 : FB_WaitAndWriteSCL;
	fbwait5 : FB_WaitAndWriteSCL;
	fbwait6 : FB_WaitAndWriteSCL;
	fbwait7 : FB_WaitAndWriteSCL;
	fbwait8 : FB_WaitAndWriteSCL;
	fbwait9 : FB_WaitAndWriteSCL;
	fbwait10 : FB_WaitAndWriteSCL;
	fbwait11 : FB_WaitAndWriteSCL;
	fbwait12 : FB_WaitAndWriteSCL;
	fbwait13 : FB_WaitAndWriteSCL;
	fbwait14 : FB_WaitAndWriteSCL;
	fbwait15 : FB_WaitAndWriteSCL;
	fbwait16 : FB_WaitAndWriteSCL;
	fbwait17 : FB_WaitAndWriteSCL;
	fbwait18 : FB_WaitAndWriteSCL;
	fbwait19 : FB_WaitAndWriteSCL;
	fbwait20 : FB_WaitAndWriteSCL;
	bStart: BOOL;
END_VAR


	fbwait0();
	fbwait1();
	fbwait2();
	fbwait3();
	fbwait4();
	fbwait5();
	fbwait6();
	fbwait7();
	fbwait8();
	fbwait9();
	fbwait10();
	fbwait11();
	fbwait12();
	fbwait13();
	fbwait14();
	fbwait15();
	fbwait16();
	fbwait17();
	fbwait18();
	fbwait19();
	fbwait20();

KOP

Este es el código de la tarea:

El código para la function block

Conclusión

Y para sorpresa de nadie, funcionan exactamente igual en rendimiento.

Por otro lado, esta es una prueba. Pronto haré lo mismo para poner a prueba una FB hecha con una máquina de estados contra un software que se ejecute todas las líneas y comprobaré los resultados de los rendimientos. Aquí sí que espero una mejora de rendimiento, ya que al saltarse una gran parte del código, podré obtener rendimientos mucho más altos.

¿Y ustedes? ¿Lo sabían ya? ¿Se imaginaban el resultado como yo?¿Creéis que algo ha fallado en mi evaluación?

Espero sus comentarios, chicos.

La entrada SCL VS KOP ¿Cuál tiene mayor rendimiento? se publicó primero en Brandon Engineer.

Crear interlocks de temporizador

Brandon — Wed, 13 Mar 2024 21:22:24 +0000

Introduction

Hoy trabajando un compañero de trabajo me enseño una forma de crear interlocks para evitar que se activen 2 salidas al mismo tiempo.

El problema que estábamos viendo era activar un motor que tiene 2 sentidos de giro y a demás de la parada queríamos dar un pequeño retardo de activación hasta encender el motor en sentido contrario.

¿Para que sirve los interlocks?

Los interlocks nos permiten hacer una activación segura tanto para las maquinas como para las personas asegurándonos que no haya ningún disgusto ni económico ni humanitario

¿Cómo crear los interlocks?

Para empezar quería agradecer a Jose Juan esta enseñanza y querría compartir con vosotros 2 formas de hacerlo, por un lado la de Jose Juan programado con KOP y la mía hecha con una maquina de estados en SCL.

La verdad es que me ha parecido muy intuitiva la forma de programarlo mi compañero y que queda muy elegante

KOP

Para empezar aprovecharemos el uso de la evaluación de flancos descendentes y activaremos un retardo de activación

SCL

Yo para hacerlo en SCL aunque puedo hacerlo como en KOP yo optaba por un funcionamiento con una maquina de estados, no tengo tanta experiencia como mi compañero Jose Juan y decidí hacer una maquina de estados muy sencillita que permite un entendimiento relativamente intuitivo

1.Diagrama máquina de estados

Para la ejecución he usado este codigo


FUNCTION_BLOCK Interlocks
VAR_INPUT
	bStartFirst: BOOL;
	bStartSecond: BOOL;
END_VAR
VAR_OUTPUT
	bFirstActivation: BOOL;
	bSecondActivation: BOOL;
END_VAR
VAR
	state: INT;
	TON: Tc2_Standard.TON;

	IDDLE: INT := 0;
	FIRST: INT := 10;
	SECOND: INT := 20;
	WAITING: INT := 30;
END_VAR


CASE state OF
	
	IDDLE:		//IDLE STATE WAITING FOR OPERATION
	
	IF bStartFirst THEN
		state:=FIRST;
		
	END_IF;
	IF bStartSecond THEN
		state:=SECOND;

	END_IF;
	
	FIRST:		//ACTIVATION OF FIRST OUTPUT
	
	bSecondActivation:=FALSE; //SECURE DISABLE OUTPUT	
	IF bStartFirst THEN
		bFirstActivation:=TRUE;
	ELSE
		state:=30;
	END_IF;
	
	SECOND:		//ACTIVATION OF SECOND OUTPUT
	
	bFirstActivation:=FALSE; //SECURE DISABLE OUTPUT
	IF bStartSecond THEN
		bSecondActivation:=TRUE;
	ELSE
		state:=WAITING;
	END_IF;	
	
	WAITING:		// WAITING FOR SECURITY
	
	TON(IN:=TRUE,PT:=T#1S,Q=>,ET=>);
	IF TON.Q THEN
		TON(IN:=FALSE);
		state:=IDDLE;
	END_IF
	
	
END_CASE;

La entrada Crear interlocks de temporizador se publicó primero en Brandon Engineer.