static void Main(string[] args)
{
// Program setup
if (1 > args.Length)
{
Usage();
}
int[] antennaList = null;
for (int nextarg = 1; nextarg < args.Length; nextarg++)
{
string arg = args[nextarg];
if (arg.Equals("--ant"))
{
if (null != antennaList)
{
Console.WriteLine("Duplicate argument: --ant specified more than once");
Usage();
}
antennaList = ParseAntennaList(args, nextarg);
nextarg++;
}
else
{
Console.WriteLine("Argument {0}:\"{1}\" is not recognized", nextarg, arg);
Usage();
}
}
try
{
// Create Reader object, connecting to physical device.
// Wrap reader in a "using" block to get automatic
// reader shutdown (using IDisposable interface).
using (Reader r = Reader.Create(args[0]))
{
//Uncomment this line to add default transport listener.
//r.Transport += r.SimpleTransportListener;
r.Connect();
if (Reader.Region.UNSPEC == (Reader.Region)r.ParamGet("/reader/region/id"))
{
Reader.Region[] supportedRegions = (Reader.Region[])r.ParamGet("/reader/region/supportedRegions");
if (supportedRegions.Length < 1)
{
throw new FAULT_INVALID_REGION_Exception();
}
r.ParamSet("/reader/region/id", supportedRegions[0]);
}
string model = r.ParamGet("/reader/version/model").ToString();
if ((model.Equals("M6e Micro") || model.Equals("M6e Nano") || model.Equals("Sargas")) && antennaList == null)
{
Console.WriteLine("Module doesn't has antenna detection support please provide antenna list");
Usage();
}
// Create a simplereadplan which uses the antenna list created above
SimpleReadPlan plan = new SimpleReadPlan(antennaList, TagProtocol.GEN2);
// Set the created readplan
r.ParamSet("/reader/read/plan", plan);
Console.WriteLine("case 1: read by using the default bap parameter values");
Console.WriteLine("Get Bap default parameters");
Gen2.BAPParameters bap = (Gen2.BAPParameters)r.ParamGet("/reader/gen2/bap");
Console.WriteLine("powerupdelay : {0} freqHopOfftimeUs {1}: ", bap.POWERUPDELAY, bap.FREQUENCYHOPOFFTIME);
// Read tags
TagReadData[] tagReads = r.Read(500);
// Print tag reads
foreach (TagReadData tr in tagReads)
{
Console.WriteLine(tr.ToString());
}
Console.WriteLine("case 2: read by setting the bap parameters");
bap.FREQUENCYHOPOFFTIME = 30000;
bap.POWERUPDELAY = 10000;
r.ParamSet("/reader/gen2/bap", bap);
Console.WriteLine("Get Bap parameters");
bap = (Gen2.BAPParameters)r.ParamGet("/reader/gen2/bap");
Console.WriteLine("powerupdelay : {0} freqHopOfftimeUs {1}: ", bap.POWERUPDELAY, bap.FREQUENCYHOPOFFTIME);
// Read tags
tagReads = r.Read(500);
// Print tag reads
foreach (TagReadData tr in tagReads)
{
Console.WriteLine(tr.ToString());
}
Console.WriteLine("case 3: read by disbling the bap option");
//initialize the with -1
//set the parameters to the module
r.ParamSet("/reader/gen2/bap", null);
Console.WriteLine("Get Bap parameters");
bap = (Gen2.BAPParameters)r.ParamGet("/reader/gen2/bap");
Console.WriteLine("powerupdelay : {0} freqHopOfftimeUs {1}: ", bap.POWERUPDELAY, bap.FREQUENCYHOPOFFTIME);
// Read tags
tagReads = r.Read(500);
// Print tag reads
foreach (TagReadData tr in tagReads)
{
Console.WriteLine(tr.ToString());
}
}
}
catch (ReaderException re)
{
Console.WriteLine("Error: " + re.Message);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
public void defaultSettings()
{
String x;
String y;
String z;
int[] antennaList = null;
TagFilter filter0;
filter0 = new TagData("AA");
Reader r = Reader.Create("tmr:///com25");
r.Connect();
TagOp op = new Gen2.ReadData(Gen2.Bank.USER, 0x104, 3);
SimpleReadPlan plan = new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter0, op, true, 150);
r.ParamSet("/reader/gen2/blf", Gen2.LinkFrequency.LINK640KHZ);
// r.ParamSet("/reader/gen2/target", Gen2.Target.AB);
// MultiReadPlan testMultiReadPlan = new MultiReadPlan(readPlans);
// r.ParamSet("/reader/read/plan", testMultiReadPlan);
//r.ParamSet("/reader/read/asyncOnTime", 25000);
//r.ParamSet("/reader/read/asyncOffTime", 200);
r.ParamSet("/reader/region/id", Reader.Region.EU3);
Gen2.BAPParameters bap = (Gen2.BAPParameters)r.ParamGet("/reader/gen2/bap");
bap.FREQUENCYHOPOFFTIME = 20;
bap.POWERUPDELAY = 3;
r.ParamSet("/reader/gen2/bap", bap);
// r.ParamSet("/reader/baudRate", 921600);
r.ParamSet("/reader/read/plan", plan);
r.TagRead += delegate(Object sender, TagReadDataEventArgs e)
{
//Debug.Print("I am here");
String userMem = ByteFormat.ToHex(e.TagReadData.Data).ToString(); // convert the input into a hex string
// Debug.Print(userMem);
String abc = e.TagReadData.EpcString;
Debug.Print(abc);
userMem.Trim();
int length = 4;
int substringposition = 2;
if (abc == "AAA2")
{
while (substringposition < 3) // split the string into small chunks per value and convert to INT
{
Debug.Print("I am in this loop");
x = userMem.Substring(substringposition, length);
xInt = Convert.ToInt32(x, 16);
substringposition = substringposition + length;
bufferX = xInt.ToString();
Debug.Print(bufferX);
y = userMem.Substring(substringposition, length);
yInt = Convert.ToInt32(y, 16);
substringposition = substringposition + length;
bufferY = yInt.ToString();
z = userMem.Substring(substringposition, length);
zInt = Convert.ToInt32(z, 16);
substringposition = substringposition + length;
bufferZ = zInt.ToString();
//updateText(xInt, yInt, zInt);
Debug.Print(x + " " + y + " " + z);
// updateProgressBars(xInt, yInt, zInt);
}
}
Action action = delegate()
{
updateText();
updateProgressBars();
};
Dispatcher.BeginInvoke(DispatcherPriority.Normal, action);
};
r.StartReading();
// Console.WriteLine("\r\n<Do other work here>\r\n");
// Thread.Sleep(50000000);
// r.Dispose();
}
public void Go(string comPort, int duration, string checkBitEnable, int rangeFromReader, int angleFromReader)
{
Thread.Sleep(1000);
Console.Clear();
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("*************** Jack Mode ENGAGED ****************");
Thread.Sleep(1000);
Console.Write("Establishing connection");
for (int i = 0; i < 30; i++)
{
Console.Write(".");
i++;
Thread.Sleep(100);
}
Console.WriteLine(".");
EM4325Tag tag = new EM4325Tag
{
Range = rangeFromReader,
Angle = angleFromReader,
Check = checkBitEnable,
FullRead = false
};
int[] antennaList = null;
double maxTick = 0;
double minTick = 100;
double tBuff = 0;
float goodFrame = 0;
float badFrame = 0;
float frameRecieved = 0;
TagFilter filter0;
var csv = new StringBuilder();
csv.Capacity = 1000000; // Need a nice large sized CSV file.
int testDuration = duration;
DateTime now = DateTime.Now;
filter0 = new TagData(tag.defaultEPCHeader);
Reader r = Reader.Create(comPort);
try
{
r.Connect();
Console.WriteLine("Connection Successful");
//csv.AppendLine("Time" + "," + "X" + "," + "Y" + "," + "Z");
TagOp op = new Gen2.ReadData(Gen2.Bank.USER, tag.UserMemoryLocation, 3);
if (checkBitEnable == "Y")
{
op = new Gen2.ReadData(Gen2.Bank.USER, tag.UserMemoryLocation, 4);
}
if (tag.FullRead)
{
op = new Gen2.ReadData(Gen2.Bank.USER, tag.UserMemoryLocation, 6);
}
SimpleReadPlan plan = new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter0, op, true, 150);
Gen2.BAPParameters bap = (Gen2.BAPParameters)r.ParamGet("/reader/gen2/bap");
bap.FREQUENCYHOPOFFTIME = 20;
bap.POWERUPDELAY = 3;
// r.ParamSet("/reader/gen2/Q", new Gen2.StaticQ(2));
r.ParamSet("/reader/gen2/blf", Gen2.LinkFrequency.LINK640KHZ); // this is required to get the desired speed.
r.ParamSet("/reader/read/asyncOnTime", testDuration);
r.ParamSet("/reader/read/asyncOffTime", 5);
r.ParamSet("/reader/read/plan", plan);
int checkInt1 = 0;
int buffcheck = 0;
double tBuffstart = 0;
// Create and add tag listeners
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
r.TagRead += delegate(Object sender, TagReadDataEventArgs e)
{
TimeSpan tsB = stopWatch.Elapsed;
tBuffstart = tsB.TotalMilliseconds;
double tempV = tBuffstart - tBuff;
tag.RSSI = e.TagReadData.Rssi.ToString();
tag.UserMemory = ByteFormat.ToHex(e.TagReadData.Data).ToString(); // convert the input into a hex string
tag.EPC = e.TagReadData.EpcString;
tag.UserMemory.Trim();
int length = 4;
int substringposition = 2; // need to offset two, due to return hex eg 0x2000
if (tag.EPC == tag.defaultEPCHeader)
{
//SimpleReadPlan planA = new SimpleReadPlan(antennaList, TagProtocol.GEN2, filter1, op, true, 50);
while (substringposition < 3) // split the string into small chunks per value and convert to INT
{
tag.mem1 = tag.UserMemory.Substring(substringposition, length);
tag.mem1Int = Convert.ToInt32(tag.mem1, 16);
substringposition = substringposition + length;
tag.XString = tag.XInteger.ToString();
tag.X = tag.UserMemory.Substring(substringposition, length);
tag.YInteger = Convert.ToInt32(tag.Y, 16);
substringposition = substringposition + length;
tag.YString = tag.YInteger.ToString();
tag.Y = tag.UserMemory.Substring(substringposition, length);
tag.ZInteger = Convert.ToInt32(tag.Z, 16);
substringposition = substringposition + length;
tag.ZString = tag.ZInteger.ToString();
if (checkBitEnable == "Y")
{
tag.Check = tag.UserMemory.Substring(substringposition, length);
checkInt1 = Convert.ToInt32(tag.Check, 16);
substringposition = substringposition + length;
buffcheck = tag.XInteger + tag.YInteger + tag.ZInteger;
}
}
}
if (checkInt1 != buffcheck && checkBitEnable == "Y") // Essentially looking to see if the total sum is correct, if not report a bad frame.
{
badFrame++;
frameRecieved++;
}
if (checkInt1 == buffcheck || checkBitEnable == "N")
{
goodFrame++;
tsB = stopWatch.Elapsed;
tBuff = tsB.TotalMilliseconds;
if (tempV > 0.0002)
{
if (tempV > maxTick)
{
maxTick = tempV;
}
if (tempV < minTick)
{
minTick = tempV;
}
}
frameRecieved++;
}
};
Console.WriteLine("");
r.StartReading();
Thread.Sleep(testDuration);
// File.WriteAllText("C:\\dmp\\testingCrap.csv", csv.ToString());
float ratio = (badFrame / frameRecieved) * 100;
float ptime = testDuration / frameRecieved;
float accelHZ = (goodFrame / testDuration) * 1000;
Console.WriteLine("------------------------------------------");
Console.WriteLine("Summary of stats");
Console.WriteLine("Test conducted " + now.TimeOfDay);
Console.WriteLine("EPC : " + tag.EPC);
Console.WriteLine("------------------------------------------");
Console.WriteLine("Test Ran for : " + testDuration + " ms ");
Console.WriteLine("Number of Packets recieved : " + frameRecieved);
Console.WriteLine("CORRUPT Packets : " + badFrame);
Console.WriteLine("GOOD Packets : " + goodFrame);
Console.WriteLine("Effective Packet loss = " + ratio + " %");
Console.WriteLine("Estimated Packet time : " + ptime + " ms");
Console.WriteLine("Min Packet time : " + minTick + " ms");
Console.WriteLine("Max Packet time : " + maxTick + " ms");
Console.WriteLine("Effective Accel Update rate = " + accelHZ + " Hz");
Console.WriteLine("Reader Range " + tag.Range);
Console.WriteLine("Reader Angle " + tag.Angle);
csv.AppendLine("------------------------------------------");
csv.AppendLine("Summary of stats");
csv.AppendLine("Test conducted " + now.TimeOfDay);
csv.AppendLine("EPC : " + tag.EPC);
csv.AppendLine("------------------------------------------");
csv.AppendLine("Test Ran for : " + testDuration + " ms ");
csv.AppendLine("Number of Packets recieved : " + frameRecieved);
csv.AppendLine("CORRUPT Packets : " + badFrame);
csv.AppendLine("GOOD Packets : " + goodFrame);
csv.AppendLine("Effective Packet loss = " + ratio + " %");
csv.AppendLine("Estimated Packet time : " + ptime + " ms");
csv.AppendLine("Min Packet time : " + minTick + " ms");
csv.AppendLine("Max Packet time : " + maxTick + " ms");
csv.AppendLine("Effective Accel Update rate = " + accelHZ + " Hz");
csv.AppendLine("Reader Range " + tag.Range);
csv.AppendLine("Reader Angle " + tag.Angle);
r.Dispose();
Console.WriteLine("");
Console.WriteLine("");
string filename = DateTime.Now.ToString("yyyy-MM-d--HH-mm-ss--Angle--" + angleFromReader);
string dateNow = @"C:\temp\" + filename + ".csv"; // The program will log data to a file with a correct Timestamp.
try
{
File.WriteAllText(dateNow, csv.ToString());
}
catch (ArgumentException e)
{
// Console.WriteLine("Can't write file.");
Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
}
Console.WriteLine("Preparing for next run");
for (int i = 0; i < 30; i++)
{
Console.Write(".");
i++;
Thread.Sleep(100);
}
Console.WriteLine(".");
stopWatch.Stop();
Thread.Sleep(2500);
Console.Clear();
Console.WriteLine("");
}
catch
{
Console.WriteLine("Connection Failed.");
Console.WriteLine("Please retry (press any key or crtl-c to exit)");
if (Console.ReadKey() != null)
{
}
}
}
/// <summary>
/// Parse string representing a parameter value.
/// </summary>
/// <param name="name">Name of parameter</param>
/// <param name="valstr">String to be parsed into a parameter value</param>
private Object ParseValue(string name, string valstr)
{
Object value = ParseValue(valstr);
switch (name.ToLower())
{
case "/reader/antenna/portswitchgpos":
case "/reader/region/hoptable":
value = ((ArrayList)value).ToArray(typeof(int));
break;
case "/reader/gpio/inputlist":
case "/reader/read/trigger/gpi":
case "/reader/probebaudrates":
value = ((ArrayList)value).ToArray(typeof(int));
break;
case "/reader/gpio/outputlist":
value = ((ArrayList)value).ToArray(typeof(int));
break;
case "/reader/antenna/settlingtimelist":
case "/reader/antenna/txrxmap":
case "/reader/radio/portreadpowerlist":
case "/reader/radio/portwritepowerlist":
value = ArrayListToInt2Array((ArrayList)value);
break;
case "/reader/region/lbt/enable":
case "/reader/antenna/checkport":
case "/reader/tagreaddata/recordhighestrssi":
case "/reader/tagreaddata/uniquebyantenna":
case "/reader/tagreaddata/uniquebydata":
case "/reader/tagreaddata/reportrssiindbm":
case "/reader/radio/enablepowersave":
case "/reader/status/antennaenable":
case "/reader/status/frequencyenable":
case "/reader/status/temperatureenable":
case "/reader/tagreaddata/reportrssiIndbm":
case "/reader/tagreaddata/uniquebyprotocol":
case "/reader/tagreaddata/enablereadfilter":
case "/reader/radio/enablesjc":
case "/reader/gen2/writeearlyexit":
case "/reader/gen2/sendselect":
case "/reader/extendedepc":
value = ParseBool(valstr);
break;
case "/reader/gen2/t4":
value = Convert.ToUInt32(valstr);
break;
case "/reader/read/plan":
if (valstr.StartsWith("SimpleReadPlan"))
{
value = LoadSimpleReadPlan(valstr);
}
else
{
string str = string.Empty;
List <ReadPlan> RdPlans = new List <ReadPlan>();
str = valstr.Remove(0, 14);
//Remove leading and trailing square brackets
string remove = Regex.Replace(str, @"]$|^\[", "");
int CurrentIndex = 0, PreviousIndex = 1;
List <string> Plans = new List <string>();
while (CurrentIndex != -1)
{
CurrentIndex = str.IndexOf("SimpleReadPlan:", CurrentIndex);
string st = string.Empty;
if (CurrentIndex != -1)
{
st = str.Substring(PreviousIndex, CurrentIndex - PreviousIndex);
PreviousIndex = CurrentIndex;
CurrentIndex += 1;
}
else
{
st = str.Substring(PreviousIndex);
}
if (st != string.Empty)
{
st = st.Remove(st.Length - 1, 1);
Plans.Add(st);
}
}
foreach (string plan in Plans)
{
RdPlans.Add(LoadSimpleReadPlan(plan));
}
MultiReadPlan mrp = new MultiReadPlan(RdPlans);
value = mrp;
}
break;
case "/reader/region/id":
value = Enum.Parse(typeof(Reader.Region), (string)value, true);
break;
case "/reader/powermode":
value = Enum.Parse(typeof(Reader.PowerMode), (string)value, true);
break;
case "/reader/tagop/protocol":
if (value is string)
{
value = Enum.Parse(typeof(TagProtocol), (string)value, true);
}
break;
case "/reader/gen2/accesspassword":
value = new Gen2.Password(Convert.ToUInt32(valstr, 16));
break;
case "/reader/gen2/session":
value = (Gen2.Session)Enum.Parse(typeof(Gen2.Session), valstr, true);
break;
case "/reader/gen2/blf":
value = (Gen2.LinkFrequency)Enum.Parse(typeof(Gen2.LinkFrequency), valstr, true);
break;
case "/reader/gen2/tagencoding":
value = (Gen2.TagEncoding)Enum.Parse(typeof(Gen2.TagEncoding), valstr, true);
break;
case "/reader/iso180006b/blf":
value = (Iso180006b.LinkFrequency)Enum.Parse(typeof(Iso180006b.LinkFrequency), valstr, true);
break;
case "/reader/gen2/target":
value = (Gen2.Target)Enum.Parse(typeof(Gen2.Target), valstr, true);
break;
case "/reader/gen2/tari":
value = (Gen2.Tari)Enum.Parse(typeof(Gen2.Tari), valstr, true);
break;
case "/reader/gen2/protocolextension":
value = (Gen2.Tari)Enum.Parse(typeof(Gen2.ProtocolExtension), valstr, true);
break;
case "/reader/regulatory/mode":
value = Enum.Parse(typeof(Reader.RegulatoryMode), valstr, true);
break;
case "/reader/regulatory/modulation":
value = Enum.Parse(typeof(Reader.RegulatoryModulation), valstr, true);
break;
case "/reader/usermode":
value = (SerialReader.UserMode)Enum.Parse(typeof(SerialReader.UserMode), (string)valstr, true);
break;
case "/reader/stats/enable":
valstr = valstr.Trim(new char[] { '[', ']' });
value = valstr != string.Empty
? (Reader.Stat.StatsFlag)Enum.Parse(typeof(Reader.Stat.StatsFlag), valstr, true)
: (Reader.Stat.StatsFlag)Enum.Parse(typeof(Reader.Stat.StatsFlag), "NONE", true);
break;
case "/reader/gen2/writemode":
value = (Gen2.WriteMode)Enum.Parse(typeof(Gen2.WriteMode), valstr, true);
break;
case "/reader/iso180006b/delimiter":
value = (Iso180006b.Delimiter)Enum.Parse(typeof(Iso180006b.Delimiter), valstr, true);
break;
case "/reader/iso180006b/modulationdepth":
value = (Iso180006b.ModulationDepth)Enum.Parse(typeof(Iso180006b.ModulationDepth), valstr, true);
break;
case "/reader/gen2/q":
Gen2.Q setQ = null;
if (-1 != valstr.IndexOf("DynamicQ"))
{
setQ = new Gen2.DynamicQ();
}
else
{
string resultString = Regex.Match(valstr, @"\d+").Value;
int q = Int32.Parse(resultString);
setQ = new Gen2.StaticQ((byte)q);
}
value = setQ;
break;
case "/reader/gen2/bap":
MatchCollection mc = Regex.Matches(valstr, @"\d+");
Gen2.BAPParameters bap = new Gen2.BAPParameters();
bap.POWERUPDELAY = Convert.ToInt32(mc[0].ToString());
bap.FREQUENCYHOPOFFTIME = Convert.ToInt32(mc[1].ToString());
value = bap;
break;
case "/reader/gen2/initq":
Gen2.InitQ queue = new Gen2.InitQ();
if (valstr.StartsWith("[") && valstr.EndsWith("]"))
{
valstr = valstr.Substring(1, valstr.Length - 2);
string[] qValue = valstr.Split(',');
foreach (string str1 in qValue)
{
string str = str1.Trim();
if (str.StartsWith("qEnable:"))
{
int index = str.IndexOf(":");
string qEnableVal = str.Substring(index + 1).Trim();
queue.qEnable = Convert.ToBoolean(qEnableVal);
}
else if (str.StartsWith("initialQ:"))
{
int index = str.IndexOf(":");
string qEnableVal = str.Substring(index + 1).Trim();
queue.initialQ = Convert.ToByte(qEnableVal);
}
else
{
throw new Exception(str + " is not a valid option");
}
}
value = queue;
}
break;
case "/reader/metadata":
string[] usermeta = valstr.Split(',');
SerialReader.TagMetadataFlag val = 0x0000;
foreach (string meta in usermeta)
{
switch (meta.Trim())
{
case "NONE":
val |= SerialReader.TagMetadataFlag.NONE;
break;
case "ANTENNAID":
val |= SerialReader.TagMetadataFlag.ANTENNAID;
break;
case "DATA":
val |= SerialReader.TagMetadataFlag.DATA;
break;
case "FREQUENCY":
val |= SerialReader.TagMetadataFlag.FREQUENCY;
break;
case "GPIO":
val |= SerialReader.TagMetadataFlag.GPIO;
break;
case "PHASE":
val |= SerialReader.TagMetadataFlag.PHASE;
break;
case "PROTOCOL":
val |= SerialReader.TagMetadataFlag.PROTOCOL;
break;
case "READCOUNT":
val |= SerialReader.TagMetadataFlag.READCOUNT;
break;
case "RSSI":
val |= SerialReader.TagMetadataFlag.RSSI;
break;
case "TIMESTAMP":
val |= SerialReader.TagMetadataFlag.TIMESTAMP;
break;
case "BRAND_IDENTIFIER":
val |= SerialReader.TagMetadataFlag.BRAND_IDENTIFIER;
break;
default:
case "ALL":
val |= SerialReader.TagMetadataFlag.ALL;
break;
}
}
value = val;
break;
default:
break;
}
return(value);
}
