ACR1552U SDK and Integration Guide
← Back to the smart card and NFC reader SDK guide
What is the ACR1552U SDK, and do you need it? The ACR1552U SDK is the official ACS developer kit for the ACR1552U USB NFC Reader IV: a reader, test cards, ACS tools, the reference manual and PC/SC sample code in Java, Visual Basic, C# and C++. You do not need it to start programming. The ACR1552U is a CCID and PC/SC reader, so any program that can call PC/SC (on Windows, winscard.dll) can read a card UID with the standard FF CA 00 00 00 Get Data command. The SDK saves time when you work with its extra features: ISO 15693 tags, the SAM slot, keyboard emulation and card emulation.
This guide covers what ACS puts in the SDK, how a Windows program talks to the reader, where the ACR1552U differs from other ACS NFC readers for a developer, and a short C# (.NET 8) example that reads a card UID. BSD Infotech is an independent ACS supplier and integrator in New Delhi, not the manufacturer. The SDK, drivers and manuals come from ACS, and we link to them rather than host copies.
What the Official ACR1552U SDK Contains
ACS sells the SDK as a boxed kit called the ACR1552U USB NFC Reader IV Software Development Kit. ACS lists these contents on its official ACR1552U SDK page (checked 16 Nov 2026):
| Part of the kit | What ACS lists |
|---|---|
| Reader | 1 x ACR1552U USB NFC Reader IV |
| Test cards | 5 x MIFARE 1K cards, 5 x ACOS3 contactless smart cards, 1 x ACOS6-SAM secure access module card |
| Tools and utilities | QuickView 2.13, Script Tool 5.02, Smart Card and Reader Tool, Keyboard Configuration Tool V100, ACS CCID PC/SC driver |
| Documents | Reference manual(s) |
| Sample code | Basic card and reader commands in Java (JDK 8), Visual Basic, Visual C# and Visual C++ (all three on .NET Framework 4.7.2) |
| SDK operating systems | Windows 10 and Windows 11 |
ACS describes the sample code as PC/SC-compliant code for programming both the reader and contactless cards. The Smart Card and Reader Tool in the kit includes NFC and NDEF tools that demonstrate card emulation and keyboard emulation.
How to get the SDK
The SDK is not a free download. ACS asks developers to request it through its sales enquiry page, linked from the SDK page. BSD Infotech can help you obtain it with the readers, or build the software for you. The ACS drivers, the reference manual and the free ACS tools are separate downloads on the ACS ACR1552U drivers and manuals page, so you can start without the kit.
What the sample code covers
In the SDK package version 1.01 (dated August 2024) that BSD Infotech holds, the sample code is split into device programming (reader commands) and card programming. The card programming folders cover ACOS3, ACOS6-SAM, ISO 15693, MIFARE Classic, MIFARE Ultralight C, NTAG and other contactless cards, plus a simple PC/SC example and a card polling example. The C# set also has a MIFARE DESFire sample. That package also contains Linux, macOS, Android and iOS/iPadOS folders with drivers and tool builds. ACS may change the contents between versions, so check the list that comes with your copy.
PC/SC Integration on Windows
On Windows, applications reach smart card readers through the Smart Card service and winscard.dll. Install the ACS PC/SC driver from the ACS page first. The ACR1552U driver and software guide has the steps. The ACS reference manual describes two paths into the reader:
APDU path: SCardTransmit
Used for APDUs to the card and for ACS pseudo-APDUs (class byte FF), such as Get Data, MIFARE Load Key / Authenticate / Read / Update, and the ISO 15693 block commands. A card must be on the reader and connected.
Flow: EstablishContext → ListReaders → Connect → Transmit → Disconnect
Escape path: SCardControl
Used for commands to the reader itself, which start with E0: firmware version, LED and buzzer, polling options, keyboard emulation settings and card emulation. ACS's example opens the reader in direct mode and uses control code 0x310000 + 3500 * 4 (that is, SCARD_CTL_CODE(3500)).
Flow: EstablishContext → ListReaders → Connect → Control → Disconnect
Steps in every program
- Establish a context with
SCardEstablishContext. Expected result: return code 0. - List the readers with
SCardListReadersand pick the ACR1552U contactless interface. ACS's examples use the name "ACS ACR1552 1S CL Reader PICC 0" and note that the name depends on your reader, so match on part of it rather than the full string. - Connect with
SCardConnectwhile a card is on the reader. ACS says to connect to the PICC (contactless) interface. The reader builds an ATR for the card it found. - Send commands with
SCardTransmit. Each reply ends with a two-byte status word;90 00means success. - Disconnect and release with
SCardDisconnectandSCardReleaseContext.
Cards that speak ISO 14443-4 (for example DESFire and ACOS3) receive your APDUs unchanged; the reader wraps them in the contactless protocol. For MIFARE Classic and Ultralight, which do not understand APDUs, you use ACS's pseudo-APDUs instead. For PC/SC in general, CCID and the other ACS readers, see the smart card and NFC reader SDK guide.
How the ACR1552U Differs for Developers
The basic PC/SC code is the same as for other ACS contactless readers. These are the features ACS documents for the ACR1552U that change what your program has to do. Command details are from the ACS ACR1552U Series reference manual.
ISO 15693 (vicinity) tags
The ACR1552U reads ISO 15693 tags such as NXP ICODE as well as ISO 14443 cards. For these tags ACS defines pseudo-APDUs with class FF and instruction FB: read and write a single block, read and write multiple blocks, and get system information. Get Data with FF CA 80 00 00 returns the DSFID and the 8-byte UID of an ISO 15693 tag. The manual states that these ISO 15693 commands need ACR1552U firmware 1.03.00 or later. BSD Infotech has not yet tested an ISO 15693 tag on this reader.
SAM slot
The reader has one SAM slot for an ISO 7816 Class A secure access module. ACS describes it as being for key diversification and mutual authentication. To your program the SAM is a contact card: you send it APDUs with SCardTransmit, as for any card. The SDK includes an ACOS6-SAM card and samples. The ACS reference manual lists the ACOS6-SAM commands it supports, and ACS supplies the full ACOS6-SAM manual through its representatives. Which SAM you use, and how, depends on your card scheme. BSD Infotech has not yet tested a SAM in this reader.
Keyboard emulation
In keyboard emulation mode the reader types the card UID into whichever program has focus, like a USB keyboard. ACS's Keyboard Configuration Tool switches it on, and the reference manual has escape commands for the output format, separator characters, keyboard layout and host interface. The host interface setting can be HID keyboard only, CCID reader only, or both. If it is set to keyboard only, PC/SC programs, including the example below, will not find the reader. Check this first when a reader that worked suddenly disappears from the reader list.
Card emulation
In card emulation mode the reader behaves like a contactless card towards a phone or another NFC reader. The ACS reference manual describes emulating an NFC Forum Type 2 Tag (MIFARE Ultralight type) or a FeliCa card, entered through an escape command. The emulated tag's UID can be set, and the Ultralight lock bytes are not supported. ACS's NFC and NDEF tools in the Smart Card and Reader Tool demonstrate it. Put the reader back in read/write mode before switching to a different emulation type.
| Task | API call | Command (hex, from the ACS manual) |
|---|---|---|
| Card UID / serial number | SCardTransmit | FF CA 00 00 00 |
| ATS of an ISO 14443-4 Type A card | SCardTransmit | FF CA 01 00 00 |
| ISO 15693 read single block | SCardTransmit | FF FB 00 00 02 20 <block> |
| Reader firmware version | SCardControl | E0 00 00 18 00 (reply starts E1 00 00 00, then the length and ASCII text) |
| Keyboard emulation and card emulation settings | SCardControl | E0 00 00 9x ... and E0 00 00 40 ...: see the manual before using them, as they change how the reader behaves |
C# Example: Read a Card UID with the ACR1552U (.NET 8)
Language: C# 12 on .NET 8, Windows only (P/Invoke to winscard.dll). Prerequisites: Windows 10 or 11, the .NET 8 SDK, the ACR1552U plugged in with the ACS PC/SC driver installed and keyboard-only mode switched off, and a card on the reader (for example MIFARE Classic 1K or NTAG). Create a console app with dotnet new console and replace Program.cs with the code below. It only reads the UID and writes nothing to the card.
Not yet tested on hardware. This example uses the standard Windows PC/SC functions and the Get Data command as the ACS ACR1552U reference manual documents them. BSD Infotech has compiled it for .NET 8 but has not yet run it with an ACR1552U and a card, so treat it as a starting point.
// C# 12, .NET 8, Windows only (winscard.dll). Not yet tested on hardware.
using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
const uint SCARD_SCOPE_USER = 0, SCARD_SHARE_SHARED = 2, SCARD_PROTOCOL_T0 = 1,
SCARD_PROTOCOL_T1 = 2, SCARD_LEAVE_CARD = 0;
Check(Pcsc.SCardEstablishContext(SCARD_SCOPE_USER, IntPtr.Zero, IntPtr.Zero, out IntPtr ctx), "EstablishContext");
try
{
// 1. List readers (the first call returns the buffer size in characters).
uint chars = 0;
Check(Pcsc.SCardListReaders(ctx, null, null, ref chars), "ListReaders (size)");
var buf = new byte[chars * 2];
Check(Pcsc.SCardListReaders(ctx, null, buf, ref chars), "ListReaders");
string[] readers = Encoding.Unicode.GetString(buf).Split('\0', StringSplitOptions.RemoveEmptyEntries);
// 2. Pick the ACR1552U contactless (PICC) interface.
string? reader = readers.FirstOrDefault(r => r.Contains("ACR1552", StringComparison.OrdinalIgnoreCase)
&& r.Contains("PICC", StringComparison.OrdinalIgnoreCase))
?? readers.FirstOrDefault(r => r.Contains("ACR1552", StringComparison.OrdinalIgnoreCase));
if (reader is null) { Console.WriteLine("No ACR1552U found. Readers: " + string.Join(", ", readers)); return; }
Console.WriteLine("Reader: " + reader);
// 3. Connect (a card must be on the reader).
Check(Pcsc.SCardConnect(ctx, reader, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,
out IntPtr card, out uint protocol), "Connect");
try
{
// 4. Get Data: FF CA 00 00 00 -> UID + 90 00
byte[] resp = Transmit(card, protocol, new byte[] { 0xFF, 0xCA, 0x00, 0x00, 0x00 });
if (resp.Length >= 2 && resp[^2] == 0x90 && resp[^1] == 0x00)
Console.WriteLine("UID: " + Convert.ToHexString(resp, 0, resp.Length - 2));
else
Console.WriteLine("Get UID failed, status: " + Convert.ToHexString(resp));
}
finally { Pcsc.SCardDisconnect(card, SCARD_LEAVE_CARD); }
}
catch (InvalidOperationException ex) { Console.WriteLine(ex.Message); }
finally { Pcsc.SCardReleaseContext(ctx); }
static byte[] Transmit(IntPtr card, uint protocol, byte[] apdu)
{
var pci = new Pcsc.SCARD_IO_REQUEST { dwProtocol = protocol, cbPciLength = (uint)Marshal.SizeOf<Pcsc.SCARD_IO_REQUEST>() };
var resp = new byte[258];
uint len = (uint)resp.Length;
Check(Pcsc.SCardTransmit(card, ref pci, apdu, (uint)apdu.Length, IntPtr.Zero, resp, ref len), "Transmit");
return resp[..(int)len];
}
static void Check(int rc, string step)
{
if (rc != 0) throw new InvalidOperationException($"{step} failed: 0x{rc:X8}");
}
static class Pcsc
{
[StructLayout(LayoutKind.Sequential)]
public struct SCARD_IO_REQUEST { public uint dwProtocol; public uint cbPciLength; }
[DllImport("winscard.dll")]
public static extern int SCardEstablishContext(uint scope, IntPtr reserved1, IntPtr reserved2, out IntPtr context);
[DllImport("winscard.dll")]
public static extern int SCardReleaseContext(IntPtr context);
[DllImport("winscard.dll", EntryPoint = "SCardListReadersW", CharSet = CharSet.Unicode)]
public static extern int SCardListReaders(IntPtr context, string? groups, byte[]? readers, ref uint chars);
[DllImport("winscard.dll", EntryPoint = "SCardConnectW", CharSet = CharSet.Unicode)]
public static extern int SCardConnect(IntPtr context, string reader, uint shareMode, uint protocols,
out IntPtr card, out uint activeProtocol);
[DllImport("winscard.dll")]
public static extern int SCardDisconnect(IntPtr card, uint disposition);
[DllImport("winscard.dll")]
public static extern int SCardTransmit(IntPtr card, ref SCARD_IO_REQUEST sendPci, byte[] send, uint sendLength,
IntPtr recvPci, byte[] recv, ref uint recvLength);
}
Expected result: two lines, the reader name (for example something like "ACS ACR1552 1S CL Reader PICC 0") and UID: followed by the card UID in hex. MIFARE Classic 1K cards usually have a 4-byte UID and NTAG cards a 7-byte UID. For a FeliCa card the same command returns the 8-byte IDm, according to the ACS manual.
If it fails: the program prints the failing step and the PC/SC error code; see the table below. Close QuickView, the Smart Card and Reader Tool and any other card program before you run it, because a program that holds the reader can block your connection.
Troubleshooting ACR1552U Integration
| What you see | Likely cause | What to do |
|---|---|---|
"No ACR1552U found", or ListReaders (size) failed: 0x8010002E (no readers available) | Driver not installed, Smart Card service stopped, or the reader is in keyboard-only mode | Install the ACS driver, check that the reader shows under "Smart card readers" in Device Manager, and set the host interface back to CCID (or CCID + keyboard) with the Keyboard Configuration Tool. |
Connect failed: 0x8010000C (no smart card) or 0x80100069 (card removed) | No card on the reader, or the card moved | Place the card flat on the reader and run again. |
Connect failed: 0x8010000B (sharing violation) | Another program has the reader open exclusively | Close other card tools and try again. |
Status 6A 81 for an APDU | The card supports neither ISO 14443-4 nor the Innovatron protocol, so it cannot take a plain APDU | Use the ACS pseudo-APDUs for that card type (for example the MIFARE or ISO 15693 commands). |
| DESFire native commands fail right after the card is tapped | ACS notes that Windows Smart Card Plug and Play may send APDUs when a card arrives, which switches a DESFire card into ISO APDU mode until it is reset | Use the ISO-wrapped DESFire commands, or reset the card before sending native commands. ACS says Windows usually resets the card after about 10 seconds of inactivity. |
| ISO 15693 commands return an error | Older reader firmware | Read the firmware version (escape command E0 00 00 18 00, or QuickView). ACS lists firmware 1.03.00 or later for these commands on the ACR1552U-M. |
Not sure whether the problem is the reader, the driver or your code? Test the reader with a ready-made tool first. The ACS reader test tools and utilities page lists the free ACS tools and the BSD utilities. If a tool reads the card and your program does not, look at your code.
Sources
SDK contents, reader features and download names were checked on the official ACS pages on 16 Nov 2026. Command details are from the ACS ACR1552U Series reference manual (version 1.05, from the SDK package version 1.01). ACS currently lists version 1.09 of the manual on its download page.
- ACS: ACR1552U USB NFC Reader IV Software Development Kit
- ACS: ACR1552U drivers, reference manual and technical specification
BSD Infotech is an independent ACS supplier and integrator, not the manufacturer. ACS, the ACS logo and ACS product names belong to Advanced Card Systems Ltd. MIFARE, DESFire, NTAG and ICODE are trademarks of NXP B.V.; FeliCa is a trademark of Sony Group Corporation.
