Revize a9ef8967

Re #8733 - Refactor protoclient into Unity + server fix

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

deltarobot-vr/.gitignore

@@ -26 +26 @@
 # Visual Studio cache directory
 .vs/
 
+# Rider project directory
+.idea/
+
 # Gradle cache directory
 .gradle/
 

deltarobot-vr/Assets/CubeMaterial.mat

@@ +1 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: CubeMaterial
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0, g: 0.61987686, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+  m_BuildTextureStacks: []

deltarobot-vr/Assets/CubeMaterial.mat.meta

@@ +1 @@
+fileFormatVersion: 2
+guid: 62f2cab33e7d65346be49f4912bdd9ee
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

deltarobot-vr/Assets/CubeScript.cs

@@ +1 @@
+using DeltaRobotVr;
+using UnityEngine;
+
+public class CubeScript : MonoBehaviour
+{
+    private const float PositionScale = 0.001f;
+    private const float LerpParam = 0.5f;
+
+    private Transform _transform;
+    
+    void Start()
+    {
+        _transform = GetComponent<Transform>();
+        
+        Client.Instance.Start();
+    }
+    
+    void Update()
+    {
+        if (Client.Instance.IsConnected)
+        {
+            var serverPosition = Client.Instance.ActuatorPosition;
+            var newPosition = new Vector3(serverPosition.X, serverPosition.Y, -serverPosition.Z) * PositionScale;
+            _transform.position = Vector3.Lerp(_transform.position, newPosition, LerpParam);
+        }
+    }
+
+    private void OnDestroy()
+    {
+        Client.Instance.Stop();
+    }
+}

deltarobot-vr/Assets/CubeScript.cs.meta

@@ +1 @@
+fileFormatVersion: 2
+guid: cfafba4e0e8b6e0adb6dda9dbc5076f8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

deltarobot-vr/Assets/DeltaRobotVr.meta

@@ +1 @@
+fileFormatVersion: 2
+guid: 86e3e33271dc4393bf31f3412d95575b
+timeCreated: 1620467739

deltarobot-vr/Assets/DeltaRobotVr/Client.cs

@@ +1 @@
+using System;
+using System.Net.Sockets;
+using System.Threading;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace DeltaRobotVr
+{
+    public readonly struct Single3
+    {
+        public float X { get; }
+        public float Y { get; }
+        public float Z { get; }
+
+        public Single3(float x, float y, float z)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+        }
+
+        public override string ToString() => "Single3[ " + X + " " + Y + " " + Z + " ]";
+    }
+
+    public sealed class Client
+    {
+        // singleton instance
+        public static readonly Client Instance = new Client();
+
+        // default server
+        private const string DefaultServer = "127.0.0.1";
+        private const int DefaultPort = 4242;
+
+        // protocol constants
+        private const UInt16 ProtocolMagicId = 0x3001;
+        private const UInt16 ProtocolVersionId = 0x2002;
+        private const UInt16 PingId = 0x3004;
+        private const UInt16 EotId = 0xF006;
+        private const UInt16 CurrentActuatorPositionId = 0x4003;
+
+        private const UInt16 Size8 = 0x0000;
+        private const UInt16 Size16 = 0x1000;
+        private const UInt16 Size32 = 0x2000;
+        private const UInt16 Size64 = 0x3000;
+        private const UInt16 Size128 = 0x4000;
+        private const UInt16 SizeVariable = 0xF000;
+        
+        private static readonly byte[] ProtocolMagicValue = Encoding.ASCII.GetBytes("DeltaRVr");
+        private const UInt32 ProtocolVersionValue = 1;
+
+        
+        private Thread _thread;
+        
+        private readonly object _isRunningLock = new object();
+        private bool _isRunning;
+
+        private readonly object _actuatorPositionLock = new object();
+        private Single3 _actuatorPosition;
+
+        private volatile bool _isConnected;
+        private volatile string _eotMsg;
+
+        static Client()
+        {
+        }
+
+        private Client()
+        {
+        }
+
+        public void Start()
+        {
+            _thread = new Thread(ThreadProcedure);
+            IsRunning = true;
+            _thread.Start();
+        }
+
+        public void Stop()
+        {
+            IsRunning = false;
+            _thread.Join();
+        }
+
+        public string EotMsg
+        {
+            get => _eotMsg;
+            private set => _eotMsg = value;
+        }
+
+        public bool IsConnected
+        {
+            get => _isConnected;
+            private set => _isConnected = value;
+        }
+
+        public Single3 ActuatorPosition
+        {
+            get
+            {
+                lock (_actuatorPositionLock)
+                {
+                    return _actuatorPosition;
+                }
+            }
+            private set
+            {
+                lock (_actuatorPositionLock)
+                {
+                    _actuatorPosition = value;
+                }
+            } 
+        }
+
+        public bool IsRunning
+        {
+            get {
+                lock (_isRunningLock)
+                {
+                    return _isRunning;
+                }
+            }
+            private set
+            {
+                lock (_isRunningLock)
+                {
+                    _isRunning = value;
+                }
+            }
+        }
+
+        private void ThreadProcedure()
+        {
+            try
+            {
+                var client = new TcpClient(DefaultServer, DefaultPort);
+                var stream = client.GetStream();
+                BinaryReader reader = new BinaryReader(stream);
+                BinaryWriter writer = new BinaryWriter(stream);
+                IsConnected = true;
+                
+                writer.Write(ProtocolMagicId);
+                writer.Write(ProtocolMagicValue);
+                writer.Write(ProtocolVersionId);
+                writer.Write(ProtocolVersionValue);
+                
+                try
+                {
+                    while (IsRunning && IsConnected)
+                    {
+                        var messageIdentifier = reader.ReadUInt16();
+                        switch (messageIdentifier)
+                        {
+                            case ProtocolMagicId:
+                                ProcessProtocolMagic(reader);
+                                break;
+                            case ProtocolVersionId:
+                                ProcessProtocolVersion(reader);
+                                break;
+                            case PingId:
+                                ProcessPing(reader, writer);
+                                break;
+                            case EotId:
+                                ProcessEot(reader);
+                                break;
+                            case CurrentActuatorPositionId:
+                                ProcessCurrentActuatorPosition(reader);
+                                break;
+                            default: //client tuto zpravu nezna
+                                var sizeIdentifier = (UInt16) (messageIdentifier & 0xF000);
+                                switch (sizeIdentifier)
+                                {
+                                    case Size8:
+                                        Skip8(reader);
+                                        break;
+                                    case Size16:
+                                        Skip16(reader);
+                                        break;
+                                    case Size32:
+                                        Skip32(reader);
+                                        break;
+                                    case Size64:
+                                        Skip64(reader);
+                                        break;
+                                    case Size128:
+                                        Skip128(reader);
+                                        break;
+                                    case SizeVariable:
+                                        SkipVariableLength(reader);
+                                        break;
+                                }
+
+                                break;
+                        }
+                    }
+                }
+                finally
+                {
+                    stream.Close();
+                    client.Close();
+                    IsConnected = true;
+                }
+            }
+            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 SkipVariableLength(BinaryReader reader)
+        {
+            UInt32 numberOfBytes = reader.ReadUInt32();
+            reader.ReadBytes((int) numberOfBytes);
+        }
+
+        private void ProcessCurrentActuatorPosition(BinaryReader reader)
+        {
+            var x = reader.ReadSingle();
+            var y = reader.ReadSingle();
+            var z = reader.ReadSingle();
+            reader.ReadSingle(); // skip unused
+
+            ActuatorPosition = new Single3(x, y, z);
+        }
+
+        private void ProcessEot(BinaryReader reader)
+        {
+            UInt32 numberOfBytes = reader.ReadUInt32();
+            Byte[] buffer = reader.ReadBytes((int) numberOfBytes);
+            EotMsg = Encoding.ASCII.GetString(buffer);
+            IsConnected = false;
+        }
+
+        private void ProcessProtocolMagic(BinaryReader reader)
+        {
+            byte[] value = reader.ReadBytes(8);
+            if (!value.SequenceEqual(ProtocolMagicValue))
+            {
+                IsConnected = false; // mozna vyhodit vyjimku
+            }
+        }
+
+        private void ProcessProtocolVersion(BinaryReader reader)
+        {
+            UInt32 value = reader.ReadUInt32();
+            if (value != ProtocolVersionValue)
+            {
+                IsConnected = false; // mozna vyhodit vyjimku
+            }
+        }
+
+        private void ProcessPing(BinaryReader reader, BinaryWriter writer)
+        {
+            UInt64 pingValue = reader.ReadUInt64();
+            writer.Write(pingValue);
+        }
+    }
+}

deltarobot-vr/Assets/DeltaRobotVr/Client.cs.meta

@@ +1 @@
+fileFormatVersion: 2
+guid: 141220c40b1654d5e808231e9ef350e9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

deltarobot-vr/Assets/Scenes/SampleScene.unity

@@ -325 +325 @@
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 599916901}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalPosition: {x: 0, y: -4, z: 0}
   m_LocalScale: {x: 10, y: 10, z: 10}
   m_Children: []
   m_Father: {fileID: 0}
@@ -501 +501 @@
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 963194225}
-  m_LocalRotation: {x: 0.18897976, y: 0.30442163, z: -0.061756246, w: 0.9315581}
-  m_LocalPosition: {x: -1.836, y: 0.39100003, z: -1.539}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 1045848416}
   m_RootOrder: 0
-  m_LocalEulerAnglesHint: {x: 22.935, y: 36.194, z: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!114 &963194229
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -599 +599 @@
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 1725982592}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalPosition: {x: 0, y: -1, z: -15}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children:
   - {fileID: 1045848416}
@@ -745 +745 @@
   - component: {fileID: 2021860139}
   - component: {fileID: 2021860138}
   - component: {fileID: 2021860137}
+  - component: {fileID: 2021860141}
   m_Layer: 0
   m_Name: MyTestCube
   m_TagString: Untagged
@@ -784 +785 @@
   m_RenderingLayerMask: 1
   m_RendererPriority: 0
   m_Materials:
-  - {fileID: 10303, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 2100000, guid: 62f2cab33e7d65346be49f4912bdd9ee, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
@@ -822 +823 @@
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 2021860136}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0.506, z: 0}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
   m_RootOrder: 3
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &2021860141
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 2021860136}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cfafba4e0e8b6e0adb6dda9dbc5076f8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
 --- !u!1001 &2038249430
 PrefabInstance:
   m_ObjectHideFlags: 0

deltarobot/curvedataserver.cpp

@@ -138 +138 @@
     message[0] = 0x02;
     message[1] = 0x20;
 
-    message[5] = 0x01;
+    message[2] = 0x01;
 
     socket->write(message);