public DemoBitmapMenuItem() { Name = "Internalize Bitmap"; TagFilter.Add(HaloTags.bitm); ApplyTagFilter = true; Click += DemoBitmapMenuItem_Click; }
private ReadOnlyCollection <MediaInstance> GetFilteredMedia(SearchMediaData searchMedia) { var tagFilter = new TagFilter(searchMedia.IncludedTags, searchMedia.ExcludedTags, _tagGraph.Object); var filteredMedia = tagFilter.Filter(_mediaInstances.ToList().AsReadOnly()); return(filteredMedia); }
private static void AssertResults ( string folderPath, string filter, params string[] expectedResults) { // Reset the testing directory before comparing, in case a previous test // changed it Utils.ResetTestFolder(); // Get the actual results string fullPath = Utils.GetTestFolder(folderPath); TagFilter tagFilter = new TagFilter(filter); var actualResults = TagUtils.GetMatchingFiles(fullPath, tagFilter); // Convert them to their file names so we can compare them as strings var actualResultsPaths = actualResults.Select(f => f.Name); // Sort them before comparing them, because we don't care about order. actualResultsPaths = actualResultsPaths.OrderBy(s => s).ToArray(); expectedResults = expectedResults.OrderBy(s => s).ToArray(); // Compare them to the expected results bool matches = actualResultsPaths.SequenceEqual(expectedResults); Assert.IsTrue(matches); }
private void search_button_Click(object sender, EventArgs e) {// Begins identification on button click. //Creates new image tagger object and inputs user path through the GetTags method ImageTagger animalImageTagger = new ImageTagger(); List <Tag> tags = animalImageTagger.GetTagsForImage(textBoxText); //creates new tag filter and then runs the tag list through it TagFilter filter = new TagFilter(); List <Tag> filteredTags = filter.Filter(tags); foreach (Tag tag in tags) { if (tag.name == "cat") { checkBox2.Checked = true; } if (tag.name == "dog") { checkBox1.Checked = true; } if (tag.name == "bird") { checkBox3.Checked = true; } } }
public ValidationResults FindAll(TagFilter tagFilter, params string[] tags) { if (tags == null) { string[] array = new string[1]; tags = array; } ValidationResults validationResults = new ValidationResults(); foreach (ValidationResult current in ((IEnumerable <ValidationResult>) this)) { bool flag = false; string[] array2 = tags; for (int i = 0; i < array2.Length; i++) { string text = array2[i]; if ((text == null && current.Tag == null) || (text != null && text.Equals(current.Tag))) { flag = true; break; } } if (flag ^ tagFilter == TagFilter.Ignore) { validationResults.AddResult(current); } } return(validationResults); }
public void Execute(CommandLineArguments arguments) { var assemblyPath = arguments.AssemblyPath; var featurePattern = arguments.FeaturePattern; featureRunner.AddListener(new ConsoleWritingEventListener { ShowCurrentTimes = arguments.ShowCurrentTime, }); var filter = new TagFilter(arguments.TagsToInclude, arguments.TagsToExclude); var featuresToRun = featureFileFinder.Find(featurePattern) .SelectMany(fileName => gherkinParser.Parse(fileName, fileReader.Read(fileName, Encoding.UTF8)).Features) .Where(f => filter.IsSatisfiedBy(f.Tags)); Console.WriteLine("Found {0} features containing {1} executable scenarios", featuresToRun.Count(), featuresToRun.Sum(f => f.Scenarios.Count)); var actionStepsTypes = actionStepsFinder.FindTypesWithActionSteps(assemblyPath); var options = new RunnerOptions { Filter = filter, DruRun = arguments.DruRun, SuccessRequired = arguments.SuccessRequired, }; foreach(var feature in featuresToRun) { var featureResult = featureRunner.Run(feature, actionStepsTypes, options); if (options.SuccessRequired && !featureResult.Success) break; } }
public async Task <ListResponse <TagResponse> > RunAsync(TagFilter filter, ListOptions options) { var tags = _uow.Tags.Query(t => t.Tasks); foreach (var tag in tags) { tag.Tasks = _uow.TagsInTasks.Query(t => t.Task).Where(t => t.TagId == tag.Id).ToList(); } await _factory.CreateAsyncQueryable(tags).LoadAsync(); var query = tags.ProjectTo <TagResponse>(); query = ApplyFilter(query, filter); int totalCount = await _factory.CreateAsyncQueryable(query).CountAsync(); if (options.Sort == null) { options.Sort = "Name"; } query = options.ApplySort(query); query = options.ApplyPaging(query); return(new ListResponse <TagResponse> { Items = await _factory.CreateAsyncQueryable(query).ToListAsync(), Page = options.Page, PageSize = options.PageSize ?? totalCount, Sort = options.Sort, TotalItemsCount = totalCount }); }
public void CanonDependentsFilter() { var canon = new FilterCanonicalizer(); var tagFilter1 = new TagFilter(Tag("A")); var tagFilter2 = new TagFilter(Tag("A")); var tagFilter3 = new TagFilter(Tag("B")); var dependentsFilter1 = new DependentsFilter(tagFilter1); var dependentsFilter2 = new DependentsFilter(tagFilter2); var dependentsFilter3 = new DependentsFilter(tagFilter3); var canonDependentsFilter1 = dependentsFilter1.Canonicalize(canon); var canonDependentsFilter2 = dependentsFilter2.Canonicalize(canon); var canonDependentsFilter3 = dependentsFilter3.Canonicalize(canon); Assert.Same(canonDependentsFilter1, canonDependentsFilter2); Assert.NotSame(canonDependentsFilter1, canonDependentsFilter3); var canonTagFilter = tagFilter1.Canonicalize(canon); var canonFilter1 = canonDependentsFilter1 as DependentsFilter; var canonFilter2 = canonDependentsFilter2 as DependentsFilter; Assert.NotNull(canonFilter1); Assert.NotNull(canonFilter2); Assert.Same(canonFilter1.Inner, canonTagFilter); Assert.Same(canonFilter2.Inner, canonTagFilter); }
public void CanonBinaryFilter() { var canon = new FilterCanonicalizer(); var tagFilter1 = new TagFilter(Tag("A")); var tagFilter2 = new TagFilter(Tag("A")); var negatingFilter1 = new NegatingFilter(new TagFilter(Tag("B"))); var negatingFilter2 = new NegatingFilter(new TagFilter(Tag("B"))); var binaryFilter1 = new BinaryFilter(tagFilter1, FilterOperator.And, negatingFilter1); var binaryFilter2 = new BinaryFilter(tagFilter2, FilterOperator.And, negatingFilter2); var binaryFilter3 = new BinaryFilter(negatingFilter1, FilterOperator.And, tagFilter2); var binaryFilter4 = new BinaryFilter(tagFilter1, FilterOperator.Or, negatingFilter1); var canonBinaryFilter1 = binaryFilter1.Canonicalize(canon); var canonBinaryFilter2 = binaryFilter2.Canonicalize(canon); var canonBinaryFilter3 = binaryFilter3.Canonicalize(canon); var canonBinaryFilter4 = binaryFilter4.Canonicalize(canon); Assert.Same(canonBinaryFilter1, canonBinaryFilter2); Assert.Same(canonBinaryFilter1, canonBinaryFilter3); Assert.NotSame(canonBinaryFilter1, canonBinaryFilter4); var canonFilter1 = canonBinaryFilter1 as BinaryFilter; var canonFilter2 = canonBinaryFilter2 as BinaryFilter; var canonFilter3 = canonBinaryFilter3 as BinaryFilter; Assert.NotNull(canonFilter1); Assert.NotNull(canonFilter2); Assert.NotNull(canonFilter3); Assert.Same(canonFilter1.Left, canonFilter2.Left); Assert.Same(canonFilter1.Right, canonFilter2.Right); Assert.Same(canonFilter1.Left, canonFilter3.Left); Assert.Same(canonFilter1.Right, canonFilter3.Right); }
public void CanonNegatingFilter() { var canon = new FilterCanonicalizer(); var tagFilter1 = new TagFilter(Tag("A")); var tagFilter2 = new TagFilter(Tag("A")); var tagFilter3 = new TagFilter(Tag("B")); var negatingFilter1 = new NegatingFilter(tagFilter1); var negatingFilter2 = new NegatingFilter(tagFilter2); var negatingFilter3 = new NegatingFilter(tagFilter3); var canonNegatingFilter1 = negatingFilter1.Canonicalize(canon); var canonNegatingFilter2 = negatingFilter2.Canonicalize(canon); var canonNegatingFilter3 = negatingFilter3.Canonicalize(canon); Assert.Same(canonNegatingFilter1, canonNegatingFilter2); Assert.NotSame(canonNegatingFilter1, canonNegatingFilter3); var canonTagFilter = tagFilter1.Canonicalize(canon); var canonFilter1 = canonNegatingFilter1 as NegatingFilter; var canonFilter2 = canonNegatingFilter2 as NegatingFilter; Assert.NotNull(canonFilter1); Assert.NotNull(canonFilter2); Assert.Same(canonFilter1.Inner, canonTagFilter); Assert.Same(canonFilter2.Inner, canonTagFilter); }
internal static Filters GenerateFromGroupFilter(NancyContext ctx, SVR_GroupFilter gf, int uid, bool nocast, bool notag, bool all, int level, bool allpic, int pic, byte tagfilter) { Filters f = new Filters { id = gf.GroupFilterID, name = gf.GroupFilterName }; List<SVR_GroupFilter> allGfs = RepoFactory.GroupFilter.GetByParentID(f.id) .Where(a => a.InvisibleInClients == 0 && ((a.GroupsIds.ContainsKey(uid) && a.GroupsIds[uid].Count > 0) || (a.FilterType & (int) GroupFilterType.Directory) == (int) GroupFilterType.Directory)) .ToList(); List<Filter> filters = allGfs .Where(cgf => (cgf.FilterType & (int) GroupFilterType.Tag) != (int) GroupFilterType.Tag || TagFilter.ProcessTags(tagfilter, new List<string> {cgf.GroupFilterName}).Count != 0) .Select(cgf => Filter.GenerateFromGroupFilter(ctx, cgf, uid, nocast, notag, level - 1, all, allpic, pic, tagfilter)).ToList(); if (gf.FilterType == ((int)GroupFilterType.Season | (int)GroupFilterType.Directory)) f.filters = filters.OrderBy(a => a.name, new SeasonComparator()).ToList(); else f.filters = filters.OrderByNatural(a => a.name).ToList(); f.size = f.filters.Count(); f.url = APIHelper.ConstructFilterIdUrl(ctx, f.id); return f; }
public static void embeddedRead(TagProtocol protocol, TagFilter filter, TagOp tagop) { TagReadData[] tagReads = null; SimpleReadPlan plan = new SimpleReadPlan(antennaList, protocol, filter, tagop, 1000); r.ParamSet("/reader/read/plan", plan); tagReads = r.Read(1000); // Print tag reads foreach (TagReadData tr in tagReads) { Console.WriteLine(tr.ToString()); if (tr.isErrorData) { // In case of error, show the error to user. Extract error code. int errorCode = ByteConv.ToU16(tr.Data, 0); Console.WriteLine("Embedded Tag operation failed. Error: " + ReaderCodeException.faultCodeToMessage(errorCode)); } else { if (tagop is Gen2.EMMicro.EM4325.GetSensorData) { if (tr.Data.Length > 0) { GetSensorDataResponse rData = new GetSensorDataResponse(tr.Data); Console.WriteLine("Data:" + rData.ToString()); } } else { Console.WriteLine(" Data:" + ByteFormat.ToHex(tr.Data, "", " ")); } } } }
public async Task <ListResponse <TagResponse> > RunAsync(TagFilter filter, ListOptions options) { var tag = _context.Tags .Include(t => t.Tasks).ThenInclude(tt => tt.Task); IQueryable <TagResponse> query = tag .Select(t => Mapper.Map <TagResponse>(t)); query = ApplyFilter(query, filter); int totalCount = await query.CountAsync(); if (options.Sort == null) { options.Sort = "Name"; } query = options.ApplySort(query); query = options.ApplyPaging(query); return(new ListResponse <TagResponse> { Items = await query.ToListAsync(), Page = options.Page, PageSize = options.PageSize ?? totalCount, Sort = options.Sort, TotalItemsCount = totalCount }); }
/// <summary> /// Just like AssertResults, but it also tests a given sort method as well. /// </summary> /// <param name="folderPath"></param> /// <param name="sortMethod"></param> /// <param name="filter"></param> /// <param name="expectedResults"></param> private static void AssertSorted ( string folderPath, string filter, SortMethod sortMethod, bool descending, params string[] expectedResults) { // Reset the testing directory before comparing, in case a previous test // changed it Utils.ResetTestFolder(); // Get the actual results string fullPath = Utils.GetTestFolder(folderPath); TagFilter tagFilter = new TagFilter(filter); var actualResults = TagUtils.GetMatchingFiles(fullPath, tagFilter, sortMethod, descending) .Select(f => f.Name); // Compare them to the expected results bool matches = actualResults.SequenceEqual(expectedResults); Assert.IsTrue(matches); }
public static List <Tag> GetTags(HttpContext ctx, SVR_AniDB_Anime anime, TagFilter.Filter filter, bool excludeDescriptions = false) { var tags = new List <Tag>(); var allTags = anime.GetAniDBTags().DistinctBy(a => a.TagName).ToList(); var filteredTags = TagFilter.ProcessTags(filter, allTags, tag => tag.TagName); foreach (AniDB_Tag tag in filteredTags) { var toAPI = new Tag { Name = tag.TagName }; var animeXRef = RepoFactory.AniDB_Anime_Tag.GetByTagID(tag.TagID).FirstOrDefault(); if (animeXRef != null) { toAPI.Weight = animeXRef.Weight; } if (!excludeDescriptions) { toAPI.Description = tag.TagDescription; } tags.Add(toAPI); } return(tags); }
private void button1_Click(object sender, EventArgs e) { try { rd = Reader.Create("192.168.1.101", ModuleTech.Region.NA, 4); } catch (Exception ex) { MessageBox.Show("连接失败,请检查读写器地址是否正确" + ex.ToString()); return; } lst1.Items.Add("连接成功!"); int[] connectedants = (int[])rd.ParamGet("ConnectedAntennas"); for (int c = 0; c < connectedants.Length; ++c) { lst1.Items.Add(c + "->" + connectedants[c]); } TagFilter tf = (TagFilter)rd.ParamGet("Singulation"); // rd.read int[] ants = new int[] { 1, 4 }; Gen2TagFilter filter = new Gen2TagFilter(ByteFormat.FromHex("FFFFFFFF"), MemBank.EPC, 32, false); rd.ParamSet("Singulation", filter); SimpleReadPlan searchPlan = new SimpleReadPlan(ants); rd.ParamSet("ReadPlan", searchPlan); }
bool DoTagsMatch(TagsCollectionBase osmGeoTags, TagFilter tagFilter) { // No tags to match if (tagFilter == null) { return(true); } // Doesn't match if it doesn't contain all of tags foreach (var tag in tagFilter.AllOfTags) { if (!osmGeoTags.Contains(tag.Key, tag.Value)) { return(false); } } // Doesn't match if it contains at least none of tags foreach (var tag in tagFilter.NoneOfTags) { if (osmGeoTags.Contains(tag.Key, tag.Value)) { return(false); } } return(true); }
private static bool MatchesFilter(string content, string tagList) { var page = new StubStoryTestPage(content); var testparser = new TagFilter(tagList); return(testparser.Matches(page)); }
public ValidationResults FindAll(TagFilter tagFilter, params string[] tags) { if (tags == null) { string[] array = new string[1]; tags = array; } ValidationResults validationResults = new ValidationResults(); foreach (ValidationResult item in (IEnumerable <ValidationResult>) this) { bool flag = false; string[] array2 = tags; foreach (string text in array2) { if (text == null && item.Tag == null) { goto IL_0053; } if (text != null && text.Equals(item.Tag)) { goto IL_0053; } continue; IL_0053: flag = true; break; } if (flag ^ tagFilter == TagFilter.Ignore) { validationResults.AddResult(item); } } return(validationResults); }
private void PerformReadAllMemOperation(TagFilter filter, TagOp op) { TagReadData[] tagReads = null; SimpleReadPlan plan = new SimpleReadPlan(null, TagProtocol.GEN2, filter, op, 1000); reader.ParamSet("/reader/read/plan", plan); Console.WriteLine("Embedded tag operation - "); // Read tags tagReads = reader.Read(500); foreach (TagReadData tr in tagReads) { Console.WriteLine(tr.ToString()); if (0 < tr.Data.Length) { Console.WriteLine(" Embedded read data: " + ByteFormat.ToHex(tr.Data, "", " ")); Console.WriteLine(" User memory: " + ByteFormat.ToHex(tr.USERMemData, "", " ")); Console.WriteLine(" Reserved memory: " + ByteFormat.ToHex(tr.RESERVEDMemData, "", " ")); Console.WriteLine(" Tid memory: " + ByteFormat.ToHex(tr.TIDMemData, "", " ")); Console.WriteLine(" EPC memory: " + ByteFormat.ToHex(tr.EPCMemData, "", " ")); } Console.WriteLine(" Embedded read data length:" + tr.Data.Length); } Console.WriteLine(); Console.WriteLine("Standalone tag operation - "); ushort[] data = (ushort[])reader.ExecuteTagOp(op, filter); //// Print tag reads if (0 < data.Length) { Console.WriteLine(" Standalone read data:" + ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(data), "", " ")); Console.WriteLine(" Standalone read data length:" + ByteConv.ConvertFromUshortArray(data).Length); } data = null; Console.WriteLine(); }
bool DoTagsMatch(TagsCollectionBase osmGeoTags, TagFilter tagFilter) { var allOfTags = tagFilter.AllOfTags; var noneOfTags = tagFilter.NoneOfTags; // Doesn't match if it doesn't contain all of tags for (int i = 0; i < allOfTags.Length; i++) { if (!osmGeoTags.Contains(allOfTags[i].Key, allOfTags[i].Value)) { return(false); } } // Doesn't match if it contains at least none of tags for (int i = 0; i < noneOfTags.Length; i++) { if (osmGeoTags.Contains(noneOfTags[i].Key, noneOfTags[i].Value)) { return(false); } } return(true); }
/// <summary> /// /// </summary> /// <param name="session"></param> /// <param name="target"></param> /// <param name="filter"></param> /// <param name="antID"></param> public CustomAntConfigPerAntenna(Gen2.Session session, Gen2.Target target, TagFilter filter, int antID) { this.session = session; this.target = target; this.filter = filter; this.antID = antID; }
public ValidationResults FindAll(TagFilter tagFilter, params string[] tags) { // workaround for params behavior - a single null parameter will be interpreted // as null array, not as an array with null as element if (tags == null) { tags = new string[] { null }; } var filteredValidationResults = new ValidationResults(); foreach (ValidationResult validationResult in this) { bool matches = tags.Any(tag => (tag == null && validationResult.Tag == null) || (tag != null && tag.Equals(validationResult.Tag))); // if ignore, look for !match // if include, look for match if (matches ^ (tagFilter == TagFilter.Ignore)) { filteredValidationResults.AddResult(validationResult); } } return(filteredValidationResults); }
/// <summary> /// Read tag memory for readers or modules other the M5e variants /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">filter</param> /// <param name="MemData">Data read from tag memory</param> private void ReadMemoryM6eVariants(Gen2.Bank bank, TagFilter filter, ref ushort[] MemData) { try { // Read tag memory with zero as start address and lenght of words to read as zero TagOp op = new Gen2.ReadData(bank, 0, 0); MemData = (ushort[])objectReader.ExecuteTagOp(op, filter); if (MemData.Length < 64) { // If data read is less then 64 words, then perform read word by word to make sure // all the data is read from the tag memory ReadTagMemoryWordByWord(bank, filter, ref MemData); } else { // If data read is more then 64 words then perform read with start address as 64 words // and length as zero ReadLargeTagMemory(bank, filter, ref MemData); } } catch (Exception ex) { if ((ex is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) || ((ex is FAULT_NO_TAGS_FOUND_Exception))) { // Perform read when the tag has mem more then 128 bytes and doesn't support // Zero start address and number of words to read as zero ReadLargeTagMemoryWithoutZeroLengthSupport(bank, filter, ref MemData); } else { throw; } } }
public ValidationResults FindAll(TagFilter tagFilter, params string[] tags) { if (tags == null) { tags = new string[1]; } ValidationResults results = new ValidationResults(); foreach (ValidationResult result in (IEnumerable <ValidationResult>) this) { bool flag = false; foreach (string str in tags) { if (((str == null) && (result.Tag == null)) || ((str != null) && str.Equals(result.Tag))) { flag = true; break; } } if (flag ^ (tagFilter == TagFilter.Ignore)) { results.AddResult(result); } } return(results); }
private void SetReadPlan() { TagFilter filter = null; if (selectMemBank == Gen2.Bank.EPC) { if (txtEpc.Text != "") { filter = new TagData(txtEpc.Text); } } else { byte[] data = ByteFormat.FromHex(txtData.Text); if (null == data) { dataLength = 0; } else { dataLength = data.Length; } filter = new Gen2.Select(false, selectMemBank, Convert.ToUInt16(startAddress * 16), Convert.ToUInt16(dataLength * 8), data); } SimpleReadPlan srp = new SimpleReadPlan(new int[] { antenna }, TagProtocol.GEN2, filter, 1000); objReader.ParamSet("/reader/read/plan", srp); }
public static async Task <IEnumerable <string> > GetCommitMessagesFromTagAsync( this IRepository repository, TagFilter filter) { var tag = repository.Tags.From(filter); if (tag is null) { throw new NullReferenceException("No tag was found with provided name."); } var commit = repository.Commits.FirstOrDefault(x => x.Sha.Equals(tag.PeeledTarget.Sha)); if (commit is null) { throw new NullReferenceException("No commits were found from provided tag."); } var exclusionList = new List <Commit>(commit.Parents) { commit }; var commitFilter = new CommitFilter() { ExcludeReachableFrom = exclusionList }; return(await repository.GetCommitMessagesByFilterAsync(commitFilter)); }
public static List <Tag> GetTags(HttpContext ctx, SVR_AniDB_Anime anime, TagFilter.Filter filter, bool excludeDescriptions = false) { // TODO This is probably slow. Make it faster. var tags = new List <Tag>(); var allTags = anime.GetAniDBTags().DistinctBy(a => a.TagName).ToDictionary(a => a.TagName, a => a); var filteredTags = TagFilter.ProcessTags(filter, allTags.Keys.ToList()); foreach (string filteredTag in filteredTags) { AniDB_Tag tag = allTags.ContainsKey(filteredTag) ? allTags[filteredTag] : RepoFactory.AniDB_Tag.GetByName(filteredTag).FirstOrDefault(); if (tag == null) { tags.Add(new Tag { Name = filteredTag }); continue; } var toAPI = new Tag { Name = tag.TagName }; if (!excludeDescriptions) { toAPI.Description = tag.TagDescription; } tags.Add(toAPI); } return(tags); }
RunnerOptions NullFilter() { return(new RunnerOptions { Filter = TagFilter.Empty(), DruRun = false, }); }
/// <summary> /// Create a SimpleReadPlan /// </summary> /// <param name="antennaList">List of antenna numbers. May be null.</param> /// <param name="protocol">Protocol identifier</param> /// <param name="filter">Tag filter. May be null.</param> /// <param name="op">Operation mode</param> /// <param name="weight">Relative scheduling weight</param> public SimpleReadPlan(ICollection <int> antennaList, TagProtocol protocol, TagFilter filter, TagOp op, int weight) : base(weight) { Antennas = (antennaList != null) ? CollUtil.ToArray(antennaList) : null; Protocol = protocol; Filter = filter; Op = op; }
public void CanCompareFilters() { AssertEqual(TagFilter.Empty(), new TagFilter(new string[0], new string[0])); AssertEqual(new TagFilter(new[] { "tag1", "tag2" }, new[] { "tag3", "tag4" }), new TagFilter(new[] { "tag2", "tag1" }, new[] { "tag4", "tag3" })); }
// Use this for initialization void Start() { gps = GameObject.Find ("GamePanelHolder").GetComponent<GamePanelScript> (); gf = gameObject.GetComponent<GameFactory> (); xreader = new XMLReader (); taad = gameObject.GetComponent<TestAddAndDestroy> (); gamesActive = new List<string> {"Auditiv","Kinæstetisk","Visuel","Taktil"}; tagFilter = new TagFilter (); LoadAllXML (); }
/// <summary> /// Creates a new additive filter /// </summary> /// <param name="a"></param> /// <param name="b"></param> public TagFilterAdditive(TagFilter a, TagFilter b) { if (a == null) { throw new ArgumentNullException("a"); } if (b == null) { throw new ArgumentNullException("b"); } _a = a; _b = b; }
/// <summary> /// Write a new ID to a tag. /// </summary> /// <param name="target">the tag target to operate on</param> /// <param name="epc">the tag ID to write</param> public override void WriteTag(TagFilter target, TagData epc) { // Validate parameters TagProtocol protocol = (TagProtocol)ParamGet("/reader/tagop/protocol"); switch (protocol) { case TagProtocol.ISO180006B: case TagProtocol.ISO180006B_UCODE: if (null == target) { throw new ReaderException("ISO18000-6B does not yet support writing ID to unspecified tags. Please provide a TagFilter."); } break; } PrepForTagop(); SetField("tag_id.id", new WriteTagArgs(target, epc)); }
/// <summary> /// Write the data to user memoru /// </summary> /// <param name="filter"> data to be written on the specified tag which is used as filter</param> private void WriteUserMem(TagFilter filter) { string userMem = string.Empty; try { objReader.ParamSet("/reader/tagop/protocol", TagProtocol.GEN2); if ((bool)rbHexRep.IsChecked) { for(int count = 0; count < txtbxHexRepList.Length; count++) { if (txtbxHexRepList[count].Text != string.Empty) { userMem += txtbxHexRepList[count].Text; } else { userMem += "00"; } } ExecuteUsermemoryTagOp(ByteConv.ToU16s(ByteFormat.FromHex(userMem)), filter); UpdateHexUserMemoryRepresentation(ByteFormat.FromHex(userMem)); txtASCIIData.IsEnabled = true; originalAsciiNewString = Utilities.HexStringToAsciiString(userMem); btnWrite.IsEnabled = false; btnWriteAscii.IsEnabled = false; } else if ((bool)rbASCII.IsChecked) { if (txtASCIIData.Text.Length > 0) { string editedAsciiData = EditAsciiString(editedAsciiNewString); UpdateHexEditor(editedAsciiData); ExecuteUsermemoryTagOp(ByteConv.ToU16s(ByteFormat.FromHex(Utilities.AsciiStringToHexString(editedAsciiData))), filter); txtASCIIData.Foreground = Brushes.Black; originalAsciiNewString = editedAsciiData; btnWrite.IsEnabled = false; btnWriteAscii.IsEnabled = false; } else { return; } } MessageBox.Show("Write user memory is successfull", "Info", MessageBoxButton.OK, MessageBoxImage.Information); } catch (Exception ex) { MessageBox.Show(ex.Message.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
/// <summary> /// Perform a lock or unlock operation on a tag. The first tag seen /// is operated on - the singulation parameter may be used to control /// this. Note that a tag without an access password set may not /// accept a lock operation or remain locked. /// </summary> /// <param name="target">the tag target to operate on</param> /// <param name="action">the tag lock action</param> public override void LockTag(TagFilter target, TagLockAction action) { PrepForTagop(); TagProtocol protocol = (TagProtocol) ParamGet("/reader/tagop/protocol"); if (action is Gen2.LockAction) { if (TagProtocol.GEN2 != protocol) { throw new ArgumentException(String.Format( "Gen2.LockAction not compatible with protocol {0}", protocol.ToString())); } Gen2.LockAction la = (Gen2.LockAction) action; // TODO: M4API makes a distinction between locking tag ID and data. // Locking tag_id allows access to only the EPC, TID and password banks. // Locking tag_data allows access to only the User bank. // Ideally, M4API would stop making the distinction, since Gen2 has a unified locking model. // In the meantime, just lock tag_id, since it covers more and tags with user memory are still uncommon. if ((la.Mask & 0x3FC) != 0) SetField("tag_id.locked", new Gen2LockArgs(target, (Gen2.LockAction) action)); else if ((la.Mask & 0x3) != 0) SetField("tag_data.locked", new Gen2LockArgs(target, (Gen2.LockAction) action)); } else throw new ArgumentException("LockTag does not support this type of TagLockAction: " + action.ToString()); }
/// <summary> /// Create a SimpleReadPlan /// </summary> /// <param name="antennaList">List of antenna numbers. May be null.</param> /// <param name="protocol">Protocol identifier</param> /// <param name="filter">Tag filter. May be null.</param> /// <param name="op">Operation mode</param> /// <param name="weight">Relative scheduling weight</param> /// <param name="useFastSearch">Enable fast search</param> public SimpleReadPlan(ICollection<int> antennaList, TagProtocol protocol, TagFilter filter, TagOp op, bool useFastSearch, int weight) : base(weight) { Antennas = (antennaList != null) ? CollUtil.ToArray(antennaList) : null; Protocol = protocol; Filter = filter; Op = op; UseFastSearch = useFastSearch; }
public void Iso180006bLockTag(TagFilter filter,byte address) { PrepForTagop(); TagProtocol protocol = (TagProtocol) ParamGet("/reader/tagop/protocol"); if (null != filter ) { Iso180006bLockArgs lockArgs = new Iso180006bLockArgs(filter, address, 1); SetField("tag_data.locked", lockArgs); } else throw new ArgumentException("ISO180006B only supports locking a single tag specified by 64-bit EPC"); }
public Iso180006bLockArgs(TagFilter target, byte address,int locked) { Target = target; Address = address; Locked = locked; }
/// <summary> /// Read data from the memory bank of a tag. /// </summary> /// <param name="target">the tag target to operate on</param> /// <param name="bank">the tag memory bank</param> /// <param name="address">the reading starting byte address</param> /// <param name="byteCount">the bytes to read</param> /// <returns>the bytes read</returns> public override byte[] ReadTagMemBytes(TagFilter target, int bank, int address, int byteCount) { PrepForTagop(); int wordAddress = 0, wordCount = 0; List<string> wheres = new List<string>(); if (TagProtocol.GEN2 == (TagProtocol)ParamGet("/reader/tagop/protocol")) { wheres.Add(String.Format("mem_bank={0:D}", bank)); wordAddress = address / 2; wordCount = ByteConv.WordsPerBytes(byteCount); } else { wordAddress = address; wordCount = byteCount; } wheres.Add(String.Format("block_count={0:D}", wordCount)); wheres.Add(String.Format("block_number={0:D}", wordAddress)); Gen2.Password password = (Gen2.Password)(ParamGet("/reader/gen2/accessPassword")); if ((TagProtocol.GEN2 == (TagProtocol)ParamGet("/reader/tagop/protocol")) && (password.Value != 0)) { wheres.Add(String.Format("password=0x{0:X}", password)); } wheres.AddRange(MakeTagopWheres(target)); string response = Select(new string[] { "data" }, "tag_data", wheres, -1)[0]; if (TagProtocol.GEN2 == (TagProtocol)ParamGet("/reader/tagop/protocol")) { // Skip "0x" prefix int charOffset = 2; // Correct for word start boundary int byteOffset = address - (wordAddress * 2); charOffset += byteOffset * 2; int charLength = byteCount * 2; string byteStr = response.Substring(charOffset, charLength); return ByteFormat.FromHex(byteStr); } else { return ByteFormat.FromHex(response); } }
void AssertEqual(TagFilter filter1, TagFilter filter2) { Assert.IsTrue(filter1 == filter2); Assert.IsFalse(filter1 != filter2); }
public WriteTagArgs(TagFilter target, TagData epc) { Target = target; Epc = epc; }
/// <summary> /// Create WHERE clauses representing a tag filter /// </summary> /// <param name="tagFilter">Tag filter</param> /// <returns>List of strings to be incorporated into "WHERE ... AND ..." phrase. /// List may be empty.</returns> private List<string> TagFilterToWhereClause(TagFilter tagFilter) { List<string> wheres = new List<string>(); if (null == tagFilter) { // Do nothing } else if (tagFilter is Iso180006b.TagData) { Iso180006b.TagData td = (Iso180006b.TagData)tagFilter; wheres.Add(String.Format("id={0}", ByteFormat.ToHex(td.EpcBytes))); } else if (tagFilter is TagData) { TagData td = (TagData) tagFilter; wheres.Add(String.Format("id={0}", ByteFormat.ToHex(td.EpcBytes))); } else if (tagFilter is Gen2.Select) { Gen2.Select sel = (Gen2.Select)tagFilter; wheres.Add("filter_subtype=0"); wheres.Add(String.Format("filter_mod_flags=0x{0:X}", (sel.Invert) ? "00000001" : "00000000")); wheres.Add(String.Format("filter_bank=0x{0:X}" , sel.Bank)); wheres.Add("filter_bit_address=" + sel.BitPointer); wheres.Add("filter_bit_length="+sel.BitLength); wheres.Add("filter_data=0x" + BitConverter.ToString(sel.Mask).Replace("-", string.Empty)); } else if (tagFilter is Iso180006b.Select) { Iso180006b.Select sel = (Iso180006b.Select)tagFilter; wheres.Add("filter_subtype=0"); string operation = string.Empty; switch (sel.Op) { case Iso180006b.SelectOp.EQUALS: operation = "00"; break; case Iso180006b.SelectOp.NOTEQUALS: operation = "01"; break; case Iso180006b.SelectOp.GREATERTHAN: operation = "02"; break; case Iso180006b.SelectOp.LESSTHAN: operation = "03"; break; default: break; }; wheres.Add(String.Format("filter_command=0x{0:X}",operation)); wheres.Add(String.Format("filter_mod_flags=0x{0:X}", (sel.Invert) ? "00000001" : "00000000")); wheres.Add("filter_bit_address=" + sel.Address); wheres.Add("filter_bit_length=64"); wheres.Add("filter_data=0x" + BitConverter.ToString(sel.Data).Replace("-", string.Empty)); } else throw new ArgumentException("RQL only supports singulation by EPC. " + tagFilter.ToString() + " is not supported."); return wheres; }
/// <summary> /// Read tag memory when tag has more then 64 words or 128 bytes. And module doesn't supports zero address and zero length. /// Reads the tag memory with 0 address and length of words as 64. If memory overrun received. Initiates reading of tag /// word by word with start address as length of alread read data and length of words to read as 0. Returns the data read from /// tag memory. /// </summary> /// <param name="bank">Gen2 mem bank</param> /// <param name="filter">filter</param> /// <param name="data">Data read from tag memory</param> private void ReadLargeTagMemoryWithoutZeroLengthSupport(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { data = null; // Data from tag memory List<ushort> dataTemp = new List<ushort>(); // Number of words to read int words = 64; // Start address uint startaddress = 0; TagOp op; bool isAllDatareceived = true; // Read till all the data from the tag memory is read while (isAllDatareceived) { try { op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); // Increment the start address to 64 and keep length of wrods to read as 64 for // all the iterations startaddress += 64; } catch (Exception ex) { try { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != ex.Message.IndexOf("Non-specific reader error")) || (-1 != ex.Message.IndexOf("General Tag Error")) || (-1 != ex.Message.IndexOf("Tag data access failed"))) { // If the memory to read requested is more then the available memory in the tag, then initiate // reading the tag memory word by word with start address as length of already read data if exists // and lenght of words to read is 1 ushort[] wordData = null; if (dataTemp.Count > 0) { // If some data is already read then include this data also so that // reading of memory doesn't continue from zero and the list sholud // not contain same data twice wordData = dataTemp.ToArray(); } ReadTagMemoryWordByWord(bank, filter, ref wordData); dataTemp.AddRange(wordData); // Come out of main while loop. And read the already read data isAllDatareceived = false; } else { throw; } } catch (Exception exception) { // If more then once the below exceptions are recieved then come out of the loop. if (exception is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != exception.Message.IndexOf("Non-specific reader error")) || (-1 != exception.Message.IndexOf("General Tag Error")) || (-1 != exception.Message.IndexOf("Tag data access failed"))) { if (dataTemp.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isAllDatareceived = false; } else { // throw the exception if the data received is null for the first iteration itself throw; } } else { throw; } } } } data = dataTemp.ToArray(); } }
/// <summary> /// Read specified tag memory bank /// </summary> /// <param name="bank">Gen2 bank</param> /// <param name="filter">filter</param> /// <param name="MemData">Data read from the tag memory</param> public void ReadTagMemoryData(Gen2.Bank bank, TagFilter filter, ref ushort[] MemData) { if (modelReader.Equals("M5e") || modelReader.Equals("M5e EU") || modelReader.Equals("M5e Compact") || modelReader.Equals("Astra")) { // Read tag memory word by word for M5e variants ReadTagMemoryWordByWord(bank, filter, ref MemData); } else { // Read tag memory for m6e variants ReadMemoryM6eVariants(bank, filter, ref MemData); } }
/// <summary> /// Write data to user memory /// </summary> /// <param name="userMemData"></param> /// <param name="filter"></param> private void ExecuteUsermemoryTagOp(ushort [] userMemData, TagFilter filter) { uint userMemStartAddress = (uint)startAddress; uint[] wrdAddressList = null; wrdAddressList = GetWordAddressList(); int editedDataCellLocLength = 0; while (editedDataCellLocLength < wrdAddressList.Length) { userMemStartAddress = wrdAddressList[editedDataCellLocLength]; ushort[] dataToBeWritten = new ushort[1]; Array.Copy(userMemData, userMemStartAddress, dataToBeWritten, 0, 1); objReader.ExecuteTagOp(new Gen2.WriteData(Gen2.Bank.USER, userMemStartAddress, dataToBeWritten), filter); editedDataCellLocLength++; } }
/// <summary> /// Write data to the memory bank of a tag. /// </summary> /// <param name="target">the tag target to operate on</param> /// <param name="bank">the tag memory bank</param> /// <param name="address">the memory address to write</param> /// <param name="data">the data to write</param> public override void WriteTagMemWords(TagFilter target, int bank, int address, ICollection<ushort> data) { ushort[] dataArray = CollUtil.ToArray(data); byte[] dataBytes = new byte[dataArray.Length * 2]; for (int i = 0; i < dataArray.Length; i++) { dataBytes[2 * i] = (byte)((dataArray[i] >> 8) & 0xFF); dataBytes[2 * i + 1] = (byte)((dataArray[i]) & 0xFF); } WriteTagMemBytes(target, bank, address*2, dataBytes); }
/// <summary> /// Read data from the memory bank of a tag. /// </summary> /// <param name="target">the tag target to operate on</param> /// <param name="bank">the tag memory bank</param> /// <param name="wordAddress">the read starting word address</param> /// <param name="wordCount">the number of words to read</param> /// <returns>the read words</returns> public override ushort[] ReadTagMemWords(TagFilter target, int bank, int wordAddress, int wordCount) { return ReadTagMemWordsGivenReadTagMemBytes(target, bank, wordAddress, wordCount); }
/// <summary> /// Parse epc memory data and populate the epc mem textboxes /// </summary> /// <param name="epcData">accepts read epc memory data</param> private void ParseEPCMemData(ushort[] epcData, TagFilter filter) { unUsedEpcData = string.Empty; byte[] epcBankData = null; if (null != epcData) { epcBankData = ByteConv.ConvertFromUshortArray(epcData); int readOffset = 0; byte[] epc, crc, pc, unusedEpc = null, additionalMemData = null; int lengthCounter = 2; crc = SubArray(epcBankData, ref readOffset, lengthCounter); pc = SubArray(epcBankData, ref readOffset, lengthCounter); lengthCounter += 2; // Extract the epc length from pc word int epclength = Convert.ToInt32(((pc[0] & 0xf8) >> 3)) * 2; epc = SubArray(epcBankData, ref readOffset, epclength); List<byte> xpc = new List<byte>(); /* Add support for XPC bits * XPC_W1 is present, when the 6th most significant bit of PC word is set */ if ((pc[0] & 0x02) == 0x02) { /* When this bit is set, the XPC_W1 word will follow the PC word * Our TMR_Gen2_TagData::pc has enough space, so copying to the same. */ try { ushort[] xpcW1 = (ushort[])objReader.ExecuteTagOp(new Gen2.ReadData(Gen2.Bank.EPC, 0x21, 1), filter); spXPC.Visibility = System.Windows.Visibility.Visible; lblXPC1MemAddress.Content = "33"; xpc.AddRange(ByteConv.ConvertFromUshortArray(xpcW1)); lengthCounter += 2; txtXPC1.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(xpcW1), "", " "); lblXPC1.Content = "XPC"; } catch (Exception ex) { spXPC.Visibility = System.Windows.Visibility.Visible; txtXPC1.Text = ex.Message; lblXPC1.Content = "XPC"; } /* If the most siginificant bit of XPC_W1 is set, then there exists * XPC_W2. A total of 6 (PC + XPC_W1 + XPC_W2 bytes) */ if ((xpc[0] & 0x80) == 0x80) { try { ushort[] xpcW2 = (ushort[])objReader.ExecuteTagOp(new Gen2.ReadData(Gen2.Bank.EPC, 0x22, 1), filter); spXPC2.Visibility = System.Windows.Visibility.Visible; lblXPC2MemAddress.Content = "34"; lengthCounter += 2; txtXPC2.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(xpcW2), "", " "); // Change the name of XPC to XPC1 lblXPC1.Content = "XPC1"; } catch (Exception ex) { spXPC2.Visibility = System.Windows.Visibility.Visible; txtXPC2.Text = ex.Message; // Change the name of XPC to XPC1 lblXPC1.Content = "XPC1"; } } } // Read extended epc memory if (epcBankData.Length > (lengthCounter + epclength)) { lblExtdEPCMemAddress.Content = Convert.ToString(readOffset/2); bool isExtendedEPCMemover = true; uint startExtdEPCMemAddress = (uint)readOffset/2; List<ushort> data = new List<ushort>(); try { while (isExtendedEPCMemover) { // Make sure reading of memory word by word doesn't override XPC1 data if (startExtdEPCMemAddress < 33) { data.AddRange((ushort[])objReader.ExecuteTagOp(new Gen2.ReadData(Gen2.Bank.EPC, startExtdEPCMemAddress, 1), filter)); startExtdEPCMemAddress += 1; } else { // Read of memory should not exceed XPC bytes isExtendedEPCMemover = false; } } } catch (Exception ex) { // If more then once the below exceptions are recieved then come out of the loop. if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != ex.Message.IndexOf("Non-specific reader error")) || (-1 != ex.Message.IndexOf("General Tag Error")) || (-1 != ex.Message.IndexOf("Tag data access failed"))) { if (data.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isExtendedEPCMemover = false; } } } if (data.Count > 0) { unusedEpc = ByteConv.ConvertFromUshortArray(data.ToArray()); } } // Read additional memory if (epcBankData.Length > (lengthCounter + epclength)) { lblAddMemAddress.Content = "35"; bool isAdditionalMemover = true; uint startAdditionalMemAddress = 0x23; List<ushort> dataAdditionalMem = new List<ushort>(); try { while (isAdditionalMemover) { dataAdditionalMem.AddRange((ushort[])objReader.ExecuteTagOp(new Gen2.ReadData(Gen2.Bank.EPC, startAdditionalMemAddress, 1), filter)); startAdditionalMemAddress += 1; } } catch (Exception ex) { // If more then once the below exceptions are recieved then come out of the loop. if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != ex.Message.IndexOf("Non-specific reader error")) || (-1 != ex.Message.IndexOf("General Tag Error")) || (-1 != ex.Message.IndexOf("Tag data access failed"))) { if (dataAdditionalMem.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isAdditionalMemover = false; } } } if (dataAdditionalMem.Count > 0) { additionalMemData = ByteConv.ConvertFromUshortArray(dataAdditionalMem.ToArray()); } } if (txtXPC1.Text != "") { spXPC.Visibility = System.Windows.Visibility.Visible; } if (txtXPC2.Text != "") { spXPC2.Visibility = System.Windows.Visibility.Visible; } txtCRC.Text = ByteFormat.ToHex(crc, "", " "); txtPC.Text = ByteFormat.ToHex(pc, "", " "); if (epc.Length == epclength) { txtEPCData.Text = ByteFormat.ToHex(epc, "", " "); } else { txtEPCData.Text = currentEPC; } if (null != unusedEpc) { txtEPCUnused.Text = ByteFormat.ToHex(unusedEpc, "", " "); unUsedEpcData = ByteFormat.ToHex(unusedEpc, "", ""); // Visible additional memory spUnused.Visibility = System.Windows.Visibility.Visible; } if (null != additionalMemData) { txtAdditionalMem.Text = ByteFormat.ToHex(additionalMemData, "", " "); unadditionalMemData = ByteFormat.ToHex(additionalMemData, "", ""); // Visible additional memory spAddMemory.Visibility = System.Windows.Visibility.Visible; } if ((bool)rbEPCAscii.IsChecked) { txtEPCValue.Text = Utilities.HexStringToAsciiString(currentEPC); txtEPCUnusedValue.Text = Utilities.HexStringToAsciiString(unUsedEpcData); txtadditionalMemValue.Text = Utilities.HexStringToAsciiString(unadditionalMemData); } else if ((bool)rbEPCBase36.IsChecked) { txtEPCValue.Text = Utilities.ConvertHexToBase36(currentEPC); txtEPCUnusedValue.Text = Utilities.ConvertHexToBase36(unUsedEpcData); txtadditionalMemValue.Text = Utilities.ConvertHexToBase36(unadditionalMemData); } #region 0 length read //if (model.Equals("M5e") || model.Equals("M5e EU") || model.Equals("M5e Compact")) //{ // ReadData(Gen2.Bank.EPC, searchSelect, out epcData); //} //else //{ // op = new Gen2.ReadData(Gen2.Bank.EPC, 0, 0); // epcData = (ushort[])objReader.ExecuteTagOp(op, searchSelect); //} //if(null!= epcData) // epcBankData = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(epcData), "", " "); //if (epcBankData.Length > 0) //{ // int epcLen = txtEpc.Text.Length; // txtCRC.Text = epcBankData.Substring(0, 5).TrimStart(' '); // txtPC.Text = epcBankData.Substring(6, 5).TrimStart(' '); // int epcstringLength = epcLen+((epcLen/2)-1); // txtEPCData.Text = epcBankData.Substring(11, epcstringLength).TrimStart(' '); // //string epcDataString = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(epcData), "", ""); // txtEPCUnused.Text = epcBankData.Substring(11 + epcstringLength).TrimStart(' '); //String.Join(" ", (epcDataString.Substring(8 + epcLen)).ToArray()); #endregion } }
/// <summary> /// Create a SimpleReadPlan /// </summary> /// <param name="antennaList">List of antenna numbers. May be null.</param> /// <param name="protocol">Protocol identifier</param> /// <param name="filter">Tag filter. May be null.</param> /// <param name="weight">Relative scheduling weight</param> public SimpleReadPlan(ICollection<int> antennaList, TagProtocol protocol, TagFilter filter, int weight) : this(antennaList, protocol, filter, _defaultTagOp, weight) { }
private void ReadReservedMemData(Gen2.Bank bank, TagFilter filter) { ushort [] reservedData; TagOp op; try { try { // Read kill password op = new Gen2.ReadData(Gen2.Bank.RESERVED, 0, 2); reservedData = (ushort[])objReader.ExecuteTagOp(op, filter); if (null != reservedData) { txtKillPassword.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); } else { txtKillPassword.Text = ""; } } catch (Exception ex) { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception) { txtKillPassword.Text = "Read Error"; } else { txtKillPassword.Text = ex.Message; } } try { // Read access password reservedData = null; op = new Gen2.ReadData(Gen2.Bank.RESERVED, 2, 2); reservedData = (ushort[])objReader.ExecuteTagOp(op, filter); if (null != reservedData) { txtAcessPassword.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); } else { txtAcessPassword.Text = ""; } } catch (Exception ex) { if (ex is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception) { txtAcessPassword.Text = "Read Error"; } else { txtAcessPassword.Text = ex.Message; } } // Read additional memory password try { reservedData = null; if (model.Equals("M5e") || model.Equals("M5e EU") || model.Equals("M5e Compact") || model.Equals("Astra")) { ReadAdditionalReservedMemDataM5eVariants(Gen2.Bank.RESERVED, 4, filter, out reservedData); } else { op = new Gen2.ReadData(Gen2.Bank.RESERVED, 4, 0); reservedData = (ushort[])objReader.ExecuteTagOp(op, filter); } if (null != reservedData) { txtReservedMemUnusedValue.Text = ByteFormat.ToHex(ByteConv.ConvertFromUshortArray(reservedData), "", " "); // Visible additional memory textboxes lblAdditionalReservedMem.Visibility = System.Windows.Visibility.Visible; txtReservedMemUnusedValue.Visibility = System.Windows.Visibility.Visible; lblAdditionalReservedMemAdd.Visibility = System.Windows.Visibility.Visible; } else { txtReservedMemUnusedValue.Text = ""; } } catch { // catch the exception and move on. Only some tags has aditional memory txtReservedMemUnusedValue.Text = ""; // Hide additional memory textboxes lblAdditionalReservedMem.Visibility = System.Windows.Visibility.Collapsed; txtReservedMemUnusedValue.Visibility = System.Windows.Visibility.Collapsed; lblAdditionalReservedMemAdd.Visibility = System.Windows.Visibility.Collapsed; } } catch (Exception) { throw; } }
/// <summary> /// Read additional reserved memory for m5e variants /// </summary> /// <param name="bank"></param> /// <param name="startAddress"></param> /// <param name="filter"></param> /// <param name="data"></param> private void ReadAdditionalReservedMemDataM5eVariants(Gen2.Bank bank, uint startAddress, TagFilter filter, out ushort[] data) { data = null; int words = 1; TagOp op; while (true) { try { op = new Gen2.ReadData(bank, startAddress, Convert.ToByte(words)); data = (ushort[])objReader.ExecuteTagOp(op, filter); words++; } catch (Exception) { throw; } } }
public Gen2LockArgs(TagFilter target, Gen2.LockAction action) { Target = target; Action = action; }
/// <summary> /// Write data to the memory bank of a tag. /// </summary> /// <param name="target">the tag target to operate on</param> /// <param name="bank">the tag memory bank</param> /// <param name="byteAddress">the starting memory address to write</param> /// <param name="data">the data to write</param> public override void WriteTagMemBytes(TagFilter target, int bank, int byteAddress, ICollection<byte> data) { PrepForTagop(); int address = 0, byteCount = 0; TagProtocol proto = (TagProtocol)ParamGet("/reader/tagop/protocol"); if (TagProtocol.GEN2 == proto) { address = byteAddress / 2; if (address * 2 != byteAddress) throw new ArgumentException("Byte write address must be even"); byteCount = data.Count; int count = ByteConv.WordsPerBytes(byteCount); if (count * 2 != byteCount) throw new ArgumentException("Byte write length must be even"); } else if (TagProtocol.ISO180006B == proto) { address = byteAddress; } else { throw new ReaderException("Writing tag data not supported for protocol " + proto.ToString()); } List<string> wheres = new List<string>(); wheres.Add(String.Format("mem_bank={0:D}", bank)); wheres.Add(String.Format("block_number={0:D}", address)); wheres.AddRange(MakeTagopWheres(target)); wheres.AddRange(MakeAccessPasswordWheres()); SetField("tag_data.data", CollUtil.ToArray(data), wheres); }
/// <summary> /// Read tag memory which has more then 64 words or 128 bytes. Returns the data read from tag memory. /// Stops reading the tag memory if FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception exception is received /// more then once. If the data read from tag memory is less then 64 words then initiates reading tag /// memory word by word /// </summary> /// <param name="bank"> Gen2 mem bank</param> /// <param name="filter">filter</param> /// <param name="data">Mem data obtained from the tag</param> private void ReadLargeTagMemory(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { List<ushort> dataTemp = new List<ushort>(); if (data != null) { dataTemp.AddRange(data); } int words = 0; uint startaddress = 64; TagOp op; bool isAllDatareceived = true; while (isAllDatareceived) { try { op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); ushort[] tempDataReceived = (ushort[])objectReader.ExecuteTagOp(op, filter); dataTemp.AddRange(tempDataReceived); startaddress += 64; if (tempDataReceived.Length < 64) { isAllDatareceived = false; // If data received is less then 64 words, perform word by word with start address as length // of the data and numer of words to read is 1 ReadTagMemoryWordByWord(bank, filter, ref data); } } catch (Exception ex) { if (ex is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) { try { // If read is success then continue the while loop with incremented start address and length as 0 words = 64; op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); startaddress += 64; words = 0; } catch (Exception et) { // If consecutively we get FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception exception blindly come out of the loop to avoid // dead lock if (et is FAULT_PROTOCOL_BIT_DECODING_FAILED_Exception) { isAllDatareceived = false; } else { throw; } } } else { throw; } } } data = dataTemp.ToArray(); } }
public void SetupContext() { Filter = new TagFilter(new [] {"foo", "bar"}); }
/// <summary> /// Create list of WHERE clauses representing tagop reader configuration (e.g., /reader/tagop/antenna, /reader/tagop/protocol) /// </summary> /// <param name="filt">Tags to target for tagop</param> /// <returns>List of strings to be incorporated into "WHERE ... AND ..." phrase. /// List may be empty.</returns> private List<string> MakeTagopWheres(TagFilter filt) { List<string> wheres = (List<string>) MakeTagopWheres(); wheres.AddRange(TagFilterToWhereClause(filt)); return wheres; }
/// <summary> /// Read tag memory word by word. If FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception /// or Non-specific reader error or General Tag Error or Tag data access failed exception /// is recieved. Memory reading is stopped and the already read data is returned /// </summary> /// <param name="bank">Gen2 memory bank</param> /// <param name="filter">Select filter</param> /// <param name="data">Read tag memory data is returned</param> private void ReadTagMemoryWordByWord(Gen2.Bank bank, TagFilter filter, ref ushort[] data) { lock (new Object()) { List<ushort> dataTemp = new List<ushort>(); uint startaddress = 0; if (data != null) { // if the data varibale already contains the data, then add that data // to data temp and chnage the start address to total data length dataTemp.AddRange(data); startaddress = (uint)data.Length; } int words = 1; TagOp op; bool isAllDatareceived = true; while (isAllDatareceived) { try { // Read tag memory word by word op = new Gen2.ReadData(bank, startaddress, Convert.ToByte(words)); dataTemp.AddRange(((ushort[])objectReader.ExecuteTagOp(op, filter))); startaddress += 1; } catch (Exception exception) { if (exception is FAULT_GEN2_PROTOCOL_MEMORY_OVERRUN_BAD_PC_Exception || (-1 != exception.Message.IndexOf("Non-specific reader error")) || (-1 != exception.Message.IndexOf("General Tag Error")) || (-1 != exception.Message.IndexOf("Tag data access failed"))) { if (dataTemp.Count > 0) { // Just skip the exception and move on. So as not to lose the already read data. isAllDatareceived = false; } else { // throw the exception if the data received is null for the first iteration itself throw; } } else { throw; } } } data = dataTemp.ToArray(); } }