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

Eigenschaft	Beschreibung
CbActive:L	Startet den MQTT Client und stellt eine Verbindung zum eingestellten Host her CbProtocol muss gesetzt sein bevor CbActive gesetzt wird!
CbAdvancedHeartbeatInterval:N	>0 sendet asynchron alle x Sekunden einen Ping an den MQTT Broker. Wird auch ausgeführt, wenn komplexe / lange Prozesse im Hauptthread laufen.
CbBasePath:C	Pfad der zusätzlich zum Host verwendet wird (z.B. ‘/mqtt’). Aktuell nur für WebSocket (bmqttpWebsocket) Verbidungen
CbCertFile:C	Nur in Verbindung mit bmqttpAWSIOT Pfad zum ` .pem ` Datei
CbCustomAuthentication_Enabled:L	Nur in Verbindung mit bmqttpAWSIOT benutzerdefinierten Authentifizierung aktivieren
CbCustomAuthentication_Headers:C	Nur in Verbindung mit bmqttpAWSIOT benutzerdefinierten Header. Werte müssen mit CRLF getrennt sein
CbCustomAuthentication_Parameters:C	Nur in Verbindung mit bmqttpAWSIOT Abfrageparameter die an den Server übergeben werden
CbCustomAuthentication_UseWebSockets:L	Nur in Verbindung mit bmqttpAWSIOT Verbindung über Websocket oder TCP
CbHeartBeatInterval:N	>0 sendet alle x Sekunden einen Ping an den MQTT Server/Broker
CbHost:C	MQTT Server/Broker/AWS IoT Endpoint
CbKeyFile:C	Nur in Verbindung mit bmqttpAWSIOT Pfad zum ` .key ` Privaten-Schlüssel Datei
CbPassword:C	Passwort für Authentifizierung Bemerkung: momentan nicht für AWS IoT
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
Name:C
Tag:N

Methoden

Methode	Beschreibung
CbPing()	Ping an MQTT Server/Broker senden nicht vorhanden für AWS IoT
CbSubscribe(aTopic:C, aQoS:N):N
CbUnSubscribe(aTopic:C):N
CbPublish(aTopic:C, aText:C, aQoS:N, aRetain:L):N	cTopic:C cText:C nQoS:N lRetain:L
CbPublishAndWait(aTopic:C, aText:C, aQoS:N, aRetain:L, aTimeout:N):L	cTopic:C cText:C nQoS:N lRetain:L nTimeout:N

Beispiel

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),

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(),

|lIsResident:P1, gl_MQTT:_U:=nil, oOwner|

function MyClient_OnPublish(Client, Topic, Text)
   log('MyClient Publish - ' + Topic + ': ' + Text, llFatal),
end,

function MyClient_OnConnect()
   log('MyClient Connect', llFatal),
end,

function MyClient_OnDisconnect()
   log('MyClient Disconnect', llFatal),
end,

function MyClient_OnPing()
   log('MyClient Ping', llFatal),
end,

if not Empty(gl_MQTT) then
    DestroyObject(gl_MQTT),
endif,

if not Empty(lIsResident) and lIsResident then
   writeln('Resident'),
   oOwner := nil,
else
   if LoadedModule <> belmbeas then
      lIsResident := True,
      SetPersistent(True),
   endif,

   oOwner := Application,
endif,

gl_MQTT                             := CreateObject('TbeCbMQTTClient',,oOwner,,true),
gl_MQTT.CbHeartBeatInterval         := 600,
gl_MQTT.CbAdvancedHeartBeatInterval := 120,
gl_MQTT.CbHost                      := "127.0.0.1",
gl_MQTT.CbPort                      := 1883,
gl_MQTT.CbProtocol                  := bmqttpMQTT,
gl_MQTT.CbActive                    := true,
if lIsResident then
   AssignEvent(gl_MQTT, 'OnPublish', 'MyClient_OnPublish'),
   AssignEvent(gl_MQTT, 'OnConnect', 'MyClient_OnConnect'),
   AssignEvent(gl_MQTT, 'OnDisconnect', 'MyClient_OnDisconnect'),
   AssignEvent(gl_MQTT, 'OnPing', 'MyClient_OnPing'),
endif,

CallResident('My_MQTT_Client', true),