update

Common/DroneData.cs

@@ -1,42 +1,67 @@
+using System.Runtime.InteropServices;
+
 namespace DroneData
 {
-  enum StructType : ulong
+  public enum DataMode : ushort
   {
-    // Output
+    None = 0, Response = 1, Request = 2
-    DataIMU = 1, DataPos = 2, 
-
-    // Input
-    DataMotor4 = 1001, DataMotor6 = 1002
   };
 
-  public struct DataInfo
+  public enum DataType : ushort
   { 
-    StructType Type;
+    None = 0, Head = 1,
-    ulong Size;
+
+    // Output
+    DataIMU = 1001, DataPos = 1002, 
+
+    // Input
+    DataMotor4 = 2001, DataMotor6 = 2002
+  };
+
+  public struct DataHead
+  {
+    public int Size;
+
+    public DataMode Mode;
+    public DataType Type;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataHead));
   }
 
-  public struct DataXYZ { float X, Y, Z; }
+  public struct XYZ { public float X, Y, Z; }
 
   public struct DataIMU
   {
-    DataXYZ Acc, Gyr, Mag;
+    public DataHead Head;
+    public XYZ Acc, Gyr, Mag;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataIMU));
   }
 
   public struct DataPos
   {
-    DataXYZ Local; // Ëîêàëüíûå êîîðäèíàòû
+    public DataHead Head;
-    float LiDAR; // Äàò÷èê ïîñàäêè
+    public XYZ Local; // Ëîêàëüíûå êîîðäèíàòû
+    public float LiDAR; // Äàò÷èê ïîñàäêè
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataPos));
   }
 
   public struct DataMotor4
   {
-    ulong Count;
+    public DataHead Head;
-    float M1, M2, M3, M4;
+    public ulong Count;
+    public float UL, UR, DL, DR;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataMotor4));
   }
 
   public struct DataMotor6
   {
-    ulong Count;
+    public DataHead Head;
-    float M1, M2, M3, M4, M5, M6;
+    public ulong Count;
+    public float UL, UR, LL, RR, DL, DR;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataMotor6));
   }
 }

DroneClient/Drone.cs

@@ -1,21 +1,17 @@
-using System.Runtime.InteropServices;
+using System.Drawing;
+using System.Runtime.InteropServices;
 
 namespace DroneClient
 {
   internal class Drone
   {
-    public struct DataOut
+
-    {
     public float AccX, AccY, AccZ;
     public float GyrX, GyrY, GyrZ;
     public float PosX, PosY;
     public float LaserRange;
-    }
 
-    public struct DataIn
-    {
     public float MotorUL, MotorUR, MotorDL, MotorDR;
-    }
 
     public static byte[] getBytes(object data)
     {
@@ -58,5 +54,165 @@ namespace DroneClient
       return mem;
     }
 
+    private byte[] SendDataMotor4()
+    {
+      DroneData.DataMotor4 mot4 = new DroneData.DataMotor4();
+
+      mot4.Head.Size = Marshal.SizeOf(typeof(DroneData.DataMotor4));
+      mot4.Head.Mode = DroneData.DataMode.Response;
+      mot4.Head.Type = DroneData.DataType.DataMotor4;
+
+      mot4.UL = MotorUL;
+      mot4.UR = MotorUR;
+      mot4.DL = MotorDL;
+      mot4.DR = MotorDR;
+
+      return getBytes(mot4);
+    }
+
+    private byte[]? RecvDataIMU(byte[] data)
+    {
+      DroneData.DataIMU imu = (DroneData.DataIMU)fromBytes(data, typeof(DroneData.DataIMU));
+
+      AccX = imu.Acc.X; AccY = imu.Acc.Y; AccZ = imu.Acc.Z;
+      GyrX = imu.Gyr.X; GyrY = imu.Gyr.Y; GyrZ = imu.Gyr.Z;
+
+      return new byte[0];
+    }
+
+    private byte[]? RecvDataPos(byte[] data)
+    {
+      DroneData.DataPos pos = (DroneData.DataPos)fromBytes(data, typeof(DroneData.DataPos));
+
+      PosX = pos.Local.X; PosY = pos.Local.Y;
+      LaserRange = pos.LiDAR;
+
+      return new byte[0];
+    }
+
+    private byte[]? ClientRequestResponse(DroneData.DataHead head, byte[] body)
+    {
+      byte[] zero = new byte[0];
+
+      switch (head.Type)
+      {
+        case DroneData.DataType.DataIMU:
+          {
+            if (head.Mode == DroneData.DataMode.Request)
+            {
+              // Запрос данных
+              // ... //
+              //
+              return zero;
+            }
+            else
+            {
+              // Пришли данные
+              return RecvDataIMU(body);
+            }
+          }
+
+        case DroneData.DataType.DataPos:
+          {
+            if (head.Mode == DroneData.DataMode.Request)
+            {
+              // Запрос данных
+              // ... //
+              //
+              return zero;
+            }
+            else
+            {
+              // Пришли данные
+              return RecvDataPos(body);
+            }
+          }
+
+        case DroneData.DataType.DataMotor4:
+          {
+            if (head.Mode == DroneData.DataMode.Request)
+            {
+              // Запрос данных
+              return SendDataMotor4();
+            }
+            else
+            {
+              // Пришли данные
+              // ... //
+              //
+              return zero;
+            }
+          }
+      }
+
+      return zero;
+    }
+
+    private const int DroneStreamCount = 512;
+    private byte[] DroneStreamData = new byte[DroneStreamCount];
+    private int DroneStreamIndex = 0;
+    private DroneData.DataHead DroneStreamHead = new DroneData.DataHead() { Mode = DroneData.DataMode.None, Size = 0, Type = DroneData.DataType.None };
+
+    public List<byte[]?>? DataStream(byte[]? data, int size)
+    {
+      List<byte[]?> ret = new List<byte[]?>();
+
+      if (data == null) return ret; // Последовательность не сформирована, ждать данных
+
+      if (size + DroneStreamIndex > DroneStreamCount) return null; // Ошибка переполнения, поток сломан (конец)
+
+      Array.Copy(data, 0, DroneStreamData, DroneStreamIndex, size);
+      DroneStreamIndex += size;
+
+      while (true)
+      {
+        if (DroneStreamHead.Size == 0) // Заголовок ещё не получен
+        {
+          if (DroneStreamIndex < DroneData.DataHead.StrLen) return ret; // Нечего слать
+          DroneStreamHead = (DroneData.DataHead)fromBytes(DroneStreamData, typeof(DroneData.DataHead));
+        }
+
+        if (DroneStreamHead.Size > DroneStreamIndex) break; // Пакет ещё не полный
+
+        byte[] body = new byte[DroneStreamHead.Size];
+
+        Array.Copy(DroneStreamData, 0, body, 0, DroneStreamHead.Size);
+
+        int shift = DroneStreamHead.Size;
+
+        DroneStreamIndex -= shift;
+        Array.Copy(DroneStreamData, shift, DroneStreamData, 0, DroneStreamIndex); // Сдвигаем массив влево, убрав использованные данные
+
+        DroneStreamHead.Size = 0; // Отменяем прошлый заголовок
+
+        ret.Add(ClientRequestResponse(DroneStreamHead, body));
+      }
+
+      return ret;
+    }
+
+    public byte[] SendReqest()
+    {
+      DroneData.DataHead imu = new DroneData.DataHead();
+      imu.Size = DroneData.DataHead.StrLen;
+      imu.Mode = DroneData.DataMode.Request;
+      imu.Type = DroneData.DataType.DataIMU;
+
+      DroneData.DataHead pos = new DroneData.DataHead();
+      pos.Size = DroneData.DataHead.StrLen;
+      pos.Mode = DroneData.DataMode.Request;
+      pos.Type = DroneData.DataType.DataPos;
+
+      byte[] si = getBytes(imu);
+      byte[] sp = getBytes(pos);
+      byte[] sm = SendDataMotor4();
+
+      byte[] send = new byte[si.Length + sp.Length + sm.Length];
+      si.CopyTo(send, 0);
+      sp.CopyTo(send, si.Length);
+      sm.CopyTo(send, si.Length + sp.Length);
+
+      return send;
+    }
   }
 }

DroneClient/DroneData.cs

@@ -0,0 +1,67 @@
+using System.Runtime.InteropServices;
+
+namespace DroneData
+{
+  public enum DataMode : ushort
+  {
+    None = 0, Response = 1, Request = 2
+  };
+
+  public enum DataType : ushort
+  { 
+    None = 0, Head = 1,
+
+    // Output
+    DataIMU = 1001, DataPos = 1002, 
+
+    // Input
+    DataMotor4 = 2001, DataMotor6 = 2002
+  };
+
+  public struct DataHead
+  {
+    public int Size;
+
+    public DataMode Mode;
+    public DataType Type;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataHead));
+  }
+
+  public struct XYZ { public float X, Y, Z; }
+
+  public struct DataIMU
+  {
+    public DataHead Head;
+    public XYZ Acc, Gyr, Mag;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataIMU));
+  }
+
+  public struct DataPos
+  {
+    public DataHead Head;
+    public XYZ Local; // Ëîêàëüíûå êîîðäèíàòû
+    public float LiDAR; // Äàò÷èê ïîñàäêè
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataPos));
+  }
+
+  public struct DataMotor4
+  {
+    public DataHead Head;
+    public ulong Count;
+    public float UL, UR, DL, DR;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataMotor4));
+  }
+
+  public struct DataMotor6
+  {
+    public DataHead Head;
+    public ulong Count;
+    public float UL, UR, LL, RR, DL, DR;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataMotor6));
+  }
+}

DroneClient/FormMain.cs

@@ -20,6 +20,8 @@ namespace DroneSimulator
       ConnectData data = (ConnectData)o;
 
       if (!data.Connect)
+      {
+        try
         {
           Invoke((MethodInvoker)delegate
           {
@@ -27,28 +29,29 @@ namespace DroneSimulator
             button_Connect.BackColor = Color.Transparent;
             MessageBox.Show("Connection closed");
           });
+        }
+        catch { }
 
         return;
       }
-
-      byte[] send = Drone.getBytes(sendDrone);
-
-      data.Server.Send(send);
     }
 
-    Drone.DataIn sendDrone;
+    Drone dataDrone = new Drone();
-
-    Drone.DataOut recvDrone;
 
     private void ReceiveCallback(object o)
     {
       ReceiveData data = (ReceiveData)o;
 
-      recvDrone = (Drone.DataOut)Drone.fromBytes(data.Buffer, typeof(Drone.DataOut));
+      List<byte[]?>? send = dataDrone.DataStream(data.Buffer, data.Size);
 
-      byte[] send = Drone.getBytes(sendDrone);
+      if (send == null) return;
-
+      try
-      try { data.Server.Send(send); }
+      {
+        foreach (byte[]? b in send)
+        {
+          if (b != null) data.Server?.Send(b);
+        }
+      }
       catch { }
     }
 
@@ -88,17 +91,19 @@ namespace DroneSimulator
 
     private void timer_Test_Tick(object sender, EventArgs e)
     {
-      label_Acc_X.Text = recvDrone.AccX.ToString();
+      label_Acc_X.Text = dataDrone.AccX.ToString();
-      label_Acc_Y.Text = recvDrone.AccY.ToString();
+      label_Acc_Y.Text = dataDrone.AccY.ToString();
-      label_Acc_Z.Text = recvDrone.AccZ.ToString();
+      label_Acc_Z.Text = dataDrone.AccZ.ToString();
 
-      label_Gyr_X.Text = recvDrone.GyrX.ToString();
+      label_Gyr_X.Text = dataDrone.GyrX.ToString();
-      label_Gyr_Y.Text = recvDrone.GyrY.ToString();
+      label_Gyr_Y.Text = dataDrone.GyrY.ToString();
-      label_Gyr_Z.Text = recvDrone.GyrZ.ToString();
+      label_Gyr_Z.Text = dataDrone.GyrZ.ToString();
 
-      label_Pos_X.Text = recvDrone.PosX.ToString();
+      label_Pos_X.Text = dataDrone.PosX.ToString();
-      label_Pos_Y.Text = recvDrone.PosY.ToString();
+      label_Pos_Y.Text = dataDrone.PosY.ToString();
-      label_Pos_L.Text = recvDrone.LaserRange.ToString();
+      label_Pos_L.Text = dataDrone.LaserRange.ToString();
+
+      netClient.SendData(dataDrone.SendReqest());
     }
 
     private void trackBar_Power_Scroll(object sender, EventArgs e)
@@ -107,7 +112,7 @@ namespace DroneSimulator
 
       label_Pow.Text = pow.ToString();
 
-      sendDrone.MotorUL = sendDrone.MotorUR = sendDrone.MotorDL = sendDrone.MotorDR = pow;
+      dataDrone.MotorUL = dataDrone.MotorUR = dataDrone.MotorDL = dataDrone.MotorDR = pow;
     }
 
     private void button_UU_MouseDown(object sender, MouseEventArgs e)
@@ -116,35 +121,35 @@ namespace DroneSimulator
 
       if (sender == button_UU)
       {
-        sendDrone.MotorUL -= pow; sendDrone.MotorUR -= pow;
+        dataDrone.MotorUL -= pow; dataDrone.MotorUR -= pow;
-        sendDrone.MotorDL += pow; sendDrone.MotorDR += pow;
+        dataDrone.MotorDL += pow; dataDrone.MotorDR += pow;
       }
       if (sender == button_DD)
       {
-        sendDrone.MotorUL += pow; sendDrone.MotorUR += pow;
+        dataDrone.MotorUL += pow; dataDrone.MotorUR += pow;
-        sendDrone.MotorDL -= pow; sendDrone.MotorDR -= pow;
+        dataDrone.MotorDL -= pow; dataDrone.MotorDR -= pow;
       }
       if (sender == button_LL)
       {
-        sendDrone.MotorUL -= pow; sendDrone.MotorUR += pow;
+        dataDrone.MotorUL -= pow; dataDrone.MotorUR += pow;
-        sendDrone.MotorDL -= pow; sendDrone.MotorDR += pow;
+        dataDrone.MotorDL -= pow; dataDrone.MotorDR += pow;
       }
       if (sender == button_RR)
       {
-        sendDrone.MotorUL += pow; sendDrone.MotorUR -= pow;
+        dataDrone.MotorUL += pow; dataDrone.MotorUR -= pow;
-        sendDrone.MotorDL += pow; sendDrone.MotorDR -= pow;
+        dataDrone.MotorDL += pow; dataDrone.MotorDR -= pow;
       }
 
       if (sender == button_ML)
       {
-        sendDrone.MotorUL -= pow; sendDrone.MotorUR += pow;
+        dataDrone.MotorUL -= pow; dataDrone.MotorUR += pow;
-        sendDrone.MotorDL += pow; sendDrone.MotorDR -= pow;
+        dataDrone.MotorDL += pow; dataDrone.MotorDR -= pow;
       }
 
       if (sender == button_MR)
       {
-        sendDrone.MotorUL += pow; sendDrone.MotorUR -= pow;
+        dataDrone.MotorUL += pow; dataDrone.MotorUR -= pow;
-        sendDrone.MotorDL -= pow; sendDrone.MotorDR += pow;
+        dataDrone.MotorDL -= pow; dataDrone.MotorDR += pow;
       }
     }
 

DroneClient/NetClient.cs

@@ -97,5 +97,10 @@ namespace DroneSimulator
       try { ServerSocket?.BeginReceive(cd.Buffer, 0, ServerData.size, 0, new AsyncCallback(ReadCallback), cd); }  
       catch { }
     }
+
+    public void SendData(byte[] data)
+    {
+      try { ServerSocket?.Send(data); } catch { }
+    }
   }
 }

DroneSimulator/Drone.cs

@@ -1,4 +1,5 @@
-using System.Numerics;
+using System.CodeDom;
+using System.Numerics;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 
@@ -284,52 +285,20 @@ namespace DroneSimulator
       AccPRY.Z = ((ul + dr) - (dl + ur)) / 4;
     }
 
-    private DroneData.DataHead StreamHead = new DroneData.DataHead() { Type = DroneData.StructType.None, Size = 0 };
+    private void RecvDataMotor4(byte[] data)
-
-    public int RecvDataStream(byte[] data)
     {
-      if (StreamHead.Type == DroneData.StructType.None) return Marshal.SizeOf(typeof(DroneData.DataHead));
+      DroneData.DataMotor4 mot = (DroneData.DataMotor4)fromBytes(data, typeof(DroneData.DataMotor4));
-
-      if (StreamHead.Type == DroneData.StructType.Head)
-      {
-        StreamHead = (DroneData.DataHead)fromBytes(data, typeof(DroneData.DataHead));
-
-        return (int)StreamHead.Size;
-      }
-
-      switch(StreamHead.Type)
-      {
-        case DroneData.StructType.DataIMU:
-          {
-            DroneData.DataIMU imu = (DroneData.DataIMU)fromBytes(data, typeof(DroneData.DataIMU));
       /* обработка */
-            break;
+      SetQadroPow(mot.UL, mot.UR, mot.DL, mot.DR);
-          }
-          case DroneData.StructType.DataPos:
-          {
-            DroneData.DataPos pos = (DroneData.DataPos)fromBytes(data, typeof(DroneData.DataPos));
-            /* обработка */
-            break;
-          }
-        case DroneData.StructType.DataMotor4:
-          {
-            DroneData.DataMotor4 pos = (DroneData.DataMotor4)fromBytes(data, typeof(DroneData.DataMotor4));
-            /* обработка */
-            SetQadroPow(pos.UL, pos.UR, pos.DL, pos.DR);
-            break;
-          }
     }
 
-      return Marshal.SizeOf(typeof(DroneData.DataHead));
+    private byte[] SendDataIMU()
-    }
+    {
+      DroneData.DataIMU imu = new DroneData.DataIMU();
 
-    public byte[] SendDataStream(DroneData.StructType type)
+      imu.Head.Size = Marshal.SizeOf(typeof(DroneData.DataIMU));
-    {
+      imu.Head.Mode = DroneData.DataMode.Response;
-      switch(type)
+      imu.Head.Type = DroneData.DataType.DataIMU;
-      {
-        case DroneData.StructType.DataIMU:
-          {
-            DroneData.DataIMU imu=new DroneData.DataIMU();
 
       imu.Acc.X = Acc.X; imu.Acc.Y = Acc.Y; imu.Acc.Z = Acc.Z;
       imu.Gyr.X = Gyr.X; imu.Gyr.Y = Gyr.Y; imu.Gyr.Z = Gyr.Z;
@@ -337,18 +306,121 @@ namespace DroneSimulator
 
       return getBytes(imu);
     }
-          case DroneData.StructType.DataPos:
+
+    private byte[] SendDataPos()
     {
       DroneData.DataPos pos = new DroneData.DataPos();
 
+      pos.Head.Size = Marshal.SizeOf(typeof(DroneData.DataPos));
+      pos.Head.Mode = DroneData.DataMode.Response;
+      pos.Head.Type = DroneData.DataType.DataPos;
+
       pos.Local.X = PosXYZ.X; pos.Local.Y = PosXYZ.Y; pos.Local.Z = PosXYZ.Z;
       pos.LiDAR = LaserRange;
 
       return getBytes(pos);
     }
+
+    private byte[]? ServerRequestResponse(DroneData.DataHead head, byte[] body)
+    {
+      byte[] zero = new byte[0];
+
+      switch (head.Type)
+      {
+        case DroneData.DataType.DataIMU:
+          {
+            if (head.Mode == DroneData.DataMode.Request)
+            {
+              // Запрос данных
+              return SendDataIMU();
+            }
+            else
+            {
+              // Пришли данные
+              // ... //
+              //
+              return zero;
+            }
           }
 
-      return null;
+        case DroneData.DataType.DataPos:
+          {
+            if (head.Mode == DroneData.DataMode.Request)
+            {
+              // Запрос данных
+              return SendDataPos();
+            }
+            else
+            {
+              // Пришли данные
+              // ... //
+              //
+              return zero;
+            }
+          }
+
+        case DroneData.DataType.DataMotor4:
+          {
+            if (head.Mode == DroneData.DataMode.Request)
+            {
+              // Запрос данных
+              // ... //
+              //
+              return zero;
+            }
+            else
+            {
+              // Пришли данные
+              RecvDataMotor4(body);
+              return zero;
+            }
+          }
+      }
+
+      return zero;
+    }
+
+    private const int DroneStreamCount = 512;
+    private byte[] DroneStreamData = new byte[DroneStreamCount];
+    private int DroneStreamIndex = 0;
+    private DroneData.DataHead DroneStreamHead = new DroneData.DataHead() { Mode = DroneData.DataMode.None, Size = 0, Type = DroneData.DataType.None };
+
+    public List<byte[]?>? DataStream(byte[]? data, int size)
+    {
+      List<byte[]?> ret = new List<byte[]?>();
+
+      if (data == null) return ret; // Последовательность не сформирована, ждать данных
+
+      if (size + DroneStreamIndex > DroneStreamCount) return null; // Ошибка переполнения, поток сломан (конец)
+
+      Array.Copy(data, 0, DroneStreamData, DroneStreamIndex, size);
+      DroneStreamIndex += size;
+
+      while (true)
+      {
+        if (DroneStreamHead.Size == 0) // Заголовок ещё не получен
+        {
+          if (DroneStreamIndex < DroneData.DataHead.StrLen) return ret; // Нечего слать
+          DroneStreamHead = (DroneData.DataHead)fromBytes(DroneStreamData, typeof(DroneData.DataHead));
+        }
+
+        if (DroneStreamHead.Size > DroneStreamIndex) break; // Пакет ещё не полный
+
+        byte[] body = new byte[DroneStreamHead.Size];
+
+        Array.Copy(DroneStreamData, 0, body, 0, DroneStreamHead.Size);
+
+        int shift = DroneStreamHead.Size;
+
+        DroneStreamIndex -= shift;
+        Array.Copy(DroneStreamData, shift, DroneStreamData, 0, DroneStreamIndex); // Сдвигаем массив влево, убрав использованные данные
+
+        DroneStreamHead.Size = 0; // Отменяем прошлый заголовок
+
+        ret.Add(ServerRequestResponse(DroneStreamHead, body));
+      }
+
+      return ret;
     }
   }
 }

DroneSimulator/DroneData.cs

@@ -1,6 +1,13 @@
+using System.Runtime.InteropServices;
+
 namespace DroneData
 {
-  public enum StructType : ulong
+  public enum DataMode : ushort
+  {
+    None = 0, Response = 1, Request = 2
+  };
+
+  public enum DataType : ushort
   { 
     None = 0, Head = 1,
 
@@ -13,32 +20,48 @@ namespace DroneData
 
   public struct DataHead
   {
-    public StructType Type;
+    public int Size;
-    public ulong Size;
+
+    public DataMode Mode;
+    public DataType Type;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataHead));
   }
 
   public struct XYZ { public float X, Y, Z; }
 
   public struct DataIMU
   {
+    public DataHead Head;
     public XYZ Acc, Gyr, Mag;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataIMU));
   }
 
   public struct DataPos
   {
+    public DataHead Head;
     public XYZ Local; // Ëîêàëüíûå êîîðäèíàòû
     public float LiDAR; // Äàò÷èê ïîñàäêè
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataPos));
   }
 
   public struct DataMotor4
   {
+    public DataHead Head;
     public ulong Count;
     public float UL, UR, DL, DR;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataMotor4));
   }
 
   public struct DataMotor6
   {
+    public DataHead Head;
     public ulong Count;
     public float UL, UR, LL, RR, DL, DR;
+
+    static public int StrLen = Marshal.SizeOf(typeof(DroneData.DataMotor6));
   }
 }

DroneSimulator/FormMain.cs

@@ -6,6 +6,7 @@ using static System.Runtime.InteropServices.JavaScript.JSType;
 using System.Security.Policy;
 using System.Runtime.InteropServices;
 using System.CodeDom;
+using System.Linq;
 
 namespace DroneSimulator
 {
@@ -23,7 +24,7 @@ namespace DroneSimulator
       InitializeComponent();
     }
 
-    private int ClientConnectionCallback(object o)
+    private void ClientConnectionCallback(object o)
     {
       NetServerClients.ConnectData data = (NetServerClients.ConnectData)o;
 
@@ -54,11 +55,9 @@ namespace DroneSimulator
           break;
         }
       }
-
-      return Marshal.SizeOf(typeof(DroneData.DataHead));
     }
 
-    private int ClientReceiveCallback(object o)
+    private void ClientReceiveCallback(object o)
     {
       NetServerClients.ReceiveData data = (NetServerClients.ReceiveData)o;
 
@@ -71,18 +70,19 @@ namespace DroneSimulator
         break;
       }
 
-      if (drone == null) return 0;
+      if (drone == null) return;
 
-      int size=drone.RecvDataStream(data.Buffer);
+      List<byte[]?>? send = drone.DataStream(data.Buffer, data.Size);
 
+      if (send == null) return;
       try 
       {
-        data.Client.Send(drone.SendDataStream(DroneData.StructType.DataIMU));
+        foreach (byte[]? b in send)
-        data.Client.Send(drone.SendDataStream(DroneData.StructType.DataPos));
+        {
+          if (b != null) data.Client?.Send(b);
+        }
       }
       catch { }
-
-      return size;
     }
 
     private void button_Client_Start_Click(object sender, EventArgs e)

DroneSimulator/NetServerClients.cs

@@ -17,8 +17,9 @@ namespace DroneSimulator
 
     public class ReceiveData
     {
+      
       public int ID;
-      public byte[]? Buffer;
+      public byte[] Buffer;
       public int Size;
 
       public Socket? Client;
@@ -28,7 +29,8 @@ namespace DroneSimulator
     {
       public int ID;
       public Socket? workSocket = null;
-      public byte[] buffer;
+      public const int count = 1024;
+      public byte[] buffer = new byte[count];
     }
 
     private int SocketID = 0;
@@ -36,7 +38,7 @@ namespace DroneSimulator
     private Socket? ServerSocket;
     private List<ClientData> ClientSockets = new List<ClientData>();
 
-    public delegate int ServerCallback(object o);
+    public delegate void ServerCallback(object o);
 
     private ServerCallback? ConnectionCallback;
     private ServerCallback? ReceiveCallback;
@@ -99,11 +101,9 @@ namespace DroneSimulator
 
         ClientSockets.Add(clientData);
 
-        int size = ConnectionCallback(new ConnectData { ID = clientData.ID, Connect = true, Count = ClientSockets.Count, Client = handler });
+        ConnectionCallback(new ConnectData { ID = clientData.ID, Connect = true, Count = ClientSockets.Count, Client = handler });
 
-        clientData.buffer=new byte[size];
+        handler.BeginReceive(clientData.buffer, 0, ClientData.count, 0, new AsyncCallback(ReadCallback), clientData);
-
-        handler.BeginReceive(clientData.buffer, 0, size, 0, new AsyncCallback(ReadCallback), clientData);
       }
       else handler.Close();
 
@@ -130,13 +130,11 @@ namespace DroneSimulator
         return;
       }
 
-      int size = ReceiveCallback(new ReceiveData { ID = cd.ID, Buffer = cd.buffer, Size = bytes, Client = cd.workSocket });
+      ReceiveCallback(new ReceiveData { ID = cd.ID, Buffer = cd.buffer, Size = bytes, Client = cd.workSocket });
-
-      cd.buffer = new byte[size];
 
       try
       {
-        cd.workSocket?.BeginReceive(cd.buffer, 0, size, 0, new AsyncCallback(ReadCallback), cd);
+        cd.workSocket?.BeginReceive(cd.buffer, 0, ClientData.count, 0, new AsyncCallback(ReadCallback), cd);
       }
       catch { }
     }