Reverse-engineering the DJI Mic 3 USB protocol
The DJI Mic 3 receiver has a second, vendor-specific USB interface for its settings. Here's how I found it, how its frames work, and what I still don't know.
The problem
The DJI Mic 3 is a wireless lavalier kit: two transmitters and a receiver. Plug the receiver into a computer over USB-C and it shows up as a normal USB microphone (how to connect it). That part just works.
Changing anything does not. Gain, noise cancelling, 32-bit float, starting the transmitters’ internal recording: all of that lives on a touchscreen the size of a stamp, or in DJI Mimo on your phone. If the mic sits on your desk for a podcast, a stream or a class, you end up reaching for the phone to change a setting on a device that’s already plugged into your computer.
So I wanted a desktop app that talks to the receiver directly. That meant learning its USB protocol.
Standing on someone else’s work
I didn’t start from zero. ShadowBitBasher/DJI-Mic-Control already controlled the DJI Mic Mini from a computer: a Rust + Tauri app that had mapped the Mic Mini’s protocol, including a firmware update that changed it halfway through (the project calls the two dialects v1 and v2). Its PROTOCOL.md is the reason any of this was possible.
My fork adds the Mic 3. Most of what follows is the Mic 3 part, but you need the Mic Mini part to read it.
Finding the right door
The Mic Mini exposes its control channel on interface 6, with bulk endpoints 0x06 (out) and 0x86 (in). The Mic 3 enumerates as vendor 0x2ca3, product 0x4015, and its control channel is somewhere else.
Listing the descriptors shows a vendor-specific interface instead:
Interface 4 class ff/f0/01 "com.dji.mic"
alt 0: no endpoints
alt 1: bulk OUT 0x01, bulk IN 0x81
The name looks like an iOS External Accessory protocol string, so I expected a handshake before the receiver would say anything. There isn’t one. Claim interface 4, select alternate setting 1, and status pushes start flowing.
Two details that cost time:
- In four-channel mode the receiver re-enumerates as
0x4115. Switching channel mode is a disconnect, and the app has to find the device again (more on the modes in mono, stereo or 4CH). - The Mic Mini 2S receiver uses the same ids as the Mic 3. More on telling them apart below.
The frame
Everything on the wire uses DJI’s DUML framing. Here’s a real command, 32-bit float recording on, broadcast to every transmitter:
55 16 04 fc 02 5a 01 01 40 5b 01 02 ff ff 00 00 0c 00 01 01 a7 73
| Bytes | Value | Meaning |
|---|---|---|
| 0 | 55 |
Start of frame |
| 1 | 16 |
Total length (22) |
| 2 | 04 |
Version |
| 3 | fc |
Header CRC-8 |
| 4–5 | 02 5a |
Command set (audio), attribute flags |
| 6–7 | 01 01 |
Sequence number, little-endian |
| 8 | 40 |
ACK requested |
| 9–10 | 5b 01 |
Constant |
| 11 | 02 |
Target-addressed command |
| 12–13 | ff ff |
Target: every transmitter |
| 14–15 | 00 00 |
Constant |
| 16–17 | 0c 00 |
Command 0x000c (32-bit float), little-endian |
| 18–19 | 01 01 |
Payload length 1, value 1 (on) |
| 20–21 | a7 73 |
CRC-16 |
A few things worth knowing:
The header CRC-8 is just a function of the length. It’s computed over the first three bytes, and two of them are constant. The original project’s notes point out that on old firmware it only ever took two values, which made it look like a direction or routing flag. It isn’t. With newer firmware sending many frame lengths, the pattern becomes obvious.
The CRC-16 is checked by residue. It uses the reflected 0x8408 polynomial (the X.25 one). Instead of comparing a computed checksum against the last two bytes, you run the CRC over the whole frame, checksum included, and check that it lands on a fixed value. v1 firmware starts at 0x0000 and lands on 0xbb01. v2 starts at 0x3692 and lands on 0x0000. Same polynomial, different seed. Building a frame means finding the two bytes that hit the residue:
/// Return the two CRC bytes that make `body` checksum to `residue` from `init`.
pub fn crc_bytes(body: &[u8], init: u16, residue: u16) -> [u8; 2] {
let v = checksum(body, init);
for b0 in 0u16..=255 {
let v1 = step(v, b0 as u8);
let target = residue ^ (v1 >> 8);
if let Some(idx) = TABLE.iter().position(|&t| t == target) {
let b1 = (v1 ^ idx as u16) & 0xff;
return [b0 as u8, b1 as u8];
}
}
unreachable!("CRC table does not cover every residue byte")
}
The Mic 3 speaks v2. Same framing, same CRC seed, same 22-byte command shape with a 16-bit target: 0x0000 is the receiver, 0xffff is every transmitter, 0x0001/0x0002 is one transmitter. The only reliable way to know the dialect is the status push: byte 11 is 0x00 on v1 and 0x03 on v2.
The method: change one thing, diff the push
The receiver pushes its whole state over and over. So the method is boring and it works: change exactly one thing, and look at which bit moved.
For the Mic 3 I wrote a throwaway probe, about 60 lines of Rust on top of nusb. It claims interface 4, selects alt 1, sends a list of hand-built frames one second apart, and prints a status push only when it differs from the previous one. Flip a setting on the receiver’s screen, or send a command, and you get one line with the new bytes. Everything else is noise you never see.
Candidate command ids came from the Mic Mini’s v2 table and from two other open-source projects that had poked at the Mic 3, usokawa/dji-mic-mo and SanMurakami/mic3-bridge. Every one went through the same loop: send it, wait for the ACK, check the status push. A setting only made it into the app when the write and the readback agreed.
Some of what came out of it, on a Mic 3 receiver with firmware 03.01.00.10 and two transmitters:
| Setting | Cmd | Values | Where it reads back |
|---|---|---|---|
| Audio channels | 0x0008 |
00 mono, 02 stereo, 04 four-channel |
status offset 21 |
| Receiver gain | 0x0039 |
signed dB: −12, −6, 0, +6, +12 | status offset 22, signed |
| Headphone (monitoring) gain | 0x0026 |
signed dB, −12…+12 | status offset 27, signed |
| Lossless audio | 0x0027 |
00 off, 01 on |
status offset 20, bit 0x04 |
| 32-bit float (TX) | 0x000c |
00 off, 01 on |
slot +9, bit 0x08 |
| Internal recording (TX) | 0x0002 |
00 stop, 01 start |
slot +9, bit 0x10 |
| Mute (TX) | 0x0009 |
00 off, 01 on |
slot +6, bit 0x04 |
Note the gains: the value is the dB number itself, as a signed byte. 0x06 is +6 dB, 0xfa is −6. No scaling table.
What the Mic 3 does differently
The Mic Mini knowledge transferred almost completely. The differences are where the bugs were.
ACKs carry a result. On the Mic Mini, byte 11 of the 14-byte ACK is always 0x00. On the Mic 3 it’s 0x00 when the command was applied and 0xff when the receiver refused it. That changed the app’s design: a refused setting now shows an error instead of failing silently.
The first command sometimes vanishes. The first frame written after opening the interface is sometimes neither applied nor acknowledged. The device layer now waits a few reads for the ACK and re-sends, twice at most. Boring fix, but it’s the difference between a button that works and one you have to click twice.
A keep-alive you can ignore. A 14-byte frame ending in 00 5b 04 06 arrives about twice a second. It needs no reply. With no transmitter connected, the status push itself drops to about once a second.
Some settings are mirrored. Address 32-bit float, vibration or loop recording to one transmitter and both change. Voice tone, input gain, mute and recording really are per transmitter. The app sends the mirrored ones as a broadcast so the UI never lies about which transmitter has what.
Room for four transmitters. On the Mic 3 the unit byte in each transmitter slot is a bitmask, 1, 2, 4, 8 for TX1 to TX4, not an index.
Recording time. Slot +14 and +16 hold each transmitter’s total and remaining internal recording time, 16-bit little-endian, in tenths of an hour.
Clock sync. Internal recordings are timestamped by the transmitter’s clock, so the app sets it on connect: command 0x0033 to the receiver, payload 09 YY MM DD hh mm ss 00 in local time.
Safety Track is gone. The Mic Mini 2S has it; the Mic 3 doesn’t. 0x0021 is refused. Channel-mode values 0x03 and 0x06 are acknowledged but change nothing, and 0x03 makes the receiver re-enumerate and come back in mono. “ACKed” does not mean “did something”.
The scary one: 0x0007
dji-mic-mo uses command 0x0007 with value 0x01 to format the transmitter’s internal storage.
While mapping commands, I sent 0x0007 with value 0x00 once, by mistake. The receiver acknowledged it. Storage capacity didn’t change. But bit 0x04 of slot +9 has been set on that transmitter ever since, and I still don’t know what it means.
Two rules came out of that. The app never sends 0x0007. And for receiver and transmitter combinations I can’t test myself, the app only sends commands that someone else has confirmed on real hardware, and checks the device’s answer.
Telling receivers apart
USB ids aren’t enough. The Mic 3 and the Mic Mini 2S share 2ca3:4015; the Mic Mini and DJI’s Mobile Receiver share 2ca3:4011.
The fix came from piedol/lavdeck, which documented a read-only get version request for the Mobile Receiver: command set 0x00, id 0x01, empty payload. It works on the Mic 3 too. The receiver answers with its hardware name, DM303_RX, padded with NULs, followed by its firmware version with the bytes reversed (0a 00 01 03 is 03.01.00.10). The Mobile Receiver answers DJI MIC MINI RX.
The app opens a receiver with the model its USB id suggests, sends get version, and switches to the right model as soon as the answer arrives. The transport is the same within each family, so the open interface is kept.
What I still don’t know
This is the honest part. Things that are unidentified or unconfirmed:
- Environment. Status offset 20 bit
0x01says whether the receiver is set to indoors or outdoors (it matches mic3-bridge), but I haven’t found a command that writes it. The app shows it read-only. - Most of the status header. Of the 52-byte header, I understand a handful of offsets. The rest are constants nobody has identified yet.
- The receiver’s battery. Offset 21 bits
0xe0look like a 1 (full) to 7 gauge and bit0x10like “charging”: it reads0x51(gauge 2, charging) when powered over USB. Plausible, not proven. - Odd constant bits in the transmitter slot, like bit
0x20at+7, whose purpose is unknown. - Two refused commands.
0x003eand0x003d(automatic recording and the internal file option on the Mini 2S) are refused by the Mic 3 for every target. - The capability request (command set
0x5b, id0x12) only returns three one-byte flags per unit. Not a usable feature list. - Not mapped yet: timecode, choosing the monitoring source, formatting (on purpose).
- The DJI Mic 2’s own receiver and the original DJI Mic (2021): no USB control interface has been documented for either. The Mic 2’s USB ids seen in the wild are file-transfer modes.
If you have a Mic 3 or a Mini 2S and know any of these, a pull request to PROTOCOL.md is the best gift.
The result
All of this became Mic Control: a free, open-source desktop app that controls the receiver over USB. Live meters with a clip warning, gain, noise cancelling, 32-bit float, mute and record on every transmitter at once, battery and recording time, one-click scenes. It never touches the audio stream: that keeps going through the normal USB audio interface while you change settings.
Where it stands, honestly: tested on a Mac with a Mic 3 (firmware 03.01.00.10, two transmitters). The macOS build is signed and notarized. Windows and Linux builds exist but haven’t been tested with a receiver yet, and Mic Mini support comes from the original project.
- Download and setup: miccontrol.app
- Code, public domain: github.com/qubik89/DJIMic3
- The full protocol notes: PROTOCOL.md
Credit where it’s due: ShadowBitBasher for the original app and protocol work, and the authors of dji-mic-mo, mic3-bridge, lavdeck, lavboard and DJI-Mic-Utility, whose hardware-tested notes made the Mic 3 part much shorter. Mic Control is an independent project, not affiliated with DJI.