protected virtual void BindDeviceHandler(IRunDevice dev, DeviceType deviceType, bool isBind)
{
if (deviceType == DeviceType.Virtual)
{
#region
if (isBind)
{
dev.DeviceRuningLog += DeviceRuningLog;
dev.UpdateContainer += UpdateContainer;
dev.DeviceObjectChanged += DeviceObjectChanged;
dev.DeleteDevice += DeleteDevice;
dev.DeviceConnector += DeviceConnector;
}
else
{
dev.DeviceRuningLog -= DeviceRuningLog;
dev.UpdateContainer -= UpdateContainer;
dev.DeviceObjectChanged -= DeviceObjectChanged;
dev.DeleteDevice -= DeleteDevice;
dev.DeviceConnector -= DeviceConnector;
}
#endregion
}
else
{
if (isBind)
{
dev.DeviceRuningLog += DeviceRuningLog;
dev.UpdateContainer += UpdateContainer;
dev.DeviceObjectChanged += DeviceObjectChanged;
dev.SendData += SendData;
dev.DeleteDevice += DeleteDevice;
dev.DeviceConnector += DeviceConnector;
}
else
{
dev.DeviceRuningLog -= DeviceRuningLog;
dev.UpdateContainer -= UpdateContainer;
dev.DeviceObjectChanged -= DeviceObjectChanged;
dev.SendData -= SendData;
dev.DeleteDevice -= DeleteDevice;
dev.DeviceConnector -= DeviceConnector;
}
}
}
protected override void BindDeviceHandler(IRunDevice dev, DeviceType devType, bool isBind)
{
if (devType == DeviceType.Virtual)
{
#region
if (isBind)
{
dev.DeviceRuningLog += DeviceRuningLog;
dev.DeviceObjectChanged += new DeviceObjectChangedHandler(DeviceObjectChanged);
}
else
{
dev.DeviceRuningLog -= new DeviceRuningLogHandler(DeviceRuningLog);
dev.DeviceObjectChanged -= new DeviceObjectChangedHandler(DeviceObjectChanged);
}
#endregion
}
else
{
if (isBind)
{
dev.DeviceRuningLog += DeviceRuningLog;
dev.DeviceObjectChanged += DeviceObjectChanged;
//dev.ReceiveData += ReceiveData;
dev.SendData += SendData;
if (dev.CommunicateType == CommunicateType.COM)
{
dev.ComParameterExchange += ComParameterExchange;
}
}
else
{
dev.DeviceRuningLog -= DeviceRuningLog;
dev.DeviceObjectChanged -= DeviceObjectChanged;
//dev.ReceiveData -= ReceiveData;
dev.SendData -= SendData;
if (dev.CommunicateType == CommunicateType.COM)
{
dev.ComParameterExchange -= ComParameterExchange;
}
}
}
}
private void GraphicsShow_MouseRightContextMenu(string devid)
{
IRunDevice dev = DeviceManager.GetDevice(devid);
if (dev != null)
{
try
{
dev.ShowContextMenu();
}
catch (Exception ex)
{
Logger.Error(true, ex.Message);
}
}
else
{
Logger.Info(false, "未找到能够显示菜单的设备");
}
}
private void UpdateContainer(object source, UpdateContainerArgs e)
{
if (e == null)
{
return;
}
if (_deviceContainer != null)
{
IRunDevice dev = this.DeviceManager.GetDevice(e.DeviceID);
if (dev != null)
{
IDeviceContainerItem item = dev.GetDeviceContainerItem();
if (item != null)
{
_deviceContainer.UpdateDevice(e.DeviceID, item);
}
}
}
}
/// <summary>
/// 运行调度设备
/// </summary>
/// <param name="dev"></param>
private void RunDevice(IRunDevice dev)
{
try
{
if (!_Com.IsDisposed)
{
if (!_Com.IsOpen)
{
lock (_Com.SyncLock)
{
_Com.Open();
}
}
if (_Com.IsOpen)
{
dev.Run((IChannel)_Com); //驱动设备运行接口
}
else
{
dev.Run((IChannel)null);
}
}
else
{
dev.Run((IChannel)null);
}
if (_Com == null || !_Com.IsOpen)
{
System.Threading.Thread.Sleep(1000);
}
//------------------------------------------------//
}
catch (Exception ex)
{
this.Server.Logger.Error(true, "串口控制器", ex);
}
}
private void RunConnector()
{
while (!_IsExited)
{
IRunDevice[] devList = this.Server.DeviceManager.GetDevices(WorkMode.TcpClient);
if (devList.Length > 0)
{
#region
for (int i = 0; i < devList.Length; i++)
{
IRunDevice dev = devList[i];
IChannel channel = this.Server.ChannelManager.GetChannel(dev.DeviceParameter.NET.RemoteIP, CommunicateType.NET);
if (channel == null)
{
StartConnect(dev.DeviceParameter.NET.RemoteIP, dev.DeviceParameter.NET.RemotePort);
}
}
#endregion
}
System.Threading.Thread.Sleep(1000);
}
}
/// <summary>
/// 初始化驱动
/// </summary>
public virtual void InitDriver(IRunDevice runDevice)
{
this._Commands.Clear();
Assembly asm = runDevice.GetType().Assembly;
Type[] types = asm.GetTypes();
foreach (Type t in types)
{
if (typeof(IProtocolCommand).IsAssignableFrom(t))
{
if (t.Name != "IProtocolCommand" && t.Name != "ProtocolCommand")
{
IProtocolCommand cmd = (IProtocolCommand)t.Assembly.CreateInstance(t.FullName);
if (cmd != null)
{
cmd.Setup(this);
_Commands.TryAdd(cmd.Name, cmd);
}
}
}
}
}
protected override void BindDeviceHandler(IRunDevice dev, DeviceType devType, bool isBind)
{
if (devType != DeviceType.Virtual)
{
if (isBind)
{
if (dev.CommunicateType == CommunicateType.COM)
{
dev.ComParameterExchange += ComParameterExchange;
}
}
else
{
if (dev.CommunicateType == CommunicateType.COM)
{
dev.ComParameterExchange -= ComParameterExchange;
}
}
}
base.BindDeviceHandler(dev, devType, isBind);
}
private IReceivePackage InternalReceivePackageData(IList <byte[]> listBytes)
{
IReceivePackage rp = new ReceivePackage()
{
RemoteIP = this.RemoteIP,
RemotePort = this.RemotePort
};
if (listBytes.Count > 0)
{
if (this.Server.ServerConfig.StartCheckPackageLength)
{
IRunDevice dev = InternalCheckCodeDevice(listBytes[0]);
if (dev != null)
{
rp.DeviceCode = dev.DeviceParameter.DeviceCode;
rp.RequestInfos = ((RunDevice)dev).InternalReceiveChannelPackageData(this.Channel, listBytes);
}
else
{
foreach (byte[] b in listBytes)
{
rp.RequestInfos.Add(new RequestInfo(this.Key, b, this.Channel));
}
}
}
else
{
foreach (byte[] b in listBytes)
{
rp.RequestInfos.Add(new RequestInfo(this.Key, b, this.Channel));
}
}
}
return(rp);
}
private void DeviceConnectorCallback(IAsyncResult ar)
{
DeviceConnectorToken token = (DeviceConnectorToken)ar.AsyncState;
IRunDevice sourceDevice = this.DeviceManager.GetDevice(token.FromDeviceID);
if (sourceDevice == null)
{
return;
}
object obj = null;
try
{
obj = token.DeviceConnectorAsync.EndInvoke(ar);
}
catch (Exception ex)
{
try
{
sourceDevice.DeviceConnectorCallbackError(ex);
}
catch (Exception e)
{
this.Logger.Error(true, "", e);
}
}
try
{
sourceDevice.DeviceConnectorCallback(obj);
}
catch (Exception ex)
{
this.Logger.Error(true, "", ex);
}
}
/// <summary>
/// 运行器
/// </summary>
private void RunController()
{
while (!IsExited)
{
if (!IsWorking)
{
System.Threading.Thread.Sleep(1000);
continue;
}
ControlMode mode = Server.Config.ControlMode;
if (mode == ControlMode.Singleton)
{
System.Threading.Thread.Sleep(100); //不进行调度
}
else if (mode == ControlMode.Self)
{
System.Threading.Thread.Sleep(100);//不进行调度
}
else if (mode == ControlMode.Parallel)
{
#region
IRunDevice[] list = this.Server.DeviceManager.GetDevices(CommunicateType.NET);
if (list.Length <= 0)
{
System.Threading.Thread.Sleep(100);
continue;
}
for (int i = 0; i < list.Length; i++)
{
if (IsExited || !IsWorking)
{
break;
}
Send(list[i], list[i].GetSendBytes());
}
System.Threading.Thread.Sleep(1000);
#endregion
}
else if (mode == ControlMode.Loop)
{
#region
IRunDevice[] devList = this.Server.DeviceManager.GetDevices(CommunicateType.NET);
if (devList.Length <= 0)
{
System.Threading.Thread.Sleep(100);
continue;
}
//检测当前控制器的运行优化级
IRunDevice dev = this.Server.DeviceManager.GetPriorityDevice(devList);
if (dev != null) //如果有优先级设备，则直接调度设备
{
this.RunDevice(dev);
}
else //如果没有优先级设备，则轮询调度设备
{
for (int i = 0; i < devList.Length; i++)
{
if (IsExited || !IsWorking)
{
break;
}
//---------每次循环都检测优先级，保证及时响应----------//
dev = this.Server.DeviceManager.GetPriorityDevice(devList);
if (dev != null)
{
this.RunDevice(dev);
}
//-------------------------------------------------//
this.RunDevice(devList[i]);
}
}
#endregion
}
}
}
public override void ChangeDeviceComInfo(string devid, int oldCom, int oldBaud, int newCom, int newBaud)
{
IRunDevice dev = DeviceManager.GetDevice(devid);
if (dev == null)
{
Logger.Info(true, String.Format("{0}号设备，改变串口信息不存在", devid.ToString()));
}
else
{
int oldComPort = oldCom;
int oldComBaud = oldBaud;
int newComPort = newCom;
int newComBaud = newBaud;
bool success = true;
if (dev.CommunicateType == CommunicateType.COM)
{
if (oldComPort != newComPort)
{
#region 对旧串口进行处理
//--------------对旧串口进行处理----------------//
IRunDevice[] oldComDevList = DeviceManager.GetDevices(oldComPort.ToString(), CommunicateType.COM);
int oldComDevCount = oldComDevList.Count((d) => d.GetHashCode() != dev.GetHashCode()); //当前串口不等于当前设备的设备数
if (oldComDevCount <= 0) //先修改设备的串口参数，该串口没有可用的设备
{
string oldKey = ComUtils.PortToString(oldComPort);
IController oldComController = ControllerManager.GetController(oldKey);
if (oldComController != null)
{
if (ControllerManager.RemoveController(oldComController.Key))
{
oldComController.StopController();
oldComController.Dispose();
IComSession comChannel = (IComSession)((IComController)oldComController).ComChannel;
comChannel.Close();
comChannel.COMOpen -= ComChannel_COMOpen;
comChannel.COMClose -= ComChannel_COMClose;
comChannel.COMError -= ComChannel_COMError;
if (ChannelManager.RemoveChannel(comChannel.Key))
{
comChannel.Close();
comChannel.Dispose();
}
}
else
{
success = false;
}
}
else
{
Logger.Info(true, "该设备的串口控制器为空");
}
}
#endregion
#region 对新串口进行处理
string newKey = ComUtils.PortToString(newComPort);
//--------------对新串口进行处理----------------//
bool newComControllerExist = ControllerManager.ContainController(newKey);
if (!newComControllerExist)
{
IChannel channel = ChannelManager.GetChannel(newKey);
if (channel == null)
{
IComSession comChannel = new ComSession(newComPort, newComBaud);
comChannel.Setup(this);
comChannel.Initialize();
comChannel.COMOpen += ComChannel_COMOpen;
comChannel.COMClose += ComChannel_COMClose;
comChannel.COMError += ComChannel_COMError;
comChannel.Open();
channel = (IChannel)comChannel;
ChannelManager.AddChannel(comChannel.Key, channel);
}
IController controller = ControllerManager.GetController(newKey);
if (controller == null)
{
controller = new ComController((IComSession)channel);
controller.Setup(this);
if (ControllerManager.AddController(controller.Key, controller))
{
controller.StartController();
}
}
else
{
IComController comController = (IComController)controller;
if (comController.ComChannel.GetHashCode() != channel.GetHashCode())
{
comController.ComChannel = (IComSession)channel;
}
}
}
if (success)
{
dev.DeviceParameter.COM.Port = newComPort;
Logger.Info(true, String.Format("{0},串口从{1}改为{2},成功", dev.DeviceParameter.DeviceName, oldComPort.ToString(), newComPort.ToString()));
}
else
{
Logger.Info(true, String.Format("{0},串口从{1}改为{2},失败", dev.DeviceParameter.DeviceName, oldComPort.ToString(), newComPort.ToString()));
}
#endregion
}
else
{
#region 波特率
if (oldComBaud != newComBaud)
{
IComSession comIO = (IComSession)ChannelManager.GetChannel(ComUtils.PortToString(oldComPort));
if (comIO != null)
{
success = comIO.Settings(newComBaud);
if (success)
{
dev.DeviceParameter.COM.Baud = newComBaud;
Logger.Info(true, String.Format("{0},串口{1}的波特率从{2}改为{3},成功", dev.DeviceParameter.DeviceName, oldComPort.ToString(), oldComBaud.ToString(), newComBaud.ToString()));
}
else
{
Logger.Info(true, String.Format("{0},串口{1}的波特率从{2}改为{3},失败", dev.DeviceParameter.DeviceName, oldComPort.ToString(), oldComBaud.ToString(), newComBaud.ToString()));
}
}
}
#endregion
}
}
else
{
Logger.Info(true, String.Format("{0},不是串口类型的设备", dev.DeviceParameter.DeviceName));
}
}
}
private void ProcessReceive(SocketAsyncEventArgs e)
{
ISocketSession socketSession = (ISocketSession)e.UserToken;
if (socketSession != null && socketSession.Client != null)
{
try
{
if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
{
SocketAsyncEventArgsEx saeaEx = (SocketAsyncEventArgsEx)e;
if (saeaEx.NextOffset >= saeaEx.InitOffset + saeaEx.Capacity)
{
saeaEx.Reset();
}
saeaEx.DataLength += saeaEx.BytesTransferred;
IReceivePackage dataPackage = new ReceivePackage();
dataPackage.RemoteIP = this.RemoteIP;
dataPackage.RemotePort = this.RemotePort;
#region 过滤数据
if (this.Server.ServerConfig.StartReceiveDataFliter)
{
IRunDevice[] devList = this.Server.DeviceManager.GetDevices(CommunicateType.NET);
if (devList != null && devList.Length > 0)
{
if (this.Server.ServerConfig.ControlMode == ControlMode.Loop ||
this.Server.ServerConfig.ControlMode == ControlMode.Self ||
this.Server.ServerConfig.ControlMode == ControlMode.Parallel)
{
#region
byte[] data = new byte[saeaEx.DataLength];
Buffer.BlockCopy(saeaEx.ReceiveBuffer, saeaEx.InitOffset, data, 0, data.Length);
IRunDevice dev = null;
try
{
dev = devList.FirstOrDefault(d => d.DeviceParameter.DeviceCode == d.Protocol.GetCode(data));
}
catch (Exception ex)
{
this.Server.Logger.Error(true, ex.Message);
}
if (dev != null)
{
ProcessFliterData(dataPackage, saeaEx, dev);
}
#endregion
}
else if (this.Server.ServerConfig.ControlMode == ControlMode.Singleton)
{
ProcessFliterData(dataPackage, saeaEx, devList[0]);
}
}
}
else
{
ProcessFliterData(dataPackage, saeaEx, null);
}
#endregion
saeaEx.SetBuffer(saeaEx.ReceiveBuffer, saeaEx.NextOffset, saeaEx.InitOffset + saeaEx.Capacity - saeaEx.NextOffset);
OnSocketReceiveData(dataPackage);
bool willRaiseEvent = socketSession.Client.ReceiveAsync(this.SocketAsyncProxy.SocketReceiveEventArgsEx);
if (!willRaiseEvent)
{
ProcessReceive(this.SocketAsyncProxy.SocketReceiveEventArgsEx);
}
}
else
{
OnCloseSocket();
}
}
catch (SocketException ex)
{
OnCloseSocket();
this.Server.Logger.Error(true, ex.Message);
}
catch (Exception ex)
{
this.Server.Logger.Error(true, ex.Message);
}
}
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Green;
ConsoleUtil.SetConsoleCtrlHandler(new ConsoleUtil.ControlCtrlDelegate(HandlerRoutine), true);
bool success = true;
Console.WriteLine("正在初始化服务程序......");
IObjectBuilder builder = new TypeCreator();
_serverFactory = new ServerFactory();
try
{
GlobalConfig gc = GlobalConfigTool.Load();
foreach (ServerSuperIO.Config.Server serverCfg in gc.Servers)
{
IServer server = _serverFactory.CreateServer(serverCfg.ServerConfig);
server.AddDeviceCompleted += server_AddDeviceCompleted;
server.DeleteDeviceCompleted += server_DeleteDeviceCompleted;
server.Start();
_serverFactory.AddServer(server);
foreach (Config.Device devCfg in serverCfg.Devices)
{
try
{
IRunDevice runDev = builder.BuildUp <IRunDevice>(devCfg.AssemblyFile, devCfg.Instance);
runDev.DeviceParameter.DeviceID = devCfg.DeviceID;
runDev.DeviceDynamic.DeviceID = devCfg.DeviceID;
runDev.CommunicateType = devCfg.CommunicateType;
runDev.Initialize(devCfg.DeviceID);
if (server.AddDevice(runDev) != devCfg.DeviceID)
{
Console.WriteLine("增加设备：" + devCfg.DeviceID + " 失败！");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
continue;
}
}
}
}
catch (Exception ex)
{
success = false;
Console.WriteLine(ex.Message);
}
if (success)
{
Console.WriteLine("初始化服务程序完成");
}
while ("exit" == Console.ReadLine())
{
_serverFactory.RemoveAllServer();
break;
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="dev"></param>
/// <param name="data"></param>
public void Send(IRunDevice dev, byte[] data)
{
if (data == null || data.Length <= 0)
{
this.Server.Logger.Info(false, dev.DeviceParameter.DeviceName + ">>要发送的数据为空");
return;
}
int counter = this.Server.DeviceManager.GetCounter(dev.DeviceParameter.DeviceID);
ISocketSession socketSession = (ISocketSession)this.Server.ChannelManager.GetChannel(dev.DeviceParameter.NET.RemoteIP, CommunicateType.NET);
if (socketSession != null)
{
int sendNum = 0;
lock (socketSession.SyncLock)
{
try
{
sendNum = dev.Send(socketSession, data);
}
catch (Exception ex)
{
this.Server.Logger.Info(true, dev.DeviceParameter.DeviceName + ">>" + ex.Message);
}
}
if (sendNum == data.Length && sendNum != 0)
{
Interlocked.Increment(ref counter);
this.Server.Logger.Info(false, dev.DeviceParameter.DeviceName + ">>发送请求数据");
}
else
{
Interlocked.Increment(ref counter);
this.Server.Logger.Info(false, dev.DeviceParameter.DeviceName + ">>尝试发送数据失败");
}
dev.ShowMonitorData(data, "发送");
dev.SaveBytes(data, "发送");
if (counter >= 3)
{
try
{
dev.Run(dev.DeviceParameter.NET.RemoteIP, null, new byte[] { });
}
catch (Exception ex)
{
this.Server.Logger.Info(true, dev.DeviceParameter.DeviceName + "," + ex.Message);
}
Interlocked.Exchange(ref counter, 0);
}
this.Server.DeviceManager.SetCounter(dev.DeviceParameter.DeviceID, counter);
}
else
{
try
{
dev.Run((IChannel)null); //如果没有找到连接，则传递空值
}
catch (Exception ex)
{
this.Server.Logger.Error(true, "网络控制器", ex);
}
}
}
private IRunDevice GetDeliveryDevice(IRunDevice[] devList, IReceivePackage dataPackage)
{
IRunDevice devRun = null;
foreach (IRunDevice dev in devList)
{
bool isDelivery = false;
if (this.Server.ServerConfig.DeliveryMode == DeliveryMode.DeviceIP)
{
#region
isDelivery = String.CompareOrdinal(dev.DeviceParameter.NET.RemoteIP, dataPackage.RemoteIP) == 0 ? true : false;
#endregion
}
else if (this.Server.ServerConfig.DeliveryMode == DeliveryMode.DeviceCode)
{
#region
if (String.IsNullOrEmpty(dataPackage.DeviceCode))
{
foreach (byte[] data in dataPackage.ListBytes)
{
if (data != null)
{
if (dev.Protocol != null &&
dev.Protocol.CheckData(data)
&&
String.CompareOrdinal(dev.Protocol.GetCode(data),
dev.DeviceParameter.DeviceCode) == 0)
{
isDelivery = true;
}
else
{
isDelivery = false;
}
}
else
{
isDelivery = false;
}
if (isDelivery)
{
break;
}
}
}
else
{
isDelivery = String.CompareOrdinal(dev.DeviceParameter.DeviceCode, dataPackage.DeviceCode) == 0 ? true : false;
}
#endregion
}
if (isDelivery)
{
devRun = dev;
break;
}
}
return(devRun);
}
/// <summary>
/// 接收数据
/// </summary>
/// <param name="socketSession"></param>
/// <param name="dataPackage"></param>
public void Receive(ISocketSession socketSession, IReceivePackage dataPackage)
{
if (dataPackage.ListBytes == null || dataPackage.ListBytes.Count <= 0)
{
return;
}
IRunDevice[] list = this.Server.DeviceManager.GetDevices(CommunicateType.NET);
if (list != null && list.Length > 0)
{
if (this.Server.ServerConfig.ControlMode == ControlMode.Loop ||
this.Server.ServerConfig.ControlMode == ControlMode.Self ||
this.Server.ServerConfig.ControlMode == ControlMode.Parallel)
{
#region
IRunDevice dev = GetDeliveryDevice(list, dataPackage);
if (dev != null)
{
lock (dev.SyncLock)
{
foreach (byte[] data in dataPackage.ListBytes)
{
#region
try
{
if (data == null)
{
dev.Run(socketSession.Key, socketSession.Channel, new byte[] { });
}
else
{
dev.Run(socketSession.Key, socketSession.Channel, data);
}
}
catch (Exception ex)
{
Server.Logger.Error(true, "", ex);
}
int counter = this.Server.DeviceManager.GetCounter(dev.DeviceParameter.DeviceID);
Interlocked.Decrement(ref counter);
if (counter < 0)
{
Interlocked.Exchange(ref counter, 0);
}
this.Server.DeviceManager.SetCounter(dev.DeviceParameter.DeviceID, counter);
#endregion
}
}
}
#endregion
}
else if (this.Server.ServerConfig.ControlMode == ControlMode.Singleton)
{
#region
try
{
lock (list[0].SyncLock)
{
foreach (byte[] data in dataPackage.ListBytes)
{
list[0].Run(socketSession.Key, (IChannel)socketSession, data);
}
}
}
catch (Exception ex)
{
Server.Logger.Error(true, "", ex);
}
#endregion
}
}
}
private void ProcessFliterData(IReceivePackage dataPackage, SocketAsyncEventArgsEx saeaEx, IRunDevice dev)
{
if (dev == null || dev.Protocol == null || dev.Protocol.ReceiveFilter == null)
{
if (dataPackage.ListBytes == null)
{
dataPackage.ListBytes = new List <byte[]>();
}
byte[] data = saeaEx.Get();
if (data.Length > 0)
{
LastActiveTime = DateTime.Now;
}
dataPackage.ListBytes.Add(data);
}
else
{
dataPackage.DeviceCode = dev.DeviceParameter.DeviceCode;
IList <byte[]> listBytes = saeaEx.Get(dev.Protocol.ReceiveFilter);
if (listBytes != null && listBytes.Count > 0)
{
LastActiveTime = DateTime.Now;
}
dataPackage.ListBytes = listBytes;
}
}
/// <summary>
/// 增加设备
/// </summary>
/// <param name="dev"></param>
/// <returns>设备ID</returns>
public string AddDevice(IRunDevice dev)
{
if (dev == null)
{
throw new ArgumentNullException("设备驱动", "参数为空");
}
if (dev.DeviceParameter.DeviceID != dev.DeviceDynamic.DeviceID)
{
throw new NotEqualException("参数和动态数据的设备ID不相等");
}
String devid = String.Empty;
if (dev.DeviceParameter.DeviceID == String.Empty ||
dev.DeviceDynamic.DeviceID == String.Empty)
{
devid = this.DeviceManager.BuildDeviceID();
dev.DeviceParameter.DeviceID = devid;
dev.DeviceDynamic.DeviceID = devid;
try
{
dev.Initialize(devid);
}
catch { throw; }
}
if (DeviceManager.ContainDevice(devid))
{
throw new ArgumentException("已经有相同的设备ID存在");
}
if (ServerConfig.ControlMode == ControlMode.Singleton)
{
if (dev.CommunicateType == CommunicateType.NET)
{
IRunDevice[] netDevices = DeviceManager.GetDevices(CommunicateType.NET);
if (netDevices.Length >= 1) //如果是Singleton模式只能有一个网络设备驱动
{
throw new IndexOutOfRangeException("当为Singleton模式时，不能增加多个网络设备驱动");
}
}
}
string desc = String.Empty;
if (this.DeviceManager.AddDevice(dev.DeviceParameter.DeviceID, dev))
{
dev.Setup(this);
this.BindDeviceHandler(dev, dev.DeviceType, true);
if (dev.DeviceType == DeviceType.Virtual)
{
desc = "增加虚拟设备";
}
else
{
IController controller = null;
if (dev.CommunicateType == CommunicateType.COM)
{
#region 串口
string key = ComUtils.PortToString(dev.DeviceParameter.COM.Port);
IChannel channel = ChannelManager.GetChannel(key);
if (channel == null)
{
IComSession comChannel = new ComSession(dev.DeviceParameter.COM.Port, dev.DeviceParameter.COM.Baud);
comChannel.Setup(this);
comChannel.Initialize();
comChannel.COMOpen += ComChannel_COMOpen;
comChannel.COMClose += ComChannel_COMClose;
comChannel.COMError += ComChannel_COMError;
comChannel.Open();
channel = (IChannel)comChannel;
ChannelManager.AddChannel(key, channel);
}
controller = ControllerManager.GetController(key);
if (controller == null)
{
controller = new ComController((IComSession)channel);
controller.Setup(this);
if (ControllerManager.AddController(controller.Key, controller))
{
controller.StartController();
}
}
else
{
IComController comController = (IComController)controller;
if (comController.ComChannel.GetHashCode() != channel.GetHashCode())
{
comController.ComChannel = (IComSession)channel;
}
}
desc = String.Format("增加'{0}'串口设备，串口:{1} 波特率:{2}", dev.DeviceParameter.DeviceName, dev.DeviceParameter.COM.Port.ToString(), dev.DeviceParameter.COM.Baud.ToString());
#endregion
}
else if (dev.CommunicateType == CommunicateType.NET)
{
#region 网络
controller = ControllerManager.GetController(SocketController.ConstantKey);
if (controller == null)
{
controller = new SocketController();
controller.Setup(this);
if (ControllerManager.AddController(controller.Key, controller))
{
controller.StartController();
}
}
desc = String.Format("增加'{0}'网络设备，IP地址:{1} 端口:{2}", dev.DeviceParameter.DeviceName, dev.DeviceParameter.NET.RemoteIP, dev.DeviceParameter.NET.RemotePort.ToString());
#endregion
}
else
{
desc = "无法识别设备的通讯类型";
}
}
desc += ",成功";
OnAddDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, true);
}
else
{
desc += ",失败";
OnAddDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, false);
}
this.Logger.Info(true, desc);
return(devid != String.Empty ? devid : dev.DeviceParameter.DeviceID);
}
protected abstract void BindDeviceHandler(IRunDevice dev, DeviceType deviceType, bool b);
public void RemoveDevice(string devid)
{
IRunDevice dev = DeviceManager.GetDevice(devid);
if (dev != null)
{
string desc = String.Empty;
string devname = dev.DeviceParameter.DeviceName;
if (DeviceManager.RemoveDevice(dev.DeviceParameter.DeviceID))
{
if (dev.DeviceType == DeviceType.Virtual)
{
desc = "删除虚拟设备";
}
else
{
#region
if (dev.CommunicateType == CommunicateType.COM)
{
IRunDevice[] comDevices = DeviceManager.GetDevices(dev.DeviceParameter.COM.Port.ToString(), CommunicateType.COM);
if (comDevices.Length == 0)
{
string key = ComUtils.PortToString(dev.DeviceParameter.COM.Port);
IController controller = ControllerManager.GetController(key);
if (controller != null)
{
controller.IsWorking = false;
if (ControllerManager.RemoveController(controller.Key))
{
controller.StopController();
controller.Dispose();
IComSession comChannel = (IComSession)((IComController)controller).ComChannel;
comChannel.Close();
comChannel.COMOpen -= ComChannel_COMOpen;
comChannel.COMClose -= ComChannel_COMClose;
comChannel.COMError -= ComChannel_COMError;
if (ChannelManager.RemoveChannel(comChannel.Key))
{
comChannel.Close();
comChannel.Dispose();
}
}
}
}
desc = String.Format("{0},从串口'{1}'删除", dev.DeviceParameter.DeviceName, dev.DeviceParameter.COM.Port.ToString());
}
else if (dev.CommunicateType == CommunicateType.NET)
{
desc = String.Format("{0}-{1},从网络中删除成功", dev.DeviceParameter.DeviceName, dev.DeviceParameter.NET.RemoteIP);
}
#endregion
}
RemoveDeviceFromShows(dev);
RemoveDeviceFromServices(dev);
dev.DeviceParameter.Delete();
dev.DeviceDynamic.Delete();
dev.Delete();
dev.Dispose();
BindDeviceHandler(dev, dev.DeviceType, false);
desc += ",成功";
OnDeleteDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, true);
}
else
{
desc += ",失败";
OnDeleteDeviceCompleted(dev.DeviceParameter.DeviceID, dev.DeviceParameter.DeviceName, false);
}
Logger.Info(true, desc);
}
}
