Revolution Pi es un PC industrial abierto, modular y duradero basado en el Raspberry Pi establecido, cumpliendo con la norma EN61131-2. Equipado con el Módulo de Cálculo Raspberry Pi, la RevPi Core base se puede expandir sin problemas utilizando módulos de E/S apropiados y gateways de bus de campo para la gestión de energía, monitoreo de procesos, salud de máquinas y más.
El Rev Pi Core es la base para cualquier aplicación y, dependiendo de sus requisitos de E/S, se pueden adjuntar módulos de expansión como RevPi DIO, RevPi AIO, RevPi Gates como módulos digitales, analógicos o de gateway.
En este tutorial, detallaremos la integración de un RevPI DIO para visualizar y controlar señales de salida a sus máquinas o aplicaciones con Ubidots. El módulo de E/S digital RevPi DIO viene con 14 entradas digitales y 14 salidas, PWM (modulación por ancho de pulso) y entradas de contador. Para una lista más detallada de las funcionalidades del RevPI DIO, consulte el folleto del producto de Revolution Pi.
Requisitos
Cable Ethernet
Fuente de alimentación de 24 V
1. Configuración de hardware
Como en cualquier configuración de un nuevo dispositivo, recomendamos familiarizarse con la guía de inicio rápido oficial de RevPi Core + RevPi DIO de Revolution Pi. Luego asegúrese de poder ensamblar correctamente el RevPi Core + DIO haciendo referencia a los artículos a continuación para obtener detalles adicionales, según sea necesario.
Una vez que su RevPi Core + RevPi DIO estén ensamblados, alimentados correctamente y conectados a Internet, podemos continuar con el firmware necesario para comunicarse con Ubidots.
2. Configuración del sistema
1. Primero debemos tener acceso a las entradas y salidas del Revolution Pi. El módulo "python3-revpimodio” proporciona todo el acceso a las E/S de los Revolution Pis y se puede programar muy fácilmente con Python3.
Basado en la imagen instalada en su RevPi Core, consulte esta guía para realizar la instalación correctamente. Si tiene la imagen Jessie en su core, simplemente instale el módulo desde el repositorio de Kunbus ejecutando los comandos a continuación en el terminal de RevPi:
NOTA: Para poder ejecutar los comandos a continuación, debe acceder al RevPi. Si aún no sabe cómo acceder al terminal del RevPi, consulte esta guía.
Actualizar paquetes del sistema:
sudo apt-get update
Instalar:
sudo apt-get install python3-revpimodio2
Actualizar distribución (todo):
sudo apt-get dist-upgrade
2. A continuación, instale el módulo requests para python3 ejecutando el comando a continuación en el terminal de RevPi:
sudo apt-get install python3-requests
3. Una vez que cada uno de los comandos anteriores haya terminado, verifique que todo sea correcto abriendo Python3 en su terminal de RevPi e importando el módulo previamente instalado.
Abra el Python3 ejecutando el comando a continuación en el terminal de RevPi:
python3
Una vez que tenga acceso a Python3, importe los módulos ''revpimodio2" y "requests" como se muestra a continuación:
import revpimodio2 import requests
Si recibe mensajes de error después de importar el módulo, verifique el problema mostrado y vuelva a intentarlo.
3. Configuración de PiCtory
PiCtory le permite vincular varios módulos RevPi, junto con el PiBridge que vincula físicamente los módulos entre sí, creando un archivo de configuración. El archivo debe informar a su RevPi Core qué módulos se encuentran en qué posición y cuáles son la configuración básica de los módulos. Para tener una mejor idea de cómo funciona esto, consulte el video a continuación:
1. Abra su navegador web e ingrese la dirección IP de sus RevPi Cores en la barra de direcciones de su navegador. Luego, verá las ventanas de inicio de sesión; para ingresar, asigne el nombre de usuario y la contraseña donde se indica. Las credenciales de inicio de sesión se pueden encontrar en el costado de su RevPi.
nombre de usuario: admin
contraseña: La encontrará en la etiqueta en el costado de su RevPi Core.
Ingrese a la sección "APPS":
2. Para comenzar con la configuración de PiCtory, presione el botón verde llamado "START".
3. Desde el catálogo de dispositivos, seleccione la versión de su RevPi Core y asígnela a las placas de configuración. Luego, asigne el RevPi DIO a la derecha del RevPi Core. Recuerde conectar el RevPi Core a la derecha de su RevPi Core utilizando el PiBridge.
NOTA IMPORTANTE: La posición de los módulos asignados en la configuración de PiCtory debe ser la misma que la asignada en el mundo físico para poder generar el archivo de configuración correctamente.
3. Ahora que tiene los módulos necesarios asignados en las placas de configuración, verifiquemos el nombre de los pines que vamos a usar a continuación. Encontrará dos códigos de muestra proporcionados, uno es para enviar un valor desde una entrada de lectura del RevPi DIO, y el otro para controlar una salida del RevPi DIO.
La entrada que vamos a usar es la Entrada 1, vea a continuación el diagrama de pines:
Desde la sección Editor de Valores, verifique si el nombre asignado para la Entrada 1 es "I_1" como se muestra en la imagen a continuación; si no, ajuste el nombre INP para que sea "l_1". NOTA IMPORTANTE: Si omite este paso, el código del firmware no podrá leer este pin.
La salida que vamos a usar es la Salida 1, vea a continuación el diagrama de pines:
Desde la sección Editor de Valores, verifique que el nombre asignado a Salida 1 sea "O_1" como se muestra en la imagen a continuación; si no, ajuste el nombre INP para que sea "O_1". NOTA IMPORTANTE: Si omite este paso, el código del firmware no podrá leer este pin.
4. Enviando (POST) datos a Ubidots
1. Para comenzar a escribir su firmware, cree un script de Python en el terminal de RevPi. Vamos a usar el editor nano para crear el nuevo script. Para hacer esto, ejecute el comando a continuación en el terminal de RevPi.
nano ubidots_revpi.py
Como verá, el terminal del editor nano se llenará automáticamente y podrá comenzar su código.
2. Copie y pegue el código de muestra a continuación en el editor nano. Una vez pegado, asigne su Token de Ubidots donde se indica en el script. Consulte aquí para obtener ayuda para localizar su token de Ubidots, si es necesario.
En este código de muestra, vamos a leer la Entrada 1 (I_1) del módulo RevPi DIO para enviar su estado a Ubidots.
NOTA: Para guardar el script en el editor nano, presione Ctrl+O, confirme el nombre del archivo a escribir (ubidots_revpi_di.py) y presione enter. Para cerrar el editor nano, presione Ctrl+X.
################################################################################# Este script envía el estado de la Entrada Digital (DI) de un pin del módulo de# expansión Revpi DIO a la Nube de Ubidots (https://ubidots.com/)## Autores: M. Hernandez################################################################################import requestsimport timeimport revpimodio2from uuid import getnode as get_macTOKEN = "A1E-dfBFE58BECK3YgAia1Sss2H9WTvW4I" # Asigne su TOKEN de UbidotsVARIABLE = "motion-detector" # Asigne la etiqueta de la Variable de UbidotsDELAY = 2 # Establezca el retraso deseado para publicar los datosrevpi = revpimodio2.RevPiModIO(autorefresh=True) # Instancia para acceder a las E/S del RevPis = requests.Session()s.headers.update({'x-test': 'true'})'''Este método construye el JSON que se enviará a la Nube de Ubidots'''def build_json(variable, value): try: # Esta estructura envía un valor a la Nube de Ubidots. Consulte la # Referencia de la API REST de Ubidots (https://ubidots.com/docs/api/) para aprender cómo # enviar más de un valor data = {variable: value} return data except: return None'''Este método realiza la solicitud HTTP a la Nube de Ubidots'''def post_variable(device, variable, value): try: # Referencia a la Referencia de la API REST de Ubidots (https://ubidots.com/docs/api/) # para aprender cómo construir la solicitud HTTP al servidor de Ubidots url = "https://industrial.api.ubidots.com/api/v1.6/devices/" + device headers = {"X-Auth-Token": TOKEN, "Content-Type": "application/json"} data = build_json(variable, value) response = s.post(url=url, headers=headers, json=data) return response.json() except: passif __name__ == "__main__": while True: mac = get_mac() # obtener la dirección mac de su dispositivo device_mac = ':'.join(("%012X" % mac)[i:i+2] for i in range(0, 12, 2)) # Leer el estado de la Entrada llamada 'I_1' sensor_status = float(revpi.io.I_1.value) # Enviar la solicitud POST al servidor de Ubidots print("Publicando valores en Ubidots") request = post_variable(device_mac, VARIABLE, sensor_status) print(request) time.sleep(DELAY)3. Ahora probemos el script. Ejecute el script creado previamente en el terminal de RevPi ejecutando el siguiente código:
python3 ubidots_revpi_di.py
Una vez que el script comience a ejecutarse, verá la respuesta de estado exitosa del servidor de Ubidots 201 :
4. Vaya a su cuenta de Ubidots y verifique que los datos se hayan recibido. Verá un nuevo dispositivo creado automáticamente en la sección de Dispositivos con el nombre del dispositivo siendo la dirección MAC de su RevPi Core.
¿No le gusta la dirección MAC como el nombre de su dispositivo en la visualización de Ubidots? No se preocupe; puede cambiar el nombre a uno más amigable, pero la etiqueta del dispositivo permanecerá como la dirección MAC para nunca confundirse qué dispositivo es cuál. Consulte el Centro de Ayuda de Ubidots para más información sobre los Etiquetas de Dispositivos y Cambios de Nombre de Dispositivo en Ubidots.
Haga clic en cualquier dispositivo en su sección de Dispositivos para visualizar la variable que se está registrando y enviando a Ubidots desde nuestro firmware de muestra. Como puede ver, nuestro código de muestra ha proporcionado una variable de detector de movimiento:
5. Desarrollo de Aplicaciones de Contador de Unidades
Ahora que el estado de su Entrada se está actualizando en su cuenta de Ubidots. Comencemos a jugar con las características de Ubidots para diseñar y desplegar su aplicación. En este tutorial, desplegaremos un Contador de Unidades para cajas que se mueven a través de una línea de suministro.
Al principio, vamos a crear una Variable Sintética, una herramienta de cálculo matemático compleja. Gracias a este Motor de Análisis de Ubidots, podrá calcular el promedio, máximo, mínimo, suma y conteo de otras variables; en este caso, la variable creada previamente (detector de movimiento). Para esta guía, vamos a calcular una suma de la variable detector de movimiento cada minuto para saber cuántas cajas fueron detectadas a medida que pasan por la línea de suministro.
Para crear la variable, presione "Agregar Variable". Luego, seleccione "Sintética":
En la ventana siguiente, debe asignar la siguiente expresión:
sum(x, data_range)
Donde:
x es la variable que se desea calcular
data_range es el intervalo de tiempo deseado para calcular los valores de la variable asignada como x
Para una explicación detallada de las Variables Sintéticas, consulte esta guía.
Después de asignar la expresión, debería tener algo similar a:
Para guardar los cambios, presione "Aceptar". Luego, asigne el nombre de la nueva variable; en este caso, nombramos la nuestra "cajas".
Resultado después de calcular la suma:
Ahora que sabemos cuántas cajas nuestro sensor está detectando, podemos crear un evento basado en la variable "cajas" para mantener el ritmo con la producción y ser alertados si la producción se retrasa.
Nuestro objetivo de producción es de 10 "cajas" por minuto. Para mantener este objetivo, el RevPi necesitará detectar un mínimo de 10 cajas por minuto. Para ser alertados sobre la caída de la producción, simplemente crearemos una alerta que nos avise cuando se detecten menos de 10 cajas.
Vaya a la sección de Eventos de su cuenta de Ubidots presionando Gestión de Dispositivos > Eventos > Agregar Evento (icono azul más).
Luego, asigne las siguientes configuraciones al evento y presione el icono azul correcto para continuar:
Primer campo: Variable Sintética creada - Cajas
Segundo campo: Valor
Tercer campo: Menos que
Cuarto campo: 10
Quinto campo: 0
Después de asignar los parámetros, debería tener algo como:
Ahora necesita asignar la acción deseada para este evento. Para continuar, presione el icono naranja más y elija la acción deseada:
Configuré el evento con una acción de correo electrónico. Y como puede ver a continuación, cuando se activa el evento, recibo el siguiente mensaje:
NOTA IMPORTANTE: El código proporcionado anteriormente solo está leyendo la entrada 1 sin establecer ninguna configuración de sensor. Según los sensores utilizados, agregue la configuración del sensor en el código según sea necesario.
6. Recibiendo (GET) datos de Ubidots
En esta aplicación de muestra, vamos a controlar una salida del módulo RevPi DIO para poder encender/apagar una luz desde la nube de Ubidots.
1. Para poder controlar una salida desde una variable de Ubidots, primero debe crear la variable. Ingrese a su dispositivo RevPi y cree una nueva variable seleccionando "Agregar Variable" y presione "Crudo":
Luego, asígnele el nombre "luz". Una vez que el dispositivo esté creado correctamente, la visualización de su dispositivo se verá algo así:
2. Vaya a su Tablero principal de Ubidots y cree un widget de control. Haga clic en el icono amarillo más(+) y siga las opciones en pantalla para desplegar nuevos widgets en el tablero. Seleccione Control –> Interruptor –> RevPICore(MACAddress) –> luz (variable recién creada) > Finalizar.
Después de construir su nuevo widget, el Tablero se recargará y se poblará con su nuevo widget de control de luz.
Este widget de "control" enviará su estado a la salida RevPi DIO para controlar el estado de una luz o cualquier otro dispositivo conectado a la Salida 1.
Para implementar esta capacidad de control, procederemos a actualizar nuestro firmware.
3. Cree un nuevo script de python usando el editor nano. Para hacer esto, ejecute el comando a continuación en el terminal de RevPi:
nano ubidots_revpi_do.py
Como verá, el terminal del editor nano se llenará automáticamente y podrá comenzar su código.
4. Por favor, copie y pegue el código de muestra a continuación en el editor nano. Una vez pegado, asigne su Token de Ubidots donde se indica en el script. Consulte aquí para obtener ayuda para localizar su token de Ubidots.
En este código de muestra, vamos a controlar una salida del módulo RevPi DIO para poder encender/apagar una luz desde el tablero de Ubidots.
NOTA: Para guardar el script en el editor nano, presione Ctrl+O, confirme el nombre del archivo a escribir (ubidots_revpi_di.py) y presione enter. Para cerrar el editor nano, presione Ctrl+X.
################################################################################# Este script controla el estado de una Salida (DO) de un pin del módulo de# expansión Revpi DIO desde la Nube de Ubidots (https://ubidots.com/)## Autores: M. Hernandez################################################################################import requestsimport timeimport revpimodio2from uuid import getnode as get_macTOKEN = "A1E-dfBFE58BECK3YgAia1Sss2H9WTvW4I" # Asigne su TOKEN de UbidotsVARIABLE = "light" # Asigne la etiqueta de la Variable de Ubidots a controlarDELAY = 5 # Establezca el retraso deseado para publicar los datosrevpi = revpimodio2.RevPiModIO(autorefresh=True) # Instancia para acceder a las E/S del RevPis = requests.Session()s.headers.update({'x-test': 'true'})'''Este método realiza la solicitud HTTP a la Nube de Ubidots'''def get_lastvalue(device_label, variable_label): try: # Referencia a la Referencia de la API REST de Ubidots (https://ubidots.com/docs/api/) # para aprender cómo construir la solicitud HTTP al servidor de Ubidots url = "https://industrial.api.ubidots.com/api/v1.6/devices/" + device_label + "/" + variable_label + "/lv" headers = {"X-Auth-Token": TOKEN} response = s.get(url=url, headers=headers) return response.json() except: passif __name__ == "__main__": while True: mac = get_mac() # obtener la dirección mac de su dispositivo device_mac = ':'.join(("%012X" % mac)[i:i+2] for i in range(0, 12, 2)) # Enviar la solicitud GET al servidor de Ubidots print("Obteniendo valores de Ubidots") light_status = get_lastvalue(device_mac, VARIABLE) if light_status == 1.00: revpi.io.O_1.value = True print("Luz ENCENDIDA") else: revpi.io.O_1.value = False print("Luz APAGADA") time.sleep(DELAY)5. Ahora probemos el script. Ejecute el script creado previamente en el terminal de RevPi:
python3 ubidots_revpi_do.py
Una vez que el script comience a ejecutarse, verá el mensaje de estado de la luz:
6. Ahora cambie el estado del widget de "Control" desde su Tablero de Ubidots y visualice el estado de la salida RevPI DIO.
7. Resumen
En solo unos minutos, ha integrado el RevPi Core + RevPi DIO con Ubidots, recibido datos de su línea de suministro para el conteo de unidades, construido una aplicación para rastrear y alertarle sobre los requisitos de producción, y controlar las luces de su planta - todo utilizando el RevPi Core + DIO con Ubidots. Para aprender más o desplegar nuevas soluciones industriales para monitoreo o gestión, consulte la línea completa de módulos de expansión RevPi.
Ahora es el momento de crear Tableros de Ubidots para visualizar y comprender sus datos para tomar las mejores decisiones, de manera simple y coherente.
Otros lectores también han encontrado útil...