luosheng/Modbus.Net
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2017-05-15 update 2 Add comments.

Browse Source
This commit is contained in:
parallelbgls
2017-05-15 15:26:00 +08:00
parent 16f63d079e
commit 1461efa42f
10 changed files with 362 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Modbus.Net/Modbus.Net.Modbus/Modbus.Net.Modbus.csproj
View File

@@ -23,6 +23,10 @@
<DocumentationFile>bin\Debug\net45\Modbus.Net.Modbus.xml</DocumentationFile>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Bcl.Build" Version="1.0.21" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ModBus.Net\Modbus.Net.csproj" />
</ItemGroup>

1
Modbus.Net/Modbus.Net.OPC/Modbus.Net.OPC.csproj
View File

@@ -25,6 +25,7 @@
<ItemGroup>
<PackageReference Include="H.Opc" Version="0.9.0" />
<PackageReference Include="Microsoft.Bcl.Build" Version="1.0.21" />
</ItemGroup>
<ItemGroup>

4
Modbus.Net/Modbus.Net.Siemens/Modbus.Net.Siemens.csproj
View File

@@ -22,6 +22,10 @@
<DocumentationFile>bin\Debug\net45\Modbus.Net.Siemens.xml</DocumentationFile>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Bcl.Build" Version="1.0.21" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ModBus.Net\Modbus.Net.csproj" />
</ItemGroup>

2
Modbus.Net/Modbus.Net/ComConnector.cs
View File

@@ -409,7 +409,7 @@ namespace Modbus.Net
Array.Copy(data, 0, returndata, 0, i);
return returndata;
}
catch (Exception ex)
catch (Exception)
{
Dispose();
return null;

7
Modbus.Net/src/Base.Common/AsyncHelper.cs
View File

@@ -55,6 +55,13 @@ namespace Modbus.Net
return task.ContinueWith(t => t.GetAwaiter().GetResult(), token);
}
/// <summary>
/// Add a CancellationToken to async task
/// </summary>
/// <typeparam name="T">type of a task</typeparam>
/// <param name="task">Task</param>
/// <param name="token">Cancellation token</param>
/// <returns>Task with cancellation token</returns>
public static Task<T> WithCancellation<T>(this Task<T> task,
CancellationToken token)
{

16
Modbus.Net/src/Base.Common/BaseMachine.cs
View File

@@ -662,6 +662,10 @@ namespace Modbus.Net
return BaseUtility.Disconnect();
}
/// <summary>
/// 获取设备的Id，字符串格式
/// </summary>
/// <returns></returns>
public string GetMachineIdString()
{
return Id.ToString();
@@ -821,12 +825,20 @@ namespace Modbus.Net
/// </summary>
public UnitExtend UnitExtend { get; set; }
/// <summary>
/// 两个地址是否一致
/// </summary>
/// <param name="other">另一个地址</param>
/// <returns>是否一致</returns>
public bool Equals(AddressUnit<TKey> other)
{
return (Area.ToUpper() == other.Area.ToUpper() && Address == other.Address) || Id.Equals(other.Id);
}
}
/// <summary>
/// 没有Id的设备属性
/// </summary>
public interface IMachinePropertyWithoutKey
{
/// <summary>
@@ -888,6 +900,10 @@ namespace Modbus.Net
/// <returns>是否断开成功</returns>
bool Disconnect();
/// <summary>
/// 获取设备的Id的字符串
/// </summary>
/// <returns></returns>
string GetMachineIdString();
}

7
Modbus.Net/src/Base.Common/CRC16.cs
View File

@@ -44,7 +44,6 @@ namespace Modbus.Net
/// </summary>
/// <param name="message">发送或返回的命令，CRC码除外</param>
/// <param name="Rcvbuf">存储CRC码的字节的数组</param>
/// <param name="CRC">生成的CRC码</param>
public short GetCRC(byte[] message, ref byte[] Rcvbuf)
{
int IX, IY, CRC;
@@ -83,7 +82,7 @@ namespace Modbus.Net
/// <summary>
/// CRC校验
/// </summary>
/// <param name="src">ST开头，&&结尾</param>
/// <param name="byteframe">需要校验的字节数组</param>
/// <returns>十六进制数</returns>
public bool CrcEfficacy(byte[] byteframe)
{
@@ -149,15 +148,13 @@ namespace Modbus.Net
decByteTotal = 255 - decByteTotal + 1;
decByteTotal = decByteTotal & 255;
int a, b = 0;
string hexByte = "", hexTotal = "";
double i;
for (i = 0; decByteTotal > 0; i++)
{
//b = Convert.ToInt32(System.Math.Pow(16.0, i));
a = decByteTotal%16;
var a = decByteTotal%16;
decByteTotal /= 16;
if (a <= 9)
hexByte = a.ToString();

347
Modbus.Net/src/Base.Common/TaskManager.cs
View File

@@ -25,10 +25,19 @@ namespace Modbus.Net
/// </summary>
public class DataReturnDef<TMachineKey> where TMachineKey : IEquatable<TMachineKey>
{
/// <summary>
/// 设备的Id
/// </summary>
public TMachineKey MachineId { get; set; }
/// <summary>
/// 返回的数据值
/// </summary>
public Dictionary<string, ReturnUnit> ReturnValues { get; set; }
}
/// <summary>
/// Limited concurrency level task scheduler
/// </summary>
public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
{
/// <summary>
@@ -192,20 +201,45 @@ namespace Modbus.Net
}
}
/// <summary>
/// 具有任务管理的设备
/// </summary>
/// <typeparam name="TMachineKey">设备的Id类型</typeparam>
public class TaskMachine<TMachineKey> where TMachineKey : IEquatable<TMachineKey>
{
private TaskFactory _tasks { get; }
/// <summary>
/// 任务工厂
/// </summary>
private readonly TaskFactory _tasks;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="machine">设备</param>
/// <param name="taskFactory">任务工厂</param>
public TaskMachine(IMachineProperty<TMachineKey> machine, TaskFactory taskFactory)
{
Machine = machine;
_tasks = taskFactory;
TasksWithTimer = new List<ITaskItem>();
}
/// <summary>
/// 设备
/// </summary>
public IMachineProperty<TMachineKey> Machine { get; }
public List<ITaskItem> TasksWithTimer { get; set; }
/// <summary>
/// 任务调度器
/// </summary>
public List<ITaskItem> TasksWithTimer { get; }
/// <summary>
/// 定时方式启动任务
/// </summary>
/// <typeparam name="TInterType">任务返回值的类型</typeparam>
/// <param name="task">任务</param>
/// <returns>任务是否执行成功</returns>
public bool InvokeTimer<TInterType>(TaskItem<TInterType> task)
{
task.DetectConnected = () => Machine.IsConnected;
@@ -221,6 +255,11 @@ namespace Modbus.Net
return false;
}
/// <summary>
/// 停止任务
/// </summary>
/// <param name="taskItemName">任务的名称</param>
/// <returns>是否停止成功</returns>
public bool StopTimer(string taskItemName)
{
if (TasksWithTimer.Exists(taskCon => taskCon.Name == taskItemName))
@@ -233,6 +272,10 @@ namespace Modbus.Net
return false;
}
/// <summary>
/// 停止所有任务
/// </summary>
/// <returns>是否停止成功</returns>
public bool StopAllTimers()
{
bool ans = true;
@@ -243,6 +286,11 @@ namespace Modbus.Net
return ans;
}
/// <summary>
/// 暂时任务
/// </summary>
/// <param name="taskItemName">任务的名称</param>
/// <returns>是否暂停成功</returns>
public bool PauseTimer(string taskItemName)
{
if (TasksWithTimer.Exists(taskCon => taskCon.Name == taskItemName))
@@ -254,6 +302,10 @@ namespace Modbus.Net
return false;
}
/// <summary>
/// 暂停所有任务
/// </summary>
/// <returns>是否暂停成功</returns>
public bool PauseAllTimers()
{
bool ans = true;
@@ -264,6 +316,11 @@ namespace Modbus.Net
return ans;
}
/// <summary>
/// 恢复任务
/// </summary>
/// <param name="taskItemName">任务的名称</param>
/// <returns>是否恢复任务</returns>
public bool ContinueTimer(string taskItemName)
{
if (TasksWithTimer.Exists(taskCon => taskCon.Name == taskItemName))
@@ -275,6 +332,10 @@ namespace Modbus.Net
return false;
}
/// <summary>
/// 恢复所有任务
/// </summary>
/// <returns>是否恢复成功</returns>
public bool ContinueAllTimers()
{
bool ans = true;
@@ -285,12 +346,18 @@ namespace Modbus.Net
return ans;
}
/// <summary>
/// 执行任务一次
/// </summary>
/// <typeparam name="TInterType">任务返回值的类型</typeparam>
/// <param name="task">任务</param>
/// <returns>任务是否执行成功</returns>
public async Task<bool> InvokeOnce<TInterType>(TaskItem<TInterType> task)
{
if (Machine.IsConnected)
{
var ans = await task.Invoke(Machine, _tasks, task.Params);
task.Return(ans);
task.Return?.Invoke(ans);
return true;
}
return false;
@@ -311,17 +378,40 @@ namespace Modbus.Net
}
}
/// <summary>
/// 任务的接口
/// </summary>
public interface ITaskItem
{
/// <summary>
/// 任务的名称
/// </summary>
string Name { get; set; }
/// <summary>
/// 启动计时器
/// </summary>
/// <returns></returns>
bool StartTimer();
/// <summary>
/// 停止计时器
/// </summary>
/// <returns></returns>
bool StopTimer();
}
/// <summary>
/// 获取数据的预定义任务
/// </summary>
public class TaskItemGetData : TaskItem<DataReturnDef>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="returnFunc">返回值的处理函数</param>
/// <param name="getCycle">循环间隔(毫秒)</param>
/// <param name="sleepCycle">设备离线时的循环间隔(毫秒)</param>
public TaskItemGetData(Action<DataReturnDef> returnFunc, int getCycle, int sleepCycle)
{
Name = "GetDatas";
@@ -347,9 +437,17 @@ namespace Modbus.Net
}
}
/// <summary>
/// 写入数据的预定义任务
/// </summary>
public class TaskItemSetData : TaskItem<bool>
{
public TaskItemSetData(Dictionary<string, double> values)
/// <summary>
/// 构造函数
/// </summary>
/// <param name="values">写入的值</param>
/// <param name="returnFunc">返回值的处理函数</param>
public TaskItemSetData(Dictionary<string, double> values, Action<bool> returnFunc = null)
{
Name = "SetDatas";
Invoke = Invoke = async (machine, tasks, parameters) =>
@@ -364,50 +462,106 @@ namespace Modbus.Net
return ans;
};
Params = new object[]{values};
Return = returnFunc;
}
}
/// <summary>
/// 任务
/// </summary>
/// <typeparam name="TInterType">任务返回值的类型</typeparam>
public class TaskItem<TInterType> : ITaskItem, IEquatable<TaskItem<TInterType>>
{
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 定时器
/// </summary>
private Timer Timer { get; set; }
/// <summary>
/// 定时器的时间
/// </summary>
public int TimerTime { get; set; }
/// <summary>
/// 离线定时器
/// </summary>
private Timer TimerDisconnected { get; set; }
/// <summary>
/// 离线定时器的时间
/// </summary>
public int TimerDisconnectedTime { get; set; }
/// <summary>
/// 执行的任务
/// </summary>
public Func<IMachinePropertyWithoutKey, TaskFactory, object[], Task<TInterType>> Invoke { get; set; }
/// <summary>
/// 检测设备的在线状态
/// </summary>
internal Func<bool> DetectConnected { get; set; }
/// <summary>
/// 任务执行的参数
/// </summary>
public object[] Params { get; set; }
/// <summary>
/// 返回值的处理函数
/// </summary>
public Action<TInterType> Return { get; set; }
/// <summary>
/// 获取设备
/// </summary>
internal Func<IMachinePropertyWithoutKey> GetMachine { get; set; }
/// <summary>
/// 获取任务工厂
/// </summary>
internal Func<TaskFactory> GetTaskFactory { get; set; }
/// <summary>
/// 是否相等
/// </summary>
/// <param name="other">另一个实例</param>
/// <returns>是否相等</returns>
public bool Equals(TaskItem<TInterType> other)
{
return Name == other?.Name;
}
/// <summary>
/// 启动定时器
/// </summary>
/// <returns>是否成功</returns>
public bool StartTimer()
{
ActivateTimerDisconnected();
return true;
}
/// <summary>
/// 激活定时器
/// </summary>
private void ActivateTimer()
{
Timer = new Timer(async state =>
{
if (!DetectConnected()) TimerChangeToDisconnect();
var ans = await Invoke(GetMachine(),GetTaskFactory(),Params);
Return(ans);
Return?.Invoke(ans);
}, null, 0, TimerTime);
}
/// <summary>
/// 反激活定时器
/// </summary>
private void DeactivateTimer()
{
Timer.Dispose();
Timer = null;
}
/// <summary>
/// 激活离线定时器
/// </summary>
private void ActivateTimerDisconnected()
{
TimerDisconnected = new Timer(async state =>
@@ -417,12 +571,19 @@ namespace Modbus.Net
}, null, 0, TimerDisconnectedTime);
}
/// <summary>
/// 反激活离线定时器
/// </summary>
private void DeactivateTimerDisconnected()
{
TimerDisconnected.Dispose();
TimerDisconnected = null;
}
/// <summary>
/// 将定时器切换至在线
/// </summary>
/// <returns></returns>
private bool TimerChangeToConnect()
{
DeactivateTimerDisconnected();
@@ -430,6 +591,10 @@ namespace Modbus.Net
return true;
}
/// <summary>
/// 将定时器切换至离线
/// </summary>
/// <returns></returns>
private bool TimerChangeToDisconnect()
{
DeactivateTimer();
@@ -437,6 +602,10 @@ namespace Modbus.Net
return true;
}
/// <summary>
/// 停止定时器
/// </summary>
/// <returns></returns>
public bool StopTimer()
{
DeactivateTimer();
@@ -450,27 +619,51 @@ namespace Modbus.Net
/// </summary>
public class TaskManager : TaskManager<string>
{
/// <summary>
/// 构造一个TaskManager
/// </summary>
/// <param name="maxRunningTask">同时可以运行的任务数</param>
/// <param name="keepConnect">读取数据后是否保持连接</param>
/// <param name="dataType">获取与设置数据的方式</param>
public TaskManager(int maxRunningTask, bool keepConnect,
MachineDataType dataType = MachineDataType.CommunicationTag)
: base(maxRunningTask, keepConnect, dataType)
{
}
/// <summary>
/// 添加一台设备
/// </summary>
/// <param name="machine">设备</param>
public void AddMachine(BaseMachine machine)
{
base.AddMachine(machine);
}
/// <summary>
/// 添加多台设备
/// </summary>
/// <param name="machines">多台设备</param>
public void AddMachines(IEnumerable<BaseMachine> machines)
{
base.AddMachines(machines);
}
/// <summary>
/// 通过Id获取设备
/// </summary>
/// <param name="id">设备Id</param>
/// <returns>获取的设备</returns>
public BaseMachine GetMachineById(string id)
{
return base.GetMachineById<string>(id) as BaseMachine;
}
/// <summary>
/// 通过通讯标志获取设备
/// </summary>
/// <param name="connectionToken">通讯标志</param>
/// <returns>获取的设备</returns>
public BaseMachine GetMachineByConnectionToken(string connectionToken)
{
return base.GetMachineByConnectionToken<string>(connectionToken) as BaseMachine;
@@ -480,7 +673,7 @@ namespace Modbus.Net
/// <summary>
/// 任务调度器
/// </summary>
/// <typeparam name="TMachineKey"></typeparam>
/// <typeparam name="TMachineKey">设备Id的类型</typeparam>
public class TaskManager<TMachineKey> where TMachineKey : IEquatable<TMachineKey>
{
/// <summary>
@@ -488,6 +681,9 @@ namespace Modbus.Net
/// </summary>
private readonly HashSet<TaskMachine<TMachineKey>> _machines;
/// <summary>
/// 全局任务取消标志
/// </summary>
private CancellationTokenSource _cts;
/// <summary>
@@ -554,6 +750,9 @@ namespace Modbus.Net
}
}
/// <summary>
/// 设备读写设备的关键字
/// </summary>
public MachineDataType MachineDataType
{
set
@@ -588,7 +787,13 @@ namespace Modbus.Net
}
}
/// <summary>
/// 设备读数据的关键字
/// </summary>
public MachineGetDataType GetDataType { get; set; }
/// <summary>
/// 设备写数据的关键字
/// </summary>
public MachineSetDataType SetDataType { get; set; }
/// <summary>
@@ -615,7 +820,7 @@ namespace Modbus.Net
machine.KeepConnect = KeepConnect;
lock (_machines)
{
_machines.Add(new TaskMachine<TMachineKey>(machine, _tasks) {TasksWithTimer = new List<ITaskItem>()});
_machines.Add(new TaskMachine<TMachineKey>(machine, _tasks));
}
}
@@ -635,6 +840,12 @@ namespace Modbus.Net
}
}
/// <summary>
/// 通过Id获取设备
/// </summary>
/// <typeparam name="TUnitKey">设备地址Id的类型</typeparam>
/// <param name="id">设备的Id</param>
/// <returns>获取设备</returns>
public BaseMachine<TMachineKey, TUnitKey> GetMachineById<TUnitKey>(TMachineKey id)
where TUnitKey : IEquatable<TUnitKey>
{
@@ -654,6 +865,12 @@ namespace Modbus.Net
}
}
/// <summary>
/// 通过通讯标志获取设备
/// </summary>
/// <typeparam name="TUnitKey">设备地址Id的类型</typeparam>
/// <param name="connectionToken">通讯标志</param>
/// <returns>获取的数据</returns>
public BaseMachine<TMachineKey, TUnitKey> GetMachineByConnectionToken<TUnitKey>(string connectionToken)
where TUnitKey : IEquatable<TUnitKey>
{
@@ -709,78 +926,117 @@ namespace Modbus.Net
}
}
/// <summary>
/// 所有设备执行定时任务
/// </summary>
/// <typeparam name="TInterType">任务返回值的类型</typeparam>
/// <param name="item">任务</param>
/// <returns>所有任务是否执行成功</returns>
public bool InvokeTimerAll<TInterType>(TaskItem<TInterType> item)
{
var ans = true;
lock (_machines)
{
foreach (var machine in _machines)
{
machine.InvokeTimer(item);
ans &= machine.InvokeTimer(item);
}
}
return true;
return ans;
}
/// <summary>
/// 所有设备停止执行所有任务
/// </summary>
/// <returns>所有任务是否停止成功</returns>
public bool StopTimerAll()
{
var ans = true;
lock (_machines)
{
foreach (var machine in _machines)
{
machine.StopAllTimers();
ans &= machine.StopAllTimers();
}
}
return true;
return ans;
}
/// <summary>
/// 所有设备停止执行某一个任务
/// </summary>
/// <param name="taskItemName">任务名称</param>
/// <returns>任务是否停止成功</returns>
public bool StopTimerAll(string taskItemName)
{
var ans = true;
lock (_machines)
{
foreach (var machine in _machines)
{
machine.StopTimer(taskItemName);
ans &= machine.StopTimer(taskItemName);
}
}
return true;
return ans;
}
/// <summary>
/// 所有设备暂停执行所有任务
/// </summary>
/// <returns>任务是否暂停成功</returns>
public bool PauseTimerAll()
{
var ans = true;
lock (_machines)
{
foreach (var machine in _machines)
{
machine.PauseAllTimers();
ans &= machine.PauseAllTimers();
}
}
return true;
return ans;
}
/// <summary>
/// 所有设备暂停执行某一个任务
/// </summary>
/// <param name="taskItemName">任务的名称</param>
/// <returns>任务是否暂停成功</returns>
public bool PauseTimerAll(string taskItemName)
{
var ans = true;
lock (_machines)
{
foreach (var machine in _machines)
{
machine.PauseTimer(taskItemName);
ans &= machine.PauseTimer(taskItemName);
}
}
return true;
return ans;
}
/// <summary>
/// 所有设备继续执行所有任务
/// </summary>
/// <returns>所有任务是否继续执行成功</returns>
public bool ContinueTimerAll()
{
var ans = true;
lock (_machines)
{
foreach (var machine in _machines)
{
machine.ContinueAllTimers();
ans &= machine.ContinueAllTimers();
}
}
return true;
return ans;
}
/// <summary>
/// 所有设备继续执行某一个任务
/// </summary>
/// <param name="taskItemName">任务的名称</param>
/// <returns>任务是否继续执行成功</returns>
public bool ConinueTimerAll(string taskItemName)
{
lock (_machines)
@@ -793,6 +1049,12 @@ namespace Modbus.Net
return true;
}
/// <summary>
/// 所有设备执行一个一次性任务
/// </summary>
/// <typeparam name="TInterType">任务的返回值类型</typeparam>
/// <param name="item">任务</param>
/// <returns>任务是否执行成功</returns>
public async Task<bool> InvokeOnceAll<TInterType>(TaskItem<TInterType> item)
{
var tasks = new List<Task<bool>>();
@@ -807,57 +1069,84 @@ namespace Modbus.Net
return ans.All(p=>p);
}
/// <summary>
/// 某个设备执行一个一次性任务
/// </summary>
/// <typeparam name="TInterType">任务的返回值类型</typeparam>
/// <param name="machineId">设备的Id</param>
/// <param name="item">任务</param>
/// <returns>任务是否执行成功</returns>
public async Task<bool> InvokeOnceForMachine<TInterType>(TMachineKey machineId, TaskItem<TInterType> item)
{
var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
if (machine != null)
{
await machine.InvokeOnce(item);
return true;
return await machine.InvokeOnce(item);
}
return false;
}
/// <summary>
/// 某个设备执行一个定时任务
/// </summary>
/// <typeparam name="TInterType">任务的返回值类型</typeparam>
/// <param name="machineId">设备的Id</param>
/// <param name="item">任务</param>
/// <returns>任务是否执行成功</returns>
public bool InvokeTimerForMachine<TInterType>(TMachineKey machineId, TaskItem<TInterType> item)
{
var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
if (machine != null)
{
machine.InvokeTimer(item);
return true;
return machine.InvokeTimer(item);
}
return false;
}
/// <summary>
/// 某个设备停止一个定时任务
/// </summary>
/// <param name="machineId">任务的Id</param>
/// <param name="taskItemName">任务的名称</param>
/// <returns>任务是否停止成功</returns>
public bool StopTimerForMachine(TMachineKey machineId, string taskItemName)
{
var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
if (machine != null)
{
machine.StopTimer(taskItemName);
return true;
return machine.StopTimer(taskItemName);
}
return false;
}
/// <summary>
/// 某个设备暂停一个定时任务
/// </summary>
/// <param name="machineId">任务的Id</param>
/// <param name="taskItemName">任务的名称</param>
/// <returns>任务是否暂停成功</returns>
public bool PauseTimerForMachine(TMachineKey machineId, string taskItemName)
{
var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
if (machine != null)
{
machine.PauseTimer(taskItemName);
return true;
return machine.PauseTimer(taskItemName);
}
return false;
}
/// <summary>
/// 某个设备继续进行一个定时任务
/// </summary>
/// <param name="machineId">任务的Id</param>
/// <param name="taskItemName">任务的名称</param>
/// <returns>任务是否继续运行成功</returns>
public bool ContinueTimerForMachine(TMachineKey machineId, string taskItemName)
{
var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
if (machine != null)
{
machine.ContinueTimer(taskItemName);
return true;
return machine.ContinueTimer(taskItemName);
}
return false;
}

6
Modbus.Net/src/Base.Common/TypeExtensions.cs
View File

@@ -8,6 +8,9 @@ using System.Threading.Tasks;
namespace Modbus.Net
{
/// <summary>
/// Extensions of Reflection
/// </summary>
public static class TypeExtensions
{
#region Public Methods
@@ -22,6 +25,9 @@ namespace Modbus.Net
/// <param name="args">
/// The types of the method's arguments to match.
/// </param>
/// <param name="isGenericMethod">
/// Is method Generic Method.
/// </param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// Thrown if:

3
Modbus.Net/src/Base.Common/ValueHelper.cs
View File

@@ -1244,7 +1244,8 @@ namespace Modbus.Net
/// 设置对应数字中相应位置的bit的值
/// </summary>
/// <param name="number">byte数子</param>
/// <param name="subPos">设置位置</param>
/// <param name="pos">设置的位置</param>
/// <param name="subPos">设置的子位置</param>
/// <param name="setBit">设置bit大小，true为1，false为0</param>
/// <returns>设置是否成功</returns>
public override bool SetBit(byte[] number, int pos, int subPos, bool setBit)