_{A Version 1 transmitter with Malcolm's Goblin RAW 420.}

LockDownRadioControl (LDRC) is a free, open-source 16-channel radio control system for models of all kinds: a transmitter and a receiver that you build yourself. Malcolm Messiter started it in the lockdown of May 2020. He and his club friends have flown many models with it since.

LDRC does not try to speak every protocol or offer every option. It does what you need to fly, cleanly and reliably, so it is quick to learn and quick to use. (It still speaks SBUS, PWM and MSP, for flight controllers and servos.)

Switch on a model and the transmitter loads its memory. Most systems only warn you, or stop you, when the wrong memory is loaded. LDRC finds the right one.

Back up a model memory to the transmitter's card in one touch, and restore it just as easily. Experiment, and undo it if you need to.

Copy a model memory to another transmitter over the radio link: no cables, no swapping cards, no computer. The model's ID goes with it, so the other transmitter loads it by itself too. Handy for buddy-box lessons, so instructor and pupil fly the same set-up.

Buddy-box with no extra modules or dongles. Hand-over is instant. When the instructor takes over to save the model, there is no hesitation. A "nudge" mode lets the pupil fly while the instructor nudges.

The telemetry page shows the packet rate (now and average), lost packets, the longest and average reconnection times, swaps between the receiver's radios, and a chart of how long each reconnection took.

If your helicopter runs Rotorflight (a Nexus, or any flight controller with Rotorflight 2.2 or 2.3), you can change PIDs, rates and the governor from the transmitter at the field. No laptop, except for the first set-up.

• 16 channels, for planes, gliders, helicopters and more.
• Flown since 2020 by Malcolm and his friends.
• Cost: Malcolm's 2020 estimate was about £120 for a transmitter. Prices have risen: today the Teensy, the Nextion screen and the sticks alone cost about £135–£155. A receiver is about £35 (prices vary by shop).
• Transmitter: a Teensy 4.1 (600 MHz ARM Cortex-M7), an Ebyte ML01DP5 radio, a Nextion NX8048P050 5-inch touchscreen, FrSky M9 Hall-sensor sticks and FrSky X9D Plus trims.
• Receiver: a Teensy 4.0 and one or two Ebyte ML01SP4 radios.
• Cases: 3D-printed in the plastic you prefer. Malcolm uses PETG.
• Everything is here: the code for the transmitter, its screen and the receiver; the Gerbers for the circuit boards; the STL files for the cases; the help texts for the SD card. There is nothing to stop anyone building one.
• Help: email Malcolm at mmessiter@gmail.com. He will be happy to help.

_{A Version 1 transmitter and receiver.}

Along the way:

• PPM has gone. Nobody used it any more, and removing it freed memory and pins.
• Gliders: a variometer sounds as the model climbs or sinks, to help find thermals.
• Helicopters: Malcolm first planned his own stabilisation. Then he found Rotorflight, and added good support for it instead: telemetry, and PIDs, rates and the governor edited from the transmitter, over MSP.

• 16 channels, about 2,000 steps each (whole microseconds, 500 to 2,500), sent in 12-bit slots.
• 4 banks (flight modes), each with its own curves.
• 32 mixes, for inputs or outputs.
• 90 model memories, and as many backups as the card holds.
• Three rates ("dual rates", but three).
• 500 packets a second. Fewer while buddy-boxing, because the instructor's transmitter also talks to the pupil's.
• Frequency hopping across 83 channels of the 2.4 GHz band, about 100 hops a second.
• Very small packets: only the channels that changed are sent, so fewer clash with others.
• Wireless buddy box, with a "nudge" mode for teaching.
• AMS: the right model memory loads by itself when you connect.
• The pupil's transmitter loads the same model as the instructor's.
• Wireless model sharing between transmitters, with no SD cards removed.
• Telemetry: the model's battery volts. With the receiver's sensors: GPS position, speed, altitude, heading and distance from home, barometric height.
• Spoken messages and other sounds.
• Your own channel names, inputs and outputs.
• 5-point curves for every channel in every bank: straight, smoothed or expo.
• Failsafe.
• 4 top switches you give jobs to (banks, motor, safety, rates, buddy); four more switches or knobs drive channels 5–8.
• Digital trims, subtrim, reverse, servo speed, macros, a motor timer, log files.
• Receiver: up to 11 PWM servo outputs, each with its own frame rate and centre; SBUS.
• Rotorflight (Nexus and others): head speed, capacity used, flight-pack volts and more on the screen, and PIDs, rates and the governor changed at the field.
• A variometer for gliders.
• Help on every page.

With Version 2: a Version 1 receiver binds and flies with a Version 2 transmitter. Rotorflight editing from a Version 2 transmitter needs a Version 2 receiver. A Version 1 transmitter can send its models to a Version 2 over the air (tested), and two Version 2s swap them. To move up, keep your models, main board, sticks and switches; print the Version 2 case front (it holds the new screen), fit the screen, and update the firmware. Keep your Teensy's card. Build one's Version 1 box has the steps.

If you are starting now, build Version 2 (LDRC_V2, Build one). The steps there cover this main board, the sticks, the switches and the shared case parts.

What is in this repository:

Flash the firmware: with PlatformIO (pio run -e teensy41 -t upload in TransmitterCode, pio run -e teensy40 -t upload in ReceiverCode), or load the ready-built .hex files with the Teensy Loader.

Load the screen: open TX_NEXTION.HMI in the Nextion Editor, compile it, and load it onto the Nextion.

Before the first flight, blades off, do every check in Build one → Testing before the first flight: failsafe and range test included.

LDRC's radio protocol is its own, and it is open. It is low-latency and built for very high reliability. It is described here because it is the most important part of any control system: it must simply never fail.

Each transmitter and receiver is identified by a hardware ID derived from the MAC address of its Teensy 4.x microcontroller. (Version 2 receivers use their ESP32-S3's MAC address the same way.)

Binding sets up a trusted link between one transmitter and one receiver.

• Unbound: a receiver in bind mode listens for a reserved default pseudo-ID. A transmitter in bind mode sends with that pseudo-ID.
• Handshake: once they connect on the pseudo-ID:
  1. The transmitter sends its unique hardware ID.
  2. The receiver stores the transmitter's ID in non-volatile memory.
  3. The receiver sends its own unique hardware ID in its acknowledgement.
  4. The transmitter checks the receiver's ID, to load the right model memory.
• Bound: from then on, every packet uses the transmitter's unique ID as the pipe address. A receiver that is not in bind mode ignores everything except packets with its stored transmitter ID.

The receiver drives the frequency hopping, in the 2.4 GHz ISM band.

• Frequency tables: both ends keep two tables in step:
  • Main table: 83 legal frequencies.
  • Discovery table: 3 of them, used to connect quickly.
• Hopping: the sequence is pseudo-random. The receiver names the next frequency in its acknowledgement (section 3.2).
• Hop timing: about 100 hops a second. The order to hop is the top bit of the acknowledgement's first byte.

• Discovery: at start-up, or after losing the signal, both ends cycle through the discovery table, to lock on quickly.
• Active: once locked, both switch at once to the main table.
• Failsafe: if the link is lost and not found again within the time-out, the receiver goes to failsafe and the transmitter goes back to searching.

Packets vary in length, to save air time. About 500 are sent a second, at 250 kbit/s.

A. Control packets. These carry the channels, and come first.

• Header (16 bits): one bit per channel.
  • Bit N set (1): channel N has changed, or is due to be repeated.
  • Bit N clear (0): channel N has not changed.
• Payload: the changed channels follow, packed in 12-bit slots.
• Receiving: the receiver reads the length (more than 2 bytes) and the header, unpacks the data and puts it on the right outputs.

B. Configuration packets. These carry settings. They are slipped in between control packets, so control is never held up.

• Marker: a zero header (0x0000) followed by a payload.
• Contents: the payload's first 12 bits name the parameter (4,096 possible).
• Size: up to 12 words of data a packet. Only the low 12 bits of each word are used, because of the packing.

The receiver sends an acknowledgement (ACK) payload for every packet it receives. It is always 6 bytes.

• One retry only. If a packet is lost, the radio tries again exactly once. Then it moves on, so new stick positions always win over old ones. There is never a backlog of stale data.
• Air time: large configuration transfers are slipped between control packets, so the controls keep most of the air time.

The instructor's (master) transmitter takes turns between the model and the pupil's (buddy) transmitter.

• Turns:
  • Master → model: packets at least 4 ms apart.
  • Master → buddy: one packet between each pair of model packets.
• Air rates: master ↔ model 250 kbit/s; master ↔ buddy 2 Mbit/s.
• How it works:
  1. Between control packets to the model, the master sends a packet to the buddy.
  2. The buddy answers with its stick positions in its acknowledgement.
  3. The master mixes or swaps the controls, by its own switch, before it sends to the model.
• No clashes: the buddy link uses the same frequency table, but walks it in the opposite direction.
• Same model: the master's packets to the buddy carry the model's ID. The buddy checks it, or loads the right model memory by itself.

Free software under GPL-2.0-or-later: see LICENSE and LICENSING.md. Use it, change it, share it. Changed versions must be shared under the same terms.

Copyright (C) 2020–2026 Malcolm Messiter. Since 2025, with Claude (Anthropic's AI) as pair programmer.