USB CDC RX Sample App

Description

The USB CDC RX Sample application demonstrates USB CDC communication and data reception performance on the supported boards for this application. It performs comprehensive USB CDC testing including high-volume data reception, throughput measurement, and performance analysis to ensure reliable high-speed USB data transfer capabilities.

The sample includes multiple USB CDC operations:

• USB CDC initialization: Initialize USB CDC serial communication with host PC.

• High-volume reception: Receive large amounts of pre-generated data over serial port.

• Throughput measurement: Measure and report data transfer rates in B/s, KB/s, or MB/s.

• Performance analysis: Analyze USB CDC reception performance under various conditions.

• Data integrity validation: Ensure received data integrity during high-speed transfers.

• Serial port management: Efficiently manage serial port communication for testing.

During each run, the app logs initialization status, reception progress, throughput measurements, and performance statistics. This makes it easy for end users to confirm that USB CDC setup and high-speed reception operations are working as expected.

The latest example structure uses a common application source tree with board-specific hardware setup kept under hw/<BOARD>/. For this app:

• Common application sources such as main.c and USB CDC reception files stay in the app root.

• Application defconfigs are stored under configs/.

• Board and hardware-specific setup is selected from hw/<BOARD>/, for example hw/SR110_RDK/.

The application can also be exported and built as a standalone app repository. In that flow, keep this app in its own directory, point SRSDK_DIR to the SDK root, and build from the app directory itself. For the full application workflow model, see Astra MCU SDK User Guide.

Supported Boards

This application supports:

• SR110_RDK

Select the defconfig that matches your target board, and the build system will pick the corresponding board-specific hardware setup from hw/<BOARD>/.

Prerequisites

• Choose one setup path:

  • CLI: Setup and Install SDK using CLI

  • VS Code: Setup and Install SDK using VS Code

• Install required Python package for ser_test.py:

  • pyserial

pip install pyserial

Test Case Selection

Before building, choose the testcase defconfig that matches your target board.

You can:

• Select the required defconfig directly from the application’s configs/ directory.

• Run make list_defconfigs from the application directory to list all supported defconfigs.

Available defconfigs:

• sr110_rdk_cm55_usb_cdc_rx_sample_app_defconfig

Building and Flashing the Example using VS Code

Use the VS Code flow described in the SR110 guide and the VS Code Extension guide:

• SR110 Build and Flash with VS Code

• Astra MCU SDK VS Code Extension User Guide

Build (VS Code):

1. Open Build and Deploy -> Build Configurations.

2. Select the usb_cdc_rx_sample_app project configuration in the Project Configuration dropdown.

3. Build with Build (SDK+Project) for the first build, or Build (Project) for rebuilds.

Flash (VS Code):

1. Use Image Conversion to generate the flash image.

2. Use Image Flashing (SWD/JTAG) to flash the firmware image.

---

Building and Flashing the Example using CLI

Use the CLI flow described in the SR110 guide:

• SR110 Build and Flash with CLI

Build (CLI):

1. Build from the application directory itself:

   cd <sdk-root>/examples/usb_examples/usb_cdc_rx_sample_app
   export SRSDK_DIR=<sdk-root>
   make <app_defconfig> BUILD=SRSDK
   

2. For faster rebuilds when only app code changes, reuse the app-local installed SDK package:

   cd <sdk-root>/examples/usb_examples/usb_cdc_rx_sample_app
   export SRSDK_DIR=<sdk-root>
   make build
   

3. If this app has been exported to its own repository, use the same commands from that exported app directory after setting SRSDK_DIR to the SDK root.

Flash (CLI):

1. Activate the SDK venv (required for image generation tools):

   # Linux/macOS
   source <sdk-root>/.venv/bin/activate
   # Windows PowerShell
   .\.venv\Scripts\Activate.ps1
   

2. Generate the flash image:

   cd <sdk-root>/tools/srsdk_image_generator
   python srsdk_image_generator.py \
     -B0 \
     -flash_image \
     -sdk_secured \
     -spk "<sdk-root>/tools/srsdk_image_generator/Inputs/spk_rc4_1_0_secure_otpk.bin" \
     -apbl "<sdk-root>/tools/srsdk_image_generator/Inputs/sr100_b0_bootloader_ver_0x012F_ASIC.axf" \
     -m55_image "<sdk-root>/examples/usb_examples/usb_cdc_rx_sample_app/out/sr110_cm55_fw/release/sr110_cm55_fw.elf" \
     -flash_type "GD25LE128" \
     -flash_freq "67"
   

3. Flash the firmware image:

   cd <sdk-root>
   python tools/openocd/scripts/flash_xspi_tcl.py \
     --cfg_path tools/openocd/configs/sr110_m55.cfg \
     --image tools/srsdk_image_generator/Output/B0_Flash/B0_flash_full_image_GD25LE128_67Mhz_secured.bin \
     --erase-all
   

---

Running the Application using VS Code Extension

1. Connect a USB cable to the application USB port on the SR110 board and press RESET.

2. For logging output, click SERIAL MONITOR and connect to the DAP logger port on J14.

   • To make it easier to identify, ensure only J14 is plugged in (not J13).

   • The logger port is not guaranteed to be consistent across OSes. As a starting point:

     • Windows: try the lower-numbered J14 COM port first.

     • Linux/macOS: try the higher-numbered J14 port first.

   • If you do not see logs after a reset, switch to the other J14 port.

3. On Windows, convert SYNA CDC 1 to a serial COM port before running ser_test.py:

   1. Open Device Manager and go to Universal Serial Bus devices.

      

   2. Right-click SYNA CDC 1 and select Update driver.

      

   3. Select Browse my computer for drivers.

      

   4. Select Let me pick from a list of available drivers on my computer.

      

   5. Choose USB Serial Device and complete the installation.

      

   6. After the update, a new entry appears under Ports (COM & LPT) as USB Serial Device (COMx) (for example, COM4).

      

      • Use that COMx value as <PORT_NAME> in the script command.

4. Run the throughput test script on that USB CDC COM port:

   python ser_test.py <PORT_NAME>
   

Expected Logs

PS C:\Release_1.3.0\Astra_MCU_SDK1.3.0\examples\SR110_RDK\usb_examples\usb_cdc_rx_sample_app> python .\ser_test.py COM4
Testing port COM4
Throughput: 9.77 MB/s

Features of Python Script

• Serial Port Throughput Measurement: Measures write throughput over serial.

• Human-Readable Output: Prints throughput in B/s, KB/s, or MB/s.

• Simple Usage: Requires only the serial port argument.