public override void SetUIParameter(string para)
{
cbReceiveMethod.SelectedIndex = 0;
cbMessage.SelectedIndex = 0;
cbWill.SelectedIndex = 0;
cbDataType.SelectedIndex = 0;
if (!string.IsNullOrEmpty(para))
{
ParaPack paraPack = new ParaPack(para);
paraPack.SetCtrlValue(txtIp, paraPack.GetValue("服务器IP"));
paraPack.SetCtrlValue(nudPort, paraPack.GetValue("端口号"));
paraPack.SetCtrlValue(tbUser, paraPack.GetValue("用户名"));
paraPack.SetCtrlValue(tbPwd, paraPack.GetValue("密码"));
paraPack.SetCtrlValue(cbEnableUser, paraPack.GetValue("开启匿名验证"));
paraPack.SetCtrlValue(tbHeart, paraPack.GetValue("心跳时间"));
paraPack.SetCtrlValue(cbMessage, paraPack.GetValue("消息质量"));
paraPack.SetCtrlValue(cbWill, paraPack.GetValue("遗愿标志"));
paraPack.SetCtrlValue(cbDataType, paraPack.GetValue("数据格式"));
paraPack.SetCtrlValue(cbClientIDEnable, paraPack.GetValue("开启Mqtt客户端识别"));
paraPack.SetCtrlValue(cbReceiveMethod, paraPack.GetValue("接收方式"));
}
else
{
string AddressIP = "127.0.0.1";
foreach (IPAddress _IPAddress in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
{
if (_IPAddress.AddressFamily.ToString() == "InterNetwork")
{
AddressIP = _IPAddress.ToString();
}
}
txtIp.Text = AddressIP;
}
}
public override string GetUIParameter()
{
ParaPack paraPack = new ParaPack();
paraPack.AddItem("内存区", cbo_functioncode);
paraPack.AddItem("偏置", ndOffset);
paraPack.AddItem("数据类型", cbo_StoreType);
paraPack.AddItem("存储位置", cbo_datatype);
paraPack.AddItem("字节长度", ndCharSize);
paraPack.AddItem("按位存取", cbPosition);
paraPack.AddItem("数据位", ndPosition);
if (rb_rw.Checked)
{
paraPack.AddItem("读写状态", "可读可写");
}
if (rb_r.Checked)
{
paraPack.AddItem("读写状态", "可读");
}
if (rb_w.Checked)
{
paraPack.AddItem("读写状态", "可写");
}
return(paraPack.ToString());
}
public override string GetUIParameter()
{
ParaPack paraPack = new ParaPack();
paraPack.AddItem("串口", comboSeriePort.SelectedItem.ToString());
paraPack.AddItem("模拟器串口", comboSmSeriePort.SelectedItem.ToString());
paraPack.AddItem("波特率", cbBaudRate.Text);
paraPack.AddItem("数据位", cbDataBits.Text);
paraPack.AddItem("校验", cbCheck.SelectedItem.ToString());
paraPack.AddItem("停止位", cbStopbits.SelectedItem.ToString());
paraPack.AddItem("连续采集", cbContinueCollect.Checked?"1":"0");
paraPack.AddItem("重试次数", nbCollectNum.Value.ToString("0"));
paraPack.AddItem("重试间隔", nbCollectInternal.Value.ToString("0"));
paraPack.AddItem("包最大长度", nbPackSize.Value.ToString("0"));
paraPack.AddItem("偏移间隔", nbPackOffset.Value.ToString("0"));
paraPack.AddItem("写超时时间", nbWriteTimeout.Value.ToString("0"));
paraPack.AddItem("读超时时间", nbReadTimeout.Value.ToString("0"));
paraPack.AddItem("RTS", cbRTSEnable.Checked ? "1" : "0");
paraPack.AddItem("发送前RTS保持时间", nbSendPreKeeyTime.Value.ToString("0"));
paraPack.AddItem("发送后RTS保持时间", nbSendAfterKeeyTime.Value.ToString("0"));
paraPack.AddItem("支持6号命令", cbSixCmd.Checked ? "1" : "0");
paraPack.AddItem("支持16号命令", cbSixteenCmd.Checked ? "1" : "0");
paraPack.AddItem("MODBUS类型", cbModbusType.SelectedItem.ToString());
return(paraPack.ToString());
}
public string GetParament()
{
ParaPack para = new ParaPack();
if (cbo_functioncode.SelectedItem != null)
{
ModbusFunctionCode funCode = (ModbusFunctionCode)cbo_functioncode.SelectedItem;
para.AddItem("内存区", funCode.Code);
}
para.AddItem("偏置", this.ndOffset.Text.Trim());
if (cbo_StoreType.SelectedItem != null)
{
ModbusDataType datatype = (ModbusDataType)cbo_StoreType.SelectedItem;
para.AddItem("数据类型", datatype.DataType.ToString());
}
if (cbo_datatype.SelectedItem != null)
{
string datatype = (string)cbo_datatype.SelectedItem;
para.AddItem("存储位置", datatype.ToString());
}
para.AddItem("字节长度", this.ndCharSize.Text.Trim() == ""?"0": this.ndCharSize.Text.Trim());
para.AddItem("按位存取", this.cbPosition.Checked?"1":"0");
para.AddItem("数据位", this.ndPosition.Text.Trim() == ""?"0": this.ndPosition.Text.Trim());
return(para.ToString());
}
protected override bool InitCommunicateKernel(IO_SERVER server, IO_COMMUNICATION communication, List <IO_DEVICE> ioDevices, SCADA_DRIVER driver)
{
if (IsCreateControl)
{
CommunicationControl = new Modbus_Serial_Ctrl();
if (communication != null)
{
CommunicationControl.SetUIParameter(communication.IO_COMM_PARASTRING);
}
}
Serial_PARA = new Modbus_Serial_PARA();
if (communication != null)
{
comParaPack = new ParaPack(communication.IO_COMM_PARASTRING);
Serial_PARA.BaudRate = Convert.ToInt32(comParaPack.GetValue("波特率"));
Serial_PARA.CollectFaultsInternal = Convert.ToInt32(comParaPack.GetValue("重试间隔"));
Serial_PARA.CollectFaultsNumber = Convert.ToInt32(comParaPack.GetValue("重试次数"));
Serial_PARA.ContinueCollect = comParaPack.GetValue("连续采集") == "1" ? true : false;
Serial_PARA.DataBits = Convert.ToInt32(comParaPack.GetValue("数据位"));
Serial_PARA.ModbusType = (ModbusType)Enum.Parse(typeof(ModbusType), comParaPack.GetValue("MODBUS类型"));
Serial_PARA.OffsetInterval = Convert.ToInt32(comParaPack.GetValue("偏移间隔"));
Serial_PARA.PackMaxSize = Convert.ToInt32(comParaPack.GetValue("包最大长度"));
Serial_PARA.ReadTimeout = Convert.ToInt32(comParaPack.GetValue("读超时时间"));
Serial_PARA.RSTSendPreKeeyTime = Convert.ToInt32(comParaPack.GetValue("发送前RTS保持时间"));
Serial_PARA.RTSSendAfterKeeyTime = Convert.ToInt32(comParaPack.GetValue("发送后RTS保持时间"));
Serial_PARA.RTSEnable = comParaPack.GetValue("RTS") == "1" ? true : false;
Serial_PARA.SerialCheck = (SerialCheck)Enum.Parse(typeof(SerialCheck), comParaPack.GetValue("校验"));
Serial_PARA.SerialPort = comParaPack.GetValue("串口");
Serial_PARA.SimulatorSerialPort = comParaPack.GetValue("模拟器串口");
Serial_PARA.SixCommmand = comParaPack.GetValue("支持6号命令") == "1" ? true : false;
Serial_PARA.SixteenCommmand = comParaPack.GetValue("支持16号命令") == "1" ? true : false;;
Serial_PARA.StopBits = (StopBits)Enum.Parse(typeof(StopBits), comParaPack.GetValue("停止位"));
Serial_PARA.WriteTimeout = Convert.ToInt32(comParaPack.GetValue("写超时时间"));
//构造获取数据命令的字节数组,Modbus
for (int i = 0; i < this.IODevices.Count; i++)
{
object fragment = new ModbusFragmentStore();
RealData mRealData = new RealData();
mRealData.Device = this.IODevices[i];
ScadaDeviceKernel driverDll = DeviceDrives.Find(x => x.DeviceDriverID == this.IODevices[i].DEVICE_DRIVER_ID);
if (driverDll != null)
{
driverDll.InitKernel(IOServer, IOCommunication, this.IODevices[i], null, this.IODevices[i].DriverInfo);
//IO_DEVICE_ADDRESS中存储的是DTU编号
mRealData.SlaveId = this.IODevices[i].IO_DEVICE_ADDRESS;
//数据库中系统编号
mRealData.DEVICEID = this.IODevices[i].IO_DEVICE_ID;
//获取下发命令的参数,注意此次要进心分段存储，因为modbus一次不能超过123个寄存器地址
mRealData.Fragment = (ModbusFragmentStore)fragment;
RealDevices.Add(mRealData);
}
}
}
return(true);
}
public string GetParament()
{
ParaPack para = new ParaPack();
para.AddItem("IO标识", tb_JsonName.Text);
para.AddItem("时间值索引", nudTime.Value.ToString("0"));
para.AddItem("数据类型", cbDataType.SelectedItem.ToString());
para.AddItem("采集值索引", nud_valueIndex.Text);
para.AddItem("命令默认值", tbCmdValue.Text);
return(para.ToString());
}
//由于此处Para里面设置的可能是不同命令的IO参数，所以需要返回不同命令的实时获取的数据,此处不需要返回Byte字节数组
public List <byte[]> GetDataCommandBytes(IO_SERVER server, IO_COMMUNICATION Communication, IO_DEVICE device, List <IO_PARA> paras, IO_PARA currentpara, ref object sender)
{
List <byte[]> cmmdBytes = new List <byte[]>();
//必须Read的IO参数
List <ModbusFragmentStore> modbusCodes = new List <ModbusFragmentStore>();
for (int i = 0; i < paras.Count; i++)
{
ParaPack paraPack = new ParaPack(paras[i].IO_PARASTRING);
if (!modbusCodes.Exists(x => x.StoredCode == paraPack.GetValue("内存区")) && paraPack.GetValue("内存区") != "")
{
ModbusFragmentStore stored = new ModbusFragmentStore();
stored.StoredCode = paraPack.GetValue("内存区");
stored.Fragments = new List <ModbusFragment>();
stored.Units = new List <ushort>();
modbusCodes.Add(stored);
}
paraPack.Dispose();
paraPack = null;
}
for (int i = 0; i < paras.Count; i++)
{
ParaPack paraPack = new ParaPack(paras[i].IO_PARASTRING);
if (paraPack.GetValue("内存区") != "")
{
if (modbusCodes.Exists(x => x.StoredCode == paraPack.GetValue("内存区")) && paraPack.GetValue("内存区") != "")
{
ModbusFragmentStore stored = modbusCodes.Find(x => x.StoredCode == paraPack.GetValue("内存区"));
if (paraPack.GetValue("偏置") != "")
{
ushort offset = 0;
if (ushort.TryParse(paraPack.GetValue("偏置"), out offset))
{
if (!stored.Units.Contains(offset))
{
stored.Units.Add(offset);
}
}
}
}
}
}
ModbusFragmentStore mainStored = new ModbusFragmentStore();
//由于modbus获取寄存器最大数量是124个，所以要进行分段，最大线圈数量是1999个
foreach (ModbusFragmentStore stored in modbusCodes)
{
stored.MakeFragment();
mainStored.Fragments.AddRange(stored.Fragments);
}
//获取要解析的命令
sender = mainStored;
return(cmmdBytes);
}
public override void SetUIParameter(string para)
{
ParaPack paraPack = new ParaPack(para);
paraPack.SetCtrlValue(txtIP, paraPack.GetValue("本机IP"));
paraPack.SetCtrlValue(nudPort, paraPack.GetValue("本机端口"));
paraPack.SetCtrlValue(cbRegisterType, paraPack.GetValue("注册包"));
paraPack.SetCtrlValue(nudIdLength, paraPack.GetValue("标识长度"));
paraPack.SetCtrlValue(cbIdStoredType, paraPack.GetValue("存储方式"));
paraPack.SetCtrlValue(cbReceiveType, paraPack.GetValue("接收方式"));
paraPack.SetCtrlValue(tbHeartbear, paraPack.GetValue("心跳字节"));
paraPack.SetCtrlValue(cbHeart, paraPack.GetValue("开启心跳"));
}
private string GetParament()
{
ParaPack para = new ParaPack();
para.AddItem("设备ID编码", this.Device.IO_DEVICE_ADDRESS);
para.AddItem("MQTT连接ID号", this.tb_MqttID.Text.Trim());
para.AddItem("数据订阅主题", this.tb_subTopic.Text.Trim());
para.AddItem("下置命令主题", this.tb_cmdSubTopic.Text.Trim());
para.AddItem("循环周期主题", this.tbTimes.Text.Trim());
para.AddItem("主动请求主题", this.tbRecieveType.Text.Trim());
return(para.ToString());
}
private string GetParament()
{
ParaPack para = new ParaPack();
para.AddItem("设备识别号", this.Device.IO_DEVICE_ADDRESS);
para.AddItem("版本号", this.tb_devVersion.Text);
para.AddItem("软件版本", this.tb_devSoftVision.Text);
para.AddItem("硬件版本", this.tb_devHardVersion.Text);
para.AddItem("MQTT连接ID号", this.tb_MqttID.Text);
para.AddItem("订阅主题", this.tb_subTopic.Text);
para.AddItem("命令主题", this.tb_cmdSubTopic.Text);
para.AddItem("时间主题", this.tbTimes.Text);
return(para.ToString());
}
public string GetParament()
{
ParaPack para = new ParaPack();
para.AddItem("JSON名称", tb_JsonName.Text);
para.AddItem("版子地址", nud_boardAddress.Value.ToString("0"));
para.AddItem("版子索引号", nud_boardIndex.Value.ToString("0"));
para.AddItem("端口号", nud_port.Value.ToString("0"));
para.AddItem("端口索引号", nud_PortIndex.Value.ToString("0"));
para.AddItem("数据类型", cb_DataType.SelectedItem.ToString());
para.AddItem("采集值索引号", nud_valueIndex.Value.ToString());
para.AddItem("是否命令参数", cbParaType.SelectedItem.ToString());
return(para.ToString());
}
protected override bool InitCommunicateKernel(IO_SERVER server, IO_COMMUNICATION communication, List <IO_DEVICE> ioDevices, SCADA_DRIVER driver)
{
if (IsCreateControl)
{
CommunicationControl = new Modbus_UDP_Ctrl();
if (communication != null)
{
CommunicationControl.SetUIParameter(communication.IO_COMM_PARASTRING);
}
}
Udp_PARA = new Modbus_TCP_PARA();
if (communication != null)
{
TcpParaPack = new ParaPack(communication.IO_COMM_PARASTRING);
Udp_PARA.CollectFaultsInternal = Convert.ToInt32(TcpParaPack.GetValue("重试间隔"));
Udp_PARA.CollectFaultsNumber = Convert.ToInt32(TcpParaPack.GetValue("重试次数"));
Udp_PARA.ContinueCollect = TcpParaPack.GetValue("重试") == "1" ? true : false;
Udp_PARA.LocalTCP_Port = TcpParaPack.GetValue("本地端口");
Udp_PARA.LocalTCP_IP = TcpParaPack.GetValue("本地IP");
Udp_PARA.SimulatorTCP_Port = TcpParaPack.GetValue("模拟设备端口");
Udp_PARA.SimulatorTCP_IP = TcpParaPack.GetValue("模拟设备IP");
Udp_PARA.WriteTimeout = int.Parse(TcpParaPack.GetValue("写超时时间"));
Udp_PARA.ReadTimeout = int.Parse(TcpParaPack.GetValue("读超时时间"));
Udp_PARA.WriteBufferSize = int.Parse(TcpParaPack.GetValue("写缓存"));
Udp_PARA.ReadBufferSize = int.Parse(TcpParaPack.GetValue("读缓存"));
//构造获取数据命令的字节数组,Modbus
for (int i = 0; i < this.IODevices.Count; i++)
{
object fragment = new ModbusFragmentStore();
RealData mRealData = new RealData();
mRealData.Device = this.IODevices[i];
ScadaDeviceKernel driverDll = DeviceDrives.Find(x => x.DeviceDriverID == this.IODevices[i].DEVICE_DRIVER_ID);
if (driverDll != null)
{
driverDll.InitKernel(IOServer, IOCommunication, this.IODevices[i], null, this.IODevices[i].DriverInfo);
//IO_DEVICE_ADDRESS中存储的是DTU编号
mRealData.SlaveId = this.IODevices[i].IO_DEVICE_ADDRESS;
//数据库中系统编号
mRealData.DEVICEID = this.IODevices[i].IO_DEVICE_ID;
//获取下发命令的参数,注意此次要进心分段存储，因为modbus一次不能超过123个寄存器地址
//mRealData.ReadSendByte = driverDll.GetDataCommandBytes(this.IOServer, this.IOCommunication, this.IODevices[i], this.IODevices[i].IOParas, null, ref fragment);
}
mRealData.Fragment = (ModbusFragmentStore)fragment;
RealDevices.Add(mRealData);
}
}
return(true);
}
public override void SetUIParameter(IO_SERVER server, IO_DEVICE device, IO_PARA para)
{
base.SetUIParameter(server, device, para);
if (para.IO_PARASTRING != null && para.IO_PARASTRING != "")
{
ParaPack paraPack = new ParaPack(para.IO_PARASTRING);
paraPack.SetCtrlValue(tb_JsonName, paraPack.GetValue("IO标识"));
paraPack.SetCtrlValue(nudTime, paraPack.GetValue("时间值索引"));
paraPack.SetCtrlValue(cbDataType, paraPack.GetValue("数据类型"));
paraPack.SetCtrlValue(nud_valueIndex, paraPack.GetValue("采集值索引"));
paraPack.SetCtrlValue(tbCmdValue, paraPack.GetValue("命令默认值"));
}
this.ParaString = para.IO_PARASTRING;
}
public override string GetUIParameter()
{
ParaPack paraPack = new ParaPack();
paraPack.AddItem("本机IP", txtIP);
paraPack.AddItem("本机端口", nudPort);
paraPack.AddItem("注册包", cbRegisterType);
paraPack.AddItem("标识长度", nudIdLength);
paraPack.AddItem("存储方式", cbIdStoredType);
paraPack.AddItem("接收方式", cbReceiveType);
paraPack.AddItem("心跳字节", tbHeartbear);
paraPack.AddItem("开启心跳", cbHeart);
return(paraPack.ToString());
}
/// <summary>
/// 初始化驱动
/// </summary>
/// <param name="server"></param>
/// <param name="communication"></param>
/// <param name="ioDevices"></param>
/// <param name="driver"></param>
/// <returns></returns>
protected override bool InitCommunicateKernel(IO_SERVER server, IO_COMMUNICATION communication, List <IO_DEVICE> ioDevices, SCADA_DRIVER driver)
{
try
{
ParaPack communicatePack = new ParaPack(communication.IO_COMM_PARASTRING);
if (communication.IO_COMM_PARASTRING != null && communication.IO_COMM_PARASTRING != "")
{
this.ServerIP = communicatePack.GetValue("服务器IP");
this.ServerPort = int.Parse(communicatePack.GetValue("端口号"));
this.UserName = communicatePack.GetValue("用户名");
this.Password = communicatePack.GetValue("密码");
this.EaableAnonymousAuthentication = bool.Parse(communicatePack.GetValue("开启匿名验证"));
this.HeartTime = int.Parse(communicatePack.GetValue("心跳时间"));
string msgqulity = communicatePack.GetValue("消息质量");
switch (msgqulity)
{
case "QoS 0 最多分发一次":
MessageQulity = MqttQualityOfServiceLevel.AtMostOnce;
break;
case "QoS 1 至少分发一次":
MessageQulity = MqttQualityOfServiceLevel.AtLeastOnce;
break;
case "QoS 2 只分发一次":
MessageQulity = MqttQualityOfServiceLevel.ExactlyOnce;
break;
}
this.WillFlag = communicatePack.GetValue("遗愿标志");
this.MqttDataType = communicatePack.GetValue("数据格式");
this.EaableClientIDAuthentication = bool.Parse(communicatePack.GetValue("开启Mqtt客户端识别"));
}
if (IsCreateControl)
{
CommunicationControl = new MQTTServerCtrl();
if (communication != null && communication.IO_COMM_PARASTRING != "")
{
CommunicationControl.SetUIParameter(communication.IO_COMM_PARASTRING);
}
}
}
catch (Exception emx)
{
this.DeviceException(emx.Message);
return(false);
}
return(true);
}
public override void SetUIParameter(IO_SERVER server, IO_DEVICE device)
{
ParaPack paraPack = new ParaPack(device.IO_DEVICE_PARASTRING);
paraPack.SetCtrlValue(tbIdentification, paraPack.GetValue("注册标识"));
paraPack.SetCtrlValue(txtAddress, device.IO_DEVICE_ADDRESS);
paraPack.SetCtrlValue(cbModbusType, paraPack.GetValue("Modbus类型"));
paraPack.SetCtrlValue(nbReadTimeout, paraPack.GetValue("读超时"));
paraPack.SetCtrlValue(nbWriteTimeout, paraPack.GetValue("写超时"));
paraPack.SetCtrlValue(ndReadBuffSize, paraPack.GetValue("读缓存"));
paraPack.SetCtrlValue(ndWriteBufferSize, paraPack.GetValue("写缓存"));
paraPack.SetCtrlValue(cbRetries, paraPack.GetValue("失败重试"));
paraPack.SetCtrlValue(ndRetiresNum, paraPack.GetValue("重试次数"));
paraPack.SetCtrlValue(nbRetiresInternal, paraPack.GetValue("重试间隔"));
}
public override string GetUIParameter()
{
ParaPack paraPack = new ParaPack();
paraPack.AddItem("注册标识", tbIdentification);
paraPack.AddItem("设备地址", txtAddress);
paraPack.AddItem("Modbus类型", cbModbusType);
paraPack.AddItem("读超时", nbReadTimeout);
paraPack.AddItem("写超时", nbWriteTimeout);
paraPack.AddItem("读缓存", ndReadBuffSize);
paraPack.AddItem("写缓存", ndWriteBufferSize);
paraPack.AddItem("失败重试", cbRetries);
paraPack.AddItem("重试次数", ndRetiresNum);
paraPack.AddItem("重试间隔", nbRetiresInternal);
return(base.GetUIParameter());
}
public override string GetUIParameter()
{
ParaPack paraPack = new ParaPack();
paraPack.AddItem("模拟设备IP", tbSMDeviceIP.Text);
paraPack.AddItem("模拟设备端口", ndSMPort.Text);
paraPack.AddItem("本地IP", tbLocalIP.Text);
paraPack.AddItem("本地端口", ndLocalPort.Text);
paraPack.AddItem("重试", cbRetries.Checked?"1":"0");
paraPack.AddItem("重试次数", ndRetiresNum.Text);
paraPack.AddItem("重试间隔", nbRetiresInternal.Text.ToString());
paraPack.AddItem("写超时时间", nbWriteTimeout.Text);
paraPack.AddItem("读超时时间", nbReadTimeout.Text);
paraPack.AddItem("读缓存", ndReadBuffSize.Text);
paraPack.AddItem("写缓存", ndWriteBufferSize.Text);
return(paraPack.ToString());
}
private string GetParament()
{
ParaPack para = new ParaPack();
para.AddItem("服务器IP", txtIp.Text);
para.AddItem("端口号", nudPort.Value.ToString("0"));
para.AddItem("用户名", tbUser.Text);
para.AddItem("密码", tbPwd.Text);
para.AddItem("开启匿名验证", cbEnableUser.Checked.ToString());
para.AddItem("心跳时间", tbHeart.Text.ToString());
para.AddItem("消息质量", cbMessage.SelectedItem.ToString());
para.AddItem("遗愿标志", cbWill.SelectedItem.ToString());
para.AddItem("数据格式", cbDataType.SelectedItem.ToString());
para.AddItem("开启Mqtt客户端识别", cbClientIDEnable.Checked.ToString());
para.AddItem("接收方式", cbReceiveMethod.SelectedItem.ToString());
return(para.ToString());
}
public override void SetUIParameter(IO_SERVER server, IO_DEVICE device, IO_PARA para)
{
base.SetUIParameter(server, device, para);
if (para.IO_PARASTRING != null && para.IO_PARASTRING != "")
{
ParaPack paraPack = new ParaPack(para.IO_PARASTRING);
paraPack.SetCtrlValue(tb_JsonName, paraPack.GetValue("JSON名称"));
paraPack.SetCtrlValue(nud_boardAddress, paraPack.GetValue("版子地址"));
paraPack.SetCtrlValue(nud_boardIndex, paraPack.GetValue("版子索引号"));
paraPack.SetCtrlValue(nud_port, paraPack.GetValue("端口号"));
paraPack.SetCtrlValue(nud_PortIndex, paraPack.GetValue("端口索引号"));
paraPack.SetCtrlValue(cb_DataType, paraPack.GetValue("数据类型"));
paraPack.SetCtrlValue(nud_valueIndex, paraPack.GetValue("采集值索引号"));
paraPack.SetCtrlValue(cbParaType, paraPack.GetValue("是否命令参数"));
}
this.ParaString = para.IO_PARASTRING;
}
public void SetParament(string parastr)
{
ParaPack para = new ParaPack(parastr);
if (para.Count > 0)
{
///内存区
for (int i = 0; i < cbo_functioncode.Items.Count; i++)
{
ModbusFunctionCode funCode = (ModbusFunctionCode)cbo_functioncode.Items[i];
if (funCode.Code == para.GetValue("内存区"))
{
cbo_functioncode.SelectedIndex = i;
break;
}
}
//数据类型
for (int i = 0; i < cbo_StoreType.Items.Count; i++)
{
ModbusDataType datatype = (ModbusDataType)cbo_StoreType.Items[i];
if (datatype.ToString() == para.GetValue("数据类型"))
{
cbo_StoreType.SelectedIndex = i;
break;
}
}
//偏置
this.ndOffset.Value = para.GetValue("偏置") == "" ? 0: Convert.ToDecimal(para.GetValue("偏置"));
this.ndCharSize.Value = para.GetValue("字节长度") == "" ? 0 : Convert.ToDecimal(para.GetValue("字节长度"));
this.ndPosition.Value = para.GetValue("数据位") == "" ? 0 : Convert.ToDecimal(para.GetValue("数据位"));
//存储位置
for (int i = 0; i < cbo_datatype.Items.Count; i++)
{
string datatype = (string)cbo_datatype.Items[i];
if (datatype.ToString() == para.GetValue("存储位置"))
{
cbo_datatype.SelectedIndex = i;
break;
}
}
//按位存取
this.cbPosition.Checked = para.GetValue("按位存取") == "1" ? true : false;
}
}
public override void SetUIParameter(string para)
{
//初始化
base.SetUIParameter(para);
ParaPack paraPack = new ParaPack(para);
//波特率
tbSMDeviceIP.Text = paraPack.GetValue("模拟设备IP");
ndSMPort.Text = paraPack.GetValue("模拟设备端口");
tbLocalIP.Text = paraPack.GetValue("本地IP");
ndLocalPort.Text = paraPack.GetValue("本地端口");
cbRetries.Checked = paraPack.GetValue("重试") == "1" ? true : false;
ndRetiresNum.Text = paraPack.GetValue("重试次数");
nbRetiresInternal.Text = paraPack.GetValue("重试间隔");
nbWriteTimeout.Value = Convert.ToDecimal(paraPack.GetValue("写超时时间"));
nbReadTimeout.Value = Convert.ToDecimal(paraPack.GetValue("读超时时间"));
ndReadBuffSize.Value = Convert.ToDecimal(paraPack.GetValue("读缓存"));
ndWriteBufferSize.Value = Convert.ToDecimal(paraPack.GetValue("写缓存"));
}
public override void SetUIParameter(IO_SERVER server, IO_DEVICE device)
{
base.SetUIParameter(server, device);
ParaPack paraPack = new ParaPack(device.IO_DEVICE_PARASTRING);
if (device.IO_DEVICE_PARASTRING != null && device.IO_DEVICE_PARASTRING != "")
{
paraPack.SetCtrlValue(tb_devID, paraPack.GetValue("设备ID编码"));
paraPack.SetCtrlValue(tb_MqttID, paraPack.GetValue("MQTT连接ID号"));
paraPack.SetCtrlValue(tb_subTopic, paraPack.GetValue("数据订阅主题"));
paraPack.SetCtrlValue(tb_cmdSubTopic, paraPack.GetValue("下置命令主题"));
paraPack.SetCtrlValue(this.tbTimes, paraPack.GetValue("循环周期主题"));
paraPack.SetCtrlValue(this.tbRecieveType, paraPack.GetValue("主动请求主题"));
}
else
{
paraPack.SetCtrlValue(tb_devID, device.IO_DEVICE_ADDRESS);
}
this.ParaString = device.IO_DEVICE_PARASTRING;
}
protected override bool InitDeviceKernel(IO_SERVER server, IO_COMMUNICATION communication, IO_DEVICE device, IO_PARA para, SCADA_DEVICE_DRIVER driver)
{
if (IsCreateControl)
{
ParaPack commPack = new ParaPack(communication.IO_COMM_PARASTRING);
ParaPack devicePack = new ParaPack(device.IO_DEVICE_PARASTRING);
if (para != null)
{
//数据格式
if (commPack.GetValue("数据格式") == "江苏协昌环保股份有限公司")
{
this.ParaCtrl = new IOParaCtrl();
this.ParaCtrl.SetUIParameter(server, device, para);
}
else if (commPack.GetValue("数据格式") == "通用MQTT解析")
{
this.ParaCtrl = new GasIOParaCtrl();
this.ParaCtrl.SetUIParameter(server, device, para);
}
}
if (commPack.GetValue("数据格式") == "江苏协昌环保股份有限公司")
{
this.DeviceCtrl = new IODeviceCtrl();
this.DeviceCtrl.SetUIParameter(server, device);
}
else if (commPack.GetValue("数据格式") == "通用MQTT解析")
{
this.DeviceCtrl = new GasIODeviceCtrl();
this.DeviceCtrl.SetUIParameter(server, device);
}
}
if (para != null)
{
this.ParaString = para.IO_PARASTRING;
}
this.DeviceParaString = device.IO_DEVICE_PARASTRING;
return(true);
}
public override void SetUIParameter(IO_SERVER server, IO_DEVICE device)
{
base.SetUIParameter(server, device);
ParaPack paraPack = new ParaPack(device.IO_DEVICE_PARASTRING);
if (device.IO_DEVICE_PARASTRING != null && device.IO_DEVICE_PARASTRING != "")
{
paraPack.SetCtrlValue(tb_devID, device.IO_DEVICE_ADDRESS);
paraPack.SetCtrlValue(tb_devVersion, paraPack.GetValue("版本号"));
paraPack.SetCtrlValue(tb_devSoftVision, paraPack.GetValue("软件版本"));
paraPack.SetCtrlValue(tb_devHardVersion, paraPack.GetValue("硬件版本"));
paraPack.SetCtrlValue(tb_MqttID, paraPack.GetValue("MQTT连接ID号"));
paraPack.SetCtrlValue(tb_subTopic, paraPack.GetValue("订阅主题"));
paraPack.SetCtrlValue(tb_cmdSubTopic, paraPack.GetValue("命令主题"));
paraPack.SetCtrlValue(this.tbTimes, paraPack.GetValue("时间主题"));
}
else
{
paraPack.SetCtrlValue(tb_devID, device.IO_DEVICE_ADDRESS);
}
this.ParaString = device.IO_DEVICE_PARASTRING;
}
public override void SetUIParameter(IO_SERVER server, IO_DEVICE device, IO_PARA para)
{
ParaPack paraPack = new ParaPack(device.IO_DEVICE_PARASTRING);
paraPack.SetCtrlValue(cbo_functioncode, paraPack.GetValue("内存区"));
paraPack.SetCtrlValue(ndOffset, paraPack.GetValue("偏置"));
paraPack.SetCtrlValue(cbo_StoreType, paraPack.GetValue("数据类型"));
paraPack.SetCtrlValue(cbo_datatype, paraPack.GetValue("存储位置"));
paraPack.SetCtrlValue(ndCharSize, paraPack.GetValue("字节长度"));
paraPack.SetCtrlValue(cbPosition, paraPack.GetValue("按位存取"));
paraPack.SetCtrlValue(ndPosition, paraPack.GetValue("数据位"));
if (paraPack.GetValue("读写状态") == "可读可写")
{
paraPack.SetCtrlValue(rb_rw, "1");
}
if (paraPack.GetValue("读写状态") == "可读")
{
paraPack.SetCtrlValue(rb_r, 1);
}
if (paraPack.GetValue("读写状态") == "可写")
{
paraPack.SetCtrlValue(rb_w, 1);
}
}
public override void SimulatorStart()
{
if (simulatorTimer == null)
{
simulatorTimer = new Timer(delegate
{
Task.Run(() =>
{
for (int i = 0; i < this.IODevices.Count; i++)
{
try
{
ParaPack devicePack = new ParaPack(this.IODevices[i].IO_DEVICE_PARASTRING);
//构造Json模拟数据
MqttJsonObject mqttJsonObject = new MqttJsonObject();
mqttJsonObject.paras = new List <MqttJsonPara>();
mqttJsonObject.device = new MqttJsonDevice()
{
hard_version = "1.0.0",
run_time = "",
soft_version = "1.0.0",
status = "normal",
uid = devicePack.GetValue("设备识别号")
};
for (int p = 0; p < this.IODevices[i].IOParas.Count; p++)
{
if (this.IODevices[i].IOParas[p].IO_POINTTYPE == "模拟量" || this.IODevices[i].IOParas[p].IO_POINTTYPE == "开关量")
{
int simulatorValue = 0;
if (this.IODevices[i].IOParas[p].IO_MINVALUE != this.IODevices[i].IOParas[p].IO_MAXVALUE)
{
int min = -100;
if (this.IODevices[i].IOParas[p].IO_MINVALUE != null && this.IODevices[i].IOParas[p].IO_MINVALUE != "")
{
min = int.Parse(this.IODevices[i].IOParas[p].IO_MINVALUE);
}
int max = 100;
if (this.IODevices[i].IOParas[p].IO_MAXVALUE != null && this.IODevices[i].IOParas[p].IO_MAXVALUE != "")
{
min = int.Parse(this.IODevices[i].IOParas[p].IO_MAXVALUE);
}
simulatorValue = random.Next(min, max);
}
else
{
simulatorValue = random.Next(-100, 100);
}
ParaPack paraPack = new ParaPack(this.IODevices[i].IOParas[p].IO_PARASTRING);
mqttJsonObject.paras.Add(new MqttJsonPara()
{
name = paraPack.GetValue("JSON名称"),
datatype = paraPack.GetValue("数据类型"),
iotype = "analog",
version = "1.0.0",
data = new List <object>()
{
DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
paraPack.GetValue("版子地址"),
paraPack.GetValue("端口号"),
simulatorValue
}
});
}
}
//
string json = ScadaHexByteOperator.ObjectToJson(mqttJsonObject);
if (mqttJsonObject != null)
{
byte[] datas = ScadaHexByteOperator.StringToUTF8Byte(json);
this.ReceiveData(this.IOServer, this.IOCommunication, this.IODevices[i], datas, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
}
this.SimulatorAppendLog(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " 时间初始化一条设备模拟数据!");
}
catch (Exception emx)
{
this.SimulatorAppendLog(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " 接收数据错误! " + emx.Message);
}
}
});
}, null, 1000, Internal * 1000);
}
}
/// <summary>
/// 解析数据
/// </summary>
/// <param name="server"></param>
/// <param name="Communication"></param>
/// <param name="device"></param>
/// <param name="para"></param>
/// <param name="datas"></param>
/// <param name="datatime"></param>
/// <param name="sender"></param>
/// <returns></returns>
protected override IOData Analysis(IO_SERVER server, IO_COMMUNICATION Communication, IO_DEVICE device, IO_PARA para, byte[] datas, DateTime datatime, object sender)
{
if (datas.Length > 0 && sender != null && para != null)
{
ParaPack paraPack = new ParaPack(para.IO_PARASTRING);
ModbusFragmentStore modbusStore = (ModbusFragmentStore)sender;
IOData data = new IOData();
data.CommunicationID = Communication.IO_COMM_ID;
data.ID = device.IO_DEVICE_ADDRESS;
data.ParaName = para.IO_NAME;
data.ServerID = server.SERVER_ID;
data.Date = DateTime.Now;
Modbus_Type dataType = (Modbus_Type)Enum.Parse(typeof(Modbus_Type), paraPack.GetValue("数据类型"));
switch (dataType)
{
case Modbus_Type.单精度浮点数32位:
data.DataType = typeof(float);
break;
case Modbus_Type.双精度浮点数64位:
data.DataType = typeof(double);
break;
case Modbus_Type.字符型:
data.DataType = typeof(string);
break;
case Modbus_Type.无符号整数16位:
data.DataType = typeof(UInt16);
break;
case Modbus_Type.无符号整数32位:
data.DataType = typeof(UInt32);
break;
case Modbus_Type.无符号整数8位:
data.DataType = typeof(byte);
break;
case Modbus_Type.符号整数16位:
data.DataType = typeof(Int16);
break;
case Modbus_Type.符号整数8位:
data.DataType = typeof(sbyte);
break;
case Modbus_Type.符号整数32位:
data.DataType = typeof(int);
break;
}
data.datas = datas;
data.ParaString = para.IO_PARASTRING;
//获取数据值高八位,低八位
int startaddr = int.Parse(paraPack.GetValue("偏置"));
int charsize = int.Parse(paraPack.GetValue("字节长度"));
string code = paraPack.GetValue("内存区");
bool bitSave = paraPack.GetValue("按位存取") == "1" ? true : false;
bool ishigh = paraPack.GetValue("存储位置") == "高八位" ? true : false;
ModbusFragment fragment = modbusStore.Fragments.Find(x => x.Code == code && startaddr >= x.StartRegister && startaddr <= x.StartRegister + x.RegisterNum);
if (fragment != null)
{
switch (code)
{
case "01": //线圈
{
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
data.ParaValue = vdatas[startaddr].ToString();
}
break;
case "02": //线圈只读
{
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
data.ParaValue = vdatas[startaddr].ToString();
}
break;
case "03": //寄存器可读可写
{
//注意是否按位读取，
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
ushort[] vals = ModbusConvert.Bytes2Ushorts(vdatas); //将字节数组转为ushort
switch (dataType)
{
case Modbus_Type.单精度浮点数32位:
{
data.ParaValue = ModbusConvert.GetReal(vals, 0).ToString();
}
break;
case Modbus_Type.双精度浮点数64位:
{
data.ParaValue = ModbusConvert.GetDouble(vals, 0).ToString();
}
break;
case Modbus_Type.字符型:
{
data.ParaValue = ModbusConvert.GetString(vals, 0, charsize).ToString();
}
break;
case Modbus_Type.无符号整数16位:
{
data.ParaValue = ModbusConvert.GetUShort(vals, 0).ToString();
}
break;
case Modbus_Type.无符号整数32位:
{
data.ParaValue = ModbusConvert.GetUInt(vals, 0).ToString();
}
break;
case Modbus_Type.无符号整数8位:
{
data.ParaValue = ModbusConvert.GetSByte(vals, 0, ishigh).ToString();
}
break;
case Modbus_Type.符号整数16位:
{
data.ParaValue = ModbusConvert.GetShort(vals, 0).ToString();
}
break;
case Modbus_Type.符号整数8位:
{
data.ParaValue = ModbusConvert.GetByte(vals, 0, ishigh).ToString();
}
break;
case Modbus_Type.符号整数32位:
{
data.ParaValue = ModbusConvert.GetInt(vals, 0).ToString();
}
break;
}
}
break;
case "04": //寄存器只读
{
//注意是否按位读取，
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
ushort[] vals = ModbusConvert.Bytes2Ushorts(vdatas); //将字节数组转为ushort
switch (dataType)
{
case Modbus_Type.单精度浮点数32位:
{
data.ParaValue = ModbusConvert.GetReal(vals, 0).ToString();
}
break;
case Modbus_Type.双精度浮点数64位:
{
data.ParaValue = ModbusConvert.GetDouble(vals, 0).ToString();
}
break;
case Modbus_Type.字符型:
{
data.ParaValue = ModbusConvert.GetString(vals, 0, charsize).ToString();
}
break;
case Modbus_Type.无符号整数16位:
{
data.ParaValue = ModbusConvert.GetUShort(vals, 0).ToString();
}
break;
case Modbus_Type.无符号整数32位:
{
data.ParaValue = ModbusConvert.GetUInt(vals, 0).ToString();
}
break;
case Modbus_Type.无符号整数8位:
{
data.ParaValue = ModbusConvert.GetSByte(vals, 0, ishigh).ToString();
}
break;
case Modbus_Type.符号整数16位:
{
data.ParaValue = ModbusConvert.GetShort(vals, 0).ToString();
}
break;
case Modbus_Type.符号整数8位:
{
data.ParaValue = ModbusConvert.GetByte(vals, 0, ishigh).ToString();
}
break;
case Modbus_Type.符号整数32位:
{
data.ParaValue = ModbusConvert.GetInt(vals, 0).ToString();
}
break;
}
}
break;
}
}
}
return(null);
}
private bool ResponseData(IO_SERVER server, IO_COMMUNICATION comm, IO_DEVICE device, IO_PARA para, string value)
{
if (para == null)
{
return(false);
}
if (para.IO_POINTTYPE == "计算值" || para.IO_POINTTYPE == "关系数据库值")
{
return(false);
}
//设备地址不能为空
if (device.IO_DEVICE_ADDRESS == "")
{
return(false);
}
try
{
//通过设备驱动进行数据解析，并生成下置的数据bytes
if (device.DeviceDrive != null)
{
ScadaDeviceKernel Driver = (ScadaDeviceKernel)device.DeviceDrive;
//获取参数中的
if (udpClient != null && master != null)
{
ParaPack paraPack = new ParaPack(para.IO_PARASTRING);
if (paraPack.Count > 0)
{
ushort offset = ushort.Parse(paraPack.GetValue("偏置"));
switch (paraPack.GetValue("内存区"))
{
case "01":
{
if (ushort.Parse(value) > 0)
{
master.WriteSingleCoil(byte.Parse(device.IO_DEVICE_ADDRESS), offset, true);
}
else
{
master.WriteSingleCoil(byte.Parse(device.IO_DEVICE_ADDRESS), offset, false);
}
}
break;
case "02": //此类型只能查询，不能写入
{
}
break;
case "03":
{
Modbus_Type datatype = (Modbus_Type)Enum.Parse(typeof(Modbus_Type), paraPack.GetValue("数据类型"));
bool ishigh = paraPack.GetValue("存储位置") == "高八位" ? true : false;
int charsize = int.Parse(paraPack.GetValue("字节长度"));
bool isposition = paraPack.GetValue("按位存取") == "1" ? true : false;
int dataposition = int.Parse(paraPack.GetValue("数据位"));
switch (datatype)
{
case Modbus_Type.单精度浮点数32位:
{
ushort[] buff = new ushort[2];
float WriteValue = float.Parse(value);
ModbusConvert.SetReal(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff);
}
break;
case Modbus_Type.双精度浮点数64位:
{
ushort[] buff = new ushort[4];
double WriteValue = double.Parse(value);
ModbusConvert.SetDouble(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff);
}
break;
case Modbus_Type.字符型:
{
ushort[] buff = new ushort[charsize];
string WriteValue = value;
if (value.Length > charsize)
{
WriteValue = value.Substring(0, charsize);
}
if (value.Length < charsize)
{
WriteValue = value.PadRight(charsize, ' ');
}
ModbusConvert.SetString(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff);
}
break;
case Modbus_Type.无符号整数8位:
{
ushort[] buff = new ushort[1];
byte WriteValue = byte.Parse(value);
ModbusConvert.SetByte(buff, 0, WriteValue, ishigh);
master.WriteSingleRegister(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff[0]);
}
break;
case Modbus_Type.符号整数8位:
{
ushort[] buff = new ushort[1];
sbyte WriteValue = sbyte.Parse(value);
ModbusConvert.SetSByte(buff, 0, WriteValue, ishigh);
master.WriteSingleRegister(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff[0]);
}
break;
case Modbus_Type.无符号整数16位:
{
if (isposition)
{
//获取当前寄存器的值
ushort[] datas = master.ReadHoldingRegisters(byte.Parse(device.IO_DEVICE_ADDRESS), offset, 1);
ushort dataValue = ModbusConvert.GetUShort(datas, 0);
if (short.Parse(value) > 0)
{
dataValue = Convert.ToUInt16(dataValue >> dataposition & 1);
}
else
{
dataValue = Convert.ToUInt16(dataValue >> dataposition & 0);
}
//新发送的值
ushort[] datas2 = new ushort[1];
ModbusConvert.SetUShort(datas2, 0, dataValue);
master.WriteSingleRegister(byte.Parse(device.IO_DEVICE_ADDRESS), offset, datas2[0]);
}
else
{
ushort WriteValue = ushort.Parse(value);
ushort[] buff = new ushort[1];
ModbusConvert.SetUShort(buff, 0, WriteValue);
master.WriteSingleRegister(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff[0]);
}
}
break;
case Modbus_Type.符号整数16位:
{
if (isposition)
{
//获取当前寄存器的值
ushort[] datas = master.ReadHoldingRegisters(byte.Parse(device.IO_DEVICE_ADDRESS), offset, 1);
short dataValue = ModbusConvert.GetShort(datas, 0);
if (short.Parse(value) > 0)
{
dataValue = Convert.ToInt16(dataValue >> dataposition & 1);
}
else
{
dataValue = Convert.ToInt16(dataValue >> dataposition & 0);
}
//新发送的值
ushort[] datas2 = new ushort[1];
ModbusConvert.SetShort(datas2, 0, dataValue);
master.WriteSingleRegister(byte.Parse(device.IO_DEVICE_ADDRESS), offset, datas2[0]);
}
else
{
Int16 WriteValue = Int16.Parse(value);
ushort[] buff = new ushort[1];
ModbusConvert.SetShort(buff, 0, WriteValue);
master.WriteSingleRegister(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff[0]);
}
}
break;
case Modbus_Type.无符号整数32位:
{
uint WriteValue = uint.Parse(value);
ushort[] buff = new ushort[2];
ModbusConvert.SetUInt(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff);
}
break;
case Modbus_Type.符号整数32位:
{
int WriteValue = int.Parse(value);
ushort[] buff = new ushort[2];
ModbusConvert.SetInt(buff, 0, WriteValue);
master.WriteMultipleRegisters(byte.Parse(device.IO_DEVICE_ADDRESS), offset, buff);
}
break;
}
}
break;
}
}
}
}
}
catch
{
return(false);
}
return(true);
}
protected override void Start()
{
if (null != _mqttServer)
{
return;
}
///相关参数不能为空
if (this.IOServer == null || this.IOCommunication == null)
{
return;
}
var optionBuilder =
new MqttServerOptionsBuilder().WithConnectionBacklog(1000).WithDefaultEndpointPort(ServerPort);
if (!String.IsNullOrEmpty(ServerIP))
{
optionBuilder.WithDefaultEndpointBoundIPAddress(IPAddress.Parse(ServerIP));
}
var options = optionBuilder.Build();
//连接验证
(options as MqttServerOptions).ConnectionValidator += context =>
{
string clientId = "";
Task.Run(() =>
{
try
{
ParaPack paraPack = new ParaPack(this.IOCommunication.IO_COMM_PARASTRING);
if (context.ClientId.Length < 2)
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
return;
}
if (EaableAnonymousAuthentication)
{
if (!context.Username.Equals(this.UserName))
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
return;
}
if (!context.Password.Equals(this.Password))
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
return;
}
}
bool isValidCleint = false;
for (int i = 0; i < IODevices.Count; i++)
{
ParaPack deviceparaPack = new ParaPack(IODevices[i].IO_DEVICE_PARASTRING);
clientId = deviceparaPack.GetValue("MQTT连接ID号").Trim(); // 将字符串转换为字符数组
if (clientId.Trim() == context.ClientId.Trim())
{
isValidCleint = true;
IODevices[i].Tag = clientId.Trim();//标记对应的客户端ID号
}
}
if (isValidCleint)
{
context.ReturnCode = MqttConnectReturnCode.ConnectionAccepted;
}
else
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
}
}
catch
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
}
if (string.IsNullOrEmpty(clientId))
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
}
});
};
_mqttServer = new MqttFactory().CreateMqttServer();
//开始连接
_mqttServer.ClientConnected += (sender, args) =>
{
if (args.ClientId == null || args.ClientId == "")
{
return;
}
IO_DEVICE device = this.IODevices.Find(x => x.Tag.ToString().Trim() == args.ClientId.Trim());
if (device == null)
{
for (int i = 0; i < IODevices.Count; i++)
{
ParaPack deviceparaPack = new ParaPack(IODevices[i].IO_DEVICE_PARASTRING);
string clientId = deviceparaPack.GetValue("MQTT连接ID号").Trim(); // 将字符串转换为字符数组
if (clientId.Trim() == args.ClientId.Trim())
{
IODevices[i].Tag = clientId.Trim();//标记对应的客户端ID号
device = IODevices[i];
break;
}
}
}
if (device == null)
{
return;
}
ParaPack commPack = new ParaPack(this.IOCommunication.IO_COMM_PARASTRING);
ParaPack devicePack = new ParaPack(device.IO_DEVICE_PARASTRING);
#region 通用MQTT解析
{
//客户端连接上后发布订阅数据
List <TopicFilter> topicFilters = new List <TopicFilter>();
device.IO_DEVICE_STATUS = 1;
this.DeviceStatus(this.IOServer, IOCommunication, device, null, "1");
string clientId = devicePack.GetValue("MQTT连接ID号").Trim(); // 将字符串转换为字符数组
device.Tag = clientId;
if (clientId.Trim() == args.ClientId.Trim())
{
TopicFilter topicFilter = new TopicFilter(devicePack.GetValue("数据订阅主题").Trim(), MessageQulity);
topicFilters.Add(topicFilter);
try
{
Task.Run(async() =>
{
await _mqttServer.SubscribeAsync(args.ClientId.Trim(), topicFilters);
});
}
catch (Exception)
{
this.DeviceException("ERROR=MQTTNet_20006,发布订阅主题失败 ");
}
}
else
{
this.DeviceException("ERROR=MQTTNet_20006,MQTT ID与设备配置ID不匹配 ");
}
//定时向客户端发布一个读取数据的订阅
if (commPack.GetValue("接收方式") == "主动")
{
MQTTTimer cleintMqtt = new MQTTTimer()
{
ClientID = args.ClientId
};
MqttClientTimes.Add(cleintMqtt);
cleintMqtt.Timer = new Timer(delegate
{
if (!cleintMqtt.IsStop)
{
try
{
_mqttServer.PublishAsync(
new MqttApplicationMessage()
{
QualityOfServiceLevel = MessageQulity,
Retain = false,
Topic = devicePack.GetValue("主动请求主题").Trim(),
Payload = Encoding.UTF8.GetBytes("{\"uid\":\"" + devicePack.GetValue("设备ID编码").Trim() + "\",\"updatecycle\":\"" + device.IO_DEVICE_UPDATECYCLE + "\",\"topic\":\"" + devicePack.GetValue("数据订阅主题").Trim() + "\"}")
}
);
///服务端向客户端发送一个服务器端循环查询数据的周期
_mqttServer.PublishAsync(
new MqttApplicationMessage()
{
QualityOfServiceLevel = MessageQulity,
Retain = false,
Topic = devicePack.GetValue("循环周期主题").Trim(),
Payload = Encoding.UTF8.GetBytes("{\"uid\":\"" + devicePack.GetValue("设备ID编码").Trim() + "\",\"updatecycle\":\"" + device.IO_DEVICE_UPDATECYCLE + "\",\"topic\":\"" + devicePack.GetValue("数据订阅主题").Trim() + "\"}")
}
);
}
catch (Exception)
{
this.DeviceException("ERROR=MQTTNet_20006,发布订阅主题失败 ");
}
}
}, args, 1000, device.IO_DEVICE_UPDATECYCLE * 1000);
}
}
#endregion
};
///断开连接
_mqttServer.ClientDisconnected += (sender, args) =>
{
Task.Run(() =>
{
if (args.WasCleanDisconnect)
{
IO_DEVICE device = this.IODevices.Find(x => x.Tag.ToString().Trim() == args.ClientId.Trim());
if (device != null)
{
device.IO_DEVICE_STATUS = 0;
this.DeviceStatus(this.IOServer, IOCommunication, device, null, "0");
}
}
});
MQTTTimer cleintTimer = MqttClientTimes.Find(x => x.ClientID == args.ClientId);
if (cleintTimer != null)
{
cleintTimer.Close();
MqttClientTimes.Remove(cleintTimer);
}
};
///接收到订阅主题的数据数据
_mqttServer.ApplicationMessageReceived += (sender, args) =>
{
if (args.ClientId == null || args.ClientId.Trim() == "")
{
return;
}
if (args.ApplicationMessage.Payload == null || args.ApplicationMessage.Payload.Length <= 0)
{
this.DeviceException("接收的数据为空");
return;
}
ParaPack commPack = new ParaPack(this.IOCommunication.IO_COMM_PARASTRING);
try
{
Task.Run(() =>
{
string cleintId = args.ClientId.Trim();
//将接收到的数据发送到实际的对应的解析数据库中
List <IO_DEVICE> selects = this.IODevices.FindAll(x => x.Tag.ToString().Trim() == args.ClientId.Trim());
if (selects.Count <= 0)
{
return;
}
string strs = ScadaHexByteOperator.UTF8ByteToString(args.ApplicationMessage.Payload);
IO_DEVICE device = null;
for (int i = 0; i < selects.Count; i++)
{
ParaPack selePack = new ParaPack(selects[i].IO_DEVICE_PARASTRING);
#region
CommonMqttJsonObject mqttJsonObject = ScadaHexByteOperator.JsonToObject <CommonMqttJsonObject>(strs);
if (mqttJsonObject == null || mqttJsonObject.paras == null || mqttJsonObject.paras.Count <= 0)
{
this.DeviceException("接收数据对象转换失败了,没有数据" + strs.Count());
this.DeviceException(strs);
continue;
}
string selectUid = selePack.GetValue("设备ID编码");
if (selectUid.Trim() == mqttJsonObject.device.uid.Trim())
{
device = selects[i];
break;
}
#endregion
}
if (device == null)
{
return;
}
device.IO_DEVICE_STATUS = 1;
ParaPack paraPack = new ParaPack(device.IO_DEVICE_PARASTRING);
#region
string deviceUid = paraPack.GetValue("设备ID编码");
if (!string.IsNullOrEmpty(device.IO_DEVICE_PARASTRING) && args.ApplicationMessage.Topic.Trim() == paraPack.GetValue("数据订阅主题").Trim())
{
CommonMqttJsonObject mqttJsonObject = ScadaHexByteOperator.JsonToObject <CommonMqttJsonObject>(strs);
this.ReceiveData(this.IOServer, IOCommunication, device, args.ApplicationMessage.Payload, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), mqttJsonObject);
}
#endregion
});
}
catch
{
return;
}
};
///订阅主题
_mqttServer.ClientSubscribedTopic += (sender, args) =>
{
};
///取消订阅主题
_mqttServer.ClientUnsubscribedTopic += (sender, args) =>
{
};
_mqttServer.Started += (sender, args) =>
{
this.IOCommunication.IO_COMM_STATUS = 1;
};
_mqttServer.Stopped += (sender, args) =>
{
this.IOCommunication.IO_COMM_STATUS = 0;
};
_mqttServer.StartAsync(options);
ParaPack commpack = new ParaPack(this.IOCommunication.IO_COMM_PARASTRING);
this.CommunctionStartChanged(this.IOServer, this.IOServer.SERVER_IP + " " + this.IOServer.SERVER_NAME + "启动服务");
}
