private async Task <ushort[]> ReadModbusRegistersAsync()
{
AllData = await _master.ReadHoldingRegistersAsync(WTX_SLAVE_ADDRESS, WTX_REGISTER_START_ADDRESS, WTX_REGISTER_DATAWORD_COUNT);
CommunicationLog?.Invoke(this, new LogEventArgs("Read all: " + string.Join(",", AllData.Select(x => x.ToString("X")).ToArray())));
return(AllData);
}
public static async Task <T> QueryHeliosValue <T>(this IModbusMaster modbus, VariableDeclaration <T> parameter)
{
Log.Debug($"Querying {parameter.Code}...");
var bytes = Encoding.ASCII.GetBytes($"{parameter.Code}\0");
var ushorts = ToUShortArray(bytes);
await modbus.WriteMultipleRegistersAsync(HeliosDefaults.SlaveAddress, HeliosDefaults.Offset, ushorts);
var result =
await modbus.ReadHoldingRegistersAsync(HeliosDefaults.SlaveAddress,
HeliosDefaults.Offset,
parameter.RegisterCount);
bytes = FromShortArray(result);
var decoded = Encoding.ASCII.GetString(bytes);
Log.Debug($"Decoded: {decoded}");
if (TryExtractValue(parameter.Code, decoded, out var value))
{
Log.Debug($"Trying to convert {value} to {typeof(T)}");
return((T)Convert.ChangeType(value, typeof(T)));
}
return(default);
public async Task <IQueryResult <ushort[]> > ReadHoldingResgistersAsync(ushort startAddress, ushort numberOfPoints, string dataTitle)
{
IQueryResult <ushort[]> queryResult = _queryResultFactory.CreateDefaultQueryResult <ushort[]>();
if (!CheckConnection(queryResult))
{
return(queryResult);
}
try
{
queryResult.Result = await _currentModbusMaster.ReadHoldingRegistersAsync(_slaveId, startAddress, numberOfPoints);
List <string> results = queryResult.Result.Select((arg => arg.ToString())).ToList();
string resStr = "";
foreach (var res in results)
{
resStr += res;
resStr += " ";
}
queryResult.IsSuccessful = true;
}
catch (Exception e)
{
queryResult.IsSuccessful = false;
}
return(queryResult);
}
private async Task <ushort[]> TryExecuteReadQuery(ushort startAddress, ushort numberOfPoints)
{
try
{
await _semaphoreSlim.WaitAsync();
if (!LastTransactionSucceed)
{
throw new Exception("");
}
ushort[] bytes = await _modbusMaster.ReadHoldingRegistersAsync(1, startAddress, numberOfPoints);
_semaphoreSlim.Release();
return(bytes);
}
catch (Exception e)
{
_semaphoreSlim.Release();
for (int i = 0; i < 2; i++)
{
await OpenConnectionSession(true);
if (LastTransactionSucceed)
{
break;
}
}
if (!LastTransactionSucceed)
{
throw;
}
return(await TryExecuteReadQuery(startAddress, numberOfPoints));
}
}
//public async Task<IEnumerable<MqttInlineRegisterJsonModel>> ReadModbusToArray(SlaveInfoYaml slaves)
//{
// ushort minAddr = slaves.registers.Min(x => x.address);
// ushort maxAddr = slaves.registers.Max(x => x.address);
// minAddr = (ushort)(minAddr - 1);
// ushort pointCnt = (ushort)((maxAddr - minAddr) + 1);
// ushort[] datas = null;
// lock (lockerObj)
// {
// switch (slaves.io_type)
// {
// case DataModel.modbus_io.ANALOG_INPUT:
// datas = master.ReadInputRegisters(slaves.deviceId, minAddr, pointCnt);
// break;
// case DataModel.modbus_io.HOLDING_REGISTER:
// datas = master.ReadHoldingRegisters(slaves.deviceId, minAddr, pointCnt);
// break;
// }
// Console.WriteLine("READ MODBUS_INPUT_REGISTER");
// }
// DateTime timeStamp = DateTime.Now;
// List<MqttRegisterJsonModel> registers = new List<MqttRegisterJsonModel>();
// foreach (SlaveInfoRegisterYaml register in slaves.registers)
// {
// Console.WriteLine("READ REGISTER: " + register.name);
// int addr = (register.address - 1) - minAddr;
// byte[] buffer = GetReadBytes(register, addr, datas);
// object value = 0f;
// switch (register.type)
// {
// case DataModel.modbus_type.DT_SIGNED:
// if (register.length > 1)
// value = BitConverter.ToInt32(buffer);
// else
// value = BitConverter.ToInt16(buffer);
// break;
// case modbus_type.DT_UNSIGNED:
// if (register.length > 1)
// value = BitConverter.ToUInt32(buffer);
// else
// value = BitConverter.ToUInt16(buffer);
// break;
// case modbus_type.DT_FLOAT:
// value = BitConverter.ToSingle(buffer);
// break;
// }
// registers.Add(register.CreateJsonModel(value));
// //registers.Add(register.ConvertRegister(Convert.ToSingle(value)));
// }
// parent.Registers = registers.ToArray();
// return parent;
//}
public async Task <List <DiMap> > ReadModbusEvent(EventGroupPoint map)
{
List <DiMap> result = new List <DiMap>();
if (master == null)
{
return(result);
}
ushort[] datas = await master.ReadHoldingRegistersAsync(_config.SlaveId, map.StartAddress, (ushort)map.DigitalPoints.Count);
int idx = 0;
foreach (DiMap m in map.DigitalPoints)
{
m.Value = datas[idx++];
result.Add(m);
}
return(result);
}
public async Task <SensorRecord> ReadSensorRecord()
{
ushort[] inputs = await modbusMaster.ReadHoldingRegistersAsync(AppConfig.SlaveAddress, Sensor.StartAddress, Sensor.NumberOfPoints);
return(new SensorRecord()
{
RecordedOn = DateTimeOffset.Now,
SensorName = Sensor.Name,
SensorValue = inputs.ToFloat()
});
}
public async Task TestHoldingRegisters()
{
var factory = new ModbusFactory();
IModbusMaster modbus = factory.CreateMaster(_client);
await _client.ConnectAsync(MODBUS_IP, MODBUS_PORT);
ushort[] data = await modbus.ReadHoldingRegistersAsync(MODBUS_SLAVE, 0, 5);
Assert.Equal(5, data.Length);
await modbus.WriteMultipleRegistersAsync(MODBUS_SLAVE, 0, new ushort[] { 1, 2, 3, 4, 5 });
data = await modbus.ReadHoldingRegistersAsync(MODBUS_SLAVE, 0, 5);
Assert.Equal(5, data.Length);
Assert.Equal(new ushort[] { 1, 2, 3, 4, 5 }, data);
await modbus.WriteMultipleRegistersAsync(MODBUS_SLAVE, 0, new ushort[] { 0, 0, 0, 0, 0 });
data = await modbus.ReadHoldingRegistersAsync(MODBUS_SLAVE, 0, 5);
Assert.Equal(5, data.Length);
Assert.Equal(new ushort[] { 0, 0, 0, 0, 0 }, data);
}
public async Task TestHoldingRegister()
{
var factory = new ModbusFactory();
IModbusMaster modbus = factory.CreateMaster(_client);
await _client.ConnectAsync(MODBUS_IP, MODBUS_PORT);
ushort[] data = await modbus.ReadHoldingRegistersAsync(MODBUS_SLAVE, 0, 1);
Assert.Single(data);
await modbus.WriteSingleRegisterAsync(MODBUS_SLAVE, 0, 1);
data = await modbus.ReadHoldingRegistersAsync(MODBUS_SLAVE, 0, 1);
Assert.Single(data);
Assert.Equal(1, data[0]);
await modbus.WriteSingleRegisterAsync(MODBUS_SLAVE, 0, 0);
data = await modbus.ReadHoldingRegistersAsync(MODBUS_SLAVE, 0, 1);
Assert.Single(data);
Assert.Equal(0, data[0]);
}
private async Task <ushort[]> TryExecuteReadQuery(ushort startAddress, ushort numberOfPoints)
{
try
{
await _semaphoreSlim.WaitAsync();
if (!LastTransactionSucceed)
{
throw new Exception("");
}
ushort[] bytes = await _modbusMaster.ReadHoldingRegistersAsync(1, startAddress, numberOfPoints);
_semaphoreSlim.Release();
return(bytes);
}
catch (StackOverflowException s)
{
throw;
}
catch (Exception e)
{
_semaphoreSlim.Release();
if (!LastTransactionSucceed)
{
throw;
}
//_modbusMaster.Dispose();
//OpenConnectionSession(false);
//for (loopIterator = 0; loopIterator < 2; loopIterator++)
//{
// if (LastTransactionSucceed) break;
// await OpenConnectionSession(true);
//}
//loopIterator = 0;
return(null);
//return await TryExecuteReadQuery(startAddress, numberOfPoints);
}
}
public Task <ushort[]> ReadHoldingRegistersAsync(byte slaveAddress, ushort startAddress, ushort numberOfPoints, ushort blockSize, CancellationToken cancellationToken)
{
return(PerformFuncAsync(async() =>
{
List <ushort> registers = new List <ushort>(numberOfPoints);
int soFar = 0;
int thisRead = blockSize;
while (soFar < numberOfPoints)
{
//If we're _not_ on the first run through here, wait for the min time
if (soFar > 0)
{
await Task.Delay(_minInterval, cancellationToken);
}
//Check to see if we've ben cancelled
cancellationToken.ThrowIfCancellationRequested();
if (thisRead > (numberOfPoints - soFar))
{
thisRead = numberOfPoints - soFar;
}
//Perform this operation
ushort[] registersFromThisRead = await _master.ReadHoldingRegistersAsync(slaveAddress, (ushort)(startAddress + soFar), (ushort)thisRead);
//Add these to the result
registers.AddRange(registersFromThisRead);
//Increment where we're at
soFar += thisRead;
}
return registers.ToArray();
}, cancellationToken));
}
public async Task <IQueryResult <ushort[]> > ReadHoldingResgistersAsync(ushort startAddress, ushort numberOfPoints,
string dataTitle)
{
await _semaphoreSlim.WaitAsync();
IQueryResult <ushort[]> queryResult = _queryResultFactory.CreateDefaultQueryResult <ushort[]>();
if (!CheckConnection(queryResult))
{
return(queryResult);
}
try
{
queryResult.Result =
await _currentModbusMaster.ReadHoldingRegistersAsync(_slaveId, startAddress, numberOfPoints);
List <string> results = queryResult.Result.Select((arg => arg.ToString())).ToList();
string resStr = "";
foreach (string res in results)
{
resStr += res;
resStr += " ";
}
LogQuery(true, dataTitle,
"Fun:3" + " Addr:" + startAddress + " Num:" + numberOfPoints + " Data:" + resStr);
queryResult.IsSuccessful = true;
}
catch (Exception e)
{
LogQuery(false, dataTitle, "Fun:3" + " Addr:" + startAddress + " Num:" + numberOfPoints, exception: e);
queryResult.IsSuccessful = false;
queryResult.AddExeption(e);
}
_semaphoreSlim.Release(1);
return(queryResult);
}
/// <inheritdoc/>
public async Task <byte[]> Read(Register register)
{
MakeSureClientIsConnected();
_logger.Information($"Getting data from slave {register.Unit} startingAdress {register.StartingAddress} size {register.Size} as DataType {Enum.GetName(typeof(DataType), register.DataType)}");
ushort[] result;
var size = Convert.ToUInt16(register.Size * GetDataSizeFrom(register.DataType));
try
{
switch (register.FunctionCode)
{
case FunctionCode.HoldingRegister:
result = await _master.ReadHoldingRegistersAsync(register.Unit, register.StartingAddress, size);
break;
case FunctionCode.InputRegister:
result = await _master.ReadInputRegistersAsync(register.Unit, register.StartingAddress, size);
break;
default:
result = new ushort[0];
break;
}
var bytes = result.GetBytes(_configuration.Endianness);
return(bytes);
}
catch (Exception ex)
{
_logger.Error(ex, $"Trouble reading register {register}");
return(null);
}
}
internal static async Task <ushort[]> GetDataByAddress(byte numOfDevice, ushort address, ushort value,
bool isQueryCritical = true)
{
if (_modbusMaster != null)
{
await _semaphoreSlim.WaitAsync();
OnWritingStartedAction?.Invoke();
try
{
ushort[] result;
result = await _modbusMaster.ReadHoldingRegistersAsync(numOfDevice, address, value);
_semaphoreSlim.Release(1);
return(result);
}
catch (Exception e)
{
_semaphoreSlim.Release(1);
if (isQueryCritical)
{
ConnectionLostAction?.Invoke();
}
throw e;
}
finally
{
//_semaphoreSlim.Release();
OnWritingCompleteAction?.Invoke();
}
}
else
{
throw new Exception("Не инициализирован объект связи");
}
}
public async Task <ushort[]> ReadHoldingRegisters(ushort startAddress, ushort pointCount)
{
return(await m_modbusConnection.ReadHoldingRegistersAsync(m_unitID, startAddress, pointCount));
}
