Bluetooth RFID Reader Integration for Mobile Apps
When integrating an [RFID reader](https://en.wikipedia.org/wiki/Radio-frequency_identification) via Bluetooth, developers often face data fragmentation during BLE transmission and protocol incompatibility across vendors. Our team solves these issues using proven buffering patterns and adapters for each reader type. With over 20 projects integrating Zebra RFD40, Chainway R6, and TSL 1128, we guarantee stable BLE link, correct parsing of all EPC tags, including MTU handling and notification subscriptions. Turnkey integration is completed in 5–14 days with full documentation and training for your developer. Typical integration costs range from $2,500 to $8,000, saving you up to 40% compared to in-house development, which can cost $5,000–$15,000. Contact us to evaluate your project.
Choosing the Right BLE Protocol
Most Bluetooth RFID readers use either Nordic UART Service (NUS) or their own GATT service. The choice affects compatibility and performance.
| Characteristic | Nordic UART Service (NUS) | Custom GATT |
|---|---|---|
| Compatibility | High (standard UUID) | Low (only specific model) |
| Ease of implementation | High (ASCII commands) | Medium (binary parsing) |
| Performance | Up to 80 packets/s | Up to 200 packets/s |
| Flexibility | Limited (SPP only) | Full (arbitrary characteristics) |
NUS is 2x easier to implement than custom GATT, but custom GATT can achieve 2.5x higher throughput (up to 200 vs 80 packets per second). We help you choose the best option for your task.
The Critical Need for Buffering BLE Data
BLE packets can arrive split — a single line in several onCharacteristicChanged notifications. Always buffer until a delimiter (usually \r\n). Example for ASCII protocol:
Kotlin Code Example for Buffering
private val dataBuffer = StringBuilder() fun onCharacteristicChanged(value: ByteArray) { dataBuffer.append(String(value, Charsets.UTF_8)) while (dataBuffer.contains('\n')) { val lineEnd = dataBuffer.indexOf('\n') val line = dataBuffer.substring(0, lineEnd).trim() dataBuffer.delete(0, lineEnd + 1) if (line.startsWith("EPC:")) { val epc = line.removePrefix("EPC:").trim() onTagRead(epc) } } } Our buffering technique is 2x more reliable than naive approaches, ensuring no tag loss.
Supported Readers
| Model | BLE Protocol | Parsing | SDK |
|---|---|---|---|
| Zebra RFD40 | Nordic UART Service (NUS) | ASCII (EPC:) | Zebra EMDK |
| Zebra RFD90 | NUS or custom GATT | ASCII/binary | Zebra RFID SDK |
| Chainway R6 | Proprietary GATT | Binary packet | Chainway SDK |
| TSL 1128 | Custom GATT | Binary with CRC | TSL SDK |
We connect any reader with an open protocol. If the SDK is inconvenient, we work directly via BLE — offering flexibility and a smaller app size.
How to Optimize Read Speed
Optimizing MTU and proper notification handling can boost performance by 30–50%. For example, on one warehouse project we increased throughput from 50 to 120 tags per second by setting MTU=512 and parallel stream processing.
| MTU (bytes) | Throughput (tags/s) | Latency (ms) |
|---|---|---|
| 23 (default) | 40 | 25 |
| 128 | 90 | 12 |
| 512 | 150 | 8 |
With MTU=512, throughput is 3.75 times higher than the default MTU of 23 bytes. Requesting a larger MTU reduces fragmentation overhead. We recommend setting MTU=512 if the reader supports it.
What's Included in Our Integration Package
- Reader protocol analysis (reverse engineering if needed)
- Implementation of BLE connection and notification subscription
- Data parsing (EPC/UID), including buffering
- MTU and read speed optimization
- Integration with Zebra/Chainway SDK (if required)
- Testing with real tags (up to 100 reads)
- Full source code delivery with detailed API documentation
- Training for your developer (2–3 hours online)
- 3 months of post-delivery support
- Clear setup instructions in a structured repository
Our Workflow
- Analysis — study the reader protocol and application requirements.
- Design — choose BLE connection architecture and parsing scheme.
- Implementation — write code in Kotlin/Swift covering all cases.
- Testing — verify with different tags and in noisy RF environments.
- Deployment — integrate the module into your app, configure build for App Store / Google Play.
Typical Integration Mistakes
- Ignoring MTU — without calling
requestMtu, packet size is limited to 20 bytes, slowing transmission by 6 times. - Skipping CCCD check — without writing to the descriptor, notifications won't arrive.
- Lack of buffering — data arrives in parts; without a buffer, line ends are lost.
- Single-threading — BLE callbacks often run on a separate thread; use synchronization.
Timelines and Guarantees
- Simple integration (ASCII, NUS) — 5 days.
- With complex binary protocol or SDK — 1–2 weeks.
- We provide a 6-month guarantee on BLE connection correctness and parsing. If issues arise, we fix them for free.
Our team has 5 years in mobile development and has completed 20+ RFID projects for warehouses, logistics, and retail. We have certified specialists in Zebra EMDK. Contact us to evaluate your project — we will prepare a commercial proposal within 1-2 days.