baogq
/
HighWayAssemble
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
master
main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2a708e8c30'
${ noResults }
HighWayAssemble/Mesnac.DeviceAdapter.Fuchs/FuchsDevice.cs

1543 lines
67 KiB
C#
Raw Normal View History Unescape Escape

添加项目文件。
2 months ago
using System;
提交
1 month ago
using System.Collections.Generic;
添加项目文件。
2 months ago
using System.ComponentModel;
//using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.Threading;
namespace Mesnac.DeviceAdapter.Fuchs
{
[ClassInterface(ClassInterfaceType.None)]
public class FuchsAdapter : IDeviceAdapter
{
public log4net.ILog LogInfo = log4net.LogManager.GetLogger("RollingLogFileAppender"); //Logging 名字要在 App.config 中能找到
#region 全局变量声明
//Dictionary<byte, int> dic = new Dictionary<byte, int>();
public AntInfo[] AntList = AntListInfo.AntList;//0没有读取状态，1主动读，2被动读
private DeviceType m_iDeviceType = DeviceType.Fuchs;
ICommunicateService m_ICommunicateService = null;
public event RecvIdentifyData RecvIdentifyDataEvent = null;
public event RecvIdentifyData RecvIdentifyData_ToMES_Event = null; //MES主动读取委托
private BackgroundWorker m_WaitingDealData = new BackgroundWorker();
public UInt16 m_iDeviceId = 0;
private string m_strIp; //读写器IP或串口号
private int m_iPort; //读写器端口号或波特率
//private readonly string m_ReadTimeout = ConfigurationManager.AppSettings["ReadTimeout"]; //读取失败，重新读取延时时间
//private readonly string m_ReadCount = ConfigurationManager.AppSettings["ReadCounts"]; //读取失败，重新读取次数
//private readonly string m_ReadDbm = ConfigurationManager.AppSettings["ReadDbm"];
//private readonly string m_WriteDbm = ConfigurationManager.AppSettings["WriteDbm"];
//private readonly string m_AnalysisFlag = ConfigurationManager.AppSettings["AnalysisFlag"]; //1：按照次数最多返回条码；2：按照平均功率最大返回条码
//private readonly string m_strFilterData = ConfigurationManager.AppSettings["FilterData"]; //过滤数据
//private readonly string m_strFilterOffset = ConfigurationManager.AppSettings["FilterOffset"]; //过滤偏移，默认为0
//private readonly string m_strReadOffset = ConfigurationManager.AppSettings["ReadOffset"]; //读取偏移，默认为0
//private readonly string m_strReadLength = ConfigurationManager.AppSettings["ReadLength"]; //读取偏移，默认为8
private Mutex mut = new Mutex();
private bool m_BeginEventSuccessful = false;
private UInt16 m_IdentifyDataLen = 0;
private byte[] m_IdentifyData = new byte[19];
private Semaphore s_BeginEvent = new Semaphore(0, 100000);
private bool IsUHFAnt = false;
private Semaphore s_UHFBeginEvent = new Semaphore(0, 100000);//超高频读头
//private ManualResetEvent BeginEvent = new ManualResetEvent(false);
private Semaphore m_WaitingForData = new Semaphore(0, 100000);
public bool TagInventory_Lable = true;//连续盘点标签标志
//private BackgroundWorker m_bgwWaitingForData = new BackgroundWorker();
private Semaphore m_GlobalSem = new Semaphore(1, 1);
private byte m_ReadDataLen = 0;
private byte[] m_ReadData = null;
private bool m_bWriteSuccedTag = false;
private Semaphore m_WriteSem = new Semaphore(0, 100000);
private bool m_bSetSignleModel = false;
private Semaphore m_SetSignelModelSem = new Semaphore(0, 100000);
private bool m_ReadDataSuccessful = false;
private Semaphore m_ReadSem = new Semaphore(0, 100000);
private bool m_GetHeartSuccessful = false;
private Semaphore m_GetHeartSem = new Semaphore(0, 100000);
private Semaphore m_MulEpcSem = new Semaphore(0, 100000);
private Semaphore m_StopSem = new Semaphore(0, 100000);
private bool m_StopIdentifySuccessful = false;
private Semaphore m_OneEpcSem = new Semaphore(0, 100000);
private bool m_SetDbmSuccessful = false;
private Semaphore m_SetDbmSem = new Semaphore(0, 100000);
private int m_BarcodeGroupCount = 0;
private byte[] m_MulAllData = null;
private byte[] m_AutoReadEPC = null;
private int m_readEPCDataLen = 0;
private byte m_OneEpcDataLen = 0;
private byte[] m_OneEpcData = null;
private byte[] m_filterData = null;
private byte[] m_CompareData = null;
private bool bRereadData = false;
private byte m_OneEpcAntenna = 254;
private bool TagInventory;
#endregion
public int AutoReport
{
get { return AutoReport; }
set { AutoReport = value; }
}
public int Filter
{
get { return Filter; }
set { Filter = value; }
}
#region 设备连接部分
public bool Device_Init(CommType iCommType, string pUrl, DeviceType iDeviceType)
{
try
{
//InitAnt();
m_iDeviceType = iDeviceType;
//LogService.Instance.Info("函数调用:Device_Init Start: ");
{
if (iCommType == CommType.RJ45) //网口
{
if (m_ICommunicateService == null)
{
m_ICommunicateService = new BgTcpClient();
}
string[] split = pUrl.Split(new Char[] { ':' });
m_strIp = split[0];
string strTemp = split[1];
m_iPort = Convert.ToInt32(strTemp);
m_ICommunicateService.Init(m_strIp, m_iPort, this);
//LogInfo.Fatal("设备初始化成功，IP：" + m_strIp + "端口号:" + m_iPort);
}
else //串口,代用串口号和波特率
{
if (m_ICommunicateService == null)
{
return false;
}
string[] split = pUrl.Split(new Char[] { ':' });
m_strIp = split[0];
string strTemp = split[1];
m_iPort = Convert.ToInt32(strTemp);
m_ICommunicateService.Init(m_strIp, m_iPort, this);
//LogInfo.Fatal("设备初始化成功，串口号：" + m_strIp + "波特率:" + m_iPort);
}
}
}
catch (Exception ex)
{
LogInfo.Fatal("IP：" + m_strIp + "端口号:" + m_iPort + "连接读写器异常：" + ex.Message);
return false;
}
return true;
}
public bool Device_Init_Id(CommType iCommType, string pUrl, ushort iDeviceId)
{
m_iDeviceId = iDeviceId;
Device_Init(iCommType, pUrl, (DeviceType)1);
return true;
}
public bool Device_Connect()
{
try
{
if (m_ICommunicateService != null)
{
if (m_ICommunicateService.Connect())
{
//LogService.Instance.Info("Device_Connect:连接成功");
return true;
}
else
{
LogInfo.Fatal("IP：" + m_strIp + "端口号: " + m_iPort + ",Device_Connect:连接失败");
return false;
}
}
else
{
return false;
}
}
catch (Exception ex)
{
LogInfo.Info("Device_Connect异常：" + ex.Message);
return false;
}
}
public void Device_Destroy()
{
m_ICommunicateService.DisConnect();
}
public bool Device_GetState()
{
return m_ICommunicateService.GetState();
}
public bool Device_ReConnect()
{
try
{
if (m_ICommunicateService != null)
{
m_ICommunicateService.DisConnect();
}
}
catch { }
return Device_Connect();
}
#endregion
public bool Device_DealValidPack(byte[] ValidData)
{
//UInt16 iDataLen = 0;
//LogService.Instance.Info("----接受的数据："+ StringChange.bytesToHexStr(ValidData, 18) + ",函数调用:Device_DealValidPack 开始!");
//LogService.Instance.Info("----函数调用:Device_DealValidPack 开始!" + StringChange.bytesToHexStr(ValidData, 12));
//LogService.Instance.Info("Pepperl_Fuchs 进入Device_DealValidPack解析函数");
try
{
#region 修改解析函数
switch (ValidData[4])
{
case 0x40: //心跳
Deal_HeartData(ValidData);
break;
case 0x05: //未读到标签&&超高频读头连续识别指令返回 Received:00.06.1D.02.FF.1C.00.06.1D.02.05.1D
if (ValidData[1] == 0X06 && ValidData[2] == 0X0A)
{
//LogService.Instance.Info("----函数调用:Device_DealValidPack：NoRead!");
m_ReadDataLen = 0;
m_ReadDataSuccessful = false;
m_ReadSem.Release();
}
else if (ValidData[2] == 0X19) //高频读头发送连续识别指令返回
{
s_BeginEvent.Release();
}
else if (ValidData[2] == 0X71)//超高频读头发送连续识别指令返回
{
s_UHFBeginEvent.Release();
//LogInfo.Info("发送连续识别指令接收返回帧，释放信号量");
}
else if (ValidData[2] == 0X10)
{
m_ReadDataLen = 0;
m_ReadDataSuccessful = false;
m_ReadSem.Release();
}
//else if (ValidData[0] == 0X00 && ValidData[1] == 0X06 && ValidData[2] == 0X02 && ValidData[3] == 0X02) //停止连续识别返回
//{
// m_StopIdentifySuccessful = true;
// m_StopSem.Release();
//}
break;
case 0X04: //多标签超高频读头接收报文
if (ValidData[0] == 0X00 && ValidData[4] == 0X04)
{
byte bDataLen = 5;
m_ReadDataLen = (byte)ValidData[7];
//m_OneEpcDataLen = m_ReadDataLen;
m_OneEpcDataLen = (byte)(m_ReadDataLen - bDataLen);
m_OneEpcData = new byte[m_OneEpcDataLen];
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 10, m_OneEpcData, 0, m_OneEpcDataLen);
//LogService.Instance.Info("函数调用:Device_DealValidPack数据解析为：" + Encoding.ASCII.GetString(m_OneEpcData, 0, 9));
}
else
{
m_ReadDataLen = 0;
m_OneEpcDataLen = 0;
}
m_ReadSem.Release();
break;
case 0X02: //单标签超高频读头
if (ValidData[0] == 0X00 && ValidData[4] == 0X02)
{
//byte bDataLen = 5;
m_ReadDataLen = (byte)ValidData[1];
//m_OneEpcDataLen = m_ReadDataLen;
m_OneEpcDataLen = (byte)(9);
m_OneEpcData = new byte[m_OneEpcDataLen];
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 8, m_OneEpcData, 0, m_OneEpcDataLen);
//LogService.Instance.Info("函数调用:Device_DealValidPack数据解析为：" + Encoding.ASCII.GetString(m_OneEpcData, 0, 9));
}
else
{
m_ReadDataLen = 0;
m_OneEpcDataLen = 0;
}
m_ReadSem.Release();
break;
case 0X00: //高频及超高频读头接收报文正常有数据
if (ValidData[1] == 0X12 && ValidData[2] == 0X19)
{
Deal_MESIdentify(ValidData);
}
else if (ValidData[1] == 0X12 && ValidData[2] == 0X10)
{
Deal_ReadData(ValidData);
}
else if (ValidData[1] == 0X14 && ValidData[2] == 0X71) //超高频读头设置按时间段连续盘点后自报数据返回
{
Deal_MESIdentify(ValidData);
}
else if (ValidData[1] == 0X14 && ValidData[2] == 0X0A) //超高频读头
{
Deal_UHFReadData(ValidData);
}
else if (ValidData[1] == 0X06 && ValidData[2] == 0X04) //设置读头工作模式返回指令
{
Deal_SetAntCT(ValidData);
}
else if (ValidData[2] == 0X0D)
{
Deal_UHFWriteData(ValidData);
}
else if (ValidData[1] == 0X06 && ValidData[2] == 0X02)//停止连续识别指令
{
Deal_StopIdentify(ValidData);
}
else if (ValidData[2] == 0XBF)
{
Deal_SetSignelModel(ValidData);
}
else
{
m_ReadDataLen = 0;
m_OneEpcDataLen = 0;
}
break;
}
#endregion
}
catch (Exception ex)
{
LogInfo.Info("Device_DealValidPack异常：" + ex.Message);
return false;
}
return true;
}
private void Deal_SetSignelModel(byte[] validData)
{
m_SetSignelModelSem.Release();
}
private void Deal_UHFWriteData(byte[] ValidData)
{
m_bWriteSuccedTag = true;
m_WriteSem.Release();
}
private void Deal_SetAntCT(byte[] validData)
{
m_SetDbmSuccessful = true;
m_SetDbmSem.Release();
}
private void Deal_StopIdentify(byte[] ValidData)
{
if (ValidData[3] == 0X02)
{
LogInfo.Info("第1路传感器停止指令接收成功，释放信号量");
}
else if (ValidData[3] == 0X04)
{
LogInfo.Info("第2路传感器停止指令接收成功，释放信号量");
}
else if (ValidData[3] == 0X06)
{
LogInfo.Info("第3路传感器停止指令接收成功，释放信号量");
}
else if (ValidData[3] == 0X08)
{
LogInfo.Info("第4路传感器停止指令接收成功，释放信号量");
}
m_StopSem.Release();
}
private void Deal_UHFReadData(byte[] ValidData)
{
m_ReadDataLen = (byte)ValidData[1];
m_OneEpcDataLen = (byte)(9);
m_OneEpcData = new byte[ValidData[1] - 8];
if (ValidData[3] == 0x02)
{
m_OneEpcAntenna = 5;
}
else if (ValidData[3] == 0x04)
{
m_OneEpcAntenna = 6;
}
else if (ValidData[3] == 0x06)
{
m_OneEpcAntenna = 7;
}
else if (ValidData[3] == 0x08)
{
m_OneEpcAntenna = 8;
}
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 8, m_OneEpcData, 0, m_OneEpcData.Length);
m_ReadDataSuccessful = true;
m_ReadSem.Release();
}
private void MessageReturn(byte Antenna)
{
//LogService.Instance.Info("接收到数据，第"+Antenna+"号传感器类型readType = " + AntList[Antenna - 1].readType);
if (RecvIdentifyDataEvent != null)
{
提交
1 month ago
RecvIdentifyDataEvent(Convert.ToUInt16(m_OneEpcData.Length), null, Antenna, m_iDeviceId, m_strIp, "1");
添加项目文件。
2 months ago
}
}
private void Deal_MESIdentify(byte[] ValidData)
{
if (ValidData[2] == 0X19)
{
//m_ReadDataLen = (byte)ValidData[1];
//m_OneEpcDataLen = Convert.ToByte(Convert.ToString(m_ReadDataLen, 16));
m_OneEpcData = new byte[12];
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 6, m_OneEpcData, 0, m_OneEpcData.Length);
Array.Reverse(m_OneEpcData, 0, 4);
Array.Reverse(m_OneEpcData, 4, 4);
Array.Reverse(m_OneEpcData, 8, 4);
//if (RecvIdentifyData_ToMES_Event != null)
//{
//LogService.Instance.Info("Pepperl_Fuchs 进入Deal_MESIdentify解析函数:" + StringChange.bytesToHexStr(ValidData,18));
if (ValidData[3] == 0X32)
{
MessageReturn(1);
}
else if (ValidData[3] == 0X34)
{
MessageReturn(2);
}
else if (ValidData[3] == 0X36)
{
MessageReturn(3);
}
else if (ValidData[3] == 0X38)
{
MessageReturn(4);
}
}
else if (ValidData[2] == 0X71)
{
//add by baogq 2020年5月11日 09:15:20
//2022-03-05 11:12:21 修改托盘标签第七位是R
if (ValidData[14] == 0X52)
{
m_OneEpcData = new byte[7];
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 8, m_OneEpcData, 0, m_OneEpcData.Length);
}
else
{
m_OneEpcData = new byte[ValidData[1] - 8];
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 8, m_OneEpcData, 0, m_OneEpcData.Length);
}
//LogService.Instance.Info("接收自报数据：" + StringChange.bytesToHexStr(m_OneEpcData, m_OneEpcData.Length));
if (ValidData[3] == 0X02)
{
MessageReturn(5);
}
else if (ValidData[3] == 0X04)
{
MessageReturn(6);
}
else if (ValidData[3] == 0X06)
{
MessageReturn(7);
}
else if (ValidData[3] == 0X08)
{
MessageReturn(8);
}
}
else if (ValidData[2] == 0X10) //高频读头单次读标签
{
m_OneEpcData = new byte[12];
m_ReadDataLen = Convert.ToByte(m_OneEpcData.Length);
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 6, m_OneEpcData, 0, m_OneEpcData.Length);
Array.Reverse(m_OneEpcData, 0, 4);
Array.Reverse(m_OneEpcData, 4, 4);
Array.Reverse(m_OneEpcData, 8, 4);
m_ReadDataSuccessful = true;
m_ReadSem.Release();
}
}
private void Deal_ReadData(byte[] ValidData)//处理读取数据返回帧
{
m_ReadDataLen = (byte)ValidData[1];
//m_OneEpcDataLen = m_ReadDataLen;
m_OneEpcDataLen = Convert.ToByte(Convert.ToString(m_ReadDataLen, 16));
m_OneEpcData = new byte[m_OneEpcDataLen];
Array.Clear(m_OneEpcData, 0, m_OneEpcData.Length);
Array.Copy(ValidData, 6, m_OneEpcData, 0, m_OneEpcDataLen);
Array.Reverse(m_OneEpcData, 0, 4);
Array.Reverse(m_OneEpcData, 4, 4);
Array.Reverse(m_OneEpcData, 8, 4);
m_ReadDataSuccessful = true;
m_ReadSem.Release();
}
private void Deal_HeartData(byte[] ValidData)//处理心跳返回帧
{
try
{
if (ValidData[0] == 0X00 && ValidData[4] == 0x40)
{
m_GetHeartSuccessful = true;
}
else
{
m_GetHeartSuccessful = false;
}
}
catch (Exception ex)
{
m_GetHeartSuccessful = false;
}
m_GetHeartSem.Release();
}
public UInt16 Device_Read(G2MemBank filterMembank, UInt16 filterWordPtr, UInt16 filterWordCnt, Byte[] filterData,
G2MemBank Membank, UInt16 WordPtr, UInt16 WordCnt, ref Byte[] pReadData, byte Antenna, int ReadTimes)
{
UInt16 resuat = 0;
int i_ReadCount = 1;
while (resuat == 0 && ReadTimes > 0)
{
//LogInfo.Info("读取数据第[" + i_ReadCount + "]次");
resuat = Device_Read(filterMembank, filterWordPtr, filterWordCnt, filterData, Membank, WordPtr, WordCnt, ref pReadData, Antenna);
i_ReadCount++;
ReadTimes--;
}
return resuat;
}
public UInt16 Device_Read(G2MemBank filterMembank, UInt16 filterWordPtr, UInt16 filterWordCnt, Byte[] filterData,
G2MemBank Membank, UInt16 WordPtr, UInt16 WordCnt, ref Byte[] pReadData, byte Antenna)
{
byte iResult = 0;
string s_CompareData1 = "";
string s_CompareData2 = "";
try
{
m_GlobalSem.WaitOne(-1, false);
//LogService.Instance.Info("函数调用:Device_Read 开始:");
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[6];
Array.Clear(pMessagePack.m_pData, 0, 6);//清空为0
if (Antenna < 5)
{
pMessagePack.m_pData[0] = 0x00;
pMessagePack.m_pData[1] = 0x06;
pMessagePack.m_pData[2] = 16; //读Data区
//1、2、3、4天线为高频读头
pMessagePack.m_pData[3] = (byte)(0X30 + (Antenna * 2));
pMessagePack.m_pData[4] = 0x00;
pMessagePack.m_pData[5] = 0x00;
}
//5、6、7、8天线为超高频读头
if (Antenna == 5)
{
pMessagePack.m_pData = new byte[4];
Array.Clear(pMessagePack.m_pData, 0, 4);//清空为0
pMessagePack.m_pData[0] = 0x00;
pMessagePack.m_pData[1] = 0x04;
pMessagePack.m_pData[2] = 0x0A;
pMessagePack.m_pData[3] = 0x02;
}
else if (Antenna == 6)
{
pMessagePack.m_pData = new byte[4];
Array.Clear(pMessagePack.m_pData, 0, 4);//清空为0
pMessagePack.m_pData[0] = 0x00;
pMessagePack.m_pData[1] = 0x04;
pMessagePack.m_pData[2] = 0x0A;
pMessagePack.m_pData[3] = 0x04;
}
else if (Antenna == 7)
{
pMessagePack.m_pData = new byte[4];
Array.Clear(pMessagePack.m_pData, 0, 4);//清空为0
pMessagePack.m_pData[0] = 0x00;
pMessagePack.m_pData[1] = 0x04;
pMessagePack.m_pData[2] = 0x0A;
pMessagePack.m_pData[3] = 0x06;
}
else if (Antenna == 8)
{
pMessagePack.m_pData = new byte[4];
Array.Clear(pMessagePack.m_pData, 0, 4);//清空为0
pMessagePack.m_pData[0] = 0x00;
pMessagePack.m_pData[1] = 0x04;
pMessagePack.m_pData[2] = 0x0A;
pMessagePack.m_pData[3] = 0x08;
}
//m_filterData = new byte[filterWordCnt];
//m_CompareData = new byte[filterWordCnt];
//if (filterWordCnt > 0)
//{
// Array.Copy(filterData, 0, m_filterData, 0, filterWordCnt);
//}
//Array.Copy(m_filterData, filterWordPtr, m_CompareData, 0, filterWordCnt);
//m_ReadSem.Release(1);
m_ReadSem.WaitOne(1, false);
m_ReadDataLen = 0;
//Thread.Sleep(2000);
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_ReadSem.WaitOne(900, false)) //等待结果,并取结果返回。
{
//if (m_ReadDataLen > 0) //有数据，正常
if (m_ReadDataLen > 0 && m_OneEpcAntenna == Antenna)
{
if (m_OneEpcData[1] == 0X36 || m_OneEpcData[1] == 0X37)
{
pReadData = new byte[7];
Array.Copy(m_OneEpcData, WordPtr, pReadData, 0, pReadData.Length);
}
else
{
pReadData = new byte[WordCnt];
Array.Copy(m_OneEpcData, WordPtr, pReadData, 0, WordCnt);
}
iResult = (byte)(pReadData.Length);
m_ReadDataLen = 0;
m_OneEpcAntenna = 254;
//Array.Copy(m_OneEpcData, filterWordPtr, m_CompareData, 0, filterWordCnt);
//s_CompareData1 = StringChange.bytesToHexStr(m_filterData, m_filterData.Length);
//s_CompareData2 = StringChange.bytesToHexStr(m_CompareData, filterWordCnt);
//if (s_CompareData1 == s_CompareData2 && Membank == G2MemBank.EPC && filterMembank == G2MemBank.EPC)
//{
// pReadData = new byte[WordCnt];
// Array.Copy(m_OneEpcData, WordPtr, pReadData, 0, WordCnt);
// iResult = (byte)(pReadData.Length);
// //LogService.Instance.Info("------------------------------------------------------------------------------------------------------" + "\r\n");
// //LogService.Instance.Info("读取到标签数据为:" + Encoding.ASCII.GetString(pReadData, 0, pReadData.Length) + ",原始数据为: " + StringChange.bytesToHexStr(pReadData, pReadData.Length) + "，数据长度为: " + pReadData.Length + "\r\n");
// //LogService.Instance.Info("------------------------------------------------------------------------------------------------------");
// m_ReadDataLen = 0;
//}
//else
//{
// iResult = 0;
// m_ReadDataLen = 0;
// LogService.Instance.Info("读取标签数据失败，与过滤标签不符！");
//}
}
else
{
iResult = 0;
m_ReadDataLen = 0;
m_OneEpcAntenna = 254;
//LogInfo.Info("读取标签数据失败,返回数据长度为0");
}
}
else //超时
{
m_ReadDataLen = 0;
iResult = 0;
m_OneEpcAntenna = 254;
//LogInfo.Info("读取标签数据失败,超时未返回");
}
}
else
{
//LogInfo.Info("发送读取标签数据命令失败");
iResult = 0;
}
}
catch (Exception ex)
{
//LogInfo.Info("读取标签数据异常：" + ex.Message);
iResult = 0;
}
finally
{
m_GlobalSem.Release();
}
return iResult;
}
public byte Device_SendHeartPack()
{
byte iResult = 0;
try
{
//LogService.Instance.Info("函数调用:Device_SendHeartPack");
m_GlobalSem.WaitOne(-1, false);
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[6];
Array.Clear(pMessagePack.m_pData, 0, 6);//清空为0
//发送读取参数QV指令 00 0A BE 02 00 55 51 56 00 00 只适用于一号天线
//pMessagePack.m_pData[0] = 0x00;
//pMessagePack.m_pData[1] = 0x0A;
//pMessagePack.m_pData[2] = 0xBE;
//pMessagePack.m_pData[3] = 0x02;
//pMessagePack.m_pData[4] = 0x00;
//pMessagePack.m_pData[5] = 0x55;
//pMessagePack.m_pData[6] = 0x51;
//pMessagePack.m_pData[7] = 0x56;
//pMessagePack.m_pData[8] = 0x00;
//pMessagePack.m_pData[9] = 0x00;
//baogq add 2019年6月21日 13:38:53
//心跳指令：00 06 0A 2A 00 00
//返回：00 06 0A 2A FF 09 00 06 0A 0A 04 0A
pMessagePack.m_pData[0] = 0x00;
pMessagePack.m_pData[1] = 0x16;
pMessagePack.m_pData[2] = 10;
pMessagePack.m_pData[3] = 42;
pMessagePack.m_pData[4] = 0x00;
pMessagePack.m_pData[5] = 0x00;
m_GetHeartSem.WaitOne(1, false);
//m_GetHeartSuccessful = false;
if (m_ICommunicateService != null)
{
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_GetHeartSem.WaitOne(2000, false)) //等待结果,并取结果返回。
{
//LogService.Instance.Info("发送心跳报正常。");
iResult = 1; //通讯连接和读写器都正常
}
else //超时
{
//LogService.Instance.Info("发送心跳报文超时。");
iResult = 2; //通讯连接器正常，读写器故障
//Device_Destroy();
};
}
else
{
//通讯连接器失败或网络故障
LogInfo.Info("发送心跳报文失败，通讯故障。");
iResult = 3;
//Device_Destroy();
}
}
else
{
return 3;
}
}
catch (Exception ex)
{
LogInfo.Info("Device_SendHeartPack：" + ex.Message);
iResult = 3;
}
finally
{
m_GlobalSem.Release();
}
m_GetHeartSuccessful = false;
return iResult;
}
public Byte Device_GetOneIdentifyData(ref Byte[] pReadData, Byte Antenna, UInt16 Timedout, int ReadCounts)
{
byte iResult = 0;
UInt16 iFilterDataLength = 0;
UInt16 filterOffset = 0;
byte[] pFilterData = new byte[1];
UInt16 readOffset = 0;
UInt16 readLength = 9;
//Thread.Sleep(Timedout);
iResult = (byte)Device_Read(G2MemBank.EPC, filterOffset, iFilterDataLength, pFilterData,
G2MemBank.EPC, readOffset, readLength, ref pReadData, Antenna, ReadCounts);
//LogService.Instance.Info("过滤偏移：[" + filterOffset + "]，过滤长度：[" + iFilterDataLength + "]，过滤数据：[" + StringChange.bytesToHexStr(pFilterData, pFilterData.Length) + "],读取偏移：["+ readOffset + "],读取长度：["+ readLength + "]");
if (iResult > 0)
{
//LogService.Instance.Info("函数调用:Device_GetOneIdentifyData成功，返回标签数据为：" + Encoding.ASCII.GetString(pReadData, 0, pReadData.Length) + "原始数据为：" + StringChange.bytesToHexStr(pReadData, pReadData.Length));
return iResult;
}
else
{
//LogService.Instance.Info("函数调用:Device_GetOneIdentifyData读取失败，进入失败重读");
//iResult = (byte)Device_Read(G2MemBank.EPC, filterOffset, iFilterDataLength, pFilterData,
// G2MemBank.EPC, readOffset, readLength, ref pReadData, Antenna, ReadCounts);
iResult = 0;
}
return iResult;
}
public UInt16 Device_Write(G2MemBank filterMembank, UInt16 filterWordPtr, UInt16 filterWordCnt, Byte[] filterData,
G2MemBank Membank, UInt16 WordPtr, UInt16 WordCnt, Byte[] pWriteData, byte Antenna)
{
mut.WaitOne();
byte iResult = 0;
byte[] pReadData = null;
UInt16 iReadLen = 0;
try
{
LogInfo.Info("函数调用:Device_Write，写入内容：" + StringChange.bytesToHexStr(pWriteData, WordCnt));
for (int i = 0; i < 3; i++)
{
m_GlobalSem.WaitOne(-1, false);
Fuchs_Write(filterMembank, filterWordPtr, filterWordCnt, filterData, Membank, WordPtr, WordCnt, pWriteData, Antenna);
m_GlobalSem.Release();
LogInfo.Info("Device_Write 写入的长度: " + WordCnt);
iReadLen = Device_Read(filterMembank, filterWordPtr, filterWordCnt, filterData, Membank, WordPtr, WordCnt, ref pReadData, Antenna);
LogInfo.Info("Device_Read 读取的长度: " + iReadLen);
if (iReadLen == WordCnt)
{
if (StringChange.CompareBytes(pReadData, pWriteData, iReadLen)) //写入的跟读出的一样
{
return 1;
}
else //写入的跟读出的不一样
{
iResult = 2;
}
}
else
{
iResult = 0;
}
}
}
catch (Exception ex)
{
LogInfo.Info("Device_Write异常：" + ex.Message);
mut.ReleaseMutex();
return 0;
}
mut.ReleaseMutex();
return iResult;
}
private UInt16 Fuchs_Write(G2MemBank filterMembank, ushort filterWordPtr, ushort filterWordCnt, byte[] filterData, G2MemBank Membank, ushort WordPtr, ushort WordCnt, byte[] pWriteData, byte Antenna)
{
byte[] u16byte = new byte[2];
byte iResult = 0;
int iSendDataLen;
try
{
MessagePack pMessagePack = new MessagePack();
//00 14 0D E4 00 00 30 00 51 37 31 31 35 30 30 30 31 00 00 00 1号超高频读头写入报文示例
if (Antenna > 4) //超高频读头
{
iSendDataLen = 8 + WordCnt; //发送指令帧长度
pMessagePack.m_pData = new byte[iSendDataLen];
Array.Clear(pMessagePack.m_pData, 0, iSendDataLen);//清空为0
pMessagePack.m_pData[0] = 0X00; //
pMessagePack.m_pData[1] = 0X14; //
pMessagePack.m_pData[2] = 0X0D; //
if (Antenna == 5)
{
pMessagePack.m_pData[3] = 0XE2; //1号超高频读头
}
else if (Antenna == 6)
{
pMessagePack.m_pData[3] = 0XE4; //2号超高频读头
}
else if (Antenna == 7)
{
pMessagePack.m_pData[3] = 0XE6; //3号超高频读头
}
else if (Antenna == 8)
{
pMessagePack.m_pData[3] = 0XE6; //4号超高频读头
}
pMessagePack.m_pData[4] = 0X00; //
pMessagePack.m_pData[5] = 0X00; //
pMessagePack.m_pData[6] = 0X30; //
pMessagePack.m_pData[7] = 0X00; //
if (WordCnt > 0)
{
Array.Copy(pWriteData, 0, pMessagePack.m_pData, 8, WordCnt); //写入数据
}
pMessagePack.m_pData[17] = 0X00;
pMessagePack.m_pData[18] = 0X00;
pMessagePack.m_pData[19] = 0X00;
}
else if (Antenna < 5) //高频读头
{
//00 12 40 32 00 00 31 32 33 34 35 36 37 38 39 00 00 00
iSendDataLen = 18; //高频写标签指令帧长度
pMessagePack.m_pData = new byte[iSendDataLen];
Array.Clear(pMessagePack.m_pData, 0, iSendDataLen);//清空为0
pMessagePack.m_pData[0] = 0X00; //
pMessagePack.m_pData[1] = 0X12; //
pMessagePack.m_pData[2] = 0X40; //
pMessagePack.m_pData[3] = (byte)(0X30 + (Antenna * 2));
pMessagePack.m_pData[4] = 0X00; //
pMessagePack.m_pData[5] = 0X00; //
if (WordCnt > 0)
{
Array.Copy(pWriteData, 0, pMessagePack.m_pData, 6, WordCnt); //写入数据
}
pMessagePack.m_pData[15] = 0X00;
pMessagePack.m_pData[16] = 0X00;
pMessagePack.m_pData[17] = 0X00;
Array.Reverse(pMessagePack.m_pData, 6, 4);
Array.Reverse(pMessagePack.m_pData, 10, 4);
Array.Reverse(pMessagePack.m_pData, 14, 4);
}
//m_WriteSem.Release(1);
m_WriteSem.WaitOne(1, false);
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_WriteSem.WaitOne(2000, false)) //等待结果,并取结果返回。
{
if (m_bWriteSuccedTag == true) //有数据，正常
{
iResult = 1;
}
else
{
iResult = 0;
}
}
else //超时
{
iResult = 0;
}
}
else
{
LogInfo.Info("发送写入命令失败");
return 0;
}
}
catch (Exception ex)
{
LogInfo.Info("Fuchs_Write异常：" + ex.Message);
return 0;
}
return iResult;
}
public bool Device_SetRf(int iDbi, byte Antenna, WriteOrRead RorW) //设置CT读头模式高频or超高频
{
bool bResult = false;
try
{
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[6];
Array.Clear(pMessagePack.m_pData, 0, 6);//清空为0
if (Antenna < 5)
{
//设置高频CT 00 06 04 02 32 30
pMessagePack.m_pData[0] = 0X00;
pMessagePack.m_pData[1] = 0X06;
pMessagePack.m_pData[2] = 0X04; //设置CT
//高频天线号 1，2，3，4
pMessagePack.m_pData[3] = (byte)(Antenna * 2);
pMessagePack.m_pData[4] = 0x32;
pMessagePack.m_pData[5] = 0x30;
}
else if (Antenna > 4) // 约定5,6,7,8天线号为超高频读头
{
//设置超高频读头CT 00 06 04 04 38 30
pMessagePack.m_pData[0] = 0X00;
pMessagePack.m_pData[1] = 0X06;
pMessagePack.m_pData[2] = 0X04; //设置CT
if (Antenna == 5)
{
pMessagePack.m_pData[3] = 0X02;
}
else if (Antenna == 6)
{
pMessagePack.m_pData[3] = 0X04;
}
else if (Antenna == 7)
{
pMessagePack.m_pData[3] = 0X06;
}
else if (Antenna == 8)
{
pMessagePack.m_pData[3] = 0X08;
}
pMessagePack.m_pData[4] = 0x38;
pMessagePack.m_pData[5] = 0x30;
}
m_SetDbmSem.WaitOne(1, false);
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_SetDbmSem.WaitOne(1000, false)) //等待结果,并取结果返回。
{
LogInfo.Info("传感器设置CT成功！");
bResult = true;
}
else //超时
{
bResult = false;
LogInfo.Info("传感器设置CT失败！");
}
}
else
{
LogInfo.Info("传感器设置CT超时！");
bResult = false;
}
}
catch (Exception ex)
{
LogInfo.Info("传感器设置CT异常：" + ex.Message);
bResult = false;
}
return bResult;
}
#region 修改按时间段盘点需求
public bool Device_StopIdentify(byte Antenna) //停止指令
{
bool bResult = false;
try
{
MessagePack pMessagePack = new MessagePack();
if (Antenna < 5) //高频读头发送停止连续盘点指令
{
pMessagePack.m_pData = new byte[6];
Array.Clear(pMessagePack.m_pData, 0, 6);//清空为0
pMessagePack.m_pData[0] = 0X00;
pMessagePack.m_pData[1] = 0X06;
pMessagePack.m_pData[2] = 0X02; //读Data区
//天线号1，2，3，4
pMessagePack.m_pData[3] = (byte)(0X30 + (Antenna * 2));
pMessagePack.m_pData[4] = 0x00;
pMessagePack.m_pData[5] = 0x00;
}
else if (Antenna > 4) //超高频读头发送停止连续盘点指令
{
pMessagePack.m_pData = new byte[4];
Array.Clear(pMessagePack.m_pData, 0, 4);//清空为0
pMessagePack.m_pData[0] = 0X00;
pMessagePack.m_pData[1] = 0X04;
pMessagePack.m_pData[2] = 0X02;
if (Antenna == 5)
{
pMessagePack.m_pData[3] = 0X02;
//AntList[Antenna - 1].UHFAntenna = true;
}
else if (Antenna == 6)
{
pMessagePack.m_pData[3] = 0X04;
//AntList[Antenna - 1].UHFAntenna = true;
}
else if (Antenna == 7)
{
pMessagePack.m_pData[3] = 0X06;
//AntList[Antenna - 1].UHFAntenna = true;
}
else if (Antenna == 8)
{
pMessagePack.m_pData[3] = 0X08;
//AntList[Antenna - 1].UHFAntenna = true;
}
}
m_StopSem.WaitOne(1, false);
//AntList[Antenna - 1].m_StopResult.WaitOne(1, false);
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_StopSem.WaitOne(1000, false)) //等待结果,并取结果返回。
{
LogInfo.Info("设备编号[" + m_iDeviceId + "],第[" + Antenna + "]路传感器，发送停止连续识别命令成功！");
bResult = true;
}
else //超时
{
LogInfo.Info("设备编号[" + m_iDeviceId + "],第[" + Antenna + "]路传感器，发送停止连续识别命令超时！");
bResult = false;
}
}
else
{
LogInfo.Info("设备编号[" + m_iDeviceId + "],第[" + Antenna + "]路传感器，发送停止连续识别命令失败！");
bResult = false;
}
}
catch (Exception ex)
{
LogInfo.Info("设备编号[" + m_iDeviceId + "],第[" + Antenna + "]路传感器，发送停止连续识别命令异常：" + ex.Message);
bResult = false;
}
//finally
//{
// m_GlobalSem.Release();
//}
return bResult;
}
private void WaitTimePanDianData(byte Antenna, int timeout, bool atuoRead) //MES主动盘点等待数据返回函数
{
LogInfo.Info("第[" + Antenna + "]路传感器，测试1");
AntList[Antenna - 1].m_WaitResult.WaitOne(1, false);
LogInfo.Info("第[" + Antenna + "]路传感器，测试2");
if (AntList[Antenna - 1].m_WaitResult.WaitOne(timeout, false))
{
LogInfo.Info("收到数据，当前第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
if (atuoRead)
{
LogInfo.Info("第[" + Antenna + "]路传感器，自动读释放信号量");
}
else
{
LogInfo.Info("第[" + Antenna + "]路传感器，MES读释放信号量");
}
AntList[Antenna - 1].readType = 0;
LogInfo.Info("收到数据，重新赋值后第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
AntList[Antenna - 1].m_Waiting.Release();
}
else
{
LogInfo.Info("未收到数据，当前第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
if (atuoRead)
{
LogInfo.Info("第[" + Antenna + "]路传感器，自动读未释放信号量");
if (RecvIdentifyDataEvent != null)
{
RecvIdentifyDataEvent(0, null, Antenna, m_iDeviceId, m_strIp, "1");
}
}
else
{
LogInfo.Info("第[" + Antenna + "]路传感器，MES读未释放信号量");
if (RecvIdentifyData_ToMES_Event != null)
{
RecvIdentifyData_ToMES_Event(0, null, Antenna, m_iDeviceId, m_strIp, "1");
}
}
AntList[Antenna - 1].readType = 0;
LogInfo.Info("未收到数据，重新赋值后第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
AntList[Antenna - 1].m_Waiting.Release();
//Device_StopIdentify(Antenna);
}
}
private void Deal_Data(byte Ant)
{
AntList[Ant - 1].ReadData = null;
while (AntList[Ant - 1].IsReading)
{
if (AntList[Ant - 1].ReadData != null)
{
Array.Clear(AntList[Ant - 1].ReadData, 0, AntList[Ant - 1].ReadData.Length);
AntList[Ant - 1].ReadData = null;
AntList[Ant - 1].readType = 0;
AntList[Ant - 1].IsReading = false;
}
}
}
public bool Device_BeginIdentify(byte Antenna, int timeout, bool AutoRead, int num)
{
#region 等第一次读取信号释放，再进行下一次
//if (AntList[Antenna - 1].readType > 0)
//{
// if (AntList[Antenna - 1].IsReading)//上次触发未返回
// {
// AntList[Antenna - 1].m_Waiting.WaitOne(timeout, false);
// LogService.Instance.Info("-------------------上次读取未释放信号量");
// //已经有读取的信号了等待信号量释放,且不再进行盘点
// return false;
// }
//}
//else
//{
// if (AutoRead)
// {
// AntList[Antenna - 1].readType = 1;//自动读取
// }
// else
// {
// AntList[Antenna - 1].readType = 2;//主动读取
// }
// AntList[Antenna - 1].IsReading = true;
//}
#endregion
//LogService.Instance.Info("开始连续识别，第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
#region 接收信号排队进行读取
//if (AntList[Antenna - 1].readType > 0)
//{
// AntList[Antenna - 1].m_Waiting.WaitOne(1, false);
// //已经有读取的信号了等待信号量释放
// if (AntList[Antenna - 1].m_Waiting.WaitOne(timeout, false))
// {
// return false;
// //LogService.Instance.Info("上次读取已返回数据，再次进行读取后第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
// //AntList[Antenna - 1].readType = AutoRead ? 1 : 2;
// //LogService.Instance.Info("上次读取已返回数据，重新赋值后第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
// }
// else
// {
// LogService.Instance.Info("上次读取未返回数据，再次进行读取后第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
// //上一次执行没有返回
// AntList[Antenna - 1].readType = AutoRead ? 1 : 2;
// LogService.Instance.Info("上次读取未返回数据，重新赋值后第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
// }
//}
//else
//{
// AntList[Antenna - 1].readType = AutoRead ? 1 : 2;
// LogService.Instance.Info("赋值后第" + Antenna + "号传感器类型readType = " + AntList[Antenna - 1].readType);
//}
#endregion
//AntList[Antenna - 1].iDeviceId = iDeviceId;
//if (AntList[Antenna - 1].readType > 0 && AntList[Antenna - 1].iDeviceId == iDeviceId)
//{
// if (AntList[Antenna - 1].IsReading && iDeviceId == m_iDeviceId)
// {
// LogService.Instance.Info("》》》IsReading = true" + iDeviceId);
// return false;
// }
// else
// {
// LogService.Instance.Info("》》》IsReading = false" + iDeviceId);
// }
//}
//else
//{
// LogService.Instance.Info("》》》Antenna [" + Antenna + "]，readType: " + AntList[Antenna - 1].readType);
// AntList[Antenna - 1].readType = AutoRead ? 1 : 2;
// AntList[Antenna - 1].IsReading = true;
//}
//LogService.Instance.Info("》》》Antenna [" + Antenna + "]，readType: " + AntList[Antenna - 1].readType);
//AntList[Antenna - 1].readType = AutoRead ? 1 : 2;
//AntList[Antenna - 1].IsReading = true;
byte[] u16byte = new byte[2];
bool bResult = false;
try
{
MessagePack pMessagePack = new MessagePack();
if (Antenna < 5)
{
pMessagePack.m_pData = new byte[6];
Array.Clear(pMessagePack.m_pData, 0, 6);//清空为0
pMessagePack.m_pData[0] = 0X00;
pMessagePack.m_pData[1] = 0X06;
pMessagePack.m_pData[2] = 0X19; //读Data区
//天线号 1，2，3，4
pMessagePack.m_pData[3] = (byte)(0X30 + (Antenna * 2));
pMessagePack.m_pData[4] = 0x00;
pMessagePack.m_pData[5] = 0x00;
IsUHFAnt = false;
}
else if (Antenna > 4) // 约定5,6,7,8天线号为超高频读头
{
pMessagePack.m_pData = new byte[4];
Array.Clear(pMessagePack.m_pData, 0, 4);//清空为0
pMessagePack.m_pData[0] = 0X00;
pMessagePack.m_pData[1] = 0X04;
pMessagePack.m_pData[2] = 0X71;
if (Antenna == 5)
{
pMessagePack.m_pData[3] = 0X02;
}
else if (Antenna == 6)
{
pMessagePack.m_pData[3] = 0X04;
}
else if (Antenna == 7)
{
pMessagePack.m_pData[3] = 0X06;
}
else if (Antenna == 8)
{
pMessagePack.m_pData[3] = 0X08;
}
IsUHFAnt = true;
}
//s_UHFBeginEvent.WaitOne(1, false);
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
//Thread.Sleep(100);
//if (!Task.Factory.StartNew(() => { Deal_Data(Antenna); }).Wait(timeout))
//{
// AntList[Antenna - 1].IsReading = false;
// AntList[Antenna - 1].readType = 0;
// AntList[Antenna - 1].ReadData = null;
// DealNoData(Antenna);
// Device_StopIdentify(Antenna);
// if (!Device_StopIdentify(Antenna)) Device_StopIdentify(Antenna);
// if (!Device_StopIdentify(Antenna)) Device_StopIdentify(Antenna);
//}
//Thread m_bgwWaitingForData = new Thread(() => m_ICommunicateService.Deal_TagInfo(Antenna, timeout));
//m_bgwWaitingForData.IsBackground = true;
//m_bgwWaitingForData.Start();
//bResult = true;
//启动等待数据接受线程
//Thread m_bgwWaitingForData = new Thread(() => WaitTimePanDianData(Antenna, timeout, AutoRead));
//m_bgwWaitingForData.IsBackground = true;
//m_bgwWaitingForData.Start();
if (IsUHFAnt)//超高频读头发送连续识别
{
if (s_UHFBeginEvent.WaitOne(2000, false)) //等待结果,并取结果返回。
{
LogInfo.Info("传感器编号[" + num + "],第[" + Antenna + "]路超高频传感器，发送连续识别命令成功！");
bResult = true;
}
else //超时
{
bResult = false;
LogInfo.Info("传感器编号[" + num + "],第[" + Antenna + "]路超高频传感器，发送连续识别命令超时！");
}
}
else
{
if (s_BeginEvent.WaitOne(2000, false)) //等待结果,并取结果返回。
{
LogInfo.Info("传感器编号[" + num + "],第[" + Antenna + "]路高频传感器，发送连续识别命令成功！");
bResult = true;
}
else //超时
{
bResult = false;
LogInfo.Info("传感器编号[" + num + "],第[" + Antenna + "]路高频传感器，发送连续识别命令超时！");
}
}
}
else
{
LogInfo.Info("传感器编号[" + num + "],第[" + Antenna + "]路传感器，发送开始连续识别命令失败！");
bResult = false;
//AntList[Antenna - 1].readType = 0;
//AntList[Antenna - 1].IsReading = false;
}
}
catch (Exception ex)
{
LogInfo.Info("传感器编号[" + num + "],第[" + Antenna + "]路传感器，发送开始连续识别命令异常：" + ex.Message);
bResult = false;
//AntList[Antenna - 1].readType = 0;
//AntList[Antenna - 1].IsReading = false;
}
//finally
//{
// m_GlobalSem.Release();
//}
return bResult;
}
#endregion
#region 未实现的函数
public string Device_GetOneIdentifyData(Byte Antenna, UInt16 Timedout)
{
string strResult = "";
int iSendDataLen = 0;
try
{
iSendDataLen = 11;
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[iSendDataLen];
Array.Clear(pMessagePack.m_pData, 0, iSendDataLen);//清空为0
pMessagePack.m_pData[0] = 0x00;
pMessagePack.m_pData[1] = 0x0B;
pMessagePack.m_pData[2] = 0XBF;
pMessagePack.m_pData[3] = (byte)(Antenna * 2);
pMessagePack.m_pData[4] = 0x00;
pMessagePack.m_pData[5] = 0x55;
pMessagePack.m_pData[6] = 0x51;
pMessagePack.m_pData[7] = 0x56;
pMessagePack.m_pData[8] = 0x00;
pMessagePack.m_pData[9] = 0x01;
pMessagePack.m_pData[10] = 0x53;
m_SetSignelModelSem.WaitOne(1, false);
if (m_ICommunicateService != null)
{
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_SetSignelModelSem.WaitOne(2000, false)) //等待结果,并取结果返回。
{
//LogService.Instance.Info("单标签模式设置成功。");
strResult = "成功"; //通讯连接和读写器都正常
}
else //超时
{
//LogService.Instance.Info("发送心跳报文超时。");
strResult = "超时"; //通讯连接器正常，读写器故障
};
}
else
{
//通讯连接器失败或网络故障
//LogService.Instance.Info("发送心跳报文失败，通讯故障。");
strResult = "失败";
}
}
else
{
return strResult;
}
}
catch (Exception ex)
{
LogInfo.Info("Device_GetOneIdentifyData：" + ex.Message);
strResult = "异常";
}
return strResult;
}
public string Device_GetOneIdentifyData_Finish(byte Antenna, ushort Timedout)
{
mut.WaitOne();
return "";
}
public Byte Device_GetOneIdentifyData_Finish(ref byte[] pReadData, byte Antenna, ushort Timedout)
{
mut.WaitOne();
byte iResult = 0;
return iResult;
}
public ushort Device_GetReportData(ref byte[] pReadData, Byte Antenna, UInt32 Timedout)
{
mut.WaitOne();
byte[] pTemp = null;
byte iReadLen = 0;
if ((iReadLen = Device_GetOneIdentifyData(ref pTemp, Antenna, (UInt16)Timedout, 1)) > 0)
{
//LogInfo.Info("设备编号[" + m_iDeviceId + "],第[" + Antenna + "]路超高频传感器,获取自报数:"+ Encoding.ASCII.GetString(pTemp, 0, pTemp.Length));
//LogInfo.Info("Device_GetReportData获取自报数据" + "数据长度" + iReadLen);
pReadData = new byte[iReadLen];
Array.Copy(pTemp, 0, pReadData, 0, iReadLen);
mut.ReleaseMutex();
return (ushort)(iReadLen);
}
else
{
mut.ReleaseMutex();
return 0;
}
}
public ushort Device_GetIdentifyData(ref byte[] pReadData, byte Antenna)
{
ushort iResult = 0;
try
{
LogInfo.Info("函数调用:Device_GetIdentifyData");
lock (m_IdentifyData)
{
if ((m_IdentifyDataLen > 0 && m_IdentifyData[m_IdentifyDataLen - 1] == (Antenna + 1)) || Antenna == 255)
{
iResult = (UInt16)(m_IdentifyDataLen - 1);
pReadData = new byte[m_IdentifyDataLen - 1];
pReadData[0] = (byte)(m_IdentifyDataLen - 3);
pReadData[1] = (byte)Antenna;
Array.Copy(m_IdentifyData, 0, pReadData, 2, m_IdentifyDataLen - 3);
m_IdentifyDataLen = 0;
LogInfo.Info("Device_GetIdentifyData:" + StringChange.bytesToHexStr(pReadData, pReadData.Length));
return iResult;
}
else
{
return 0;
}
}
}
catch (Exception ex)
{
LogInfo.Info("获得识别期间数据异常：" + ex.Message);
return 0;
}
}
public void DealNoData(byte Antenna)
{
if (AntList[Antenna - 1].readType == 2)
{
if (RecvIdentifyData_ToMES_Event != null)
{
RecvIdentifyData_ToMES_Event(0, null, Antenna, m_iDeviceId, m_strIp, "1");
}
}
else
{
if (RecvIdentifyDataEvent != null)
{
RecvIdentifyDataEvent(0, null, Antenna, m_iDeviceId, m_strIp, "1");
}
}
}
提交
1 month ago
public bool Device_WriteAlarmLight(int port, UInt16 Timedout)
{
throw new NotImplementedException();
}
public List<TagInfo> Device_GetAllIdentifyData(byte Antenna, ushort Timedout, int ReadCounts)
{
throw new NotImplementedException();
}
添加项目文件。
2 months ago
//public List<TagInfo> TagInventoryTimePeriod(byte Antenna, int time)
//{
// List<TagInfo> t = new List<TagInfo> { };
// new System.Threading.Tasks.TaskFactory().StartNew(() => {
// t = LongTimeFunc();
// }).Wait(time);
// bool TagInventory_Lable = true;
// DateTime dt1 = DateTime.Now;
// Device_BeginIdentify(Antenna, time,true);
// while (TagInventory_Lable)
// {
// int dt = (int)DateTime.Now.Subtract(dt1).TotalMilliseconds;
// if (dt > time)
// {
// Device_StopIdentify(Antenna);
// if (!Device_StopIdentify(Antenna)) Device_StopIdentify(Antenna);
// if (!Device_StopIdentify(Antenna)) Device_StopIdentify(Antenna);
// TagInfo TagInfo = new TagInfo();
// TagInfo.Antana = Antenna;
// TagInfo.iDeviceId = m_iDeviceId;
// TagInfo.EPCData = null;
// tagInfoList.Add(TagInfo);
// TagInventory_Lable = false;
// }
// }
// return tagInfoList;
//}
#endregion
}
}