Hoy en día, el internet de las cosas (IoT) está transformando nuestro mundo, desde parlantes inteligentes, aspiradoras, cerraduras hasta asistentes de voz y muchas otras aplicaciones que pueden ser controladas de forma remota. Una de las tecnologías más relevantes en este campo es el protocolo MQTT (Message Queuing Telemetry Transport). En este artículo, quiero mostrarte cómo controlar dispositivos MQTT con Java, abriendo un mundo de posibilidades para todos aquellos que somos fans de Duke. Crearemos una aplicación con Java capaz de monitorear y controlar dispositivos MQTT, como una ventana automática controlada por un sensor de lluvia.

Qué es MQTT
MQTT es un protocolo de mensajería con una arquitectura publicador/subscriptor que trabaja sobre TCP/IP. En cada comunicación existen al menos tres elementos: un publicador, un bróker y un subscriptor. El bróker es responsable de gestionar la comunicación, asegurando que un mensaje enviado por el publicador sea recibido por todos los subscriptores interesados, sin que estos necesiten conocer al publicador directamente.
Para entender mejor, imagina que el bróker es como un “centro de distribución de mensajes”. Los publicadores envían mensajes a este centro, y los subscriptores indican qué mensajes les interesan a través del uso de tópicos. El bróker se encarga de que cada mensaje llegue a los subscriptores correctos. Esto permite una comunicación eficiente y desacoplada entre dispositivos.

TCP/IP es crucial aquí porque garantiza características como la retransmisión de paquetes perdidos, una velocidad de transferencia de información confiable y la seguridad a través de la encriptación con TSL/SSL.
Entendiendo los Tópicos en MQTT
Antes de adentrarnos en el código, quiero hacer una breve introducción a cómo funcionan los tópicos en MQTT. Un tópico en MQTT es básicamente una ruta o canal que se utiliza para organizar los mensajes. Piensa en un tópico como la dirección de una casa: es necesario para asegurarse de que los mensajes llegan al lugar correcto.
Estructura de un Tópico
Los tópicos en MQTT siguen una estructura jerárquica similar a un sistema de archivos en un ordenador. Por ejemplo, un tópico podría verse así:
hogar/sala/temperatura
En este caso, hogar es el nivel superior, seguido de sala, y finalmente temperatura es el nivel más específico. Esto permite organizar y categorizar los mensajes de manera sencilla.
Publicación y Suscripción
En MQTT, un publicador envía un mensaje a un tópico específico, y los suscriptores que estén interesados en ese tópico recibirán el mensaje. Es importante destacar que el publicador y el suscriptor no necesitan conocerse entre sí; solo necesitan saber el tópico. Esto hace que la comunicación sea más flexible y escalable.
Hablemos de código
Para este ejemplo, vamos a usar la Keyestudio Smart Home, que cuenta con un chip Keyestudio con wifi y varios sensores programables con el Arduino IDE. El código que usé para hacer las pruebas con este dispositivo está en este repositorio de GitHub.
En específico, utilizaremos el sensor de agua “raindrop” y uno de los servos (la casa tiene dos: uno para la puerta y otro para la ventana). La idea es usar el sensor de agua para abrir o cerrar la ventana dependiendo del estado del sensor.
El Broker
Para hacer mas sencillas las cosas, vamos a usar la versión de prueba del servidor Mosquitto. Esta está disponible en test.mosquitto.com y puedes conectarte a él para hacer casi todo tipo de pruebas sin costo alguno.
¡No tengo sensores físicos y quiero hacer el ejemplo!
¡Está bien! En ese caso podemos simular ambos (en sensor de agua y el servo) con los comandos de mosquitto. Para eso debes instalarlo localmente, las instrucciones las encuentras en la página oficial, clic acá. Los comandos son:
Para conectarte y recibir mensajes en un tópico puedes usar:
mosquitto_sub -h test.mosquitto.org -t "hogar/sala/temperatura"
Para publicar mensajes:
mosquitto_pub -h test.mosquitto.org -t "hogar/sala/temperatura" -m "el mensaje"
Finalmente, en nuestra aplicación, los mensajes se van a enviar usando JSON, y el formato es el siguiente:
{
"water": 1561,
"time": 111
}
Hagamos código Java
Utilizaremos el componente raindrop y uno de los servos1 (la casa tiene dos, uno para el control de la puerta y otro para el de la ventana). La idea es utilizar el sensor de agua en el raindrop para abrir o cerrar la ventana.
Haremos una aplicación de consola sencilla, que al correr monitoreará el estado del sensor de agua y accionará a partir de esos valores.
Para esto agregaremos la dependencia Eclipse Paho a nuestra aplicación:
<dependency>
<groupId>org.eclipse.paho</groupId>
<artifactId>org.eclipse.paho.client.mqttv3</artifactId>
<version>1.2.5</version>
</dependency>
Luego crearemos una clase Java que utilizará Paho MQTT para subscribirse a un tópico MQTT y publicar un mensaje a los datos recibidos:
public class ItsRaining {
private static final String HOME_ID = "my-unique-id";
public static void main(String[] args) throws MqttException {
MqttClient client = new MqttClient(
"tcp://test.mosquitto.org",
MqttClient.generateClientId());
client.connect();
client.subscribe(HOME_ID + "/raindrop/status", (topic, message) -> {
System.out.println("Message: "; + new String(message.getPayload()));
int water = JsonParser.parseString(new String(message.getPayload()))
.getAsJsonObject().get("water").getAsInt();
if (water > 1000) {
System.out.println("It's Raining");
client.publish(HOME_ID + "/window/position",
"CLOSE".getBytes(),
1,
false);
} else {
System.out.println(&quot;It's not Raining&quot;);
client.publish(HOME_ID + "/window/position",
"OPEN".getBytes(),
1,
false);
}
});
}
}
Expliquemos paso a paso que es lo que ocurre acá:
1. Declaración de un ID único para usar como base en el tópico de conexión.
private static final String HOME_ID = "my-unique-id";
El uso de identificadores en los tópicos es importante para garantizar la suscripción a los mensajes apropiados y no recibir datos irrelevantes. En esta línea de código el HOME_ID se utiliza como prefijo asegurando que los mensajes relacionados específicamente con el hogar identificado por HOME_ID sean los que se reciban.
2. Creación y conexión al cliente MQTT
public static void main(String[] args) throws MqttException {
MqttClient client = new MqttClient(
"tcp://test.mosquitto.org",
MqttClient.generateClientId());
client.connect();
}
- Creamos un método
mainen nuestra clase como función de entrada de la aplicación. - Creamos una instancia de
MqttClientcon los parámetros siguientes:- La dirección del servidor (broker) al que nos vamos a conectar.
- Un identificador de cliente único en el servidor.
- Conectamos al servidor.
3. Suscripción al tópico y manejo del mensaje
client.subscribe(HOME_ID + "/raindrop/status", (topic, message) -> {
System.out.println("Message: " + new String(message.getPayload()));
int water = JsonParser.parseString(new String(message.getPayload()))
.getAsJsonObject().get("water").getAsInt();
}
- En la línea 10, nos suscribimos al tópico
HOME_ID + "/raindrop/status". - Cuando se recibe el mensaje, se imprime el contenido.
- Finalmente, usamos
JsonParserpara obtener el valor dewaterque es lo que nos interesa de la información que nos envía el raindrop.
4. Publicamos un mensaje al tópico que escucha el servo basándonos en el valor recibido.
if (water > 1000) {
System.out.println("It's Raining");
client.publish(HOME_ID + "/window/position",
"CLOSE".getBytes(),
1,
false);
} else {
System.out.println("It's not Raining");
client.publish(HOME_ID + "/window/position",
"OPEN".getBytes(),
1,
false);
}
- Acá es donde tomamos acción basándonos en el valor recibido. Si el valor es superior a
1000, se publica un mensajeCLOSEal tópicoHOME_ID + "/window/position". - valor de
wateres menor o igual a1000, se publica el mensajeOPENen el mismo tópico.
Esto permite usar el sensor raindrop para monitorear el estado de la “lluvia” y controlar la posición de la ventana en función de los datos recibido. ¡Y listo! Tenemos una aplicación básica hecha en Java para controlar dispositivos IoT utilizando MQTT.
Conclusión
Con este artículo, has aprendido a controlar y escuchar dispositivos IoT con MQTT y Java. Este es solo el comienzo: puedes ampliar este proyecto integrando más dispositivos o incluso creando una interfaz gráfica que te permita manejar todo de manera más visual y accesible.
¿Podría preguntarte qué dispositivos puedo encontrar en el mercado que utilizan MQTT si no deseo hacerlos yo mismo?
MQTT es un protocolo ampliamente usado y muchos dispositivos en el mercado lo utilizan para comunicación. Marcas como Philips (ejemplo las luces Philips Hue) pueden ser controladas a través de MQTT, los dispositivos Shelly que cuentan con interruptores y sensores también usan MQTT, entre otros.
El código completo de los ejemplos de Java con MQTT los puedes encontrar en mi GitHub.
1. Servo: Un servo es un dispositivo que combina un motor con un sistema de control para mover y mantener un objeto en una posición específica. Es como un motor inteligente que puede moverse a un ángulo exacto y mantener esa posición con precisión. Los servos se utilizan en cosas como robots, modelos a control remoto, y otros dispositivos que necesitan movimiento controlado.




0 comentarios