public void ByteToHexStringTest2( )
{
byte[] b1 = new byte[] { 0x13, 0xA6, 0x15, 0x85, 0x5B, 0x05, 0x12, 0x36, 0xF2, 0x27 };
string str = "13A615855B051236F227";
Assert.AreEqual(str, SoftBasic.ByteToHexString(b1));
}
public void ByteToHexStringTest3( )
{
string str1 = "1234";
string str2 = "3100320033003400";
Assert.AreEqual(str2, SoftBasic.ByteToHexString(str1));
}
public void ReverseBytesByWordTest5( )
{
byte[] data = new byte[8] {
0x46, 0x38, 0xA0, 0xB0, 0xFF, 0x3D, 0xC1, 0x08
};
byte[] buffer = ReverseBytesByWord(data, DataFormat.DCBA);
Assert.IsTrue(Communication.BasicFramework.SoftBasic.IsTwoBytesEquel(new byte[] { 0x46, 0x38, 0xA0, 0xB0, 0xFF, 0x3D, 0xC1, 0x08 }, buffer),
"Data:" + SoftBasic.ByteToHexString(buffer) + " Actual:" + SoftBasic.ByteToHexString(new byte[] { 0x08, 0xC1, 0x3D, 0xFF, 0xB0, 0xA0, 0x38, 0x46 }));
}
// 读取成功时，显示结果数据
private void ShowReadContent(OperateResult <byte[]> result, string strplc)
{
// 本方法是考虑了后台线程调用的情况
if (InvokeRequired)
{
// 如果是后台调用显示UI，那么就使用委托来切换到前台显示
Invoke(new Action <OperateResult <byte[]>, string>(ShowReadContent), result, strplc);
return;
}
byte[] arry = result.Content;
//PLC1的请求指令区10字节
byte[] arry1 = new byte[10];
//PLC2的写入分步指令区10字节
byte[] arry2 = new byte[10];
if (strplc == "PLC1")
{
int waringflag = arry[20];
Array.Copy(arry, 0, arry1, 0, 10);
textBox10.Text = "读指令区：" + SoftBasic.ByteToHexString(arry1, ' ') + "\r\n" +
"A1工位指令撤销状态：" + arry[10].ToString() + "\r\n" +
"A2工位指令撤销状态：" + arry[11].ToString() + "\r\n" +
"抽检工位指令撤销状态：" + arry[12].ToString() + "\r\n" +
"B工位指令撤销状态：" + arry[13].ToString() + "\r\n" +
"地面PLC报警状态：" + arry[20].ToString() + "\r\n" +
"夹具状态不对应报警：" + arry[21].ToString() + "\r\n" +
"退库自动出库物料规格：" + arry[14].ToString() + "\r\n" +
"退库自动出库物料状态：" + arry[15].ToString() + "\r\n";
}
if (strplc == "PLC2")
{
Array.Copy(arry, 10, arry2, 0, 10);
//Array.Copy(arry, 40, arry3, 0, 10);
int WX = (int)(arry[30] * 256) + arry[31];
int WY = (int)(arry[32] * 256) + arry[33];
int WZ = (int)(arry[34] * 256) + arry[35];
//int startflag = arry[36];
//int actionflag = arry[37];
int RX = (int)(arry[40] * 256) + arry[41];
int RY = (int)(arry[42] * 256) + arry[43];
int RZ = (int)(arry[44] * 256) + arry[45];
textBox6.Text = "写指令区：" + SoftBasic.ByteToHexString(arry2, ' ') + "\r\n" +
"夹具状态：" + arry[28].ToString() + "\r\n" +
"新写入坐标标志：" + arry[29].ToString() + "\r\n" +
"写入坐标：" + "X坐标：" + WX.ToString() + " Y坐标：" + WY.ToString() + " Z坐标：" + WZ.ToString() + "\r\n" +
"启动信号：" + arry[36].ToString() + " 抓放动作：" + arry[37].ToString() + " 区域标签：" + arry[38].ToString() + "\r\n" +
"请求指令工位来源：" + arry[39].ToString() + "\r\n" +
"实时坐标：" + "X坐标：" + RX.ToString() + " Y坐标：" + RY.ToString() + " Z坐标：" + RZ.ToString() + "\r\n" +
"PLC X,Y到位标志：" + arry[46].ToString() + "\r\n" +
"抓放完成标志：" + arry[47].ToString() + " " + " 允许下降标志：" + arry[48].ToString() + "\r\n";
}
}
private void button3_Click(object sender, EventArgs e)
{
try
{
textBox2.Text = SoftBasic.ByteToHexString(File.ReadAllBytes(textBox1.Text), ' ', 32);
}
catch (Exception ex)
{
MessageBox.Show("Failed:" + ex.Message);
}
}
public void ByteToHexStringExample1( )
{
#region ByteToHexStringExample1
byte[] b1 = new byte[] { 0x13, 0xA6, 0x15, 0x85, 0x5B, 0x05, 0x12, 0x36, 0xF2, 0x27 };
Console.WriteLine(SoftBasic.ByteToHexString(b1, ' '));
// 输出 "13 A6 15 85 5B 05 12 36 F2 27";
#endregion
}
/// <summary>
/// 批量读取
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Btn_ReadMany_Click(object sender, EventArgs e)
{
try
{
OperateResult <byte[]> result = siemensTcpNet.Read(txt_ReadMany_Address.Text, ushort.Parse(txt_ReadMany_Lenth.Text));
if (result.IsSuccess)
{
txt_Result_Many.Text = $"结果：{SoftBasic.ByteToHexString(result.Content)}";
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 读取报文
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Btn_Read_Message_Click(object sender, EventArgs e)
{
try
{
OperateResult <byte[]> result = siemensTcpNet.ReadFromCoreServer(SoftBasic.HexStringToBytes(txt_Read_Message.Text));
if (result.IsSuccess)
{
txt_Result_Message.Text = $"结果：{SoftBasic.ByteToHexString(result.Content)}";
}
}
catch (Exception)
{
throw;
}
}
private void button3_Click(object sender, EventArgs e)
{
// 发送数据
byte[] send = null;
if (checkBox1.Checked)
{
send = SoftBasic.HexStringToBytes(textBox5.Text);
}
else
{
string str = textBox5.Text.Replace("\\n", "\n").Replace("\\r", "\r");
send = Encoding.ASCII.GetBytes(str);
}
if (checkBox3.Checked)
{
// 显示发送信息
if (checkBox4.Checked)
{
textBox6.AppendText("[" + DateTime.Now.ToString("HH:mm:ss.fff") + (Program.Language == 1 ? "] [" + comboBox1.Text + "] [发] " : "] [" + comboBox1.Text + "] [S] ") +
(checkBox1.Checked ? SoftBasic.ByteToHexString(send, ' ') : Encoding.ASCII.GetString(send)) + Environment.NewLine);
}
else
{
textBox6.AppendText((Program.Language == 1 ? "[" + comboBox1.Text + "] [发] " : "[" + comboBox1.Text + "] [S] ") +
(checkBox1.Checked ? SoftBasic.ByteToHexString(send, ' ') : Encoding.ASCII.GetString(send)) + Environment.NewLine);
}
}
try
{
lock (lockObject)
{
for (int i = 0; i < sockets.Count; i++)
{
if (sockets[i].EndPoint.ToString( ) == comboBox1.Text)
{
sockets[i].Socket.Send(send, 0, send.Length, SocketFlags.None);
break;
}
}
}
}
catch (Exception ex)
{
HslCommunication.BasicFramework.SoftBasic.ShowExceptionMessage(ex);
}
}
private void btnManyRead_Click(object sender, EventArgs e)
{
try
{
OperateResult <byte[]> read = m_siemensTcpNet.Read(txtManyReadAddr.Text, ushort.Parse(txtManyReadLen.Text));
if (read.IsSuccess)
{
txtManyReadResult.Text = "结果：" + SoftBasic.ByteToHexString(read.Content);
}
else
{
txtManyReadResult.Text = "读取失败：" + read.ToMessageShowString();
}
}
catch (Exception ex)
{
MessageBox.Show("读取失败：" + ex.StackTrace);
}
}
private void LibInit()
{
try
{
ThreadState4 = true;
logNet2 = new LogNetSingle("StrDataLog.txt");
_LibnodavePLC = new LibnodavePLC();
bool isopen = _LibnodavePLC.Init("DB1.0", Txt_IP.Text);;
byte[] ReciveData = new byte[1000];
string sendmessage = "";
Task.Run(() =>
{
while (true)
{
this.Invoke(new Action(() =>
{
lock (this)
{
sendmessage = Txt_Send.Text = GetRandomString(400);
}
}
)
);
_LibnodavePLC.WriteBytes(SoftBasic.HexStringToBytes(Txt_Send.Text));
logNet2.RecordMessage(HslMessageDegree.DEBUG, "写入", sendmessage);
ReciveData = _LibnodavePLC.ReadBytes(200);
this.Invoke(new Action(() =>
{
lock (this)
Txt_Recieve.Text = SoftBasic.ByteToHexString(ReciveData);
logNet2.RecordMessage(HslMessageDegree.DEBUG, "读取", Txt_Recieve.Text);
logNet2.RecordMessage(HslMessageDegree.DEBUG, null, "是否正常" + Check(Txt_Recieve.Text, Txt_Send.Text));
}));
}
}
);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private OperateResult <byte[]> ExtractActualData(byte[] response)
{
try
{
if (response[response.Length - 1] != 0x01)
{
return(new OperateResult <byte[]>(response[response.Length - 1], "Wrong: " + SoftBasic.ByteToHexString(response, ' ')));
}
int length = response[5] * 256 + response[6];
byte[] buffer = new byte[length];
Array.Copy(response, 7, buffer, 0, length);
return(OperateResult.CreateSuccessResult(buffer));
}
catch (Exception ex)
{
return(new OperateResult <byte[]>("Wrong:" + ex.Message + " Code:" + SoftBasic.ByteToHexString(response, ' ')));
}
}
/// <summary>
/// 批量写入bool类型的数组，支持的类型为X,Y,S,T,C，具体的地址范围取决于PLC的类型
/// </summary>
/// <param name="address">PLC的地址信息</param>
/// <param name="value">数据信息</param>
/// <returns>是否写入成功</returns>
public override OperateResult Write(string address, bool[] value)
{
OperateResult <byte[]> operateResult = BuildWriteBoolCommand(station, address, value, sumCheck, watiingTime);
if (!operateResult.IsSuccess)
{
return(operateResult);
}
OperateResult <byte[]> operateResult2 = ReadFromCoreServer(operateResult.Content);
if (!operateResult2.IsSuccess)
{
return(operateResult2);
}
if (operateResult2.Content[0] != 6)
{
return(new OperateResult(operateResult2.Content[0], "Write Faild:" + SoftBasic.ByteToHexString(operateResult2.Content, ' ')));
}
return(OperateResult.CreateSuccessResult());
}
/// <summary>
/// 停止PLC
/// </summary>
/// <returns>是否停止成功</returns>
public OperateResult StopPLC()
{
OperateResult <byte[]> operateResult = BuildStop(station, sumCheck, watiingTime);
if (!operateResult.IsSuccess)
{
return(operateResult);
}
OperateResult <byte[]> operateResult2 = ReadFromCoreServer(operateResult.Content);
if (!operateResult2.IsSuccess)
{
return(operateResult2);
}
if (operateResult2.Content[0] != 6)
{
return(new OperateResult(operateResult2.Content[0], "Stop Faild:" + SoftBasic.ByteToHexString(operateResult2.Content, ' ')));
}
return(OperateResult.CreateSuccessResult());
}
/// <summary>
/// 启动PLC
/// </summary>
/// <returns>是否启动成功</returns>
public OperateResult StartPLC()
{
OperateResult <byte[]> operateResult = MelsecFxLinksOverTcp.BuildStart(station, sumCheck, watiingTime);
if (!operateResult.IsSuccess)
{
return(operateResult);
}
OperateResult <byte[]> operateResult2 = ReadBase(operateResult.Content);
if (!operateResult2.IsSuccess)
{
return(operateResult2);
}
if (operateResult2.Content[0] != 6)
{
return(new OperateResult(operateResult2.Content[0], "Start Faild:" + SoftBasic.ByteToHexString(operateResult2.Content, ' ')));
}
return(OperateResult.CreateSuccessResult());
}
public void ReadFromCoreServerExample2( )
{
#region ReadFromCoreServerExample2
ModbusTcpNet modbus = new ModbusTcpNet("192.168.0.100");
// 此处举例实现特殊的modbus功能码
OperateResult <byte[]> read = modbus.ReadFromCoreServer(SoftBasic.HexStringToBytes("0x00 0x00 0x00 0x00 0x00 0x03 0x01 0x09 0x01"));
if (read.IsSuccess)
{
// 成功，开始解析从服务器返回的数据，是一条完整的报文信息
Console.WriteLine(SoftBasic.ByteToHexString(read.Content, ' '));
}
else
{
// 失败
}
#endregion
}
public void SoftBuffer1( )
{
SoftBuffer softBuffer = new SoftBuffer(1000);
byte[] b1 = new byte[] { 0x13, 0xA6, 0x15, 0x85, 0x5B, 0x05, 0x12, 0x36, 0xF2, 0x27 };
softBuffer.SetBytes(b1, 367);
byte[] b2 = softBuffer.GetBytes(367, b1.Length);
Assert.IsTrue(SoftBasic.IsTwoBytesEquel(b1, b2), "第一次" + SoftBasic.ByteToHexString(b2));
byte[] b3 = new byte[] { 0x12, 0xC6, 0x25, 0x3C, 0x42, 0x85, 0x5B, 0x05, 0x12, 0x87 };
softBuffer.SetBytes(b3, 367 + b1.Length);
byte[] b4 = softBuffer.GetBytes(367 + b1.Length, b3.Length);
Assert.IsTrue(SoftBasic.IsTwoBytesEquel(b3, b4), "第二次");
byte[] b5 = SoftBasic.SpliceTwoByteArray(b1, b3);
byte[] b6 = softBuffer.GetBytes(367, b1.Length + b3.Length);
Assert.IsTrue(SoftBasic.IsTwoBytesEquel(b5, b6), "第三次");
}
/// <summary>
/// 检查当前的Modbus-Rtu响应是否是正确的
/// </summary>
/// <param name="send">发送的数据信息</param>
/// <returns>带是否成功的结果数据</returns>
protected virtual OperateResult <byte[]> CheckModbusTcpResponse(byte[] send)
{
// 核心交互
OperateResult <byte[]> result = ReadBase(send);
if (!result.IsSuccess)
{
return(result);
}
// 长度校验
if (result.Content.Length < 5)
{
return(new OperateResult <byte[]>(StringResources.Language.ReceiveDataLengthTooShort + "5"));
}
// 检查crc
if (!SoftCRC16.CheckCRC16(result.Content))
{
return(new OperateResult <byte[]>(StringResources.Language.ModbusCRCCheckFailed +
SoftBasic.ByteToHexString(result.Content, ' ')));
}
// 发生了错误
if ((send[1] + 0x80) == result.Content[1])
{
return(new OperateResult <byte[]>(result.Content[2], ModbusInfo.GetDescriptionByErrorCode(result.Content[2])));
}
if (send[1] != result.Content[1])
{
return(new OperateResult <byte[]>(result.Content[1], $"Receive Command Check Failed: "));
}
// 移除CRC校验
byte[] buffer = new byte[result.Content.Length - 2];
Array.Copy(result.Content, 0, buffer, 0, buffer.Length);
return(OperateResult.CreateSuccessResult(buffer));
}
/// <summary>
/// 验证欧姆龙的Fins-Udp返回的数据是否正确的数据，如果正确的话，并返回所有的数据内容
/// </summary>
/// <param name="response">来自欧姆龙返回的数据内容</param>
/// <param name="isRead">是否读取</param>
/// <returns>带有是否成功的结果对象</returns>
public static OperateResult <byte[]> UdpResponseValidAnalysis(byte[] response, bool isRead)
{
if (response.Length >= 14)
{
int err = response[12] * 256 + response[13];
// if (err > 0) return new OperateResult<byte[]>( err, StringResources.Language.OmronReceiveDataError );
if (!isRead)
{
OperateResult <byte[]> success = OperateResult.CreateSuccessResult(new byte[0]);
success.ErrorCode = err;
success.Message = GetStatusDescription(err) + " Received:" + SoftBasic.ByteToHexString(response, ' ');
return(success);
}
else
{
// 读取操作 -> read operate
byte[] content = new byte[response.Length - 14];
if (content.Length > 0)
{
Array.Copy(response, 14, content, 0, content.Length);
}
OperateResult <byte[]> success = OperateResult.CreateSuccessResult(content);
if (content.Length == 0)
{
success.IsSuccess = false;
}
success.ErrorCode = err;
success.Message = GetStatusDescription(err) + " Received:" + SoftBasic.ByteToHexString(response, ' ');
return(success);
}
}
return(new OperateResult <byte[]>(StringResources.Language.OmronReceiveDataError));
}
/// <summary>
/// Extract actual data form plc response
/// </summary>
/// <param name="response">response data</param>
/// <param name="isRead">read</param>
/// <returns>result</returns>
public static OperateResult <byte[]> ExtractActualData(byte[] response, bool isRead)
{
try
{
if (isRead)
{
if (response[0] == 0x06)
{
byte[] buffer = new byte[response.Length - 13];
Array.Copy(response, 10, buffer, 0, buffer.Length);
return(OperateResult.CreateSuccessResult(SoftBasic.AsciiBytesToBytes(buffer)));
}
else
{
byte[] buffer = new byte[response.Length - 9];
Array.Copy(response, 6, buffer, 0, buffer.Length);
return(new OperateResult <byte[]>(BitConverter.ToUInt16(SoftBasic.AsciiBytesToBytes(buffer), 0), "Data:" + SoftBasic.ByteToHexString(response)));
}
}
else
{
if (response[0] == 0x06)
{
return(OperateResult.CreateSuccessResult(new byte[0]));
}
else
{
byte[] buffer = new byte[response.Length - 9];
Array.Copy(response, 6, buffer, 0, buffer.Length);
return(new OperateResult <byte[]>(BitConverter.ToUInt16(SoftBasic.AsciiBytesToBytes(buffer), 0), "Data:" + SoftBasic.ByteToHexString(response)));
}
}
}
catch (Exception ex)
{
return(new OperateResult <byte[]>(ex.Message));
}
}
private OperateResult CheckPlcWriteResponse(byte[] ack)
{
if (ack.Length == 0)
{
return(new OperateResult(StringResources.Language.MelsecFxReceiveZore));
}
if (ack[0] == 0x15)
{
return(new OperateResult(StringResources.Language.MelsecFxAckNagative + " Actual: " + SoftBasic.ByteToHexString(ack, ' ')));
}
if (ack[0] != 0x06)
{
return(new OperateResult(StringResources.Language.MelsecFxAckWrong + ack[0] + " Actual: " + SoftBasic.ByteToHexString(ack, ' ')));
}
return(OperateResult.CreateSuccessResult( ));
}
/// <summary>
/// 从PLC反馈的数据进行提炼bool数组操作
/// </summary>
/// <param name="response">PLC反馈的真实数据</param>
/// <param name="start">起始提取的点信息</param>
/// <param name="length">bool数组的长度</param>
/// <returns>数据提炼后的真实数据</returns>
public static OperateResult <bool[]> ExtractActualBoolData(byte[] response, int start, int length)
{
OperateResult <byte[]> operateResult = ExtractActualData(response);
if (!operateResult.IsSuccess)
{
return(OperateResult.CreateFailedResult <bool[]>(operateResult));
}
try
{
bool[] array = new bool[length];
bool[] array2 = SoftBasic.ByteToBoolArray(operateResult.Content, operateResult.Content.Length * 8);
for (int i = 0; i < length; i++)
{
array[i] = array2[i + start];
}
return(OperateResult.CreateSuccessResult(array));
}
catch (Exception ex)
{
OperateResult <bool[]> operateResult2 = new OperateResult <bool[]>();
operateResult2.Message = "Extract Msg：" + ex.Message + Environment.NewLine + "Data: " + SoftBasic.ByteToHexString(response);
return(operateResult2);
}
}
/// <summary>
/// 从PLC反馈的数据进行提炼操作
/// </summary>
/// <param name="response">PLC反馈的真实数据</param>
/// <returns>数据提炼后的真实数据</returns>
public static OperateResult <byte[]> ExtractActualData(byte[] response)
{
try
{
byte[] array = new byte[(response.Length - 4) / 2];
for (int i = 0; i < array.Length; i++)
{
byte[] bytes = new byte[2]
{
response[i * 2 + 1],
response[i * 2 + 2]
};
array[i] = Convert.ToByte(Encoding.ASCII.GetString(bytes), 16);
}
return(OperateResult.CreateSuccessResult(array));
}
catch (Exception ex)
{
OperateResult <byte[]> operateResult = new OperateResult <byte[]>();
operateResult.Message = "Extract Msg：" + ex.Message + Environment.NewLine + "Data: " + SoftBasic.ByteToHexString(response);
return(operateResult);
}
}
/// <summary>
/// 检查PLC返回的读取数据是否是正常的
/// </summary>
/// <param name="ack">Plc反馈的数据信息</param>
/// <returns>检查结果</returns>
public static OperateResult CheckPlcReadResponse(byte[] ack)
{
if (ack.Length == 0)
{
return(new OperateResult(StringResources.Language.MelsecFxReceiveZore));
}
if (ack[0] == 21)
{
return(new OperateResult(StringResources.Language.MelsecFxAckNagative + " Actual: " + SoftBasic.ByteToHexString(ack, ' ')));
}
if (ack[0] != 2)
{
return(new OperateResult(StringResources.Language.MelsecFxAckWrong + ack[0] + " Actual: " + SoftBasic.ByteToHexString(ack, ' ')));
}
if (!MelsecHelper.CheckCRC(ack))
{
return(new OperateResult(StringResources.Language.MelsecFxCrcCheckFailed));
}
return(OperateResult.CreateSuccessResult());
}
/// <summary>
/// 校验读取返回数据状态
/// </summary>
/// <param name="ack"></param>
/// <returns></returns>
private OperateResult CheckPlcReadResponse(byte[] ack)
{
if (ack.Length == 0) return new OperateResult(StringResources.Language.MelsecFxReceiveZore);
if (ack[0] == 0x45) return new OperateResult(StringResources.Language.MelsecFxAckWrong + " Actual: " + SoftBasic.ByteToHexString(ack, ' '));
if ((ack[ack.Length - 1]!=0x0A) &&(ack[ack.Length -2]!=0x0D)) return new OperateResult(StringResources.Language.MelsecFxAckWrong + " Actual: " + SoftBasic.ByteToHexString(ack, ' '));
return OperateResult.CreateSuccessResult();
}
private void ReceiveCallBack(IAsyncResult ar)
{
if (ar.AsyncState is ClientSession client)
{
try
{
int length = client.Socket.EndReceive(ar);
if (length == 0)
{
Invoke(new Action(() =>
{
client.Socket.Close( );
lock (lockObject)
{
sockets.Remove(client);
comboBox1.DataSource = sockets.Select(m => m.EndPoint.ToString( )).ToArray( );
}
textBox6.AppendText("Client Offline[" + client.EndPoint.Address.ToString( ) + "]" + Environment.NewLine);
}));
return;
}
;
client.Socket.BeginReceive(buffer, 0, 2048, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client);
byte[] data = new byte[length];
Array.Copy(buffer, 0, data, 0, length);
Invoke(new Action(() =>
{
string msg = string.Empty;
if (checkBox1.Checked)
{
msg = SoftBasic.ByteToHexString(data, ' ');
}
else
{
msg = Encoding.ASCII.GetString(data);
}
if (checkBox4.Checked)
{
textBox6.AppendText($"[{DateTime.Now:HH:mm:ss.fff}] [{client.EndPoint}] [{(Program.Language == 1 ? "收" : "R")}] " + msg + Environment.NewLine);
}
else
{
textBox6.AppendText($"[{client.EndPoint}] [{(Program.Language == 1 ? "收" : "R")}] " + msg + Environment.NewLine);
}
}));
}
catch (ObjectDisposedException)
{
Invoke(new Action(() =>
{
lock (lockObject)
{
sockets.Remove(client);
comboBox1.DataSource = sockets.Select(m => m.EndPoint.ToString( )).ToArray( );
}
}));
}
catch
{
Invoke(new Action(() =>
{
lock (lockObject)
{
sockets.Remove(client);
comboBox1.DataSource = sockets.Select(m => m.EndPoint.ToString( )).ToArray( );
}
textBox6.AppendText(Program.Language == 1 ? "服务器断开连接。" : "DisConnect from remote" + Environment.NewLine);
}));
}
}
}
/// <summary>
/// 批量读取bool类型数据，支持的类型为X,Y,S,T,C，具体的地址范围取决于PLC的类型
/// </summary>
/// <param name="address">地址信息，比如X10,Y17，注意X，Y的地址是8进制的</param>
/// <param name="length">读取的长度</param>
/// <returns>读取结果信息</returns>
public override OperateResult <bool[]> ReadBool(string address, ushort length)
{
OperateResult <byte[]> operateResult = BuildReadCommand(station, address, length, isBool: true, sumCheck, watiingTime);
if (!operateResult.IsSuccess)
{
return(OperateResult.CreateFailedResult <bool[]>(operateResult));
}
OperateResult <byte[]> operateResult2 = ReadFromCoreServer(operateResult.Content);
if (!operateResult2.IsSuccess)
{
return(OperateResult.CreateFailedResult <bool[]>(operateResult2));
}
if (operateResult2.Content[0] != 2)
{
return(new OperateResult <bool[]>(operateResult2.Content[0], "Read Faild:" + SoftBasic.ByteToHexString(operateResult2.Content, ' ')));
}
byte[] array = new byte[length];
Array.Copy(operateResult2.Content, 5, array, 0, length);
return(OperateResult.CreateSuccessResult(array.Select((byte m) => m == 49).ToArray()));
}
/// <summary>
/// 批量读取PLC的数据，以字为单位，支持读取X,Y,M,S,D,T,C，具体的地址范围需要根据PLC型号来确认
/// </summary>
/// <param name="address">地址信息</param>
/// <param name="length">数据长度</param>
/// <returns>读取结果信息</returns>
public override OperateResult <byte[]> Read(string address, ushort length)
{
OperateResult <byte[]> operateResult = BuildReadCommand(station, address, length, isBool: false, sumCheck, watiingTime);
if (!operateResult.IsSuccess)
{
return(OperateResult.CreateFailedResult <byte[]>(operateResult));
}
OperateResult <byte[]> operateResult2 = ReadFromCoreServer(operateResult.Content);
if (!operateResult2.IsSuccess)
{
return(OperateResult.CreateFailedResult <byte[]>(operateResult2));
}
if (operateResult2.Content[0] != 2)
{
return(new OperateResult <byte[]>(operateResult2.Content[0], "Read Faild:" + SoftBasic.ByteToHexString(operateResult2.Content, ' ')));
}
byte[] array = new byte[length * 2];
for (int i = 0; i < array.Length / 2; i++)
{
ushort value = Convert.ToUInt16(Encoding.ASCII.GetString(operateResult2.Content, i * 4 + 5, 4), 16);
BitConverter.GetBytes(value).CopyTo(array, i * 2);
}
return(OperateResult.CreateSuccessResult(array));
}
/// <summary>
/// 接收到串口数据的时候触发
/// </summary>
/// <param name="sender">串口对象</param>
/// <param name="e">消息</param>
private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
int rCount = 0;
byte[] buffer = new byte[1024];
byte[] receive = null;
while (true)
{
System.Threading.Thread.Sleep(20); // 此处做个微小的延时，等待数据接收完成
int count = serialPort.Read(buffer, rCount, serialPort.BytesToRead);
rCount += count;
if (count == 0)
{
break;
}
receive = new byte[rCount];
Array.Copy(buffer, 0, receive, 0, count);
}
if (receive == null)
{
return;
}
if (receive.Length < 3)
{
LogNet?.WriteError(ToString( ), $"Uknown Data：" + SoftBasic.ByteToHexString(receive, ' '));
return;
}
if (Serial.SoftCRC16.CheckCRC16(receive))
{
byte[] modbusCore = SoftBasic.BytesArrayRemoveLast(receive, 2);
if (!CheckModbusMessageLegal(modbusCore))
{
// 指令长度验证错误，关闭网络连接
LogNet?.WriteError(ToString( ), $"Receive Nosense Modbus-rtu : " + SoftBasic.ByteToHexString(receive, ' '));
return;
}
// 验证站号是否一致
if (station >= 0 && station != modbusCore[0])
{
LogNet?.WriteError(ToString( ), $"Station not match Modbus-rtu : " + SoftBasic.ByteToHexString(receive, ' '));
return;
}
// LogNet?.WriteError( ToString( ), $"Success：" + BasicFramework.SoftBasic.ByteToHexString( receive, ' ' ) );
// 需要回发消息
byte[] copy = ModbusInfo.PackCommandToRtu(ReadFromModbusCore(modbusCore));
serialPort.Write(copy, 0, copy.Length);
if (IsStarted)
{
RaiseDataReceived(receive);
}
}
else
{
LogNet?.WriteWarn("CRC Check Failed : " + SoftBasic.ByteToHexString(receive, ' '));
}
}
/// <summary>
/// 发送消息给套接字，直到完成的时候返回
/// </summary>
/// <param name="socket">网络套接字</param>
/// <param name="data">字节数据</param>
/// <returns>发送是否成功的结果</returns>
protected OperateResult Send(Socket socket, byte[] data)
{
if (data == null)
{
return(OperateResult.CreateSuccessResult());
}
if (UseSynchronousNet)
{
try
{
socket.Send(data);
return(OperateResult.CreateSuccessResult());
}
catch (Exception ex)
{
socket?.Close();
LogNet?.WriteException("Send", ex);
return(new OperateResult <byte[]>(ex.Message));
}
}
OperateResult result = new OperateResult();
ManualResetEvent sendDone = null;
StateObject state = null;
try
{
sendDone = new ManualResetEvent(false);
state = new StateObject(data.Length);
}
catch (Exception ex)
{
return(new OperateResult(ex.Message));
}
try
{
state.WaitDone = sendDone;
state.WorkSocket = socket;
state.Buffer = data;
socket.BeginSend(state.Buffer, state.AlreadyDealLength, state.DataLength - state.AlreadyDealLength,
SocketFlags.None, new AsyncCallback(SendCallBack), state);// 发送数据异步返回的方法
Console.WriteLine($"发送：{SoftBasic.ByteToHexString(state.Buffer, ' ')}");
}
catch (Exception ex)
{
// 发生了错误，直接返回
LogNet?.WriteException(ToString(), ex);
result.Message = ex.Message;
socket?.Close();
sendDone.Close();
return(result);
}
// 等待发送完成
sendDone.WaitOne();
sendDone.Close();
if (state.IsError)
{
socket.Close();
result.Message = state.ErrerMsg;
return(result);
}
state.Clear();
state = null;
result.IsSuccess = true;
result.Message = StringResources.Language.SuccessText;
return(result);
}