After a few months of development, we are excited to introduce our improved Hot Wheels RC conversion kit. If you haven't heard about the Turbo64 conversion kit before, it's a DIY kit containing everything you need to convert Hot Wheels and other 1/64 scale diecast cars into remote control cars, excluding the tools required to "open" Hot Wheels (or remove the bottom of the cars). The kit includes a chassis, small components like bearings and screws, motors, electronics, and even parts to build a remote controller with two joysticks. The firmware is open source, allowing you to modify it to add new features.

Our electronics are designed in-house, and we confidently state that it’s the best RC control board for small scales (up to 1/32) available on the market. It features two DC motor drivers, a battery management system, an audio amplifier (just connect a speaker to play sounds from your Hot Wheels), a gyroscope for enhanced drifting control, servo motor controllers, WiFi/BLE connectivity, and open-source firmware. While this sounds impressive, we continue to add new features each month. Here’s what we’ve introduced in the last month:

• New Gyroscope Logic: The gyroscope improves control during drifting. Previously challenging with small cars, our RC control board integrates it on the same circuit as the motor driver, servo controller, and RF receiver. All gyroscope settings, including sensitivity, can be updated via a web browser.
• High-Frequency DC Motor Control: This enhancement results in smoother operation and quieter performance.
• Adaptive Side Holders: The chassis now includes adaptive side holders for easier mounting of Hot Wheels bodies.
• Low Profile Servo Arm: The servo arm is only 4mm high, making it suitable for Hot Wheels with limited space.
• LED Connectivity: You can now connect LEDs to illuminate your RC car.
• New Web App: A web application has been developed to update car settings.

How to Convert Hot Wheels / 1:64 Scale Cars into an RC Car

1. Select a Car: Choose a car you wish to convert; it can be a Hot Wheels or another 1/64 scale model.
2. Order the Kit: Purchase the Hot Wheels RC conversion kit from our online store.
3. Prepare Tools: Gather a power drill with a 5mm bit (to "open" Hot Wheels cars) and a Dremel tool.
4. Remove the Bottom: Carefully detach the bottom of the car.
5. Assemble the Kit: If you live outside Europe, order a Li-Po battery (80-200mAh depending on your car size). Soldering is not required; all electronics come with pre-soldered wires and connectors.
6. Install the Kit: Fit the assembled kit into the car body.
7. Assemble the Remote Control: Put together the remote control unit.
8. Enjoy Racing: Play and race with friends, family, or enjoy solo sessions.

The full guide can be found on our website.

Where to Buy

You can order Turbo64 Hot Wheels RC conversion kits exclusively at our online shop.

In this guide, I’ll show you which electronics you need to build an RC car featuring a servo motor (for steering), a DC motor (to move the car forward and backward), lights, and sound. If you enjoy programming, you can customize the firmware (based on Arduino and ESP32XX SOCs). However, if you don’t know how to program, you can use Loco.Engineering circuits (or modules) with pre-built firmware.

Electronics Required for the RC Car:

1. Servo Motor
   Used to turn the front wheels left or right. If space is limited, you can replace the servo motor with a DC motor and potentiometer.
2. Brushed DC Motor
   Powers the movement of the car forward and backward.
3. Control Circuit or Board
   Receives messages from a mobile device or computer over WiFi, or from a custom remote control.
   • Recommended: Use the Loco.Engineering RC car module.
   • Alternative: Build your own control board using an ESP32S3/C3 module, a DC motor driver, a battery controller, and an audio amplifier (if sound functionality is desired).
4. Battery (Li-Poly/Li-Ion, 3.6V)
   The capacity depends on your car's scale. For example, 100–150 mAh works well for 1:64 scale cars (e.g., Hot Wheels).
5. (Optional) Joystick Modules and an ESP32S3/C3 Development Module
   These are for building a custom remote control. You can also control the car directly from mobile devices or a computer over WiFi.

Connections

Loco.Engineering RC Board Outputs

The Loco RC board includes all the necessary outputs to connect a servo motor, DC motor, lights, and sound. Below is a guide to wiring each component.

If you use a custom RC board, refer to the board's schematic.

Connecting a Servo Motor

Servo motors are controlled with PWM and require 5V power.

• Orange Wire (servo): Connect to IO21 (RC car board).
• Red Wire (servo): Connect to 5V (RC car board).
• Black Wire (servo): Connect to GND (RC car board).

Connecting a DC Motor

To control a brushed DC motor, use the built-in DC motor driver on the Loco RC board.

• DC Motor Wire A: Connect to Motor #1 outputs (any output).
• DC Motor Wire B: Connect to Motor #1 outputs (another output).

Connecting a Battery

To use a battery, you’ll need a battery controller for charging. The Loco module includes a battery controller for 3.6V batteries.

• Black Wire (battery): Connect to any GND (RC car board).
• Red Wire (battery): Connect to BAT+ (RC car board).

(Optional) Connecting LEDs (Lights)

You can connect LEDs to any IO pin on the RC car module. Each IO pin provides around 2.75V and up to 40mA. If required, solder a resistor to the LED circuit.

• "+" (LED): Connect to any IO pin (RC car board).
• GND (LED): Connect to any GND (RC car board).

(Optional) Connecting a Speaker

You can connect a small speaker to the Loco RC board to play sounds.

• Speaker Wires: Solder directly to the Speaker outputs on the RC board.

Firmware

All Loco.Engineering RC boards come pre-loaded with firmware that you can modify to add new features. If you build your own control board you should upload the firmware yourself:

• Source code: https://github.com/loco-engineering/arduino-rc-car.
• For questions: Email hey@loco.engineering.

Controlling the Car

You have two options to control your car:

1. Web Browser Control:
   • Power the car and connect to the WiFi network "loco-rc" (default password: "loco.eng") from a mobile device.computer.
   • Open http://rc.local in a browser.
2. Custom Remote Control:
   • Build a remote control using a breadboard, two joysticks, and an ESP32S3/C3 dev board.
   • Upload the firmware for the remote from https://github.com/loco-engineering/arduino-rc-car.

What’s Next?

If you’ve connected everything correctly, you’ll have a functional RC car with steering, sound, and lights. This setup works for car scales 1:87, 1:64, 1:43, and 1:32, giving you flexibility in your builds.

For further questions or support, feel free to contact hey@loco.engineering.

In this tutorial, I’ll show you how to create a fully automated level crossing for a model railroad layout or diorama. This setup works even without DCC and is compatible with small scales like N, TT, and H0. We’ll explore four different ways to control the level crossing:

1. Using DCC (requires a DCC command station)
2. Via a web browser
3. By pressing a button mounted somewhere on your layout or module
4. Fully automated: The level crossing activates when a train passes a specific point and deactivates when the train clears another point.

What You’ll Need

1. Two level crossing signals
   If you don’t have signals yet, you can use Loco.Engineering signals. Both common "-" and common "+" configurations will work, but this tutorial assumes signals with a common "+" as they are the most common. Signals with 1, 2, or 3 LEDs are compatible.
2. A speaker (optional)
   Adding sound will enhance the realism of your layout.
3. A decoder
   Use a Loco.Engineering accessory decoder or build your own decoder based on the ESP32S3 SoC. (You can find instructions for creating your own DCC accessory decoder here).
4. Track
   Any brand will work (e.g., Märklin, Kato, Peco, Roco, etc.).
5. NFC readers and NFC tags
   These can be ordered from the Loco.Engineering store. Alternatively, you can use other sensors capable of sending interrupts, like Hall sensors with magnets.
   Note: If you only want to control the level crossing with DCC or a button and don’t need automation, NFC readers and tags are unnecessary.
6. Materials for housing electronics
   Use cardboard or other materials to construct a box for electronics and to mount the signals.

Estimated Costs

The total estimated cost is around 80 EUR/85 USD, including signals, a decoder, and sensors (assuming you use Loco.Engineering components).

Tutorial Overview

This tutorial is divided into three parts:

1. Part 1: Create a level crossing that can be controlled via a web browser or DCC.
2. Part 2: Add a button for manual control.
3. Part 3: Implement automation using NFC readers or other sensors.

In this first part, we’ll focus on the web browser and DCC control. By the end, your level crossing will be functional with sound (if a speaker is used) like on the video below:

Connections

1. Connect the Signal Wires
   Signals I use for this tutorial have "+" and "-" wires for each LED. However, if your signals use a common "+" or "-", the setup will still work. Connect "-" of your signals to outputs 00-15 (in my case it will be 00, 04, 11, 15). "+" from LEDs should be connected to any "+" on a decoder.
2. Optional Speaker
   To enhance realism, connect a speaker to the decoder’s "S+" and "S-" terminals. Speaker polarity doesn’t matter.

Your connections should resemble the photo below:

DCC Decoder Settings

1. Power the Decoder
   Use a USB-C cable or supply DCC/DC/AC power (up to 20V). A green status LED should light up.
2. Access the Decoder’s Interface
   • Open the Wi-Fi settings on your device and connect to the "loco-...." network. The default password is "loco.eng".
   • In a web browser, navigate to http://loco.local.
3. Configure the Signal LEDs
   • Click on "Add Status" and configure the settings for the signal LEDs.
   • For this example, I used turnout DCC packets with address 5:
     • "On" is triggered by a DCC packet with direction "1".
     • "Off" is triggered by a DCC packet with direction "0".
   • You can use any DCC address and you can use an signal aspect DCC packet instead of turnout DCC packets.
     
     My settings are shown below:

4. Save and Test
   Click "Save" and send a DCC packet to test the configuration. Your level crossing, complete with sound, should now be operational.

Next Steps

In Part 2, we’ll add a button to manually start/stop the level crossing "animation". In Part 3, we’ll implement automation using NFC readers ( you can replace NFC with other sensors capable of sending interrupts).

Questions?

If you have any questions, feel free to contact us at hey@loco.engineering.

At Loco.Engineering, we're focused on simplifying how we control model trains and other electronic toys. To be honest, most of the technologies used in model trains and RC toys are outdated. For example, many DCC decoders still require CV programming with special proprietary tools, when we now have WiFi, and all settings should be updated via a web browser in 2024. That’s why we continue to work on our DCC converter, which allows you to use almost any MCU with Arduino or native SDKs to control model trains via DCC or WiFi, without needing a command station.

Our DCC converter is designed to convert DCC signals from the track into a digital signal (0 or 1) that can be read by any MCU, such as ESP32 SoCs, Raspberry Pi, and others. Additionally, the converter transforms DCC or AC into DC, which can power accessories, train motors, and other components. It also drops the voltage to 5V and 3.3V to power MCU boards, RGB LEDs, servo motors, and other devices requiring those voltages.

The new version can handle much more current: up to 2A on outputs with 8–22V, up to 2A on outputs with 5V, and up to 1A on the 3.3V output. This should be enough to power several servo motors, RGB LEDs, ESP32/Raspberry Pi boards, train motors, and more. We’ve reduced the board size to 35mm x 18mm x 5mm, allowing it to fit even in some H0 trains with MCU boards.

Full Specifications:

• Dimensions: 35mm x 18mm x 5mm
• Converts DCC signal from rails into a digital signal that can be read by an MCU (ESP32 boards, Arduino boards, and others)
• Converts DCC and AC into DC (Direct Current)
• Maximum total current: 2A (up to 2A on outputs with 8–22V, up to 2A on outputs with 5V, and up to 1A on 3.3V)
• Power supply: 8-22V DCC / AC / DC
• 3 power outputs: 3.3V DC, 5V DC, 8-22V DC
• Mounting holes

An example schematic of how to use this circuit can be found at: loco.engineering/docs

How to Use and Connect a DCC Converter

You can use a DCC converter in two ways:

1. Without an MCU board: Use it solely to convert DCC/AC into DC to power accessories. Three outputs are available: the same voltage as the track, 5V, and 3.3V.
2. With an MCU board (e.g., ESP32S3 dev board or Raspberry Pi): You can handle the DCC signal with your MCU board or use WCC (Wireless Command Control) to control trains or accessories on your layout.

Example of how to control a signal with DCC, the DCC converter, and an MCU board.

Example of How to Control a Signal with DCC, the DCC Converter, and an MCU Board

To control accessories or model trains, you can use:

• Our SimpleDCC firmware, which includes a built-in web app and a web throttle (works only with ESP32S3 boards).
• NmraDCC library.

For more information and a Getting Started guide, visit our documentation at: loco.engineering/docs/dcc-converter

I Don’t Want to Touch Any Hardware, But I Want to Upload My Own Firmware

If you prefer to use ready-to-go programmable decoders, check out our train and accessory DCC/WCC decoders. You can upload any firmware that works with ESP32S3 SoCs. All decoders come with default firmware that works out of the box, allowing you to control trains and accessories with DCC or directly from a web browser, even without a command station. Your layout can run on DC (analog control).

Where to Buy

Loco.Engineering DCC converters and decoders can be ordered from our store: loco.engineering/products

Feel free to contact us at hey@loco.engineering if you have any questions.

In this guide, I will show how to get started with DCC-EX to control your model trains and the whole model railroad layout with a very affordable setup (around 60 EUR / 70 USD for the whole setup excluding DCC decoder costs). Why do we still use and show how to use DCC-EX when our project’s main goal is to replace Digital Command Control with Wireless Command Control? That’s simple - we all still have DCC decoders and trains/kits are still sold with DCC decoders. That’s why we need some solution to mix DCC and WCC decoders on the same layout. This is Part 1 of guides about how you can control your model railroad layout with DCC and WCC at the same time, where we set up DCC-EX hardware, upload DCC-EX firmware, and control a train, signal, and a turnout with DCC-EX (your train or layout accessory has to have a DCC decoder to be controlled from a DCC-EX command station).

DCC-EX is an open-source project (hardware, firmware, and software) that helps you control model railroad layouts. You can think that it’s a command station like a command station from Märklin, Roco, and others. However, DCC-EX is developed by people who are really passionate about model trains, and everyone can implement their own features. That’s why using DCC and WCC on the same layout is possible with DCC-EX only.

What you need for this guide

• A train with a DCC decoder or a layout accessory (a signal, for example) connected to a DCC accessory decoder (we tested steps described in this guide with our DCC/WCC accessory decoder, but almost any accessory decoder should work as well). If you want to build an accessory decoder yourself - check this guide.
• Parts described in the next chapter (DCC-EX hardware setup).

DCC-EX hardware setup

To start using DCC-EX, you need 2 boards (or PCBs or circuits) that can be ordered at our online shop or your local online shops:

• Arduino Mega or some equivalent.
• DC motor driver that can handle at least up to 15V and at least 2A (for big layouts, 5-10A is recommended). To avoid any issues with connections, we recommend using a DC motor driver that can be inserted into an Arduino board, for example, this board from our DCC-EX bundle.
• Power adapter, for example, 15V, 3A, that is used to charge laptops.

With those 2 boards, you will be able to control your layout from a computer over a USB cable using a web app (or a web throttle) or JMRI (an app for model railway automation).

Connect boards together

After you get all 3 parts from the previous chapter (2 boards and a power adapter), you should connect them together. If you use a DC driver designed to be connected with Arduino boards by inserting it into sockets, you should just insert a motor board into your Arduino board and connect wires from tracks to terminals on a DC motor board marked as outputs for motors (for example, M1A, M1B, M2A, M2B). A power adapter should be connected to terminals on a DC motor board that are marked as a power input. That’s it, your DCC command station is ready, and the final setup should look like as on a diagram below.

Upload firmware

To start sending DCC commands with a DCC-EX command station, you should upload a DCC-EX app to an Arduino board. This can be done without any knowledge of how to program an MCU and even without knowing what Arduino is. Just follow the guide at https://dcc-ex.com/ex-commandstation/get-started/installer.html#gsc.tab=0 - you should download the application available for Windows, Linux, and macOS, connect an Arduino board to a computer over USB, select required settings in the app, and click on Upload.

How to control trains with DCC-EX

There are 2 options for how you can control trains with DCC-EX. The simplest option is to connect your DCC-EX command station to a computer with a USB cable and open in a browser https://dcc-ex.com/WebThrottle-EX/. You will see a web app or web throttle that you can use to control trains directly from a computer or a mobile device in case it supports USB serial communication.

To use a DCC-EX web throttle is easy - just type in the address of your train and use controls to move it back/forward and enable/disable functions. Also, the web throttle allows you to program DCC decoders.

How to control signals, turnouts, and other accessories with DCC-EX

DCC-EX web throttle doesn’t let you control layout accessories like signals, turnouts, and others. To control them, you can use JMRI - an application for model railroad automation. Let’s check how to control a signal (don’t forget that your signal should be connected to a DCC accessory decoder and that DCC decoder should respond to DCC Signal packets).

• Download and install JMRI - follow the guide here https://www.jmri.org/help/en/html/setup/index.shtml.
• Connect the DCC-EX command station to the computer by a USB cable.
• Launch PanelPro.
• Select in the top menu bar Tools → Tables → Signals → Signal Heads.

Click on Add…and select in an opened window:

• DCC Signal Decoder from the Top dropdown (by default, the “Double Output” option is shown).
• Type in the DCC decoder address.
• Select Offset address (required with some decoders, so try to select and check if a signal responds to commands from JMRI; if not, try again with the disabled Offset address option).
• Click Create.

• To change a signal state, just select which state should be active by selecting an option in the Appearance column.

That’s it. Now you have a fully functional DCC command station that you can control straight from your computer with additional proprietary tools. Simple and clean setup. However, it can be even improved more by using Wireless Command Control instead of Digital Command Control. The next part will describe how to mix both protocols and make migration from DCC to WCC easier and have the possibility to have DCC and WCC (for example, for two-way communication between trains, NFC readers, or hall sensors without any wires) on the same layout.

Feel free to contact us at hey@loco.engineering in case of any questions or feedback.

When we tested our first version of the RC car control board for small-scale RC cars (up to 1:32) around 14 months ago, we couldn't have imagined that Hot Wheels RC conversion kits would become so popular. At that time, it was merely an internal test project. In this guide, I will compare four conversion kits (including our Turbo64) to save you time and money and demonstrate why Turbo64 is likely the best and easiest Hot Wheels RC conversion kit, which can also be used to convert other 1:64 scale cars into RC cars.

Options for Building an RC Hot Wheels / 1:64 diecast cars

1. Order a Fully Assembled Hot Wheels / 1:64 Car
This is the easiest option with no assembly required; however, you're limited to the models available on the market.

2. Order a Pre-assembled Hot Wheels RC Conversion Kit
The kit comes pre-assembled; however, you will need to prepare the Hot Wheels/diecast car for kit installation, which requires special tools.UdostępnijPrzepisz

3. Order a Conversion Kit with a Prepared Chassis Mounting Hot Wheels Car Body
This option includes everything needed to build an RC Hot Wheels car, including the car body and required tools. You can think of this as a STEM project.

4. Order a Conversion Kit and Assemble It Yourself
In this case, you receive the chassis and hardware components, but assembly is required. The main advantage is that you can convert almost any 1:64 car. Note: not all kits include a battery and remote controller, so you may need to find and order these separately.

5. Download or Order Models for 3D Printing
You will receive only the models to print on a 3D printer. You must also find and order all required components and tools like a DC motor, servo motor, bearings, etc.

6. Do Everything Yourself
This is the most creative, complex, and time-consuming option.

Available Hot Wheels RC Conversion Kits

Turbo64 was initially used to test our RC car control board; hence it's not a "create and forget" project but one that we update frequently. The Turbo64 Hot Wheels RC kit includes everything needed for a functional RC car (hardware components, chassis, electronics) for other cars in 1:64 scale as well. A car can be controlled from any device via Bluetooth or custom remote controllers, with options to connect Radiolink or SkyFLy receivers if desired. The firmware's source code is available for modification by buyers who wish to add custom features.

Feel free to contact us at hey@loco.engineering if you have any feedback or questions.

Today, we're excited to announce our modules for remote-controlled battery-powered cars and other vehicles, such as cars for train layouts, city layouts, boats, and cranes. We'll delve into how to use these car modules for various models and toys in our future posts. But today, I want to discuss the problems we aim to solve with this board and the main features that will help you create more interactive projects with less effort and more joy. You can find our car module available at our online store.

What problem are we addressing with this board?

It's simple - the problem is how to create remote-controlled cars and other battery-powered devices with DC motors, servos, and sound without dealing with electronics complexity. Some might argue that they can easily build RC cars with electronics from local shops or Aliexpress, and that's true. However, wouldn't it be much better and easier to have a small circuit (15mm x 30mm) that contains everything you need for your car? This includes DC motor drivers, servo drivers, sound, WiFi/BLE connectivity, ready-to-use Arduino firmware that you can modify, schematics for remote controllers with firmware, and the ability to control vehicles from a browser on any WiFi-enabled device. This is precisely what we integrate into our car modules (and other Loco.Engineering modules). You just need to solder or connect motors, speakers, and batteries to one small board, and the electronics part is ready in just 5 minutes. This means you can spend more time playing and creating more interesting projects. We're addressing a similar problem in railway modeling with our WCC modules. From our experience and conversations with modelers, setting up electronics on layouts takes up half the time or even more depending on layout complexity.

Main features of the RC car module

• Based on ESP32S3 - a dual-core XTensa LX7 MCU capable of running at 240 MHz with 4MB flash memory and 2MB RAM.
• Two modern DC motor drivers from Texas Instruments to control up to 2 DC motors and other loads, with a maximum current per motor of 3A and total current up to 4A. We've also integrated Back EMF and current sensing for more realistic physics.
• Control of multiple servo motors.
• The module and devices with the module can be controlled over WiFi/BLE from custom remote controllers based on ESP32S3/C3 SoCs or through a browser on mobile devices and computers.
• Built-in battery charging with battery level indication, eliminating the need for an additional battery circuit to connect li-poly and protected li-ion batteries.
• Built-in 5W audio amplifier - just connect a speaker and you can play sounds from your vehicle.
• Firmware based on Arduino and ESP-IDF with available source - https://github.com/loco-engineering/arduino-rc-car
• Schematic and firmware for a remote controller - https://github.com/loco-engineering/arduino-rc-car, with a kit containing all required components available in our online shop.
• 7 GPIOs with PWM to control lights and other loads.
• I2C, UART, and SPI for connecting external sensors such as gyroscopes, hall sensors, and others.
• 5V and 3.3V outputs.
• The smallest circuit with such a range of features available on the market. It fits even small vehicles in scale H0 or 1:87, with dimensions of 15mm x 27mm.
• Over-the-air updates.
• Weekly firmware updates.
• A web-based app to control cars and vehicles.
• Modules can communicate with each other, allowing for highly interactive layouts.
• Designed and produced in Europe.
• Available in two versions: bare circuit and with soldered wires.
• Costs less than buying development modules with components and soldering them together.
• Commercial license available for everyone, including small indie brands and manufacturers, with a small fee (2%) per each sold product with our hardware and firmware without any additional fixed and initial fees.
• Possibility to connect UWB (Ultra-wideband - https://en.wikipedia.org/wiki/Ultra-wideband) modules for indoor tracking with accuracy in a few centimeters.
• Possibility to connect an NFC reader.
• Removable USB type-C for charging and firmware uploading.
• Possibility to connect your own charging module, for example, wireless charging.
• No vendor lock-in; you can change the firmware as you want.

What RC models and toys can you build with this module?

• Cars, buses, and other vehicles for your train or city layout in scales 1:160 (N), 1:87 (H0), and larger.
• RC cars with a brushed DC motor, steering powered by a servo motor, and realistic physics.
• Remote-controlled battery-powered vehicles such as cranes, boats, buses, and trains.
• Robots.

How to control a car/vehicle with the Loco.Engineering car module

• Using a remote controller over ESP-NOW. Firmware and schematic examples with 2 joysticks powered from a battery are available in our git repository. The kit with all required components to build a remote controller is available at our online shop.
• Over WiFi from a browser on a mobile device or computer.
• Over BLE from a browser on a mobile device or computer.
• Over USB from a computer (on our roadmap, expected release in June).

How to get started

We recommend checking the entire electronics setup before installing it in the final toy/model/robot. To start using our car, follow these easy steps:

• Order a Loco.Engineering car module.
• (Optional if you haven’t and if your project requires) Order a DC motor, servo motor, 3.6V protected battery (for example), speaker, axles, wheels, gears, and other components for your toy/model/robot.
• Receive the car module and connect/solder wires from motors and the speaker.
• We ship the module with preinstalled firmware so you can start using it after connecting motors and the battery.
• Connect a battery and check that a status LED on the module flashes in blue.
• Open WiFi settings on any computer or device and connect to a network with a name like “Loco-xxxxxx”.
• Open a browser on that device/computer and go to http://loco.local. Click/tap on buttons to check that motors work.

That’s it. Follow guides in our Knowledge Base to add your custom logic to the firmware and upload it to your module. Feel free to contact us at hey@loco.engineering if you have any questions or feedback.

In this guide, I'll explain three options for controlling model railway layouts and a few trains on the floor in your room. If you're already familiar with the first two options (analog control and DCC), you can skip to the section on option 3 - Wireless Command Control.

There are three ways to control trains and accessories (signals, level crossings, lights) in model railways:

1. Analog Control or DC (Direct Current) control
2. Digital Command Control (DCC)
3. Wireless Command Control

Analog Control or DC

This is the simplest way to move trains on the track. You power the track from a source with positive and negative terminals, similar to batteries. The train receives power through its metal wheels and transmits it to the motor. It works the same way as connecting a motor directly to a battery - depending on which motor wire is connected to the positive or negative terminal, the motor will rotate forward or backward.

The main disadvantage of this control type is that you can't selectively control individual trains. If you put multiple trains on a track with analog control, they will all move if they're equipped with only analog control boards. Most low-price starter kits, such as those from Piko, only offer analog control. This can be a good starting point, but after some time, trains and tracks with analog control can become boring because you'll want to control multiple trains independently and have the ability to play train sounds and control accessories like signals.

This is where DCC, or Digital Command Control, comes in.

Digital Command Control (DCC)

The concept of Digital Command Control is to send not just power, but also messages to trains and accessories through the track or additional wires. How does it work? A special power adapter (or command station) sends alternating voltage instead of direct current like a battery. It's as if you were rapidly rotating an analog controller's knob from maximum clockwise to maximum counterclockwise. Depending on how quickly it alternates between these extremes, it can send 0 or 1. For example, if one cycle takes 1 second, it represents 0, and if it takes 2 seconds, it represents 1. By combining 0s and 1s, you can send messages. The command station operates on the same principle, but the alternation between +Vmax and -Vmax is much faster - typically 106 μs for a "1" and at least 200 μs for a "0".

All trains and accessories on a layout must be physically connected (trains are "connected" to rails via metal wheels). You can't simply install a signal, for example, without connecting it to the track or wires carrying the DCC signal. Another limitation of DCC is that the protocol isn't dynamic - for instance, you can't send text to display on a train station screen or upload new sounds to a train decoder. For most DCC decoders (boards that control trains and accessories), you even need special tools to update firmware and upload sounds. More details about DCC can be found at https://dccwiki.com/

There are a few other protocols similar to DCC that send messages over the track. The most popular after DCC is Mfx - a protocol developed by Märklin. While the protocol is proprietary, Märklin has done an excellent job designing sets and additional accessories that work out of the box. However, before buying any Märklin sets, you should be aware that Märklin requires specific tracks with a middle rail, and you can't use trains from other brands with Märklin. This means that if you choose Märklin, you're committed to using only Märklin products.

Getting Started with DCC

The simplest way to start with DCC is to buy a DCC starter kit. Brands like Märklin or Roco offer excellent options for beginners. If you prefer a more hands-on approach, you might want to check out the open-source command station based on Arduino at https://dcc-ex.com/#gsc.tab=0.

For those interested in building their own DCC decoder using Arduino and ESP32, we have a separate guide that walks you through the process step by step. This option is great for hobbyists who enjoy a bit of DIY and want to understand the technology from the ground up.

Wireless Command Control

Wireless Command Control (WCC) has been designed to simplify electronics for model railways while providing more interactive layouts. WCC doesn't require wires or tracks to send messages, as all communication is wireless. It also introduces two-way direct communication between trains and other layout elements. What does this mean? One train can send messages to other trains, signals, station decoders, etc., directly without additional tools and over the air.

To achieve this with DCC, you'd need at least one wire between two layout elements or between an element and the command station. For example, if you want to add 10 block detectors to the layout, you'd need to connect those detectors to a command station with 10 wires. WCC doesn't require any signal wires between layout elements, and all elements on the layout can communicate with each other, even trains, which isn't possible with DCC.

The average cost of a WCC system is much lower because you don't need a command station, wires, or additional tools to connect a command station to your laptop or mobile phone. Setting up a WCC system is as simple as an analog system - you need a power adapter with DC or AC, and you install a board into a train or connect accessories to the WCC accessory decoder. That's it. After you power a WCC decoder, you connect to it over WiFi and open the web app. The web app works with all modern browsers (released after 2020) and on all devices with WiFi.

More details about WCC can be found at https://loco.engineering/docs/

How to start with WCC:

It's easy - all you need is a train or accessory that you want to control over WCC and a train or accessory decoder. You can also build your own WCC decoder based on ESP32S3 and Arduino - check our GitHub repository for more information on how to build a WCC decoder.

What to choose?

As the lead developer of the WCC system, I recommend using it even if you already have a layout with DCC. WCC supports DCC but offers many more possibilities for interaction and significantly simplifies your model railway electronics.

The advantages of WCC include:

1. Wireless control, eliminating the need for complex wiring
2. Enhanced interactivity between trains and other layout elements
3. Simplified setup and maintenance
4. Cost-effective expansion of your layout

We're confident that WCC can enhance your model railway experience, regardless of your current setup. If you have any questions or need assistance in implementing WCC with your existing layout or just plan to buy your first set, please don't hesitate to contact us at hey@loco.engineering.

In this guide, I will show you how to convert almost any Hot Wheels or other 1/64 scale diecast cars into an RC car. At the end of this guide, you can download the files needed for 3D printing. If you don't have a 3D printer, you can order all the required printed parts and other components, including electronics, from our online store.

For this build, we’ll use a belt instead of gears, similar to high-level RC cars in larger scales, bicycles, and other machines. To understand how it works, check this article https://www.tec-science.com/mechanical-power-transmission/belt-drive/power-transmission-of-a-belt-drive/. Since there isn’t a real drive belt for 1/64 scale cars, we’ll replace it with an elastic band. Belts work great for larger scales and even in model trains, so why not use them for Hot Wheels and other 1/64, 1/43 cars?

What You Will Need

Tools:

The tools required depend on the car you want to convert. For some cars, only screwdrivers are necessary. However, converting Hot Wheels requires a few additional tools:

• Screwdriver, size 00 and 000
• Power drill with a 5mm bit (to "open" Hot Wheels cars)
• Dremel tool to clean the car body
• Tweezers
• Flush cutter

Hardware:

We designed this kit to be as simple as possible, requiring just five components, all available in our online shop or from marketplaces like Aliexpress:

• 4 x 1mm x 2mm x 1mm sealed bearings
• 2 x 1/64 scale wheel sets (optional)
• 10 x M1.0 x 6mm screws
• 10 x M1.0 x 10mm screws
• 1mm axle
• Elastic band (6 – 6.5 mm / 1/4")

Electronics for the Car (Controlled from a Phone/Computer):

We’ll use a Loco.Engineering RC car board, which includes everything you need to build an RC car. It features a gyroscope, audio amplifier for sound, and an open-source firmware you can modify (based on Arduino and ESP32). It can also be controlled from any device with WiFi. What will you need:

• 1 x Loco.Engineering RC car module
• 1 x 100-150 mAh Li-poly battery
• 1 x 1.7g rotational servo, 5V
• 1 x DC motor (14.5-15mm x 8mm x 6mm, 30,000 rpm, 3.6 - 4.2V)

Optional Electronics for a Remote Controller:

• 2 x joystick modules
• ESP32S3/ESP32C3 development board

Steps to Build Your RC Car

1. Open the Car

Remove the bottom of your car. For Hot Wheels, drill out the joints as shown in the photo below.

2. Assemble the Conversion Kit

Download the 3D models linked at the end of this guide and print the parts. The kit has only five printed parts and is simple to assemble without requiring engineering expertise.

3. Front Wheels and Steering

• Insert two 1mm x 2mm x 1mm bearings into the front wheel holders
• Insert M1.0 x 6mm - 10mm (depends on wheels you use) screws through the bearings and attach both wheels.
• Insert the bearings with wheels into the holes in the front wheel holders.
• Place the front wheel holders into the main body.
• Install and lock the top front wheel holder.
• Mount the steering arm using two M1.0 x 6mm screws.
• Install the servo and connect it to the steering arm.

4. Rear Wheels and DC Motor

• Cut the 1mm axle to the required width.
• Insert a bearing onto the axle.
• Insert the axle through the first bearing (file it slightly with sandpaper if needed).
• Add the second bearing to the other side of the axle.
• Center the axle.
• Place a large pulley onto the axle.
• Attach the rear wheels to the axle.
• Solder wires to the motor.
• Insert the motor into its position.
• Attach the small pulley to the motor.
• Connect the pulleys with an elastic band.
• Install the rear wheel holder onto the main body with four screws and adjust the length to fit your car body.

5. Electronic Connections

• Solder the DC motor wires to the controller board.
• Cut and solder the servo wires to the controller board.
• Solder the battery wires to the controller board.
• Attach a charging connector to the controller board.
• Secure the controller board and battery with a band.

6. Test the Setup

• Power the charger.
• Ensure the green LED on the board is on.
• Open the WiFi networks list on any device and connect to “rc_xxxxx”.
• Open https://rc.local in any browser.
• Test the car by moving it forward/backward and turning left/right.
• If everything works fine, proceed to mount the car body.

7. Install Inside the Car

Hot Wheels cars typically have two types of bottom attachments:

1. By two metal joints.
2. By one metal joint and a plastic connector at the rear.

Depending on your car type, glue magnets to the main body and the bottom with the wheels that you built.

Final Step

Your RC Hot Wheels car is now ready! Build more and race with your friends. Loco RC car boards allow up to 25 users to race simultaneously.

Feel free to contact us at hey@loco.engineering if you have any questions or feedback.

Files for Printing

Note: All files listed below are for private use only. Redistribution or sale is prohibited.

• Level of Complexity: EASY
• Required time: 10 - 15 min

In this guide, you'll learn how to create your own wireless accessory or multifunction DCC decoder based on the ESP32S3 microcontroller and the SimpleDCC/WCC project.

Why should you build your own DCC decoder or use a programmable decoder?

Here are some key benefits:

Flexibility: You can implement complex control logic that's simply not possible with off-the-shelf decoders. This gives you unprecedented customization options.

No vendor lock-in: When you build your own decoder, you're not tied to any particular brand or manufacturer. You have complete freedom to choose the components and features that suit your needs.

Cost savings: Building your own decoder is often much more affordable than purchasing proprietary decoders from model railroad companies.

Repairability: If your custom-built decoder ever breaks, you can easily replace individual components inside it, rather than having to discard the entire unit.

Expanded capabilities: With a programmable decoder, you can connect all sorts of additional sensors and components, like NFC readers, stepper motors, displays, and more - things that aren't possible with typical commercial decoders.

In fact, many hobbyists find that once they experience the power and flexibility of a programmable decoder, they never want to go back to proprietary solutions. The customization and cost-savings are simply too compelling.

So if you're ready to take your model railroad control to the next level, let's dive into the steps to build your own wireless DCC decoder using the ESP32S3 and SimpleDCC/WCC project.

Components of a DCC/WCC decoder

Here are the key components needed to build your own DCC/WCC decoder:

• ESP32S3 Board: At the heart of your custom decoder will be an ESP32S3 system-on-chip (SoC). This powerful microcontroller has built-in Bluetooth, Wi-Fi, PWM capabilities, analog-to-digital converters, and over 30 I/O connections that can each handle up to 40mA of current - perfect for powering signals, lights, and other model railroad accessories.
• DCC Converter (optional if you want to control the layout from the web app): To interface your ESP32S3 with the model railroad's DCC track power, you'll need a DCC converter circuit. This converts the alternating current (AC) from the rails into the direct current (DC) needed to power the microcontroller, while also converting the voltage changes on the rails into digital 0 and 1 signals that the ESP32S3 can understand. You have a couple options here - you can use a ready-to-use DCC converter circuit, or you can build your own using an optocoupler and rectifier bridge. If you choose to build it yourself, we've provided a schematic below that you can use as a reference (please note this schematic is only for non-commercial use).

• Firmware (or application) that will control elements connected to the decoder. We'll use the SimpleDCC/WCC project for Arduino - https://github.com/loco-engineering/simpledcc-arduino
• (Optional) A DC motor driver if you want to control a train, DC motors, or solenoids (for example, Kato turnouts use solenoids to change direction)
• (Optional) An LED driver if you need more than 40mA per LED
• (Optional) Digital-to-Analog converter and audio amplifier to play sound
• (Optional) Green connectors and/or a breadboard to avoid excessive soldering

In this tutorial, we'll create a SimpleDCC decoder based on the ESP32-S3 development board, the Loco.Engineering DCC converter, and the SimpleDCC/WCC framework for Arduino. Alternatively, you can buy a ready-to-use programmable Loco.Engineering decoder that already has the ESP32-S3 SoC, DCC converter, and other features.

The decoder in this tutorial will control a Polish Railway signal, but you can use any other signal(s) you need. If you don't know how DCC works, be sure to check the related guide.

Don't worry if you've never programmed before - you can use the SimpleDCC/WCC project without writing any code, as the decoder logic can be updated directly in the web browser.

How SimpleDCC/WCC Differ from Other DCC Projects/Decoders

The main differences are:

• You don't need to understand DCC's inner workings because the decoder's logic can be set in the web app without additional programming tools.
• There's no need to study lengthy manuals. SimpleDCC performs actions (e.g., changing semaphore aspects, turning lights on/off) without strictly adhering to often ambiguous DCC protocols. You can view all messages received by a SimpleDCC decoder in your browser (with options to group and filter them), and define the decoder's response to received packets. In our experience, this greatly simplifies working with DCC.
• SimpleDCC decoders are compatible with virtually all command stations and DCC protocols (with mfx support on our roadmap). Even if you don't understand a DCC packet's format, you can still assign actions to it. For instance, Märklin Mobile Station sends accessory DCC packets in a non-standard format that most accessory decoders don't understand, but with SimpleDCC, you can assign actions to these packets as-is.
• SimpleDCC/WCC decoders can control trains, vehicles, and layout accessories like signals and turnouts without needing to know the specific types connected. With a traditional decoder, changing a signal aspect requires finding the correct command to send from the command station. With SimpleDCC/WCC, the user defines what action should occur when a specific DCC packet is received. You're not limited to predefined signal aspects or features set by manufacturers like Pico or Marklin. Instead, you can create virtually any state and action you need. No programming is required, but for advanced users, the source code is available for full control over the decoder's behavior.
• You can control almost everything with SimpleDCC/WCC from a command station or web browser, including RGB addressable LEDs, NFC readers, Hall sensors, servo motors, DC motors/single solenoids (an external DC motor driver is required) and more.
• SimpleDCC/WCC decoders can communicate with each other directly without any additional tools

Connections

If you use a Loco.Engineering decoder, you should connect it to the rails with DCC, and the signal should be connected to the decoder.

If you use your own ESP32-S3 board and a DCC converter, you should:

• Connect the ESP32-S3 board to the DCC converter
• Connect the DCC converter to the rails
• Connect a signal to the ESP32-S3 board

Example of connections in case you use an ESP32-S3 development board and Loco.Engineering DCC converter:

Upload SimpleDCC/WCC on a decoder

It's time to upload the SimpleDCC/WCC firmware to your DCC decoder. All the steps below will work only for ESP32-S3 boards, including Loco.Engineering decoders that are based on the ESP32-S3 as well.

How to upload the firmware to a SimpleDCC/WCC decoder:

1. Download and install the Arduino IDE (Arduino is an application used to develop applications that can be launched on different microcontrollers).
2. Install the ESP32 development tools for Arduino.
3. Follow the instructions from the SimpleDCC/WCC repository on GitHub to install all the required frameworks.
4. Upload the firmware to the decoder and reboot it.
5. On your phone, tablet, or laptop, connect to the Wi-Fi network named loco-xxxxx (by default, you should be able to connect without a password).
6. Open http://loco.local or http://192.168.4.1 in your web browser.
7. You should see the web-based configuration interface for the SimpleDCC/WCC decoder.

If the decoder is connected to the rails, you'll see the DCC packets in the web app (don't forget that you need a DCC converter that can transform the DCC signal from the rails into digital messages, convert the alternating current to direct current, and step down the voltage - do not connect your ESP32-S3 board directly to the rails).

The idea behind SimpleDCC is to make DCC as simple as possible. That's why you shouldn't have to spend hours or even days reading through decoder manuals. To get your decoder working with your command station, you only need to complete two steps:

1. Add an accessory or train decoder to your command station - use any decoder address, any port, and any function number.
2. Add the decoder settings you used on the command station to your SimpleDCC/WCC decoder in the web app.

What features do we plan to add to Simple DCC?

This is the initial version of the SimpleDCC decoders for Arduino, but there are plans to add more features in the coming months. For example, the developers plan to add the following capabilities between September and December 2024:

• NFC readers to get information about train locations
• Support for stepper motors
• Ability to play media files, including video, on small displays

Feel free to contact the developers at hey[at]loco.engineering if you have any ideas about what should be added to the SimpleDCC/WCC Arduino project.

If you need ready-to-use or programmable decoders with features like sound, DCC decoder, LED drivers, and motor drivers, you can check out the Loco.Engineering decoders.

After more than 1 year of development, experiments, tests, and sleepless nights we're ready to introduce Loco.Engineering accessory decoder that, we guess, is the most comprehensive decoder available on the market now. In this introduction post, I will show you why we think so.

The problem we want to solve

Let's start with a bit of history about why we decided to develop a new decoder and a new control system for model railways and other toys. You can tell that DCC (Digital Command Control) can do what you need and that's true if you're ready to spend a huge amount of time on electronics instead of playing and demonstrating your layout. A simple example is how to get a message and handle that a train crosses some section on tracks and add signal automation based on that message. Just check how it can be implemented with Marklin in this video. in 2023 it's a fully outdated solution because we use RF signals everywhere but model railways still send messages over the track which of course makes the whole layout-building process very very complicated.

We are in Loco.Engineering decided to change the way how we control layouts by moving all messages from tracks to the air and introducing 2-side communication between decoders (in classic DCC a decoder communicates with a command station but there is no communication between decoders directly) - you don't need any more command stations and additional wires especially to get feedback from decoders, because all messages between decoders are sent over the air. That should simplify the whole electronics on a layout, give the possibility to build temporary layouts with complex logic, and make it easier to play with model railways for young guys.

Main features

• Different outputs to make your layout interactive

- 14 outputs for LEDs / other loads with dimming and up to 60mA/output (even enough for small motors)

- 4 outputs for heavy loads with up to 500mA

- Output to connect DC motors or servo motors, multiple motors can be connected if you need to move them all in the same direction (for example, barriers on a level crossing)

- Output for a speaker 3W

- I2C outputs to connect an NFC reader, your custom sensors, and other modules

- 2 inputs for interrupts

• Can handle 3 protocols at the same time

- DCC (Digital Command Control)

- WCC (Wireless Command Control, no command stations are required, can be controlled directly from a computer or mobile devices)

- Mfx (will be available in February 2024, currently in beta testing)

• A web application to set decoder settings (for example, to set dimming for individual LEDs of a signal, combination of LEDs to highlight, etc), no programming over the track is required

• Firmware updates with new features every 2 weeks
• Fully programmable - you can use our firmware or develop your own with Arduino or ESP32 IDF.
• API to develop a custom application to control all decoders on the layout
• Compact size
• Friendly support from engineers who develop and improve decoders not from 3rd party people
• Low cost (€70 or $80) because we sell our decoders directly on our website

How to use Loco.Engineering accessory decoders

When we designed our decoders we had 2 things in mind

• simplicity in usage
• flexibility

That's why getting started with Loco.Engineering decoders is very easy

• Buy a decoder on our website, receive it, and unpack
• Connect your accessory (for example, a signal) to a decoder, all outputs on a decoder are marked and all documentation can be found online (no more than 100-page pdf files), a getting started manual is included with each decoder
• Power a decoder from rails or just with a USB type-c cable for fast evaluation
• Open the web app, click on "Add module" and set a decoder settings
• That's it

Roadmap

Most companies that produce DCC decoders don't make any improvements after they release the production version and just sell them. We develop and produce all decoders in our workshop which means that we can introduce improvements and add new features even every day. For example, today we received an idea in the e-mail from one of our users that it would be great to have feature A, and next week feature A can be implemented and all users that already have our decoders should just update the firmware like you update all your applications on a mobile device. That's why feel free to send your feedback and ideas at hey[]loco.engineering. Anyway, what's on our roadmap for the next few months

• Finish NFC modules that will help to notify all decoders on a layout that a train, car, or vehicle crosses some area and it's time to change a signal aspect, down barriers, or do something else
• Ready to use electronic kits like a level crossing kit, light kit with RGB LEDs, etc
• Add support for small displays that can be used on train stations, for example

Where to buy

Decoders can be purchased at our online shop only. In case you don't like it you can return a decoder within 14 days after you receive a package without any questions from our side. We ship worldwide from Poland.

If you have any questions feel free to contact us at hey[]loco.engineering and don't forget to subscribe to our news here

Today I want to explain what you're paying for when ordering a DCC multifunction decoder, accessory decoder, and other electronics for your layout. and what is the main reason that they are so expensive and how we in Loco.Engineering is trying to solve this problem to make model railways accessible for more people (even with small budgets and young guys). Let's start from the basics - what is needed to send a DCC message, receive that DCC message and do some actions (move a train, turn on LEDs, etc).

DCC basics

DCC is a very simple protocol that is a bit over-engineered and already outdated, to be honest. If you still don't know or understand how it works look at the following example. Imagine you have a model train motor that you can start/stop/change the rotation direction. You can rotate a motor for 1 second forward and 1 second back. Also, you can rotate a motor for 2 seconds forward and for 2 seconds back. of course, it's just an example because there is no value in rotating the motor forward and back for the same periods. DCC works in the same way - a command station powers rails with very short intervals - around 58 μs and 100 μs (intervals in 58μs and 100μs is a standard developed by NMRA). For example, the command station sends +12V (voltage depends on a command station model, 12V is just an example) during 58μs (if you connect a motor, it will rotate forward for 58μs), then -12V during 58μs(the same motor will rotate backward for 58μs, etc), then +12V during 100μs, and finally -12V during 100μs. Of course, if you just connect a motor to rails with such a DCC signal you'll see nothing in most cases but if you have a very responsive motor you'll hear some noise from the motor. This means that you need something that can understand that the voltage in rails is changed from +12V to -12V, and how long +12V occurs. Here we use DCC decoders that can convert voltage changes (from +12V to -12V) and durations of how long +12V is kept in rails to some messages that we can use to control trains, signals, etc. If a decoder detects that rails have +12V for 58μs, a decoder thinks that it's 1, and if rails have +12V for 100μs, a decoder interprets it as 0. By combining such "0" and "1" we can send/read messages like when you write in any chat application. There are a few standards or protocols that describe what different combinations of 0 and 1 mean. The basic protocol is developed by NMRA and you can find more details on the official website.

How do DCC command stations work?

Let's check what components are required to send and handle DCC messages. To send a message to a decoder you need

• MCU "thinks" about what message should be sent. For example, you press a button on a station command to turn on the lights of a loco and MCU finds how many 0 and 1 (message structure) should be in a message that should be sent to a loco's decoder
• The motor driver converts a digital message from MCU to voltage signals (a motor driver power rails with +12V and -12V during different periods as we described in the previous chapter) that go to rails and then are handled by decoders

That's it. The cost of those 2 components is 5-10 EUR, but I guess you know how much command stations are cost. Of course, command stations have buttons and small/big screens but components for a command station still cost not more than 20-30 EUR.  So the reasonable price for a command station like Marklin Mobile Station is 70-80 EUR. Everything is paid on top of it - distribution fees and marketing. Well, but what do Loco.Engineering and WCC introduce? With Loco.Engineering and WCC you don't need command stations anymore because each decoder on a model railway layout has an MCU microchip that can not just receive messages from other trains and accessories but can send messages to others (in a traditional DCC-only command stations send messages to trains and accessories). To update logic on decoders you can use computers, mobile phones, or tablets that can communicate with decoders directly without additional devices and any wires. This means that you can not just reduce costs on your model layout but simplify electronics a lot.

How do DCC decoders work?

Let's check what is needed to handle a DCC message on a decoder and do some actions when a new message is received:

• Rectifier bridge to convert alternative current (if you remember, in DCC a command station powers rails with positive and negative voltage during some periods) to direct current
• An optocoupler or just a few diodes and resistors to transform positive and negative voltage changes to digital 0 and 1
• MCU to handle digital 0 and 1
• A motor driver to control a DC motor
• Mosfets for high-load outputs
• (Optional) Digital to analog converter for sound

You can check at electronics online stores how much such components cost. The total amount will be up to 20 EUR including digital to analog converter for sound even if you buy components just for 1 decoder. In case we want to add wireless communication it will be a bit more expensive - around 25-30 EUR.  So the reasonable price on classic sound DCC decoders should be around 45-55 EUR and on wireless sound DCC decoders should be around 65-75 EUR. And now just check how much your sound decoders cost. There is one brand that has very nice decoders for a reasonable price - of course, our decoders and decoders from Hornby. So what value Loco.Engineering and WCC introduce for DCC decoders?

• CV programming is not required anymore - the whole logic of a decoder can be updated directly from a computer, mobile phone, or tablet.
• Decoders can send messages not just receive messages
• Better and faster message delivery because all messages are being delivered over the air not rails
• Tracking train and vehicle locations with NFC
• Wireless Command Control is an open protocol, all wireless decoders available on the market use a proprietary protocol to communicate between applications and decoders. With WCC you're able to create your web and mobile applications and even control layout from your single board computer like Raspberry Pi
• Layout automation is a base feature
• Low cost - 55-75 EUR for wireless sound decoders with most modern IoT technologies
• Friendly documentation (not a pdf file)

Loco.Engineering and WCC decoders are available in our online store - https://loco.engineering/products. Feel free to contact us at hey@loco.engineering in case any questions or ideas about how we can improve and what we can add to our decoders.

No updates for a long time but it's because we haven't enough time for blog posts. When we don't work on WCC and decoders we have fun testing what we've finished already. and those tests become more and more interesting because interactions that you can add to your layout with WCC are limited by your imagination only and the size of the gauge you build.

We have great news - we're already waiting for PCBs that will be used in production. This means that we are very very close to releasing the first version of DCC train and accessory decoders that you can buy and use on your layout. We plan to start selling decoders in January 2024 after around 2 years of development and huge amount of experiments and trying different hardware options.

Here is how Loco.Engineering WCC/DCC decoders will look like. Each decoder has outputs for speakers, a tiny RF antenna for sending messages over the air (no more any signals over wires but of course classic DCC is supported) and communicate with computers/mobile devices, and I2C to connect additional modules like NFC reader, sensor modules, or even your submodule developed with Arduino or ESP Idf. Dimensions are 11 mm x 39 mm. Versions with different connectors like NMRA 8-pin connectors will be available as well.

We decided to use the same core board (on the image above) for train decoders and accessory decoders because there is no difference between trains, vehicles, and other layout elements in WCC - all decoders use the same firmware. This means that you can install different non-standard elements like displays, movable current collectors, and others even in trains and you can add sound to any level crossing. Of course, it's not easy to solder wires to a small decoder each time to want to connect or reconnect signals, servomotors, or speakers that's why we designed a special expander board with wire connectors (green on the picture below) for accessories, this expander board has 12 outputs for LEDs and other loads, outputs for speakers, DCC decoder and I2C in case if you want to develop something very custom with Arduino or ESP IDF.

What's next? Now we're waiting when PCBs for core decoders and accessory decoders will be delivered. As usual shipping before Christmas takes forever. After we get them and solder everything in our workshop in Poland, we plan to spend a few weeks hard testing all components and finish our web app.

In a few weeks, we plan to introduce our early adopters program. Approved users of that program will be able to get a 20% discount on all decoders and get updates before they go live for all other users, send feedback and ideas on what they like or don't like, and what they want to add to decoders and WCC. Of course, early adopters will have premium support. Subscribe here to be notified about this early adopters program and when decoders are available on our website.

Today I want to show you how easy to add Wireless Command Control to your layout (new one or with existing DCC decoders) and forget about any DCC complexity forever. If you don't know what is WCC - check this post.

When we designed how layout elements (trains, signals, switches, etc) communicate with a control panel (the application on a laptop/mobile device, remote control with buttons, etc) we wanted to keep this communication for users as simple as possible and of course, still, provide scalability because today you have 2 trains and next year you have 100 trains. Just imagine setting up DCC for 100 trains. With WCC it doesn't matter at all how many trains and layout elements you have because all messages are sent over the air. Let me show how it works in detail.

With WCC all trains and layout elements "live" and communicate with each other inside a mesh (or in a group). For example, train A can send a message to a level crossing that train A will cross it in a minute and signals on the level crossing should start blinking. The question here is how to set all this logic - what should be done if some event occurs? The traditional way is to use CVs on your DCC decoders to set how a decoder should react to different DCC messages. WCC fully changes it - now you don't need any more programming each decoder because the whole layout logic is dynamic. One of your WCC decoders is a main decoder that communicates with the web app or remote control from one side and forwards messages to other decoders from another side.  If you have just one WCC decoder on your layout - that decoder will be a main decoder as well.

There are a few options for how you can connect a main WCC decoder to the web app:

• Over WiFi, in this case, you need a WiFi router. If you haven't a modem you can use your mobile phone. if your mobile cannot be a wifi router or you have very bad Internet, there is the second option
• Over USB cable. In this case, you don't need a WiFi router but you need a WCC dongle (costs 20EUR) or any ESP32S3 development board with UART<->USB converter. The second option doesn't work with mobile devices
• (Currently in development) You can install the WCC server on any single-board computer with Ubuntu, for example on Raspberry Pi. This option will work in the same way as the first with WiFi router but you don't need Internet all the time - only to set up.

After your main decoder is connected to WiFi or via a USB cable, it will be visible in the web app and you can start to control your layout and add automation.

Each time you want to add a new WCC decoder to your layout, steps will be

• Power a decoder
• Use Wi/Fi, Bluetooth, and USB (only for accessory decoders) to set the name/id of your layout
• Wait until you see the online status for a new decoder in the web app

That's it, after you see that a decoder is connected in the web app you can start control/automate it in the web app.

WCC decoders will be available in January 2024. Don't forget to subscribe here to be notified when decoders are available. Estimated price - 50-60 EUR.