aswi2021virtual-surreality-gitlab/deltarobot-protoclient/Program.cs @ b8512c30

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();
        }

    }
}