SikongJueluo
/
FPGA_WebLab
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix bug: couldn't convert package

This commit is contained in:
SikongJueluo 2025-04-17 14:25:37 +08:00
parent 3b674f413a
commit d25f9882fc
No known key found for this signature in database
7 changed files with 187 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
server.test/UDPServerTest.cs
View File

@ -111,12 +111,12 @@ public class UDPServerTest
foreach (var number in bytesArray)
{
Assert.True(await UDPClientPool.SendBytesAsync(serverEP, NumberProcessor.NumberToBytes(number, 4).Value));
Assert.True(await UDPClientPool.SendBytesAsync(serverEP, Number.NumberToBytes(number, 4).Value));
var ret = await udpServer.FindDataAsync(address);
Assert.True(ret.HasValue);
var data = ret.Value;
Assert.Equal(address, data.Address);
Assert.Equal(number, NumberProcessor.BytesToNumber(data.Data));
Assert.Equal(number, Number.BytesToNumber(data.Data));
}
}
@ -130,13 +130,13 @@ public class UDPServerTest
foreach (var number in bytesArray)
{
Assert.True(await UDPClientPool.SendBytesAsync(serverEP, NumberProcessor.NumberToBytes(number, 4).Value));
Assert.True(await UDPClientPool.SendBytesAsync(serverEP, Number.NumberToBytes(number, 4).Value));
var ret = await udpServer.WaitForAckAsync(address);
Assert.True(ret.IsSuccessful);
var data = ret.Value;
Assert.True(data.IsSuccessful);
Assert.Equal(number, NumberProcessor.BytesToNumber(data.ToBytes()));
Assert.Equal(number, Number.BytesToNumber(data.ToBytes()));
}
}
@ -150,13 +150,13 @@ public class UDPServerTest
foreach (var number in bytesArray)
{
Assert.True(await UDPClientPool.SendBytesAsync(serverEP, NumberProcessor.NumberToBytes(number, 8).Value));
Assert.True(await UDPClientPool.SendBytesAsync(serverEP, Number.NumberToBytes(number, 8).Value));
var ret = await udpServer.WaitForDataAsync(address);
Assert.True(ret.IsSuccessful);
var data = ret.Value;
Assert.True(data.IsSuccessful);
Assert.Equal(number, NumberProcessor.BytesToNumber(data.ToBytes()));
Assert.Equal(number, Number.BytesToNumber(data.ToBytes()));
}
}
}

62
server/src/Common.cs
View File

@ -2,8 +2,18 @@ using DotNext;
namespace Common
{
public class NumberProcessor
/// <summary>
/// 数字处理工具
/// </summary>
public class Number
{
/// <summary>
/// 整数转成二进制字节数组
/// </summary>
/// <param name="num">整数</param>
/// <param name="length">整数长度</param>
/// <param name="isRightHigh">是否高位在右边</param>
/// <returns>二进制字节数组</returns>
public static Result<byte[]> NumberToBytes(ulong num, uint length, bool isRightHigh = false)
{
if (length > 8)
@ -33,6 +43,12 @@ namespace Common
return arr;
}
/// <summary>
/// 二进制字节数组转成整数
/// </summary>
/// <param name="bytes">二进制字节数组</param>
/// <param name="isRightHigh">是否高位在右边</param>
/// <returns>整数</returns>
public static Result<ulong> BytesToNumber(byte[] bytes, bool isRightHigh = false)
{
if (bytes.Length > 8)
@ -66,12 +82,28 @@ namespace Common
/// <summary>
/// 比特合并成二进制字节
/// </summary>
/// <param name="bits1">[TODO:parameter]</param>
/// <param name="bits1Len">[TODO:parameter]</param>
/// <param name="bits2">[TODO:parameter]</param>
/// <param name="bits2Len">[TODO:parameter]</param>
/// <returns>[TODO:return]</returns>
public static Result<byte[]> MultiBitsToBytes(ulong bits1, uint bits1Len, ulong bits2, uint bits2Len)
{
return NumberToBytes(MultiBitsToNumber(bits1, bits1Len, bits2, bits2Len).Value,
(bits1Len + bits2Len) % 8 != 0 ? (bits1Len + bits2Len) / 8 + 1 : (bits1Len + bits2Len) / 8);
}
/// <summary>
/// 比特合并成整型
/// </summary>
/// <param name="bits1">[TODO:parameter]</param>
/// <param name="bits1Len">[TODO:parameter]</param>
/// <param name="bits2">[TODO:parameter]</param>
/// <param name="bits2Len">[TODO:parameter]</param>
/// <returns>[TODO:return]</returns>
public static Result<ulong> MultiBitsToNumber(ulong bits1, uint bits1Len, ulong bits2, uint bits2Len)
{
if (bits1Len + bits2Len > 64) throw new ArgumentException("Two Bits is more than 64 bits");
@ -80,6 +112,14 @@ namespace Common
return num;
}
/// <summary>
/// 比特合并成整型
/// </summary>
/// <param name="bits1">[TODO:parameter]</param>
/// <param name="bits1Len">[TODO:parameter]</param>
/// <param name="bits2">[TODO:parameter]</param>
/// <param name="bits2Len">[TODO:parameter]</param>
/// <returns>[TODO:return]</returns>
public static Result<uint> MultiBitsToNumber(uint bits1, uint bits1Len, uint bits2, uint bits2Len)
{
if (bits1Len + bits2Len > 64) throw new ArgumentException("Two Bits is more than 64 bits");
@ -88,17 +128,37 @@ namespace Common
return num;
}
/// <summary>
/// 比特位检查
/// </summary>
/// <param name="srcBits">[TODO:parameter]</param>
/// <param name="dstBits">[TODO:parameter]</param>
/// <param name="mask">[TODO:parameter]</param>
/// <returns>[TODO:return]</returns>
public static bool BitsCheck(ulong srcBits, ulong dstBits, ulong mask = 0xFFFF_FFFF_FFFF_FFFF)
{
return (srcBits & mask) == dstBits;
}
/// <summary>
/// 比特位检查
/// </summary>
/// <param name="srcBits">[TODO:parameter]</param>
/// <param name="dstBits">[TODO:parameter]</param>
/// <param name="mask">[TODO:parameter]</param>
/// <returns>[TODO:return]</returns>
public static bool BitsCheck(uint srcBits, uint dstBits, uint mask = 0xFFFF_FFFF)
{
return (srcBits & mask) == dstBits;
}
/// <summary>
/// 字符串转二进制字节数组
/// </summary>
/// <param name="str">[TODO:parameter]</param>
/// <param name="numBase">[TODO:parameter]</param>
/// <returns>[TODO:return]</returns>
public static byte[] StringToBytes(string str, int numBase = 16)
{
var len = str.Length;

31
server/src/JtagController.cs
View File

@ -261,7 +261,7 @@ class Jtag
if (retPackLen != 4)
throw new Exception($"RecvDataPackage BodyData Length not Equal to 4: Total {retPackLen} bytes");
return Convert.ToUInt32(NumberProcessor.BytesToNumber(retPackOpts.Data).Value);
return Convert.ToUInt32(Number.BytesToNumber(retPackOpts.Data).Value);
}
public async ValueTask<Result<RecvDataPackage>> RunCommand(uint devAddr, uint command)
@ -281,7 +281,7 @@ class Jtag
if (!ret) throw new Exception("Send 1st address package failed!");
// Send Data Package
ret = await UDPClientPool.SendDataPackAsync(ep,
new SendDataPackage(NumberProcessor.NumberToBytes(command, 4).Value));
new SendDataPackage(Number.NumberToBytes(command, 4).Value));
if (!ret) throw new Exception("Send data package failed!");
// Check Msg Bus
@ -322,52 +322,52 @@ class Jtag
if (retPackLen != 4)
throw new Exception($"RecvDataPackage BodyData Length not Equal to 4: Total {retPackLen} bytes");
if (NumberProcessor.BitsCheck(
NumberProcessor.BytesToNumber(retPack.Value.Options.Data).Value, result, resultMask))
if (Number.BitsCheck(
Number.BytesToNumber(retPack.Value.Options.Data).Value, result, resultMask))
ret = true;
return ret;
}
public async ValueTask<Result<bool>> ClearAllRegisters()
async ValueTask<Result<bool>> ClearAllRegisters()
{
return await RunCommand(JtagAddr.STATE, 0xFF_FF_FF_FF, 0x01_02_02_02, JtagState.ALL_REG);
}
public async ValueTask<Result<bool>> ClearWriteDataReg()
async ValueTask<Result<bool>> ClearWriteDataReg()
{
return await RunCommand(JtagAddr.STATE, 0x00_00_11_00, 0x01_00_02_00, JtagState.WRITE_DATA_FIFO | JtagState.CMD_EXEC_FINISH);
}
public async ValueTask<Result<bool>> RunTest()
async ValueTask<Result<bool>> RunTest()
{
return await RunCommand(
JtagAddr.WRITE_CMD,
NumberProcessor.MultiBitsToNumber(JtagCmd.CMD_JTAG_RUN_TEST, JtagCmd.LEN_CMD_JTAG, 0, 28).Value,
Number.MultiBitsToNumber(JtagCmd.CMD_JTAG_RUN_TEST, JtagCmd.LEN_CMD_JTAG, 0, 28).Value,
0x01_00_00_00, JtagState.CMD_EXEC_FINISH);
}
public async ValueTask<Result<bool>> DRIDcode()
async ValueTask<Result<bool>> DRIDcode()
{
return await RunCommand(
JtagAddr.WRITE_DATA,
NumberProcessor.MultiBitsToNumber(0, 22, JtagCmd.JTAG_DR_IDCODE, JtagCmd.LEN_JTAG_DR).Value, 0, 0);
Number.MultiBitsToNumber(0, 22, JtagCmd.JTAG_DR_IDCODE, JtagCmd.LEN_JTAG_DR).Value, 0, 0);
}
public async ValueTask<Result<bool>> LoadIR()
async ValueTask<Result<bool>> LoadIR()
{
return await RunCommand(
JtagAddr.WRITE_CMD,
NumberProcessor.MultiBitsToNumber(JtagCmd.CMD_JTAG_LOAD_IR, JtagCmd.LEN_CMD_JTAG, 10, 28).Value,
Number.MultiBitsToNumber(JtagCmd.CMD_JTAG_LOAD_IR, JtagCmd.LEN_CMD_JTAG, 10, 28).Value,
0x01_00_00_00);
}
public async ValueTask<Result<uint>> LoadDRCareo()
async ValueTask<Result<uint>> LoadDRCareo()
{
var ret = await RunCommand(
JtagAddr.WRITE_CMD,
NumberProcessor.MultiBitsToNumber(JtagCmd.CMD_JTAG_LOAD_DR_CAREO, JtagCmd.LEN_CMD_JTAG, 32, 28).Value,
Number.MultiBitsToNumber(JtagCmd.CMD_JTAG_LOAD_DR_CAREO, JtagCmd.LEN_CMD_JTAG, 32, 28).Value,
0x01_00_00_00, JtagState.CMD_EXEC_FINISH);
if (ret.Value)
@ -380,6 +380,9 @@ class Jtag
{
var ret = false;
// Clear Data
await MsgBus.UDPServer.ClearUDPData(this.address);
ret = (await ClearAllRegisters()).Value;
ret = (await RunTest()).Value;
ret = (await DRIDcode()).Value;

4
server/src/Router.cs
View File

@ -70,7 +70,7 @@ namespace Router
public static async ValueTask<IResult> SendBytes(string address, int port, string bytes)
{
var endPoint = new IPEndPoint(IPAddress.Parse(address), port);
var ret = await UDPClientPool.SendBytesAsync(endPoint, NumberProcessor.StringToBytes(bytes));
var ret = await UDPClientPool.SendBytesAsync(endPoint, Number.StringToBytes(bytes));
if (ret) { return TypedResults.Ok(); }
else { return TypedResults.InternalServerError(); }
@ -105,7 +105,7 @@ namespace Router
{
var endPoint = new IPEndPoint(IPAddress.Parse(address), port);
var ret = await UDPClientPool.SendDataPackAsync(endPoint,
new WebProtocol.SendDataPackage(NumberProcessor.StringToBytes(data)));
new WebProtocol.SendDataPackage(Number.StringToBytes(data)));
if (ret) { return TypedResults.Ok(); }
else { return TypedResults.InternalServerError(); }

101
server/src/UdpClientPool.cs
View File

@ -2,28 +2,54 @@ using System.Net;
using System.Net.Sockets;
using System.Text;
/// <summary>
/// UDP客户端发送池
/// </summary>
public class UDPClientPool
{
private static IPAddress localhost = IPAddress.Parse("127.0.0.1");
/// <summary>
/// 发送字符串
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="stringArray">字符串数组</param>
/// <returns>是否成功</returns>
public static bool SendString(IPEndPoint endPoint, string[] stringArray)
{
var isSuccessful = true;
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
byte[] sendbuf = Encoding.ASCII.GetBytes(stringArray[0]);
foreach (var str in stringArray)
{
byte[] sendbuf = Encoding.ASCII.GetBytes(str);
var sendLen = socket.SendTo(sendbuf, endPoint);
if (str.Length != sendLen) isSuccessful = false;
}
var sendLen = socket.SendTo(sendbuf, endPoint);
socket.Close();
if (sendLen == stringArray[0].Length) { return true; }
if (isSuccessful) { return true; }
else { return false; }
}
/// <summary>
/// 异步发送字符串
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="stringArray">字符串数组</param>
/// <returns>是否成功</returns>
public async static ValueTask<bool> SendStringAsync(IPEndPoint endPoint, string[] stringArray)
{
return await Task.Run(() => { return SendString(endPoint, stringArray); });
}
/// <summary>
/// 发送二进制字节
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="buf">二进制字节</param>
/// <returns>是否成功</returns>
public static bool SendBytes(IPEndPoint endPoint, byte[] buf)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
@ -34,11 +60,23 @@ public class UDPClientPool
else { return false; }
}
/// <summary>
/// 异步发送二进制字节
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="buf">二进制字节</param>
/// <returns>是否成功</returns>
public async static ValueTask<bool> SendBytesAsync(IPEndPoint endPoint, byte[] buf)
{
return await Task.Run(() => { return SendBytes(endPoint, buf); });
}
/// <summary>
/// 发送地址包
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="pkg">地址包</param>
/// <returns>是否成功</returns>
public static bool SendAddrPack(IPEndPoint endPoint, WebProtocol.SendAddrPackage pkg)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
@ -50,11 +88,24 @@ public class UDPClientPool
else { return false; }
}
/// <summary>
/// 异步发送地址包
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="pkg">地址包</param>
/// <returns>是否成功</returns>
public async static ValueTask<bool> SendAddrPackAsync(IPEndPoint endPoint, WebProtocol.SendAddrPackage pkg)
{
return await Task.Run(() => { return SendAddrPack(endPoint, pkg); });
}
/// <summary>
/// 发送数据包
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="pkg">数据包</param>
/// <returns>是否成功</returns>
public static bool SendDataPack(IPEndPoint endPoint, WebProtocol.SendDataPackage pkg)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
@ -66,38 +117,48 @@ public class UDPClientPool
else { return false; }
}
/// <summary>
/// 异步发送数据包
/// </summary>
/// <param name="endPoint">IP端点（IP地址与端口）</param>
/// <param name="pkg">数据包</param>
/// <returns>是否成功</returns>
public async static ValueTask<bool> SendDataPackAsync(IPEndPoint endPoint, WebProtocol.SendDataPackage pkg)
{
return await Task.Run(() => { return SendDataPack(endPoint, pkg); });
}
public static bool SendLocalHost(int port, string[] stringArray)
/// <summary>
/// 发送字符串到本地
/// </summary>
/// <param name="port">端口</param>
/// <param name="stringArray">字符串数组</param>
/// <returns>是否成功</returns>
public static bool SendStringLocalHost(int port, string[] stringArray)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
byte[] sendBytes = Encoding.ASCII.GetBytes(stringArray[0]);
IPEndPoint ep = new IPEndPoint(localhost, port);
var sendLen = socket.SendTo(sendBytes, ep);
socket.Close();
if (sendLen == sendBytes.Length) { return true; }
else { return false; }
return SendString(new IPEndPoint(localhost, port), stringArray);
}
public static void CycleSendLocalHost(int times, int sleepMilliSeconds, int port, string[] stringArray)
/// <summary>
/// 循环发送字符串到本地
/// </summary>
/// <param name="times">发送总次数</param>
/// <param name="sleepMilliSeconds">间隔时间</param>
/// <param name="port">端口</param>
/// <param name="stringArray">字符串数组</param>
/// <returns>是否成功</returns>
public static bool CycleSendStringLocalHost(int times, int sleepMilliSeconds, int port, string[] stringArray)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
byte[] sendbuf = Encoding.ASCII.GetBytes(stringArray[0]);
IPEndPoint ep = new IPEndPoint(localhost, port);
var isSuccessful = true;
while (times-- >= 0)
{
socket.SendTo(sendbuf, ep);
isSuccessful = SendStringLocalHost(port, stringArray);
if (!isSuccessful) break;
Thread.Sleep(sleepMilliSeconds);
}
socket.Close();
return isSuccessful;
}
}

18
server/src/UdpServer.cs
View File

@ -2,6 +2,7 @@ using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using DotNext;
using DotNext.Threading;
using Newtonsoft.Json;
@ -392,6 +393,23 @@ public class UDPServer
}
}
/// <summary>
/// 清空指定IP地址的数据
/// </summary>
/// <param name="ipAddr">IP地址</param>
/// <returns>无</returns>
public async Task ClearUDPData(string ipAddr)
{
using (await udpData.AcquireWriteLockAsync())
{
if (udpData.TryGetValue(ipAddr, out var dataQueue) && dataQueue.Count > 0)
{
dataQueue.Clear();
}
}
}
/// <summary>
/// Start UDP Server
/// </summary>

4
server/src/WebProtocol.cs
View File

@ -202,7 +202,7 @@ namespace WebProtocol
arr[2] = burstLength;
arr[3] = _reserved;
var bytesAddr = Common.NumberProcessor.NumberToBytes(address, 4).Value;
var bytesAddr = Common.Number.NumberToBytes(address, 4).Value;
Array.Copy(bytesAddr, 0, arr, 4, bytesAddr.Length);
return arr;
@ -248,7 +248,7 @@ namespace WebProtocol
);
}
var address = Common.NumberProcessor.BytesToNumber(bytes[4..]).Value;
var address = Common.Number.BytesToNumber(bytes[4..]).Value;
return new SendAddrPackage(bytes[1], bytes[2], Convert.ToUInt32(address));
}
}