private void decodeSetMessage(ModbusMessage msg)
{
String setType = (String)msg.Data["SetType"];
if ("yiYeWeiZhi".Equals(setType))
{
LHS_SuctionPlate = (String)msg.Data["LHS_SuctionPlate"];
LHS_TargetPlate = (String)msg.Data["LHS_TargetPlate"];
LHS_Imbitition = Int32.Parse((String)msg.Data["LHS_Imbitition"]);
}
if ("suDuSheZhi".Equals(setType))
{
LHS_LiquidRate = Int32.Parse((String)msg.Data["LHS_LiquidRate"]);
LHS_DischargeRate = Int32.Parse((String)msg.Data["LHS_DischargeRate"]);
}
if ("weiZhiSheZhi".Equals(setType))
{
LHS_LiquidPosition = Int32.Parse((String)msg.Data["LHS_LiquidPosition"]);
LHS_DischargePosition = Int32.Parse((String)msg.Data["LHS_DischargePosition"]);
}
if ("LHS_PlateStatus".Equals(setType))
{
LHS_PlateStatus = (String)msg.Data["LHS_PlateStatus"];
}
}
public override void ReceiveMsg(String s)
{
ModbusMessage message = ModbusMessageHelper.decodeModbusMessage(s);
switch (message.MsgType)
{
case ModbusMessage.MessageType.RESPONSE:
decodeResponseMessage(message);
break;
case ModbusMessage.MessageType.CMD:
decodeCmdMessage(message);
break;
case ModbusMessage.MessageType.REPORT:
decodeReportMessage(message);
break;
case ModbusMessage.MessageType.SET:
decodeSetMessage(message);
break;
case ModbusMessage.MessageType.GET:
break;
}
}
public override void ReceiveMsg(String s)
{
ModbusMessage message = ModbusMessageHelper.decodeModbusMessage(s);
//switch (message.MsgType)
{
}
}
public static String createCmd(String cmd)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("Cmd", cmd);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.CMD), creator.getDataBytes()));
}
private void decodeBasicMsg(String s)
{
ModbusMessage message = ModbusMessageHelper.decodeModbusMessage(s);
DeviceType type = EnumHelper.deviceStringToDeviceType((String)message.Data["DeviceType"]);
BaseVirtualDevice device = (BaseVirtualDevice)VirtualDeviceFactory.createVirtualDevice(type, true);
device.IsVirt = true;
device.CurrentDeviceType = type;
/*
* if (type == DeviceType.Dispen)
* {
* String subType = (String)message.Data["SubType"];
* if ("PeiYangMin".Equals(subType))
* {
* ((AutoDispenVirtualDevice)device).SubType = AutoDispenVirtualDevice.AutoDispenType.PeiYangMin;
* }
* else
* {
* ((AutoDispenVirtualDevice)device).SubType = AutoDispenVirtualDevice.AutoDispenType.ShenKongBan;
* }
* }*/
device.IdentifyID = (String)message.Data["IdentifyID"];
device.Code = (String)message.Data["Code"];
device.IP = (String)message.Data["IP"];
device.Name = (String)message.Data["Name"];
device.SerialID = (String)message.Data["SerialID"];
device.MySocket = mySocket;
device.DeviceManager = deviceManager;
device.init();
deviceManager.addDevice(device);
}
public override void decodeCmdMessage(ModbusMessage msg)
{
String cmd = (String)msg.Data["Cmd"];
if ("Start".Equals(cmd))
{
//dispenTimer.Start();
this.MDF_Cmd = "Start";
}
if ("Reset".Equals(cmd))
{
MDF_WhichDish = 1;
MDF_WhichStack = 1;
this.MDF_Cmd = "Reset";
}
if ("Stop".Equals(cmd))
{
//dispenTimer.Stop();
this.MDF_Cmd = "Stop";
}
if ("Auto".Equals(cmd))
{
this.MDF_Cmd = "Auto";
}
this.sendOKResponse();
}
public override void decodeReportMessage(ModbusMessage msg)//解码报告消息
{
String reportType = (String)msg.Data["ReportType"];
if ("MPF_Current".Equals(reportType))
{
MPF_Current1 = double.Parse((String)msg.Data["MPF_Current1"]);
MPF_Current2 = double.Parse((String)msg.Data["MPF_Current2"]);
MPF_Current3 = double.Parse((String)msg.Data["MPF_Current3"]);
MPF_Current4 = double.Parse((String)msg.Data["MPF_Current4"]);
}
if ("MPF".Equals(reportType))
{
String PlateNum = (String)msg.Data["MPF_Whichplate"];
String Barcode = (String)msg.Data["MPF_BarCode"];
MPFDispenMessage disMsg = new MPFDispenMessage();
disMsg.PlateNum = PlateNum;
disMsg.Barcode = Barcode;
lock (DispenMessages)
{
DispenMessages.Add(disMsg);
}
lock (RefreshObject)
{
needRefreshMessages = true;
}
}
}
public void SendMessage(Rs232CommunicationManager rs232Manager, ModbusMessage message)
{
int messageLength = message.Data.Length * 2;
var data = new byte[messageLength + 7];
data[0] = (byte)':';
byte[] address = HexHelper.EncodeByteAsHex(message.Address);
byte[] function = HexHelper.EncodeByteAsHex(message.Function);
data[1] = address[0];
data[2] = address[1];
data[3] = function[0];
data[4] = function[1];
byte[] messageBytes = HexHelper.EncodeAsHexArray(message.Data);
for (int i = 0; i < messageLength; i++)
data[5 + i] = messageBytes[i];
byte[] numericMessage = HexHelper.DecodeHexArray(data, 1, 4 + messageLength);
byte[] lrc = HexHelper.EncodeByteAsHex(CalculateLRC(numericMessage));
data[data.Length - 2] = lrc[0];
data[data.Length - 1] = lrc[1];
// The data is now 8 bits per character, but it's not a problem, it will
// be reduced to 7 bits per character automatically.
rs232Manager.SendMessage(new RS232Message(data));
}
public static String createOKResponse()
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("Result", "OK");
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.RESPONSE), creator.getDataBytes()));
}
public override void decodeReportMessage(ModbusMessage msg)//解码报告消息
{
String reportType = (String)msg.Data["ReportType"];
if ("MDF_Current".Equals(reportType))
{
MDF_Current1 = double.Parse((String)msg.Data["MDF_Current1"]);
MDF_Current2 = double.Parse((String)msg.Data["MDF_Current2"]);
MDF_Current3 = double.Parse((String)msg.Data["MDF_Current3"]);
MDF_Current4 = double.Parse((String)msg.Data["MDF_Current4"]);
}
if ("MDF".Equals(reportType))
{
String Stackcode = (String)msg.Data["MDF_WhichStack"];
String Petricode = (String)msg.Data["MDF_WhichDish"];
String Barcode = (String)msg.Data["MDF_BarCode"];
MDFDispenMessage xinXi = new MDFDispenMessage();
xinXi.Stackcode = Stackcode;
xinXi.Petricode = Petricode;
xinXi.Barcode = Barcode;
lock (DispenMessages)
{
DispenMessages.Add(xinXi);
}
lock (RefreshObject)
{
needRefreshMessages = true;
}
}
}
public static String createODReport(String OD)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("ReportType", "OD");
creator.addKeyPair("OD", OD);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.REPORT), creator.getDataBytes()));
}
public ModbusRequest(ModbusMessage message, byte slaveAddress, short register, int attempts = 3, int timeout = 5000)
{
Message = message;
SlaveAddress = slaveAddress;
RegisterNumber = register;
AttemptsLeft = attempts - 1;
_timeout = timeout;
}
public static String createStopMsg(int moduleNum)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "Stop");
creator.addKeyPair("moduleNum", moduleNum.ToString());
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createSetMode(String s)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "Mode");
creator.addKeyPair("Mode", s);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createDeployStatus(String LHS_PlateStatus)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "LHS_PlateStatus");
creator.addKeyPair("LHS_PlateStatus", LHS_PlateStatus);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createSuDuConfirmMsg(String LHS_LiquidRate, String LHS_DischargeRate)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "suDuSheZhi");
creator.addKeyPair("LHS_LiquidRate", LHS_LiquidRate);
creator.addKeyPair("LHS_DischargeRate", LHS_DischargeRate);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createSetSystem(String Mode, String Command)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "System");
creator.addKeyPair("Sys_Mode", Mode);
creator.addKeyPair("Sys_Command", Command);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createSetLight(String pwm, String allightText)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "Light");
creator.addKeyPair("Light_pwm", pwm);
creator.addKeyPair("Light_allighText", allightText);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createSetMianJiLowAndUpp(String Lower, String Upper)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "MianJiShaiXuan");
creator.addKeyPair("MianJi_Max", Upper);
creator.addKeyPair("MianJi_Min", Lower);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createWeiZhiConfirmMsg(String LHS_LiquidPosition, String LHS_DischargePosition)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "weiZhiSheZhi");
creator.addKeyPair("LHS_LiquidPosition", LHS_LiquidPosition);
creator.addKeyPair("LHS_DischargePosition", LHS_DischargePosition);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
/// <summary>
/// Retrieves the Hardware Version from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The hardware version as reported by the charge controller</returns>
public static string GetHardwareVersion(ModbusMessenger messenger)
{
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
ModbusMessage registers = messenger.ReadHoldingRegisters(0xf00a, 0x0001);
messenger.TransportEndoing = te;
return(registers.DataPoints[0] + "." + registers.DataPoints[1]);
}
public static String createCodeReport(String Add_Num, String Rem_Num)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("ReportType", "Code");
creator.addKeyPair("Add_Num", Add_Num);
creator.addKeyPair("Rem_Num", Rem_Num);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.REPORT), creator.getDataBytes()));
}
public override void decodeSetMessage(ModbusMessage msg)
{
String setType = (String)msg.Data["SetType"];
if ("MPF_NumAndVol".Equals(setType))
{
this.MPF_PlateNum = Int32.Parse((String)msg.Data["MPF_PlateNum"]);
this.MPF_Volsperwell = double.Parse((String)msg.Data["MPF_Volsperwell"]);
}
}
public static String createSetMotor(String text_speed, String elecspeed, String slope)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "Motor");
creator.addKeyPair("Motor_text_speed", text_speed);
creator.addKeyPair("Motor_elecspeed", elecspeed);
creator.addKeyPair("Motor_slope", slope);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public static String createSystemReport(String DeviceInfo, String Status, String Batch_Info)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("ReportType", "System");
creator.addKeyPair("Sys_DeviceInfo", DeviceInfo);
creator.addKeyPair("Sys_Status", Status);
creator.addKeyPair("Sys_Batch_Info", Batch_Info);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.REPORT), creator.getDataBytes()));
}
private void cmdSend_Click(object sender, EventArgs e)
{
var message = new ModbusMessage(
txtMessageText.Text,
Convert.ToByte(txtAddress.Text),
Convert.ToByte(txtFunction.Text, 16));
communicationManager.SendMessage(message);
InvokeDisplayModbusMessage(message, MessageType.Outgoing);
}
private void decodeSetMessage(ModbusMessage msg)
{
String setType = (String)msg.Data["SetType"];
if ("Mode".Equals(setType))
{
String mode = (String)msg.Data["Mode"];
MMA_TestMode = stringToJianCeMoShi(mode);
}
}
public static String createMuBiaoConfirmMsg(String LHS_SuctionPlate, String LHS_TargetPlate, String LHS_Imbitition)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "yiYeWeiZhi");
creator.addKeyPair("LHS_SuctionPlate", LHS_SuctionPlate);
creator.addKeyPair("LHS_TargetPlate", LHS_TargetPlate);
creator.addKeyPair("LHS_Imbitition", LHS_Imbitition);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.SET), creator.getDataBytes()));
}
public override void decodeSetMessage(ModbusMessage msg)
{
String setType = (String)msg.Data["SetType"];
if ("MDF_NumAndVol".Equals(setType))
{
this.MDF_NumsperStack = Int32.Parse((String)msg.Data["MDF_NumsperStack"]);
this.MDF_VolsperDish = double.Parse((String)msg.Data["MDF_VolsperDish"]);
}
}
public override void ReceiveMsg(String s)
{
ModbusMessage message = ModbusMessageHelper.decodeModbusMessage(s);
switch (message.MsgType)
{
case ModbusMessage.MessageType.SET:
decodeSetMessage(message);
break;
}
}
public static String createMotorReport(String Status, String text_speed, String elecspeed, String Power)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("ReportType", "Motor");
creator.addKeyPair("Motor_Status", Status);
creator.addKeyPair("Motor_text_speed", text_speed);
creator.addKeyPair("Motor_elecspeed", elecspeed);
creator.addKeyPair("Motor_Power", Power);
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.REPORT), creator.getDataBytes()));
}
/// <summary>
/// Retrieves the Serial Number from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The serial number of the charge controller</returns>
public static string GetSerialNumber(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
ModbusMessage registers = messenger.ReadHoldingRegisters(0xf000, 0x0004);//was 0x0008
messenger.TransportEndoing = te;
return(System.Text.Encoding.ASCII.GetString(registers.DataPoints.ToArray()));//needed substring 0, 8
}
public static String createResponseMsg(int moduleNum, int tpR, int phR, int doR)
{
ModbusMessageDataCreator creator = new ModbusMessageDataCreator();
creator.addKeyPair("SetType", "Response");
creator.addKeyPair("moduleNum", moduleNum.ToString());
creator.addKeyPair("tpR", tpR.ToString());
creator.addKeyPair("phR", phR.ToString());
creator.addKeyPair("doR", doR.ToString());
return(ModbusMessageHelper.createModbusMessage(ModbusMessage.messageTypeToByte(ModbusMessage.MessageType.RESPONSE), creator.getDataBytes()));
}
private void InvokeDisplayModbusMessage(ModbusMessage message, MessageType type)
{
string stringToDisplay = string.Format(
"Address: {0} Function: {1:X} Message: {2}",
message.Address,
message.Function,
HexHelper.EncodeAsHexString(message.Data));
rtbDisplay.InvokeDisplayMessage(stringToDisplay, type);
}
public void BeginReadFromSlave(byte slaveAddress, short register, Action<string> onSuccessCallback)
{
if (_sentRequests.ContainsKey(slaveAddress))
return;
var data = new byte[2];
ArrayHelper.WriteShortToByteArray(data, register, 0);
ModbusMessage message = new ModbusMessage(data, slaveAddress, ReadFunctionCode);
ModbusRequest request = AddSentRequest(slaveAddress, register, message, OnResponseToReadRequestReceived);
_modbusManager.SendMessage(message);
request.StartTimer();
}
private void OnResponseToWriteRequestReceived(ModbusRequest request, ModbusMessage message)
{
}
private void OnResponseToReadRequestReceived(ModbusRequest request, ModbusMessage message)
{
if (message.Function == ReadFunctionCode)
{
string readValue = new UTF8Encoding().GetString(message.Data);
if (DataReadEvent != null)
DataReadEvent(this, new ModbusDataReadEventArgs(request.SlaveAddress, request.RegisterNumber, readValue));
}
}
private ModbusRequest AddSentRequest(byte slaveAddress, short register, ModbusMessage message, Action<ModbusRequest, ModbusMessage> ResponseHandler)
{
ModbusRequest request = new ModbusRequest(message, slaveAddress, register, NumberOfAttempts, RequestTimeout);
request.TimeoutEvent += new EventHandler(OnRequestTimeout);
request.ResponseHandler = ResponseHandler;
_sentRequests.Add(slaveAddress, request);
return request;
}
public void WriteToSlave(byte slaveAddress, short register, string value)
{
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
writer.Write(register);
writer.Write(new UTF8Encoding().GetBytes(value));
writer.Flush();
byte[] data = stream.ToArray();
ModbusMessage message = new ModbusMessage(data, slaveAddress, WriteFunctionCode);
ModbusRequest request = AddSentRequest(slaveAddress, register, message, OnResponseToWriteRequestReceived);
_modbusManager.SendMessage(message);
request.StartTimer();
}
}
private void OnReadRequestReceived(ModbusMessage message)
{
if (message.Data.Length < 2)
return;
short register = ArrayHelper.ReadShortFromByteArray(message.Data, 0);
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
writer.Write(new UTF8Encoding().GetBytes(GetRegisterValue(register)));
writer.Flush();
modbusManager.SendMessage(new ModbusMessage(stream.ToArray(), Address, ReadFunctionCode));
}
}
private void OnWriteRequestReceived(ModbusMessage message)
{
if (message.Data.Length < 4)
return;
using (var stream = new MemoryStream(message.Data))
using (var reader = new BinaryReader(stream))
{
var register = reader.ReadInt16();
var data = new byte[message.Data.Length - 2];
reader.Read(data, 0, message.Data.Length - 2);
string newValue = new UTF8Encoding().GetString(data);
SetRegisterValue(register, newValue);
}
modbusManager.SendMessage(message);
}
public void SendMessage(ModbusMessage message)
{
messageProcessor.SendMessage(rs232Manager, message);
}
public void SendMessage(Rs232CommunicationManager rs232Manager, ModbusMessage message)
{
throw new NotImplementedException();
}
