TbeCbMQTTClient

Eine Komponente für das MQTT Netzwerkprotokoll. Für Codeblock Umgebungen ohne Formular muss der Codeblock persistent ausgeführt werden.

Andernfalls wird das Objekt nach Beendigung des Codeblocks zerstört.

Eigenschaften

Achtung: Die Verdingungs-Eigenschaften müssen eingestellt werden bevor CbActive gesetzt wird.

Eigenschaften	Beschreibung
CbActive:L	Startet den MQTT Client und stellt eine Verbindung zum eingestellten Host her CbProtocol muss gesetzt sein bevor CbActive gesetzt wird!
CbHost:C	MQTT Server/Broker/AWS IoT Endpoint
CbPort:N	Port
CbProtocol:N	bmqttpMQTT bmqttpWebsocket bmqttpAWSIOT - Amazon AWS IoT
CbTLS:L	TLS ein-/ausschalten Bemerkung: für AWS IoT ist TLS immer an
CbUser:C	Benutzername für Authentifizierung Bemerkung: momentan nicht für AWS IoT
CbPassword:C	Passwort für Authentifizierung Bemerkung: momentan nicht für AWS IoT
CbCertPath:C	Nur in Verbindung mit bmqttpAWSIOT Pfad zum `.pem` Datei
CbKeyPath:C	Nur in Verbindung mit bmqttpAWSIOT Pfad zum `.key` Privaten-Schlüssel Datei
CbHeartBeatInterval:N	>0 sendet alle x Sekunden einen Ping an den MQTT Server/Broker
CbCustomAuthentication_Enabled:L	Nur in Verbindung mit bmqttpAWSIOT benutzerdefinierten Authentifizierung aktivieren
CbCustomAuthentication_Parameters:C	Nur in Verbindung mit bmqttpAWSIOT Abfrageparameter die an den Server übergeben werden
CbCustomAuthentication_Headers:C	Nur in Verbindung mit bmqttpAWSIOT benutzerdefinierten Header. Werte müssen mit CRLF getrennt sein
CbCustomAuthentication_UseWebSockets:L	Nur in Verbindung mit bmqttpAWSIOT Verbindung über Websocket oder TCP

Funktionen und Methoden

Funktion

Parameter

Beschreibung

CbPing()

Ping an MQTT Server/Broker senden

nicht vorhanden für AWS IoT

CbPublish:N()

cTopic:C
cText:C
nQoS:N
lRetain:L

sendet eine Nachricht an alle abonnierten Clients

cTopic: ist der Kanal, in dem die Nachricht veröffentlicht werden soll.
cText: ist der Text der Nachricht.
QoS: ist die Dienstgüte der veröffentlichten Nachricht.
- bmqttqsAtMostOnce: Die Nachricht wird nach bestem Bemühen des zugrunde liegenden TCP/IP-Netzwerks zugestellt. Die Nachricht kommt beim Server entweder einmal oder gar nicht an, der Server quittiert den Empfang nicht,
- bmqttqsAtLeastOnce: garantiert, dass die Nachricht mindestens einmal beim Empfänger eintrifft. Die Nachricht kann aber auch mehrmals beim Empfänger eintreffen. Wird der Empfang der Nachricht z.b wegen Störung der Kommunikationsverbindung nach einer bestimmten Zeit nicht bestätigt, wird die Nachricht erneut gesendet.
- bmqttqsExactlyOnce: wie bmqttqsAtLeastOnce nur das aktiv verhindert wird das die Nachricht mehrfach beim Empfänger eintrifft (nicht vorhanded für AWS IoT)
lRetain: Wenn True, muss der Server die Nachricht und QoS speichern, damit sie an künftige Abonnenten zugestellt werden kann (nicht vorhanded für AWS IoT)

CbPublishAndWait:L()

cTopic:C
cText:C
nQoS:N
lRetain:L
nTimeout:N

wie CbPublish() nur wird je QoS Level auf die Bestätigung des Servers über den Empfang der Nachricht gewartet

nTimeout in Sekunden wie lange auf die Bestätigung über den Empfang der Nachricht gewartet wird.

Verfügbare Ereignisse

Funktion	Parameter	Beschreibung
OnException()	aClient:O, aException:O	TCP/IP oder MQTT Fehlern
OnBeforeConnect()	aClient:O, aCleanSession:Boolean, aClientIdentifier:C	Letzte möglichkeit die Eigenschaften des Klients zu ändern
OnConnect()	aClient:O, aSession:Boolean, aReasonCode:N, aReasonName:C	Nach dem erforleichen Verbinden
OnDisconnect()	aClient:O, aReasonCode:N, aReasonName:C	Nach dem erforleichen Trennung
OnPublish()	aClient:O, aTopic:C, aText:C	Empfang von Botschaften von eigenen oder fremden Klient
OnPing()	aClient:O	Empfang von Bestätigung eines Ping
OnSubscribe()	aClient:O, aPacketIdentifier:N	Nach dem erforleichen Anmeldung zumTopic
OnUnsubscribe()	aClient:O, aPacketIdentifier:N	Nach dem erforleichen Ausmeldung vom Topic
OnPubAck()	aClient:O, aPacketIdentifier:N, aReasonCode:N, aReasonName:C	Empfang von PUBACK mit nQoS bmqttqsAtLeastOnce
OnPubRec()	aClient:O, aPacketIdentifier:N, aReasonCode:N, aReasonName:C	Empfang von PUBREC mit nQoS bmqttqsExactlyOnce
OnPubRel()	aClient:O, aPacketIdentifier:N, aReasonCode:N, aReasonName:C	Empfang von PUBREL mit nQoS bmqttqsExactlyOnce
OnPubComp()	aClient:O, aPacketIdentifier:N, aReasonCode:N, aReasonName:C	Empfang von PUBCOMP mit nQoS bmqttqsExactlyOnce
OnAuth()	aClient:O, aReasonCode:N, aReasonName:C	Empfang von Authentifizierungsdaten
OnSSLVerify()	aClient:O, aAccept:L	Empfang eines Zertifikäts aAccept ist Rückgabe Parameter (um zu weiter zu gehen, muss auf true gesetzt werden)

Beispiel

Ausführliches Beispiel mit Formular → siehe Anhänge

Einfaches AWS IoT Beispiel:

CODE

SetPersistent(true),

//******************************************************************************
function ClientPublish(oClient, cTopic, cText)
  Meld('ClientPublish: ' + cTopic + ' / ' + cText),
end,

//******************************************************************************
// Globalen MQTTClient instanziieren
// Der Codeblock muss persistent ausgeführt werden, andernfalls wird der
// MQTT Client am Ende des Codeblocks wieder zerstört und ist dann nicht mehr
// verfügbar/aktiv
//******************************************************************************
function InitMQTTClient(cEndpoint, nPort)
   if empty(gl_MQTTClient) then
      startseq
         gl_MQTTClient := CreateObject('TbeCbMQTTClient',, Application),

         AssignEvent(gl_MQTTClient, "OnPublish", "ClientPublish"),

         gl_MQTTClient.CbHost     := cEndpoint,
         gl_MQTTClient.CbPort     := nPort,
         gl_MQTTCLient.CbProtocol := bmqttpAWSIoT,
         gl_MQTTCLient.CertFile   := '\\..\..\..pem',
         gl_MQTTCLient.KeyFile    := '\\..\..\..private.key',
         gl_MQTTClient.CbActive   := true,

         writeln('MQTTClient initalisiert'),
      onerror
         Log(GetErrorText(GetErrorObj()), llError),
         writeln('Allgemeiner Fehler: ' + GetErrorText(GetErrorObj())),
      stopseq,
   else
      writeln('MQTTClient bereits initalisiert'),
   endif,
end,


//******************************************************************************
// Globale MQTTClient Instanz zerstören
//******************************************************************************
function DestroyMQTTClient()
   if not empty(gl_MQTTClient) then
      DestroyObject(gl_MQTTClient),
      gl_MQTTClient := nil,
      writeln('MQTTClient zerstört'),
   endif,
end,


DestroyMQTTClient(),
InitMQTTClient('127.0.0.1', 1883),

Komplizierteres MQTT Beispiel:

CODE

SetPersistent(true)

//******************************************************************************
function ClientException(oClient, oException)
  meld('ClientException: ' + GetErrorText(oException)),
end,

//******************************************************************************
function ClientBeforeConnect(oClient, lCleanSession, cClientIdentifier)
  writeln('ClientBeforeConnect: ' + cClientIdentifier),
end,

//******************************************************************************
function ClientConnect(oClient, lSession, nReasonCode, cReasonName)
  Meld('ClientConnect: ' + Str(nReasonCode) + ' / ' + cReasonName),

  oClient.CbSubscribe('TestTopic', bmqttqsAtMostOnce),

  Meld(Str(oClient.CbPublish('TestTopic', 'TestMessage', bmqttqsAtMostOnce, false))),
  if oClient.CbPublishAndWait('TestTopic', 'TestMessage mit Wait', bmqttqsAtMostOnce, false, 1000) then
     Meld('Message Verschickt'),
  else
     Meld('Message nicht verschickt'),
  endif,
end,

//******************************************************************************
function ClientDisconnect(oClient, nReasonCode, cReasonName)
  Meld('ClientDisconnect: ' + cReasonName),
end,

//******************************************************************************
function ClientPublish(oClient, cTopic, cText)
  Meld('ClientPublish: ' + cTopic + ' / ' + cText),
end,

//******************************************************************************
function ClientPing(oClient)
   Meld('ClientPing'),
end,

//******************************************************************************
function ClientSubscribe(oClient, nPacketIdentifier)
  Meld('ClientSubscribe: ' + Str(nPacketIdentifier)),
end,

//******************************************************************************
function ClientUnsubscribe(oClient, nPacketIdentifier)
  Meld('ClientUnsubscribe: ' + str(nPacketIdentifier)),
end,

//******************************************************************************
function ClientPubAck(oClient, nPacketIdentifier, nReasonCode, cReasonName)
  meld('ClientPubAck'),
end,

//******************************************************************************
function ClientPubRec(oClient, nPacketIdentifier, nReasonCode, cReasonName)
  meld('ClientPubRec'),
end,

//******************************************************************************
function ClientPubRel(oClient, nPacketIdentifier, nReasonCode, cReasonName)
  meld('ClientPubRel'),
end,

//******************************************************************************
function ClientPubComp(oClient, nPacketIdentifier, nReasonCode, cReasonName)
  meld('ClientPubComp'),
end,

//******************************************************************************
// Globalen MQTTClient instanziieren
// Der Codeblock muss persistent ausgeführt werden, andernfalls wird der
// MQTT Client am Ende des Codeblocks wieder zerstört und ist dann nicht mehr
// verfügbar/aktiv
//******************************************************************************
function InitMQTTClient(cHost, nPort)
   if empty(gl_MQTTClient) then
      startseq
         gl_MQTTClient := CreateObject('TbeCbMQTTClient',, Application),

         AssignEvent(gl_MQTTClient, "OnException", "ClientException"),
         AssignEvent(gl_MQTTClient, "OnBeforeConnect", "ClientBeforeConnect"),
         AssignEvent(gl_MQTTClient, "OnConnect", "ClientConnect"),
         AssignEvent(gl_MQTTClient, "OnDisconnect", "ClientDisconnect"),
         AssignEvent(gl_MQTTClient, "OnPublish", "ClientPublish"),
         AssignEvent(gl_MQTTClient, "OnPing", "ClientPing"),
         AssignEvent(gl_MQTTClient, "OnSubscribe", "ClientSubscribe"),
         AssignEvent(gl_MQTTClient, "OnUnsubscribe", "ClientUnsubscribe"),

         AssignEvent(gl_MQTTClient, "OnPubAck", "ClientPubAck"),
         AssignEvent(gl_MQTTClient, "OnPubRec", "ClientPubRec"),
         AssignEvent(gl_MQTTClient, "OnPubRel", "ClientPubRel"),
         AssignEvent(gl_MQTTClient, "OnPubComp", "ClientPubComp"),

         gl_MQTTClient.CbHost     := cHost,
         gl_MQTTClient.CbPort     := nPort,
         gl_MQTTCLient.CbProtocol := bmqttpMQTT,
         gl_MQTTClient.CbActive   := true,

         writeln('MQTTClient initalisiert'),
      onerror
         Log(GetErrorText(GetErrorObj()), llError),
         writeln('Allgemeiner Fehler: ' + GetErrorText(GetErrorObj())),
      stopseq,
   else
      writeln('MQTTClient bereits initalisiert'),
   endif,
end,

//******************************************************************************
// Globale MQTTClient Instanz zerstören
//******************************************************************************
function DestroyMQTTClient()
   if not empty(gl_MQTTClient) then
      DestroyObject(gl_MQTTClient),
      gl_MQTTClient := nil,
      writeln('MQTTClient zerstört'),
   endif,
end,


DestroyMQTTClient(),
InitMQTTClient('127.0.0.1', 1883),


writeln(gl_MQTTClient.CbSubscribe('TestTopic2', bmqttqsAtMostOnce)),
gl_MQTTClient.CbPublish('TestTopic2', 'Testmessage', bmqttqsAtMostOnce, false),
writeln(gl_MQTTClient.CbUnSubscribe('TestTopic2')),

gl_MQTTClient.CbPing(),

Weitere Verknüpfungen

Service :: AWS MQTT