mirror/tinyusb
3
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2026-03-30 19:33:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3278 from c1570/improved_docs

Browse Source 
Documentation improvements
This commit is contained in:
Ha Thach
2025-11-11 13:19:59 +07:00
committed by GitHub
parent 96f35fc0a5 a1ae5b20cc
commit 8a094e807b
25 changed files with 1767 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
.github/workflows/static_analysis.yml vendored
View File

@ -90,7 +90,8 @@ jobs:
path: ${{ steps.analyze.outputs.sarif-output }}
PVS-Studio:
if: github.repository_owner == 'hathach'
# Only run on non-forked PR since secrets token is required
if: github.repository_owner == 'hathach' && github.event.pull_request.head.repo.fork == false
runs-on: ubuntu-latest
strategy:
fail-fast: false
@ -141,7 +142,8 @@ jobs:
path: pvs-studio-${{ matrix.board }}.sarif
SonarQube:
if: github.repository_owner == 'hathach'
# Only run on non-forked PR since secrets token is required
if: github.repository_owner == 'hathach' && github.event.pull_request.head.repo.fork == false
runs-on: ubuntu-latest
env:
BUILD_WRAPPER_OUT_DIR: build_wrapper_output_directory
@ -184,7 +186,8 @@ jobs:
--define sonar.cfamily.compile-commands=${{ env.BUILD_WRAPPER_OUT_DIR }}/compile_commands.json
IAR-CStat:
#if: github.repository_owner == 'hathach'
# Only run on non-forked PR since secrets token is required
#if: github.repository_owner == 'hathach' && github.event.pull_request.head.repo.fork == false
if: false
runs-on: ubuntu-latest
strategy:

56
README.rst
View File

@ -1,26 +1,55 @@
TinyUSB
=======
|Build Status| |CircleCI Status| |Documentation Status| |Static Analysis| |Fuzzing Status| |License|
Sponsors
========
--------
TinyUSB is funded by: Adafruit. Purchasing products from them helps to support this project.
.. figure:: docs/assets/adafruit_logo.svg
:alt: Adafruit Logo
:align: left
:target: https://www.adafruit.com
TinyUSB Project
===============
.. raw:: html
<div class="clear-both"></div>
Overview
--------
.. figure:: docs/assets/logo.svg
:alt: TinyUSB
:align: left
TinyUSB is an open-source cross-platform USB Host/Device stack for embedded system, designed to be memory-safe with no dynamic allocation and thread-safe with all interrupt events are deferred then handled in the non-ISR task function. Check out the online `documentation <https://docs.tinyusb.org/>`__ for more details.
.. raw:: html
<div class="clear-both"></div>
TinyUSB is an open-source cross-platform USB Host/Device stack for embedded systems. It’s designed for memory safety
(no dynamic allocation) and thread safety (all interrupts deferred to non-ISR task functions). The stack emphasizes portability,
small footprint, and real-time performance across 50+ MCU families.
Key Features
------------
* **Thread-safe:** USB interrupts deferred to task context
* **Memory-safe:** No dynamic allocation, all buffers static
* **Portable:** Supports 50+ MCU families
* **Comprehensive:** Includes CDC, HID, MSC, Audio, and Host support
* **RTOS-friendly:** Works with bare metal, FreeRTOS, RT-Thread, and Mynewt
.. figure:: docs/assets/stack.svg
:width: 500px
:align: left
:alt: stackup
.. raw:: html
<div class="clear-both"></div>
::
.
@ -36,7 +65,7 @@ TinyUSB is an open-source cross-platform USB Host/Device stack for embedded syst
Getting started
===============
---------------
See the `online documentation <https://docs.tinyusb.org>`_ for information about using TinyUSB and how it is implemented.
@ -49,7 +78,7 @@ For bugs and feature requests, please `raise an issue <https://github.com/hathac
See `Porting`_ guide for adding support for new MCUs and boards.
Device Stack
============
------------
Supports multiple device configurations by dynamically changing USB descriptors, low power functions such like suspend, resume, and remote wakeup. The following device classes are supported:
@ -70,7 +99,7 @@ Supports multiple device configurations by dynamically changing USB descriptors,
If you have a special requirement, ``usbd_app_driver_get_cb()`` can be used to write your own class driver without modifying the stack. Here is how the RPi team added their reset interface `raspberrypi/pico-sdk#197 <https://github.com/raspberrypi/pico-sdk/pull/197>`_
Host Stack
==========
----------
- Human Interface Device (HID): Keyboard, Mouse, Generic
- Mass Storage Class (MSC)
@ -81,14 +110,14 @@ Host Stack
Similar to the Device Stack, if you have a special requirement, ``usbh_app_driver_get_cb()`` can be used to write your own class driver without modifying the stack.
Power Delivery Stack
====================
--------------------
- Power Delivery 3.0 (PD3.0) with USB Type-C support (WIP)
- Super early stage, only for testing purpose
- Only support STM32 G4
OS Abstraction layer
====================
--------------------
TinyUSB is completely thread-safe by pushing all Interrupt Service Request (ISR) events into a central queue, then processing them later in the non-ISR context task function. It also uses semaphore/mutex to access shared resources such as Communication Device Class (CDC) FIFO. Therefore the stack needs to use some of the OS's basic APIs. Following OSes are already supported out of the box.
@ -98,7 +127,7 @@ TinyUSB is completely thread-safe by pushing all Interrupt Service Request (ISR)
- **Mynewt** Due to the newt package build system, Mynewt examples are better to be on its `own repo <https://github.com/hathach/mynewt-tinyusb-example>`_
Supported CPUs
==============
--------------
+--------------+-----------------------------+--------+------+-----------+------------------------+-------------------+
| Manufacturer | Family | Device | Host | Highspeed | Driver | Note |
@ -234,7 +263,7 @@ Supported CPUs
+--------------+-----------------------------+--------+------+-----------+------------------------+-------------------+
Table Legend
------------
^^^^^^^^^^^^
========= =========================
✔ Supported
@ -244,7 +273,7 @@ Table Legend
========= =========================
Development Tools
=================
-----------------
The following tools are provided freely to support the development of the TinyUSB project:
@ -273,6 +302,5 @@ The following tools are provided freely to support the development of the TinyUS
.. _Supported Boards: docs/reference/boards.rst
.. _Dependencies: docs/reference/dependencies.rst
.. _Concurrency: docs/reference/concurrency.rst
.. _Contributing: docs/contributing/index.rst
.. _Code of Conduct: CODE_OF_CONDUCT.rst
.. _Porting: docs/contributing/porting.rst
.. _Porting: docs/porting.rst

3
docs/_static/custom.css vendored Normal file
View File

@ -0,0 +1,3 @@
.clear-both {
clear: both;
}

8
docs/conf.py
View File

@ -14,7 +14,7 @@ from pathlib import Path
# -- Project information -----------------------------------------------------
project = 'TinyUSB'
copyright = '2024, Ha Thach'
copyright = '2025, Ha Thach'
author = 'Ha Thach'
@ -41,6 +41,8 @@ html_favicon = 'assets/logo.svg'
html_theme_options = {
'sidebar_hide_name': True,
}
html_static_path = ['_static']
html_css_files = ['custom.css']
todo_include_todos = True
@ -52,7 +54,9 @@ def preprocess_readme():
if src.exists():
content = src.read_text()
content = re.sub(r"docs/", r"", content)
content = re.sub(r".rst", r".html", content)
content = re.sub(r"\.rst\b", r".html", content)
if not content.endswith("\n"):
content += "\n"
tgt.write_text(content)
preprocess_readme()

1
docs/contributing/code_of_conduct.rst
View File

@ -1 +0,0 @@
.. include:: ../../CODE_OF_CONDUCT.rst

22
docs/contributing/index.rst
View File

@ -1,22 +0,0 @@
************
Contributing
************
Contributing can be highly rewarding, but it can also be frustrating at times.
It takes time to review patches, and as this is an open source project, that
sometimes can take a while. The reviewing process depends on the availability
of the maintainers, who may not be always available. Please try to be
understanding through the process.
There a few guidelines you need to keep in mind when contributing. Please have
a look at them as that will make the contribution process easier for all
parties.
Index
=====
.. toctree::
:maxdepth: 2
code_of_conduct
porting

180
docs/faq.rst Normal file
View File

@ -0,0 +1,180 @@
**************************
Frequently Asked Questions
**************************
General Questions
=================
**Q: What microcontrollers does TinyUSB support?**
TinyUSB supports 50+ MCU families including STM32, RP2040, NXP (iMXRT, Kinetis, LPC), Microchip SAM, Nordic nRF5x, ESP32, and many others. See :doc:`reference/boards` for the complete list.
**Q: Can I use TinyUSB in commercial projects?**
Yes, TinyUSB is released under the MIT license, allowing commercial use with minimal restrictions.
**Q: Does TinyUSB require an RTOS?**
No, TinyUSB works in bare metal environments. It also supports FreeRTOS, RT-Thread, and Mynewt.
**Q: How much memory does TinyUSB use?**
Typical usage: 8-20KB flash, 1-4KB RAM depending on enabled classes and configuration. The stack uses static allocation only.
Build and Setup
================
**Q: Why do I get "arm-none-eabi-gcc: command not found"?**
Install the ARM GCC toolchain: ``sudo apt-get install gcc-arm-none-eabi`` on Ubuntu/Debian, or download from ARM's website for other platforms.
**Q: Build fails with "Board 'X' not found"**
Check available boards: ``ls hw/bsp/FAMILY/boards/`` or run ``python tools/build.py -l`` to list all supported boards.
**Q: What are the dependencies and how do I get them?**
Run ``python tools/get_deps.py FAMILY`` where FAMILY is your MCU family (e.g., stm32f4, rp2040). This downloads MCU-specific drivers and libraries.
**Q: Can I use my own build system instead of Make/CMake?**
Yes, just add all ``.c`` files from ``src/`` to your project and configure include paths. See :doc:`getting_started` for details.
**Q: Error: "tusb_config.h: No such file or directory"**
This is a very common issue. You need to create ``tusb_config.h`` in your project and ensure it's in your include path. The file must define ``CFG_TUSB_MCU`` and ``CFG_TUSB_OS`` at minimum. Copy from ``examples/device/*/tusb_config.h`` as a starting point.
**Q: RP2040 + pico-sdk ignores my tusb_config.h settings**
The pico-sdk build system can override ``tusb_config.h`` settings. The ``CFG_TUSB_OS`` setting is often ignored because pico-sdk sets it to ``OPT_OS_PICO`` internally. Use pico-sdk specific configuration methods or modify the CMake configuration.
**Q: "multiple definition of dcd_..." errors with STM32**
This happens when multiple USB drivers are included. Ensure you're only including the correct portable driver for your STM32 family. Check that ``CFG_TUSB_MCU`` is set correctly and you don't have conflicting source files.
Device Development
==================
**Q: My USB device isn't recognized by the host**
Common causes:
- Invalid USB descriptors - validate with ``LOG=2`` build
- ``tud_task()`` not called regularly in main loop
- Incorrect ``tusb_config.h`` settings
- USB cable doesn't support data (charging-only cable)
**Q: Windows shows "Device Descriptor Request Failed"**
This typically indicates:
- Malformed device descriptor
- USB timing issues (check crystal/clock configuration)
- Power supply problems during enumeration
- Conflicting devices on the same USB hub
**Q: How do I implement a custom USB class?**
Use the vendor class interface (``CFG_TUD_VENDOR``) or implement a custom class driver. See ``src/class/vendor/`` for examples.
**Q: Can I have multiple configurations or interfaces?**
Yes, TinyUSB supports multiple configurations and composite devices. Modify the descriptors in ``usb_descriptors.c`` accordingly.
**Q: How do I change Vendor ID/Product ID?**
Edit the device descriptor in ``usb_descriptors.c``. For production, obtain your own VID from USB-IF or use one from your silicon vendor.
**Q: Device works alone but fails when connected through USB hub**
This is a known issue where some devices interfere with each other when connected to the same hub. Try:
- Using different USB hubs
- Connecting devices to separate USB ports
- Checking for power supply issues with the hub
Host Development
================
**Q: Why doesn't my host application detect any devices?**
Check:
- Power supply - host mode requires more power than device mode
- USB connector type - use USB-A for host applications
- Board supports host mode on the selected port
- Enable logging with ``LOG=2`` to see enumeration details
**Q: Can I connect multiple devices simultaneously?**
Yes, through a USB hub. TinyUSB supports multi-level hubs and multiple device connections.
**Q: Does TinyUSB support USB 3.0?**
No, TinyUSB currently supports USB 2.0 and earlier. USB 3.0 devices typically work in USB 2.0 compatibility mode.
Configuration and Features
==========================
**Q: How do I enable/disable specific USB classes?**
Edit ``tusb_config.h`` and set the corresponding ``CFG_TUD_*`` or ``CFG_TUH_*`` macros to 1 (enable) or 0 (disable).
**Q: Can I use both device and host modes simultaneously?**
Yes, with dual-role/OTG capable hardware. See ``examples/dual/`` for implementation examples.
**Q: How do I optimize for code size?**
- Disable unused classes in ``tusb_config.h``
- Use ``CFG_TUSB_DEBUG = 0`` for release builds
- Compile with ``-Os`` optimization
- Consider using only required endpoints/interfaces
**Q: Does TinyUSB support low power/suspend modes?**
Yes, TinyUSB handles USB suspend/resume. Implement ``tud_suspend_cb()`` and ``tud_resume_cb()`` for custom power management.
**Q: What CFG_TUSB_MCU should I use for x86/PC platforms?**
For PC/motherboard applications, there's no standard MCU option. You may need to use a generic option or modify TinyUSB for your specific use case. Consider using libusb or other PC-specific USB libraries instead.
**Q: RP2040 FreeRTOS configuration issues**
The RP2040 pico-sdk has specific requirements for FreeRTOS integration. The ``CFG_TUSB_OS`` setting may be overridden by the SDK. Use pico-sdk specific configuration methods and ensure proper task stack sizes for the USB task.
Debugging and Troubleshooting
=============================
**Q: How do I debug USB communication issues?**
1. Enable logging: build with ``LOG=2``
2. Use ``LOGGER=rtt`` or ``LOGGER=swo`` for high-speed logging
3. Use USB protocol analyzers for detailed traffic analysis
4. Check with different host systems (Windows/Linux/macOS)
**Q: My application crashes or hard faults**
Common causes:
- Stack overflow - increase stack size in linker script
- Incorrect interrupt configuration
- Buffer overruns in USB callbacks
- Build with ``DEBUG=1`` and use a debugger
**Q: Performance is poor or USB transfers are slow**
- Ensure ``tud_task()``/``tuh_task()`` called frequently (< 1ms intervals)
- Use DMA for USB transfers if supported by your MCU
- Optimize endpoint buffer sizes
- Consider using high-speed USB if available
**Q: Some USB devices don't work with my host application**
- Not all devices follow USB standards perfectly
- Some may need device-specific handling
- Composite devices may have partial support
- Check device descriptors and implement custom drivers if needed
**Q: ESP32-S3 USB host/device issues**
ESP32-S3 has specific USB implementation challenges:
- Ensure proper USB pin configuration
- Check power supply requirements for host mode
- Some features may be limited compared to other MCUs
- Use ESP32-S3 specific examples and documentation

188
docs/getting_started.rst Normal file
View File

@ -0,0 +1,188 @@
***************
Getting Started
***************
This guide will get you up and running with TinyUSB quickly with working examples.
Project Structure
====================
TinyUSB separates example applications from board-specific hardware configurations:
* **Example applications**: Located in `examples/ <https://github.com/hathach/tinyusb/tree/master/examples/>`_ directories
* **Board Support Packages (BSP)**: Located in ``hw/bsp/FAMILY/boards/BOARD_NAME/`` with hardware abstraction including pin mappings, clock settings, and linker scripts
* **Build system**: Located in `examples/build_system/ <https://github.com/hathach/tinyusb/tree/master/examples/build_system>`_ which supports both Make and CMake. Though some MCU families such as espressif or rp2040 only support cmake
For example, stm32h743eval is located in `hw/bsp/stm32h7/boards/stm32h743eval <https://github.com/hathach/tinyusb/tree/master/hw/bsp/stm32h7/boards/stm32h743eval>`_ where ``FAMILY=stm32h7`` and ``BOARD=stm32h743eval``. When you build with ``BOARD=stm32h743eval``, the build system automatically finds the corresponding BSP using the FAMILY.
For guidance on integrating TinyUSB into your own firmware (configuration, descriptors, initialization, and callback workflow), see :doc:`integration`.
Quick Start Examples
====================
The fastest way to understand TinyUSB is to see it working. These examples demonstrate core functionality and can be built immediately.
We'll assume you are using the **STM32H743 Eval board** (BOARD=stm32h743eval) under the **stm32h7** family. For other boards, see ``Board Support Packages`` below.
Get the Code
------------
.. code-block:: bash
$ git clone https://github.com/hathach/tinyusb tinyusb
$ cd tinyusb
$ python tools/get_deps.py -b stm32h743eval # or python tools/get_deps.py stm32h7
.. note::
For rp2040 `pico-sdk <https://github.com/raspberrypi/pico-sdk>`_ or `esp-idf <https://github.com/espressif/esp-idf>`_ for Espressif targets are required; install them per vendor instructions.
Simple Device Example
---------------------
The `cdc_msc <https://github.com/hathach/tinyusb/tree/master/examples/device/cdc_msc>`_ example creates a USB device with both a virtual serial port (CDC) and mass storage (MSC).
**What it does:**
* Appears as a serial port that echoes back any text you send
* Appears as a small USB drive with a README.TXT file
* Blinks an LED to show activity
**Build and run with CMake:**
.. code-block:: bash
$ cd examples/device/cdc_msc
$ cmake -DBOARD=stm32h743eval -B build # add "-G Ninja" to use Ninja build
$ cmake --build build
# cmake --build build --target cdc_msc-jlink
.. tip::
Flashed/Debugger can be selected with --target ``-jlink``, ``-stlink`` or ``-openocd`` depending on your board. Use ``--target help`` to list all supported targets.
**Build and run with Make:**
.. code-block:: bash
$ cd examples/device/cdc_msc
$ make BOARD=stm32h743eval all
$ make BOARD=stm32h743eval flash-jlink
.. tip::
Flashed/Debugger can be selected with target ``flash-jlink``, ``flash-stlink`` or ``flash-openocd`` depending on your board.
Connect the device to your computer and you'll see both a new serial port and a small USB drive appear.
Simple Host Example
-------------------
The `cdc_msc_hid <https://github.com/hathach/tinyusb/tree/master/examples/host/cdc_msc_hid>`_ example creates a USB host that can connect to USB devices with CDC, MSC, or HID interfaces.
**What it does:**
* Detects and enumerates connected USB devices
* Communicates with CDC devices (like USB-to-serial adapters)
* Reads from MSC devices (like USB drives)
* Receives input from HID devices (like keyboards and mice)
**Build and run with CMake:**
.. code-block:: bash
$ cd examples/host/cdc_msc_hid
$ cmake -DBOARD=stm32h743eval -B build
$ cmake --build build
**Build and run with Make:**
.. code-block:: bash
$ cd examples/host/cdc_msc_hid
$ make BOARD=stm32h743eval all
$ make BOARD=stm32h743eval flash-jlink
Connect USB devices to see enumeration messages and device-specific interactions in the serial output.
Additional Build Options
------------------------
Debug and Logging
^^^^^^^^^^^^^^^^^
TinyUSB built-in logging can be enabled by setting `CFG_TUSB_DEBUG` which is done by passing ``LOG=level``. The higher the level, the more verbose the logging.
In addition to traditional hw uart as default, logging with debugger such as `Segger RTT <https://www.segger.com/products/debug-probes/j-link/technology/about-real-time-transfer/>`_ (10x faster) is also supported with `LOGGER=rtt` option.
.. code-block:: bash
$ cmake -B build -DBOARD=stm32h743eval -DLOG=2 # logging level 2 with uart
$ cmake -B build -DBOARD=stm32h743eval -DLOG=2 -DLOGGER=rtt # logging level 2 with RTT
.. code-block:: bash
$ make BOARD=stm32h743eval LOG=2 all # logging level 2 with uart
$ make BOARD=stm32h743eval LOG=2 LOGGER=rtt all # logging level 2 with RTT
RootHub Port Selection
^^^^^^^^^^^^^^^^^^^^^^
Some boards support multiple usb controllers (roothub ports), by default one rh port is used as device, another as host in ``board.mk/board.cmake``. This can be overridden with option ``RHPORT_DEVICE=n`` or ``RHPORT_HOST=n`` To choose another port. For example to select the HS port of a STM32F746Disco board, use:
.. code-block:: bash
$ cmake -B build -DBOARD=stm32h743eval -DRHPORT_DEVICE=1 # select roothub port 1 as device
.. code-block:: bash
$ make BOARD=stm32h743eval RHPORT_DEVICE=1 all # select roothub port 1 as device
RootHub Port Speed
^^^^^^^^^^^^^^^^^^
A MCU can support multiple operational speed. By default, the example build system will use the fastest supported on the board. Use option ``RHPORT_DEVICE_SPEED=OPT_MODE_FULL/HIGH_SPEED/`` or ``RHPORT_HOST_SPEED=OPT_MODE_FULL/HIGH_SPEED/`` e.g To force operating speed
.. code-block:: bash
$ cmake -B build -DBOARD=stm32h743eval -DRHPORT_DEVICE_SPEED=OPT_MODE_FULL_SPEED
.. code-block:: bash
$ make BOARD=stm32h743eval RHPORT_DEVICE_SPEED=OPT_MODE_FULL_SPEED all
IAR Embedded Workbench
----------------------
For IAR users, project connection files are available. Import `tools/iar_template.ipcf <https://github.com/hathach/tinyusb/tree/master/tools/iar_template.ipcf>`_ or use native CMake support (IAR 9.50.1+). See `tools/iar_gen.py <https://github.com/hathach/tinyusb/tree/master/tools/iar_gen.py>`_ for automated project generation.
Common Issues and Solutions
---------------------------
**Build Errors**
* **"arm-none-eabi-gcc: command not found"**: Install ARM GCC toolchain: ``sudo apt-get install gcc-arm-none-eabi``
* **"Board 'X' not found"**: Check the available boards in ``hw/bsp/FAMILY/boards/`` or run ``python tools/build.py -l``
* **Missing dependencies**: Run ``python tools/get_deps.py FAMILY`` where FAMILY matches your board or ``python tools/get_deps.py -b BOARD``
**Runtime Issues**
* **Device not recognized**: Check USB descriptors implementation and ``tusb_config.h`` settings
* **Enumeration failure**: Enable logging with ``LOG=2`` and check for USB protocol errors
* **Hard faults/crashes**: Verify interrupt handler setup and stack size allocation
**Linux Permissions**
Some examples require udev permissions to access USB devices:
.. code-block:: bash
$ cp `examples/device/99-tinyusb.rules <https://github.com/hathach/tinyusb/tree/master/examples/device/99-tinyusb.rules>`_ /etc/udev/rules.d/
$ sudo udevadm control --reload-rules && sudo udevadm trigger
Next Steps
==========
* Check :doc:`integration` for integrating TinyUSB into your own firmware
* Check :doc:`reference/boards` for board-specific information
* Explore more examples in `examples/device/ <https://github.com/hathach/tinyusb/tree/master/examples/device>`_ and `examples/host/ <https://github.com/hathach/tinyusb/tree/master/examples/host>`_ directories
* Read :doc:`reference/usb_concepts` to understand USB fundamentals

21
docs/index.rst
View File

@ -1,14 +1,21 @@
:hide-toc:
.. include:: ../README_processed.rst
.. toctree::
:caption: Index
:hidden:
:maxdepth: 2
:caption: Information
Info <info/index>
Reference <reference/index>
Contributing <contributing/index>
getting_started
integration
porting
reference/index
faq
troubleshooting
.. toctree::
:maxdepth: 1
:caption: Project Info
info/index
.. toctree::
:caption: External Links

48
docs/info/changelog.rst
View File

@ -20,6 +20,7 @@ API Changes
-----------
- Core APIs
- Add weak callbacks with new syntax for better compiler compatibility
- Add ``tusb_deinit()`` to cleanup stack
- Add time functions: ``tusb_time_millis_api()`` and ``tusb_time_delay_ms_api()``
@ -27,6 +28,7 @@ API Changes
- Introduce ``xfer_isr()`` callback for ISO transfer optimization in device classes
- Device APIs
- CDC: Add notification support ``tud_cdc_configure()``, ``tud_cdc_n_notify_uart_state()``,
``tud_cdc_n_notify_conn_speed_change()``, ``tud_cdc_notify_complete_cb()``
- MSC: Add ``tud_msc_inquiry2_cb()`` with bufsize parameter, update ``tud_msc_async_io_done()``
@ -36,6 +38,7 @@ API Changes
``tud_mtp_response_send()``, ``tud_mtp_event_send()``
- Host APIs
- Core: Add ``tuh_edpt_close()``, ``tuh_address_set()``, ``tuh_descriptor_get_device_local()``,
``tuh_descriptor_get_string_langid()``, ``tuh_connected()``, ``tuh_bus_info_get()``
- Add enumeration callbacks: ``tuh_enum_descriptor_device_cb()``,
@ -50,6 +53,7 @@ Controller Driver (DCD & HCD)
-----------------------------
- DWC2
- Support DWC2 v4.30a with improved reset procedure
- Fix core reset: wait for AHB idle before reset
- Add STM32 DWC2 data cache support with proper alignment
@ -64,6 +68,7 @@ Controller Driver (DCD & HCD)
- Refactor bitfields for better code generation
- FSDEV (STM32)
- Fix AT32 compile issues after single-buffered endpoint changes
- Add configurable single-buffered isochronous endpoints
- Fix STM32H7 recurrent suspend ISR
@ -72,35 +77,42 @@ Controller Driver (DCD & HCD)
- Improve PMA size handling for STM32U0
- EHCI
- Fix removed QHD getting reused
- Fix NXP USBPHY disconnection detection
- Chipidea/NXP
- Fix race condition with spinlock
- Improve iMXRT support: fix build, disable BOARD_ConfigMPU, fix attach debouncing on port1 highspeed
- Fix iMXRT1064 and add to HIL test pool
- MAX3421E
- Use spinlock for thread safety instead of atomic flag
- Implement ``hcd_edpt_close()``
- RP2040
- Fix audio ISO transfer: reset state before notifying stack
- Fix CMake RTOS cache variable
- Abort transfer if active in ``iso_activate()``
- SAMD
- Add host controller driver support
Device Stack
------------
- USBD Core
- Introduce ``xfer_isr()`` callback for interrupt-time transfer handling
- Add ``usbd_edpt_xfer_fifo()`` stub
- Revert endpoint busy/claim status if ``xfer_isr()`` defers to ``xfer_cb()``
- Audio
- Major simplification of UAC driver and alt settings management
- Move ISO transfers into ``xfer_isr()`` for better performance
- Remove FIFO mutex (single producer/consumer optimization)
@ -109,25 +121,30 @@ Device Stack
- Update buffer macros with cache line size alignment
- CDC
- Add notification support: ``CFG_TUD_CDC_NOTIFY``, ``tud_cdc_n_notify_conn_speed_change()``, ``tud_cdc_notify_complete_cb()``
- Reduce default bInterval from 16ms to 1ms for better responsiveness
- Rename ``tud_cdc_configure_fifo()`` to ``tud_cdc_configure()`` and add ``tx_overwritable_if_not_connected`` option
- Fix web serial robustness with major overhaul and logic cleanup
- HID
- Add Usage Page and Table for Power Devices (0x84 - 0x85)
- Fix HID descriptor parser variable size and 4-byte item handling
- Add consumer page configurations
- MIDI
- Fix MIDI interface descriptor handling after audio streaming interface
- Skip RX data with all zeroes
- MSC
- Add async I/O support for MSC using ``tud_msc_async_io_done()``
- Add ``tud_msc_inquiry2_cb()`` with bufsize for full inquiry response
- MTP
- Add new Media Transfer Protocol (MTP) device class driver
- Support MTP operations: GetDeviceInfo, SendObjectInfo, SendObject
- Add MTP event support with ``tud_mtp_event_send()``
@ -135,13 +152,16 @@ Device Stack
- Add hardware-in-the-loop testing support
- NCM
- Add USB NCM link state control support
- Fix DHCP offer/ACK destination
- USBTMC
- Add vendor-specific message support
- Vendor
- Fix vendor device reset and open issues
- Fix descriptor parsing for ``CFG_TUD_VENDOR > 1``
- Fix vendor FIFO argument calculation
@ -150,6 +170,7 @@ Host Stack
----------
- USBH Core
- Major enumeration improvements:
- Fix enumeration racing conditions
- Add proper attach debouncing with hub/rootport handling (200ms delay)
@ -173,6 +194,7 @@ Host Stack
- Force removed devices in same bus info before setting address
- CDC Serial Host
- Major refactor to generalize CDC serial drivers (FTDI, CP210x, CH34x, PL2303, ACM)
- Add explicit ``sync()`` API with ``TU_API_SYNC()`` returning ``tusb_xfer_result_t``
- Rename ``tuh_cdc_get_local_line_coding()`` to ``tuh_cdc_get_line_coding_local()``
@ -180,6 +202,7 @@ Host Stack
- Implement ``tuh_cdc_get/set_dtr/rts()`` as inline functions
- MIDI Host
- Major API changes:
- Rename ``tuh_midi_stream_flush()`` to ``tuh_midi_write_flush()``
- Add ``tuh_midi_packet_read_n()`` and ``tuh_midi_packet_write_n()``
@ -189,9 +212,11 @@ Host Stack
- Add ``tuh_midi_descriptor_cb()`` and ``tuh_midi_itf_get_info()``
- MSC Host
- Continue async I/O improvements
- HID Host
- Fix version string to actually show version
0.18.0
@ -226,6 +251,7 @@ Controller Driver (DCD & HCD)
-----------------------------
- DWC2
- Add DMA support for both device and host controller
- Add host driver support including: full/high speed, control/bulk/interrupt (CBI) transfer, split CBI i.e FS/LS attached via highspeed hub, hub support
@ -695,6 +721,7 @@ Controller Driver (DCD & HCD)
-----------------------------
- [DWC2] Generalize synopsys dwc2 with synopsys/dwc2 which support both FS and HS phy (UTMI and ULPI) for various MCUs.
- Broadcom 28/27xx on raspberrypi SBC
- Silicon Labs EFM32
- Espressif ESP32 Sx
@ -916,6 +943,7 @@ HID
- Add more hid keys constant from 0x6B to 0xA4
- [Breaking] rename API
- ``HID_PROTOCOL_NONE/KEYBOARD/MOUSE`` to ``HID_ITF_PROTOCOL_NONE/KEYBOARD/MOUSE``
- ``tud_hid_boot_mode()`` to ``tud_hid_get_protocol()``
- ``tud_hid_boot_mode_cb()`` to ``tud_hid_set_protocol_cb()``
@ -925,6 +953,7 @@ MIDI
- Fix MIDI buffer overflow issue
- [Breaking] rename API
- Rename ``tud_midi_read()`` to ``tud_midi_stream_read()``
- Rename ``tud_midi_write()`` to ``tud_midi_stream_write()``
- Rename ``tud_midi_receive()`` to ``tud_midi_packet_read()``
@ -1075,15 +1104,19 @@ Device Controller Driver
- Use ``dcd_event_bus_reset()`` with link speed to replace bus_signal
- ESP32-S2:
- Add bus suspend and wakeup support
- SAMD21:
- Fix (walkaround) samd21 setup_packet overflow by USB DMA
- STM32 Synopsys:
- Rework USB FIFO allocation scheme and allow RX FIFO size reduction
- Sony CXD56
- Update Update Spresense SDK to 2.0.2
- Fix dcd issues with setup packets
- Correct EP number for cdc_msc example
@ -1100,19 +1133,24 @@ USB Device
**Class Driver**
- CDC
- Allow to transmit data, even if the host does not support control line states i.e set DTR
- HID
- change default ``CFG_TUD_HID_EP_BUFSIZE`` from 16 to 64
- MIDI
- Fix midi sysex sending bug
- MSC
- Invoke only scsi complete callback after status transaction is complete.
- Fix ``scsi_mode_sense6_t`` padding, which cause IAR compiler internal error.
- USBTMC
- Change interrupt endpoint example size to 8 instead of 2 for better compatibility with mcu
**Example**
@ -1154,6 +1192,7 @@ Device Controller Driver
- Enhance STM32 Synopsys
- Support bus events disconnection/suspend/resume/wakeup
- Improve transfer performance with optimizing xfer and fifo size
- Support Highspeed port (OTG_HS) with both internal and external PHY
- Support multiple usb ports with rhport=1 is highspeed on selected MCUs e.g H743, F23. It is possible to have OTG_HS to run on Fullspeed PHY (e.g lacking external PHY)
@ -1163,6 +1202,7 @@ Device Controller Driver
- Support F105, F107
- Enhance STM32 fsdev
- Improve dcd fifo allocation
- Fix ISTR race condition
- Support remap USB IRQ on supported MCUs
@ -1171,6 +1211,7 @@ Device Controller Driver
- Enhance NUC 505: enhance set configure behavior
- Enhance SAMD
- Fix race condition with setup packet
- Add SAMD11 option ``OPT_MCU_SAMD11``
- Add SAME5x option ``OPT_MCU_SAME5X``
@ -1178,6 +1219,7 @@ Device Controller Driver
- Fix SAMG control data toggle and stall race condition
- Enhance nRF
- Fix hanged when ``tud_task()`` is called within critical section (disabled interrupt)
- Fix disconnect bus event not submitted
- Implement ISO transfer and ``dcd_edpt_close()``
@ -1203,6 +1245,7 @@ USB Device
- Improve USB Highspeed support with actual link speed detection with ``dcd_event_bus_reset()``
- Enhance class driver management
- ``usbd_driver_open()`` add max length argument, and return length of interface (0 for not supported). Return value is used for finding appropriate driver
- Add application implemented class driver via ``usbd_app_driver_get_cb()``
- IAD is handled to assign driver id
@ -1219,11 +1262,13 @@ USB Device
- USBTMC: fix descriptors when INT EP is disabled
- CDC:
- Send zero length packet for end of data when needed
- Add ``tud_cdc_tx_complete_cb()`` callback
- Change ``tud_cdc_n_write_flush()`` return number of bytes forced to transfer, and flush when writing enough data to fifo
- MIDI:
- Add packet interface
- Add multiple jack descriptors
- Fix MIDI driver for sysex
@ -1231,12 +1276,14 @@ USB Device
- DFU Runtime: fix response to SET_INTERFACE and DFU_GETSTATUS request
- Rename some configure macro to make it clear that those are used directly for endpoint transfer
- ``CFG_TUD_HID_BUFSIZE`` to ``CFG_TUD_HID_EP_BUFSIZE``
- ``CFG_TUD_CDC_EPSIZE`` to ``CFG_TUD_CDC_EP_BUFSIZE``
- ``CFG_TUD_MSC_BUFSIZE`` to ``CFG_TUD_MSC_EP_BUFSIZE``
- ``CFG_TUD_MIDI_EPSIZE`` to ``CFG_TUD_MIDI_EP_BUFSIZE``
- HID:
- Fix gamepad template descriptor
- Add multiple HID interface API
- Add extra comma to HID_REPORT_ID
@ -1258,6 +1305,7 @@ Examples
- Add new ``hid_multiple_interface``
- Enhance ``net_lwip_webserver`` example
- Add multiple configuration: RNDIS for Windows, CDC-ECM for macOS (Linux will work with both)
- Update lwip to STABLE-2_1_2_RELEASE for ``net_lwip_webserver``

1
docs/info/code_of_conduct.rst Normal file
View File

@ -0,0 +1 @@
.. include:: ../../CODE_OF_CONDUCT.rst

1
docs/info/index.rst
View File

@ -10,3 +10,4 @@ Index
changelog
contributors
code_of_conduct

93
docs/integration.rst Normal file
View File

@ -0,0 +1,93 @@
*******************
Integrating TinyUSB
*******************
Once you've seen TinyUSB working in the examples, use this guide to wire the stack into your own firmware.
Integration Steps
=================
1. **Get TinyUSB**: Copy this repository or add it as a git submodule to your project at ``your_project/tinyusb``.
2. **Add source files**: Add every ``.c`` file from ``tinyusb/src/`` to your project build system.
.. note::
Only supported dcd/hcd drivers for your CPU sources under ``tinyusb/src/portable/vendor/usbip/`` are needed. Add
3. **Configure TinyUSB**: Create ``tusb_config.h`` with macros such as ``CFG_TUSB_MCU``, ``CFG_TUSB_OS``, and class enable flags. Start from any example's ``tusb_config.h`` and tweak.
4. **Configure include paths**: Add ``your_project/tinyusb/src`` (and the folder holding ``tusb_config.h``) to your include paths.
5. **Implement USB descriptors**: For device stack, implement the ``tud_descriptor_*_cb()`` callbacks (device) or host descriptor helpers that match your product.
6. **Initialize TinyUSB**: Call ``tusb_init()`` once the clocks/peripherals are ready. Pass ``tusb_rhport_init_t`` if you need per-port settings.
7. **Handle interrupts**: From the USB ISR call ``tusb_int_handler(rhport, true)`` so the stack can process events.
8. **Run USB tasks**: Call ``tud_task()`` (device) or ``tuh_task()`` (host) regularly from the main loop, RTOS task.
9. **Implement class callbacks**: Provide the callbacks for the classes you enabled (e.g., ``tud_cdc_rx_cb()``, ``tuh_msc_mount_cb()``).
Minimal Example
===============
.. code-block:: c
#include "tusb.h"
int main(void) {
board_init(); // Your board initialization
// Init device stack on roothub port 0 for highspeed device
tusb_rhport_init_t dev_init = {
.role = TUSB_ROLE_DEVICE,
.speed = TUSB_SPEED_HIGH
};
tusb_init(0, &dev_init);
// init host stack on roothub port 1 for fullspeed host
tusb_rhport_init_t host_init = {
.role = TUSB_ROLE_DEVICE,
.speed = TUSB_SPEED_FULL
};
tusb_init(1, &host_init);
while (1) {
tud_task(); // device task
tuh_task(); // host task
app_task(); // Your application logic
}
}
void USB0_IRQHandler(void) {
// forward interrupt port 0 to TinyUSB stack
tusb_int_handler(0, true);
}
void USB1_IRQHandler(void) {
// forward interrupt port 0 to TinyUSB stack
tusb_int_handler(1, true);
}
.. note::
Unlike many libraries, TinyUSB callbacks don't need to be registered. Implement functions with the prescribed names (for example ``tud_cdc_rx_cb()``) and the stack will invoke them automatically.
.. note::
Naming follows ``tud_*`` for device APIs and ``tuh_*`` for host APIs. Refer to :doc:`reference/glossary` for a summary of the prefixes and callback naming rules.
STM32CubeIDE Integration
========================
To integrate TinyUSB device stack with STM32CubeIDE
1. In STM32CubeMX, enable USB_OTG_FS/HS under Connectivity, set to "Device_Only" mode
2. Enable the USB global interrupt in NVIC Settings
3. Add ``tusb.h`` include and call ``tusb_init()`` in main.c
4. Call ``tud_task()`` in your main loop
5. In the generated ``stm32xxx_it.c``, modify the USB IRQ handler to call ``tud_int_handler(0)``
.. code-block:: c
void OTG_FS_IRQHandler(void) {
tud_int_handler(0);
}
6. Create ``tusb_config.h`` and ``usb_descriptors.c`` files
.. tip::
STM32CubeIDE generated code conflicts with TinyUSB. Don't use STM32's built-in USB middleware (USB Device Library) when using TinyUSB. Disable USB code generation in STM32CubeMX and let TinyUSB handle all USB functionality.

0
docs/contributing/porting.rst → docs/porting.rst
View File

282
docs/reference/architecture.rst Normal file
View File

@ -0,0 +1,282 @@
************
Architecture
************
This document explains TinyUSB's internal architecture, design principles, and how different components work together.
Design Principles
=================
Memory Safety
-------------
TinyUSB is designed for resource-constrained embedded systems with strict memory requirements:
TinyUSB uses **no dynamic allocation** - all memory is statically allocated at compile time for predictability. All buffers have bounded, compile-time defined sizes to prevent overflow issues. The TinyUSB core avoids heap allocation, resulting in **predictable memory usage** where consumption is fully deterministic.
Thread Safety
-------------
TinyUSB achieves thread safety through a deferred interrupt model:
- **ISR deferral**: USB interrupts are captured and deferred to task context
- **Single-threaded processing**: All USB protocol handling occurs in task context
- **Queue-based design**: Events are queued from ISR and processed in ``tud_task()``
- **RTOS integration**: Proper semaphore/mutex usage for shared resources
Portability
-----------
The stack is designed to work across diverse microcontroller families:
- **Hardware abstraction**: MCU-specific code isolated in portable drivers
- **OS abstraction**: RTOS dependencies isolated in OSAL layer
- **Modular design**: Features can be enabled/disabled at compile time
- **Standard compliance**: Strict adherence to USB specifications
Core Architecture
=================
Layer Structure
---------------
TinyUSB follows a layered architecture from hardware to application:
.. figure:: ../assets/stack.svg
:width: 500px
:align: left
:alt: stackup
.. raw:: html
<div class="clear-both"></div>
Component Overview
------------------
- **Application Layer**: Your main application code that uses TinyUSB APIs.
- **Class Drivers**: Implement specific USB device classes (CDC, HID, MSC, etc.) and handle class-specific requests.
- **Device/Host Core**: Implements USB protocol state machines, endpoint management, and core USB functionality.
- **OS Abstraction**: Provides threading primitives and synchronization for different RTOS environments.
- **Device/Host Controller Driver**: drivers that interface with MCU USB peripherals. Several MCUs may share a common driver.
Device Stack Architecture
=========================
This section is concerned with the **Device Stack**, i.e., the component of TinyUSB used in USB devices (that talk to a USB host).
Core Components
---------------
**Device Controller Driver (DCD)**:
- MCU-specific USB device peripheral driver
- Handles endpoint configuration and data transfers
- Abstracts hardware differences between MCU families
- Located in ``src/portable/VENDOR/USBIP/``
**USB Device Core (USBD)**:
- Implements USB device state machine
- Handles standard USB requests (Chapter 9)
- Manages device configuration and enumeration
- Located in ``src/device/``
**Class Drivers**:
- Implement USB class specifications
- Handle class-specific requests and data transfer
- Provide application APIs
- Located in ``src/class/*/``
Data Flow
---------
**Control Transfers (Setup Requests)**:
.. code-block:: none
USB Bus → DCD → USBD Core → Class Driver → Application
↓
Standard requests handled in core
↓
Class-specific requests → Class Driver
**Data Transfers**:
.. code-block:: none
Application → Class Driver → USBD Core → DCD → USB Bus
USB Bus → DCD → USBD Core → Class Driver → Application
Event Processing
----------------
TinyUSB uses a deferred interrupt model for thread safety:
1. **Interrupt Occurs**: USB hardware generates interrupt
2. **ISR Handler**: ``dcd_int_handler()`` captures event, minimal processing
3. **Event Queuing**: Events queued for later processing
4. **Task Processing**: ``tud_task()`` (called by application code) processes queued events
5. **Callback Execution**: Application callbacks executed in task context
.. code-block:: none
USB IRQ → ISR → Event Queue → tud_task() → Class Callbacks → Application
Host Stack Architecture
=======================
This section is concerned with the **Host Stack**, i.e., the component of TinyUSB used in USB hosts, managing connected USB devices.
Core Components
---------------
**Host Controller Driver (HCD)**:
- MCU-specific USB host peripheral driver
- Manages USB pipes and data transfers
- Handles host controller hardware
- Located in ``src/portable/VENDOR/FAMILY/``
**USB Host Core (USBH)**:
- Implements USB host functionality
- Manages device enumeration and configuration
- Handles pipe management and scheduling
- Located in ``src/host/``
**Hub Driver**:
- Manages USB hub devices
- Handles port management and device detection
- Supports multi-level hub topologies
- Located in ``src/host/``
Device Enumeration
------------------
The host stack follows USB enumeration process:
1. **Device Detection**: Hub or root hub detects device connection
2. **Reset and Address**: Reset device, assign unique address
3. **Descriptor Retrieval**: Get device, configuration, and class descriptors
4. **Driver Matching**: Find appropriate class driver for device
5. **Configuration**: Configure device and start communication
6. **Class Operation**: Normal class-specific communication
.. code-block:: none
Device Connect → Reset → Get Descriptors → Load Driver → Configure → Operate
Class Architecture
==================
Common Class Structure
----------------------
All USB classes follow a similar architecture:
**Device Classes**:
- ``*_device.c``: Device-side implementation
- ``*_device.h``: Device API definitions
- Implement class-specific descriptors
- Handle class requests and data transfer
**Host Classes**:
- ``*_host.c``: Host-side implementation
- ``*_host.h``: Host API definitions
- Manage connected devices of this class
- Provide application interface
Class Driver Interface
----------------------
See ``usbd.c``.
**Required Functions**:
- ``init()``: Initialize class driver
- ``reset()``: Reset class state
- ``open()``: Configure class endpoints
- ``control_xfer_cb()``: Handle control requests
- ``xfer_cb()``: Handle data transfer completion
**Optional Functions**:
- ``close()``: Clean up class resources
- ``deinit()``: Deinitialize class driver
- ``sof()``: Start-of-frame processing
- ``xfer_isr()``: Called from USB ISR context on transfer completion. Data will get queued for ``xfer_cb()`` only if this returns ``false``.
Descriptor Management
---------------------
Each class is responsible for:
- **Interface Descriptors**: Define class type and endpoints
- **Class-Specific Descriptors**: Additional class requirements
- **Endpoint Descriptors**: Define data transfer characteristics
Memory Management
=================
Static Allocation Model
-----------------------
TinyUSB uses only static memory allocation; it allocates fixed-size endpoint buffers for each configured endpoint, static buffers for class-specific data handling, a fixed buffer dedicated to control transfers, and static event queues for deferred interrupt processing.
Buffer Management
-----------------
**Endpoint Buffers**:
- Allocated per endpoint at compile time
- Size defined by ``CFG_TUD_*_EP_BUFSIZE`` macros
- Used for USB data transfers
**FIFO Buffers**:
- Ring buffers for streaming data
- Size defined by ``CFG_TUD_*_RX/TX_BUFSIZE`` macros
- Separate read/write pointers
Threading Model
===============
Task-Based Design
-----------------
TinyUSB uses a cooperative task model; it provides main tasks - ``tud_task()`` for device and ``tuh_task()`` for host operation. These tasks must be called regularly (typically less than 1ms intervals) to ensure all USB events are processed in task context, where application callbacks also execute.
RTOS Integration
----------------
**Bare Metal**:
- Application calls ``tud_task()`` in main loop
- No threading primitives needed
- Simplest integration method
**FreeRTOS**:
- USB task runs at high priority
- Semaphores used for synchronization
- Queue for inter-task communication
**Other RTOS**:
- Similar patterns with RTOS-specific primitives
- OSAL layer abstracts RTOS differences
Interrupt Handling
------------------
**Interrupt Service Routine**:
- Minimal processing in ISR
- Event capture and queuing only
- Quick return to avoid blocking
**Deferred Processing**:
- All complex processing in task context
- Thread-safe access to data structures
- Application callbacks in known context
Memory Usage Patterns
---------------------
**Flash Memory**:
- Core stack: 8-15KB depending on features
- Each class: 1-4KB additional
- Portable driver: 2-8KB depending on MCU
**RAM Usage**:
- Core stack: 1-2KB
- Endpoint buffers: User configurable
- Class buffers: Depends on configuration

31
docs/reference/boards.rst
View File

@ -107,17 +107,20 @@ olimex_emz64 Olimex PIC32-EMZ64 pic32mz http
olimex_hmz144 Olimex PIC32-HMZ144 pic32mz https://www.olimex.com/Products/PIC/Development/PIC32-HMZ144/open-source-hardware
cynthion_d11 Great Scott Gadgets Cynthion samd11 https://greatscottgadgets.com/cynthion/
samd11_xplained SAMD11 Xplained Pro samd11 https://www.microchip.com/en-us/development-tool/ATSAMD11-XPRO
atsamd21_xpro SAMD21 Xplained Pro samd21 https://www.microchip.com/DevelopmentTools/ProductDetails/ATSAMD21-XPRO
circuitplayground_express Adafruit Circuit Playground Express samd21 https://www.adafruit.com/product/3333
curiosity_nano SAMD21 Curiosty Nano samd21 https://www.microchip.com/en-us/development-tool/dm320119
cynthion_d21 Great Scott Gadgets Cynthion samd21 https://greatscottgadgets.com/cynthion/
feather_m0_express Adafruit Feather M0 Express samd21 https://www.adafruit.com/product/3403
itsybitsy_m0 Adafruit ItsyBitsy M0 samd21 https://www.adafruit.com/product/3727
metro_m0_express Adafruit Metro M0 Express samd21 https://www.adafruit.com/product/3505
qtpy Adafruit QT Py samd21 https://www.adafruit.com/product/4600
seeeduino_xiao Seeeduino XIAO samd21 https://wiki.seeedstudio.com/Seeeduino-XIAO/
sparkfun_samd21_mini_usb SparkFun SAMD21 Mini samd21 https://www.sparkfun.com/products/13664
trinket_m0 Adafruit Trinket M0 samd21 https://www.adafruit.com/product/3500
atsamd21_xpro SAMD21 Xplained Pro samd2x_l2x https://www.microchip.com/DevelopmentTools/ProductDetails/ATSAMD21-XPRO
atsaml21_xpro SAML21 Xplained Pro samd2x_l2x https://www.microchip.com/en-us/development-tool/atsaml21-xpro-b
circuitplayground_express Adafruit Circuit Playground Express samd2x_l2x https://www.adafruit.com/product/3333
curiosity_nano SAMD21 Curiosty Nano samd2x_l2x https://www.microchip.com/en-us/development-tool/dm320119
cynthion_d21 Great Scott Gadgets Cynthion samd2x_l2x https://greatscottgadgets.com/cynthion/
feather_m0_express Adafruit Feather M0 Express samd2x_l2x https://www.adafruit.com/product/3403
itsybitsy_m0 Adafruit ItsyBitsy M0 samd2x_l2x https://www.adafruit.com/product/3727
metro_m0_express Adafruit Metro M0 Express samd2x_l2x https://www.adafruit.com/product/3505
qtpy Adafruit QT Py samd2x_l2x https://www.adafruit.com/product/4600
saml22_feather SAML22 Feather samd2x_l2x https://github.com/joeycastillo/Feather-Projects/tree/main/SAML22%20Feather
seeeduino_xiao Seeeduino XIAO samd2x_l2x https://wiki.seeedstudio.com/Seeeduino-XIAO/
sensorwatch_m0 SensorWatch samd2x_l2x https://github.com/joeycastillo/Sensor-Watch
sparkfun_samd21_mini_usb SparkFun SAMD21 Mini samd2x_l2x https://www.sparkfun.com/products/13664
trinket_m0 Adafruit Trinket M0 samd2x_l2x https://www.adafruit.com/product/3500
d5035_01 D5035-01 samd5x_e5x https://github.com/RudolphRiedel/USB_CAN-FD
feather_m4_express Adafruit Feather M4 Express samd5x_e5x https://www.adafruit.com/product/3857
itsybitsy_m4 Adafruit ItsyBitsy M4 samd5x_e5x https://www.adafruit.com/product/3800
@ -125,10 +128,9 @@ metro_m4_express Adafruit Metro M4 Express samd5x_e5x http
pybadge Adafruit PyBadge samd5x_e5x https://www.adafruit.com/product/4200
pyportal Adafruit PyPortal samd5x_e5x https://www.adafruit.com/product/4116
same54_xplained SAME54 Xplained Pro samd5x_e5x https://www.microchip.com/DevelopmentTools/ProductDetails/ATSAME54-XPRO
same70_qmtech SAME70 QMTech same7x https://www.aliexpress.com/item/1005003173783268.html
same70_xplained SAME70 Xplained same7x https://www.microchip.com/en-us/development-tool/atsame70-xpld
samg55_xplained SAMG55 Xplained Pro samg https://www.microchip.com/DevelopmentTools/ProductDetails/ATSAMG55-XPRO
atsaml21_xpro SAML21 Xplained Pro saml2x https://www.microchip.com/en-us/development-tool/atsaml21-xpro-b
saml22_feather SAML22 Feather saml2x https://github.com/joeycastillo/Feather-Projects/tree/main/SAML22%20Feather
sensorwatch_m0 SensorWatch saml2x https://github.com/joeycastillo/Sensor-Watch
========================= =================================== ========== ================================================================================= ======
MindMotion
@ -295,6 +297,7 @@ stm32l052dap52 STM32 L052 DAP stm32l0 n/a
stm32l0538disco STM32 L0538 Discovery stm32l0 https://www.st.com/en/evaluation-tools/32l0538discovery.html
stm32l412nucleo STM32 L412 Nucleo stm32l4 https://www.st.com/en/evaluation-tools/nucleo-l412kb.html
stm32l476disco STM32 L476 Disco stm32l4 https://www.st.com/en/evaluation-tools/32l476gdiscovery.html
stm32l496nucleo STM32 L496 Nucleo stm32l4 https://www.st.com/en/evaluation-tools/nucleo-l496ZG-P.html
stm32l4p5nucleo STM32 L4P5 Nucleo stm32l4 https://www.st.com/en/evaluation-tools/nucleo-l4p5zg.html
stm32l4r5nucleo STM32 L4R5 Nucleo stm32l4 https://www.st.com/en/evaluation-tools/nucleo-l4r5zi.html
stm32n6570dk STM32 N6570-DK stm32n6 https://www.st.com/en/evaluation-tools/stm32n6570-dk.html

10
docs/reference/concurrency.rst
View File

@ -3,17 +3,17 @@ Concurrency
***********
The TinyUSB library is designed to operate on single-core MCUs with multi-threaded applications in mind. Interaction with interrupts is especially important to pay attention to.
It is compatible with optionally using a RTOS.
It is compatible with optionally using an RTOS.
General
-------
When writing code, keep in mind that the OS (if using a RTOS) may swap out your code at any time. Also, your code can be preempted by an interrupt at any time.
When writing code, keep in mind that the OS (if using an RTOS) may swap out your code at any time. Also, your code can be preempted by an interrupt at any time.
Application Code
----------------
The USB core does not execute application callbacks while in an interrupt context. Calls to application code are from within the USB core task context. Note that the application core will call class drivers from within their own task.
The USB core does not execute application callbacks while in an interrupt context. Calls to application code are from within the USB core task context. Note that the application core will call class drivers from within its own task.
Class Drivers
-------------
@ -38,5 +38,5 @@ Much of the processing of the USB stack is done in an interrupt context, and car
In particular:
* Ensure that all memory-mapped registers (including packet memory) are marked as volatile. GCC's optimizer will even combine memory access (like two 16-bit to be a 32-bit) if you don't mark the pointers as volatile. On some architectures, this can use macros like _I , _O , or _IO.
* All defined global variables are marked as ``static``.
* Ensure that all memory-mapped registers (including packet memory) are marked as volatile. GCC's optimizer will even combine memory accesses (like two 16-bit to be a 32-bit) if you don't mark the pointers as volatile. On some architectures, this can use macros like _I , _O , or _IO.
* All defined global variables are marked as ``static``.

14
docs/reference/dependencies.rst
View File

@ -2,11 +2,11 @@
Dependencies
************
MCU low-level peripheral driver and external libraries for building TinyUSB examples
MCU low-level peripheral drivers and external libraries for building TinyUSB examples
======================================== ================================================================ ======================================== ======================================================================================================================================================================================================================================================================================================================================================================
======================================== ================================================================ ======================================== ==============================================================================================================================================================================================================================================================================================================================================================
Local Path Repo Commit Required by
======================================== ================================================================ ======================================== ======================================================================================================================================================================================================================================================================================================================================================================
======================================== ================================================================ ======================================== ==============================================================================================================================================================================================================================================================================================================================================================
hw/mcu/allwinner https://github.com/hathach/allwinner_driver.git 8e5e89e8e132c0fd90e72d5422e5d3d68232b756 fc100s
hw/mcu/analog/msdk https://github.com/analogdevicesinc/msdk.git b20b398d3e5e2007594e54a74ba3d2a2e50ddd75 maxim
hw/mcu/artery/at32f402_405 https://github.com/ArteryTek/AT32F402_405_Firmware_Library.git 4424515c2663e82438654e0947695295df2abdfe at32f402_405
@ -23,7 +23,7 @@ hw/mcu/infineon/mtb-xmclib-cat3 https://github.com/Infineon/mtb-xmclib
hw/mcu/microchip https://github.com/hathach/microchip_driver.git 9e8b37e307d8404033bb881623a113931e1edf27 sam3x samd11 samd21 samd51 samd5x_e5x same5x same7x saml2x samg
hw/mcu/mindmotion/mm32sdk https://github.com/hathach/mm32sdk.git b93e856211060ae825216c6a1d6aa347ec758843 mm32
hw/mcu/nordic/nrfx https://github.com/NordicSemiconductor/nrfx.git 11f57e578c7feea13f21c79ea0efab2630ac68c7 nrf
hw/mcu/nuvoton https://github.com/majbthrd/nuc_driver.git 2204191ec76283371419fbcec207da02e1bc22fa nuc
hw/mcu/nuvoton https://github.com/majbthrd/nuc_driver.git 2204191ec76283371419fbcec207da02e1bc22fa nuc100_120 nuc121_125 nuc126 nuc505
hw/mcu/nxp/lpcopen https://github.com/hathach/nxp_lpcopen.git b41cf930e65c734d8ec6de04f1d57d46787c76ae lpc11 lpc13 lpc15 lpc17 lpc18 lpc40 lpc43
hw/mcu/nxp/mcux-sdk https://github.com/nxp-mcuxpresso/mcux-sdk a1bdae309a14ec95a4f64a96d3315a4f89c397c6 kinetis_k kinetis_k32l2 kinetis_kl lpc51 lpc54 lpc55 mcx imxrt
hw/mcu/raspberry_pi/Pico-PIO-USB https://github.com/sekigon-gonnoc/Pico-PIO-USB.git 675543bcc9baa8170f868ab7ba316d418dbcf41f rp2040
@ -80,10 +80,10 @@ hw/mcu/wch/ch32f20x https://github.com/openwch/ch32f20x.gi
hw/mcu/wch/ch32v103 https://github.com/openwch/ch32v103.git 7578cae0b21f86dd053a1f781b2fc6ab99d0ec17 ch32v10x
hw/mcu/wch/ch32v20x https://github.com/openwch/ch32v20x.git c4c38f507e258a4e69b059ccc2dc27dde33cea1b ch32v20x
hw/mcu/wch/ch32v307 https://github.com/openwch/ch32v307.git 184f21b852cb95eed58e86e901837bc9fff68775 ch32v30x
lib/CMSIS_5 https://github.com/ARM-software/CMSIS_5.git 2b7495b8535bdcb306dac29b9ded4cfb679d7e5c imxrt kinetis_k32l2 kinetis_kl lpc51 lpc54 lpc55 mcx mm32 msp432e4 nrf saml2x lpc11 lpc13 lpc15 lpc17 lpc18 lpc40 lpc43 stm32c0 stm32f0 stm32f1 stm32f2 stm32f3 stm32f4 stm32f7 stm32g0 stm32g4 stm32h5 stm32h7 stm32h7rs stm32l0 stm32l1 stm32l4 stm32l5 stm32n6 stm32u0 stm32u5 stm32wb stm32wbasam3x samd11 samd21 samd51 samd5x_e5x same5x same7x saml2x samg tm4c
lib/CMSIS_6 https://github.com/ARM-software/CMSIS_6.git b0bbb0423b278ca632cfe1474eb227961d835fd2 ra
lib/CMSIS_5 https://github.com/ARM-software/CMSIS_5.git 2b7495b8535bdcb306dac29b9ded4cfb679d7e5c imxrt kinetis_k32l2 kinetis_kl lpc51 lpc54 lpc55 mcx mm32 msp432e4 nrf saml2x lpc11 lpc13 lpc15 lpc17 lpc18 lpc40 lpc43 stm32c0 stm32f0 stm32f1 stm32f2 stm32f3 stm32f4 stm32f7 stm32g0 stm32g4 stm32h5 stm32h7 stm32h7rs stm32l0 stm32l1 stm32l4 stm32l5 stm32u0 stm32u5 stm32wb stm32wbasam3x samd11 samd21 samd51 samd5x_e5x same5x same7x saml2x samg tm4c
lib/CMSIS_6 https://github.com/ARM-software/CMSIS_6.git 6f0a58d01aa9bd2feba212097f9afe7acd991d52 ra stm32n6
lib/FreeRTOS-Kernel https://github.com/FreeRTOS/FreeRTOS-Kernel.git cc0e0707c0c748713485b870bb980852b210877f all
lib/lwip https://github.com/lwip-tcpip/lwip.git 159e31b689577dbf69cf0683bbaffbd71fa5ee10 all
lib/sct_neopixel https://github.com/gsteiert/sct_neopixel.git e73e04ca63495672d955f9268e003cffe168fcd8 lpc55
tools/uf2 https://github.com/microsoft/uf2.git c594542b2faa01cc33a2b97c9fbebc38549df80a all
======================================== ================================================================ ======================================== ======================================================================================================================================================================================================================================================================================================================================================================
======================================== ================================================================ ======================================== ==============================================================================================================================================================================================================================================================================================================================================================

269
docs/reference/getting_started.rst
View File

@ -1,269 +0,0 @@
***************
Getting Started
***************
Add TinyUSB to your project
---------------------------
To incorporate tinyusb to your project
* Copy or ``git submodule`` this repo into your project in a subfolder. Let's say it is ``your_project/tinyusb``
* Add all the ``.c`` in the ``tinyusb/src`` folder to your project
* Add ``your_project/tinyusb/src`` to your include path. Also make sure your current include path also contains the configuration file ``tusb_config.h``.
* Make sure all required macros are all defined properly in ``tusb_config.h`` (configure file in demo application is sufficient, but you need to add a few more such as ``CFG_TUSB_MCU``, ``CFG_TUSB_OS`` since they are passed by make/cmake to maintain a unique configure for all boards).
* If you use the device stack, make sure you have created/modified usb descriptors for your own need. Ultimately you need to implement all **tud descriptor** callbacks for the stack to work.
* Add ``tusb_init(rhport, role)`` call to your reset initialization code.
* Call ``tusb_int_handler(rhport, in_isr)`` in your USB IRQ Handler
* Implement all enabled classes's callbacks.
* If you don't use any RTOSes at all, you need to continuously and/or periodically call ``tud_task()``/``tuh_task()`` function. All of the callbacks and functionality are handled and invoked within the call of that task runner.
.. code-block:: c
int main(void) {
tusb_rhport_init_t dev_init = {
.role = TUSB_ROLE_DEVICE,
.speed = TUSB_SPEED_AUTO
};
tusb_init(0, &dev_init); // initialize device stack on roothub port 0
tusb_rhport_init_t host_init = {
.role = TUSB_ROLE_HOST,
.speed = TUSB_SPEED_AUTO
};
tusb_init(1, &host_init); // initialize host stack on roothub port 1
while(1) { // the mainloop
your_application_code();
tud_task(); // device task
tuh_task(); // host task
}
}
void USB0_IRQHandler(void) {
tusb_int_handler(0, true);
}
void USB1_IRQHandler(void) {
tusb_int_handler(1, true);
}
Examples
--------
For your convenience, TinyUSB contains a handful of examples for both host and device with/without RTOS to quickly test the functionality as well as demonstrate how API should be used. Most examples will work on most of :doc:`the supported boards <boards>`. Firstly we need to ``git clone`` if not already
.. code-block:: bash
$ git clone https://github.com/hathach/tinyusb tinyusb
$ cd tinyusb
Some ports will also require a port-specific SDK (e.g. RP2040) or binary (e.g. Sony Spresense) to build examples. They are out of scope for tinyusb, you should download/install it first according to its manufacturer guide.
Dependencies
^^^^^^^^^^^^
The hardware code is located in ``hw/bsp`` folder, and is organized by family/boards. e.g raspberry_pi_pico is located in ``hw/bsp/rp2040/boards/raspberry_pi_pico`` where ``FAMILY=rp2040`` and ``BOARD=raspberry_pi_pico``. Before building, we firstly need to download dependencies such as: MCU low-level peripheral driver and external libraries e.g FreeRTOS (required by some examples). We can do that by either ways:
1. Run ``tools/get_deps.py {FAMILY}`` script to download all dependencies for a family as follow. Note: For TinyUSB developer to download all dependencies, use FAMILY=all.
.. code-block:: bash
$ python tools/get_deps.py rp2040
2. Or run the ``get-deps`` target in one of the example folder as follow.
.. code-block:: bash
$ cd examples/device/cdc_msc
$ make BOARD=feather_nrf52840_express get-deps
You only need to do this once per family. Check out :doc:`complete list of dependencies and their designated path here <dependencies>`
Build Examples
^^^^^^^^^^^^^^
Examples support make and cmake build system for most MCUs, however some MCU families such as espressif or rp2040 only support cmake. First change directory to an example folder.
.. code-block:: bash
$ cd examples/device/cdc_msc
Then compile with make or cmake
.. code-block:: bash
$ # make
$ make BOARD=feather_nrf52840_express all
$ # cmake
$ mkdir build && cd build
$ cmake -DBOARD=raspberry_pi_pico ..
$ make
To list all available targets with cmake
.. code-block:: bash
$ cmake --build . --target help
Note: some examples especially those that uses Vendor class (e.g webUSB) may requires udev permission on Linux (and/or macOS) to access usb device. It depends on your OS distro, typically copy ``99-tinyusb.rules`` and reload your udev is good to go
.. code-block:: bash
$ cp examples/device/99-tinyusb.rules /etc/udev/rules.d/
$ sudo udevadm control --reload-rules && sudo udevadm trigger
RootHub Port Selection
~~~~~~~~~~~~~~~~~~~~~~
If a board has several ports, one port is chosen by default in the individual board.mk file. Use option ``RHPORT_DEVICE=x`` or ``RHPORT_HOST=x`` To choose another port. For example to select the HS port of a STM32F746Disco board, use:
.. code-block:: bash
$ make BOARD=stm32f746disco RHPORT_DEVICE=1 all
$ cmake -DBOARD=stm32f746disco -DRHPORT_DEVICE=1 ..
Port Speed
~~~~~~~~~~
A MCU can support multiple operational speed. By default, the example build system will use the fastest supported on the board. Use option ``RHPORT_DEVICE_SPEED=OPT_MODE_FULL/HIGH_SPEED/`` or ``RHPORT_HOST_SPEED=OPT_MODE_FULL/HIGH_SPEED/`` e.g To force F723 operate at full instead of default high speed
.. code-block:: bash
$ make BOARD=stm32f746disco RHPORT_DEVICE_SPEED=OPT_MODE_FULL_SPEED all
$ cmake -DBOARD=stm32f746disco -DRHPORT_DEVICE_SPEED=OPT_MODE_FULL_SPEED ..
Size Analysis
~~~~~~~~~~~~~
First install `linkermap tool <https://github.com/hathach/linkermap>`_ then ``linkermap`` target can be used to analyze code size. You may want to compile with ``NO_LTO=1`` since ``-flto`` merges code across ``.o`` files and make it difficult to analyze.
.. code-block:: bash
$ make BOARD=feather_nrf52840_express NO_LTO=1 all linkermap
Debug
^^^^^
To compile for debugging add ``DEBUG=1``\ , for example
.. code-block:: bash
$ make BOARD=feather_nrf52840_express DEBUG=1 all
$ cmake -DBOARD=feather_nrf52840_express -DCMAKE_BUILD_TYPE=Debug ..
Log
~~~
Should you have an issue running example and/or submitting an bug report. You could enable TinyUSB built-in debug logging with optional ``LOG=``. ``LOG=1`` will only print out error message, ``LOG=2`` print more information with on-going events. ``LOG=3`` or higher is not used yet.
.. code-block:: bash
$ make BOARD=feather_nrf52840_express LOG=2 all
$ cmake -DBOARD=feather_nrf52840_express -DLOG=2 ..
Logger
~~~~~~
By default log message is printed via on-board UART which is slow and take lots of CPU time comparing to USB speed. If your board support on-board/external debugger, it would be more efficient to use it for logging. There are 2 protocols:
* `LOGGER=rtt`: use `Segger RTT protocol <https://www.segger.com/products/debug-probes/j-link/technology/about-real-time-transfer/>`_
* Cons: requires jlink as the debugger.
* Pros: work with most if not all MCUs
* Software viewer is JLink RTT Viewer/Client/Logger which is bundled with JLink driver package.
* ``LOGGER=swo`` : Use dedicated SWO pin of ARM Cortex SWD debug header.
* Cons: only work with ARM Cortex MCUs minus M0
* Pros: should be compatible with more debugger that support SWO.
* Software viewer should be provided along with your debugger driver.
.. code-block:: bash
$ make BOARD=feather_nrf52840_express LOG=2 LOGGER=rtt all
$ make BOARD=feather_nrf52840_express LOG=2 LOGGER=swo all
$ cmake -DBOARD=feather_nrf52840_express -DLOG=2 -DLOGGER=rtt ..
$ cmake -DBOARD=feather_nrf52840_express -DLOG=2 -DLOGGER=swo ..
Flash
^^^^^
``flash`` target will use the default on-board debugger (jlink/cmsisdap/stlink/dfu) to flash the binary, please install those support software in advance. Some board use bootloader/DFU via serial which is required to pass to make command
.. code-block:: bash
$ make BOARD=feather_nrf52840_express flash
$ make SERIAL=/dev/ttyACM0 BOARD=feather_nrf52840_express flash
Since jlink/openocd can be used with most of the boards, there is also ``flash-jlink/openocd`` (make) and ``EXAMPLE-jlink/openocd`` target for your convenience. Note for stm32 board with stlink, you can use ``flash-stlink`` target as well.
.. code-block:: bash
$ make BOARD=feather_nrf52840_express flash-jlink
$ make BOARD=feather_nrf52840_express flash-openocd
$ cmake --build . --target cdc_msc-jlink
$ cmake --build . --target cdc_msc-openocd
Some board use uf2 bootloader for drag & drop in to mass storage device, uf2 can be generated with ``uf2`` target
.. code-block:: bash
$ make BOARD=feather_nrf52840_express all uf2
$ cmake --build . --target cdc_msc-uf2
IAR Support
^^^^^^^^^^^
Use project connection
~~~~~~~~~~~~~~~~~~~~~~
IAR Project Connection files are provided to import TinyUSB stack into your project.
* A buildable project of your MCU need to be created in advance.
* Take example of STM32F0:
- You need ``stm32l0xx.h``, ``startup_stm32f0xx.s``, ``system_stm32f0xx.c``.
- ``STM32L0xx_HAL_Driver`` is only needed to run examples, TinyUSB stack itself doesn't rely on MCU's SDKs.
* Open ``Tools -> Configure Custom Argument Variables`` (Switch to ``Global`` tab if you want to do it for all your projects)
Click ``New Group ...``, name it to ``TUSB``, Click ``Add Variable ...``, name it to ``TUSB_DIR``, change it's value to the path of your TinyUSB stack,
for example ``C:\\tinyusb``
**Import stack only**
Open ``Project -> Add project Connection ...``, click ``OK``, choose ``tinyusb\\tools\\iar_template.ipcf``.
**Run examples**
1. Run ``iar_gen.py`` to generate .ipcf files of examples:
.. code-block::
> cd C:\tinyusb\tools
> python iar_gen.py
2. Open ``Project -> Add project Connection ...``, click ``OK``, choose ``tinyusb\\examples\\(.ipcf of example)``.
For example ``C:\\tinyusb\\examples\\device\\cdc_msc\\iar_cdc_msc.ipcf``
Native CMake support
~~~~~~~~~~~~~~~~~~~~
With 9.50.1 release, IAR added experimental native CMake support (strangely not mentioned in public release note). Now it's possible to import CMakeLists.txt then build and debug as a normal project.
Following these steps:
1. Add IAR compiler binary path to system ``PATH`` environment variable, such as ``C:\Program Files\IAR Systems\Embedded Workbench 9.2\arm\bin``.
2. Create new project in IAR, in Tool chain dropdown menu, choose CMake for Arm then Import ``CMakeLists.txt`` from chosen example directory.
3. Set up board option in ``Option - CMake/CMSIS-TOOLBOX - CMake``, for example ``-DBOARD=stm32f439nucleo -DTOOLCHAIN=iar``, **Uncheck 'Override tools in env'**.
4. (For debug only) Choose correct CPU model in ``Option - General Options - Target``, to profit register and memory view.

98
docs/reference/glossary.rst Normal file
View File

@ -0,0 +1,98 @@
********
Glossary
********
.. glossary::
BSP
Board Support Package. A collection of board-specific code that provides hardware abstraction for a particular development board, including pin mappings, clock settings, linker scripts, and hardware initialization routines. Located in ``hw/bsp/FAMILY/boards/BOARD_NAME``.
Bulk Transfer
USB transfer type used for large amounts of data that doesn't require guaranteed timing. Used by mass storage devices and CDC class.
CDC
Communications Device Class. USB class for devices that communicate serial data, creating virtual serial ports.
Control Transfer
USB transfer type used for device configuration and control. All USB devices must support control transfers on endpoint 0.
DCD
Device Controller Driver. The hardware abstraction layer for USB device controllers in TinyUSB. See also HCD.
Descriptor
Data structures that describe USB device capabilities, configuration, and interfaces to the host.
Device Class
USB specification defining how devices of a particular type (e.g., storage, audio, HID) communicate with hosts.
DFU
Device Firmware Update. USB class that allows firmware updates over USB.
Endpoint
Communication channel between host and device. Each endpoint has a direction (IN/OUT) and transfer type.
Enumeration
Process where USB host discovers and configures a newly connected device.
HCD
Host Controller Driver. The hardware abstraction layer for USB host controllers in TinyUSB. See also DCD.
HID
Human Interface Device. USB class for input devices like keyboards, mice, and game controllers.
High Speed
USB 2.0 speed mode operating at 480 Mbps.
Full Speed
USB speed mode operating at 12 Mbps, supported by USB 1.1 and 2.0.
Low Speed
USB speed mode operating at 1.5 Mbps, typically used by simple input devices.
Interrupt Transfer
USB transfer type for small, time-sensitive data with guaranteed maximum latency.
Isochronous Transfer
USB transfer type for time-critical data like audio/video with guaranteed bandwidth but no error correction.
MSC
Mass Storage Class. USB class for storage devices like USB drives.
OSAL
Operating System Abstraction Layer. TinyUSB component that abstracts RTOS differences.
OTG
On-The-Go. USB specification allowing devices to act as both host and device.
Pipe
Host-side communication channel to a device endpoint.
Root Hub
The USB hub built into the host controller, where devices connect directly.
Stall
USB protocol mechanism where an endpoint responds with a STALL handshake to indicate an error condition or unsupported request. Used for error handling, not flow control.
Super Speed
USB 3.0 speed mode operating at 5 Gbps. Not supported by TinyUSB.
tud
TinyUSB Device. Function prefix for all device stack APIs (e.g., ``tud_task()``, ``tud_cdc_write()``).
tuh
TinyUSB Host. Function prefix for all host stack APIs (e.g., ``tuh_task()``, ``tuh_cdc_receive()``).
UAC
USB Audio Class. USB class for audio devices.
UVC
USB Video Class. USB class for video devices like cameras.
VID
Vendor Identifier. 16-bit number assigned by USB-IF to identify device manufacturers.
PID
Product Identifier. 16-bit number assigned by vendor to identify specific products.
USB-IF
USB Implementers Forum. Organization that maintains USB specifications and assigns VIDs.

11
docs/reference/index.rst
View File

@ -1,10 +1,15 @@
Index
=====
*********
Reference
*********
Complete reference documentation for TinyUSB APIs, configuration, and supported hardware.
.. toctree::
:maxdepth: 2
getting_started
architecture
usb_concepts
boards
dependencies
concurrency
glossary

428
docs/reference/usb_concepts.rst Normal file
View File

@ -0,0 +1,428 @@
************
USB Concepts
************
This document provides a brief introduction to USB protocol fundamentals that are essential for understanding TinyUSB development.
TinyUSB API Naming Conventions
===============================
TinyUSB uses consistent function prefixes to organize its API:
* **tusb_**: Core stack functions (initialization, interrupt handling)
* **tud_**: Device stack functions (e.g., ``tud_task()``, ``tud_cdc_write()``)
* **tuh_**: Host stack functions (e.g., ``tuh_task()``, ``tuh_cdc_receive()``)
* **tu_**: Internal utility functions (generally not used by applications)
This naming makes it easy to identify which part of the stack a function belongs to and ensures there are no naming conflicts when using both device and host stacks together.
USB Protocol Basics
====================
Universal Serial Bus (USB) is a standardized communication protocol designed for connecting devices to hosts (typically computers). Understanding these core concepts is essential for effective TinyUSB development.
Host and Device Roles
----------------------
**USB Host**: The controlling side of a USB connection (typically a computer). The host:
- Initiates all communication
- Provides power to devices
- Manages the USB bus
- Enumerates and configures devices
**TinyUSB Host Stack**: Enable with ``CFG_TUH_ENABLED=1`` in ``tusb_config.h``. Call ``tuh_task()`` regularly in your main loop. See the :doc:`../getting_started` Quick Start Examples for implementation details.
**USB Device**: The peripheral side (keyboard, mouse, storage device, etc.). Devices:
- Respond to host requests
- Cannot initiate communication
- Receive power from the host
- Must be enumerated by the host before use
**TinyUSB Device Stack**: Enable with ``CFG_TUD_ENABLED=1`` in ``tusb_config.h``. Call ``tud_task()`` regularly in your main loop. See the :doc:`../getting_started` Quick Start Examples for implementation details.
**OTG (On-The-Go)**: Some devices can switch between host and device roles dynamically. **TinyUSB Support**: Both stacks can be enabled simultaneously on OTG-capable hardware. See ``examples/dual/`` for dual-role implementations.
USB Transfers
=============
Every USB transfer consists of the host issuing a request, and the device replying to that request. The host is the bus master and initiates all communication.
Devices cannot initiate sending data; for unsolicited incoming data, polling is used by the host.
USB defines four transfer types, each intended for different use cases:
Control Transfers
-----------------
Used for device configuration and control commands.
**Characteristics**:
- Bidirectional (uses both IN and OUT)
- Guaranteed delivery with error detection
- Limited data size (8-64 bytes per packet)
- All devices must support control transfers on endpoint 0
**Usage**: Device enumeration, configuration changes, class-specific commands
**TinyUSB Context**: Handled automatically by the core stack for standard requests; class drivers handle class-specific requests. Endpoint 0 is managed by ``src/device/usbd.c`` and ``src/host/usbh.c``. Configure buffer size with ``CFG_TUD_ENDPOINT0_SIZE`` (typically 64 bytes).
Bulk Transfers
--------------
Used for large amounts of data that don't require guaranteed timing.
**Characteristics**:
- Unidirectional (separate IN and OUT endpoints)
- Guaranteed delivery with error detection
- Large packet sizes (up to 512 bytes for High Speed)
- Uses available bandwidth when no other transfers are active
**Usage**: File transfers, large data communication, CDC serial data
**TinyUSB Context**: Used by MSC (mass storage) and CDC classes for data transfer. Configure endpoint buffer sizes with ``CFG_TUD_MSC_EP_BUFSIZE`` and ``CFG_TUD_CDC_EP_BUFSIZE``. See ``src/class/msc/`` and ``src/class/cdc/`` for implementation details.
Interrupt Transfers
-------------------
Used for small, time-sensitive data with guaranteed maximum latency.
**Characteristics**:
- Unidirectional (separate IN and OUT endpoints)
- Guaranteed delivery with error detection
- Small packet sizes (up to 64 bytes for Full Speed)
- Regular polling interval (1ms to 255ms)
**Usage**: Keyboard/mouse input, sensor data, status updates
**TinyUSB Context**: Used by HID class for input reports. Configure with ``CFG_TUD_HID`` and ``CFG_TUD_HID_EP_BUFSIZE``. Send reports using ``tud_hid_report()`` or ``tud_hid_keyboard_report()``. See ``src/class/hid/`` and HID examples in ``examples/device/hid_*/``.
Isochronous Transfers
---------------------
Used for time-critical streaming data.
**Characteristics**:
- Unidirectional (separate IN and OUT endpoints)
- No error correction (speed over reliability)
- Guaranteed bandwidth
- Real-time delivery
**Usage**: Audio, video streaming
**TinyUSB Context**: Used by Audio class for streaming audio data. Configure with ``CFG_TUD_AUDIO`` and related audio configuration macros. See ``src/class/audio/`` and audio examples in ``examples/device/audio_*/`` for UAC2 implementation.
Endpoints and Addressing
=========================
Endpoint Basics
---------------
**Endpoint**: A communication channel between host and device.
- Each endpoint has a number (0-15) and direction
- Endpoint 0 is reserved for control transfers
- Other endpoints are assigned by device class requirements
**TinyUSB Endpoint Management**: Configure maximum endpoints with ``CFG_TUD_ENDPOINT_MAX``. Endpoints are automatically allocated by enabled classes. See your board's ``usb_descriptors.c`` for endpoint assignments.
**Direction**:
- **OUT**: Host to device (host sends data out)
- **IN**: Device to host (host reads data in)
- Note that in TinyUSB code, for ``tx``/``rx``, the device perspective is used typically: E.g., ``tud_cdc_tx_complete_cb()`` designates the callback executed once the device has completed sending data to the host (in device mode).
**Addressing**: Endpoints are addressed as EPx IN/OUT (e.g., EP1 IN, EP2 OUT)
Endpoint Configuration
----------------------
Each endpoint is configured with a specific **transfer type** (control, bulk, interrupt, or isochronous), a **direction** (IN, OUT, or bidirectional for control only), a **maximum packet size** that depends on USB speed and transfer type, and an **interval** for interrupt and isochronous endpoints.
**TinyUSB Configuration**: Endpoint characteristics are defined in descriptors (``usb_descriptors.c``) and automatically configured by the stack. Buffer sizes are set via ``CFG_TUD_*_EP_BUFSIZE`` macros.
Error Handling and Flow Control
-------------------------------
**Transfer Results**: USB transfers can complete with different results. An **ACK** indicates a successful transfer, while a **NAK** signals that the device is not ready (commonly used for flow control). A **STALL** response indicates an error condition or unsupported request, and **Timeout** occurs when a transfer fails to complete within the expected time frame.
**Flow Control in USB**: Unlike network protocols, USB doesn't use traditional congestion control. Instead, devices use NAK responses when not ready to receive data, applications implement buffering and proper timing strategies, and some classes (like CDC) support hardware flow control mechanisms such as RTS/CTS.
**TinyUSB Handling**: Transfer results are represented as ``xfer_result_t`` enum values. The stack automatically handles NAK responses and timing. STALL conditions indicate application-level errors that should be addressed in class drivers.
USB Device States
=================
A USB device progresses through several states:
1. **Attached**: Device is physically connected
2. **Powered**: Device receives power from host
3. **Default**: Device responds to address 0
4. **Address**: Device has been assigned a unique address
5. **Configured**: Device is ready for normal operation
6. **Suspended**: Device is in low-power state
**TinyUSB State Management**: State transitions are handled automatically by ``src/device/usbd.c``. You can implement ``tud_mount_cb()`` and ``tud_umount_cb()`` to respond to configuration changes, and ``tud_suspend_cb()``/``tud_resume_cb()`` for power management.
Device Enumeration Process
==========================
When a device is connected, the host follows this process:
1. **Detection**: Host detects device connection
2. **Reset**: Host resets the device
3. **Descriptor Requests**: Host requests device descriptors
4. **Address Assignment**: Host assigns unique address to device
5. **Configuration**: Host selects and configures device
6. **Class Loading**: Host loads appropriate drivers
7. **Normal Operation**: Device is ready for use
**TinyUSB Role**: The device stack handles steps 1-6 automatically; your application handles step 7.
USB Descriptors
===============
Descriptors are data structures that describe device capabilities:
Device Descriptor
-----------------
Describes the device (VID, PID, USB version, etc.)
Configuration Descriptor
------------------------
Describes device configuration (power requirements, interfaces, etc.)
Interface Descriptor
--------------------
Describes a functional interface (class, endpoints, etc.)
Endpoint Descriptor
-------------------
Describes endpoint characteristics (type, direction, size, etc.)
String Descriptors
------------------
Human-readable strings (manufacturer, product name, etc.)
**TinyUSB Implementation**: You provide descriptors in ``usb_descriptors.c`` via callback functions:
- ``tud_descriptor_device_cb()`` - Device descriptor
- ``tud_descriptor_configuration_cb()`` - Configuration descriptor
- ``tud_descriptor_string_cb()`` - String descriptors
The stack automatically handles descriptor requests during enumeration. See examples in ``examples/device/*/usb_descriptors.c`` for reference implementations.
USB Classes
===========
USB classes define standardized protocols for device types:
**Class Code**: Identifies the device type in descriptors
**Class Driver**: Software that implements the class protocol
**Class Requests**: Standardized commands for the class
**Common TinyUSB-Supported Classes**:
- **CDC (02h)**: Communication devices (virtual serial ports) - Enable with ``CFG_TUD_CDC``
- **HID (03h)**: Human interface devices (keyboards, mice) - Enable with ``CFG_TUD_HID``
- **MSC (08h)**: Mass storage devices (USB drives) - Enable with ``CFG_TUD_MSC``
- **Audio (01h)**: Audio devices (speakers, microphones) - Enable with ``CFG_TUD_AUDIO``
- **MIDI**: MIDI devices - Enable with ``CFG_TUD_MIDI``
- **DFU**: Device Firmware Update - Enable with ``CFG_TUD_DFU``
- **Vendor**: Custom vendor classes - Enable with ``CFG_TUD_VENDOR``
.. note::
**Vendor Class Buffer Configuration**: Unlike other USB classes, the vendor class supports setting buffer sizes to 0 in ``tusb_config.h`` (``CFG_TUD_VENDOR_RX_BUFSIZE = 0``) to disable internal buffering. When disabled, data goes directly to ``tud_vendor_rx_cb()`` and the ``tud_vendor_read()``/``tud_vendor_write()`` functions are not available - applications must handle data directly in callbacks.
See ``examples/device/*/tusb_config.h`` for configuration examples.
USB Speeds
==========
USB supports multiple speed modes:
**Low Speed (1.5 Mbps)**:
- Simple devices (mice, keyboards)
- Limited endpoint types and sizes
**Full Speed (12 Mbps)**:
- Most common for embedded devices
- All transfer types supported
- Maximum packet sizes: Control (64), Bulk (64), Interrupt (64)
**High Speed (480 Mbps)**:
- High-performance devices
- Larger packet sizes: Control (64), Bulk (512), Interrupt (1024)
- Requires more complex hardware
**Super Speed (5 Gbps)**:
- USB 3.0 and later
- Not supported by TinyUSB
**TinyUSB Speed Support**: Most TinyUSB ports support Full Speed and High Speed. Speed is typically auto-detected by hardware. Configure speed requirements in board configuration (``hw/bsp/FAMILY/boards/BOARD/board.mk``) and ensure your MCU supports the desired speed.
USB Controller Abstraction
===========================
USB controllers are hardware peripherals that handle the low-level USB protocol implementation. Understanding how they work helps explain TinyUSB's architecture and portability.
Controller Fundamentals
-----------------------
**What Controllers Do**:
- Handle USB signaling and protocol timing
- Manage endpoint buffers and data transfers
- Generate interrupts for USB events
- Implement USB electrical specifications
**Key Components**: USB controllers consist of several key components working together. The **Physical Layer** provides USB signal drivers and receivers for electrical interfacing. The **Protocol Engine** handles USB packets and ACK/NAK responses according to the USB specification. **Endpoint Buffers** provide hardware FIFOs or RAM for data storage during transfers. Finally, the **Interrupt Controller** generates events for software processing when USB activities occur.
Controller Architecture Types
-----------------------------
Different MCU vendors implement USB controllers with varying architectures.
To list a few common patterns:
**FIFO-Based Controllers** (e.g., STM32 OTG, NXP LPC):
- Shared or dedicated FIFOs for endpoint data
- Software manages FIFO allocation and data flow
- Common in higher-end MCUs with flexible configurations
**Buffer-Based Controllers** (e.g., STM32 FSDEV, Microchip SAMD, RP2040):
- Fixed packet memory areas for each endpoint
- Hardware automatically handles packet placement
- Simpler programming model, common in smaller MCUs
**Descriptor-Based Controllers** (e.g., NXP EHCI-style):
- Use descriptor chains to describe transfers
- Hardware processes transfer descriptors independently
- More complex but can handle larger transfers autonomously
TinyUSB Controller Abstraction
------------------------------
TinyUSB abstracts controller differences through the TinyUSB **Device Controller Driver (DCD)** layer.
These internal details don't matter to users of TinyUSB typically; however, when debugging, knowledge about internal details helps sometimes.
**Portable Interface** (``src/device/usbd.h``):
- Standardized function signatures for all controllers
- Common endpoint and transfer management APIs
- Unified interrupt and event handling
**Controller-Specific Drivers** (``src/portable/VENDOR/FAMILY/``):
- Implement the DCD interface for specific hardware
- Handle vendor-specific register layouts and behaviors
- Manage controller-specific quirks and workarounds
**Common DCD Functions**:
- ``dcd_init()`` - Initialize controller hardware
- ``dcd_edpt_open()`` - Configure endpoint with type and size
- ``dcd_edpt_xfer()`` - Start data transfer on endpoint
- ``dcd_int_handler()`` - Process USB interrupts
- ``dcd_connect()/dcd_disconnect()`` - Control USB bus connection
Host Controller Driver (HCD)
-----------------------------
TinyUSB also abstracts USB host controllers through the **Host Controller Driver (HCD)** layer for host mode applications.
**Portable Interface** (``src/host/usbh.h``):
- Standardized interface for all host controllers
- Common device enumeration and pipe management
- Unified transfer scheduling and completion handling
**Common HCD Functions**:
- ``hcd_init()`` - Initialize host controller hardware
- ``hcd_port_connect_status()`` - Check device connection status
- ``hcd_port_reset()`` - Reset connected device
- ``hcd_edpt_open()`` - Open communication pipe to device endpoint
- ``hcd_edpt_xfer()`` - Transfer data to/from connected device
**Host vs Device Architecture**: While DCD is reactive (responds to host requests), HCD is active (initiates all communication). Host controllers manage device enumeration, driver loading, and transfer scheduling to multiple connected devices.
TinyUSB Event System & Thread Safety
====================================
Deferred Interrupt Processing
-----------------------------
**Core Architectural Principle**: TinyUSB uses a deferred interrupt processing model where all USB hardware events are captured in interrupt service routines (ISRs) but processed later in non-interrupt context.
**Event Flow**:
1. **Hardware Event**: USB controller generates interrupt (e.g., data received, transfer complete)
2. **ISR Handling**: TinyUSB ISR captures the event and pushes it to a central event queue
3. **Deferred Processing**: Application calls ``tud_task()`` or ``tuh_task()`` to process queued events
4. **Class Driver Callbacks**: Events trigger appropriate class driver functions and user callbacks
**Buffer Integration**: The deferred processing model works seamlessly with TinyUSB's buffer/FIFO design. Since callbacks run in task context (not ISR), it's safe and straightforward to enqueue TX data directly in RX callbacks - for example, processing incoming CDC data and immediately sending a response.
Controller Event Flow
---------------------
**Typical USB Event Processing**:
1. **Hardware Event**: USB controller detects bus activity (setup packet, data transfer, etc.)
2. **Interrupt Generation**: Controller generates interrupt to CPU
3. **ISR Processing**: ``dcd_int_handler()`` reads controller status
4. **Event Queuing**: Events are queued for later processing (thread safety)
5. **Task Processing**: ``tud_task()`` processes queued events
6. **Class Notification**: Appropriate class drivers handle the event
7. **Application Callback**: User code responds to the event
USB Class Driver Architecture
==============================
TinyUSB implements USB classes through a standardized driver pattern that provides consistent integration with the core stack while allowing class-specific functionality.
Class Driver Pattern
---------------------
**Standardized Entry Points**: Each class driver implements these core functions:
- ``*_init()`` - Initialize class driver state and buffers
- ``*_reset()`` - Reset to initial state on USB bus reset
- ``*_open()`` - Parse and configure interfaces during enumeration
- ``*_control_xfer_cb()`` - Handle class-specific control requests
- ``*_xfer_cb()`` - Handle transfer completion callbacks
**Multi-Instance Support**: Classes support multiple instances using ``_n`` suffixed APIs:
.. code-block:: c
// Single instance (default instance 0)
tud_cdc_write(data, len);
// Multiple instances
tud_cdc_n_write(0, data, len); // Instance 0
tud_cdc_n_write(1, data, len); // Instance 1
**Integration with Core Stack**: Class drivers are automatically discovered and integrated through function pointers in driver tables. The core stack calls class drivers during enumeration, control requests, and data transfers without requiring explicit registration.
Class Driver Types
-------------------
TinyUSB classes have different architectural patterns based on their buffering capabilities and callback designs.
Most classes like CDC, MIDI, and HID always use internal buffers for data management. These classes provide notification-only callbacks such as ``tud_cdc_rx_cb(uint8_t itf)`` that signal when data is available, requiring applications to use class-specific APIs like ``tud_cdc_read()`` and ``tud_cdc_write()`` to access the data. HID is slightly different in that it provides direct buffer access in some callbacks (``tud_hid_set_report_cb()`` receives buffer and size parameters), but it still maintains internal endpoint buffering that cannot be disabled.
The **Vendor Class** is unique in that it supports both buffered and direct modes. When buffered, vendor class behaves like other classes with ``tud_vendor_read()`` and ``tud_vendor_write()`` APIs. However, when buffering is disabled by setting buffer size to 0, the vendor class provides direct buffer access through ``tud_vendor_rx_cb(itf, buffer, bufsize)`` callbacks, eliminating internal FIFO overhead and providing direct endpoint control.
**Block-Oriented Classes** like MSC operate differently by handling large data blocks through callback interfaces. The application implements storage access functions such as ``tud_msc_read10_cb()`` and ``tud_msc_write10_cb()``, while the TinyUSB stack manages the USB protocol aspects and the application manages the underlying storage.
Power Management
================
USB provides power to devices:
**Bus-Powered**: Device draws power from USB bus (up to 500mA)
**Self-Powered**: Device has its own power source
**Suspend/Resume**: Devices must enter low-power mode when bus is idle
**TinyUSB Power Management**:
- Implement ``tud_suspend_cb()`` and ``tud_resume_cb()`` for power management
- Configure power requirements in device descriptor (``bMaxPower`` field)
- Use ``tud_remote_wakeup()`` to wake the host from suspend (if supported)
- Enable remote wakeup with ``CFG_TUD_USBD_ENABLE_REMOTE_WAKEUP``
Next Steps
==========
- Start with :doc:`../getting_started` for basic setup
- Review ``examples/device/*/tusb_config.h`` for configuration examples
- Explore examples in ``examples/device/`` and ``examples/host/`` directories

304
docs/troubleshooting.rst Normal file
View File

@ -0,0 +1,304 @@
***************
Troubleshooting
***************
This guide helps you diagnose and fix common issues when developing with TinyUSB.
Build Issues
============
Toolchain Problems
------------------
**"arm-none-eabi-gcc: command not found"**
The ARM GCC toolchain is not installed or not in PATH.
*Solution*:
.. code-block:: bash
# Ubuntu/Debian
$ sudo apt-get update && sudo apt-get install gcc-arm-none-eabi
# macOS with Homebrew
$ brew install --cask gcc-arm-embedded
# Windows: Download from ARM website and add to PATH
**"make: command not found" or CMake errors**
Build tools are missing.
*Solution*:
.. code-block:: bash
# Ubuntu/Debian
$ sudo apt-get install build-essential cmake
# macOS
$ xcode-select --install
$ brew install cmake
Dependency Issues
-----------------
**"No rule to make target" or missing header files**
Dependencies for your MCU family are not downloaded.
*Solution*:
.. code-block:: bash
# Download dependencies for specific board or family
$ python tools/get_deps.py -b stm32h743eval # Replace with your board
$ python tools/get_deps.py stm32f4 # Replace with your family
# Or from example directory
cd examples/device/cdc_msc
make BOARD=your_board get-deps
**Board Not Found**
Invalid board name in build command.
*Diagnosis*:
.. code-block:: bash
# List available boards for a family
ls hw/bsp/stm32f4/boards/
*Solution*: Use exact board name from the listing.
Runtime Issues
==============
Device Mode Problems
--------------------
**Device not recognized by host**
The most common issue - host doesn't see your USB device.
*Diagnosis steps*:
1. Check USB cable (must support data, not just power)
2. Enable logging: build with ``LOG=2``
3. Use different USB ports/hosts
4. Check device manager (Windows) or ``dmesg`` (Linux)
*Common causes and solutions*:
- **Invalid descriptors**: Review ``usb_descriptors.c`` carefully
- **``tud_task()`` not called**: Ensure regular calls in main loop (< 1ms interval)
- **Wrong USB configuration**: Check ``tusb_config.h`` settings
- **Hardware issues**: Verify USB pins, crystal/clock configuration
**Enumeration starts but fails**
Device is detected but configuration fails.
*Diagnosis*:
.. code-block:: bash
# Build with logging enabled
make BOARD=your_board LOG=2 all
*Look for*:
- Setup request handling errors
- Endpoint configuration problems
- String descriptor issues
*Solutions*:
- Implement all required descriptors
- Check endpoint sizes match descriptors
- Ensure control endpoint (EP0) handling is correct
**Data transfer issues**
Device enumerates but data doesn't transfer correctly.
*Common causes*:
- Buffer overruns in class callbacks
- Incorrect endpoint usage (IN vs OUT)
- Flow control issues in CDC class
*Solutions*:
- Check buffer sizes in callbacks
- Verify endpoint directions in descriptors
- Implement proper flow control
Host Mode Problems
------------------
**No devices detected**
Host application doesn't see connected devices.
*Hardware checks*:
- Power supply adequate for host mode
- USB-A connector for host (not micro-USB)
- Board supports host mode on selected port
*Software checks*:
- ``tuh_task()`` called regularly
- Host stack enabled in ``tusb_config.h``
- Correct root hub port configuration
**Device enumeration fails**
Devices connect but enumeration fails.
*Diagnosis*:
.. code-block:: bash
# Enable host logging
make BOARD=your_board LOG=2 RHPORT_HOST=1 all
*Common issues*:
- Power supply insufficient during enumeration
- Timing issues with slow devices
- USB hub compatibility problems
**Class driver issues**
Device enumerates but class-specific communication fails.
*Troubleshooting*:
- Check device descriptors match expected class
- Verify interface/endpoint assignments
- Some devices need device-specific handling
Performance Issues
==================
Slow Transfer Speeds
--------------------
**Symptoms**: Lower than expected USB transfer rates
*Causes and solutions*: Improve **task scheduling** by calling ``tud_task()``/``tuh_task()`` more frequently to ensure timely USB event processing. Consider increasing **endpoint buffer sizes** for bulk transfers to reduce the frequency of small transfers. Enable **DMA usage** for USB transfers if your hardware supports it to offload CPU processing. Finally, use **High Speed** (480 Mbps) instead of Full Speed (12 Mbps) when possible to achieve better throughput.
High CPU Usage
--------------
**Symptoms**: MCU spending too much time in USB handling
*Solutions*:
- Use efficient logging (RTT/SWO instead of UART)
- Reduce log level in production builds
- Optimize descriptor parsing
- Use DMA for data transfers
Hardware-Specific Issues
========================
STM32 Issues
------------
**Clock configuration problems**:
- USB requires precise 48MHz clock
- HSE crystal must be configured correctly
- PLL settings affect USB timing
**Pin configuration**:
- USB pins need specific alternate function settings
- VBUS sensing configuration
- ID pin for OTG applications
RP2040 Issues
-------------
**PIO-USB for host mode**:
- Requires specific pin assignments
- CPU overclocking may be needed for reliable operation
- Timing-sensitive - avoid long interrupt disable periods
ESP32 Issues
------------
**USB peripheral differences**:
- ESP32-S2/S3/P4 have different USB capabilities
- DMA configuration varies between models
Advanced Debugging
==================
Using USB Analyzers
-------------------
For complex issues, hardware USB analyzers provide detailed protocol traces:
- **Wireshark** with USBPcap (Windows) or usbmon (Linux)
- **Hardware analyzers**: Total Phase Beagle, LeCroy USB analyzers
- **Logic analyzers**: For timing analysis of USB signals
Debugging with GDB
------------------
Debugging with traditional debuggers is limited due to the real time nature of USB.
However, especially for diagnosis of crashes, it can still be useful.
.. code-block:: bash
# Build with debug info
make BOARD=your_board DEBUG=1 all
# Use with debugger
arm-none-eabi-gdb build/your_app.elf
*Useful breakpoints*:
- ``dcd_int_handler()`` - USB interrupt entry
- ``tud_task()`` - Main device task
- Class-specific callbacks
Custom Logging
--------------
For production debugging, implement custom logging:
.. code-block:: c
// In tusb_config.h
#define CFG_TUSB_DEBUG_PRINTF my_printf
// Your implementation
void my_printf(const char* format, ...) {
// Send to RTT, SWO, or custom interface
}
Getting Help
============
When reporting issues:
1. **Minimal reproducible example**: Simplify to bare minimum
2. **Build information**: Board, toolchain version, build flags
3. **Logs**: Include output with ``LOG=2`` enabled
4. **Hardware details**: Board revision, USB connections, power supply
5. **Host environment**: OS version, USB port type
**Resources**:
- GitHub Discussions: https://github.com/hathach/tinyusb/discussions
- Issue Tracker: https://github.com/hathach/tinyusb/issues
- Documentation: https://docs.tinyusb.org

49
hw/bsp/family_support.cmake
View File

@ -10,6 +10,40 @@ get_filename_component(TOP ${TOP} ABSOLUTE)
set(UF2CONV_PY ${TOP}/tools/uf2/utils/uf2conv.py)
function(family_resolve_board BOARD_NAME BOARD_PATH_OUT)
if ("${BOARD_NAME}" STREQUAL "")
message(FATAL_ERROR "You must set BOARD (e.g. metro_m4_express, raspberry_pi_pico). Use -DBOARD=xxx on the cmake command line.")
endif()
file(GLOB _board_paths
LIST_DIRECTORIES true
RELATIVE ${TOP}/hw/bsp
${TOP}/hw/bsp/*/boards/*
)
set(_hint_names "")
foreach(_board_path ${_board_paths})
get_filename_component(_board_name ${_board_path} NAME)
if (_board_name STREQUAL "${BOARD_NAME}")
set(${BOARD_PATH_OUT} ${_board_path} PARENT_SCOPE)
return()
endif()
string(FIND "${_board_name}" "${BOARD_NAME}" _pos)
if (_pos EQUAL 0)
list(APPEND _hint_names ${_board_name})
endif()
endforeach()
if (_hint_names)
list(REMOVE_DUPLICATES _hint_names)
list(SORT _hint_names)
list(JOIN _hint_names ", " _hint_str)
message(FATAL_ERROR "BOARD '${BOARD_NAME}' not found. Boards with the same prefix:\n${_hint_str}")
else()
message(FATAL_ERROR "BOARD '${BOARD_NAME}' not found under hw/bsp/*/boards")
endif()
endfunction()
#-------------------------------------------------------------
# Toolchain
# Can be changed via -DTOOLCHAIN=gcc|iar or -DCMAKE_C_COMPILER= or ENV{CC}=
@ -78,21 +112,8 @@ endif ()
# FAMILY and BOARD
#-------------------------------------------------------------
if (NOT DEFINED FAMILY)
if (NOT DEFINED BOARD)
message(FATAL_ERROR "You must set a BOARD variable for the build (e.g. metro_m4_express, raspberry_pi_pico).
You can do this via -DBOARD=xxx on the cmake command line")
endif ()
family_resolve_board("${BOARD}" BOARD_PATH)
# Find path contains BOARD
file(GLOB BOARD_PATH LIST_DIRECTORIES true
RELATIVE ${TOP}/hw/bsp
${TOP}/hw/bsp/*/boards/${BOARD}
)
if (NOT BOARD_PATH)
message(FATAL_ERROR "Could not detect FAMILY from BOARD=${BOARD}")
endif ()
# replace / with ; so that we can get the first element as FAMILY
string(REPLACE "/" ";" BOARD_PATH ${BOARD_PATH})
list(GET BOARD_PATH 0 FAMILY)
set(FAMILY ${FAMILY} CACHE STRING "Board family")

2
tools/gen_doc.py
View File

@ -23,7 +23,7 @@ def gen_deps_doc():
Dependencies
************
MCU low-level peripheral driver and external libraries for building TinyUSB examples
MCU low-level peripheral drivers and external libraries for building TinyUSB examples
{tabulate(df, headers="keys", tablefmt='rst')}
"""