implemented PublisherSubscriber Facade and MqttCommunication implementing the facade

ADIS_Csharp/RobotLib/Communication/IPublisherSubscriber.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace RobotLib.Communication
+{
+    internal interface IPublisherSubscriber
+    {
+        /// <summary>
+        /// New message to a subscribed topic arrived.
+        /// </summary>
+        event EventHandler<SubscribedMsgArrivedEventArgs> NewMessageArrived;
+
+        /// <summary>
+        /// Subscribe to a topic.
+        /// </summary>
+        /// <param name="topic">The topic to subscribe to.</param>
+        void Subscribe(string topic);
+
+        /// <summary>
+        /// Publish message to a topic.
+        /// </summary>
+        /// <param name="topic">The topic where to publish the data to.</param>
+        /// <param name="message">Data to publish.</param>
+        void Publish(string topic, string message);
+    }
+}

ADIS_Csharp/RobotLib/Communication/MqttPublisherSubscriber.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Text;
+using uPLibrary.Networking.M2Mqtt;
+using uPLibrary.Networking.M2Mqtt.Messages;
+
+namespace RobotLib.Communication
+{
+    internal class MqttPublisherSubscriber : IPublisherSubscriber
+    {
+        private MqttClient client;
+        private static readonly NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
+        private object clientLock = new object();
+
+        /// <summary>
+        /// Singleton pattern.
+        /// </summary>
+        public static MqttPublisherSubscriber Instance { get; } = new MqttPublisherSubscriber();
+
+        /// <summary>
+        /// Event to catch for subscribed messages. Topic needs to be checked, since other classes might also subscribe to topics.
+        /// </summary>
+        public event EventHandler<SubscribedMsgArrivedEventArgs> NewMessageArrived;
+
+        /// <summary>
+        /// Connection state to the broker.
+        /// </summary>
+        public bool IsConnected { get ; private set; }
+
+        private MqttPublisherSubscriber() 
+        { }
+
+        public bool Connect(string brokerIp)
+        {
+            bool success = false;
+            lock (clientLock)
+            {
+                // protect from multiple connects
+                if (IsConnected) return true;
+                IsConnected = true;
+
+                log.Info($"Connecting to Mqtt Broker.");
+                // creating an MqttClient object
+                client = new MqttClient(brokerIp);
+                // register to message received and disconnect
+                client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived;
+                client.ConnectionClosed += Client_ConnectionClosed;
+                // generate a clientID and connect to Broker
+                string clientId = Guid.NewGuid().ToString();
+                var result = client.Connect(clientId);
+                success = result == 0 ? true : false;
+                log.Info($"Connecting done. Success = {success}");
+            }
+            return success;
+        }
+
+        public void Disconnect()
+        {
+            lock (clientLock)
+            {
+                if (IsConnected == false) return;
+
+                client.Disconnect();
+                log.Info($"Disconnect was called.");
+                IsConnected = false;
+            }
+        }
+
+        private void Client_ConnectionClosed(object sender, EventArgs e)
+        {
+            lock (clientLock)
+            {
+                IsConnected = false;
+                log.Info($"Connection was closed.");
+            }
+        }
+
+        private void Client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e)
+        {
+            lock (clientLock)
+            {
+                SubscribedMsgArrivedEventArgs eventArgs = new(e.Topic, Encoding.UTF8.GetString(e.Message));
+                log.Trace($"Message received on topic {eventArgs.Topic}: {eventArgs.Message}");
+                NewMessageArrived?.Invoke(this, eventArgs);
+            }
+        }
+
+        public void Publish(string topic, string message)
+        {
+            lock (clientLock)
+            {
+                var result = client.Publish(topic, Encoding.ASCII.GetBytes(message));
+                log.Trace($"Published to topic '{topic}'. Message = {message}", result == 0 ? true : false);
+            }
+        }
+
+        public void Subscribe(string topic)
+        {
+            lock (clientLock)
+            {
+                var result = client.Subscribe(new string[] { topic }, new byte[] { MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE });
+                log.Info($"Subscribed to topic '{topic}'. Success = %s", result == 0 ? true : false);
+            }
+        }
+    }
+}

ADIS_Csharp/RobotLib/Communication/SubscribedMsgArrivedEventArgs.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace RobotLib.Communication
+{
+    public class SubscribedMsgArrivedEventArgs : EventArgs
+    {
+        public string Topic { get; }
+        public string Message { get;  }
+
+        public SubscribedMsgArrivedEventArgs(string topic, string message)
+        {
+            Topic = topic;
+            Message = data;
+        }
+    }
+}

ADIS_Csharp/RobotLib/RobotLib.csproj

@@ -1,10 +1,11 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="M2MqttDotnetCore" Version="1.1.0" />
     <PackageReference Include="NLog" Version="5.1.0" />
   </ItemGroup>