How to make a function synchronous with NFC calls?

I'm developing an iOS NFC application interacting with ISO15693 chips.

I need to send multiple consecutive commands through NFC and those commands shall be executed one by one and I need to wait for the result of the previous command to execute the next one.

As of today I'm using:

DispatchQueue.global().async {
    DispatchQueue.global().sync {
        var fw_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_FW_ID)
        print("Read FirmwareID \(fw_id)")
        var sw_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_SW_ID)
        print("Read SotfwareID \(sw_id)")
        var ex_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_EX_ID)
        print("Read ExternalID \(ex_id)")
    }
}

The commands are correctly executed one by one.

But inside the sendI2CCommand:

public static func sendI2CCommand(tag: NFCISO15693Tag, command: UInt8) -> String{
    var res:String = ""
    tag.sendRequest(requestFlags: 0x12, commandCode: 0xD4, data: Data([0x04, 0x02, 0x00, command]))
    { result in
        switch result {
            case .success(( let responseFlag as NFCISO15693ResponseFlag, let response as Data)):
                break
            case .failure(_):
                break
            default:
                tag.sendRequest(requestFlags: 0x12, commandCode: 0xD5, data: Data([0x04, 0x02, 0x00]))
                { result in
                    switch result {
                        case .success(( let responseFlag as NFCISO15693ResponseFlag, let response2 as Data)):
                            break
                    case .failure(_):
                            break
                        default:
                            tag.sendRequest(requestFlags: 0x12, commandCode: 0xD2, data: Data([0x04, 0x00, 0x06]))
                            { result in
                                switch result {
                                    case .success(( let responseFlag as NFCISO15693ResponseFlag, let response2 as Data)):
                                        var foo = response2
                                        foo.insert(responseFlag.rawValue, at: 0)
                                        let responseHex = foo.hexadecimalCompressed.substring(with: 2..<4)
                                        res = responseHex
                                        break
                                    case .failure(_):
                                        break
                                    default:
                                        break
                                }
                            }
                            break
                    }
                }
                break
        }
    }
    usleep(50000)
    return res
}

the sendI2CCommand is sending two consecutive NFC commands. But even if the call is inside the DispatchQueue sync, the result of the function is not waiting for the end of the execution and I need to add a very ugly
usleep(50000)
before returning the value, otherwise the result is empty and is not returning any data as the APDU commands takes some time to be executed.

I also tried to use semaphore inside the function but it blocks my APDU commands:

let semaphore = DispatchSemaphore(value: 0)

at the beginning of the function

semaphore.signal()

when my processing is finished.

And

semaphore.wait()

just before returning the result but it crashes during processing.

So how can I avoid using usleep function to wait for the end of the processing before returning the result in my function?

You cannot do what you're describing like this. You will block shared threads that you're not allowed to block. This is precisely what async/await and CheckedContinuation is designed for.

// Add `async throws` here
public static func sendI2CCommand(tag: NFCISO15693Tag, command: UInt8) async throws -> String {
    // Wrap in a CheckedThrowingContinuation
    try await withCheckedThrowingContinuation { continuation in
        // Call your async method
        tag.sendRequest(requestFlags: 0x12, commandCode: 0xD4, data: Data([0x04, 0x02, 0x00, command]))
        { result in

           // ... When you would return a value:
                                continuation.resume(returning: responseHex)

           // ... When there is an error:
           continuation.resume(throwing: error)
        }
    }
}

You must make sure to call .resume precisely one time.

Then your top level code becomes:

Task {
    do {
        var fw_id = try await NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_FW_ID)
        print("Read FirmwareID \(fw_id)")
        var sw_id = try await NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_SW_ID)
        print("Read SotfwareID \(sw_id)")
        var ex_id = try await NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_EX_ID)
        print("Read ExternalID \(ex_id)")
    } catch {
        // handle error
    }
}

If you don't want sendI2CCommand to return until it actually has a result then you can use a DispatchGroup as follows:

public static func sendI2CCommand(tag: NFCISO15693Tag, command: UInt8) -> String{
    var res:String = ""
    var group = DispatchGroup()
    group.enter()
    DispatchQueue.global().async {
        tag.sendRequest(requestFlags: 0x12, commandCode: 0xD4, data: Data([0x04, 0x02, 0x00, command]))
        { result in
            switch result {
            case .success(( let responseFlag as NFCISO15693ResponseFlag, let response as Data)):
                group.leave()
            case .failure(_):
                group.leave()
            default:
                tag.sendRequest(requestFlags: 0x12, commandCode: 0xD5, data: Data([0x04, 0x02, 0x00]))
                { result in
                    switch result {
                    case .success(( let responseFlag as NFCISO15693ResponseFlag, let response2 as Data)):
                        group.leave()
                    case .failure(_):
                        group.leave()
                    default:
                        tag.sendRequest(requestFlags: 0x12, commandCode: 0xD2, data: Data([0x04, 0x00, 0x06]))
                        { result in
                            switch result {
                            case .success(( let responseFlag as NFCISO15693ResponseFlag, let response2 as Data)):
                                var foo = response2
                                foo.insert(responseFlag.rawValue, at: 0)
                                let responseHex = foo.hexadecimalCompressed.substring(with: 2..<4)
                                res = responseHex
                            case .failure(_):
                                break
                            default:
                                break
                            }
                            group.leave()
                        }
                    }
                }
            }
        }
    }

    group.wait()

    return res
}

You can also remove the DispatchGroup.global().sync from the calling code:

DispatchQueue.global().async {
    var fw_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_FW_ID)
    print("Read FirmwareID \(fw_id)")
    var sw_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_SW_ID)
    print("Read SotfwareID \(sw_id)")
    var ex_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_EX_ID)
    print("Read ExternalID \(ex_id)")
}

Another option is to modify sendI2CCommand to take a completion handler:

public static func sendI2CCommand(tag: NFCISO15693Tag, command: UInt8, completion: (String) -> Void) -> String{
    var res = ""
    tag.sendRequest(requestFlags: 0x12, commandCode: 0xD4, data: Data([0x04, 0x02, 0x00, command]))
    { result in
        switch result {
        case .success(( let responseFlag as NFCISO15693ResponseFlag, let response as Data)):
            completion(res)
        case .failure(_):
            completion(res)
        default:
            tag.sendRequest(requestFlags: 0x12, commandCode: 0xD5, data: Data([0x04, 0x02, 0x00]))
            { result in
                switch result {
                case .success(( let responseFlag as NFCISO15693ResponseFlag, let response2 as Data)):
                    completion(res)
                case .failure(_):
                    completion(res)
                default:
                    tag.sendRequest(requestFlags: 0x12, commandCode: 0xD2, data: Data([0x04, 0x00, 0x06]))
                    { result in
                        switch result {
                        case .success(( let responseFlag as NFCISO15693ResponseFlag, let response2 as Data)):
                            var foo = response2
                            foo.insert(responseFlag.rawValue, at: 0)
                            let responseHex = foo.hexadecimalCompressed.substring(with: 2..<4)
                            res = responseHex
                        case .failure(_):
                            break
                        default:
                            break
                        }
                        completion(res)
                    }
                }
            }
        }
    }
}

Then the calling code looks like this:

DispatchQueue.global().async {
    NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_FW_ID) { fw_id in
        print("Read FirmwareID \(fw_id)")
        var sw_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_SW_ID) { sw_id in
            print("Read SotfwareID \(sw_id)")
            var ex_id = NFCUtils.sendI2CCommand(tag: self.tag!, command: NFCConstants.CONFIG_EX_ID) { ex_id in
                print("Read ExternalID \(ex_id)")
            }
        }
    }
}