public new static MSG_SET_READER_CONFIG FromString(string str)
{
string val;
XmlDocument xdoc = new XmlDocument();
xdoc.LoadXml(str);
XmlNode node = (XmlNode)xdoc.DocumentElement;
MSG_SET_READER_CONFIG msg = new MSG_SET_READER_CONFIG();
try { msg.MSG_ID = Convert.ToUInt32(XmlUtil.GetNodeAttrValue(node, "MessageID")); }
catch { }
val = XmlUtil.GetNodeValue(node, "ResetToFactoryDefault");
msg.ResetToFactoryDefault = Convert.ToBoolean(val);
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "ReaderEventNotificationSpec");
if (null != xnl)
{
if (xnl.Count != 0)
msg.ReaderEventNotificationSpec = PARAM_ReaderEventNotificationSpec.FromXmlNode(xnl[0]);
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "AntennaProperties");
if (null != xnl)
{
if (xnl.Count != 0)
{
msg.AntennaProperties = new PARAM_AntennaProperties[xnl.Count];
for (int i = 0; i < xnl.Count; i++)
msg.AntennaProperties[i] = PARAM_AntennaProperties.FromXmlNode(xnl[i]);
}
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "AntennaConfiguration");
if (null != xnl)
{
if (xnl.Count != 0)
{
msg.AntennaConfiguration = new PARAM_AntennaConfiguration[xnl.Count];
for (int i = 0; i < xnl.Count; i++)
msg.AntennaConfiguration[i] = PARAM_AntennaConfiguration.FromXmlNode(xnl[i]);
}
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "ROReportSpec");
if (null != xnl)
{
if (xnl.Count != 0)
msg.ROReportSpec = PARAM_ROReportSpec.FromXmlNode(xnl[0]);
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "AccessReportSpec");
if (null != xnl)
{
if (xnl.Count != 0)
msg.AccessReportSpec = PARAM_AccessReportSpec.FromXmlNode(xnl[0]);
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "KeepaliveSpec");
if (null != xnl)
{
if (xnl.Count != 0)
msg.KeepaliveSpec = PARAM_KeepaliveSpec.FromXmlNode(xnl[0]);
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "GPOWriteData");
if (null != xnl)
{
if (xnl.Count != 0)
{
msg.GPOWriteData = new PARAM_GPOWriteData[xnl.Count];
for (int i = 0; i < xnl.Count; i++)
msg.GPOWriteData[i] = PARAM_GPOWriteData.FromXmlNode(xnl[i]);
}
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "GPIPortCurrentState");
if (null != xnl)
{
if (xnl.Count != 0)
{
msg.GPIPortCurrentState = new PARAM_GPIPortCurrentState[xnl.Count];
for (int i = 0; i < xnl.Count; i++)
msg.GPIPortCurrentState[i] = PARAM_GPIPortCurrentState.FromXmlNode(xnl[i]);
}
}
}
catch { }
try
{
XmlNodeList xnl = XmlUtil.GetXmlNodes(node, "EventsAndReports");
if (null != xnl)
{
if (xnl.Count != 0)
msg.EventsAndReports = PARAM_EventsAndReports.FromXmlNode(xnl[0]);
}
}
catch { }
try
{
ArrayList xnl = XmlUtil.GetXmlNodeCustomChildren(node);
if (null != xnl)
{
if (xnl.Count != 0)
{
for (int i = 0; i < xnl.Count; i++)
{
ICustom_Parameter custom = CustomParamDecodeFactory.DecodeXmlNodeToCustomParameter((XmlNode)xnl[i]);
if (custom != null) msg.AddCustomParameter(custom);
}
}
}
}
catch { }
return msg;
}
public MSG_SET_READER_CONFIG_RESPONSE SET_READER_CONFIG(MSG_SET_READER_CONFIG msg, out MSG_ERROR_MESSAGE msg_err, int time_out)
{
msg_err = null;
//Add your code here
_event_SET_READER_CONFIG_RESPONSE = new ClientManualResetEvent(false);
_event_SET_READER_CONFIG_RESPONSE.msg_id = msg.MSG_ID;
_event_ERROR_MESSAGE = new ClientManualResetEvent(false);
WaitHandle[] waitHandles = new WaitHandle[] { _event_SET_READER_CONFIG_RESPONSE.evt, _event_ERROR_MESSAGE.evt };
bool[] bit_array = msg.ToBitArray();
byte[] data = Util.ConvertBitArrayToByteArray(bit_array);
cI.Send(data);
int wait_result = WaitHandle.WaitAny(waitHandles, time_out, false);
int cursor = 0;
int length;
BitArray bArr;
try
{
switch (wait_result)
{
case 0:
bArr = Util.ConvertByteArrayToBitArray(_event_SET_READER_CONFIG_RESPONSE.data);
length = bArr.Count;
MSG_SET_READER_CONFIG_RESPONSE msg_rsp = MSG_SET_READER_CONFIG_RESPONSE.FromBitArray(ref bArr, ref cursor, length);
if (msg_rsp.MSG_ID != msg.MSG_ID) return null;
else
return msg_rsp;
case 1:
bArr = Util.ConvertByteArrayToBitArray(_event_ERROR_MESSAGE.data);
length = bArr.Count;
msg_err = MSG_ERROR_MESSAGE.FromBitArray(ref bArr, ref cursor, length);
return null;
default:
return null;
}
}
catch
{
return null;
}
}
public new static MSG_SET_READER_CONFIG FromBitArray(ref BitArray bit_array, ref int cursor, int length)
{
if (cursor > length) return null;
int field_len = 0;
object obj_val;
ArrayList param_list = new ArrayList();
MSG_SET_READER_CONFIG obj = new MSG_SET_READER_CONFIG();
int msg_type = 0;
cursor += 6;
msg_type = (int)(UInt64)Util.CalculateVal(ref bit_array, ref cursor, 10);
if (msg_type != obj.msgType)
{
cursor -= 16;
return null;
}
obj.msgLen = (UInt32)(UInt64)Util.CalculateVal(ref bit_array, ref cursor, 32);
obj.msgID = (UInt32)(UInt64)Util.CalculateVal(ref bit_array, ref cursor, 32);
if (cursor > length) throw new Exception("Input data is not complete message");
field_len = 1;
Util.ConvertBitArrayToObj(ref bit_array, ref cursor, out obj_val, typeof(bool), field_len);
obj.ResetToFactoryDefault = (bool)obj_val;
cursor += param_reserved_len;
obj.ReaderEventNotificationSpec = PARAM_ReaderEventNotificationSpec.FromBitArray(ref bit_array, ref cursor, length);
param_list = new ArrayList();
PARAM_AntennaProperties _param_AntennaProperties = PARAM_AntennaProperties.FromBitArray(ref bit_array, ref cursor, length);
if (_param_AntennaProperties != null)
{
param_list.Add(_param_AntennaProperties);
while ((_param_AntennaProperties = PARAM_AntennaProperties.FromBitArray(ref bit_array, ref cursor, length)) != null) param_list.Add(_param_AntennaProperties);
if (param_list.Count > 0)
{
obj.AntennaProperties = new PARAM_AntennaProperties[param_list.Count];
for (int i = 0; i < param_list.Count; i++)
obj.AntennaProperties[i] = (PARAM_AntennaProperties)param_list[i];
}
}
param_list = new ArrayList();
PARAM_AntennaConfiguration _param_AntennaConfiguration = PARAM_AntennaConfiguration.FromBitArray(ref bit_array, ref cursor, length);
if (_param_AntennaConfiguration != null)
{
param_list.Add(_param_AntennaConfiguration);
while ((_param_AntennaConfiguration = PARAM_AntennaConfiguration.FromBitArray(ref bit_array, ref cursor, length)) != null) param_list.Add(_param_AntennaConfiguration);
if (param_list.Count > 0)
{
obj.AntennaConfiguration = new PARAM_AntennaConfiguration[param_list.Count];
for (int i = 0; i < param_list.Count; i++)
obj.AntennaConfiguration[i] = (PARAM_AntennaConfiguration)param_list[i];
}
}
obj.ROReportSpec = PARAM_ROReportSpec.FromBitArray(ref bit_array, ref cursor, length);
obj.AccessReportSpec = PARAM_AccessReportSpec.FromBitArray(ref bit_array, ref cursor, length);
obj.KeepaliveSpec = PARAM_KeepaliveSpec.FromBitArray(ref bit_array, ref cursor, length);
param_list = new ArrayList();
PARAM_GPOWriteData _param_GPOWriteData = PARAM_GPOWriteData.FromBitArray(ref bit_array, ref cursor, length);
if (_param_GPOWriteData != null)
{
param_list.Add(_param_GPOWriteData);
while ((_param_GPOWriteData = PARAM_GPOWriteData.FromBitArray(ref bit_array, ref cursor, length)) != null) param_list.Add(_param_GPOWriteData);
if (param_list.Count > 0)
{
obj.GPOWriteData = new PARAM_GPOWriteData[param_list.Count];
for (int i = 0; i < param_list.Count; i++)
obj.GPOWriteData[i] = (PARAM_GPOWriteData)param_list[i];
}
}
param_list = new ArrayList();
PARAM_GPIPortCurrentState _param_GPIPortCurrentState = PARAM_GPIPortCurrentState.FromBitArray(ref bit_array, ref cursor, length);
if (_param_GPIPortCurrentState != null)
{
param_list.Add(_param_GPIPortCurrentState);
while ((_param_GPIPortCurrentState = PARAM_GPIPortCurrentState.FromBitArray(ref bit_array, ref cursor, length)) != null) param_list.Add(_param_GPIPortCurrentState);
if (param_list.Count > 0)
{
obj.GPIPortCurrentState = new PARAM_GPIPortCurrentState[param_list.Count];
for (int i = 0; i < param_list.Count; i++)
obj.GPIPortCurrentState[i] = (PARAM_GPIPortCurrentState)param_list[i];
}
}
obj.EventsAndReports = PARAM_EventsAndReports.FromBitArray(ref bit_array, ref cursor, length);
ICustom_Parameter custom = CustomParamDecodeFactory.DecodeCustomParameter(ref bit_array, ref cursor, length);
if (custom != null)
{
obj.Custom.Add(custom);
while ((custom = CustomParamDecodeFactory.DecodeCustomParameter(ref bit_array, ref cursor, length)) != null) obj.Custom.Add(custom);
}
return obj;
}
// Sets the client's configuration
public void Set_Reader_Config(ReaderManager.ReaderConfig readerconfig)
{
// find number of antennas to set
byte numAntennaToSet = 0;
ushort antennaSet = 0;
for (int i = 0; i < readerconfig.antennaID.Length; i++)
if (readerconfig.antennaID[i])
{
antennaSet = (ushort)i;
numAntennaToSet++;
}
MSG_SET_READER_CONFIG msg = new MSG_SET_READER_CONFIG();
msg.AccessReportSpec = new PARAM_AccessReportSpec();
msg.AccessReportSpec.AccessReportTrigger = ENUM_AccessReportTriggerType.End_Of_AccessSpec;
PARAM_C1G2InventoryCommand cmd = new PARAM_C1G2InventoryCommand();
cmd.C1G2RFControl = new PARAM_C1G2RFControl();
//cmd.C1G2RFControl.ModeIndex = 1000;
cmd.C1G2RFControl.ModeIndex = readerconfig.modeIndex;
cmd.C1G2RFControl.Tari = 0;
cmd.C1G2SingulationControl = new PARAM_C1G2SingulationControl();
cmd.C1G2SingulationControl.Session = new TwoBits(0);
cmd.C1G2SingulationControl.TagPopulation = readerconfig.tagPopulation;
cmd.C1G2SingulationControl.TagTransitTime = readerconfig.tagTransitTime;
cmd.TagInventoryStateAware = false;
msg.AntennaConfiguration = new PARAM_AntennaConfiguration[numAntennaToSet];
for (ushort i = 1; i < numAntennaToSet + 1; i++)
{
msg.AntennaConfiguration[i - 1] = new PARAM_AntennaConfiguration();
msg.AntennaConfiguration[i - 1].AirProtocolInventoryCommandSettings = new UNION_AirProtocolInventoryCommandSettings();
msg.AntennaConfiguration[i - 1].AirProtocolInventoryCommandSettings.Add(cmd);
msg.AntennaConfiguration[i - 1].AntennaID = antennaSet;
msg.AntennaConfiguration[i - 1].RFReceiver = new PARAM_RFReceiver();
msg.AntennaConfiguration[i - 1].RFReceiver.ReceiverSensitivity = readerconfig.readerSensitivity;
msg.AntennaConfiguration[i - 1].RFTransmitter = new PARAM_RFTransmitter();
msg.AntennaConfiguration[i - 1].RFTransmitter.ChannelIndex = readerconfig.channelIndex;
msg.AntennaConfiguration[i - 1].RFTransmitter.HopTableID = readerconfig.hopTableIndex;
msg.AntennaConfiguration[i - 1].RFTransmitter.TransmitPower = (ushort)(61 - (readerconfig.attenuation * 4));
}
//msg.AntennaProperties = new PARAM_AntennaProperties[1];
//msg.AntennaProperties[0] = new PARAM_AntennaProperties();
//msg.AntennaProperties[0].AntennaConnected = true;
//msg.AntennaProperties[0].AntennaGain = 0;
//msg.AntennaProperties[0].AntennaID = 1;
msg.EventsAndReports = new PARAM_EventsAndReports();
msg.EventsAndReports.HoldEventsAndReportsUponReconnect = false;
msg.KeepaliveSpec = new PARAM_KeepaliveSpec();
msg.KeepaliveSpec.KeepaliveTriggerType = ENUM_KeepaliveTriggerType.Null;
msg.KeepaliveSpec.PeriodicTriggerValue = readerconfig.periodicTriggerValue;
msg.ReaderEventNotificationSpec = new PARAM_ReaderEventNotificationSpec();
msg.ReaderEventNotificationSpec.EventNotificationState = new PARAM_EventNotificationState[5];
msg.ReaderEventNotificationSpec.EventNotificationState[0] = new PARAM_EventNotificationState();
msg.ReaderEventNotificationSpec.EventNotificationState[0].EventType = ENUM_NotificationEventType.AISpec_Event;
msg.ReaderEventNotificationSpec.EventNotificationState[0].NotificationState = false;
msg.ReaderEventNotificationSpec.EventNotificationState[1] = new PARAM_EventNotificationState();
msg.ReaderEventNotificationSpec.EventNotificationState[1].EventType = ENUM_NotificationEventType.Antenna_Event;
msg.ReaderEventNotificationSpec.EventNotificationState[1].NotificationState = true;
msg.ReaderEventNotificationSpec.EventNotificationState[2] = new PARAM_EventNotificationState();
msg.ReaderEventNotificationSpec.EventNotificationState[2].EventType = ENUM_NotificationEventType.GPI_Event;
msg.ReaderEventNotificationSpec.EventNotificationState[2].NotificationState = false;
msg.ReaderEventNotificationSpec.EventNotificationState[3] = new PARAM_EventNotificationState();
msg.ReaderEventNotificationSpec.EventNotificationState[3].EventType = ENUM_NotificationEventType.Reader_Exception_Event;
msg.ReaderEventNotificationSpec.EventNotificationState[3].NotificationState = true;
msg.ReaderEventNotificationSpec.EventNotificationState[4] = new PARAM_EventNotificationState();
msg.ReaderEventNotificationSpec.EventNotificationState[4].EventType = ENUM_NotificationEventType.RFSurvey_Event;
msg.ReaderEventNotificationSpec.EventNotificationState[4].NotificationState = true;
msg.ROReportSpec = new PARAM_ROReportSpec();
msg.ROReportSpec.N = 1;
msg.ROReportSpec.ROReportTrigger = ENUM_ROReportTriggerType.Upon_N_Tags_Or_End_Of_AISpec;
msg.ROReportSpec.TagReportContentSelector = new PARAM_TagReportContentSelector();
msg.ROReportSpec.TagReportContentSelector.AirProtocolEPCMemorySelector = new UNION_AirProtocolEPCMemorySelector();
PARAM_C1G2EPCMemorySelector c1g2mem = new PARAM_C1G2EPCMemorySelector();
c1g2mem.EnableCRC = false;
c1g2mem.EnablePCBits = false;
msg.ROReportSpec.TagReportContentSelector.AirProtocolEPCMemorySelector.Add(c1g2mem);
msg.ROReportSpec.TagReportContentSelector.EnableAccessSpecID = false;
msg.ROReportSpec.TagReportContentSelector.EnableAntennaID = true;
msg.ROReportSpec.TagReportContentSelector.EnableChannelIndex = false;
msg.ROReportSpec.TagReportContentSelector.EnableFirstSeenTimestamp = true;
msg.ROReportSpec.TagReportContentSelector.EnableInventoryParameterSpecID = false;
msg.ROReportSpec.TagReportContentSelector.EnableLastSeenTimestamp = false;
msg.ROReportSpec.TagReportContentSelector.EnablePeakRSSI = true;
msg.ROReportSpec.TagReportContentSelector.EnableROSpecID = false;
msg.ROReportSpec.TagReportContentSelector.EnableSpecIndex = false;
msg.ROReportSpec.TagReportContentSelector.EnableTagSeenCount = true;
msg.ResetToFactoryDefault = false;
MSG_SET_READER_CONFIG_RESPONSE rsp = client.SET_READER_CONFIG(msg, out msg_err, 3000);
if (rsp != null)
{
//textBox2.Text = rsp.ToString() + "\n";
WriteMessage(rsp.ToString(), "setReaderConfig");
}
else if (msg_err != null)
{
WriteMessage("setReaderConfig " + rsp.ToString() + "\n");
}
else
WriteMessage("setReaderConfig Commmand time out!" + "\n");
}
