Blog de Amazon Web Services (AWS)

IoT para la industria 4.0: AWS IoT SiteWise

Por Jorge Alfaro, Arquitecto de Soluciones en Amazon Web Services México.

La industria de manufactura ha tenido una serie de evoluciones desde la introducción de la máquina de vapor entre 1760 y 1840, posteriormente la segunda revolución industrial se da con la producción en serie, el ferrocarril y la electricidad en los años de 1870 y 1914. Para mediados del siglo XX se da un nuevo cambio con la Revolución Digital introduciendo el uso de los sistemas de computo y las telecomunicaciones globales.

El termino Revolución 4.0 se menciona por primera vez en Alemania durante la feria de Hannover en 2011. Y se presenta una nueva promesa: combinar técnicas avanzadas de producción y operaciones con tecnologías como inteligencia artificial, robótica o Internet de las cosas (IoT).

Uno de los retos más difíciles para las organizaciones es identificar la tecnología correcta que por un lado les proporcione más valor agregado y a la vez que sea de rápida adopción. De no hacerlo corren el riesgo de perder oportunidades de eficiencias muy importantes, mejorar la calidad de sus productos o incluso perder mercado contra sus competidores que sí realicen estos cambios..

Otro de los retos importantes es cómo dar los primeros pasos hacia la adopción de Internet de las Cosas en entornos de producción. Un caso de uso que vemos frecuentemente en la Internet de las cosas Industrial, es acerca del mantenimiento preventivo de maquinaria industrial, donde se busca obtener información constantemente que permita planear y realizar mantenimientos predictivos de manera inteligente, y así evitar paros no planeados, mejorar los tiempos de producción, encontrar optimizaciones y por último generar reportes sobre las mejoras obtenidas al negocio casi en tiempo real.

Para lograr esto, AWS cuenta con AWS IoT SiteWise el cual es un servicio administrado que facilita las tareas de recopilación, almacenamiento, organización y monitoreo de los datos del equipo industrial a escala para ayudar a la toma de mejores decisiones en función de los datos. Puede usar AWS IoT SiteWise para controlar las operaciones en diferentes instalaciones, computar rápidamente las métricas industriales de rendimiento y crear aplicaciones que analizan los datos de equipos industriales a fin de evitar problemas costosos en equipamientos y reducir las brechas de producción. Esto permite la recopilación sistemática de datos en dispositivos, la identificación rápida de problemas con el monitoreo remoto y la mejora de los procesos en múltiples sitios con datos centralizados.

A continuación se explicará cómo es posible crear una solución de monitoreo de un motor utilizando sensores conectados a un microcontrolador ESP32 de Espressif el cual enviara mensajes a AWS IoT SiteWise. De esta manera se puede construir de manera muy rápida un piloto para comenzar a experimentar con tecnología de AWS en el mundo de IoTpara Industria 4.0.

Arquitectura a construir

Componentes que se requieren

  • Arduino IDE
  • Tarjeta de desarrollo ESP32, esta placa tiene la gran ventaja de soportar conexiones WiFi, Bluetooth y permite trabajar con varios sensores. La forma de programarla puede ser con FreeRTOS o bien con el IDE de Arduino, el cual usaremos en este blog post.
  • Acelerómetro ADXL345. Es un acelerómetro que permite detectar los movimientos en eje X, Y, Z. Este sensor se usa en algunos equipos especializados para medir vibraciones.
  • Sensor de vibración LM32. Es un sensor común con un rango de operación entre -55ºC y 150ºC. Para un primer experimento resulta adecuado pero se pueden usar sensores de mayor rango para ambientes productivos.
  • Una cuenta de AWS, para realizar este proyecto se usará el servicio AWS IoT SiteWise.

Guía de configuración de ESP32 con Arduino IDE

Para comenzar, en Arduino IDE ir a FILE > Preferences . En la ventana que se abre, ingresar el siguiente texto en Addditional Board Manager URLs : https://dl.espressif.com/dl/package_esp32_index.json

Y dar clic en OK. Luego, en el TOOLS > Board > Boards Manager… En la siguiente ventana escribir ESP32 en la opción de búsqueda y dar clic en Install en la opción de ESP32 by Espressif Systems.

Al final debe quedar de la siguiente forma:

El siguiente paso, es conectar el dispositivo ESP32 a la computadora y hacer que Arduino IDE pueda grabar el código en este.

A continuación se selecciona en el menu  Tools > Board y posteriormente seleccionar el tipo de ESP32 que se usará. Una opción que se puede usar ESP32 DEV Module.

Para realizar la conexión por puerto USB a COM dependiendo si se usa una MAC o Windows hay que seguir la guía de este link . Cuando ya se tenga configurado se puede seleccionar el puerto USB como puerto de comunicaciones: Tools > Port:  /dev/cu.SLAB_USBtoUART Si es una máquina Windows, seleccionar el puerto COM que se seleccionó en esta guía

En esta parte es importante mencionar que existen muchas versiones de este chip. Por eso existen muchas opciones con distinta cantidad de pins. Para este blog se usara este dispositivo:

Configuración del ESP32 con Arduino IDE

Es importante descargar las siguientes librerías, se pueden descargar los archivos ZIP y copiarlos en la carpeta de Arduino/libraries o bien con el Administrador de librerías en el IDE de Arduino.

MQTT Client

WiFiClientSecure

Adafruit_Sensor

Adafruit_ADXL345_U

Las conexiones de los sensores en el ESP32 serán las siguientes:

  • El sensor de temperatura LM32 puede estar conectado en alguno de los pines marcados como ADC pues enviará datos analógicos que necesitan ser transformados a lectura digital. En el caso del código y con la board que se tiene se usa el PIN  13
  • El acelerómetro ADXL345 se tiene que conectar en los PIN marcados como SCL y SDA que en este caso son los PIN 22 y 21.

Con esto ya se tiene el dispositivo ESP32 configurado y listo para funcionar. A continuación se abrirá un nuevo proyecto en el Arduino IDE para copiar el siguiente código:

#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>
#include "esp_adc_cal.h"
#include "conf.h"
#include <WiFiClientSecure.h>
#include <MQTTClient.h>

// Aqui definimos el topico de publicacion
#define AWS_IOT_PUBLISH_TOPIC   "sitewise/ingest"
#define AWS_IOT_SUBSCRIBE_TOPIC "sitewise/ingest"
#define PinTemp 13 // Pin del sensor de Temperatura / ADC
const char* ntpServer = "pool.ntp.org";

String payload;
float pay_x;
float pay_y;
float pay_z;
float pay_temp;
long tiempo;

float LM35_TempC_Sensor = 0.0;
float Voltage = 0.0;
int LM35_Raw_Sensor = 0;


int cont;

/*Initialize an instance of Adafruit_ADXL345_Unified with a unique id*/
Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345);

// Inicializamos cliente de MQTT
WiFiClientSecure net = WiFiClientSecure();
MQTTClient client = MQTTClient(256);

uint32_t readADC_Cal(int ADC_Raw)
{
  esp_adc_cal_characteristics_t adc_chars;
  esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 1100, &adc_chars);
  return(esp_adc_cal_raw_to_voltage(ADC_Raw, &adc_chars));
}

// Function that gets current epoch time
unsigned long getTime() {
  time_t now;
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    //Serial.println("Failed to obtain time");
    return(0);
  }
  time(&now);
  return now;
}
// Funcion para conexion a AWS IoT Core
void connectAWS()
{
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.println("Conectando a Wi-Fi");
  while (WiFi.status() != WL_CONNECTED){
    delay(500);
    Serial.print(".");
  }
  // Configurar WiFiClientSecure para usar las credenciales 
  net.setCACert(AWS_CERT_CA);
  net.setCertificate(AWS_CERT_CRT);
  net.setPrivateKey(AWS_CERT_PRIVATE);
  // Conectarse al broker de MQTT
  client.begin(AWS_IOT_ENDPOINT, 8883, net);

  Serial.print("Conectando a AWS IOT");
  while (!client.connect(THINGNAME)) {
    Serial.print(".");
    delay(100);
  }
  if(!client.connected()){
    Serial.println("AWS IoT Timeout!");
    return;
  }
  Serial.println("AWS IoT Conectado!");
}


void setup() {
  Serial.begin(9600);
  configTime(0, 0, ntpServer);
  // Conexion a la red WiFi y AWS IoT
    connectAWS();  // Inicializacion de cliente de IoT
    
   if(!accel.begin())
    {
      /* Hay un problema con  ADXL345 ... check your connections */
      Serial.println("Ooops, no ADXL345 detectado ... Verificar conexiones!");
      while(1);
    }
    accel.setRange(ADXL345_RANGE_16_G);
}

void loop() 
{

    /*Datos del ADXL345 */
    sensors_event_t event; 
    accel.getEvent(&event);
   
    /* Desplegar datos (celeracion expresada es m/s^2) */
    /* IMPORTANTE: FALTA ELIMINAR la aceleracion de la tierra ***/
    pay_x =event.acceleration.x;
    pay_y =event.acceleration.y;
    pay_z =event.acceleration.z;
    
    Serial.print("X: "); Serial.print(event.acceleration.x); Serial.print("  ");
    Serial.print("Y: "); Serial.print(event.acceleration.y); Serial.print("  ");
    Serial.print("Z: "); Serial.print(event.acceleration.z); Serial.print("  ");Serial.println("m/s^2 ");


    // Leer sensor LM35 en ADC Pin
    LM35_Raw_Sensor = analogRead(PinTemp);  
    // Calibrate ADC & Get Voltage (in mV)
    Voltage = readADC_Cal(LM35_Raw_Sensor);
    pay_temp = Voltage / 10;
    
    Serial.println(String(pay_temp));
    tiempo = getTime();
    payload = "{\"propertyAlias\":\"/PlantaA/motor1/temp\"";
    payload += ",\"value\":\"";
    payload += String(pay_temp).c_str();
    payload += "\",\"timeInSeconds\":\"";
    payload += String(tiempo).c_str();
    payload += "\"}";
    Serial.println(String(payload));
    client.publish(AWS_IOT_PUBLISH_TOPIC, (char*) payload.c_str() );

    payload = "{\"propertyAlias\":\"/PlantaA/motor1/vibra_x\"";
    payload += ",\"value\":\"";
    payload += String(pay_x).c_str();
    payload += "\",\"timeInSeconds\":\"";
    payload += String(tiempo).c_str();
    payload += "\"}";
    Serial.println(String(payload));
    client.publish(AWS_IOT_PUBLISH_TOPIC, (char*) payload.c_str() );

    payload = "{\"propertyAlias\":\"/PlantaA/motor1/vibra_y\"";
    payload += ",\"value\":\"";
    payload += String(pay_y).c_str();
    payload += "\",\"timeInSeconds\":\"";
    payload += String(tiempo).c_str();
    payload += "\"}";
    Serial.println(String(payload));
    client.publish(AWS_IOT_PUBLISH_TOPIC, (char*) payload.c_str() );

    payload = "{\"propertyAlias\":\"/PlantaA/motor1/vibra_z\"";
    payload += ",\"value\":\"";
    payload += String(pay_z).c_str();
    payload += "\",\"timeInSeconds\":\"";
    payload += String(tiempo).c_str();
    payload += "\"}";
    Serial.println(String(payload));
    client.publish(AWS_IOT_PUBLISH_TOPIC, (char*) payload.c_str() );
    
    delay(5000); //envio cada 5 seg
}

A continuación se requiere crear el dispositivo en AWS IoT Core de donde se descargarán los certificados para ponerlos en el código del ESP32.

Es importante hacer notar que las regiones dónde AWS IoT SiteWise existe (al momento de escribir este Blog) son: us-east-1, us-west-2, eu-central-1, eu-west-1, ap-southeast-1 , ap-southeast-2 . Para crear los dispositivos en dichos lugares.

A continuación se explica cómo crear el dispositivo que enviará la información a AWS IoT Core.

Ingresamos en la consola de AWS luego a AWS IoT Core.  Pasos:

  • En el menú de la izquierda dar Clic en Administración → Objetos . 
  • En la pantalla central, dar clic en Crear objetos,
  • Seleccionar Crear un único objeto
  • Clic en Siguiente.
  • Ingresa el nombre del objeto, Clic en Siguiente
  • Seleccionar Generar automáticamente un certificado nuevo, clic en Siguiente
  • Clic en Crear política. En la siguiente ventana ingresar el nombre de la política:
  • Clic en Modo Avanzado. Ingresar la siguiente política:
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": [
        "arn:aws:iot:<REGION>:<CUENTA>:client/${iot:Connection.Thing.ThingName}"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": [
        "arn:aws:iot:<REGION>:<CUENTA>:topic/sitewise/ingest"
      ]
    }
  ]
}

En la política, se requiere reemplazar <REGION> por el nombre correcto de la region de AWS donde se esta trabajando, así como el número de nuestra cuenta <CUENTA>. En <topic> se puede usar el que está o bien reemplazarlo por otro. Pero la sintaxis debe ser similar a la siguiente y dejar al inicio la palabra topic:

arn:aws:iot:<REGION>:<CUENTA>:topic/topico_deseado/otro_subtopico
  • Al terminar de actualizar la política se puede regresar a la pestaña de AWS IoT Core y se verá la nueva política creada.
  • Dar clic en Crear un objeto, teniendo seleccionada la política ESP32_sensores_SiteWise que se creo.
  • IMPORTANTE: En la siguiente parte se debe descargar los certificados, de lo contrario no es posible volver a hacerlo. Se debe descargar : Certificado del dispositivo, Archivo de clave pública, Archivo de clave privada y Clave RSA de 2048 bits: Amazon Root CA 1

Finalmente, se crea otro archivo llamado conf.h y se copia el siguiente código:

#include <pgmspace.h>

#define SECRET
#define THINGNAME "Motor_NoSerie_12345"

const char WIFI_SSID[] = "NOMBRE WIFI";
const char WIFI_PASSWORD[] = "CONTRASEÑA WIFI";
const char AWS_IOT_ENDPOINT[] = "COLOCAR AQUI ENDPOINT DE AWS IoT CORE";

// Amazon Root CA 1
static const char AWS_CERT_CA[] PROGMEM = R"EOF(
REEMPLAZAR Y COLOCAR AQUI CONTENIDO DE ARCHIVO : AmazonRootCA1.pem
)EOF";

// Device Certificate
static const char AWS_CERT_CRT[] PROGMEM = R"KEY(
REEMPLAZAR Y COLOCAR AQUI CONTENIDO DE ARCHIVO : certificate.pem.crt
)KEY";

// Device Private Key
static const char AWS_CERT_PRIVATE[] PROGMEM = R"KEY(
REEMPLAZAR Y COLOCAR AQUI CONTENIDO DE ARCHIVO : private.pem.key
)KEY";

En este último archivo se copiará el contenido de los certificados descargados y el endpoint al cual se conectará el dispositivo ESP32 a AWS IoT Core.  Debe quedar similar a la siguiente imagen:

El EndPoint o punto de enlace se localiza en AWS IoT Core, en la sección de Configuración en luego en Punto de enlace de datos de dispositivo . Y finalmente, cambiar los datos de la red WIFI. Con esto es posible compilar el código y copiarlo al dispositivo ESP32. Es importante tomar en cuenta que el cable USB debe tener los cables de datos y no solo de energía.

Una vez que se carga el código y se ejecuta la compilación así se verán los mensajes desde el serial de Arduino IDE:

Ahora, es posible comenzar a recibir los mensajes en AWS IoT Core en la sección de Prueba, en el Cliente de prueba de MQTT, se puede ingresar # en el filtro de tema para verificar todos los mensajes que llegan, independiente del tópico que se definió.

Configuración de Modelos y activos en AWS IoT SiteWise

Una vez que llegan los mensajes se continuará con la configuración de AWS IoT SiteWise. En la consola de AWS, ingresar SiteWise en los Servicios. AWS IoT SiteWise puede tener 3 formas de ingesta de datos: SiteWise gateway, uso del API y finalmente AWS IoT Rules (la que se usará en este ejercicio).

Un Asset (Activo) representa un dispositivo, una pieza de equipo o un proceso que envía uno o más flujos de datos a AWS IoT SiteWise. Cada uno de estos flujos corresponde a un alias que tiene una propiedad única. Por ejemplo:

/PlantaXYZ/Motor1/Temperatura es la medida de temperatura del motor1 en la planta XYZ.

Basado en estas medidas se pueden crear métricas, por ejemplo tener la temperatura promedio de 4 horas o la temperatura máxima de esas 4 horas, etc.

Para poder crear un Asset, primero se requiere definir el modelo. Aquí se definen las propiedades para el Asset o Activo, estas pueden ser Attributes, Measurements, Transforms y Metrics.

Finalmente es importante tener en cuenta la siguiente jerarquía:

Asset model → Asset → Asset property

A continuación se creará la representación del motor que se monitoreará. En AWS IoT SiteWise, en el menú de la izquierda dar clic en : Compilación → Modelos. Luego clic en Crear un modelo, e ingresar los siguientes datos:

  • Nombre: Motor bomba 1234
  • Definición de atributos: Nombre: Serie, Valor predeterminado: SinValor. Tipo de datos: Cadena
  • Definición de mediciones. Nombre: Temperatura, Unidad: Celcius. Tipo de datos: Doble. Clic en Agregar nueva medición
  • Definición de mediciones. Nombre :Vibra_x . Tipo de datos: Doble. Clic en Agregar nueva medición
  • Definición de mediciones. Nombre: Vibra_y . Tipo de datos: Doble. Clic en Agregar nueva medición
  • Definición de mediciones. Nombre: Vibra_z . Tipo de datos: Doble. Clic en Agregar nueva medición
  • Definición de métricas: Nombre: Max_temp_5m . Formula: max(Temperatura) . Tipo Dato: Doble. Intervalo de tiempo: 5 minutos.

Y clic hasta abajo en Crear un modelo

Una vez que se crea el modelo, dar clic en Editar para que se regrese nuevamente al modelo para agregar una nueva métrica.

En Definición de métricas, clic en Agregar nueva Métrica :

  • Definición de métricas: Nombre: motor_detenido . Formula: max(Vibra_x)-min(Vibra_x) . Tipo Dato: Doble. Intervalo de tiempo: 5 minutos.
  • Clic en Guardar

Con este valor se evaluará si el motor esta detenido.

Ahora se creará un activo. Dar clic en el menú Activos y luego clic en Crear un activo

  • En Modelo, seleccionar el motor Motor bomba 1234 que se creo en el paso previo.
  • Y el nombre representa que hace la bomba : bomba cisterna 1
  • Clic en Crear un activo

Ahora es necesario asociar este activo con el flujo de datos que van a llegar. Para permitir que AWS IoT SiteWise acepte los mensajes por AWS IoT Core message broker se requiere permitir las notificaciones.

En la misma sección de el activo que se acaba de crear,

  • Dar clic en Editar
  • En la sección de Atributos, Serie, cambiar SinValor a 123-345 y Estado de la notificación de MQTT a HABILITADO
  • Adicionalmente ingresar los tópicos que se definieron en el ESP32 para Temperatura, Vibra_x, Vibra_y, Vibra_z y habilitarlos todos. Es importante colocar una diagonal al inicio.

Deberá quedar de la siguiente manera:

Finalmente en Métrica, solo se cambia a HABILITADO y clic en Guardar

Crear Regla en AWS IoT Core

A continuación se crearán dos reglas de AWS IoT Core con las cuales se dirigirán los mensajes a AWS IoT SiteWise y a un bucket de S3.

En AWS IoT Core, en el menú de la izquierda, clic en Acto → Reglas → Crear una regla

  • Nombre: ESP32_Motores_SiteWise
  • Instrucción de consulta de regla : SELECT * FROM ‘sitewise/ingest’
  • Clic en Añadir acción
  • Seleccionar Por alias de propiedad, e ingresar los campos como en la imagen:

En el código del microcontrolador se manda la hora en tiempo UNIX Timestamp, pero en caso de que se tenga un dispositivo que no pueda mandar este dato se puede colocar la siguiente cadena en el campo Tiempo en segundos:  ${floor(timestamp() / 1E3)}

El rol es el que se creo en el paso anterior y el nombre es distinto al presentado en la imagen.

Dar clic en Guardar

Configuración del Portal de AWS IoT SiteWise

Ahora es necesario crear la estructura jerárquica de los modelos. Para esto se tendrá los siguientes elementos:

PlantaXY → Linea Producción1 → Motor

Ahora se creará una línea de producción que contenga los motores.

En el menu de la izquierda, damos clic en Modelo, y luego Crear modelo en Modelos y ahora se creará el valor de la planta:

  • Nombre: Linea Produccion
  • Definición de atributos: Nombre: Localidad, Valor predeterminado: {«lat»: «none», «lon»: «none»}. Tipo de datos: Cadena
  • Definición de jerarquía: Nombre: Linea_Prod_Jerarquia. Modelo: Motor bomba 1234
  • Clic en Añadir acción
  • En la siguiente página, se selecciona “Enviar datos de mensajes a las propiedades de activos en AWS IoT SiteWise”
  • Clic en Configurar acción

Nuevamente en AWS IoT SiteWise, en el menu de la izquierda, damos clic en Activo, y luego Crear un Activo:

  • Modelo: seleccionar  Linea Produccion
  • Nombre: Linea Produccion 1
  • Clic en Añadir Activo. Una vez que esté Active, clic en Editar
  • Clic en Agregar un activo asociado.
    • Jerarquia: Linea_Prod_Jerarquia
    • Activo: bomba cisterna 1
  • Clic en Guardar

Ahora se creará la empresa completa, en el menu de la izquierda, damos clic en Modelo, y luego Crear un Modelo:

  • Nombre: Planta_XYZ
  • Definición de jerarquía: Nombre: Todas_lineas_Jerarquia. Modelo: Linea Produccion
  • Clic en Añadir Activo. Una vez que esté Active, clic en Editar
  • Clic en Agregar un activo asociado.
    • Jerarquia: Linea_Prod_Jerarquia
    • Activo: Linea Produccion
  • Clic en Guardar

Ahora toca crear el activo ligado al modelo que se acaba de crear. En AWS IoT SiteWise, en el menu de la izquierda, damos clic en Activo, y luego Crear un Activo:

  • Modelo: seleccionar Planta_XYZ
  • Nombre: Planta Ciudad A
  • Clic en Añadir Activo. Una vez que esté Active, clic en Editar
  • Clic en Agregar un activo asociado.
    • Jerarquia: Todas_lineas_Jerarquia
    • Activo: Linea Produccion 1
  • Clic en Guardar

Creación del portal SiteWise

A continuación se creará el portal donde se podrá visualizar las métricas que llegan. En AWS IoT SiteWise dar clic en Monitoreo→ Portales. Luego clic en Crear Portal

En la siguiente sección ingresar los siguientes datos

  • Nombre : Portal Planta
  • En Autenticación de usuario, marcar IAM.
  • En Email, ingresar un correo al que tenga acceso.
  • Clic en Siguiente
  • En Habilitar alarmas, deshabilitarlo.
  • Y clic en Crear
  • En Invitar a administradores, hay que seleccionar el usuario o rol que se esta usando.
  • Y clic en Asignar usuarios
  • En la siguiente pantalla se mostrará la URL del portal https://
  • Abrir dicha liga
  • Ya en el portal, clic en Projects→ Create Project. Se agrega el nombre del proyecto y clic en Create project.
  • Luego en el menú de la izquierda, clic en Seleccionar Planta Ciudad A y clic en Add asset to project . Seleccionar Select existing project y escoger el nombre del proyecto creado anteriormente. Y clic en Add asset to project
  • En el menu de la izquierda, clic en Dashboard. Y luego clic en Create dashboard
  • En el menu de la derecha, clic en la jerarquía hasta llegar al mínimo nivel, donde se tienen las propiedades que se crearon antes.
  • Arrastrar Temperatura para crear una gráfica de este valor reportado.
  • Seleccionar las 3 vibraciones en otra gráfica para observar qué se tenga movimiento.
  • Con esto se puede tener las gráficas en tiempo real de lo que el microcontrolador ESP32 envía.

Creación de alarmas

Supongamos que el motor que se está monitoreando debe operar todo el tiempo, de esta manera se pondrá una alarma para detectar que está detenido. Una manera es leer las vibraciones que genera en operación normal y cuales son en caso de estar apagado.

Para el motor que se esta monitoreando en caso de estar apagado hay una diferencia de .9 en las graficas de un eje. Para lo cual se usará la siguiente fórmula en SiteWise en un intervalo de 5 minutos.

(max(abs(vibra_x))-min(abs(vibra_x)) 

De esta manera se eliminan los valores negativos y se compara la maxima contra la minima vibración.

Antes de agregar la alarma primero se tiene que definir el valor que la activará, para ello clic en Modelos → Motor Bomba 1234 y clic en Editar. En la siguiente pantalla,

  • Definición de atributos , clic en Agregar nuevo atributo, 
  • Nombre: Detenido
  • Valor : .9
  • Clic en Guardar

Ahora, en la sección Definiciones de alarma, clic en Agregar Alarma 

  • Seleccionar Alarma de AWS IoT Events
  • En Detalles de alarma,  Nombre de alarma: MotorDetenido
  • Definición de umbral
    • Propiedad: seleccionar : motor_detenido
    • Operador: < menor que
    • Valor: Detenido
    • Gravedad : 1
  • Dejar todos los demás valores por defecto
  • Clic en Agregar alarma

Ahora en el Dashboard en el portal, se puede arrastrar el valor Motor_detenido :

Como se ve, marca con una linea roja el umbral que se definió y si está fuera de parametro.

Conclusiones

AWS IoT SiteWise permite estar capturando información directamente desde los dispositivos a través de AWS IoT Core usando el protocolo MQTT. En muchos casos es adecuado desplegar un Gateway o pasarela que permita conectar otros microcontroladores que no tengan esta posibilidad o bien que sea un sólo sistema de envío para todos.

Para comenzar a realizar pruebas y crear un piloto de escala pequeña, este blog da una guía por donde comenzar. Posteriormente es posible usar los mismos modelos y activos creados para crecer a una escala mayor. También permite evaluar los mejores tiempos en que cada sensor estará enviando la información para calibrar correctamente los mensajes que se requieren para tener información valiosa. Una de las ventajas de enviar los mensajes a través de AWS IoT Core usando Reglas es la posibilidad de poder duplicar los datos que llegan y pasarlos a AWS IoT SiteWise así como un repositorio de S3 donde puedan ser usados para modelos de Inteligencia artificial donde existen distintas estrategias para mantenimiento predictivo.

Sobre el autor

Jorge Alfaro, Arquitecto de Soluciones en Amazon Web Services México.
Cuenta con mas de 25 años de experiencia en la industria, ayudando a grandes corporativos en diseñar y mover sus cargas de trabajo a la nube de AWS, su área de especialidad es IoT

Sobre los revisores

Raul Hugo, Arquitecto de Soluciones en Amazon Web Services  Peru

Javier Galvez, Arquitecto de Soluciones en Amazon Web Services  Argentina