Build Firmware
Without Writing Code
eFlow is EmbeddedOS's visual block programming environment. Drag GPIO, timer, AI, and protocol blocks onto a canvas, connect them with wires, and eFlow generates production-ready C code that runs on any EoS-supported board.
What is eFlow?
eFlow is a node-based visual editor — the same paradigm used by Unreal Engine Blueprints, Node-RED, and Max/MSP — but designed specifically for embedded firmware on EmbeddedOS.
Block-Based
Every hardware capability is a block: GPIO, UART, I²C, SPI, ADC, PWM, timers, AI inference, PID controllers, filters. Drag them onto the canvas.
Wire-Connected
Draw wires between output ports and input ports. eFlow validates type compatibility in real time — you cannot connect incompatible blocks.
Generates Real C
Click Generate and eFlow produces readable, HAL-idiomatic C code. No obfuscated output — you can read, modify, and extend the generated code.
void sensor_task(void *arg) {
eos_i2c_init(I2C1, 400000);
eos_kalman_t kf = eos_kalman_init(0.1f, 1.0f);
while (1) {
float raw = bme280_read_temp(I2C1, 0x76);
float filtered = eos_kalman_update(&kf, raw);
if (filtered > 30.0f) {
eos_uart_printf(UART1, "[ALERT] Temp=%.1f°C\n", filtered);
} else {
eos_uart_printf(UART1, "Temp=%.1f°C\n", filtered);
}
eos_task_delay_ms(1000);
}
}The 8-Step eFlow Pipeline
From blank canvas to flashed firmware in 8 steps. Each step is handled by eFlow and ebuild — no manual toolchain configuration needed.
Design
Open eFlow in your browser or via ebuild eflow open. Drag blocks from the palette onto the canvas.
Connect
Draw wires between block output ports and input ports. eFlow validates type compatibility in real time.
Configure
Click any block to set its parameters: pin numbers, baud rates, thresholds, model paths, timer intervals.
Simulate
Click Run in eFlow to simulate the block diagram in-browser. Virtual GPIO pins respond, UART output appears in the console.
Generate
Click Generate Code. eFlow produces a complete, readable C source file that uses the EoS HAL — no magic, no black box.
Build
ebuild build compiles the generated code. The output is a standard .elf / .bin firmware image.
Validate
ebuild analyze runs stack depth analysis, MISRA checks, and memory overlap detection on the generated firmware.
Deploy
ebuild flash writes the firmware to your board via JTAG, SWD, or USB bootloader. ebuild monitor shows live output.
Block Library
Every block generates a specific EoS HAL call. Click a block to see the generated C code.
GPIO Output
Drive a pin HIGH or LOW. Connects to Timer or Logic blocks.
eos_gpio_write(GPIO_PA5, HIGH);
GPIO Input
Read a pin state. Outputs 0 or 1 to downstream blocks.
uint8_t v = eos_gpio_read(GPIO_PC13);
UART Write
Send a string or formatted value over UART.
eos_uart_printf(UART1, "val=%d\n", x);
ADC Read
Sample an analog pin in millivolts (0–3300mV).
uint32_t mv = eos_adc_read_mv(ADC1_CH0);
PWM Output
Set duty cycle (0–100%) on a PWM channel.
eos_pwm_set_duty(PWM_CH0, duty);
Real-World Use Cases
Common embedded patterns that eFlow handles in minutes — no manual HAL calls, no register-level debugging.
Sensor Data Pipeline
Read a BME280 temperature sensor over I²C every 1 second, apply a Kalman filter, and send the result over UART. No manual register manipulation needed.
Motor Speed Controller
Read encoder pulses on a GPIO interrupt, compute RPM, run a PID loop against a setpoint, and output the corrected duty cycle to a PWM channel.
Edge AI Classifier
Sample an ADC microphone at 16kHz, run FFT to extract frequency features, feed into a TFLite keyword-spotting model, and toggle a GPIO on detection.
CAN Bus Gateway
Receive CAN frames from a vehicle bus, parse the payload, apply a threshold check, and relay filtered data over UART to a host computer.
eFlow vs Writing C Directly
eFlow is not a replacement for writing C — it is a faster starting point. Here is when to use each approach.
CAD + eFlow Integration
When you import a KiCad schematic via ebuild cad analyze, eFlow automatically populates all block pin fields with the correct pin names from your schematic. No manual lookup in the datasheet.
Import Schematic
Run ebuild cad analyze my-board.kicad_sch. ebuild reads your KiCad schematic and extracts all MCU pin assignments.
Auto-Populated Blocks
Open eFlow. Every GPIO, UART, SPI, and I²C block is pre-configured with the correct pin names from your schematic (e.g. UART_TX = PA9).
Simulate Your Real Board
Run the simulation. Virtual peripherals match your actual schematic — the BME280 on I²C1 address 0x76 responds exactly as it will on real hardware.
Ready to Try eFlow?
Open the interactive simulator and run an eFlow block diagram in your browser — no install required.