Skip to content
Montic Studio

Getting started with Montic W04 - CH32V208

The Montic W04 is a development board compatible with the Pro Micro form factor. It uses WCH’s CH32V208 low-power Bluetooth SoC processor, which integrates a single-core high-performance 32-bit RISC-V CPU and supports Bluetooth® 5 (LE) wireless connectivity. It is an excellent first board for exploring wireless applications.

Hardware overview

The Montic W04 is based on the WCH CH32V208 processor, a 32-bit RISC-V low-power Bluetooth SoC. It supports clock frequencies up to 144MHz, provides 64KB of SRAM, and up to 480KB of Flash. In addition to Bluetooth wireless applications, the Montic W04 also supports a CAN controller, a USB 2.0 full-speed host/device controller, and common peripherals like UART, SPI, I2C, and ADC.

The board also includes 16Mbits (2MBytes) of onboard Flash storage, a WS2812 addressable RGB LED that supports 256 brightness levels and 16 million colors, and a tactile switch. Our goal is to keep the board as compact as possible while offering enough interaction options.

For power, the board uses a USB-C connector so you can rely on the USB-C cables you already have. The Montic W04 also retains battery power support and includes onboard charge and discharge circuitry.

On the IO side, aside from two additional power pins, the Montic W04 keeps IO compatibility with the Pro Micro while the CH32V208 provides rich peripheral capabilities and enhanced I/O ports.

Pinout diagram

Before you start using the product, take a moment to understand the pinout. Montic keeps the Pro Micro form factor and compatibility with a few adjustments. There are 26 pins in total. The detailed pinout diagram will be provided below.

TODO:

  • Clarify which pins are used and how they are multiplexed.
  • Provide a complete pinout diagram that explains pin multiplexing (similar to the example below). sample

Microcontroller (MCU)

The Montic W04 uses WCH’s CH32V208, a 32-bit processor based on the RISC-V architecture. The CPU core is QingKe V4C with instruction set extensions I, M, A, and C.

ModelInstruction setHardware stack depthInterrupt nesting levelTable-free interrupt channelsPipelineVector table modeExtended instructions (XW)Number of memory protection regions
QingKe V4ARV32IMAC2243Address/Instruction❌4
QingKe V4BRV32IMAC2243Address/Instruction✔4
QingKe V4CRV32IMAC2243Address/Instruction✔4
QingKe V4FRV32IMACF3843Address/Instruction✔4

Instruction set notes:

  • I: Supports integer operations with 32 integer registers
  • M: Supports integer multiplication and division instructions
  • A: Supports atomic instructions
  • C: Supports 16-bit compressed instructions
  • F: Supports single-precision floating-point operations with 32 floating-point registers
  • XW: QingKe processors add an extended RISC-V instruction set for additional 16-bit compressed instructions on byte and half-word operations. Use the MRS compiler or toolchains provided with it to enable these instructions.

Product features

ItemSpecification
CPU frequencyUp to 144MHz
Flash (Bytes)128KB or 480KB(1)
SRAM (Bytes)64KB
USB Full Speed Device (USBD)1 x USB 2.0, supports USB FS 12Mbps and Low-speed 1.5Mbps modes(2)
USB Full Speed Host (USBHD)1 x USB 2.0 Host
Bluetooth® 5 (LE)Supports BLE 5.3(3)
CAN1x CAN 2.0A and 2.0B(2)
GPIO ports53
Other peripheral interfaces4x UART / 2x SPI / 2x I2C / ADC / 5x TIMER / 2x WDT

(1) The Flash size refers to the zero-wait operation region R0WAIT; the non-zero-wait region is 480K - R0WAIT.

(2) The USBD and CAN controllers share a dedicated 512-byte SRAM area for data transmission and reception. When using USBD and CAN simultaneously, allocate this shared area carefully to avoid data conflicts.

(3) The Bluetooth® 5 (LE) protocol stack is provided by WCH as a binary library. Source code is not provided; only SDK API documentation is available. See the Resources section for more details.

Low-power modes

The CH32V208 supports three low-power modes, allowing you to balance low power consumption, short startup time, and multiple wake-up events based on your scenario. From the perspective of processor, peripherals, and voltage regulator behavior, the modes are:

  • Sleep mode: The core stops running while all peripherals (including core-private peripherals) continue to run.
  • Stop mode: All clocks stop. After wake-up, the system continues execution.
  • Standby mode: All clocks stop. After wake-up, the microcontroller resets (power-on reset).
ModeHow to enterWake-up sourceClock impactVoltage regulator
SleepWFI/WFEAny interrupt or wake-up eventCore clock off; other clocks unaffectedNormal
StopSet SLEEPDEEP to 1, clear PDDS to 0, then WFI/WFEAny external interrupt/event (configured in the external interrupt registers)HSE, HSI, PLL, and peripheral clocks are offNormal when LPDS=0; low-power when LPDS=1
StandbySet SLEEPDEEP to 1, set PDDS to 1, then WFI/WFERising edge on WKUP pin, RTC alarm event, NRST pin reset, or IWDG reset. Note: Any event can wake the system, but it resets after wake-up.HSE, HSI, PLL, and peripheral clocks are offOff

For more information on the QingKe V4C processor and CH32V208, see the Resources section.

Onboard Flash

The Montic W04 includes 2MBytes of Flash to expand the ROM space. It communicates via the CH32V208’s Serial Peripheral Interface (SPI) memory interface.

For more details, refer to the Flash datasheet:

ZD25WQ16B datasheet

Power

The Montic W04 can be powered in multiple ways: USB-C, lithium battery, or direct power input. Thanks to the onboard charge/discharge circuitry, you can charge a lithium battery via USB-C or other power inputs.

Supported power inputs and their maximum voltage/current:

USB-CVBUS pinLithium battery
Max voltage (V)553.3
Max current (mA)500??

USB-C

The USB-C port is the most convenient power option. You can use it to provide power to the device or charge the lithium battery connected to the board.

Lithium battery

A dedicated JST 1.25mm connector is provided for lithium batteries. The circuit supports charging while the battery is connected.

VBUS pin

When using an external power supply, connect to the VBUS pin (5V). Ensure the external power supply can deliver sufficient current.

Buttons and LED

ComponentQuantityPurpose
WS2812 RGB LED1Addressable RGB LED for status indication or lighting effects
BOOT button1Boot mode selection

Board dimensions

TODO: add a dimensional drawing including IO spacing and layout.

Getting started

CH32V208 and Montic W04 products

CH32V20x Series Development Documentation

More resources

Development environment

Using CH32V20x EVT

  1. Install the WCH-ISP-Tool (Windows) or wchisp (macOS/Linux).
  2. Download the reference examples from CH32V20xEVT, which include CH32V208 application samples and documentation, including BLE stack manuals and BLE OTA guidance.
  3. Install MounRiver Studio (Embedded RISC-V IDE) for Windows or Linux, or use the macOS Toolchains package from the same site.
  4. Ensure you have a USB-C data cable and the Montic W04 development board.

The CH32V20xEVT package contents include:

  • CH32V20x_List.txt

  • CH32V20x_List_EN.txt

  • Directory

    EXAM/

    • DirectoryAPPLICATION/
      • DirectoryUSBPD/
        • …
      • DirectoryWS2812_LED/
        • …
    • DirectoryBKP/
      • …
    • DirectoryBLE/
      • …
    • DirectoryCAN/
      • …
    • DirectoryCRC/
      • …
    • DirectoryDMA/
      • …

    …

    • DirectoryUSB/
      • …
    • DirectoryWWDG/
      • …
  • Directory

    PUB/

    • …

Set up MounRiver Studio

  1. Download and install MounRiver Studio. On the download page, choose the Windows version. Important: download the Embedded RISC-V IDE version.

  2. Unzip the downloaded package, open the extracted directory, and run the installer (for example, MounRiver_Studio_V192_Setup.exe). Follow the prompts to complete installation.

  3. Launch MounRiver Studio.

    After installation, start MounRiver Studio from the desktop shortcut or Start Menu. You should see a screen similar to the one below.

After setting up the software development environment, let’s create a program to blink the RGB LED.

  1. Load the WS2812_LED example.

    After installation, open MounRiver Studio and choose File -> Load.

  2. Navigate to the EXAM/APPLICATION/WS2812_LED folder.

    In the load dialog, browse to the EXAM/APPLICATION/WS2812_LED directory from the CH32V20xEVT package.

  3. Select the MDK folder inside WS2812_LED.

    Choose the Keil (MDK) project folder to open the example.

  4. Flash the example onto the Montic W04.

    With your board connected, click Download to flash the firmware. The onboard WS2812 LED should start blinking, confirming everything works.

Develop with Arduino

  1. Install the Arduino IDE.

    Download and install the latest Arduino IDE for your operating system.

  2. Add CH32V Arduino board support.

    The CH32V Arduino core is community-maintained. Follow the instructions in the arduino_core_ch32 repository to add the CH32V board manager URL to the Arduino IDE, then install the board package.

  3. Select the Montic W04 board.

    Go to Tools -> Board, choose CH32V EVT Boards Support > H32V20x, then in Tools -> Board Select, pick Montic W04 CH32V208CB.

  4. Verify the board definitions.

    After installing, check the boards.txt and pin definitions to confirm the Montic W04 configuration is present. If you need to add the board manually, append the following entry to packages/CH32V-dev/Ch32v-Mac/CH32V/core/riscv/boards.txt (path may vary by OS):

    Board definition snippet
    ##############################################################
    Montic_W04_CH32V208CB.name=Montic W04 CH32V208CB
    

    Montic_W04_CH32V208CB.cdcoptions=CDC disabled,CDC USB
    Montic_W04_CH32V208CB.upload.protocol=daplink
    Montic_W04_CH32V208CB.upload.maximum_size=475136
    Montic_W04_CH32V208CB.upload.speed=115200
    Montic_W04_CH32V208CB.upload.wait_for_upload_port=false
    

    Montic_W04_CH32V208CB.vid.0=0x1A86
    Montic_W04_CH32V208CB.pid.0=0x8010
    Montic_W04_CH32V208CB.vid.1=0x1A86
    Montic_W04_CH32V208CB.pid.1=0x8010
    

    Montic_W04_CH32V208CB.build.mcu=ch32v20x
    Montic_W04_CH32V208CB.build.core=ch32v20x
    Montic_W04_CH32V208CB.build.variant=Montic_W04
    Montic_W04_CH32V208CB.build.variant_system_lib=stdPeriph
    Montic_W04_CH32V208CB.build.board=Montic_W04
    Montic_W04_CH32V208CB.build.series=CH32V20x
    Montic_W04_CH32V208CB.build.product_line=CH32V208
    Montic_W04_CH32V208CB.build.chip=CH32V208CB
    Montic_W04_CH32V208CB.build.flash_ld=ld/Link.ld
    

    Montic_W04_CH32V208CB.build.led=PC13
    Montic_W04_CH32V208CB.build.vusb_pin=PC2
    Montic_W04_CH32V208CB.build.vbus_pin=PB8
    Montic_W04_CH32V208CB.build.pvdin_pin=PC15
    Montic_W04_CH32V208CB.build.neopixel_pin=PA2
    Montic_W04_CH32V208CB.build.usb_manufacturer=Montic
    Montic_W04_CH32V208CB.build.usb_product=W04
    Montic_W04_CH32V208CB.build.board_name=Montic W04
    

    Montic_W04_CH32V208CB.upload.maximum_ram_size=65536
    

    Montic_W04_CH32V208CB.build.openocdscript=ch32v20x_openocd.cfg
    

    Montic_W04_CH32V208CB.menu.clock.144=System Clock 144MHz
    Montic_W04_CH32V208CB.menu.bootloader.0=No bootloader
    Montic_W04_CH32V208CB.menu.timer.0=Default
    Montic_W04_CH32V208CB.menu.usb.0=MSC+CDC
    Montic_W04_CH32V208CB.menu.usb.1=CDC
    Montic_W04_CH32V208CB.menu.upload_method.0=via WCHISP
    

    Montic_W04_CH32V208CB.menu.upload_method.0.upload.tool=wlinkupload
    Montic_W04_CH32V208CB.menu.upload_method.0.build.BUILD_UPLOADER=wlink
    Montic_W04_CH32V208CB.menu.upload_method.0.build.BUILD_CDC=CDC
    Montic_W04_CH32V208CB.menu.upload_method.0.build.upload_flags=--name Montic W04 --chip ch32v208cb --reset 20 --path ./tools/wlink
    Montic_W04_CH32V208CB.menu.upload_method.0.upload.protocol=wlink
    

    Montic_W04_CH32V208CB.menu.upload_method.0.upload.params.verbose=-v
    Montic_W04_CH32V208CB.menu.upload_method.0.upload.params.quiet=-q
    Montic_W04_CH32V208CB.menu.upload_method.0.upload.pattern="{build.path}/{build.project_name}.elf"
    Montic_W04_CH32V208CB.menu.upload_method.0.upload.maximum_size=45571

    If you are using macOS, the paths will differ; adjust accordingly. After adding the board definition, update pins_arduino.h under variants/Montic_W04 with the W04 pin assignments:

    Pin definition snippet
    #ifndef Pins_Arduino_h
    #define Pins_Arduino_h
    

    #include <stdint.h>
    #include "soc/soc_caps.h"
    

    #define PIN_RGB_LED 15
    // BUILTIN_LED can be used in the Arduino API digitalWrite() like Blink.ino
    static const uint8_t LED_BUILTIN = SOC_GPIO_PIN_COUNT + PIN_RGB_LED;
    #define BUILTIN_LED LED_BUILTIN
    #define LED_BUILTIN LED_BUILTIN
    // RGB_BUILTIN and RGB_BRIGHTNESS can be used in the Arduino API neopixelWrite()
    #define RGB_BUILTIN    LED_BUILTIN
    #define RGB_BRIGHTNESS 64
    

    static const uint8_t TX = 29;
    static const uint8_t RX = 30;
    

    static const uint8_t SDA = 33;
    static const uint8_t SCL = 34;
    

    static const uint8_t SS = 13;
    static const uint8_t MOSI = 14;
    static const uint8_t MISO = 15;
    static const uint8_t SCK = 8;
    

    static const uint8_t A0 = 9;
    static const uint8_t A1 = 10;
    static const uint8_t A2 = 11;
    static const uint8_t A3 = 12;
    

    static const uint8_t D0 = 33;
    static const uint8_t D1 = 34;
    static const uint8_t D2 = 31;
    static const uint8_t D3 = 32;
    static const uint8_t D4 = 35;
    static const uint8_t D5 = 36;
    static const uint8_t D6 = 17;
    static const uint8_t D7 = 16;
    static const uint8_t D8 = 13;
    static const uint8_t D9 = 14;
    static const uint8_t D10 = 15;
    static const uint8_t D11 = 8;
    

    #endif /* Pins_Arduino_h */

  5. Restart the Arduino IDE and select Montic W04 as the target board.

    Go to Tools -> Board and choose Montic W04. You can also search directly in the board dropdown. If you encounter setup issues, refer to the arduino_core_ch32 repository for the latest guidance and support.

  6. Upload your first sketch.

    Click Upload to compile and flash your code. Once complete, the board is ready for use.

Serial demo

Let’s use Arduino to demonstrate serial output. This demo uses the Adafruit TinyUSB Library bundled as a Git submodule of arduino_core_ch32.

  1. Create a new Arduino sketch.

    With CH32V EVT Boards Support > H32V20x selected and Montic W04 CH32V208CB chosen under Tools -> Board Select, paste the following code:

    #include <Arduino.h>
    #include <Adafruit_TinyUSB.h> // required for USB Serial
    

    void setup () {
    }
    

    void loop () {
      delay(1000);
      Serial.println("1");
      delay(1000);
      Serial.println("2");
    }

    Save the sketch to a folder you can easily locate for later compilation outputs.

  2. Compile and upload the program.

    Click Verify in the Arduino IDE to ensure the code compiles.

    For the first upload, use the WCP In-system Programmer (ISP) as described in the Blink Demo step 4. Use Sketch -> Export Compiled Binary to obtain the .hex file.

  3. View serial output.

    After uploading, open Tools -> Serial Monitor in the Arduino IDE, set baud rate to 115200, and observe the printed output.

Resources and guides

Using CH32-RS Community Rust support projects for WCH 32-bit microcontrollers.
Using Embassy Embassy is a Rust-based asynchronous framework for embedded development.
Using the UF2 Bootloader An easy-to-use firmware update bootloader based on the MSC protocol.

Resources