Cómo programar en Python las entradas de interrupción del PLC industrial Raspberry

Introducción

Python es un lenguaje de programación de alto nivel que te permite hacer cosas complejas con pocas líneas de código. Un ejemplo de esto es el propósito de este tutorial. Por lo tanto, en este post vamos a ver un ejemplo de como programar las entradas de interrupción del Raspberry PLC con Python.  
 

Requisitos

Los puntos clave que debes tener en cuenta son los siguientes: 

• Familia PLC Raspberry

• Acceso al PLC: shh.  Puedes encontrar nn tutorial sobre cómo acceder al dispositivo a través de Linux o Windows en la Guía del usuario del PLC Raspberry.

• Python instalado

Enlaces relacionados

Conceptos básicos sobre salidas digitales del PLC industrial Raspberry
Leer >>

Cómo encontrar tu PLC industrial ideal
Leer >>

Interrupción externa mediante un sensor de etiquetas capacitivo con un PLC industrial basado en Arduino

Leer >>

Productos dela familia PLC Raspberry
Leer >>

Ejemplo de código

Para este ejemplo, necesitas importar las librerías que puedes ver al principio del código, teniendo en cuenta que "signal", "sys" y "RPi.gpio" son imprescindibles para trabajar con entradas de interrupción en Python con un PLC Raspberry. El INT_GPIO debe ser el GPIO de la Raspberry que vas a configurar como entrada de interrupción, en este caso el 13, que es el INT. Si no conoces el mapeo entre los GPIOs de la Raspberry y las E/S de tu PLC, puedes echar un vistazo a estas tablas, incluidas también en el Ficha técnica y la Guía de Usuario. 

Para continuar con la explicación, debes saber que una señal es una interrupción de software entregada a un proceso. El sistema operativo utiliza las señales para informar de situaciones excepcionales a un programa en ejecución. 

La primera función es signal_handler, una función que tiene que ser llamada si se anticipa un evento que desencadena una señal, y se le puede decir al sistema operativo que la ejecute cuando llegue ese tipo de señal en particular.  En este caso, este handler hace un GPIO.cleanup() y un sys.exit(0) cuando detecta un CTRL+C (comando que envía un SIGINT). 

La segunda función se llama int_activated_callback y, dentro de ella, puedes poner el código que quieres que se ejecute cuando se active la interrupción..

Finally, in the main, there is the GPIO.setmode, configuring it following the GPIOs disposition of the BCM, the GPIO.setup, configuring the GPIO pin to be an input, and GPIO.add_event_detect, that enables an interrupt that calls the "callback" function when the activation edge is FALLING, considering a bouncing time  of 1 second (which is the period that no interrupt is going to be activated to avoid signal bouncing). The signal.signal is the function to activate the signal_handler, previously explained. The last infinite loop is simply to test that you can be executing other processes in your code meanwhile the interruption is ready to be activated. 

Así, si ejecutas este código, realizará impresiones de "Trabajo" indefinidas hasta que se active la interrupción. Cuando detecte un flanco descendente en la señal, las impresiones anteriores se detendrán, la interrupción se activará y verás la impresión "INT activada" una vez, luego las impresiones de "Trabajo" continuarán hasta que se active otra interrupción (siempre respetando el tiempo de "bounce" de 1000 ms).

/*
   Copyright (c) 2019 Boot&Work Corp., S.L. All rights reserved

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
import signal
import sys
import time 

import RPi.GPIO as GPIO

INT_GPIO = 13

def signal_handler(sif, frame):
    GPIO.cleanup()
    sys.exit(0)

def int_activated_callback(channel):
    print("INT activated")

if __name__ == '__main__':
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(INT_GPIO, GPIO.IN)
    GPIO.add_event_detect(INT_GPIO, GPIO.FALLING, callback=int_activated_callback,bouncetime=1000)
    signal.signal(signal.SIGINT, signal_handler)
    while 1:
        print ("Work")
        time.sleep(0.1)

La interrupción tiene que ser provocada por una activación de la señal de entrada, ya sea por un flanco ascendente o un flanco descendente. Para probarlo, puedes conectar el GND del sensor al GND optoaislado de la entrada que vas a utilizar ((-)IX.5) y la salida del sensor a la señal de entrada de interrupción(IX.5/INT). Cuando el sensor digital se active, verás la activación de la interrupción también.  Aquí tienes un ejemplo de una de las entradas de interrupción del PLC, con el pin GND y el pin SIGNAL::