En este artículo, crearemos un sistema de electricidad prepago basado en IoT y aprenderemos exactamente cómo funciona.
Crearemos un medidor que monitoreará el uso de electricidad e informará las facturas a un servidor de monitoreo (que también crearemos). En un sistema eléctrico común, las facturas vienen después del consumo y luego pagamos la factura. Pero en este sistema, primero hay que pagar la electricidad por recarga. Cuando su consumo de electricidad exceda su límite de recarga, recibirá advertencias. Si aún no se paga la factura, la luz se cortará automáticamente.
Componentes necesarios
Dependencias
Sistema operativo: Windows/Linux/MacOSx
Lenguajes de programación utilizados – Python 2.7
Medios de comunicación – GPRS
Tecnología utilizada
- Protocolo MQTT (transporte de telemetría de cola de mensajes): MQTT es un protocolo ligero para transmitir mensajes a través de Internet. Funciona como una arquitectura cliente-servidor. El servidor se llama corredor.
- GPRS: servicio (Servicio General de Radio por Paquetes), que funciona en base al servicio de radio por paquetes y proporciona conectividad a Internet para dispositivos celulares.
Información técnica
Calcularemos el uso de energía utilizando algunos sensores o circuitos. Luego mapearemos el uso de energía en términos de dinero, es decir, 500 W por 50 dólares. El contador inteligente tendrá un interruptor de apagado/encendido y será controlado por el servidor de monitorización. Cuando un usuario recarga, la energía aumenta y el servidor envía un comando de ENCENDIDO al medidor. Luego encenderá la alimentación y, cuando se complete la recarga, el comando será apagar el medidor y ponerlo en OFF.
Crear un sistema como este tendrá algunos desafíos, tales como:
¿Cómo calculará el medidor la potencia?
Usaremos un sensor de calculadora de energía para obtener los datos de energía y luego los datos se enviarán al controlador principal del medidor inteligente.
¿Cómo se comunicará la estación de servicio principal (estación de monitoreo) con el medidor?
Para la comunicación utilizaremos un módulo GSM y tecnología GPRS para la conectividad a Internet. Para la señalización utilizaremos el protocolo MQTT.
¿Cómo se realizará la factura y las recargas?
Construiremos un script Python en el lado del servidor que se encargará de todas las operaciones, como calcular la energía en tiempo real y compararla con el plan de energía comprado por el usuario y enviar una señal de encendido o apagado al medidor.
Apague y encienda para eventos específicos.
El medidor tendrá una unidad de microcontrolador para encender o apagar la alimentación principal y controlar todas las partes de control.
Diagrama de bloques
Figura 1 Sistema eléctrico prepago basado en GPRS
- La unidad de medición contiene un microcontrolador y un módulo GSM para procesamiento y comunicación. El contador tiene un relé que controla la electricidad de la casa. También hay un sensor que calcula la potencia.
- El servidor de suministro de electricidad es un script de Python que mantiene registros del uso del suministro de energía y recibe estos datos del medidor a través de MQTT.
- El servidor de suministro eléctrico puede enviar comandos de ENCENDIDO y APAGADO al medidor a través de MQTT.
¿Como funciona el sistema?
Cuando los usuarios recargan para un plan de energía específico, el medidor comienza a leer el uso de energía mediante un sensor de energía. En este caso calculamos la diferencia de voltaje a través de una resistencia, obteniendo así la potencia utilizada por todos los dispositivos conectados al medidor. El consumo de energía se envía al sistema de suministro (servidor/script Python) a través del protocolo MQTT, y los cálculos de factura y energía se realizan en el servidor. Una vez realizados todos los cálculos, podemos determinar las siguientes señales que debemos enviar al medidor y al usuario:
Señales de advertencia: Cuando la recarga del medidor está por finalizar.
Medidor ON/OFF: Apagar/Encender la conexión de alimentación
Consumo total de energía: cuando el usuario solicita el uso de energía, los datos se envían con un resumen de uso.
Para recargar aún más la conexión, el usuario puede contactar con la estación de servicio, cambiando algunas variables.
Entendiendo el código fuente
Configuración de variables de conexión de módem GSM y MQTT
En primer lugar, configuramos nuestro medidor para la comunicación incluyendo la biblioteca TinyGSM:
#incluir
Definimos nuestro módem en la parte superior del código, que utilizamos para fines GPRS.
#establecer TINY_GSM_MODEM_SIM800
A continuación, definimos nuestra conexión de módem a nuestro microcontrolador con los pines serie del software.
SoftwareSerial SerialAT(5, 6); //RX,TX
Ahora le decimos a nuestra biblioteca de módem GSM qué pines serie vamos a conectar.
Módem TinyGsm (SerialAT);
Luego cambiamos nuestro APN (Access Point Name) por el APN de la tarjeta SIM.
const char apn = “bsnllive”;
En este punto, nuestro módem GSM ya está casi configurado. El resto se puede entender a partir de los comentarios del código.
Ahora definimos nuestro protocolo de comunicación "MQTT", pero primero importemos la biblioteca pub-sub-cliente necesaria para MQTT.
#incluir
A continuación definimos la dirección de nuestro broker y los temas a los que nos suscribiremos, que pueden ser cualquier cosa dependiendo de los nombres de los medidores.
const char* corredor = “corretor.hivemq.com”;
const char* topicSub = “GsmClientTest/led”;
const char* topicInit = “GsmClientTest/init”;
const char* topicPub = “GsmClientTest/ledStatus”;
Ahora es el momento de configurar el módem y los clientes MQTT en nuestro código.
Cliente TinyGsmClient (módem);
PubSubClientmqtt(cliente);
Función de configuración para iniciar todo en orden
Primero, iniciamos nuestras conexiones en serie y configuramos los pines de SALIDA digital y el pin de SALIDA de nuestro relé (interruptor de alimentación principal).
pinMode(Relay_PIN, SALIDA);
Ahora reiniciamos nuestro módem para comprobar si le ha sucedido algo anteriormente.
reinicio.del.módem;
Luego tomamos la información del módem y la imprimimos en un terminal serie.
Cadena modemInfo = modem.getModemInfo;
SerialMon.print(“Módem: “);
SerialMon.println(modemInfo);
Ahora, como vamos a enviar datos a través de la red, no debemos continuar hasta que nuestro módem esté conectado a la red celular, por lo que agregamos una condición de bloqueo.
si (!modem.waitForNetwork) {
SerialMon.println(”fallido”);
mientras (verdadero);
}
SerialMon.println(”Aceptar”);
Luego de conectarnos a la red, ahora procedemos a conectarnos al servicio GPRS, esto también se hace en una conexión de bloqueo.
if (!modem.gprsConnect(apn, usuario, contraseña)) {
SerialMon.println(”fallido”);
mientras (verdadero);
}
Nuestro sistema está conectado a Internet, tenemos IP asignadas y la conexión TCP está activa. Ahora nos conectamos a nuestro servidor MQTT.
mqtt.setServer(corredor, 1883);
Como utilizamos MQTT, la biblioteca siempre envía señales de ping al corredor. No queremos interrumpir nada en la biblioteca ni en nuestra conexión principal. Por lo tanto, para recibir mensajes del corredor, agregamos un método de devolución de llamada.
mqtt.setCallback(mqttCallback);
Ahora estamos conectados al broker MQTT y necesitamos establecer una condición que establezca que si alguna vez nos desconectamos del servidor, nos volveremos a conectar automáticamente. O si estamos conectados, enviamos a nuestro cliente al bucle.
si (mqtt.conectado) {
mqt.bucle;
}
O simplemente nos volvemos a conectar como se describe a continuación.
otro {
// Reconectarnos cada 10 segundos
t larga sin signo = milis;
if (t – último intento de reconexión > 10000L) {
últimoReconnectAttempt = t;
si (mqttConnect) {
último intento de conexión = 0;
}
}
Hay algunos puntos sobre la función de conexión MQTT con respecto a la recepción de devoluciones de llamada.
mqttConnect: explicación de la función
Nos conectamos con el corredor proporcionando el nombre de nuestro cliente como nombre único.
mqtt.connect(“medidor de electricidad GSM”)
Luego enviamos una señal de confirmación a cualquier cliente sobre un tema relacionado con el corredor.
mqtt.publish(topicInit, “Medidor iniciado”);
Luego registramos a nuestro cliente con un tema.
mqtt.subscribe(temaSub);
Finalmente, devolvemos si nuestro cliente está conectado o no.
devolver mqtt.conectado;
mqttCallback(char* tema, byte* carga útil, unsigned int len): explicación de la función
Esta función recibe mensajes del broker en algunas variables.
Tema: Este es el tema sobre el cual viene el mensaje; es necesario cuando estamos suscritos a múltiples temas y determinamos qué mensaje viene.
Carga útil: este es el mensaje real que recibimos del corredor en bytes.
Len: Esto nos da la longitud total del mensaje recibido.
Ahora, usando estas variables, determinamos lo que el servidor intenta decirle al medidor.
if(data_r_in_string == “datos”){
Ahora, si recibimos un comando del servidor que dice "datos", comenzamos a tomar lecturas del sensor o pin analógico y las enviamos al servidor:
flotador v1 = analogRead(A0);
flotador v2 = analogRead(A1);
Además, cuando recibimos mensajes como encender o apagar el medidor/alimentación principal, también encendemos el relé.
si(data_r_in_string == “ON”){
escritura digital (PIN_relé, ALTO);
mqtt.publish(topicPub, “el medidor está encendido”);
}
Así funciona nuestra unidad de medida. Para obtener información sobre la unidad del servidor, lea a continuación.
Guión del servidor
El script del servidor está completamente basado en Python, por lo que primero comenzamos con el protocolo de comunicación MQTT. Entonces, la configuración de la comunicación se detalla a continuación.
A continuación, importamos las bibliotecas necesarias para comunicarnos con el corredor MQTT.
Importar paho.mqtt.client como mqtt
importar paho.mqtt.publish cómo publicar
A continuación asignamos dos variables con temas MQTT, una a la que enviaremos mensajes y otra a la que recibiremos mensajes.
tema_suscripción = “ts/café/reporte”
publicar_topic = “ts/café/máquina”
Ahora declararemos una variable llamada cliente con cliente mqtt.
cliente = mqtt.Cliente
Ahora haremos dos devoluciones de llamada de funciones 1. Para recibir mensajes 2. Haciendo algo en una conexión exitosa.
client.on_connect = on_connect
client.on_message=on_message
Finalmente, nos conectaremos al broker MQTT en un puerto e iniciaremos el cliente dentro de un bucle sin bloqueo.
cliente.connect(“broker.hivemq.com”, 1883, 60)
cliente.loop_start
Una vez que la conexión sea exitosa, podemos enviar mensajes usando lo siguiente:
publicar.single(tema, datos_mensaje, nombre de host =”broker.hivemq.com”)
Ahora ingresamos a nuestra función de devolución de llamada para analizar los mensajes entrantes.
Disponemos de dos funciones para recibir datos. Uno es para verificar el estado inicial del medidor si se ha iniciado o no; el segundo es recibir los datos del medidor.
In_message: recibe datos del medidor, como lecturas y estado.
Inicio: Obtiene el estado inicial del medidor si se inicia
Ahora mostramos todos los datos recibidos del medidor en una línea como una pantalla como lo hicimos en uno de nuestros proyectos de IoT "tablero de IoT"
si (conectado == Verdadero):
print '\r' + “Estado del medidor:”, estado, '\t', “Datos del medidor:”,
datos, '\t', “Estado del medidor:”, estado,
Una vez que comenzamos a recibir datos, podemos planificar cómo responderemos al medidor.
Aquí, solo estamos recibiendo dos voltajes y si la condición de V1 es menor que V2, entonces el medidor se apagará. De lo contrario, se encenderá cuando ambos voltajes sean iguales.
Si f(“:” en el mensaje):
datos = mensaje
v1,v2= mensaje.split(“:”)
#cualquier condición para encender/apagar la alimentación
si(int(v1) <int(v2)):
enviar_signs(“ACTIVADO”)
si(int(v1) == int(v2)):
enviar_signs(“APAGADO”)
Código del medidor
