In einem früheren Beitrag haben wir gezeigt, wie man mithilfe eines MQTT-Brokers Nachrichten von IoT-Geräten sendet und empfängt. In diesem Beitrag erweitern wir diese Idee auf ein Beispiel aus der Praxis.

Angenommen, Sie haben ein IoT-Gerät, das Temperatur und Luftfeuchtigkeit in einem Gewächshaus misst (Es ist nicht schwer, eines mit Raspberry Pi oder Arduino herzustellen).

Wir möchten die Gewächshausbedingungen von einem anderen Computer oder vielleicht einem zentralen Protokollierungsdienst aus fernüberwachen. Im vorherigen Beitrag haben wir eine Go-Implementierung des Codes zum Senden von Nachrichten gezeigt, daher werden wir dieses Beispiel erweitern.

Anstatt nur eine Zeichenfolge mit der Aufschrift „Temperatur ist x, Luftfeuchtigkeit ist y“ zu senden, definieren wir eine Struktur für die Nachricht und das Gerät. Bedenken Sie, dass Sie ein Gerät zur Überwachung von Feuchtigkeit oder Niederschlag haben (oder in Zukunft hinzufügen möchten) und dieses auch anschließen möchten.

Um die Möglichkeit mehrerer Geräte und Typen offen zu lassen, benötigen wir ein Datenmodell, um damit umzugehen.

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
}

Die Nachrichtenstruktur ist das, was an den MQTT-Broker gesendet wird. Wir haben eine Schnittstelle erstellt, um die gemeinsamen Attribute unserer IoT-Geräte zu verarbeiten und die Details der spezifischen Geräte zu abstrahieren.

Das TempRHDevice ist unser Gerät, das Temperatur und Luftfeuchtigkeit misst. Es implementiert die Geräteschnittstelle, sodass es in einer Nachricht verwendet werden kann.

Als nächstes müssen wir die Nachricht an den Broker senden. Der Einfachheit halber verwenden wir in diesem Beispiel das JSON-Format. Beachten Sie, dass wir in einem großen System mit Tausenden oder mehr Geräten möglicherweise ein kompakteres Format verwenden möchten.

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

Go macht das Marshalling in JSON ziemlich einfach. Nach dem Marshalling wird die JSON-Nachricht an den Broker gesendet.

Was möchten wir sonst noch mit den Daten machen, wenn wir sie haben: sie in einer Datenbank speichern, auf einem Dashboard anzeigen, die Werte auf Alarmbedingungen prüfen? Wir müssen den JSON konvertieren, um ihn nutzbar zu machen.

Auf der Empfangsseite müssen wir nur den JSON in eine Struktur entmarshalieren. Wir verwenden eine ähnliche Struktur wie auf der Absenderseite. Wir brauchen jedoch eine Möglichkeit zum Unmarshalieren in einen konkreten Typ und nicht in die Geräteschnittstelle in Message. Wir werden Message eine benutzerdefinierte Unmarshal-Methode hinzufügen, um den Code ebenfalls etwas übersichtlicher zu machen

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 ist angebracht, hier darauf hinzuweisen, dass diese Methode komplizierter wird, wenn weitere Gerätetypen hinzugefügt werden. Wie erkennt die UnmarshalJSON-Methode beispielsweise, welchen Gerätetyp die Nachricht enthält? Wir könnten in UnmarshalJSON eine clevere Logik verwenden, um den Typ zu erkennen. 

Bedenken Sie als weitere Alternative, dass MQTT zum Veröffentlichen in mehreren Themen verwendet werden kann und es gängige Praxis ist, eine hierarchische Namenskonvention für Themen zu verwenden. Im Falle mehrerer Gerätetypen im Gewächshausbeispiel besteht die empfohlene Vorgehensweise darin, unterschiedliche Gerätetypen zu unterschiedlichen Themen veröffentlichen zu lassen. So werden wir künftig vorgehen, wenn wir neue Gerätetypen hinzufügen. 

Im Gewächshausbeispiel könnten die Themennamen wie folgt aufgebaut sein:


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




In MQTT können wir Themen mit einem Platzhalterthema abonnieren, wie zum Beispiel:


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




, das mit allen Geräten im Gewächshaus-Namespace übereinstimmt. Dann müssten wir nur noch Logik zu „processMsg()“ hinzufügen, um uns das Thema der eingehenden Nachricht anzusehen und zu wissen, wie man sie entmarshallt.

Da wir nun eine Gerätenachricht in einer verwendbaren Form haben, was sollte damit gemacht werden? Im nächsten Beitrag dieser Reihe demonstrieren wir unseren Ansatz, die Nachricht in PostGres beizubehalten.

Den vollständigen Quellcode für den Absender finden Sie wie gewohnt hier und den Abonnentencode hier.

Teilen Sie mir Ihre Gedanken in den Kommentaren mit.

Danke!