For the past decade, I've been teaching Bluetooth LE to engineers, developers, and hobbyists. I've used Nordic dev kits, Silicon Labs boards, ESP32 modules, and half a dozen different IDEs. I've written courses that start with toolchain setup, SDK installation, and the inevitable "blinky" example before anyone writes a single line of wireless code.
It works. People learn. But I've always felt like there was friction in the process—friction that had nothing to do with Bluetooth LE itself.
When I started designing my new course, Bluetooth LE Unplugged, I wanted to remove that friction entirely. That decision led me to BleuIO, and it fundamentally changed how I think about teaching wireless protocols.
In this post, I'll share why I made this choice, what I discovered along the way, and why I think this approach might work better for certain types of learners.
The Problem I Kept Running Into
Here's a pattern I noticed over years of training:
A developer signs up to learn Bluetooth LE. They're motivated. Maybe they're building a mobile app that connects to a sensor, or prototyping a wearable, or evaluating wireless options for their company's next product.
Day one looks like this:
- Download an IDE (often several gigabytes)
- Install the SDK and toolchain
- Configure environment variables, paths, and board definitions
- Debug why the "hello world" example won't compile
- Flash the board, troubleshoot the debugger connection
- Finally—maybe—see an LED blink
And we haven't touched Bluetooth LE yet.
For experienced embedded engineers, this setup is routine. Annoying, maybe, but familiar. But for developers coming from web, mobile, or application backgrounds? It's a wall. And that wall has nothing to do with understanding advertising packets, connection intervals, or GATT services.
I found myself spending entire training sessions on toolchain issues instead of the protocol I was supposed to be teaching.
What I Was Looking For
When I started planning Bluetooth LE Unplugged, I had a few requirements:
- Immediate wireless interaction. Learners should be able to send and receive Bluetooth LE packets within minutes, not hours.
- No SDK installation. The learning environment should work out of the box, on any operating system, without downloading gigabytes of toolchains.
- See both sides. One of the hardest concepts in Bluetooth LE is understanding how Central and Peripheral roles work together. I wanted learners to control both sides of a connection simultaneously.
- Focus on concepts, not syntax. The commands should be readable and self-explanatory, not buried in vendor-specific APIs.
I evaluated several options: HCI-level tools, Python libraries, various USB dongles, and even browser-based Web Bluetooth approaches. Each had tradeoffs.
Then I found BleuIO.
Why BleuIO Clicked
BleuIO is a USB dongle that speaks Bluetooth LE through simple AT commands over a serial port. You plug it in, open a terminal, type AT+CENTRAL, and you're a Central device. Type AT+PERIPHERAL, and you're a Peripheral. No drivers on most systems. No SDK. No compilation. And while the simplicity makes it ideal for learning, BleuIO is also deployed in commercial and enterprise environments—industrial gateways, testing infrastructure, and rapid prototyping workflows.
Here's what scanning for nearby devices looks like:
AT+CENTRAL
AT+GAPSCAN=3That's it. Two commands, and you're seeing every Bluetooth LE device advertising around you.
What struck me wasn't just the simplicity—it was the readability. When a student types AT+GAPSCAN, they're literally invoking a GAP (Generic Access Profile) scan. The command names map directly to Bluetooth LE concepts. There's no abstraction layer hiding what's actually happening.
With AT commands, the abstraction is almost zero. You type a command, you see the result. Cause and effect are immediate and visible. Compare that to any SDK, where you're dealing with initialization structures, callback functions, error handling, and vendor-specific APIs—all before you've even started scanning.
The Dual-Dongle Insight
Here's where things got interesting.
BleuIO dongles are inexpensive enough that I could include two in the course kit. One acts as a Central, one as a Peripheral. You open two terminal windows side by side, and suddenly you're watching a Bluetooth LE conversation from both perspectives.
Let me show you what I mean. In one terminal (the Peripheral):
AT+PERIPHERAL
AT+ADVSTARTIn the other terminal (the Central):
AT+CENTRAL
AT+GAPSCAN=3
AT+GAPCONNECT=[address from scan]And just like that, you've established a Bluetooth LE connection—and you can see exactly what happened on both sides.
This was the moment I knew I had found the right approach. One of the most common points of confusion in Bluetooth LE is understanding the asymmetry between Central and Peripheral roles. Who initiates the connection? Who advertises? Who scans? Why does the Peripheral set the advertising interval but the Central set the connection parameters?
When you're staring at two terminals and watching the handshake happen in real time, these questions answer themselves.
What This Means for Learners
The BleuIO approach isn't right for every application. If you're building a battery-powered wearable, a compact sensor node, or any product where size, power consumption, and cost-per-unit matter, you'll need custom firmware on dedicated hardware. There's no escaping that.
But many Bluetooth LE applications don't have those constraints. If you're building a desktop tool, a test fixture, an industrial gateway, or a prototype that runs from USB power, BleuIO can take you all the way to production.
And even if you do need custom firmware eventually, here's what I've found: learning the protocol first makes the SDK easier later.
When you already understand how advertising and scanning work, how connections are established, and how GATT operations flow between Central and Peripheral—when you've controlled both sides of these interactions yourself—the SDK code starts to make sense. You're not learning the protocol and the implementation simultaneously. You're mapping familiar concepts onto new syntax.
The BleuIO approach works particularly well for:
- Mobile and web developers who want to understand what's happening on the other side of their Bluetooth LE stack
- Product managers and architects who need protocol literacy without becoming firmware engineers
- Embedded developers new to wireless who want to understand Bluetooth LE concepts before diving into vendor-specific SDKs
- Anyone who's tried the SDK-first approach and bounced off
The Tradeoffs
I want to be honest about the limitations, because I think that matters.
BleuIO's AT command interface doesn't expose everything. The underlying hardware doesn't support LE Coded PHY for long-range applications, and some advanced features like channel-specific scanning or Direct Test Mode aren't accessible via AT commands. For battery-operated products, compact form factors, or high-volume manufacturing where every cent and milliamp matters, you'll still need traditional embedded development with custom firmware.
But those constraints help focus attention on what matters most when learning: the protocol fundamentals. Advertising, scanning, connections, GATT services and characteristics, reading, writing, notifications—these concepts are the same whether you're working with AT commands or an SDK, whether you're prototyping or deploying in the field.
The difference is that with BleuIO, you can master those concepts in hours instead of days, and the knowledge transfers directly to whatever platform you use next.
What I Built
Bluetooth LE Unplugged is the course I wish I'd had when I started learning wireless protocols. It ships with two BleuIO dongles, and the entire curriculum is designed around the dual-terminal approach I described above.
You'll go from unboxing to your first Bluetooth LE connection in about ten minutes. No SDK installation. No toolchain configuration. Just plug in, open a terminal, and start sending commands.
From there, we build up systematically:
- How advertising and scanning actually work (and why the timing matters)
- Connection establishment from both Central and Peripheral perspectives
- GATT services, characteristics, and descriptors—what they are and how to interact with them
- Reading, writing, and notifications in practice
- Bonding and security basics
By the end, you'll have a working mental model of Bluetooth LE that will serve you whether you're writing Swift for iOS, Kotlin for Android, or C for embedded systems.
Final Thoughts
I'm not abandoning SDK-based training. For developers building battery-powered devices, compact wearables, or high-volume products, custom firmware is still the right path—and I have courses in the Bluetooth Developer Academy that cover exactly that.
But I've come to believe that the protocol and the implementation are two different things—and that learning them separately, in the right order, makes both easier. And for many applications, the AT command approach isn't just a stepping stone; it's a viable production solution.
BleuIO gave me a way to teach the protocol first, with tools that scale from learning to deployment. Bluetooth LE Unplugged is the result.
If you've struggled with Bluetooth LE in the past, or if you've been putting off learning it because the SDK setup felt overwhelming, I'd encourage you to try a different approach. Sometimes the fastest path forward is the one with the fewest obstacles at the start.
