En una publicación anterior, mostramos cómo enviar y recibir mensajes desde dispositivos IoT utilizando un corredor MQTT. En esta publicación ampliaremos esa idea a un ejemplo del mundo real.

Supongamos que tiene un dispositivo IoT que mide la temperatura y la humedad en un invernadero (No es difícil hacer uno usando Raspberry Pi o Arduino).

Queremos monitorear las condiciones del invernadero de forma remota desde otra computadora o, tal vez, desde un servicio de registro central. En la publicación anterior, mostramos una implementación de código de Go para enviar mensajes, por lo que ampliaremos ese ejemplo.

En lugar de simplemente enviar una cadena que diga "la temperatura es x, la humedad es y", definamos una estructura para el mensaje y el dispositivo. Considera que tienes (o quieres agregar en el futuro) un dispositivo para monitorear la humedad o la lluvia y quieres conectar ese también.

Para dejar abierta la posibilidad de múltiples dispositivos y tipos, necesitamos un modelo de datos para manejar eso.

type Message struct {
    Time   time.Time `json:"time"`
    Device Device    `json:"device"`
}

type Device interface {
    ID() string
    Name() string
}

type TempRHDevice struct {
    Id         string  `json:"id"`
    DeviceName string  `json:"name,omitempty"`
    Temp       float32 `json:"temp,omitempty"`
    Rh         float32 `json:"rh,omitempty"`
}

func (t TempRHDevice) ID() string {
    return t.Id
}

func (t TempRHDevice) Name() string {
    return t.DeviceName
}

La estructura del mensaje es lo que se enviará al corredor MQTT. Creamos una interfaz para manejar los atributos comunes de nuestros dispositivos IoT y abstraer los detalles de los dispositivos específicos.

El TempRHDevice es nuestro dispositivo que mide la temperatura y la humedad. Implementa la interfaz del Dispositivo, por lo que se puede utilizar en un Mensaje.

A continuación, debemos enviar el mensaje al corredor. Emplearemos el formato JSON por su simplicidad en este ejemplo. Tenga en cuenta que en un sistema a gran escala con miles o más dispositivos, es posible que deseemos utilizar un formato más compacto.

message := generateRandomMessage()
payload, err := json.Marshal(message)
if err != nil {
    panic(err)
}
token := client.Publish(topic, 0, false, payload)

Go hace que la clasificación en JSON sea bastante fácil. Una vez calculado, el mensaje json se envía al corredor.

¿Qué más querríamos hacer con los datos una vez que los tengamos? Almacenarlos en una base de datos, mostrarlos en un tablero, verificar los valores para condiciones de alarma. Necesitaremos convertir el json para que sea utilizable.

En el lado receptor, solo necesitamos descomponer el json en una estructura. Usaremos una estructura similar a la utilizada en el lado emisor; pero necesitamos una forma de descomponerlo en un tipo concreto en lugar de la interfaz del Dispositivo en Mensaje. Agregaremos un método de desclasificación personalizado en Mensaje para que el código también sea un poco más limpio

type rawMessage struct {
    Time   time.Time `json:"time"`
    Device TempRHDevice    `json:"device"`
}
func (m *Message) UnmarshalJSON(data []byte) error {
    var raw rawMessage
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }
    m.Time = raw.Time
    m.Device = &raw.Device
    return nil
}

...

func processMsg(ctx context.Context, ....

...

    case msg, ok := 



Es apropiado señalar aquí que este método se complica cuando se agregan más tipos de dispositivos. Por ejemplo, ¿cómo sabrá el método UnmarshalJSON qué tipo de dispositivo contiene el mensaje? Podríamos aplicar una lógica inteligente en UnmarshalJSON para detectar el tipo. 

Como otra alternativa, recuerde que MQTT se puede utilizar para publicar en varios temas y es una práctica común utilizar una convención de nomenclatura jerárquica para los temas. Entonces, en el caso de varios tipos de dispositivos en el ejemplo del invernadero, la forma recomendada es publicar diferentes tipos de dispositivos en diferentes temas. Esta es la forma en que lo manejaremos en el futuro a medida que agreguemos nuevos tipos de dispositivos. 

En el ejemplo del invernadero, los nombres de los temas podrían estructurarse así:


/greenhouse/temprh/deviceid
/greenhouse/moisture/deviceid




En MQTT, podemos suscribirnos a temas usando un tema comodín, como:


if token := client.Subscribe("/greenhouse/#", 0, nil); token.Wait() && token.Error() != nil {
        fmt.Println(token.Error())
        os.Exit(1)
    }




que coincidirá con todos los dispositivos en el espacio de nombres del invernadero. entonces solo necesitaríamos agregar lógica a ProcessMsg() para ver el tema del mensaje entrante y saber cómo descomponerlo.

 Ahora que tenemos un mensaje de dispositivo en un formato utilizable, ¿qué se debe hacer con él? En la próxima publicación de esta serie, demostraremos nuestro enfoque para conservar el mensaje en PostGres.

Como de costumbre, el código fuente completo del remitente se puede encontrar aquí y el código del suscriptor se puede encontrar aquí.

Déjame saber tu opinión en los comentarios.

¡Gracias!