Revize b8512c30

Re #8630 - Implement protoclient

deltarobot-protoclient/.gitignore

@@ +1 @@
+bin
+.vs
+obj

deltarobot-protoclient/ConsoleApp1.csproj

@@ +1 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net5.0</TargetFramework>
+  </PropertyGroup>
+
+</Project>

deltarobot-protoclient/ConsoleApp1.sln

@@ +1 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31205.134
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApp1", "ConsoleApp1.csproj", "{12586309-0C91-4F56-9BF0-BC726D66FE58}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{12586309-0C91-4F56-9BF0-BC726D66FE58}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{12586309-0C91-4F56-9BF0-BC726D66FE58}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{12586309-0C91-4F56-9BF0-BC726D66FE58}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{12586309-0C91-4F56-9BF0-BC726D66FE58}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {7CC35946-E646-4889-BF96-6E68EA7D7355}
+	EndGlobalSection
+EndGlobal

deltarobot-protoclient/Program.cs

@@ +1 @@
+using System;
+using System.Net.Sockets;
+using System.Threading;
+using System.IO;
+
+namespace ConsoleApp1
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("Hello World!");
+            Singleton client = Singleton.Instance;
+            client.start();
+            while (client.IsRunning)
+            {
+                Console.WriteLine(client.X + " " + client.Y + " " + client.Z);
+                Thread.Sleep(100);
+            }
+        }
+    }
+
+    public sealed class Singleton
+    {
+        private static readonly Singleton instance = new Singleton();
+
+        private const string SERVER = "127.0.0.1";
+        private const Int32 PORT = 4242;
+
+        private const UInt16 PROTOCOL_MAGIC = 0x3001;
+        private const UInt16 PROTOCOL_VERSION = 0x2002;
+        private const UInt16 PING = 0x3004;
+        private const UInt16 EOT = 0xF006;
+        private const UInt16 CURACTPOS = 0x4003;
+
+        private const UInt16 SIZE_8 = 0x0000;
+        private const UInt16 SIZE_16 = 0x1000;
+        private const UInt16 SIZE_32 = 0x2000;
+        private const UInt16 SIZE_64 = 0x3000;
+        private const UInt16 SIZE_128 = 0x4000;
+        private const UInt16 SIZE_VARIABLE = 0xF000;
+
+        private const UInt64 PROTOCOL_MAGIC_VALUE = 0x44656C7461525672; // `DeltaRVr` in ASCII
+        private const UInt32 PROTOCOL_VERSION_VALUE = 1;
+
+        private TcpClient client;
+        private NetworkStream stream;
+        private Boolean isRunning;
+        private Thread t;
+
+        private Single x;
+        private Single y;
+        private Single z;
+        private string eotMsg;
+
+        static Singleton()
+        {
+        }
+
+        private Singleton()
+        {
+        }
+
+        public static Singleton Instance
+        {
+            get
+            {
+                return instance;
+            }
+        }
+
+        public string EotMsg
+        {
+            get
+            {
+                lock (this)
+                {
+                    return eotMsg;
+                }
+            }
+            set
+            {
+                lock (this)
+                {
+                    eotMsg = value;
+                }
+            }
+        }
+
+        public Single X
+        {
+            get
+            {
+                lock (this)
+                {
+                    return x;
+                }
+            }
+            set
+            {
+                lock (this)
+                {
+                    x = value;
+                }
+            }
+        }
+        public Single Y
+        {
+            get
+            {
+                lock (this)
+                {
+                    return y;
+                }
+            }
+            set
+            {
+                lock (this)
+                {
+                    y = value;
+                }
+            }
+        }
+
+        public Single Z
+        {
+            get
+            {
+                lock (this)
+                {
+                    return z;
+                }
+            }
+            set
+            {
+                lock(this)
+                {
+                    z = value;
+                }
+            }
+        }
+
+        public Boolean IsRunning
+        {
+            get
+            {
+                lock(this)
+                {
+                    return isRunning;
+                }
+            }
+            private set
+            {
+                lock (this)
+                {
+                    isRunning = value;
+                }
+            }
+        }
+
+        private void connect()
+        {
+            try
+            {
+                client = new TcpClient(SERVER, PORT);
+                stream = client.GetStream();
+                BinaryReader reader = new BinaryReader(stream);
+                UInt16 sizeIdentifier = 0;
+                UInt16 messageIdentifier = 0;
+                
+
+                try
+                {
+                    while (IsRunning)
+                    {
+                        messageIdentifier = reader.ReadUInt16();
+                        //Console.WriteLine(String.Format("{0:X}", messageIdentifier));
+                        switch (messageIdentifier)
+                        {
+                            case PROTOCOL_MAGIC:
+                                protocolMagicProcessing(reader);
+                                break;
+                            case PROTOCOL_VERSION:
+                                protocolVersionProcessing(reader);
+                                break;
+                            case PING:
+                                pingProcessing(reader);
+                                break;
+                            case EOT:
+                                eotProcessing(reader);
+                                break;
+                            case CURACTPOS:
+                                currentActuatorPositionProcessing(reader);
+                                break;
+                            default: //client tuto zpravu nezna
+                                sizeIdentifier = (UInt16)(messageIdentifier & 0xF000);
+                                switch (sizeIdentifier)
+                                {
+                                    case SIZE_8:
+                                        skip8(reader);
+                                        break;
+                                    case SIZE_16:
+                                        skip16(reader);
+                                        break;
+                                    case SIZE_32:
+                                        skip32(reader);
+                                        break;
+                                    case SIZE_64:
+                                        skip64(reader);
+                                        break;
+                                    case SIZE_128:
+                                        skip128(reader);
+                                        break;
+                                    case SIZE_VARIABLE:
+                                        skipV(reader);
+                                        break;
+                                }
+                                break;  
+                        }
+                    }
+                }
+                finally
+                {
+                    stream.Close();
+                    client.Close();
+                }
+            }
+            catch(Exception)
+            {
+                Console.WriteLine("failed to connect");
+            }
+            
+        }
+
+        
+
+        private void skip8(BinaryReader reader)
+        {
+            reader.ReadByte();
+        }
+
+        private void skip16(BinaryReader reader)
+        {
+            reader.ReadUInt16();
+        }
+
+        private void skip32(BinaryReader reader)
+        {
+            reader.ReadUInt32();
+        }
+
+        private void skip64(BinaryReader reader)
+        {
+            reader.ReadUInt64();
+        }
+
+        private void skip128(BinaryReader reader)
+        {
+            reader.ReadUInt64();
+            reader.ReadUInt64();
+        }
+
+        private void skipV(BinaryReader reader)
+        {
+            UInt32 numberOfBytes = reader.ReadUInt32();
+            reader.ReadBytes((int)numberOfBytes);
+        }
+
+        private void currentActuatorPositionProcessing(BinaryReader reader)
+        {
+            //Console.WriteLine("got position");
+            lock(this)
+            {
+                X = reader.ReadSingle();
+                Y = reader.ReadSingle();
+                Z = reader.ReadSingle();
+            }
+            reader.ReadSingle();
+        }
+
+        private void eotProcessing(BinaryReader reader)
+        {
+            UInt32 numberOfBytes = reader.ReadUInt32();
+            Byte[] buffer = reader.ReadBytes((int)numberOfBytes);
+            EotMsg = System.Text.Encoding.ASCII.GetString(buffer);
+            IsRunning = false;
+        }
+
+        private void protocolMagicProcessing(BinaryReader reader)
+        {
+            UInt64 value = reader.ReadUInt64();
+            if(value != PROTOCOL_MAGIC_VALUE)
+            {
+                IsRunning = false; // mozna vyhodit vyjimku
+            }
+        }
+
+        private void protocolVersionProcessing(BinaryReader reader)
+        {
+            UInt32 value = reader.ReadUInt32();
+            if(value != PROTOCOL_VERSION_VALUE)
+            {
+                IsRunning = false; // mozna vyhodit vyjimku
+            }
+        }
+
+        private void pingProcessing(BinaryReader reader)
+        {
+            UInt64 pingValue = reader.ReadUInt64();
+
+            // send pong
+            Byte[] buffer = BitConverter.GetBytes(pingValue);
+            stream.Write(buffer, 0, buffer.Length);
+        }
+
+        public void start()
+        {
+            t = new Thread(new ThreadStart(connect));
+            IsRunning = true;
+            t.Start();
+            
+        }
+
+        public void stop()
+        {
+            IsRunning = false;
+            t.Join();
+        }
+
+    }
+}