DUILIO F4

Key features

DUILIO F4 - Key features

This page provides a structured technical overview of DUILIO F4, covering STM32 motion control capabilities, safety and failsafe behavior, I/O, and supported motor driver interfaces for robotics and machines.

Project documentation is available on GitHub.

Motion control and safety

I/O and interfaces

System architecture

Section	Details
MCU	Microcontroller: STM32F411 (64-pin, Cortex-M4F) Deterministic real-time motion control handled on-board Pre-developed, profile-based firmware (no application code required)
Motion control	2 independent motion axes per board Speed, position and torque control Torque control via external current sensors Acceleration / deceleration ramps Limits and soft limits Axis coordination and motion mixing Interlocks, watchdogs and failsafe behaviors
Scalability	Native RS485 multi-drop bus Designed for 10+ DUILIO F4 boards on the same bus Example: 10 boards = 20 motors, centrally coordinated Architecture: one host, many Duilio nodes (distributed real-time control)
Motor drivers	External motor drivers only (no power stages on-board) Supported / supportable interfaces: PWM / DIR ENABLE + DIR + PWM Dual-PWM (forward / reverse) STEP / DIR (speed or position usage) Analog speed (0-5 V) Analog speed + direction RC-style PWM (ESC / servo pulse) Serial / protocol-based drivers (profile-dependent)
Encoders and feedback	2 I2C absolute encoders 2 quadrature incremental encoders (A/B) Z channel and limit switches for homing Position feedback, homing and zero reference
RC I/O	4 RC servo inputs (PWM pulse capture) 4 RC servo outputs Usage: RC receivers, ESCs, servos, mixed/manual control
Digital I/O (power)	4 NPN low-side outputs External relays, solenoids, lamps Current: < 2 A per channel Firmware-controlled, profile-dependent
Digital I/O (logic)	End-stops and safety inputs Dedicated homing inputs
Analog inputs	2 analog inputs (0-5 V) Torque reference Position reference (potentiometer) Analog command input
Sensors	2 ultrasonic sonar interfaces (TRIG / ECHO) Other digital and analog sensors (profile-dependent)
Safety and failsafe	Safe state on communication timeout Configurable behavior on host or bus loss Motion enabled only after valid startup sequence Optional multi-condition enable logic Hardware and firmware safety interlocks Immediate output disable on fault conditions Internal watchdog and supervision logic Outputs forced to safe state at power-up
Configuration	Programming interface: ST-Link (SWD) Firmware flashing and configuration via ST-Link USB: optional / experimental, not the primary interface
Host systems	Raspberry Pi SBCs PCs Industrial computers Role separation: Host = logic, UI, networking Duilio = real-time motion and I/O control
Power	VIN: 6 V - 43 V USB: 5 V Raspberry Pi header: 5 V (HAT mode)
Raspberry Pi power output	Up to 5.1 V / 5 A Direct Raspberry Pi power supply
Protection	TVS and ESD protection Reverse and back-feed protection Designed for noisy motor environments
System philosophy	Designed to work with different motor types and external motor drivers The same motion control logic can be reused across different machines

Motor driver compatibility

DUILIO F4 works with many external motor drivers. Compatibility depends on the control interface used by the motor driver, while DUILIO handles motion logic and coordination.

Supported control interfaces

PWM + DIR (5 V)
ENABLE + DIR + PWM (5 V)
Dual PWM (forward / reverse)
STEP / DIR (speed or position profiles)
Analog speed (0-5 V)
Analog speed + direction (0-5 V)
RC-style PWM (ESC / servo)

Commonly used motor driver families

Examples for reference only, not official support:

ZS-X11 series
BLD-300 / BLD-510
BTS7960 (IBT-2 modules)
ODrive
VESC
Industrial and industrial-light drives such as Nanotec, Leadshine, Oriental Motor, Trinamic, Delta Electronics, Omron, SINAMICS, Maxon, Bosch Rexroth, Parker, Lexium, Panasonic

Specific compatibility depends on wiring and firmware profile. Some drivers are already used in real applications, others are under evaluation.

Comparison / Positioning

From Controllers to Motion-Control System Cores

Most controllers are designed to run code.
DUILIO F4 is designed to run machines.
This comparison highlights architectural differences, not raw performance.

Segments filled indicate level from 0 to 4.

Controller	5V logic compatibility	High-resolution analog inputs	Designed failsafe logic	Multi-motor coordination	Wide input voltage range	Can power peripherals (e.g. Raspberry Pi)	Works with external motor drivers	System watchdog & safety states	Time to a working motion system	Cost efficiency (typical)
Arduino UNO / MKR
Arduino GIGA R1
ESP32
STM32 Nucleo
DUILIO F4

Note: Scores reflect typical system-level usage, not raw MCU capabilities. General-purpose boards may require extra hardware and firmware to reach similar safety and motion features.

Why it exists / Problem it solves

The story behind Duilio

I was born in the early 1980s. As a kid, I spent hours building improvised tracks: toy cars, RC projects, and homemade push go-karts in a soapbox style, like today's Red Bull races. Today we would call them maker projects. Back then, it was simply how I played.

I studied mechanical engineering. For many years now, I've been working as a designer for a large company. Not my own.

But outside of work, I've always remained a maker. That's where Duilio comes from.

Duilio is part of a broader remote-driving project. The idea was to allow someone who hasn't been able to leave home for many years to control a real machine remotely from their PC, as if they were there.

One of the first applications was mowing the grass in my garden from a distance. A real machine, with real motors and real problems.

During development, I kept hitting the same limitation: motors existed, drivers worked, but the most fragile part was always the same -- the motion logic.

Not so much because of what it did, but because of how it changed every time.

With each different driver and each different controller, the programming model changed. Solutions became obsolete quickly, and development boards grew less and less compatible with each other.

And sooner or later, something subtle would ruin the balance: small electrical noise issues, extra components added as patches, software adapted or rewritten every time.

Ramps, limits, coordination, fault handling. Every project was almost a fresh start.

At some point, I decided to do something simple: design a proper board to control motors.

Not for a quick prototype. But for a real machine.

That board turned out better than expected. And that's where Duilio was born.

Today, Duilio is a solid foundation for motion control: a system designed to add safety, coordination, and repeatability on top of external motor drivers, without reinventing everything every time.

If you're building a real machine, Duilio comes from exactly the same kind of problem.

-- Fabio Giuliodori