En esta entrada te voy a enseñar cómo puedes crear un telerruptor usando la O exclusiva en Step 7.

Como recordarás (sino te lo recuedo yo) la O exclusiva lo que hace es una combinatoria binaria de tal forma que el resultado es TRUE cuando los bits intervinientes tienen valor diferente entre sí y un FALSE si son iguales.

O exclusiva en Step 7: ejemplo de un telerruptor

Normalmente en los programas que he visto por ahí para realizar un telerruptor o balanza se suelen usar Set y Reset.

Recordemos que una balanza o telerruptor lo que hace es que alterna el valor de una salida digital cada vez que una entrada se pone a TRUE.

De esta forma, cuando por primera vez pones la entrada a 1, la salida se pone a 1 también.

La entrada vuelve a cero, y la salida sigue estando a 1.

Ahora, si vuelves a poner la entrada a 1, la salida que estaba a uno, cambia poniéndose a cero.

Volviendo a poner la entrada a 1, la salida se pondría a 1, y así sucesivamente.

¿Cómo vamos a usar la O exclusiva en Step 7?

La gracia de este ejemplo, es dar un uso a la O exclusiva ya que como digo, se puede hacer con Set y Reset.

Ya vimos en otro ejemplo cómo crear un telerruptor con Set y Reset cuando hablábamos de la lógica boolena.

Pero así aprendemos otra forma de hacerlo, y ya de paso, practicamos algo de AWL.

La idea es que podamos reutilizar el código de este telerruptor, por lo que vamos a usar, esta vez, un FC al que le suministraremos 3 señales:

• Señal de entrada del telerruptor (M100.0)
• Salida de la balanza o telerruptor (M200.0)
• Marca auxiliar (M50.0)

El FC tendría una pinta como esta:

Y el interior del FC que le he llamado «Balanza» sería este:

Explicación del código

Te cuento lo que he hecho.

La idea es leer la señal de entrada y con ella, alternar el valor de la balanza.

Como solo queremos que se ejecute una vez, nos vamos a apoyar en una marca usando un pulso y un salto.

De tal forma, que cuando la señal de entrada pase de 0 a 1, se ejecutará el código que queremos, y cuando bien siga pulsado a 1, o se ponga a cero, no se ejecute:

 U     #Sennal        // Leemos la señal de entrad del telerruptor
 FP    #Auxiliar      // Generamos un pulso para que solo se ejecute una vez
 SPBN  EXIT     

Dentro de la parte que si queremos que se ejecute, tenemos lo siguiente:

 SET                 // Ponemos una variable temporal a 1
=     #temporal
X     #temporal      // Realizamos la O exclusiva entre esta variable temporal
X     #Balanza       // Y nuestra señal de balanza o telerruptor
=     #Balanza        

Lo que hacemos en este caso, es apoyarnos en una variable temporal para realizar la O exclusiva con la señal de la balanza, de tal forma, que como siempre realizamos una O exclusiva con una señal que está a uno, lo que hará es cambiar de valor de forma alterna en función de lo que ella misma tenga de valor.

Recuerda que la tabla de la verdad de la O exclusiva es la siguiente:

Al final del programa tenemos:

SET   
SAVE                 // Ponemos el ENO a 1 para que se propague si fuera necesario

Para lo que lo pongo es para que el ENO siempre este a a uno.

¿Pero no se puede hacer más fácil aún?

Espero que te hayas dado cuenta, que lo de realizar la O exclusiva en Step 7 para realizar una balanza se puede simplificar aún más.

Si tenemos en cuenta que hacemos una O exclusiva con un valor que siempre está a uno… ¿no es lo mismo que dar la vuelta a la propia señal?

Bingo.

Es que realmente es lo que queremos ¿no?

Pues sí, se puede simplificar aún mucho más, simplemente negando la señal de balanza e igualando:

¿Ves lo que te digo?

Realmente con hacer lo siguiente sería suficiente:

UN    #Balanza         // Negamos nuestra señal de balanza o telerruptor
=     #Balanza         // Obteniendo el nuevo valor de la salida

Vale.
Te he troleado un poco con lo de la O exclusiva en Step 7 jeje.
Pero ahora, ya sabes cómo usarla, y dos formas de hacer lo mismo… ¿o no?

Telerruptor sin usar AWL

Como decía Súper Ratón: ¡no se vayan todavía! , ¡aún hay más!

Para los que no están muy duchos en AWL, te propongo otra alternativa muy muy sencilla basada en negar la entrada, haciendo un FC muy sencillo que tenga simplemente este código:

Tela de complicado ¿eh?

Vale. Pues este código irá asociado con la llamada:

Funciona exactamente igual que el que he realizado en AWL.

La diferencia es que el pulso lo he realizado en el exterior (por variar) y no usar ni siquiera los saltos.

Lógicamente podrías colocar todo este código en el interior del FC2 haciendo algo parecido al realizado en AWL pero en ladder.

Pero la idea de este ejemplo, era realizarlo lo más sencillo posible usando las instrucciones más básicas posibles.

Espero tus comentarios

Como siempre, espero que te haya gustado y que te sea útil.

Si se te ocurre otra forma de realizarlo,  ¡ya sabes!

Por supuesto, este ejemplo irá incluido en la próxima edición de Cómo programar Step 7 y no morir en el intento que espero actualizarlo a lo largo de este año.