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.

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.

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

<Declaration>
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
</Declaration>
<Implementation>
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;
</Implementation>

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