How to get tid​

[wateryys]

I use swift to develop, I can get epc，How to get tid​

[TimvdGaag]

I've grabbed an example from our project to read the user memory bank.
but I think you could also use it to read the TID memory bank.

hope this helps

        let error = NurApiReadTagByEPC(nurapiHandle, 0, false, &epcArray, DWORD(UInt32(epcArray.count)), BYTE(NUR_BANK_TID.rawValue), 0, lenght, &buffer)

example with the NUR_BANK_USER.rawValue

   /**
     * Retrieve the user Memory of a tag
     */
    func getTagUserMem(epc: NSData) -> NSData?{
        NotificationCenter.default.post(name: Notification.Name(rawValue: "startedMemoryRead"), object:nil )
        /** Stop the inventory stream */
        _ = InventoryComponent.sharedInstance.stopStream()
        /** Disable near scan set antenna full power */
        InventoryComponent.sharedInstance.disableNearScan()
        /** Convert epc byte array to singulate agianst */
        let epcArray = epcToByteArray(epc: epc)
        /** First try reading most occuring user bank size for us */
        let data192 = readUserMem(start: 192, epcArrayParam: epcArray)
        if(data192 != nil) {
            /** enable the proximity antenna's */
            InventoryComponent.sharedInstance.enableNearScan()
            _ = InventoryComponent.sharedInstance.startStream()
            
            NotificationCenter.default.post(name: Notification.Name(rawValue: "doneMemoryRead"), object:nil )
            return data192
        }
        /** First try reading second most occuring user bank size for us */
        let data56 = readUserMem(start: 56, epcArrayParam: epcArray)
        if(data56 != nil) {
            InventoryComponent.sharedInstance.enableNearScan()
            _ = InventoryComponent.sharedInstance.startStream()
            
            NotificationCenter.default.post(name: Notification.Name(rawValue: "doneMemoryRead"), object:nil )
            return data56
        }
        /** try searching for other user bank sizes */
        let data = readUserMem(start: 192, epcArrayParam: epcArray)
        InventoryComponent.sharedInstance.enableNearScan()
        _ = InventoryComponent.sharedInstance.startStream()
        NotificationCenter.default.post(name: Notification.Name(rawValue: "doneMemoryRead"), object:nil )
        return data
    }
    
    private func readUserMem(start: Int, epcArrayParam: [BYTE])  -> NSData? {
        var epcArray = epcArrayParam
        var data = NSData()
        for i in start..<1024 where i%8 == 0{
            if(ConnectionComponent.hasReaderConnected() == false){
                return nil
            }
            var buffer: [BYTE] = [BYTE]()
            for _ in 0..<i {
                buffer.append(0 as BYTE)
            }
            let lenght: Int32 = Int32(i)
            
            let error = NurApiReadTagByEPC(Bluetooth.sharedInstance().nurapiHandle, 0, false, &epcArray, DWORD(UInt32(epcArray.count)), BYTE(NUR_BANK_USER.rawValue), 0, lenght, &buffer)
            
            if(UInt32(error) == NUR_NO_ERROR.rawValue) {
                print("succes")
                data = NSData(bytes: buffer, length: Int(buffer.count))
                continue
            }
            if UInt32(error) == NUR_ERROR_G2_TAG_MEM_OVERRUN.rawValue {
                break
            } else {
                return nil
            }
        }
        if(data.length < 1){
            return nil
        }
        return data

    }

[nullfx]

got beat to the reply but our company develops a unified mobile api (for both iOS and Android and a number of other devices) and this is a snippet from our read( tidAt instruction byEpc ) for Nordic ID:

    /// Read a tag's TID by EPC
    ///
    /// - Parameters:
    ///   - tidAt: Specify the address offset and length to read the TID
    ///   - byEpc: The existing EPC value used to identify the target tag
    ///   - secured: This provides the access security configuration for the operation. Use 'nil' or 'nonSecured' to denote a non-secure operation.
    /// - Returns: the 'Data' of the tag TID
    @discardableResult open func read( tidAt: Instruction, byEpc: String, secured: AccessSecurity? = nil ) -> Data? {
        guard let nurHandle : HANDLE = Bluetooth.sharedInstance()?.nurapiHandle else { return nil }
        var data = [UInt8](repeating: 0, count: Int(tidAt.length))
        var epc = Data(hexString: byEpc)!.map{$0}
        let epcLen = UInt32(byEpc.count / 2)
        var password: UInt32 = 0
        let isSecured = secured != nil && secured?.secured ?? false
        if isSecured {
            password = secured!.password
        }
        let code = NurApiReadTagByEPC(nurHandle, password, isSecured, &epc, epcLen, UInt8(NUR_BANK_TID.rawValue), UInt32(tidAt.address), tidAt.length, &data)
        let ec = NUR_ERRORCODES(rawValue: UInt32(code))
        raiseLog(eventArg: LogEvent(READER_TAG, action: "read tidAt", message: "\(code == NUR_SUCCESS.rawValue)"))
        if ec == NUR_SUCCESS {
            return Data(data)
        } else {
            return nil
        }
    }

access security:

//
//  AccessSecurity.swift
//  MobileCore
//
//  Created by Steve on 1/29/20.
//  Copyright © 2020 GlobeRanger. All rights reserved.
//

import Foundation

/// A class used to specify Access Security for tag operations which require it
open class AccessSecurity {
    /// A pre-defined value indicating the tag operation does not require secure operations
    public static var nonSecured = AccessSecurity(password: 0, secured: false)
    /// The secure password
    open var password: UInt32
    /// Indicates a secure operation is required
    open var secured: Bool
    /// Creates a new Access security instance
    /// - Parameters:
    ///   - password: The password used in the secure operation
    ///   - secured: Whether this is a secure operation
    public init( password: UInt32, secured: Bool ) {
        self.password = password
        self.secured = secured
    }
}

edit (forgot instruction):

//
//  Instruction.swift
//  MobileCore
//
//  Created by Steve on 1/29/20.
//  Copyright © 2020 GlobeRanger. All rights reserved.
//

import Foundation

/// A class used to get and set extended tag data
open class Instruction {
    /// The extended tag data starting address
    open var address: Int32
    /// The length of the extended tag data
    open var length: Int32
    /// Access security required for the instruction
    open var security: AccessSecurity?
    /// Creates a new instance of the instruction
    /// - Parameters:
    ///   - address: The starting address of the instruction
    ///   - length: The length of the instruction
    ///   - security: Any security information used by the instruction
    public init(address: Int32, length: Int32, security: AccessSecurity? = nil) {
        self.address = address
        self.length = length
        self.security = security
    }
}

[wateryys]

Sorry, I'm a little confused. I used the demo code to get the epc, but I don't know how to get the tid

[wateryys]

//
//  MARK: - Bluetooth delegate
//
func notificationReceived(_ timestamp: DWORD, type: Int32, data: LPVOID!, length: Int32) {
    print("received notification: \(type)")
    switch NUR_NOTIFICATION(rawValue: UInt32(type)) {
    case NUR_NOTIFICATION_INVENTORYSTREAM:
        handleTag(data: data, length: length)

    default:
        NSLog("received notification: \(type)")
        break
    }
}

private func handleTag (data: UnsafeMutableRawPointer?, length: Int32) {
    guard let handle: HANDLE = Bluetooth.sharedInstance().nurapiHandle else {
        return
    }

    guard let streamDataPtr = data?.bindMemory(to: NUR_INVENTORYSTREAM_DATA.self, capacity: Int(length)) else {
        return
    }

    defer {
        let streamData = UnsafePointer<NUR_INVENTORYSTREAM_DATA>(streamDataPtr).pointee

        // restart stream if it stopped
        if streamData.stopped.boolValue {
            if checkError( NurApiStartInventoryStream(handle, self.rounds, self.q, self.session), message: "Failed to start inventory stream") {
                print("stream restarted")
            }
        }
    }

    // first lock the tag storage
    if !checkError(NurApiLockTagStorage(handle, true), message: "Failed to lock tag storage" ) {
        return
    }

    // get number of tags read in this round
    var tagCount: Int32 = 0
    if !checkError(NurApiGetTagCount(handle, &tagCount), message: "Failed to clear tag storage" ) {
        return
    }

    print("tags found: \(tagCount)")

    if tagCount == 0 {
        // if no tags then we're done here
        _ = checkError(NurApiLockTagStorage(handle, false), message: "Failed to lock tag storage" )
        return
    }

    // allocate space to hold the tags and fetch them all at once
    let tagBuffer = UnsafeMutablePointer<NUR_TAG_DATA_EX>.allocate(capacity: Int(tagCount))
    let stride = UInt32(MemoryLayout<NUR_TAG_DATA_EX>.stride)
    let status = checkError(NurApiGetAllTagDataEx(handle, tagBuffer, &tagCount, stride), message: "Failed to fetch tags" )

    for index in 0 ..< Int(tagCount) {
        let tagData = tagBuffer[index]

        // convert the tag data into an array of BYTEs
        withUnsafeBytes(of: tagData.epc) { raw in
            // array with correct length
            let bytes = raw[0 ..< Int(tagData.epcLen)]

            // convert to a hex string
            let epc = bytes.reduce( "", { result, byte in
                result + String(format:"%02x", byte )
            })

            DispatchQueue.main.async {
                if !self.tags.contains(where: { $0.epc == epc } ) {
                    // emit a tag to any optional handler
                    let tag = Tag(epc: epc, rssi: tagData.rssi, scaledRssi: tagData.scaledRssi, antennaId: tagData.antennaId, timestamp: tagData.timestamp, frequency: tagData.freq, channel: tagData.channel )

                    self.tags.append(tag)
                    self.tagsFoundLabel.text = String(self.tags.count)
                    self.tableView.reloadData()
                }
            }
        }
    }

[nullfx]

if you copy the code i posted above into a class the class you're handling read notifications / the code you posted above (you'll have to remove the logging stuff i'm sure, get it to compile)

inside the bit where you get the Tag object (down towards the bottom) you can use the tag object to call the read( tidAt byEPC ... to get the TID. you need to find out how long your TID is though. play with it debugging the app till the call returns the full TID.

just a hint Nordic ID's api will return the partial TID from 0-n until it hits then end, then it won't give you the TID at all... its been ages since we did this implementation though, I can't recall if the tags we were testing on were 16 or 24 words long, but play with it and see...

also, i'm just writing this directly in the comments so this may not be 100% correct but hopefully you get the idea...

DispatchQueue.main.async {
    if !self.tags.contains(where: { $0.epc == epc } ) {
        // emit a tag to any optional handler
        let tag = Tag(epc: epc, rssi: tagData.rssi, scaledRssi: tagData.scaledRssi, antennaId: tagData.antennaId, timestamp: tagData.timestamp, frequency: tagData.freq, channel: tagData.channel )
        
        // you have to know the length of the TID but... just guessing 16
        let tid = read( tidAt: Instruction(address: 0, length: 16, secured: nil), byEpc: tag.epc, secured: nil );

        self.tags.append(tag)
        self.tagsFoundLabel.text = String(self.tags.count)
        self.tableView.reloadData()
    }
}

[wateryys]

sorry I don't have these two methods
var epc = Data(hexString: byEpc)!.map{$0}
raiseLog(eventArg: LogEvent(READER_TAG, action: "read tidAt", message: "(code == NUR_SUCCESS.rawValue)"))

I use var epc = byEpc.data(using: .utf8)!.map{$0} replace
but Return nil

[nullfx]

right, like i said before the logging bit (this is part of my company's internal sdk) you'll have to remove.

sorry... the Data( hexString is an extension, looks something like:

public extension Data {
    /// Initializer which takes a hexadecimal string and converts it to a 'Data' object
    init?(hexString: String) {
        let len = hexString.count / 2
        var data = Data(capacity: len)
        for i in 0..<len {
            let j = hexString.index(hexString.startIndex, offsetBy: i*2)
            let k = hexString.index(j, offsetBy: 2)
            let bytes = hexString[j..<k]
            if var num = UInt8(bytes, radix: 16) {
                data.append(&num, count: 1)
            } else {
                return nil
            }
        }
        self = data
    }
    
    /// Convert a 'Data' object to an uppercase hexadecimal string representation
    func toHexString() -> String {
        return self.map{ String(format:"%02x", $0) }.joined().uppercased()
    }
}

[wateryys]

sorry I use this method ,but always return nil ,length tried many values , tag.epc = ac11200426040158
let tid = self.read(tidAt: Instruction.init(address: 0, length: 24), byEpc: tag.epc)

[wateryys]

@discardableResult open func read( tidAt: Instruction, byEpc: String, secured: AccessSecurity? = nil ) -> Data? {
    guard let nurHandle : HANDLE = Bluetooth.sharedInstance()?.nurapiHandle else { return nil }
    var data = [UInt8](repeating: 0, count: Int(tidAt.length))
    var epc = Data(hexString: byEpc)!.map{$0}
    let epcLen = UInt32(byEpc.count / 2)
    var password: UInt32 = 0
    let isSecured = secured != nil && secured?.secured ?? false
    if isSecured {
        password = secured!.password
    }
    let code = NurApiReadTagByEPC(nurHandle, password, isSecured, &epc, epcLen, UInt8(NUR_BANK_TID.rawValue), UInt32(tidAt.address), tidAt.length, &data)
    let ec = NUR_ERRORCODES(rawValue: UInt32(code))
    if ec == NUR_SUCCESS {
        return Data(data)
    } else {
        return nil
    }
}

[nullfx]

just a hint Nordic ID's api will return the partial TID from 0-n until it hits then end, then it won't give you the TID at all... its been ages since we did this implementation though, I can't recall if the tags we were testing on were 16 or 24 words long, but play with it and see...

as I mention here... the nordic id api requires you specify the exact length of the tid. start with a small number (ex: 2 then keep trying... 4, 6, 8, 12...) until it returns nothing again. then the previous value is what your TID length needs to be. this will vary depending on the type of tag you're using. https://rfid4u.com/rfid-epc-gen2-memory/

[nullfx]

to make things simpler, rather than trying to read the TID as a separate operation during inventory, the nordic id readers can fetch the TID or USER data for you during inventory so the tag can come populated with either user data or the TID.

again, if you try to read too much user/tid the tags will never show up in inventory so you have to set the amount of extended tag (user or tid) to a length that can be read by the device.

I've cloned the current demo here and modified the code that does the StartInventory so that it includes the TID. now when you get the notification the tag will just include the TID.

at the top of InventoryViewController.swift there is a constant TID_LENGTH (just because its easier to see up there) that you can set to the maximum width of the TID. my tags max width is 6, any longer than this and nothing shows up. any shorter than this and the reader won't see the entire TID.

it currently just prints out the EPC and TID to the console. hopefully this helps more than the other code snippets.

[wateryys]

Thank you very much，According to the demo, we found epc and tid

[nullfx]

i updated the demo to add the tag details to the tableview (and fixed a bug with the start/stop and check if running code) and added the tid to the tag details, so you can get latest to see the whole thing just running in the UI as well as printing out in the console. its been 2-3 years since i've worked on the code for this device so i was a bit rusty :D but it should all be up and running now