Another single-board computer: Milk V Duo S

I stumbled upon another series of single board computers capable of running Linux online, the Milk V Duo S. These boards are interesting because they have both an ARM and a RISC V processor.

At first look, the idea of having two CPUs in one board is appealing. The possibility of dedicating one core to real‑time tasks while the other handles a full Linux stack seems like the ultimate design. As I dug into the documentation, it turns out that the board uses a simple switch to choose which core boots. In other words, you can boot either the ARM side or the RISC‑V side, but not run both concurrently. The board in conjunction runs FreeRTOS.

The Milk V Duo S is built around the SG2000 chip, an in‑house TPU for deep learning (about 0.5 TOPS under INT8), and IO capabilities. I paid approx $18 for the model with built in flash storage (8GB!) with no wifi. Also purchasable are models with PoE capabilities. 

My thoughts are if I can't find a use for a device with an ethernet port, then adding wifi makes no difference. If I can then justify a project that would necessitate wifi, then wifi becomes a priority. Otherwise, I end up collecting microcontrollers and small computers for the sake of them.

Now, the funny thing is, if you plan to use the microSD card slot, you cannot access the eMMC storage (!!!). From: https://milkv.io/docs/mars/compute-module/boot

In addition, the eMMC version shares the hardware interface with the SD card, so they cannot be used at the same time. 

While frustrating, 8GB flash storage is more than enough for a small system like this and the ability to flash the onboard storage using a microSD card, instead of UART, is agreeable. The docs to flash the onboard storage from SD aren't entirely clear, nevermind the possibility of wanting to flash other Linux systems. The other way is to flash directly to the eMMC using their Windows programs  or a CLI Python package. I wasn't able to get the Python util working on my Macbook and didn't feel like spinning up a VM for such a trivial procedure so I went with the SD card method.

For flashing the stock image, you can download them here: https://github.com/milkv-duo/duo-buildroot-sdk-v2/releases/ choosing either ARM or RISCV emmc images, and transfer to an SD card. Inserting the SD card with the system image, lets the board flash the internal eMMC storage with the OS. 

.
├── boot.emmc
├── fip.bin
├── META
│   ├── metadata.txt
│   └── misc_info.txt
├── partition_emmc.xml
├── rootfs_ext4.emmc
└── utils
   ├── cimg2raw
   ├── cvi_mipi_tx.ko
   ├── progress
   ├── update-script.sh
   ├── update-script.sh_
   └── upgrading.jpg

Now, for the purpose of flashing, the board will look for certain files to run upon boot with an SD card inserted, namely utils/update-script.sh (see here) which comes from boot.emmc, which is built into the image itself (see here).
 The update-script.sh script inserts a few kernel modules, sets up /dev and proceeds to run ./update-script.sh_
The actual flashing part is:

SCRIPT_PATH=`dirname $0`
TOP="$SCRIPT_PATH/../"
if [ -f $TOP/boot.emmc ];then
$SCRIPT_PATH/cimg2raw $TOP/boot.emmc
dd if=$TOP/boot.emmc of=/dev/mmcblk0p1
fi
if [ -f $TOP/logo.jpg ];then
$SCRIPT_PATH/cimg2raw $TOP/logo.jpg
dd if=$TOP/logo.jpg of=/dev/mmcblk0p2
fi
if [ -f $TOP/rootfs_ext4.emmc ];then
$SCRIPT_PATH/cimg2raw $TOP/rootfs_ext4.emmc
dd if=$TOP/rootfs_ext4.emmc of=/dev/mmcblk0p4
fi

This is what we're after. WIth this methodology, we can flash whatever OS by simply: 1. running a script on boot and 2. flashing our kernel and rootfs to specific partitions. In fact, there is even a build of Debian for the SG200x boards. The appropriate file used to install Debian is here, but you still must use the Windows tools to flash (link here).
 

Now, what to do with it? 

Imagine you’ve got a camera feeding raw frames in via the CSI interface. You load a trimmed‑down YOLO or MobileNet model onto the SG2000’s TPU, which accelerates operations like convolutions, activations, and pooling in hardware at around 0.5 TOPS under INT8. This means the TPU handles the heavy math locally. It can pull frames from memory, processing them for inference, then returning bounding boxes or labels back to the main OS (Linux in this case). The CPU is mostly free for housekeeping, networking, or additional logic, because the TPU’s pipeline and scheduler take care of the data flow. For edge AI projects, like real‑time detection or classification, this is great. It allows more headroom than a microcontroller, less overhead than a full GPU on a Pi.

The Milk V Duo S bridges a gap between microcontrollers like the ESP32/8266, which are great for lightweight tasks but lack a full OS, and something heftier like a Raspberry Pi, which comes with a huge ecosystem but can be overkill. The price of the Milk V series ($10-$20 CAD) compared to a Raspberry Pi 5 ($80+ CAD) is a huge difference here. Granted, the community of the Raspberry Pi series is much larger, you get what you pay for. 

Links

The vendor of the Milk V boards have released Buildroot repos so you can reproduce builds yourself: https://github.com/milkv-duo/duo-buildroot-sdk-v2/tree/1b43e1c0202b630c41f2f18a6d91bdaddf499c49
Linux <> RTOS examples: https://github.com/milkv-duo/duo-examples