static void Main(string[] args)
        {
            // Program setup
            if (1 != args.Length)
            {
                Console.WriteLine(String.Join("\r\n", new string[] {
                    "Please provide reader URL, such as:",
                    "tmr:///com4",
                    "tmr://my-reader.example.com",
                }));
                Environment.Exit(1);
            }

            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();
                        }
                        else
                        {
                            r.ParamSet("/reader/region/id", supportedRegions[0]);
                        }
                    }

                    DenatranIAVCustomTagOperations denatranIavCustomTagOp = new DenatranIAVCustomTagOperations();

                    denatranIavCustomTagOp.reader = r;

                    #region Initialsettings
                    //Initial settings
                    //Set BLF 320KHZ
                    Console.WriteLine(String.Format("Get BLF : {0}", r.ParamGet("/reader/gen2/blf")));
                    Console.WriteLine("Set BLF to 320KHZ");
                    r.ParamSet("/reader/gen2/blf", Gen2.LinkFrequency.LINK320KHZ);
                    Console.WriteLine(String.Format("Get BLF : {0}", r.ParamGet("/reader/gen2/blf")));
                    Console.WriteLine();

                    //Set session
                    Console.WriteLine(String.Format("Get session : {0}", r.ParamGet("/reader/gen2/session")));
                    Console.WriteLine("Set session");
                    r.ParamSet("/reader/gen2/session", Gen2.Session.S0);
                    Console.WriteLine(String.Format("Get session : {0}", r.ParamGet("/reader/gen2/session")));
                    Console.WriteLine();

                    //Set target
                    Console.WriteLine(String.Format("Get target : {0}", r.ParamGet("/reader/gen2/target")));
                    Console.WriteLine("Set target");
                    r.ParamSet("/reader/gen2/target", Gen2.Target.AB);
                    Console.WriteLine(String.Format("Get target : {0}", r.ParamGet("/reader/gen2/target")));
                    Console.WriteLine();

                    //Set tari
                    Console.WriteLine(String.Format("Get tari : {0}", r.ParamGet("/reader/gen2/tari")));
                    Console.WriteLine("Set tari");
                    r.ParamSet("/reader/gen2/tari", Gen2.Tari.TARI_6_25US);
                    Console.WriteLine(String.Format("Get tari : {0}", r.ParamGet("/reader/gen2/tari")));
                    Console.WriteLine();

                    //Set tagencoding
                    Console.WriteLine(String.Format("Get tagencoding : {0}", r.ParamGet("/reader/gen2/tagEncoding")));
                    Console.WriteLine("Set tagencoding");
                    r.ParamSet("/reader/gen2/tagEncoding", Gen2.TagEncoding.FM0);
                    Console.WriteLine(String.Format("Get tagencoding : {0}", r.ParamGet("/reader/gen2/tagEncoding")));
                    Console.WriteLine();

                    //Set Q
                    Console.WriteLine(String.Format("Get Q : {0}", r.ParamGet("/reader/gen2/q")));
                    Console.WriteLine("Set Q");
                    Gen2.StaticQ staticQ = new Gen2.StaticQ(0);
                    r.ParamSet("/reader/gen2/q", staticQ);
                    Console.WriteLine(String.Format("Get Q : {0}", r.ParamGet("/reader/gen2/q")));
                    Console.WriteLine();
                    #endregion Initialsettings

                    TagReadData[] tagReads;
                    // Read
                    tagReads = r.Read(500);

                    if (tagReads.Length == 0)
                    {
                        Console.WriteLine("Error : No tags found");
                    }
                    else
                    {
                        #region Filter initialization
                        //Gen2Select filter
                        Gen2.Select selectfilter = new Gen2.Select(false, Gen2.Bank.EPC, 32,
                            (ushort)(tagReads[0].Epc.Length * 8), ByteFormat.FromHex(tagReads[0].EpcString));
                        //TagData filter
                        TagFilter tagdataFilter = new TagData(ByteFormat.FromHex(tagReads[0].EpcString));

                        #endregion Filter initialization

                        #region Tag Operation Initialization

                        byte payload = 0x80;
                        ushort readptr = 0xFFFF;
                        ushort wordAddress = 0xFFFF;
                        ushort word = 0xFFFF;
                        //Read ptr for readsec tagop
                        ushort readSecReadPtr = 0x0000;
                        //Set the tag Identification and writeCredentials
                        Gen2.DenatranIAVWriteCredential writeCredential = new Gen2.DenatranIAVWriteCredential
                            ( new byte [] {0x80, 0x10, 0x00, 0x12, 0x34, 0xAD, 0xBD, 0xC0} , 
                            new byte [] {0xDE,0xAD,0xBE,0xEF,0xDE,0xAD,0xBE,0xEF,0xDE,0xAD,0xBE,0xEF,0xDE,0xAD,0xBE,0xEF});
                        //Set the data and writeCredentials for WriteSec
                        Gen2.DenatranIAVWriteSecCredential writeSecCredential = new Gen2.DenatranIAVWriteSecCredential
                            (new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
                            new byte[] { 0x35, 0x49, 0x87, 0xbd, 0xb2, 0xab, 0xd2, 0x7c, 0x2e, 0x34, 0x78, 0x8b, 0xf2, 0xf7, 0x0b, 0xa2 });
                        //IAVDenatran secure tag operation - ActivateSecureMode
                        denatranIavCustomTagOp.tagOpActivateSecureMode = new Gen2.Denatran.IAV.ActivateSecureMode(payload);
                        //IAVDenatran secure tag operation - AuthenticateOBU
                        denatranIavCustomTagOp.tagOpAuthenticateOBU = new Gen2.Denatran.IAV.AuthenticateOBU(payload);
                        //IAVDenatran secure tag operation - ActivateSiniavMode
                        denatranIavCustomTagOp.tagOpActivateSiniavMode = new Gen2.Denatran.IAV.ActivateSiniavMode(0x81, new byte[] { 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef });
                        //IAVDenatran secure tag operation - OBUAuthFullPass1
                        denatranIavCustomTagOp.tagOpOBUAuthFullPass1 = new Gen2.Denatran.IAV.OBUAuthFullPass1(payload);
                        //IAVDenatran secure tag operation - OBUAuthFullPass2
                        denatranIavCustomTagOp.tagOpOBUAuthFullPass2 = new Gen2.Denatran.IAV.OBUAuthFullPass2(payload);
                        //IAVDenatran secure tag operation - OBUAuthID
                        denatranIavCustomTagOp.tagOpOBUAuthID = new Gen2.Denatran.IAV.OBUAuthID(payload);
                        //IAVDenatran secure tag operation - OBUReadFromMemMap
                        denatranIavCustomTagOp.tagOpOBUReadFromMemMap = new Gen2.Denatran.IAV.OBUReadFromMemMap
                            (payload, readptr);
                        //IAVDenatran secure tag operation - OBUWriteToMemMap
                        denatranIavCustomTagOp.tagOpOBUWriteToMemMap = new Gen2.Denatran.IAV.OBUWriteToMemMap
                            (payload, wordAddress, word, writeCredential);
                        //IAVDenatran secure tag operation - OBUAuthFullPass
                        denatranIavCustomTagOp.tagOpOBUAuthFullPass = new Gen2.Denatran.IAV.OBUAuthFullPass(payload);
                        //IAVDenatran secure tag operation - GetTokenId
                        denatranIavCustomTagOp.tagOpGetTokenId = new Gen2.Denatran.IAV.GetTokenId();
                        //IAVDenatran secure tag operation - ReadSec
                        denatranIavCustomTagOp.tagOpReadSec = new Gen2.Denatran.IAV.ReadSec
                            (payload, readSecReadPtr);
                        //IAVDenatran secure tag operation - WriteSec
                        denatranIavCustomTagOp.tagOpWriteSec = new Gen2.Denatran.IAV.WriteSec
                            (payload, writeSecCredential);
                        #endregion Tag Operation Initialization

                        #region Standalonetagoperations

                        //Standalone tagop
                        Console.WriteLine("Standalone tagop without filter : ");
                        Console.WriteLine();
                        denatranIavCustomTagOp.ExecuteTagOpFilter(null);

                        Console.WriteLine("Standalone tagop with tagdata filter : ");
                        Console.WriteLine();
                        denatranIavCustomTagOp.ExecuteTagOpFilter(tagdataFilter);

                        Console.WriteLine("Standalone tagop with gen2Select filter : ");
                        Console.WriteLine();
                        denatranIavCustomTagOp.ExecuteTagOpFilter(selectfilter);

                        #endregion Standalonetagoperations

                        #region Embeddedtagoperations

                        //Embedded tagop
                        Console.WriteLine("Embedded tagop without filter and fastsearch : ");
                        Console.WriteLine();
                        denatranIavCustomTagOp.EmbeddedTagOpFilter(null, false);

                        Console.WriteLine("Embedded tagop with tagdata filter and fastsearch enabled : ");
                        Console.WriteLine();
                        denatranIavCustomTagOp.EmbeddedTagOpFilter(tagdataFilter, true);

                        Console.WriteLine("Embedded tagop with gen2select filter and fast search enabled : ");
                        Console.WriteLine();
                        denatranIavCustomTagOp.EmbeddedTagOpFilter(selectfilter, true);

                        #endregion Embeddedtagoperations
                    }
                }
            }
            catch (ReaderException re)
            {
                Console.WriteLine("Error: " + re.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }
        }
Exemplo n.º 2
0
        /// <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);
        }