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.
Aucma.Scada/HighWayIot.Rfid/Impl/RFLY_I160ADAPTER.CS

1487 lines
63 KiB
C#

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

using GRreader;
using HighWayIot.Common;
using HighWayIot.Log4net;
using HighWayIot.Rfid;
using HighWayIot.Rfid.Dto;
using HighWayIot.Rfid.Impl;
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
namespace MaterialTraceability.Rfid.Impl
{
[ClassInterface(ClassInterfaceType.None)]
public class RFly_I160Adapter : IDeviceAdapter
{
private LogHelper log = LogHelper.Instance;
private StringChange stringChange = StringChange.Instance;
private JsonChange jsonChange = JsonChange.Instance;
#region 全局变量声明
List<TagInfo> m_TagInfoList = new List<TagInfo>();
CommType gConnetType = new CommType();
private DeviceType m_iDeviceType = DeviceType.RFly_I160;
private DeviceType DeviceType;
ICommunicateService m_ICommunicateService = null;
public UHFreader MyReader = new UHFreader();
public event RecvIdentifyData RecvIdentifyDataEvent = null;
public UInt16 m_iDeviceId = 0;
private string m_strIp; //读写器IP或串口号
private int m_iPort; //读写器端口号或波特率
private readonly string m_ReadDbm = "10";
private readonly string m_WriteDbm = "10";
private readonly string m_AnalysisFlag = "1"; //1按照次数最多返回条码2按照平均功率最大返回条码
private int m_ConnectFlag = 0;
//private Mutex mut = new Mutex();
private ManualResetEvent BeginEvent = new ManualResetEvent(true);
public bool TagInventory_Lable = true;//连续盘点标签标志
private Semaphore m_GlobalSem = new Semaphore(1, 1);
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_OneEpcSemSuccessful = false;
private Semaphore m_OneEpcSem = new Semaphore(0, 100000);
private bool m_ReadDataSuccessful = false;
private bool m_Device_ReadSuccessful = false;
private byte m_ReadDataLen = 0;
private byte[] m_ReadData = null;
private Semaphore m_ReadSem = new Semaphore(0, 100000);
private Semaphore m_WriteSem = 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_OneEpcAntenna = 254;
private byte[] m_OneEpcData = null;
private bool m_GetReadNoDataSuccessful;
private bool writeResult = false;
#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
{
m_iDeviceType = iDeviceType;
//LogService.Instance.Debug("函数调用:Device_Init Start: ");
//if (iDeviceType == DeviceType.Mesnac_GRUV100)
{
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);
log.RfidLog("设备初始化成功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);
log.RfidLog("设备初始化成功,串口号:" + m_strIp + "波特率:" + m_iPort);
}
}
}
catch (Exception ex)
{
log.Error("连接读写器异常:", ex);
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())
{
log.RfidLog("Device_Connect:连接成功");
return true;
}
else
{
log.RfidLog("Device_Connect:连接失败");
return false;
}
}
else
{
return false;
}
}
catch (Exception ex)
{
log.Error("Device_Connect异常", ex);
return false;
}
}
public void Device_Destroy()
{
m_ICommunicateService.DisConnect();
}
public bool Device_GetState()
{
return m_ICommunicateService.GetState();
}
public bool Device_ReConnect()
{
log.RfidLog("Device_Connect 调用重连函数!");
return Device_Connect();
}
#endregion
public bool Device_DealValidPack(byte[] ValidData)
{
byte bAntana = 0; //读写器天线号 默认0x04
UInt16 iReadCount = 0; //标签读取次数
UInt16 iRSSI = 0; //标签信号强度
byte[] bResultEPC_Data = new byte[14];
byte[] bNoData = new byte[12];
try
{
byte info = ValidData[3];
switch (info) //心跳
{
case 0X90:
m_GetHeartSuccessful = true;
Console.WriteLine("Device_DealValidPack处理函数" + stringChange.bytesToHexStr(ValidData, ValidData.Length));
try
{
log.SemaphoreLog("信号量m_GetHeartSem释放");
m_GetHeartSem.Release();
}
catch (Exception ex)
{
log.Error("心跳信号量处理异常", ex);
log.SemaphoreLog("信号量m_GetHeartSem释放异常" + ex.Message);
}
break;
case 0x02:
if (ValidData[2] == 0x00 || ValidData[2] == 0x01)
{
log.RfidLog("----函数调用:Device_DealValidPackNoRead!");
m_BarcodeGroupCount = 0;
m_GetReadNoDataSuccessful = true;
m_OneEpcDataLen = 0;
}
else
{
log.RfidLog("----函数调用:Device_DealValidPack 有数据!");
m_BarcodeGroupCount = Convert.ToInt32(ValidData[5].ToString()); //标签组数TagCount
m_MulAllData = new byte[ValidData.Length];
Array.Clear(m_MulAllData, 0, ValidData.Length);
Array.Copy(ValidData, 0, m_MulAllData, 0, ValidData.Length);
Array.Copy(m_MulAllData, 11, bResultEPC_Data, 0, 14);
m_ReadDataLen = 14;
m_OneEpcDataLen = 14;
m_OneEpcData = new byte[m_OneEpcDataLen];
bAntana = ValidData[8];
m_OneEpcAntenna = ValidData[8];
iReadCount = ValidData[6];
iRSSI = ValidData[7];
//DeviceType 改为 m_iDeviceType原代码为DeviceType,因测试一体机没有赋值改为m_iDeviceType
//四通道读写器业务逻辑
if (DeviceType == DeviceType.Mesnac_GRUR445)
{
m_TagInfoList = Device_DealTagInfoList2(m_MulAllData);
}
else
{
m_TagInfoList = Device_AutoDealContent(m_MulAllData);
}
//m_OneEpcSem.Release();
//m_ReadSem.Release();
//log.RfidLog("----有数据,释放信号量!");
}
try
{
log.SemaphoreLog("信号量m_OneEpcSem释放");
m_OneEpcSem.Release();
//log.SemaphoreLog("信号量m_GlobalSem释放");
//m_GlobalSem.Release();
}
catch (Exception e)
{
log.Error("释放信号量错误!" + e.ToString());
log.SemaphoreLog("释放信号量错误:" + e.Message);
}
break;
default:
log.RfidLog("Device_DealValidPack处理函数" + stringChange.bytesToHexStr(ValidData, ValidData.Length));
Console.WriteLine("Device_DealValidPack处理函数" + stringChange.bytesToHexStr(ValidData, ValidData.Length));
break;
}
}
catch (Exception ex)
{
log.Error("空间名:" + ex.Source + "" + '\n' +
"方法名:" + ex.TargetSite + '\n' +
"故障点:" + ex.StackTrace.Substring(ex.StackTrace.LastIndexOf("\\") + 1, ex.StackTrace.Length - ex.StackTrace.LastIndexOf("\\") - 1) + '\n' +
"错误提示:", ex);
return false;
}
return true;
}
public byte Device_SendHeartPack()
{
byte iResult = 0;
try
{
log.RfidLog("函数调用:Device_SendHeartPack");
//m_GlobalSem.WaitOne(-1, false);
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[9];
Array.Clear(pMessagePack.m_pData, 0, 1);//清空为0
//获取温度
pMessagePack.m_pData[0] = 0xAA;
pMessagePack.m_pData[1] = 0x55;
pMessagePack.m_pData[2] = 0x00;
pMessagePack.m_pData[3] = 0x90;
pMessagePack.m_pData[4] = 0x90;
pMessagePack.m_pData[5] = 0x0D;
m_GetHeartSem.WaitOne(1, false);
log.SemaphoreLog("信号量m_GetHeartSemWaitOne(1, false)");
if (m_ICommunicateService != null)
{
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
log.SemaphoreLog("信号量m_GetHeartSemWaitOne(9000, false)");
if (m_GetHeartSem.WaitOne(5000, false)) //等待结果,并取结果返回。
{
if (m_GetHeartSuccessful)
{
//log.RfidLog("发送心跳正常。");
iResult = 1; //通讯连接和读写器都正常
}
}
else //超时
{
log.SemaphoreLog("信号量m_GetHeartSem发送心跳超时");
log.RfidLog("发送心跳超时。");
iResult = 2; //通讯连接器正常,读写器故障
};
}
else
{
//通讯连接器失败或网络故障
log.RfidLog("发送心跳报文失败,通讯故障。");
iResult = 3;
}
}
else
{
//m_GetHeartSem.Release();
return 3;
}
}
catch (Exception ex)
{
log.RfidLog("Device_SendHeartPack" + ex.Message);
iResult = 3;
}
finally
{
//m_GlobalSem.Release();
//m_GetHeartSem.Release();
}
return iResult;
}
public ushort Device_GetReportData(ref byte[] pReadData, Byte Antenna, UInt32 Timedout)
{
byte[] pTemp = null;
byte iReadLen = 0;
if ((iReadLen = Device_GetOneIdentifyData(ref pTemp, Antenna, (UInt16)Timedout)) > 0)
{
// log.RfidLog("Device_GetReportData获取自报数据" + "数据长度" + iReadLen);
pReadData = new byte[iReadLen + 1];
pReadData[0] = iReadLen;
Array.Copy(pTemp, 0, pReadData, 1, iReadLen);
return (ushort)(iReadLen + 1);
}
else
{
return 0;
}
}
/// <summary>
/// 根据天线号识别单个标签EPC数据只返回读到的第一条数据
/// </summary>
/// <returns>识别的标签EPC长度0为识别失败</returns>
/// <param name="pReadData">识别到的数据缓存区</param>
/// <param name="Antenna">天线号0为本机255为所有天线</param>
/// <param name="Timedout">超时时间,单位毫秒,识别到立即返回,未识别到等待超时返回</param>
public Byte Device_GetOneIdentifyData(ref Byte[] pReadData, Byte Antenna, UInt16 Timedout)
{
byte[] u16byte = new byte[2];
byte iResult = 0;
byte[] bCRC = new byte[4];
try
{
m_GlobalSem.WaitOne(1, false);
//log.RfidLog("函数调用:Device_GetOneIdentifyData");
if (Antenna == 0) //此版本4为主机
{
Antenna = (byte)(Antenna + 1);
}
MessagePack pMessagePack = new MessagePack();
//A5 5A 00 0A 80 00 64 EE 0D 0A //100毫秒的示例
pMessagePack.m_pData = new byte[8];
pMessagePack.m_pData[0] = 0xAA;
pMessagePack.m_pData[1] = 0x55;
pMessagePack.m_pData[2] = 0x02;
pMessagePack.m_pData[3] = 0x02;
//pMessagePack.m_pData[4] = 0x03;
//pMessagePack.m_pData[5] = 0xE8;
u16byte = BitConverter.GetBytes(Timedout); //超时时间
u16byte = stringChange.Swap16Bytes(u16byte); //协议里为大端在前
//log.RfidLog("u16byte" + u16byte);
Array.Copy(u16byte, 0, pMessagePack.m_pData, 4, 2);
Array.Copy(pMessagePack.m_pData, 2, bCRC, 0, 4);
pMessagePack.m_pData[6] = stringChange.CalculateVerify(bCRC, bCRC.Length);
pMessagePack.m_pData[7] = 0x0D;
//log.RfidLog("pMessagePack.m_pData" + pMessagePack.m_pData);
//int i = m_OneEpcSem.Release(1);
m_OneEpcSem.WaitOne(1, false);
m_OneEpcDataLen = 0;
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
m_ReadDataSuccessful = true;
if (m_OneEpcSem.WaitOne(Timedout + 1000, false)) //等待结果,并取结果返回。
{
if ((m_OneEpcDataLen > 0 && m_OneEpcAntenna == Antenna)) //有数据,正常
{
pReadData = new byte[14];
Array.Copy(m_AutoReadEPC, 0, pReadData, 0, 14);
log.RfidLog("Device_GetOneIdentifyData:" + stringChange.bytesToHexStr(pReadData, pReadData.Length));
iResult = m_OneEpcDataLen;
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
m_ReadDataSuccessful = false;
}
else
{
log.RfidLog("Device_GetOneIdentifyData长度或者天线号不正确");
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
iResult = 0;
m_ReadDataSuccessful = false;
}
}
else //超时
{
iResult = 0;
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
m_ReadDataSuccessful = false;
log.RfidLog("Device_GetOneIdentifyData超时");
}
}
else
{
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
log.RfidLog("Device_GetOneIdentifyData发送识别单条EPC命令失败");
iResult = 0;
m_ReadDataSuccessful = false;
}
}
catch (Exception ex)
{
log.Error("Device_GetOneIdentifyData识别单条EPC数据异常", ex);
iResult = 0;
m_ReadDataSuccessful = false;
}
finally
{
//m_GlobalSem.Release();
}
return iResult;
}
public UInt16 Device_Read(G2MemBank filterMembank, UInt16 filterWordPtr, UInt16 filterWordCnt, Byte[] filterData,
G2MemBank Membank, UInt16 WordPtr, UInt16 WordCnt, ref Byte[] pReadData, byte Antenna)
{
byte[] u16byte = new byte[2];
byte iResult = 0;
try
{
m_GlobalSem.WaitOne(1, false);
log.RfidLog("函数调用:Device_Read");
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[8];
Array.Clear(pMessagePack.m_pData, 0, pMessagePack.m_pData.Length);//清空为0
pMessagePack.m_pData[0] = 0xAA;
pMessagePack.m_pData[1] = 0x55;
pMessagePack.m_pData[2] = 0x02;
pMessagePack.m_pData[3] = 0x02;
pMessagePack.m_pData[4] = 0x03;
pMessagePack.m_pData[5] = 0xE8;
pMessagePack.m_pData[6] = 0xEB;
pMessagePack.m_pData[7] = 0x0D;
//m_ReadSem.Release(1);
m_ReadSem.WaitOne(1, false);
m_ReadDataLen = 0;
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
m_ReadDataSuccessful = true;
if (m_ReadSem.WaitOne(2000, false)) //等待结果,并取结果返回。
{
if (m_ReadDataLen > 0) //有数据,正常
{
pReadData = new byte[m_ReadDataLen];
Array.Copy(m_OneEpcData, 0, pReadData, 0, m_ReadDataLen);
iResult = m_ReadDataLen;
log.RfidLog("Device_Read:" + stringChange.bytesToHexStr(pReadData, pReadData.Length));
m_ReadDataLen = 0;
}
else
{
m_ReadDataLen = 0;
log.RfidLog("Device_Read失败,返回长度为0");
iResult = 0;
}
}
else //超时
{
log.RfidLog("Device_Read失败,超时未返回");
iResult = 0;
}
}
else
{
log.RfidLog("发送读取命令失败");
iResult = 0;
}
}
catch (Exception ex)
{
log.Error("读取数据异常:", ex);
iResult = 0;
}
finally
{
//m_GlobalSem.Release();
}
return iResult;
}
public UInt16 Device_Write(G2MemBank filterMembank, UInt16 filterWordPtr, UInt16 filterWordCnt, Byte[] filterData,
G2MemBank Membank, UInt16 WordPtr, UInt16 WordCnt, Byte[] pWriteData, byte Antenna)
{
byte[] u16byte = new byte[2];
byte iResult = 0;
try
{
m_GlobalSem.WaitOne(1, false);
log.RfidLog("函数调用:Device_Write");
//int datalen = 36+ pWriteData.Length;
int datalen = 48;
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[datalen];
Array.Clear(pMessagePack.m_pData, 0, pMessagePack.m_pData.Length);//清空为0
pMessagePack.m_pData[0] = 0xAA;
pMessagePack.m_pData[1] = 0x55;
pMessagePack.m_pData[2] = (byte)(datalen - 6);//先占位
pMessagePack.m_pData[3] = 0x03;
pMessagePack.m_pData[4] = 0x00;
pMessagePack.m_pData[5] = 0x64;
pMessagePack.m_pData[6] = 0x00;
pMessagePack.m_pData[7] = 0x00;
pMessagePack.m_pData[8] = 0x00;
pMessagePack.m_pData[9] = 0x00;
pMessagePack.m_pData[10] = 0x01;
pMessagePack.m_pData[11] = 0x00;
pMessagePack.m_pData[12] = 0x00;
pMessagePack.m_pData[13] = 0x00;
pMessagePack.m_pData[14] = 0x20;
pMessagePack.m_pData[15] = 0x60;
Array.Copy(filterData, 0, pMessagePack.m_pData, 16, filterData.Length);
pMessagePack.m_pData[28] = 0x03;
pMessagePack.m_pData[29] = 0x00;
pMessagePack.m_pData[30] = 0x00;
pMessagePack.m_pData[31] = 0x00;
pMessagePack.m_pData[32] = 0x00;
pMessagePack.m_pData[33] = (byte)WordCnt;
Array.Copy(pWriteData, 0, pMessagePack.m_pData, 34, pWriteData.Length);
byte[] bCRC = new byte[datalen - 4];
//Array.Copy(u16byte, 0, pMessagePack.m_pData, 4, 2);
Array.Copy(pMessagePack.m_pData, 2, bCRC, 0, bCRC.Length);
pMessagePack.m_pData[datalen - 2] = stringChange.CalculateVerify(bCRC, bCRC.Length);
pMessagePack.m_pData[datalen - 1] = 0x0D;
m_WriteSem.WaitOne(1, false);
m_ReadDataLen = 0;
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
m_ReadDataSuccessful = true;
if (m_WriteSem.WaitOne(2000, false)) //等待结果,并取结果返回。
{
//log.RfidLog("Device_Write成功");
if (writeResult)
{
iResult = 1;
}
}
else //超时
{
log.RfidLog("Device_Write失败,超时未返回");
iResult = 0;
}
}
else
{
log.RfidLog("发送写入命令失败");
iResult = 0;
}
}
catch (Exception ex)
{
log.Error("写入数据异常:", ex);
iResult = 0;
}
finally
{
//m_GlobalSem.Release();
}
return iResult;
}
/// <summary>
/// 返回读写器获取的条码中最好的一条 1:按照读取次数最多返回条码2按照功率最大返回条码
/// </summary>
/// <param name="cBarcodeObjList">要处理的数据</param>
/// <param name="iFlag">1:按照读取次数最多返回条码2按照平均功率最大返回条码</param>
/// <param name="iPrintLogFlag">1:打印log0不打印Log</param>
/// <returns></returns>
public byte[] CommandAnalysisBarcode(List<TagInfo> cBarcodeObjList, int iFlag, int iPrintLogFlag)
{
byte[] tempBarcode = null;
if (iFlag == 1) //按次数最多获取
{
if (iPrintLogFlag == 1)
{
// log.RfidLog("----调用通用函数:CommandAnalysisBarcode Flag=1 按照最大次数选择条码,如果次数相同 ,按照平均功率最大的选择条码:");
}
#region 按照最大次数选择条码,如果次数相同 ,按照平均功率最大的选择条码
#region 求出最大次数
int iOrderMaxCount = cBarcodeObjList[0].Count;
for (int i = 0; i < cBarcodeObjList.Count; i++)
{
if (iPrintLogFlag == 1)
{
#region 打印所有条码 次数和平均功率
log.RfidLog("条码:[ " + stringChange.bytesToHexStr(cBarcodeObjList[i].EPC, cBarcodeObjList[i].EPC.Length) + " ] 次数:[ " + cBarcodeObjList[i].Count.ToString() + " ] 平均最大功率: [" + cBarcodeObjList[i].RSSI.ToString() + " ]");
#endregion
}
if (cBarcodeObjList[i].Count > iOrderMaxCount)
{
iOrderMaxCount = cBarcodeObjList[i].Count;
}
}
if (iPrintLogFlag == 1)
{
//LogService.Instance.Debug("按照次数优先,最大次数为:" + iOrderMaxCount.ToString());
}
#endregion
#region 求出等于最大次数的所有条码对象
List<TagInfo> cBarcodeObjListCount = new List<TagInfo>();
foreach (TagInfo itemMax in cBarcodeObjList)
{
if (itemMax.Count == iOrderMaxCount)
{
cBarcodeObjListCount.Add(itemMax);
//LogService.Instance.Debug("按照次数优先,等于最大次数条码为:" + stringChange.bytesToHexStr(itemMax.EPC, itemMax.EPC.Length));
}
}
if (iPrintLogFlag == 1)
{
//LogService.Instance.Debug("按照次数优先,等于最大次数条码数量为:" + cBarcodeObjListCount.Count.ToString());
}
#endregion
#region 求出最优条码
if (cBarcodeObjListCount.Count == 1) //如果只有一条
{
foreach (TagInfo itemCount in cBarcodeObjListCount)
{
if (itemCount.Count == iOrderMaxCount)
{
if (iPrintLogFlag == 1)
{
//log.RfidLog("---- 取出的最优条码是: " + stringChange.bytesToHexStr(itemCount.EPC, itemCount.EPC.Length));
}
tempBarcode = new byte[itemCount.EPC.Length];
Array.Copy(itemCount.EPC, 0, tempBarcode, 0, itemCount.EPC.Length);
}
}
//Add By baogq 2019年5月24日 15:29:20
//tempBarcode = new byte[cBarcodeObjListCount[0].EPC.Length];
//tempBarcode = cBarcodeObjListCount[0].EPC;
//Array.Copy(cBarcodeObjListCount[0].EPC, 0, tempBarcode, 0, cBarcodeObjListCount[0].EPC.Length);
cBarcodeObjListCount.Clear();
return tempBarcode;
}
else //如果有多条
{
#region 求出最大次数相同下条码的强度最强的条码
#region 求出最大次数相同的条码中,强度的最大值
float iOrderAvgMaxPower = cBarcodeObjListCount[0].RSSI;
for (int i = 0; i < cBarcodeObjListCount.Count; i++)
{
if (cBarcodeObjListCount[i].RSSI > iOrderAvgMaxPower)
{
iOrderAvgMaxPower = cBarcodeObjListCount[i].RSSI;
}
}
if (iPrintLogFlag == 1)
{
//LogService.Instance.Debug("按照次数优先,等于最大次数条码中平均功率最大值为:" + iOrderAvgMaxPower.ToString());
}
#endregion
foreach (TagInfo itemAvg in cBarcodeObjListCount)
{
if (itemAvg.RSSI == iOrderAvgMaxPower)
{
if (iPrintLogFlag == 1)
{
//log.RfidLog("---- 取出的最优条码是: " + stringChange.bytesToHexStr(itemAvg.EPC, itemAvg.EPC.Length));
}
tempBarcode = new byte[itemAvg.EPC.Length];
Array.Copy(itemAvg.EPC, 0, tempBarcode, 0, itemAvg.EPC.Length);
}
}
#endregion
}
#endregion
#endregion
return tempBarcode;
}
else if (iFlag == 2)//按照功率最大获取
{
if (iPrintLogFlag == 1)
{
//log.RfidLog("----调用通用函数:CommandAnalysisBarcode Flag=2 按照最大平均功率取出条码,如果最大平均功率相同,则按照次数最大取值最优条码:");
}
#region 按照最大平均功率取出条码,如果最大功率相同,则按照次数最大取值最优条码
#region 求出最大功率
int iMaxAvgPow = cBarcodeObjList[0].RSSI;
for (int i = 0; i < cBarcodeObjList.Count; i++)
{
if (iPrintLogFlag == 1)
{
#region 打印所有条码 次数和平均功率
log.RfidLog("条码:[ " + stringChange.bytesToHexStr(cBarcodeObjList[i].EPC, cBarcodeObjList[i].EPC.Length) + " ] 平均最大功率: [" + cBarcodeObjList[i].RSSI.ToString() + " ] 次数:[ " + cBarcodeObjList[i].Count.ToString() + " ] ");
#endregion
}
if (cBarcodeObjList[i].RSSI > iMaxAvgPow)
{
iMaxAvgPow = cBarcodeObjList[i].RSSI;
}
}
if (iPrintLogFlag == 1)
{
//LogService.Instance.Debug("按照平均功率最大,最大平均功率为:" + iMaxAvgPow.ToString());
}
#endregion
#region 求出等于最大功率的所有条码对象
List<TagInfo> cBarcodeObjListCount = new List<TagInfo>();
foreach (TagInfo itemMax in cBarcodeObjList)
{
if (itemMax.RSSI == iMaxAvgPow)
{
cBarcodeObjListCount.Add(itemMax);
}
}
if (iPrintLogFlag == 1)
{
//LogService.Instance.Debug("按照平均功率最大,最大平均功率相同的条码数量为:" + cBarcodeObjListCount.Count.ToString());
}
#endregion
#region 求出最优条码
//如果只有一条
if (cBarcodeObjListCount.Count == 1)
{
if (iPrintLogFlag == 1)
{
// log.RfidLog("---- 取出的最优条码是: " + stringChange.bytesToHexStr(cBarcodeObjList[0].EPC, cBarcodeObjList[0].EPC.Length));
}
tempBarcode = new byte[cBarcodeObjListCount[0].EPC.Length];
Array.Copy(cBarcodeObjListCount[0].EPC, 0, tempBarcode, 0, cBarcodeObjListCount[0].EPC.Length);
}
else //如果有多条
{
#region 求出平均功率最大相同时,条码读到次数最多的一个条码
#region 求出平均功率最大相同条码中,最大的次数
int iReadMaxCount = cBarcodeObjListCount[0].Count;
for (int i = 0; i < cBarcodeObjListCount.Count; i++)
{
if (cBarcodeObjListCount[i].Count > iReadMaxCount)
{
iReadMaxCount = cBarcodeObjListCount[i].Count;
}
}
if (iPrintLogFlag == 1)
{
//LogService.Instance.Debug("在最大平均功率相同的条码中,读取次数最多为:" + iReadMaxCount.ToString());
}
#endregion
foreach (TagInfo itemReadCount in cBarcodeObjListCount)
{
if (itemReadCount.Count == iReadMaxCount)
{
if (iPrintLogFlag == 1)
{
// log.RfidLog("---- 取出的最优条码是: " + stringChange.bytesToHexStr(itemReadCount.EPC, itemReadCount.EPC.Length));
}
tempBarcode = new byte[itemReadCount.EPC.Length];
Array.Copy(itemReadCount.EPC, 0, tempBarcode, 0, itemReadCount.EPC.Length);
}
}
#endregion
}
#endregion
#endregion
return tempBarcode;
}
else
{
return tempBarcode;
}
}
#region 处理自动上传的函数
private Mutex mutauto = new Mutex();
/// <summary>
/// 四通道读写器标签逻辑处理
/// </summary>
/// <param name="AutoDealReportData"></param>
/// <returns></returns>
public List<TagInfo> Device_DealTagInfoList(byte[] AutoDealReportData)
{
List<TagInfo> tagInfoList = new List<TagInfo>();
byte[] bResultEPC_Data = new byte[14];
m_AutoReadEPC = null;
m_readEPCDataLen = 0;
//LogService.Instance.Debug("----函数调用:Device_AutoDealContent 开始!");
try
{
mutauto.WaitOne();
int iFirstCountPos = 6; //第一次读取标签次数位置
int iFirstRSSIPos = 7; //第一次读取标签强度位置
int iFirstAnt = 8;
int iFirstPC = 9; //第一次读取标签天线位置
int iFirstLeftBarcketPos = 11;//EPC数据起始位置
UInt16 tempDataCount = 0;
int tempDataRSSI = 0;
UInt16 tempDataANT = 0;
int iBarcodeGroupCount = Convert.ToInt32(AutoDealReportData[5].ToString()); //标签组数
int iBarcodeLength = 16; //标签长度
int iCommonSecondFlag = 0;
for (int j = 0; j < iBarcodeGroupCount; j++)
{
TagInfo tag = new TagInfo();
byte[] tempDataByte = new byte[iBarcodeLength];
Array.Clear(tempDataByte, 0, iBarcodeLength);
Array.Copy(AutoDealReportData, iFirstLeftBarcketPos, tempDataByte, 0, iBarcodeLength);
byte[] tempCountByte = new byte[1]; //取出标签次数
Array.Clear(tempCountByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstCountPos, tempCountByte, 0, 1);
tempDataCount = tempCountByte[0];
byte[] tempRSSIByte = new byte[1]; //取出标签强度
Array.Clear(tempRSSIByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstRSSIPos, tempRSSIByte, 0, 1);
//tempDataRSSI = tempRSSIByte[0];
tempDataRSSI = stringChange.HexStringToNegative(stringChange.bytesToHexStr(tempRSSIByte, 1));
byte[] tempPCByte = new byte[2]; //取出PC
Array.Clear(tempPCByte, 0, 2);
Array.Copy(AutoDealReportData, iFirstPC, tempPCByte, 0, 2);
//tempPCByte = tempPCByte[0];
#region add by wenjy 20220829 取出天线号
byte[] tempAntByte = new byte[1]; //取出天线号
Array.Clear(tempAntByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstAnt, tempAntByte, 0, 1);
tempDataANT = tempAntByte[0];
#endregion
tag.Count = tempDataCount;
tag.RSSI = tempDataRSSI;
tag.EPC = tempDataByte;
tag.EPCstring = System.Text.Encoding.ASCII.GetString(tempDataByte);
//tag.EPCstring = stringChange.bytesToHexStr(tempDataByte, tempDataByte.Length);
tag.PC = tempPCByte;
tag.Antana = tempDataANT;
tagInfoList.Add(tag);
int iBarcodeListLen = tagInfoList.Count; //特别注意,必须这样,要不然会多一条数据
//int iFirstCountPos = 6; //第一次读取标签次数位置
//int iFirstRSSIPos = 7; //第一次读取标签强度位置
//int iFirstAnt = 8; //第一次读取标签天线位置
//int iFirstLeftBarcketPos = 11;//EPC数据起始位置
iFirstCountPos = iFirstCountPos + 21; //次数
iFirstRSSIPos = iFirstCountPos + 1; //强度
iFirstAnt = iFirstRSSIPos + 1; //天线
iFirstPC = iFirstAnt + 1;
iFirstLeftBarcketPos = iFirstLeftBarcketPos + 21;
log.RfidLog("----函数调用:Device_AutoDealContent 第[" + (iCommonSecondFlag + 1) + "]次数据解析为:" + tag.EPCstring + ",读取标签次数:[" + tempDataCount + "],标签信号强度:[" + tempDataRSSI + "],天线号:[" + tempDataANT + "]");
iCommonSecondFlag++;
if (iCommonSecondFlag == iBarcodeGroupCount)
{
mutauto.ReleaseMutex();
log.RfidLog("《《《返回标签数据!");
return tagInfoList;
}
}
}
catch (Exception ex)
{
log.RfidLog("----函数调用:Device_AutoDealContent 自动处理函数异常:" + ex.ToString());
mutauto.ReleaseMutex();
}
return tagInfoList;
}
public List<TagInfo> Device_DealTagInfoList2(byte[] AutoDealReportData)
{
List<TagInfo> tagInfoList = new List<TagInfo>();
byte[] bResultEPC_Data = new byte[14];
m_AutoReadEPC = null;
m_readEPCDataLen = 0;
try
{
mutauto.WaitOne();
int iFirstCountPos = 6; //第一次读取标签次数位置
int iFirstRSSIPos = 7; //第一次读取标签强度位置
int iFirstAnt = 8;
int iFirstPC = 9; //第一次读取标签天线位置
int iFirstLeftBarcketPos = 11;//EPC数据起始位置
UInt16 tempDataCount = 0;
int tempDataRSSI = 0;
UInt16 tempDataANT = 0;
int iBarcodeGroupCount = Convert.ToInt32(AutoDealReportData[5].ToString()); //标签组数
int iBarcodeLength = 16; //标签长度
int iCommonSecondFlag = 0;
for (int j = 0; j < iBarcodeGroupCount; j++)
{
TagInfo tag = new TagInfo();
byte[] tempPCByte = new byte[2]; //取出PC
Array.Clear(tempPCByte, 0, 2);
Array.Copy(AutoDealReportData, iFirstPC, tempPCByte, 0, 2);
int pc = Convert.ToInt32(tempPCByte[0].ToString("X"));
int epcLength = EPCLengthByPC(pc);
iBarcodeLength = epcLength;
byte[] tempDataByte = new byte[epcLength];
Array.Clear(tempDataByte, 0, iBarcodeLength);
Array.Copy(AutoDealReportData, iFirstLeftBarcketPos, tempDataByte, 0, iBarcodeLength);
byte[] tempCountByte = new byte[1]; //取出标签次数
Array.Clear(tempCountByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstCountPos, tempCountByte, 0, 1);
tempDataCount = tempCountByte[0];
byte[] tempRSSIByte = new byte[1]; //取出标签强度
Array.Clear(tempRSSIByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstRSSIPos, tempRSSIByte, 0, 1);
tempDataRSSI = stringChange.HexStringToNegative(stringChange.bytesToHexStr(tempRSSIByte, 1));
#region add by wenjy 20220829 取出天线号
byte[] tempAntByte = new byte[1]; //取出天线号
Array.Clear(tempAntByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstAnt, tempAntByte, 0, 1);
tempDataANT = tempAntByte[0];
#endregion
tag.Count = tempDataCount;
tag.RSSI = tempDataRSSI;
tag.EPC = tempDataByte;
if (pc == 24)
{
tag.EPCstring = stringChange.bytesToHexStr(tempDataByte, tempDataByte.Length).Substring(0, 7);
}
else
{
tag.EPCstring = System.Text.Encoding.ASCII.GetString(tempDataByte);
}
tag.PC = tempPCByte;
tag.Antana = tempDataANT;
tagInfoList.Add(tag);
int iBarcodeListLen = tagInfoList.Count; //特别注意,必须这样,要不然会多一条数据
iFirstCountPos = iFirstCountPos + iBarcodeLength + 5; //次数
iFirstRSSIPos = iFirstCountPos + 1; //强度
iFirstAnt = iFirstRSSIPos + 1; //天线
iFirstPC = iFirstAnt + 1;
iFirstLeftBarcketPos = iFirstLeftBarcketPos + iBarcodeLength + 5;
log.RfidLog("----函数调用:Device_DealTagInfoList2 第[" + (iCommonSecondFlag + 1) + "]次数据解析为:" + tag.EPCstring + ",读取标签次数:[" + tempDataCount + "],标签信号强度:[" + tempDataRSSI + "],天线号:[" + tempDataANT + "]");
iCommonSecondFlag++;
if (iCommonSecondFlag == iBarcodeGroupCount)
{
mutauto.ReleaseMutex();
log.RfidLog("《《《返回标签数据!");
return tagInfoList;
}
}
}
catch (Exception ex)
{
log.RfidLog("----函数调用:Device_AutoDealContent 自动处理函数异常:" + ex.ToString());
mutauto.ReleaseMutex();
}
return tagInfoList;
}
private int EPCLengthByPC(int pcValue)
{
int epcLength = 0;
if (pcValue >= 10 && pcValue < 20)
{
epcLength = 4;
}
else if (pcValue >= 20 && pcValue < 30)
{
epcLength = 8;
}
else if (pcValue >= 30 && pcValue < 40)
{
epcLength = 12;
}
else if (pcValue >= 40 && pcValue < 50)
{
epcLength = 16;
}
else if (pcValue >= 50 && pcValue < 60)
{
epcLength = 20;
}
else if (pcValue >= 60 && pcValue < 70)
{
epcLength = 24;
}
else if (pcValue >= 70 && pcValue < 80)
{
epcLength = 28;
}
else if (pcValue >= 80 && pcValue < 90)
{
epcLength = 30;
}
return epcLength;
}
/// <summary>
/// 一体机读写器标签逻辑处理
/// </summary>
/// <param name="AutoDealReportData"></param>
/// <returns></returns>
public List<TagInfo> Device_AutoDealContent(byte[] AutoDealReportData)
{
List<TagInfo> tagInfoList = new List<TagInfo>();
byte[] bResultEPC_Data = new byte[12];
m_AutoReadEPC = null;
m_readEPCDataLen = 0;
try
{
mutauto.WaitOne();
int iFirstCountPos = 6; //第一次读取标签次数位置
int iFirstRSSIPos = 7; //第一次读取标签强度位置
int iFirstAnt = 8; //第一次读取标签天线位置
int iFirstLeftBarcketPos = 11;//EPC数据起始位置
UInt16 tempDataCount = 0;
UInt16 tempDataRSSI = 0;
UInt16 tempDataANT = 0;
int iBarcodeGroupCount = Convert.ToInt32(AutoDealReportData[5].ToString()); //标签组数
int iBarcodeLength = 16; //标签长度
for (int j = 0; j < iBarcodeGroupCount; j++)
{
TagInfo tag = new TagInfo();
byte[] tempDataByte = new byte[iBarcodeLength];
Array.Clear(tempDataByte, 0, iBarcodeLength);
Array.Copy(AutoDealReportData, iFirstLeftBarcketPos, tempDataByte, 0, iBarcodeLength);
byte[] tempCountByte = new byte[1]; //取出标签次数
Array.Clear(tempCountByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstCountPos, tempCountByte, 0, 1);
tempDataCount = tempCountByte[0];
byte[] tempRSSIByte = new byte[1]; //取出标签强度
Array.Clear(tempRSSIByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstRSSIPos, tempRSSIByte, 0, 1);
tempDataRSSI = tempRSSIByte[0];
byte[] tempAntByte = new byte[1]; //取出天线号
Array.Clear(tempAntByte, 0, 1);
Array.Copy(AutoDealReportData, iFirstAnt, tempAntByte, 0, 1);
tempDataANT = tempAntByte[0];
tag.Count = tempDataCount;
tag.RSSI = tempDataRSSI;
tag.EPC = tempDataByte;
tag.EPCstring = System.Text.Encoding.ASCII.GetString(tempDataByte); ;
tag.Antana = tempDataANT;
tagInfoList.Add(tag);
int iBarcodeListLen = tagInfoList.Count; //特别注意,必须这样,要不然会多一条数据
iFirstCountPos = iFirstCountPos + 21;
iFirstRSSIPos = iFirstCountPos + 1;
iFirstAnt = iFirstRSSIPos + 1;
iFirstLeftBarcketPos = iFirstLeftBarcketPos + 21;
}
}
catch (Exception ex)
{
log.RfidLog("----函数调用:Device_AutoDealContent 自动处理函数异常:" + ex.ToString());
mutauto.ReleaseMutex();
}
return tagInfoList;
}
#endregion
#region 该函数不实现了
public bool Device_SetRf(int iDbi, byte Antenna, WriteOrRead RorW)
{
bool bResult = false;
try
{
bool Set_OK;
if (RorW == WriteOrRead.Read)
{
Set_OK = MyReader.SetPower(iDbi, Convert.ToSingle(m_WriteDbm));
if (Set_OK) //设置功率工程
{
log.RfidLog("设置天线读功率成功!");
bResult = true;
}
else
{
log.Error("设置天线读功率失败;");
bResult = false;
}
}
else
{
Set_OK = MyReader.SetPower(Convert.ToSingle(m_ReadDbm), iDbi);
if (Set_OK) //设置功率工程
{
log.RfidLog("设置天线写功率成功!");
bResult = true;
}
else
{
log.Error("设置天线写功率失败;");
bResult = false;
}
}
}
catch (Exception ex)
{
log.Error("Device_SetRf异常", ex);
bResult = false;
}
return bResult;
}
public string Device_GetOneIdentifyData(Byte Antenna, UInt16 Timedout)
{
byte[] u16byte = new byte[2];
byte[] bCRC = new byte[4];
string strResult = "";
try
{
m_GlobalSem.WaitOne(1, false);
//log.RfidLog("函数调用:Device_GetOneIdentifyData");
if (Antenna == 0) //此版本1为主机
{
Antenna = (byte)(Antenna + 1);
}
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[8];
pMessagePack.m_pData[0] = 0xAA;
pMessagePack.m_pData[1] = 0x55;
pMessagePack.m_pData[2] = 0x02;//change by yinzf
pMessagePack.m_pData[3] = 0x02;
//pMessagePack.m_pData[4] = 0x00;
//pMessagePack.m_pData[5] = 0x64;
//pMessagePack.m_pData[6] = 0x67;
u16byte = BitConverter.GetBytes(Timedout); //超时时间
u16byte = stringChange.Swap16Bytes(u16byte); //协议里为大端在前
//log.RfidLog("u16byte" + u16byte);
Array.Copy(u16byte, 0, pMessagePack.m_pData, 4, 2);
Array.Copy(pMessagePack.m_pData, 2, bCRC, 0, 4);
pMessagePack.m_pData[6] = stringChange.CalculateVerify(bCRC, bCRC.Length);
pMessagePack.m_pData[7] = 0x0D;
//m_OneEpcSem.Release(1);
m_OneEpcSem.WaitOne(1, false);
m_OneEpcDataLen = 0;
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_OneEpcSem.WaitOne(Timedout + 500, false)) //等待结果,并取结果返回。
{
if (m_OneEpcDataLen >= 1) //有数据,正常
{
strResult = Encoding.ASCII.GetString(m_OneEpcData);
//Encoding.ASCII.GetBytes(strResult);
//pReadData = new byte[m_OneEpcDataLen];
//Array.Copy(m_OneEpcData, 0, pReadData, 0, m_OneEpcDataLen);
log.RfidLog("Device_GetOneIdentifyData:" + stringChange.bytesToHexStr(m_OneEpcData, m_OneEpcDataLen));
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
}
else
{
strResult = stringChange.bytesToHexStr(m_OneEpcData, m_OneEpcDataLen);
log.RfidLog("Device_GetOneIdentifyData:" + stringChange.bytesToHexStr(m_OneEpcData, m_OneEpcDataLen));
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
strResult = "";
}
}
else //超时
{
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
log.RfidLog("Device_GetOneIdentifyData超时未返回");
strResult = "";
}
}
else
{
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
log.RfidLog("Device_GetOneIdentifyData发送识别单条EPC命令超时");
strResult = "";
}
}
catch (Exception ex)
{
log.Error("Device_GetOneIdentifyData识别单条EPC数据异常", ex);
strResult = "";
}
finally
{
//m_GlobalSem.Release();
}
return strResult;
}
public string Device_GetOneIdentifyData_Finish(byte Antenna, ushort Timedout)
{
return "";
}
public Byte Device_GetOneIdentifyData_Finish(ref byte[] pReadData, byte Antenna, ushort Timedout)
{
return 0;
}
public bool Device_BeginIdentify()
{
byte[] u16byte = new byte[2];
bool bResult = false;
try
{
log.RfidLog("函数调用:Device_BeginIdentify");
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[1];
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (BeginEvent.WaitOne(200, false)) //等待结果,并取结果返回。
{
bResult = true;
}
else //超时
{
bResult = false;
}
}
else
{
log.RfidLog("发送开始连续识别命令失败:");
bResult = false;
}
}
catch (Exception ex)
{
log.Error("发送开始连续识别命令异常", ex);
bResult = false;
}
return bResult;
}
public bool Device_StopIdentify()
{
bool bResult = false;
try
{
log.RfidLog("函数调用:Device_StopIdentify");
MessagePack pMessagePack = new MessagePack();
pMessagePack.m_pData = new byte[1];
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
if (m_StopSem.WaitOne(200, false)) //等待结果,并取结果返回。
{
bResult = true;
}
else //超时
{
bResult = false;
}
}
else
{
log.RfidLog("发送停止连续识别命令失败:");
bResult = false;
}
}
catch (Exception ex)
{
log.Error("发送停止连续识别命令异常:", ex);
bResult = false;
}
return bResult;
}
public ushort Device_GetIdentifyData(ref byte[] pReadData, byte Antenna)
{
return 0;
}
public List<TagInfo> Device_GetTagInfoList(DeviceType devicetype, int waitTime)
{
log.Info("进入Device_GetTagInfoList函数参数deviceType" + jsonChange.ModeToJson(devicetype) + "waitTime" + waitTime);
byte[] u16byte = new byte[2];
byte iResult = 0;
byte[] bCRC = new byte[4];
try
{
//log.SemaphoreLog("信号量m_GlobalSemWaitOne(1, false)");
//m_GlobalSem.WaitOne(1, false);
MessagePack pMessagePack = new MessagePack();
//A5 5A 00 0A 80 00 64 EE 0D 0A //100毫秒的示例
pMessagePack.m_pData = new byte[8];
pMessagePack.m_pData[0] = 0xAA;
pMessagePack.m_pData[1] = 0x55;
pMessagePack.m_pData[2] = 0x02;
pMessagePack.m_pData[3] = 0x02;
//pMessagePack.m_pData[4] = 0x03;
//pMessagePack.m_pData[5] = 0xE8;
if (waitTime == 0)
{
waitTime = 1000;
}
u16byte = BitConverter.GetBytes(waitTime); //超时时间
u16byte = stringChange.Swap16Bytes(u16byte); //协议里为大端在前
//log.RfidLog("u16byte" + u16byte);
Array.Copy(u16byte, 0, pMessagePack.m_pData, 4, 2);
Array.Copy(pMessagePack.m_pData, 2, bCRC, 0, 4);
pMessagePack.m_pData[6] = stringChange.CalculateVerify(bCRC, bCRC.Length);
pMessagePack.m_pData[7] = 0x0D;
//m_OneEpcSem.WaitOne(1, false);
GetAllRelese(m_OneEpcSem);
log.SemaphoreLog("信号量m_OneEpcSemWaitOne(1, false)");
m_OneEpcDataLen = 0;
DeviceType = devicetype;
if (m_ICommunicateService.SendMessage(pMessagePack)) //发送报文成功
{
m_ReadDataSuccessful = true;
log.SemaphoreLog("信号量m_OneEpcSemWaitOne(" + waitTime + ", false)");
if (m_OneEpcSem.WaitOne(waitTime + 2000, false)) //等待结果,并取结果返回。
{
if (m_OneEpcDataLen > 0) //有数据,正常
{
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
m_ReadDataSuccessful = false;
log.Info("成功返回数据!");
return m_TagInfoList;
}
else
{
log.Info("Device_GetTagInfoLista长度或者天线号不正确");
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
iResult = 0;
m_TagInfoList.Clear();
m_ReadDataSuccessful = false;
}
}
else //超时
{
iResult = 0;
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
m_ReadDataSuccessful = false;
m_TagInfoList.Clear();
log.Info("Device_GetTagInfoList超时");
log.SemaphoreLog("信号量m_OneEpcSem返回Device_GetTagInfoList超时");
}
}
else
{
m_OneEpcDataLen = 0;
m_OneEpcAntenna = 254;
log.Info("Device_GetTagInfoList发送识别单条EPC命令失败");
iResult = 0;
m_TagInfoList.Clear();
m_ReadDataSuccessful = false;
}
}
catch (Exception ex)
{
log.Info("Device_GetTagInfoList识别单条EPC数据异常" + ex.Message);
log.Error("Device_GetTagInfoList识别单条EPC数据异常", ex);
iResult = 0;
m_TagInfoList.Clear();
m_ReadDataSuccessful = false;
}
finally
{
// m_GlobalSem.Release();
}
return m_TagInfoList;
}
#endregion
private void GetAllRelese(Semaphore sph)
{
bool res = sph.WaitOne(1, false);
if (res)
{
log.RfidLog("信号量手动释放");
GetAllRelese(sph);
}
}
}
}