> ## Documentation Index
> Fetch the complete documentation index at: https://docs.edgeimpulse.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Qualcomm QCC744M Evaluation Kit

The Qualcomm QCC744M Evaluation Kit (EVK) is a microcontroller development board built around the QCC744-2 SoC — a tri-radio chipset integrating 1x1 Wi-Fi 6, Bluetooth 5.4, and IEEE 802.15.4 (Thread and Zigbee-ready), powered by Qualcomm's first connectivity platform built around a RISC-V core. The 32-bit RV32IMAFCP MCU runs at up to 325 MHz with FPU and DSP support. The QCC744M module includes 4 MB of PSRAM and an external 8 MB flash chip, and is based on the Bouffalo Lab BL61x/BL618 chipset lineage.

Edge Impulse supports the QCC744M EVK through a dedicated Zephyr firmware, so you can sample sensor data, build models, and run trained machine learning models directly on the device. The Edge Impulse firmware for this development board is open source and hosted on GitHub: [edgeimpulse/firmware-qc-qcc744m-evk](https://github.com/edgeimpulse/firmware-qc-qcc744m-evk).

<Frame caption="Qualcomm QCC744M EVK">
  <img src="https://mintcdn.com/edgeimpulse/vgQdysbGgOtr_C16/.assets/images/qcc774m-evk/qcc744m_evk.png?fit=max&auto=format&n=vgQdysbGgOtr_C16&q=85&s=7453f9afb3e7b774141202a6b35bc362" width="512" height="781" data-path=".assets/images/qcc774m-evk/qcc744m_evk.png" />
</Frame>

## Zephyr support

The QCC744M EVK is supported upstream in the Zephyr RTOS as the `qcc744m_evk` board (board qualifier `bl618m05q2i`). For board-level details, pin mappings, and console configuration, see the [Zephyr `qcc744m_evk` board documentation](https://docs.zephyrproject.org/latest/boards/qcom/qcc744m_evk/doc/index.html).

Edge Impulse integration is provided by our [Edge Impulse SDK for Zephyr](https://github.com/edgeimpulse/edge-impulse-sdk-zephyr) module. This module is pulled in automatically as a west module by the [QCC744M EVK firmware](https://github.com/edgeimpulse/firmware-qc-qcc744m-evk) manifest, and provides the on-device inferencing SDK together with the Kconfig options that enable it in your build.

## Key features

* **SoC:** Qualcomm QCC744-2 (based on the Bouffalo Lab BL618 / BL61x series)
* **CPU:** 32-bit RV32IMAFCP RISC-V MCU, up to 325 MHz, with FPU and DSP support
* **Memory:** 4 MB PSRAM, 8 MB external flash
* **Connectivity:** 1x1 Wi-Fi 6, Bluetooth 5.4, IEEE 802.15.4 (Thread / Zigbee-ready)
* **Peripherals:** UART, SPI, I2C, I2S, ADC, GPIO
* **Serial console:** UART0 over the onboard USB-serial converter (115200 baud, 8N1)

## Setting up the board

### USB connections

The EVK has two USB-C ports, and they are not interchangeable:

* The **left USB-C** connects to the on-board CH347 USB-to-UART/JTAG bridge. It enumerates as **two serial ports** (listed as `wch.cn` devices, for example `/dev/tty.usbmodem…` on macOS) and carries both the **serial console and the flashing UART**. Use this port for everything in this guide.
* The **right USB-C** is the QCC744's **native USB**, which is only active once application firmware brings it up. It does not present a serial port at rest and is **not** used for flashing.

Connect the left USB-C to your computer; the on-board power LED confirms the board is powered.

### Jumpers and buttons

The CH347 bridge signals reach the SoC through the **J3** header (UART / DTR1 / JTAG selects), and the SoC is powered through the jumpers along the board edge:

* Keep the **UART** jumpers on **J3** fitted — they carry the console and flashing UART between the bridge and the SoC.
* The **DTR1** select on **J3** ties the bridge's DTR line to the SoC boot pin (GPIO2). Fitting it lets the flashing tool pull the board into download mode automatically (see [Troubleshooting](#troubleshooting)).
* The **power jumpers** at the board edge must be fitted for the SoC to receive power.

The **BOOT** button holds the boot strap (GPIO2) high and the **RESET** button resets the SoC — together they put the board into UART download mode (see [Flashing the firmware](#flashing-the-firmware)).

## Supported sensors

The Edge Impulse reference firmware supports the following Arduino Modulino boards and sensors:

* The [Arduino Modulino Movement](https://docs.zephyrproject.org/latest/boards/shields/arduino_modulino_movement/doc/index.html) (ST LSM6DSO 6-axis IMU) over I2C, for motion and vibration data.
* The Arduino Modulino Pixels board for visual status feedback.
* The Arduino Modulino Buttons board for physical control.
* The on-board **ADC** channels, for analog sensor data.

To connect the Arduino Modulino Movement to the EVK:

| Modulino Movement | QCC744M EVK |
| ----------------- | ----------- |
| GND               | GND         |
| 3V3               | VDD\_3V3    |
| SDA               | GPIO23      |
| SCL               | GPIO24      |

## Building the firmware

Before you begin, install the [Zephyr SDK and the `west` tool](https://docs.zephyrproject.org/latest/develop/getting_started/index.html), the [Edge Impulse CLI](/tools/clis/edge-impulse-cli), and Node.js.

<Steps>
  <Step title="Initialize the west workspace">
    Initialize a west workspace from the firmware repository and pull in Zephyr, the Edge Impulse SDK for Zephyr module, and all dependencies:

    ```bash theme={"system"}
    west init -m https://github.com/edgeimpulse/firmware-qc-qcc744m-evk qcc744m-workspace
    cd qcc744m-workspace/firmware-qc-qcc744m-evk
    west update
    ```
  </Step>

  <Step title="Add your model">
    In [Edge Impulse Studio](https://studio.edgeimpulse.com), go to **Deployment**, select the **Zephyr library** deployment option, and click **Build**. Extract the downloaded `.zip` into the `model/` folder so that it contains `model-parameters/`, `tflite-model/`, and the model `CMakeLists.txt`.
  </Step>

  <Step title="Build">
    ```bash theme={"system"}
    west build -b qcc744m_evk
    ```

    The application binary is generated at `build/zephyr/zephyr.bin`.
  </Step>
</Steps>

## Flashing the firmware

The QCC744M firmware includes a flashing script for programming the board over UART.

<Steps>
  <Step title="Enter flash mode">
    Hold the **BOOT** button (left), press and release **RESET** (right), then release **BOOT**. The board is now in UART flash (ISP) mode.

    <Frame caption="QCC744M EVK BOOT (left) and RESET (right) buttons">
      <img src="https://mintcdn.com/edgeimpulse/vgQdysbGgOtr_C16/.assets/images/qcc774m-evk/buttons.jpg?fit=max&auto=format&n=vgQdysbGgOtr_C16&q=85&s=d534987f4495b14ac96c430902f346a5" width="1200" height="711" data-path=".assets/images/qcc774m-evk/buttons.jpg" />
    </Frame>
  </Step>

  <Step title="Flash the firmware">
    Flash the bootloader and application image the first time:

    ```bash theme={"system"}
    ./flash.sh --allboot2
    ```

    The bootloader only needs to be flashed once per board. For subsequent application updates, use:

    ```bash theme={"system"}
    ./flash.sh
    ```
  </Step>

  <Step title="Boot the firmware">
    Press **RESET** to boot into the Edge Impulse firmware.
  </Step>
</Steps>

<Info>
  Prefer a GUI? Qualcomm's Windows-only **QConn Flash** utility from the [Qualcomm QCC74x SDK](https://git.codelinaro.org/clo/qcc7xx/QCCSDK-QCC74x) is an alternative. Enter flash mode as above, flash the bootloader once to `0x0`, then flash `zephyr.bin` to `0x2000`.
</Info>

## Connecting to Edge Impulse

The firmware exposes a serial console on **UART0** at **115200** baud (8 data bits, no parity, 1 stop bit) over the onboard USB-serial converter. You can drive it directly with the Edge Impulse CLI or with any serial terminal.

### Running inference

To run your impulse, open a serial connection to the board and issue one of the following AT commands, or use the Edge Impulse CLI:

| Command              | Description                       |
| -------------------- | --------------------------------- |
| `AT+RUNIMPULSE`      | Run the impulse once              |
| `AT+RUNIMPULSECONT`  | Run the impulse continuously      |
| `AT+RUNIMPULSEDEBUG` | Run the impulse with debug output |
| `b`                  | Stop an active inference run      |

```bash theme={"system"}
edge-impulse-run-impulse
```

You can also use the Arduino Modulino Buttons board:

| Button | Action                        |
| ------ | ----------------------------- |
| A      | Toggle inference              |
| B      | Toggle the data forwarder     |
| C      | Cycle between the IMU and ADC |

The Arduino Modulino Pixels board provides the corresponding status feedback:

| State                        | Colour  |
| ---------------------------- | ------- |
| Idle                         | Green   |
| Inference running            | Yellow  |
| Data forwarder using the IMU | Blue    |
| Data forwarder using the ADC | Magenta |

Button A starts or stops inference, while the serial interface exposes the same workflow through `AT+RUNIMPULSE`, `AT+RUNIMPULSECONT`, `AT+RUNIMPULSEDEBUG`, and `b` to stop an active inference run.

### Collecting data with the data forwarder

The firmware can stream raw IMU or ADC samples over serial at a fixed frequency (`CONFIG_SAMPLING_FREQUENCY_HZ`, 50 Hz by default) so you can capture training data with the [Edge Impulse data forwarder](/tools/clis/edge-impulse-cli/data-forwarder). Use the Modulino Buttons board to cycle between the IMU and ADC source. The Modulino Pixels board indicates the active source: blue for IMU data and magenta for ADC data.

<Steps>
  <Step title="Enter data forwarder mode">
    Press button B on the Arduino Modulino Buttons board, or send `AT+STARTDATAFWD` over the serial connection. Press button B again, or send `AT+STOPDATAFWD`, to exit.
  </Step>

  <Step title="Start the data forwarder">
    ```bash theme={"system"}
    edge-impulse-data-forwarder
    ```

    Follow the prompts to log in, select your project, and name the sensor axes. You can then collect samples from the **Data acquisition** page in Studio.
  </Step>
</Steps>

### Example: the sample motion-recognition project

The [qcc744m-evk: Continuous motion recognition](https://studio.edgeimpulse.com/public/1078774/latest) public project is a complete example built from IMU data captured through the data forwarder — a spectral-features and classifier impulse that recognizes movement gestures. Clone it into your own account to start from a working impulse.

<Frame caption="The qcc744m-evk Continuous motion recognition sample project in Edge Impulse Studio">
  <img src="https://mintcdn.com/edgeimpulse/vgQdysbGgOtr_C16/.assets/images/qcc774m-evk/studio-project-overview.png?fit=max&auto=format&n=vgQdysbGgOtr_C16&q=85&s=2466afaa1fa2cc02ec72ba737046ca9a" width="2880" height="1800" data-path=".assets/images/qcc774m-evk/studio-project-overview.png" />
</Frame>

## Deploying an updated model

Because the model is compiled into the firmware as a Zephyr library, updating your model means rebuilding and re-flashing:

1. Rebuild your model in Studio (**Deployment** → **Zephyr library** → **Build**) and extract it into the `model/` folder.
2. Rebuild the firmware with `west build -b qcc744m_evk`.
3. Reflash the board as described in [Flashing the firmware](#flashing-the-firmware).

## Troubleshooting

<AccordionGroup>
  <Accordion title="No serial port appears">
    Use the **left USB-C** (the CH347 bridge), not the right (native USB) port. On macOS the bridge appears as two `wch.cn` `usbmodem` devices; the console and flashing UART is one of the two — if one does not respond, use the other.
  </Accordion>

  <Accordion title="Flashing prints resp: FL and 'handshake failed'">
    The SoC booted its application instead of entering ROM download mode — the boot strap (GPIO2) was not held at reset. Confirm you are flashing over the correct port (the bridge exposes **two** serial ports; try the other one), and make sure the programmer can drive BOOT: fit the **DTR1** select on **J3**, or hold the **BOOT** button while tapping **RESET**.
  </Accordion>

  <Accordion title="The data forwarder shows 'No valid sensor readings received from device'">
    The board must be running the Edge Impulse firmware **and** actively streaming. Flash the firmware, then send `AT+STARTDATAFWD` to enter data-forwarder mode before starting `edge-impulse-data-forwarder`. If auto-detection still fails, pass the rate explicitly with `--frequency 50`.
  </Accordion>
</AccordionGroup>

## Next steps: building a machine learning model

With everything set up you can now build your first machine learning model with these tutorials:

* [Continuous motion recognition](/tutorials/end-to-end/motion-recognition)
* [Recognize sounds from audio](/tutorials/end-to-end/sound-recognition)
* [Responding to your voice](/tutorials/end-to-end/keyword-spotting)

Looking to connect different sensors? The [Data forwarder](/tools/clis/edge-impulse-cli/data-forwarder) lets you easily send data from any sensor into Edge Impulse.