add remote update

server/src/UdpClientPool.cs

@@ -204,9 +204,90 @@ public class UDPClientPool
         return retPack;
     }
 
-    public static async ValueTask<Result<RecvDataPackage>> ReadAddrWithCheck(
-            IPEndPoint endPoint, uint devAddr, int timeout = 1000)
+    /// <summary>
+    /// [TODO:description]
+    /// </summary>
+    /// <param name="endPoint">[TODO:parameter]</param>
+    /// <param name="devAddr">[TODO:parameter]</param>
+    /// <param name="result">[TODO:parameter]</param>
+    /// <param name="resultMask">[TODO:parameter]</param>
+    /// <param name="timeout">[TODO:parameter]</param>
+    /// <returns>[TODO:return]</returns>
+    public static async ValueTask<Result<bool>> ReadAddr(
+            IPEndPoint endPoint, uint devAddr, UInt32 result, UInt32 resultMask, int timeout = 1000)
     {
+        var address = endPoint.Address.ToString();
+
+        var ret = await ReadAddr(endPoint, devAddr, timeout);
+        if (!ret.IsSuccessful) return new(ret.Error);
+        if (!ret.Value.IsSuccessful)
+            return new(new Exception($"Read device {address} address {devAddr} failed"));
+
+        var retData = ret.Value.Options.Data;
+        if (retData is null)
+            return new(new Exception($"Device {address} receive none"));
+        if (retData.Length != 4)
+            return new(new Exception(
+                $"Device {address} receive data is {retData.Length} bytes instead of 4 bytes"));
+
+        // Check result
+        try
+        {
+            var retCode = Convert.ToUInt32(Common.Number.BytesToUInt64(retData).Value);
+            return Common.Number.BitsCheck(retCode, result, resultMask);
+        }
+        catch (Exception error)
+        {
+            return new(error);
+        }
+    }
+
+    /// <summary>
+    /// [TODO:description]
+    /// </summary>
+    /// <param name="endPoint">[TODO:parameter]</param>
+    /// <param name="devAddr">[TODO:parameter]</param>
+    /// <param name="result">[TODO:parameter]</param>
+    /// <param name="resultMask">[TODO:parameter]</param>
+    /// <param name="timeout">[TODO:parameter]</param>
+    /// <returns>[TODO:return]</returns>
+    public static async ValueTask<Result<bool>> ReadAddrWithWait(
+            IPEndPoint endPoint, uint devAddr, UInt32 result, UInt32 resultMask, int timeout = 1000)
+    {
+        var address = endPoint.Address.ToString();
+
+        var startTime = DateTime.Now;
+        while (true)
+        {
+            var elapsed = DateTime.Now - startTime;
+            if (elapsed >= TimeSpan.FromMilliseconds(timeout)) break;
+            var timeleft = TimeSpan.FromMilliseconds(timeout) - elapsed;
+
+            try
+            {
+                var ret = await ReadAddr(endPoint, devAddr, Convert.ToInt32(timeleft.TotalMilliseconds));
+                if (!ret.IsSuccessful) return new(ret.Error);
+                if (!ret.Value.IsSuccessful)
+                    return new(new Exception($"Read device {address} address {devAddr} failed"));
+
+                var retData = ret.Value.Options.Data;
+                if (retData is null)
+                    return new(new Exception($"Device {address} receive none"));
+                if (retData.Length != 4)
+                    return new(new Exception(
+                        $"Device {address} receive data is {retData.Length} bytes instead of 4 bytes"));
+
+                // Check result
+                var retCode = Convert.ToUInt32(Common.Number.BytesToUInt64(retData).Value);
+                if (Common.Number.BitsCheck(retCode, result, resultMask)) return true;
+            }
+            catch (Exception error)
+            {
+                return new(error);
+            }
+        }
+
+        return false;
     }
 
 
@@ -249,4 +330,58 @@ public class UDPClientPool
 
         return udpWriteAck.Value.IsSuccessful;
     }
+
+    /// <summary>
+    /// [TODO:description]
+    /// </summary>
+    /// <param name="endPoint">[TODO:parameter]</param>
+    /// <param name="devAddr">[TODO:parameter]</param>
+    /// <param name="dataArray">[TODO:parameter]</param>
+    /// <param name="timeout">[TODO:parameter]</param>
+    /// <returns>[TODO:return]</returns>
+    public static async ValueTask<Result<bool>> WriteAddr(IPEndPoint endPoint, UInt32 devAddr, byte[] dataArray, int timeout = 1000)
+    {
+        var ret = false;
+        var opts = new SendAddrPackOptions();
+
+
+        opts.BurstType = BurstType.FixedBurst;
+        opts.CommandID = 0;
+        opts.Address = devAddr;
+
+        // Check Msg Bus
+        if (!MsgBus.IsRunning)
+            return new(new Exception("Message bus not working!"));
+
+        opts.IsWrite = true;
+        var writeTimes = dataArray.Length / (256 * (32 / 8)) + 1;
+        for (var i = 0; i < writeTimes; i++)
+        {
+            // Sperate Data Array
+            var isLastData = i == writeTimes - 1;
+            var sendDataArray =
+                isLastData ?
+                dataArray[(i * (256 * (32 / 8)))..] :
+                dataArray[(i * (256 * (32 / 8)))..((i + 1) * (256 * (32 / 8)))];
+
+            // Write Jtag State Register
+            opts.BurstLength = ((byte)(sendDataArray.Length / 4 - 1));
+            ret = await UDPClientPool.SendAddrPackAsync(endPoint, new SendAddrPackage(opts));
+            if (!ret) return new(new Exception("Send 1st address package failed!"));
+
+            // Send Data Package
+            ret = await UDPClientPool.SendDataPackAsync(endPoint, new SendDataPackage(sendDataArray));
+            if (!ret) return new(new Exception("Send data package failed!"));
+
+            // Wait for Write Ack
+            var udpWriteAck = await MsgBus.UDPServer.WaitForAckAsync(endPoint.Address.ToString(), endPoint.Port, timeout);
+            if (!udpWriteAck.IsSuccessful) return new(udpWriteAck.Error);
+
+            if (!udpWriteAck.Value.IsSuccessful)
+                return false;
+        }
+
+        return true;
+    }
+
 }