UHF Integrated RFID Reader C# SDK & Guide

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0-windows</TargetFramework>
    <PlatformTarget>AnyCPU</PlatformTarget>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- Reference the core reader driver assemblies -->
    <Reference Include="ADDeviceReader">
      <HintPath>lib\ADDeviceReader.dll</HintPath>
      <Private>true</Private>
    </Reference>
    <Reference Include="ADDevice">
      <HintPath>lib\ADDevice.dll</HintPath>
      <Private>true</Private>
    </Reference>
    <Reference Include="ADBases">
      <HintPath>lib\ADBases.dll</HintPath>
      <Private>true</Private>
    </Reference>
    <Reference Include="ADNetConfig">
      <HintPath>lib\ADNetConfig.dll</HintPath>
      <Private>true</Private>
    </Reference>
  </ItemGroup>
</Project>

using System;
using ADSDK.Device;
using ADSDK.Bases;

public class RfidConnectionManager
{
    private Reader _reader;

    public bool ConnectReader(string readerIp = "192.168.1.116", int port = 49152)
    {
        try
        {
            // Instantiate driver with Adpar (Integrated fixed reader protocol)
            _reader = new Reader();

            // Configure TCP/IP client parameters
            var tcpParams = new TcpipParameters
            {
                IPAddress = readerIp,
                Port = port,
                ConnectTimeout = 3000 // 3 seconds timeout
            };

            // Attempt TCP socket handshake
            bool isConnected = _reader.Connect(tcpParams);
            if (isConnected)
            {
                Console.WriteLine($"[INFO] Successfully connected to Integrated Reader at {readerIp}:{port}");
                
                // Query hardware model & firmware version
                string version = _reader.GetFirmwareVersion();
                Console.WriteLine($"[INFO] Reader Firmware Version: {version}");
                return true;
            }

            Console.WriteLine($"[ERROR] Connection refused by reader at {readerIp}:{port}");
            return false;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"[EXCEPTION] Socket connection failed: {ex.Message}");
            return false;
        }
    }
}

public void ConfigureRfParameters(Reader reader, int powerDbm = 30)
{
    // 1. Set RF Transmission Power (+10 dBm to +30 dBm)
    // 30 dBm = 18m max vehicle range; 20 dBm = 5m calibrated parking lane
    bool powerSet = reader.SetTxPower(powerDbm);
    if (powerSet)
    {
        Console.WriteLine($"[INFO] RF Power successfully set to {powerDbm} dBm.");
    }

    // 2. Set Indian WPC Frequency Hopping (865.0 MHz - 867.0 MHz)
    // Region code 3 = Indian WPC Band (Channels 865.1, 865.7, 866.3, 866.9 MHz)
    bool regionSet = reader.SetRegion(3);
    if (regionSet)
    {
        Console.WriteLine("[INFO] Frequency band configured to Indian WPC ETA (865–867 MHz).");
    }

    // 3. Configure Single-Tag Inventory mode (Fast response for boom barriers)
    // Mode 0 = Fast single tag inventory; Mode 1 = Multi-tag anti-collision
    reader.SetWorkMode(0);
}

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using ADSDK.Device;

public class TagInventoryService
{
    private readonly ConcurrentDictionary<string, DateTime> _seenTags = new();
    private readonly TimeSpan _debounceWindow = TimeSpan.FromSeconds(3);

    public async Task StartInventoryLoopAsync(Reader reader, Action<string, int> onTagDetected, CancellationToken ct)
    {
        Console.WriteLine("[INFO] Starting continuous 6C tag inventory stream...");

        while (!ct.IsCancellationRequested)
        {
            try
            {
                // Execute EPC Gen2 inventory sweep
                var tagReport = reader.Identify6C();
                if (tagReport != null && tagReport.TagCount > 0)
                {
                    foreach (var tag in tagReport.Tags)
                    {
                        string epcHex = tag.EpcString;
                        int rssi = tag.Rssi;

                        // Check debounce window to avoid spamming boom barrier
                        DateTime now = DateTime.UtcNow;
                        if (_seenTags.TryGetValue(epcHex, out DateTime lastSeen))
                        {
                            if (now - lastSeen < _debounceWindow)
                                continue; // Skip duplicate within debounce TTL
                        }

                        _seenTags[epcHex] = now;

                        // Fire event callback for business logic
                        onTagDetected?.Invoke(epcHex, rssi);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[WARN] Inventory sweep warning: {ex.Message}");
            }

            // Yield thread for 30ms (~33 sweeps per second)
            await Task.Delay(30, ct);
        }
    }
}

public class BoomBarrierController
{
    private readonly Reader _reader;

    public BoomBarrierController(Reader reader)
    {
        _reader = reader;
    }

    public async Task TriggerBarrierOpenAsync(string vehicleEpc, int pulseDurationMs = 1000)
    {
        Console.WriteLine($"[ACCESS GRANTED] Vehicle EPC {vehicleEpc} authorized. Triggering Barrier Relay...");

        try
        {
            // Close relay contact (Relay Port 1 = Active / High)
            // Pins COM and NO are bridged, completing the barrier open circuit
            _reader.SetIOMode(relayId: 1, state: 1);

            // Hold open pulse for specified duration (typically 1000ms)
            await Task.Delay(pulseDurationMs);

            // Release relay contact (Relay Port 1 = Inactive / Low)
            _reader.SetIOMode(relayId: 1, state: 0);

            Console.WriteLine("[INFO] Relay returned to open state. Boom barrier cycle complete.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"[CRITICAL] Failed to pulse barrier relay: {ex.Message}");
        }
    }
}