ciro_xu/iotgateway
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
2bc9fcc357
iotgateway/Plugins/Drivers/PLC.LS/DeviceXGB.cs

744 lines
32 KiB
C#
Raw Normal View History

fix StartClientAsync
2023-12-21 11:36:42 +00:00
using HslCommunication;
using HslCommunication.Profinet.LSIS;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json.Linq;
using PluginInterface;
using System.IO.Ports;
using System.Net;
namespace PLC.LSIS
{
[DriverSupported("FENet")]
[DriverSupported("CNet")]
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[DriverInfo("XGB", "V1.0.0", "Copyright IoTGateway.net 20231223")]
fix StartClientAsync
2023-12-21 11:36:42 +00:00
public class DeviceXGB : IDriver
{
public ILogger _logger { get; set; }
private readonly string _device;
private XGBCnet xGBCnet = null;
private XGBFastEnet fastEnet = null;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
#region ConfigParameter
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("Device Id")] public string DeviceId { get; set; }
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("PLC LSCpuInfo")] public LSCpuInfo lSCpuInfo { get; set; } = LSCpuInfo.XGB;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("PLC TypeConnect")] public LSTypeConnect lSTypeConnect { get; set; } = LSTypeConnect.FENet;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("IP")] public string IpAddress { get; set; } = "127.0.0.1";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("Port")] public int Port { get; set; } = 2004;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
[ConfigParameter("Slot")] public short Slot { get; set; } = 0;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("PortName")] public string PortName { get; set; } = "COM1";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("BaudRate")] public int BaudRate { get; set; } = 9600;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("DataBits")] public int DataBits { get; set; } = 8;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("Parity")] public Parity Parity { get; set; } = Parity.None;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("StopBits")] public StopBits StopBits { get; set; } = StopBits.One;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("Station")] public byte Station { get; set; } = 1;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("Overtime time ms")] public int Timeout { get; set; } = 3000;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
Add DeviceXGK
2023-12-23 12:15:55 +00:00
[ConfigParameter("Minimum communication Cycle ms")] public uint MinPeriod { get; set; } = 3000;
fix StartClientAsync
2023-12-21 11:36:42 +00:00
#endregion
#region
/// <summary>
/// 反射构造函数
/// </summary>
/// <param name="device"></param>
/// <param name="logger"></param>
public DeviceXGB(string device, ILogger logger)
{
_device = device;
_logger = logger;
_logger.LogInformation($"Device:[{_device}],Create()");
}
public bool IsConnected { get; set; }
public bool Connect()
{
try
{
_logger.LogInformation($"Device:[{_device}],Connect()");
if (!IsConnected)
{
switch (lSTypeConnect)
{
case LSTypeConnect.FENet:
if (fastEnet == null || !IsConnected)
{
fastEnet = new XGBFastEnet(IpAddress, Port);
Add DeviceXGK
2023-12-23 12:15:55 +00:00
fastEnet.SlotNo = (byte)Slot;
fastEnet.SetCpuType = $"{lSCpuInfo}";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
IsConnected = fastEnet.ConnectServer().IsSuccess;
}
break;
case LSTypeConnect.CNet:
if (xGBCnet == null || !IsConnected)
{
xGBCnet = new XGBCnet
{
Station = Station
};
xGBCnet.SerialPortInni(sp =>
{
sp.PortName = PortName;
sp.BaudRate = BaudRate;
sp.DataBits = DataBits;
sp.StopBits = StopBits;
sp.Parity = Parity;
});
xGBCnet.Open();
IsConnected = xGBCnet.IsOpen();
}
break;
default:
return IsConnected;
}
}
else
{
return IsConnected;
}
return IsConnected;
}
catch (Exception ex)
{
_logger.LogError(ex, $"Device:[{_device}],Connect()");
return IsConnected;
}
}
public bool Close()
{
try
{
_logger.LogInformation($"Device:[{_device}],Close()");
switch (lSTypeConnect)
{
case LSTypeConnect.FENet:
if (fastEnet != null)
{
fastEnet.ConnectClose();
return !IsConnected;
}
break;
case LSTypeConnect.CNet:
if (xGBCnet != null)
{
xGBCnet.Close();
return !IsConnected;
}
break;
default:
return false;
}
return !IsConnected;
}
catch (Exception ex)
{
_logger.LogError(ex, $"Device:[{_device}],Close()");
return false;
}
}
public void Dispose()
{
try
{
_logger?.LogInformation($"Device:[{_device}],Dispose()");
switch (lSTypeConnect)
{
case LSTypeConnect.FENet:
if (fastEnet != null)
{
fastEnet.Dispose();
}
break;
case LSTypeConnect.CNet:
if (xGBCnet != null)
{
xGBCnet.Dispose();
}
break;
}
// Suppress finalization.
GC.SuppressFinalize(this);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Device:[{_device}],Dispose()");
}
}
[Method("XGB", description: "Read")]
public DriverReturnValueModel Read(DriverAddressIoArgModel ioArg)
{
DriverReturnValueModel ret = new() { StatusType = VaribaleStatusTypeEnum.Good };
if (!IsConnected)
ret.StatusType = VaribaleStatusTypeEnum.Bad;
else
{
if (ret.StatusType != VaribaleStatusTypeEnum.Good)
return ret;
try
{
if (ioArg.ValueType == DataTypeEnum.Bool)
{
OperateResult<bool[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadBool(ioArg.Address, 1) : xGBCnet.ReadBool(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
if (ioArg.ValueType == DataTypeEnum.Bit)
{
OperateResult<bool[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadBool(ioArg.Address, 1) : xGBCnet.ReadBool(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
if (ioArg.ValueType == DataTypeEnum.Byte)
{
OperateResult<byte> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadByte(ioArg.Address) : xGBCnet.ReadByte(ioArg.Address);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
if (ioArg.ValueType == DataTypeEnum.Uint16)
{
OperateResult<ushort[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadUInt16(ioArg.Address, 1) : xGBCnet.ReadUInt16(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Int16)
{
OperateResult<short[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadInt16(ioArg.Address, 1) : xGBCnet.ReadInt16(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Int32)
{
OperateResult<int[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadInt32(ioArg.Address, 1) : xGBCnet.ReadInt32(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Uint32)
{
OperateResult<uint[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadUInt32(ioArg.Address, 1) : xGBCnet.ReadUInt32(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Int64)
{
OperateResult<long[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadInt64(ioArg.Address, 1) : xGBCnet.ReadInt64(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Uint64)
{
OperateResult<ulong[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadUInt64(ioArg.Address, 1) : xGBCnet.ReadUInt64(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Double)
{
OperateResult<double[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadDouble(ioArg.Address, 1) : xGBCnet.ReadDouble(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Float)
{
OperateResult<float[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadFloat(ioArg.Address, 1) : xGBCnet.ReadFloat(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content[0]);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.AsciiString)
{
OperateResult<string> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadString(ioArg.Address, 1) : xGBCnet.ReadString(ioArg.Address, 1);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.UnKnow;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = "Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
_logger.LogError($"Device:[{_device}],[{ioArg.ValueType}]类型未定义");
return ret;
}
}
catch (Exception ex)
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
ret.Message = ex.Message;
_logger.LogError(ex, $"Device:[{_device}],ReadRegistersBuffers(),Error");
}
}
return ret;
}
[Method("XGB", description: "ReadMultiple")]
public DriverReturnValueModel ReadMultiple(DriverAddressIoArgModel ioArg)
{
DriverReturnValueModel ret = new() { StatusType = VaribaleStatusTypeEnum.Good };
if (!IsConnected)
ret.StatusType = VaribaleStatusTypeEnum.Bad;
else
{
if (ret.StatusType != VaribaleStatusTypeEnum.Good)
return ret;
try
{
string startAddress;
if (ioArg.Address.Contains('|'))
{
startAddress = ioArg.Address.Split('|')[0];
ioArg.Address = ioArg.Address.Split('|')[1];
}
var args = ioArg.Address.Split(',');
startAddress = args[0];
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ushort length = (ushort)(ushort.Parse(args[1]) * 2);
fix StartClientAsync
2023-12-21 11:36:42 +00:00
if (ioArg.ValueType == DataTypeEnum.Bool)
{
OperateResult<bool[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadBool(startAddress, length) : xGBCnet.ReadBool(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
if (ioArg.ValueType == DataTypeEnum.Bit)
{
OperateResult<bool[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadBool(startAddress, length) : xGBCnet.ReadBool(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
if (ioArg.ValueType == DataTypeEnum.Byte)
{
OperateResult<byte[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Read(startAddress, length) : xGBCnet.Read(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
if (ioArg.ValueType == DataTypeEnum.Uint16)
{
OperateResult<ushort[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadUInt16(startAddress, length) : xGBCnet.ReadUInt16(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Int16)
{
OperateResult<short[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadInt16(startAddress, length) : xGBCnet.ReadInt16(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Int32)
{
OperateResult<int[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadInt32(startAddress, length) : xGBCnet.ReadInt32(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Uint32)
{
OperateResult<uint[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadUInt32(startAddress, length) : xGBCnet.ReadUInt32(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Int64)
{
OperateResult<long[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadInt64(startAddress, length) : xGBCnet.ReadInt64(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Uint64)
{
OperateResult<ulong[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadUInt64(startAddress, length) : xGBCnet.ReadUInt64(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Double)
{
OperateResult<double[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadDouble(startAddress, length) : xGBCnet.ReadDouble(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.Float)
{
OperateResult<float[]> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadFloat(startAddress, length) : xGBCnet.ReadFloat(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else if (ioArg.ValueType == DataTypeEnum.AsciiString)
{
OperateResult<string> read = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.ReadString(startAddress, length) : xGBCnet.ReadString(startAddress, length);
if (read.IsSuccess)
ret.Value = Newtonsoft.Json.JsonConvert.SerializeObject(read.Content);
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = $"Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
return ret;
}
else
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.UnKnow;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
ret.Message = "Read failed";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
_logger.LogError($"Device:[{_device}],[{ioArg.ValueType}]类型未定义");
return ret;
}
}
catch (Exception ex)
{
IsConnected = false;
ret.StatusType = VaribaleStatusTypeEnum.Bad;
ret.Message = ex.Message;
_logger.LogError(ex, $"Device:[{_device}],ReadRegistersBuffers(),Error");
}
}
return ret;
}
[Method("XGB", description: "Write")]
public async Task<RpcResponse> WriteAsync(string RequestId, string Method, DriverAddressIoArgModel ioArg)
{
RpcResponse rpcResponse = new() { IsSuccess = false };
try
{
OperateResult writeResult;
if (!IsConnected)
Add DeviceXGK
2023-12-23 12:15:55 +00:00
rpcResponse.Description = "Device connection has been disconnected";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
else
{
if (ioArg.ValueType == DataTypeEnum.Bool)
{
var value = ioArg.Value.ToString() == "1" || ioArg.Value.ToString().ToLower() == "true";
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.WriteCoil(ioArg.Address, value) : xGBCnet.WriteCoil(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
if (ioArg.ValueType == DataTypeEnum.Bit)
{
var value = ioArg.Value.ToString() == "1" || ioArg.Value.ToString().ToLower() == "true";
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.WriteCoil(ioArg.Address, value) : xGBCnet.WriteCoil(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
if (ioArg.ValueType == DataTypeEnum.Byte)
{
var value = ioArg.Value.ToString();
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
if (ioArg.ValueType == DataTypeEnum.Uint16)
{
var value = ushort.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
else if (ioArg.ValueType == DataTypeEnum.Int16)
{
var value = short.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
else if (ioArg.ValueType == DataTypeEnum.Int32)
{
var value = int.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
else if (ioArg.ValueType == DataTypeEnum.Uint32)
{
var value = uint.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
else if (ioArg.ValueType == DataTypeEnum.Int64)
{
var value = long.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
else if (ioArg.ValueType == DataTypeEnum.Uint64)
{
var value = ulong.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
else if (ioArg.ValueType == DataTypeEnum.Double)
{
var value = double.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
else if (ioArg.ValueType == DataTypeEnum.Float)
{
var value = float.Parse(ioArg.Value.ToString());
writeResult = lSTypeConnect == LSTypeConnect.FENet ? fastEnet.Write(ioArg.Address, value) : xGBCnet.Write(ioArg.Address, value);
rpcResponse.IsSuccess = true;
return rpcResponse;
}
Add DeviceXGK
2023-12-23 12:15:55 +00:00
rpcResponse.Description = $"Writing is not supported:{Method}";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
}
}
catch (Exception ex)
{
IsConnected = false;
Add DeviceXGK
2023-12-23 12:15:55 +00:00
rpcResponse.Description = $"Write failed,[method]:{Method},[ioArg]:{ioArg},[ex]:{ex}";
fix StartClientAsync
2023-12-21 11:36:42 +00:00
_logger.LogError(ex, $"Device:[{_device}],WriteAsync(),Error");
}
return rpcResponse;
}
#endregion
}
public enum LSTypeConnect
{
CNet = 0,
FENet = 1,
}
}
Reference in New Issue Copy Permalink