基本介紹#
標準儀器設備介面是上位機和儀器通信使用的介面，如示波器、電源、信號發生器等。常用的標準儀器介面及對應的通信協議如下。
| 通信介面 | 通信協議 |
|---|---|
| LAN | VXI-11 |
| USB | USB-TMC |
| GPIB | IEEE488 |
LAN 的通信協議和 TCP/IP 的 TCP Client/Server 、RAW Socket 沒什麼本質區別，只要支持其中之一都可以正常識別。
GPIB 的通信協議比較複雜，而且物理層是並口傳輸，幾乎只能使用專用的收發器芯片進行通信，專用收發器的控制方式類似 SRAM ，也並沒有什麼很難解決的問題。
USB 的通信方式就必須品鑑一下了。
而我司作為一個測試設備和儀器公司，居然在這方面沒有任何技術積累，那就讓我來細品一下什麼是 USB-TMC 枚舉吧。
整體思路#
首先非常重要的是翻閱標準文檔，有以下兩份我自己機翻的雙語對照版，需要雙頁視圖對照查看。
USBTMC_1_00_EnCh.pdf | yono 的文件
USBTMC_usb488_subclass_1_00_EnCh.pdf | yono 的文件
其次非常不重要的是找一個友商的正規儀器抓數據包看看是啥情況。
ps：實際上我並沒有看過第二份文檔哪怕一眼，完全依靠抓數據和第一個文檔互相映照就完成了驅動開發。
值得關注的是 USB-TMC 類枚舉實際上只有 USB488 這一個子類，而且仍有許多的預留數據位置和通信過程，所以我認為 TMC 這個枚舉仍然可以使用很多年。
枚舉過程#
眾所周知，驅動程序在 USB 設備的枚舉階段需要詢問描述符，這個描述符的編寫是怎麼枚舉成 TMC 設備的關鍵。
經過抓包，一個示例的設備描述符就出來了，和它一模一樣就好了，有如下。
UCHAR device_framework_full_speed_demo[] = {
/* Device descriptor 設備描述符 */
0x12, // len(static)
0x01, // device(static)
0x00, 0x02, // USB2.0(static)
0x00, // DeviceClass(static)
0x00, // DeviceSubClass(static)
0x00, // bDeviceProtocol(static)
0x40, // bMaxPacketSize0
0x69, 0x0A, // idVendor (VID): 0x0A69
0x8A, 0x08, // idProduct (PID): 0x088A
0x00, 0x01, // bcdDevice: Device release number 0x0100
0x01, // iManufacturer 廠商字符串描述符的索引(static)
0x02, // iProduct 產品字符串描述符的索引(static)
0x03, // iSerialNumber 序列號字符串描述符的索引(static)
0x01, // bNumConfigurations(static)
/* Device qualifier descriptor 設備限定符描述符 */
0x0a, // len(static)
0x06, // bDescriptorType: Device Qualifier Descriptor(static)
0x00, 0x02, // USB2.0(static)
0x00, // DeviceClass(static)
0x00, // DeviceSubClass(static)
0x00, // bDeviceProtocol(static)
0x40, // bMaxPacketSize0
0x01, // bNumConfigurations(static)
0x00, // reserve(static)
/* Configuration descriptor 配置描述符 */
0x09, // len(static)
0x02, // bDescriptorType: Configuration Descriptor(static)
0x20, 0x00, // wTotalLength: Total length of data for this configuration (32 bytes)
0x01, // bNumInterfaces(static)
0x01, // bConfigurationValue(static)
0x00, // iConfiguration: Index of configuration string descriptor
0x80, // bmAttributes: Self-powered 自供電
0x64, // bMaxPower: 200 mA (0x64 * 2 mA)
/* Interface descriptor 接口描述符 */
0x09, // len(static)
0x04, // bDescriptorType: Interface Descriptor(static)
0x00, // bInterfaceNumber: Interface 0
0x00, // bAlternateSetting
0x02, // bNumEndpoints: 2 endpoints(static)
0xFE, // bInterfaceClass: TMC(static)
0x03, // bInterfaceSubClass: USB488(static)
0x01, // bInterfaceProtocol(static)
0x00, // iInterface: Index of interface string descriptor(static)
/* Endpoint descriptor 端點描述符(Bulk Out) */
0x07, // len(static)
0x05, // bDescriptorType: Endpoint Descriptor(static)
0x81, // bEndpointAddress: 端點地址（IN 方向，端點號 1）
0x02, // bmAttributes: 傳輸類型為批量（Bulk）
0x40, 0x00, // wMaxPacketSize: 最大包大小 64 字節
0x00, // bInterval: 查詢間隔（用於批量傳輸時為 0）
/* Endpoint descriptor 端點描述符(Bulk In) */
0x07, // len(static)
0x05, // bDescriptorType: Endpoint Descriptor(static)
0x01, // bEndpointAddress: 端點地址（OUT 方向，端點號 1）
0x02, // bmAttributes: 傳輸類型為批量（Bulk）
0x40, 0x00, // wMaxPacketSize: 最大包大小 64 字節
0x00, // bInterval: 查詢間隔（用於批量傳輸時為 0）
};
其中最為關鍵的是 Interface descriptor 部分中的 bInterfaceClass 和 bInterfaceSubClass 這兩個部分直接決定了我們的枚舉類型。當然整個描述符中的其他標有 (static) 的部分都是必須與示例一模一樣的，是標準的規定。有些是 TMC 標準，有些是 USB 標準，反正標有 (static) 的部分都一模一樣就好了。
最為特殊的是，USB-TMC 的協議沒有高速全速之分，無論工作在什麼 USB 線路上，都需要設備限定符，這是和其他現代化的 USB 協議棧所不同的地方。
次為特殊的是，USB-TMC 設備不能使用組合枚舉，會破壞 NI-VISA 對 USB-TMC 的識別和資源調用。例如我嘗試組合枚舉成 TMC + 串口 設備，設備管理器中都顯示出來了 (枚舉成功)，但是使用 VISA 調用時只能調用串口，TMC 設備不能調用了。
向儀器發送指令的過程#
通信中，會通過此前描述符中的 Bulk Out 端點向儀器發送報文。所以設備應該反復開啟這個 Bulk Out 端點以接收任何可能的報文。如果設備沒有開啟 Bulk Out 端點，將會使得設備產生大量的 NAK 包，觸發向設備發送重啟端點的 setup 指令。
例如一個經典的報文如下
0x01, 0x02, 0xFD, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2A, 0x49, 0x44, 0x4E, 0x3F, 0x0A, 0x00, 0x00
這個報文可以依據 USBTMC_1_00 標準文檔中的描述進行解析，分為如下幾個段。
| 報文段 | 含義 |
|---|---|
| 0x01 | 標識這個報文是 OUT 請求，也就是儀器需要解析這個報文的內容進行動作。 |
| 0x02, 0xFD | 報文 tag 及其反碼，這個 tag 每個報文都會不同。 |
| 0x00 | 固定 0。 |
| 0x06, 0x00, 0x00, 0x00 | 指內容長度是 6 ，這個長度以小端 32 位傳輸。 |
| 0x01, 0x00, 0x00, 0x00 | 僅首字節的第一個 bit 有意義，是 1 表示內容語句已經完成傳輸，是 0 表示還有後續的內容報文。 |
| 0x2A, 0x49, 0x44, 0x4E, 0x3F, 0x0A | 6 個字節的正式內容，是 *IDN?\r ，\r 是回車的轉義字符。 |
| 0x00, 0x00 | 保證整個報文長度是 4 字節對齊的補 0。 |
簡單來說也就是解析 Bulk Out 端點接收到的報文數據的首個字節，如果是 0x01 那麼進行後續解析，提取到 "*IDN?" 的正式 SCPI 指令並進行處理。
向儀器接收回覆的過程#
通信中，儀器並不能隨意通過 USB 向上位機發送回覆，這是和串口通信不同的。當上位機期望接收回覆數據時，會在 Bulk Out 端點上發送一個報文，表示儀器現在可以發送回覆了，一個經典開啟回覆的報文示例如下。
0x02, 0x03, 0xFC, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
這個報文可以依據 USBTMC_1_00 標準文檔中的描述進行解析，分為如下幾個段。
| 報文段 | 含義 |
|---|---|
| 0x02 | 標識這個報文是 IN 請求，也就是儀器應當發送任何可能的回覆了。 |
| 0x03, 0xFC | 報文 tag 及其反碼，這個 tag 每個報文都會不同。 |
| 0x00 | 固定 0。 |
| 0x00, 0x04, 0x00, 0x00 | 表示上位機開通了 0x0400 共 1024 個字節的接收 buffer，這個值完全不用理會，上位機資源那麼豐富，如果通信失敗讓他自己開大點就好了。 |
| 0x00 | 其 D1 位也就是 &0x2 的那一位有意義，如果是 1 意味著下面一個字節是上位機支持且設備必須支持的終止符，如果是 0 則不用理會。其他位全是預留。 |
| 0x00 | 如果上個字節的 D1 位是 1，那麼這個字節表示支持的終止符，例如 \r。 |
| 0x00, 0x00 | 填充的保留字符，實際作用也是保證整個報文長度是 4 字節對齊的補 0。 |
簡單來說也就是解析 Bulk Out 端點接收到的報文數據的首個字節，如果是 0x02 那麼開啟設備的發送通道，例如上位機此前傳輸了 "*IDN?" 的正式 SCPI 指令，那麼設備此時需要傳輸原本產生的回覆。
而所謂指定終止符功能，當然不會支持，在後面必須的 setup 包介紹中，會介紹如何讓上位機知道我們不支持這個指定。
一個經典的回覆傳輸報文如下。
0x02, 0x03, 0xFC, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2A, 0x49, 0x44, 0x4E, 0x3F, 0x0A, 0x00, 0x00,
| 報文段 | 含義 |
|---|---|
| 0x02 | 標識這個報文是 IN 請求的回覆。 |
| 0x03, 0xFC | 報文 tag 及其反碼，這個 tag 應該複製請求報文的。 |
| 0x00 | 固定 0。 |
| 0x06, 0x00, 0x00, 0x00 | 表示回覆的有效數據共 6 個字節，這個長度以小端 32 位傳輸。 |
| 0x01, 0x00, 0x00, 0x00 | 僅首字節的第一個 bit 有意義，是 1 表示內容語句已經完成傳輸，是 0 表示還有後續的內容報文。 |
| 0x2A, 0x49, 0x44, 0x4E, 0x3F, 0x0A | *IDN?\r，這是在做回環測試，我的儀器會複製最後一條接收到的指令響應任何回覆。 |
| 0x00, 0x00 | 保證整個報文長度是 4 字節對齊的補 0。 |
一個優秀的 4 字節對齊方法#
使用位運算非常方便高效地進行 4 字節對齊
uint8_t *data; // 原有報文buffer
uint32_t len = OriginalLen; // 原有長度
for(uint32_t i = len; i < ((len + 0x3) & ~0x3U); i++)
{
data[i] = 0x00;
}
_write(data, ((len + 0x3) & ~0x3U));
setup 包的處理#
0x80,0x06 開頭的這些標準 setup 包，有如下類別，恕我也愛莫能助，我也是完全依賴 usbx 協議棧進行自動處理。
#define UX_GET_STATUS 0u
#define UX_CLEAR_FEATURE 1u
#define UX_SET_FEATURE 3u
#define UX_SET_ADDRESS 5u
#define UX_GET_DESCRIPTOR 6u
#define UX_SET_DESCRIPTOR 7u
#define UX_GET_CONFIGURATION 8u
#define UX_SET_CONFIGURATION 9u
#define UX_GET_INTERFACE 10u
#define UX_SET_INTERFACE 11u
#define UX_SYNCH_FRAME 12u
而 0xA1 or 0xA2 開頭的 COMMAND_REQUEST 包，有如下內容是我們必須處理的。
以 0xA1,0x07 開頭，表示在詢問設備的特性，此時有一個示例的回覆包如下。其中的內容比較多，可以自行翻閱文檔，推薦是直接按這個回覆就好了。此時會告訴上位機，我們不支持設定結尾符。
0x01, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
以 0xA2,0x01 開頭，表示清除 bulk-out 傳輸，我們啥也不管，回覆成功就好了，回覆包如下。
0x01,tag (複製 setup 包以 0 計的第 2 個字節)
以 0xA2,0x02 開頭，表示詢問此前清除 bulk-out 傳輸的請求的狀態，我們啥也不管，回覆成功就好了，回覆包如下。
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00
至於其他的 COMMAND_REQUEST 包，不常用不用管。
[!NOTE]
首先你應該稍微熟悉 usbx 的實踐，起碼使用過其中已有的例子例如 CDC_ACM，否則以下內容毫無意義。以下均是在 usbx 這個 usb 協議棧框架下，如何將 TMC 枚舉增加進去的示例。
枚舉描述符在 usbx 中的實踐#
關注到 _ux_device_stack_initialize 函數，其中有這樣的部分，也就是只會以 Interface descriptor 以及 Configuration descriptor 部分在描述符整體中的位置進行寄存。Configuration descriptor 部分之前的統統作為 == 設備描述符 ==， Interface descriptor 部分以後的作為 == 端點描述符 ==。
switch(descriptor_type)
{
case UX_INTERFACE_DESCRIPTOR_ITEM:
......
break;
case UX_CONFIGURATION_DESCRIPTOR_ITEM:
......
break;
default:
break;
}
那麼需要稍微修改原本的 ux_device_descriptors.c 文件中 USBD_Device_Framework_Builder 函數的內容，原本函數中應該有類似如下的內容。其中指定只有高速 USB 才需要設備限定符，但是我們的 USB-TMC 現在通常都是工作在全速 USB 上的，又因為 USB-TMC 的協議沒有高速全速之分，所以這裡需要刪掉這個 if 判斷，無論高速還是全速，都把這個設備限定符編進描述符中。
/* Check if USBx is in high speed mode to add qualifier descriptor */
if(Speed == USBD_HIGH_SPEED)
{
pDevQualDesc = (USBD_DevQualiDescTypedef *)(pDevFrameWorkDesc + pdev->CurrDevDescSz);
pDevQualDesc->bLength = (uint8_t)sizeof(USBD_DevQualiDescTypedef);
pDevQualDesc->bDescriptorType = UX_DEVICE_QUALIFIER_DESCRIPTOR_ITEM;
pDevQualDesc->bcdDevice = 0x0200;
pDevQualDesc->Class = 0x00;
pDevQualDesc->SubClass = 0x00;
pDevQualDesc->Protocol = 0x00;
pDevQualDesc->bMaxPacketSize = 0x40;
pDevQualDesc->bNumConfigurations = 0x01;
pDevQualDesc->bReserved = 0x00;
pdev->CurrDevDescSz += (uint32_t)sizeof(USBD_DevQualiDescTypedef);
}
其他部分不需要大的調整，只要按照示例描述符一段一段修改參數就可以了，在原文件基礎上修改好的 ux_device_descriptors.c 和 ux_device_descriptors.h 文件如下。
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file ux_device_descriptors.c
* @author MCD Application Team
* @brief USBX Device descriptor header file
******************************************************************************
* @attention
*
* Copyright (c) 2020-2021 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "ux_device_descriptors.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
USBD_DevClassHandleTypeDef USBD_Device_FS, USBD_Device_HS;
uint8_t UserClassInstance[USBD_MAX_CLASS_INTERFACES] = {
CLASS_TYPE_TMC,
};
uint8_t UserTMCInterface[] = {
INTERFACE_TMC_USB488,
};
/* The generic device descriptor buffer that will be filled by builder
Size of the buffer is the maximum possible device FS descriptor size. */
#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN static uint8_t DevFrameWorkDesc_FS[USBD_FRAMEWORK_MAX_DESC_SZ] __ALIGN_END = {0};
/* The generic device descriptor buffer that will be filled by builder
Size of the buffer is the maximum possible device HS descriptor size. */
#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN static uint8_t DevFrameWorkDesc_HS[USBD_FRAMEWORK_MAX_DESC_SZ] __ALIGN_END = {0};
static uint8_t *pDevFrameWorkDesc_FS = DevFrameWorkDesc_FS;
static uint8_t *pDevFrameWorkDesc_HS = DevFrameWorkDesc_HS;
/* USER CODE BEGIN PV0 */
/* USER CODE END PV0 */
/* String Device Framework :
Byte 0 and 1 : Word containing the language ID : 0x0904 for US
Byte 2 : Byte containing the index of the descriptor
Byte 3 : Byte containing the length of the descriptor string
*/
#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN UCHAR USBD_string_framework[USBD_STRING_FRAMEWORK_MAX_LENGTH] __ALIGN_END = {0};
/* Multiple languages are supported on the device, to add
a language besides English, the Unicode language code must
be appended to the language_id_framework array and the length
adjusted accordingly. */
#if defined(__ICCARM__) /* IAR Compiler */
#pragma data_alignment = 4
#endif /* defined ( __ICCARM__ ) */
__ALIGN_BEGIN UCHAR USBD_language_id_framework[LANGUAGE_ID_MAX_LENGTH] __ALIGN_END = {0};
/* USER CODE BEGIN PV1 */
/* USER CODE END PV1 */
/* Private function prototypes -----------------------------------------------*/
static void USBD_Desc_GetString(uint8_t *desc, uint8_t *Buffer, uint16_t *len);
static uint8_t USBD_Desc_GetLen(uint8_t *buf);
static uint8_t *USBD_Device_Framework_Builder(USBD_DevClassHandleTypeDef *pdev, uint8_t *pDevFrameWorkDesc, uint8_t *UserClassInstance, uint8_t Speed);
static uint8_t USBD_FrameWork_AddToConfDesc(USBD_DevClassHandleTypeDef *pdev, uint8_t Speed, uint8_t *pCmpstConfDesc);
static uint8_t USBD_FrameWork_AddClass(USBD_DevClassHandleTypeDef *pdev, USBD_CompositeClassTypeDef class, uint8_t cfgidx, uint8_t Speed, uint8_t *pCmpstConfDesc);
static uint8_t USBD_FrameWork_FindFreeIFNbr(USBD_DevClassHandleTypeDef *pdev);
static void USBD_FrameWork_AddConfDesc(uint32_t Conf, uint32_t *pSze);
static void USBD_FrameWork_AssignEp(USBD_DevClassHandleTypeDef *pdev, uint8_t Add, uint8_t Type, uint32_t Sze);
static void USBD_FrameWork_TMC_Desc(USBD_DevClassHandleTypeDef *pdev, uint32_t pConf, uint32_t *Sze);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* @brief USBD_Get_Device_Framework_Speed
* Return the device speed descriptor
* @param Speed : HIGH or FULL SPEED flag
* @param length : length of HIGH or FULL SPEED array
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_Get_Device_Framework_Speed(uint8_t Speed, ULONG *Length)
{
uint8_t *pFrameWork = NULL;
/* USER CODE BEGIN Device_Framework0 */
/* USER CODE END Device_Framework0 */
if(USBD_FULL_SPEED == Speed)
{
USBD_Device_Framework_Builder(&USBD_Device_FS, pDevFrameWorkDesc_FS, UserClassInstance, Speed);
/* Get the length of USBD_device_framework_full_speed */
*Length = (ULONG)(USBD_Device_FS.CurrDevDescSz + USBD_Device_FS.CurrConfDescSz);
pFrameWork = pDevFrameWorkDesc_FS;
}
else
{
USBD_Device_Framework_Builder(&USBD_Device_HS, pDevFrameWorkDesc_HS, UserClassInstance, Speed);
/* Get the length of USBD_device_framework_high_speed */
*Length = (ULONG)(USBD_Device_HS.CurrDevDescSz + USBD_Device_HS.CurrConfDescSz);
pFrameWork = pDevFrameWorkDesc_HS;
}
/* USER CODE BEGIN Device_Framework1 */
/* USER CODE END Device_Framework1 */
return pFrameWork;
}
/**
* @brief USBD_Get_String_Framework
* Return the language_id_framework
* @param Length : Length of String_Framework
* @retval Pointer to language_id_framework buffer
*/
uint8_t *USBD_Get_String_Framework(ULONG *Length)
{
uint16_t len = 0U;
uint8_t count = 0U;
/* USER CODE BEGIN String_Framework0 */
/* USER CODE END String_Framework0 */
/* Set the Manufacturer language Id and index in USBD_string_framework */
USBD_string_framework[count++] = USBD_LANGID_STRING & 0xFF;
USBD_string_framework[count++] = USBD_LANGID_STRING >> 8;
USBD_string_framework[count++] = USBD_IDX_MFC_STR;
/* Set the Manufacturer string in string_framework */
USBD_Desc_GetString((uint8_t *)USBD_MANUFACTURER_STRING, USBD_string_framework + count, &len);
/* Set the Product language Id and index in USBD_string_framework */
count += len + 1;
USBD_string_framework[count++] = USBD_LANGID_STRING & 0xFF;
USBD_string_framework[count++] = USBD_LANGID_STRING >> 8;
USBD_string_framework[count++] = USBD_IDX_PRODUCT_STR;
/* Set the Product string in USBD_string_framework */
USBD_Desc_GetString((uint8_t *)USBD_PRODUCT_STRING, USBD_string_framework + count, &len);
/* Set Serial language Id and index in string_framework */
count += len + 1;
USBD_string_framework[count++] = USBD_LANGID_STRING & 0xFF;
USBD_string_framework[count++] = USBD_LANGID_STRING >> 8;
USBD_string_framework[count++] = USBD_IDX_SERIAL_STR;
/* Set the Serial number in USBD_string_framework */
USBD_Desc_GetString((uint8_t *)USBD_SERIAL_NUMBER, USBD_string_framework + count, &len);
/* USER CODE BEGIN String_Framework1 */
/* USER CODE END String_Framework1 */
/* Get the length of USBD_string_framework */
*Length = strlen((const char *)USBD_string_framework);
return USBD_string_framework;
}
/**
* @brief USBD_Get_Language_Id_Framework
* Return the language_id_framework
* @param Length : Length of Language_Id_Framework
* @retval Pointer to language_id_framework buffer
*/
uint8_t *USBD_Get_Language_Id_Framework(ULONG *Length)
{
uint8_t count = 0U;
/* Set the language Id in USBD_language_id_framework */
USBD_language_id_framework[count++] = USBD_LANGID_STRING & 0xFF;
USBD_language_id_framework[count++] = USBD_LANGID_STRING >> 8;
/* Get the length of USBD_language_id_framework */
*Length = strlen((const char *)USBD_language_id_framework);
return USBD_language_id_framework;
}
/**
* @brief USBD_Get_Interface_Number
* Return interface number
* @param class_type : Device class type
* @param interface_type : Device interface type
* @retval interface number
*/
uint16_t USBD_Get_Interface_Number(uint8_t class_type, uint8_t interface_type)
{
uint8_t itf_num = 0U;
uint8_t idx = 0U;
/* USER CODE BEGIN USBD_Get_Interface_Number0 */
/* USER CODE END USBD_Get_Interface_Number0 */
for(idx = 0; idx < USBD_MAX_SUPPORTED_CLASS; idx++)
{
if((USBD_Device_FS.tclasslist[idx].ClassType == class_type) && (USBD_Device_FS.tclasslist[idx].InterfaceType == interface_type))
{
itf_num = USBD_Device_FS.tclasslist[idx].Ifs[0];
}
}
/* USER CODE BEGIN USBD_Get_Interface_Number1 */
/* USER CODE END USBD_Get_Interface_Number1 */
return itf_num;
}
/**
* @brief USBD_Get_Configuration_Number
* Return configuration number
* @param class_type : Device class type
* @param interface_type : Device interface type
* @retval configuration number
*/
uint16_t USBD_Get_Configuration_Number(uint8_t class_type, uint8_t interface_type)
{
uint8_t cfg_num = 1U;
/* USER CODE BEGIN USBD_Get_CONFIGURATION_Number0 */
/* USER CODE END USBD_Get_CONFIGURATION_Number0 */
/* USER CODE BEGIN USBD_Get_CONFIGURATION_Number1 */
/* USER CODE END USBD_Get_CONFIGURATION_Number1 */
return cfg_num;
}
/**
* @brief USBD_Desc_GetString
* Convert ASCII string into Unicode one
* @param desc : descriptor buffer
* @param Unicode : Formatted string buffer (Unicode)
* @param len : descriptor length
* @retval None
*/
static void USBD_Desc_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
{
uint8_t idx = 0U;
uint8_t *pdesc;
if(desc == NULL)
{
return;
}
pdesc = desc;
*len = (uint16_t)USBD_Desc_GetLen(pdesc);
unicode[idx++] = *(uint8_t *)len;
while(*pdesc != (uint8_t)'\0')
{
unicode[idx++] = *pdesc;
pdesc++;
}
}
/**
* @brief USBD_Desc_GetLen
* return the string length
* @param buf : pointer to the ASCII string buffer
* @retval string length
*/
static uint8_t USBD_Desc_GetLen(uint8_t *buf)
{
uint8_t len = 0U;
uint8_t *pbuff = buf;
while(*pbuff != (uint8_t)'\0')
{
len++;
pbuff++;
}
return len;
}
/**
* @brief USBD_Device_Framework_Builder
* Device Framework builder
* @param pdev: device instance
* @param pDevFrameWorkDesc: Pointer to the device framework descriptor
* @param UserClassInstance: type of the class to be added
* @param Speed: Speed parameter HS or FS
* @retval status
*/
static uint8_t *USBD_Device_Framework_Builder(USBD_DevClassHandleTypeDef *pdev, uint8_t *pDevFrameWorkDesc, uint8_t *UserClassInstance, uint8_t Speed)
{
static USBD_DeviceDescTypedef *pDevDesc;
static USBD_DevQualiDescTypedef *pDevQualDesc;
uint8_t Idx_Instance = 0U;
/* Set Dev and conf descriptors size to 0 */
pdev->CurrConfDescSz = 0U;
pdev->CurrDevDescSz = 0U;
/* Set the pointer to the device descriptor area*/
pDevDesc = (USBD_DeviceDescTypedef *)pDevFrameWorkDesc;
/* Start building the generic device descriptor common part */
pDevDesc->bLength = (uint8_t)sizeof(USBD_DeviceDescTypedef);
pDevDesc->bDescriptorType = UX_DEVICE_DESCRIPTOR_ITEM;
pDevDesc->bcdUSB = USB_BCDUSB;
pDevDesc->bDeviceClass = 0x00;
pDevDesc->bDeviceSubClass = 0x00;
pDevDesc->bDeviceProtocol = 0x00;
pDevDesc->bMaxPacketSize = USBD_MAX_EP0_SIZE;
pDevDesc->idVendor = USBD_VID;
pDevDesc->idProduct = USBD_PID;
pDevDesc->bcdDevice = 0x0100;
pDevDesc->iManufacturer = USBD_IDX_MFC_STR;
pDevDesc->iProduct = USBD_IDX_PRODUCT_STR;
pDevDesc->iSerialNumber = USBD_IDX_SERIAL_STR;
pDevDesc->bNumConfigurations = USBD_MAX_NUM_CONFIGURATION;
pdev->CurrDevDescSz += (uint32_t)sizeof(USBD_DeviceDescTypedef);
/* Check if USBx is in high speed mode to add qualifier descriptor */
pDevQualDesc = (USBD_DevQualiDescTypedef *)(pDevFrameWorkDesc + pdev->CurrDevDescSz);
pDevQualDesc->bLength = (uint8_t)sizeof(USBD_DevQualiDescTypedef);
pDevQualDesc->bDescriptorType = UX_DEVICE_QUALIFIER_DESCRIPTOR_ITEM;
pDevQualDesc->bcdDevice = 0x0200;
pDevQualDesc->Class = 0x00;
pDevQualDesc->SubClass = 0x00;
pDevQualDesc->Protocol = 0x00;
pDevQualDesc->bMaxPacketSize = 0x40;
pDevQualDesc->bNumConfigurations = 0x01;
pDevQualDesc->bReserved = 0x00;
pdev->CurrDevDescSz += (uint32_t)sizeof(USBD_DevQualiDescTypedef);
/* Build the device framework */
while(Idx_Instance < USBD_MAX_SUPPORTED_CLASS)
{
if((pdev->classId < USBD_MAX_SUPPORTED_CLASS) && (pdev->NumClasses < USBD_MAX_SUPPORTED_CLASS) && (UserClassInstance[Idx_Instance] != CLASS_TYPE_NONE))
{
/* Call the composite class builder */
(void)USBD_FrameWork_AddClass(pdev, (USBD_CompositeClassTypeDef)UserClassInstance[Idx_Instance], 0, Speed, (pDevFrameWorkDesc + pdev->CurrDevDescSz));
/* Increment the ClassId for the next occurrence */
pdev->classId++;
pdev->NumClasses++;
}
Idx_Instance++;
}
/* Check if there is a composite class and update device class */
if(pdev->NumClasses > 1)
{
pDevDesc->bDeviceClass = 0xEF;
pDevDesc->bDeviceSubClass = 0x02;
pDevDesc->bDeviceProtocol = 0x01;
}
else
{
/* Check if the CDC ACM class is set and update device class */
if(UserClassInstance[0] == CLASS_TYPE_CDC_ACM)
{
pDevDesc->bDeviceClass = 0x02;
pDevDesc->bDeviceSubClass = 0x02;
pDevDesc->bDeviceProtocol = 0x00;
}
}
return pDevFrameWorkDesc;
}
/**
* @brief USBD_FrameWork_AddToConfDesc
* Add a new class to the configuration descriptor
* @param pdev: device instance
* @param Speed: device speed
* @param pCmpstConfDesc: to composite device configuration descriptor
* @retval status
*/
uint8_t USBD_FrameWork_AddToConfDesc(USBD_DevClassHandleTypeDef *pdev, uint8_t Speed, uint8_t *pCmpstConfDesc)
{
uint8_t interface = 0U;
pdev->Speed = Speed;
if(pdev->classId == 0U)
{
/* Add configuration and IAD descriptors */
USBD_FrameWork_AddConfDesc((uint32_t)pCmpstConfDesc, &pdev->CurrConfDescSz);
}
switch(pdev->tclasslist[pdev->classId].ClassType)
{
case CLASS_TYPE_TMC:
switch(pdev->tclasslist[pdev->classId].InterfaceType)
{
case INTERFACE_TMC_USB488:
/* Find the first available interface slot and Assign number of interfaces */
interface = USBD_FrameWork_FindFreeIFNbr(pdev);
pdev->tclasslist[pdev->classId].NumIf = 1U;
pdev->tclasslist[pdev->classId].Ifs[0] = interface;
/* Assign endpoint numbers */
pdev->tclasslist[pdev->classId].NumEps = 2U; /* EP_IN, EP_OUT */
/* Check the current speed to assign endpoints */
if(pdev->Speed == USBD_HIGH_SPEED)
{
/* Assign IN Endpoint */
USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPIN_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPIN_HS_MPS);
/* Assign OUT Endpoint */
USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPOUT_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPOUT_HS_MPS);
}
else
{
USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPIN_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPIN_FS_MPS);
USBD_FrameWork_AssignEp(pdev, USBD_TMC_NONE_EPOUT_ADDR, USBD_EP_TYPE_BULK, USBD_TMC_NONE_EPOUT_FS_MPS);
}
USBD_FrameWork_TMC_Desc(pdev, (uint32_t)pCmpstConfDesc, &pdev->CurrConfDescSz);
break;
default:
break;
}
break;
default:
break;
}
return UX_SUCCESS;
}
/**
* @brief USBD_FrameWork_AddClass
* Register a class in the class builder
* @param pdev: device instance
* @param class: type of the class to be added (from USBD_CompositeClassTypeDef)
* @param cfgidx: configuration index
* @param speed: device speed
* @param pCmpstConfDesc: to composite device configuration descriptor
* @retval status
*/
uint8_t USBD_FrameWork_AddClass(USBD_DevClassHandleTypeDef *pdev, USBD_CompositeClassTypeDef class, uint8_t cfgidx, uint8_t Speed, uint8_t *pCmpstConfDesc)
{
static uint8_t interface_idx = 0U;
if((pdev->classId < USBD_MAX_SUPPORTED_CLASS) && (pdev->tclasslist[pdev->classId].Active == 0U))
{
/* Store the class parameters in the global tab */
pdev->tclasslist[pdev->classId].ClassId = pdev->classId;
pdev->tclasslist[pdev->classId].Active = 1U;
pdev->tclasslist[pdev->classId].ClassType = class;
if(class == CLASS_TYPE_TMC)
{
pdev->tclasslist[pdev->classId].InterfaceType = UserTMCInterface[interface_idx];
interface_idx++;
if(interface_idx == sizeof(UserTMCInterface))
{
interface_idx = 0U;
}
}
/* Call configuration descriptor builder and endpoint configuration builder */
if(USBD_FrameWork_AddToConfDesc(pdev, Speed, pCmpstConfDesc) != UX_SUCCESS)
{
return UX_ERROR;
}
}
UNUSED(cfgidx);
return UX_SUCCESS;
}
/**
* @brief USBD_FrameWork_FindFreeIFNbr
* Find the first interface available slot
* @param pdev: device instance
* @retval The interface number to be used
*/
static uint8_t USBD_FrameWork_FindFreeIFNbr(USBD_DevClassHandleTypeDef *pdev)
{
uint32_t idx = 0U;
/* Unroll all already activated classes */
for(uint32_t i = 0U; i < pdev->NumClasses; i++)
{
/* Unroll each class interfaces */
for(uint32_t j = 0U; j < pdev->tclasslist[i].NumIf; j++)
{
/* Increment the interface counter index */
idx++;
}
}
/* Return the first available interface slot */
return (uint8_t)idx;
}
/**
* @brief USBD_FrameWork_AddConfDesc
* Add a new class to the configuration descriptor
* @param Conf: configuration descriptor
* @param pSze: pointer to the configuration descriptor size
* @retval none
*/
static void USBD_FrameWork_AddConfDesc(uint32_t Conf, uint32_t *pSze)
{
/* Intermediate variable to comply with MISRA-C Rule 11.3 */
USBD_ConfigDescTypedef *ptr = (USBD_ConfigDescTypedef *)Conf;
ptr->bLength = (uint8_t)sizeof(USBD_ConfigDescTypedef);
ptr->bDescriptorType = UX_CONFIGURATION_DESCRIPTOR_ITEM;
ptr->wDescriptorLength = 0x20;
ptr->bNumInterfaces = 1U;
ptr->bConfigurationValue = 1U;
ptr->iConfiguration = USBD_CONFIG_STR_DESC_IDX;
ptr->bmAttributes = USBD_CONFIG_BMATTRIBUTES;
ptr->bMaxPower = USBD_CONFIG_MAXPOWER;
*pSze += sizeof(USBD_ConfigDescTypedef);
}
/**
* @brief USBD_FrameWork_AssignEp
* Assign and endpoint
* @param pdev: device instance
* @param Add: Endpoint address
* @param Type: Endpoint type
* @param Sze: Endpoint max packet size
* @retval none
*/
static void USBD_FrameWork_AssignEp(USBD_DevClassHandleTypeDef *pdev, uint8_t Add, uint8_t Type, uint32_t Sze)
{
uint32_t idx = 0U;
/* Find the first available endpoint slot */
while(((idx < (pdev->tclasslist[pdev->classId]).NumEps) && ((pdev->tclasslist[pdev->classId].Eps[idx].is_used) != 0U)))
{
/* Increment the index */
idx++;
}
/* Configure the endpoint */
pdev->tclasslist[pdev->classId].Eps[idx].add = Add;
pdev->tclasslist[pdev->classId].Eps[idx].type = Type;
pdev->tclasslist[pdev->classId].Eps[idx].size = (uint16_t)Sze;
pdev->tclasslist[pdev->classId].Eps[idx].is_used = 1U;
}
/**
* @brief USBD_FrameWork_TMC_Desc
* Configure and Append the TMC Descriptor
* @param pdev: device instance
* @param pConf: Configuration descriptor pointer
* @param Sze: pointer to the current configuration descriptor size
* @retval None
*/
static void USBD_FrameWork_TMC_Desc(USBD_DevClassHandleTypeDef *pdev, uint32_t pConf, uint32_t *Sze)
{
static USBD_IfDescTypedef *pIfDesc;
static USBD_EpDescTypedef *pEpDesc;
switch(pdev->tclasslist[pdev->classId].InterfaceType)
{
case INTERFACE_TMC_USB488:
/* Append Interface descriptor to Configuration descriptor */
__USBD_FRAMEWORK_SET_IF(pdev->tclasslist[pdev->classId].Ifs[0], 0U, (uint8_t)(pdev->tclasslist[pdev->classId].NumEps), UX_DEVICE_CLASS_TMC_CLASS, UX_DEVICE_SUB_CLASS_USB488_CLASS, INTERFACE_TMC_USB488, 0U);
if(pdev->Speed == USBD_HIGH_SPEED)
{
/* Append Endpoint descriptor to Configuration descriptor */
__USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[0].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[0].size, USBD_TMC_NONE_EPIN_FS_BINTERVAL, USBD_TMC_NONE_EPIN_HS_BINTERVAL);
__USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[1].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[1].size, USBD_TMC_NONE_EPOUT_HS_BINTERVAL, USBD_TMC_NONE_EPOUT_FS_BINTERVAL);
}
else
{
/* Append Endpoint descriptor to Configuration descriptor */
__USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[0].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[0].size, USBD_TMC_NONE_EPIN_FS_BINTERVAL, USBD_TMC_NONE_EPIN_HS_BINTERVAL);
__USBD_FRAMEWORK_SET_EP(pdev->tclasslist[pdev->classId].Eps[1].add, USBD_EP_TYPE_BULK, (uint16_t)pdev->tclasslist[pdev->classId].Eps[1].size, USBD_TMC_NONE_EPOUT_HS_BINTERVAL, USBD_TMC_NONE_EPOUT_FS_BINTERVAL);
}
break;
default:
break;
}
}
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file ux_device_descriptors.h
* @author MCD Application Team
* @brief USBX Device descriptor header file
******************************************************************************
* @attention
*
* Copyright (c) 2020-2021 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __UX_DEVICE_DESCRIPTORS_H__
#define __UX_DEVICE_DESCRIPTORS_H__
#ifdef __cplusplus
extern "C"
{
#endif
/* Includes ------------------------------------------------------------------*/
#include "ux_api.h"
#include "ux_stm32_config.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "main.h"
/* USER CODE END Includes */
/* Private defines -----------------------------------------------------------*/
#define USBD_MAX_NUM_CONFIGURATION 1U
#define USBD_MAX_SUPPORTED_CLASS 3U
#define USBD_MAX_CLASS_ENDPOINTS 9U
#define USBD_MAX_CLASS_INTERFACES 12U
#define USBD_HID_CUSTOM_ACTIVATED 1U
#define USBD_CONFIG_MAXPOWER 0x64 // bMaxPower: 200 mA (0x64 * 2 mA)
#define USBD_COMPOSITE_USE_IAD 1U
#define USBD_DEVICE_FRAMEWORK_BUILDER_ENABLED 1U
#define USBD_FRAMEWORK_MAX_DESC_SZ 200U
/* Exported types ------------------------------------------------------------*/
/* USER CODE BEGIN ET */
/* USER CODE END ET */
/* Enum Class Type */
typedef enum
{
CLASS_TYPE_NONE = 0,
CLASS_TYPE_HID = 1,
CLASS_TYPE_CDC_ACM = 2,
CLASS_TYPE_MSC = 3,
CLASS_TYPE_CDC_ECM = 4,
CLASS_TYPE_DFU = 5,
CLASS_TYPE_VIDEO = 6,
CLASS_TYPE_PIMA_MTP = 7,
CLASS_TYPE_CCID = 8,
CLASS_TYPE_PRINTER = 9,
CLASS_TYPE_RNDIS = 10,
CLASS_TYPE_AUDIO_10 = 11,
CLASS_TYPE_AUDIO_20 = 12,
CLASS_TYPE_TMC = 40,
} USBD_CompositeClassTypeDef;
/* Enum NONE Interface Type */
typedef enum
{
INTERFACE_NONE_DEFIN = 0
} USBD_NONEInterfaceTypeDef;
/* Enum HID Interface Type */
typedef enum
{
INTERFACE_HID_CUSTOM = 0,
INTERFACE_HID_KEYBOARD = 1,
INTERFACE_HID_MOUSE = 2,
} USBD_HIDInterfaceTypeDef;
typedef enum
{
INTERFACE_TMC_USB488 = 1,
} USBD_TMCInterfaceTypeDef;
/* USB Endpoint handle structure */
typedef struct
{
uint32_t status;
uint32_t total_length;
uint32_t rem_length;
uint32_t maxpacket;
uint16_t is_used;
uint16_t bInterval;
} USBD_EndpointTypeDef;
/* USB endpoint handle structure */
typedef struct
{
uint8_t add;
uint8_t type;
uint16_t size;
uint8_t is_used;
} USBD_EPTypeDef;
/* USB Composite handle structure */
typedef struct
{
USBD_CompositeClassTypeDef ClassType;
uint32_t ClassId;
uint8_t InterfaceType;
uint32_t Active;
uint32_t NumEps;
uint32_t NumIf;
USBD_EPTypeDef Eps[USBD_MAX_CLASS_ENDPOINTS];
uint8_t Ifs[USBD_MAX_CLASS_INTERFACES];
} USBD_CompositeElementTypeDef;
/* USB Device handle structure */
typedef struct _USBD_DevClassHandleTypeDef
{
uint8_t Speed;
uint32_t classId;
uint32_t NumClasses;
USBD_CompositeElementTypeDef tclasslist[USBD_MAX_SUPPORTED_CLASS];
uint32_t CurrDevDescSz;
uint32_t CurrConfDescSz;
} USBD_DevClassHandleTypeDef;
/* USB Device endpoint direction */
typedef enum
{
OUT = 0x00,
IN = 0x80,
} USBD_EPDirectionTypeDef;
/* USB Device descriptors structure */
typedef struct
{
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t bcdUSB;
uint8_t bDeviceClass;
uint8_t bDeviceSubClass;
uint8_t bDeviceProtocol;
uint8_t bMaxPacketSize;
uint16_t idVendor;
uint16_t idProduct;
uint16_t bcdDevice;
uint8_t iManufacturer;
uint8_t iProduct;
uint8_t iSerialNumber;
uint8_t bNumConfigurations;
} __PACKED USBD_DeviceDescTypedef;
/* USB Iad descriptors structure */
typedef struct
{
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bFirstInterface;
uint8_t bInterfaceCount;
uint8_t bFunctionClass;
uint8_t bFunctionSubClass;
uint8_t bFunctionProtocol;
uint8_t iFunction;
} __PACKED USBD_IadDescTypedef;
/* USB interface descriptors structure */
typedef struct
{
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bInterfaceNumber;
uint8_t bAlternateSetting;
uint8_t bNumEndpoints;
uint8_t bInterfaceClass;
uint8_t bInterfaceSubClass;
uint8_t bInterfaceProtocol;
uint8_t iInterface;
} __PACKED USBD_IfDescTypedef;
/* USB endpoint descriptors structure */
typedef struct
{
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bEndpointAddress;
uint8_t bmAttributes;
uint16_t wMaxPacketSize;
uint8_t bInterval;
} __PACKED USBD_EpDescTypedef;
/* USB Config descriptors structure */
typedef struct
{
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t wDescriptorLength;
uint8_t bNumInterfaces;
uint8_t bConfigurationValue;
uint8_t iConfiguration;
uint8_t bmAttributes;
uint8_t bMaxPower;
} __PACKED USBD_ConfigDescTypedef;
/* USB Qualifier descriptors structure */
typedef struct
{
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t bcdDevice;
uint8_t Class;
uint8_t SubClass;
uint8_t Protocol;
uint8_t bMaxPacketSize;
uint8_t bNumConfigurations;
uint8_t bReserved;
} __PACKED USBD_DevQualiDescTypedef;
typedef struct
{
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t bcdTMC;
uint16_t bCountryCode;
uint8_t bNumDescriptors;
uint8_t bTMCDescriptorType;
uint16_t wDescriptor;
} __PACKED USBD_TMCDescTypedef;
/* Exported functions prototypes ---------------------------------------------*/
/* USER CODE BEGIN EFP */
/* USER CODE END EFP */
uint8_t *USBD_Get_Device_Framework_Speed(uint8_t Speed, ULONG *Length);
uint8_t *USBD_Get_String_Framework(ULONG *Length);
uint8_t *USBD_Get_Language_Id_Framework(ULONG *Length);
uint16_t USBD_Get_Interface_Number(uint8_t class_type, uint8_t interface_type);
uint16_t USBD_Get_Configuration_Number(uint8_t class_type, uint8_t interface_type);
/* Private defines -----------------------------------------------------------*/
/* USER CODE BEGIN Private_defines */
/* USER CODE END Private_defines */
#define USBD_VID 0x0A69
#define USBD_PID 0x088A
#define USBD_LANGID_STRING 1033 /* English (United States) */
#define USBD_MANUFACTURER_STRING "YONO"
#define USBD_PRODUCT_STRING "yonoDevice"
#define USBD_SERIAL_NUMBER "123456789"
#define USB_DESC_TYPE_INTERFACE 0x04U
#define USB_DESC_TYPE_ENDPOINT 0x05U
#define USBD_EP_TYPE_CTRL 0x00U
#define USBD_EP_TYPE_ISOC 0x01U
#define USBD_EP_TYPE_BULK 0x02U
#define USBD_EP_TYPE_INTR 0x03U
#define USBD_FULL_SPEED 0x00U
#define USBD_HIGH_SPEED 0x01U
#define USB_BCDUSB 0x0200U
#define LANGUAGE_ID_MAX_LENGTH 2U
#define USBD_IDX_MFC_STR 0x01U
#define USBD_IDX_PRODUCT_STR 0x02U
#define USBD_IDX_SERIAL_STR 0x03U
#define USBD_MAX_EP0_SIZE 64U
#define USBD_DEVICE_QUALIFIER_DESC_SIZE 0x0AU
#define USBD_STRING_FRAMEWORK_MAX_LENGTH 256U
/* */
#define UX_DEVICE_CLASS_TMC_CLASS 0xFEU
#define UX_DEVICE_SUB_CLASS_USB488_CLASS 0x03U
/* Device TMC none */
#define USBD_TMC_NONE_EPIN_ADDR 0x81U
#define USBD_TMC_NONE_EPOUT_ADDR 0x01U
#define USBD_TMC_NONE_EPIN_FS_MPS 0x40U
#define USBD_TMC_NONE_EPIN_HS_MPS 0x40U
#define USBD_TMC_NONE_EPIN_FS_BINTERVAL 5U
#define USBD_TMC_NONE_EPIN_HS_BINTERVAL 0U
#define USBD_TMC_NONE_EPOUT_FS_MPS 0x40U
#define USBD_TMC_NONE_EPOUT_HS_MPS 0x40U
#define USBD_TMC_NONE_EPOUT_FS_BINTERVAL 0U
#define USBD_TMC_NONE_EPOUT_HS_BINTERVAL 5U
#ifndef USBD_CONFIG_STR_DESC_IDX
#define USBD_CONFIG_STR_DESC_IDX 0x00
#endif /* USBD_CONFIG_STR_DESC_IDX */
#ifndef USBD_CONFIG_BMATTRIBUTES
#define USBD_CONFIG_BMATTRIBUTES 0x80
#endif /* USBD_CONFIG_BMATTRIBUTES */
/* Private macro -----------------------------------------------------------*/
/* USER CODE BEGIN Private_macro */
/* USER CODE END Private_macro */
#define __USBD_FRAMEWORK_SET_EP(epadd, eptype, epsize, HSinterval, FSinterval) \
do \
{ \
/* Append Endpoint descriptor to Configuration descriptor */ \
pEpDesc = ((USBD_EpDescTypedef *)((uint32_t)pConf + *Sze)); \
pEpDesc->bLength = (uint8_t)sizeof(USBD_EpDescTypedef); \
pEpDesc->bDescriptorType = USB_DESC_TYPE_ENDPOINT; \
pEpDesc->bEndpointAddress = (epadd); \
pEpDesc->bmAttributes = (eptype); \
pEpDesc->wMaxPacketSize = (epsize); \
if(pdev->Speed == USBD_HIGH_SPEED) \
{ \
pEpDesc->bInterval = (HSinterval); \
} \
else \
{ \
pEpDesc->bInterval = (FSinterval); \
} \
*Sze += (uint32_t)sizeof(USBD_EpDescTypedef); \
} \
while(0)
#define __USBD_FRAMEWORK_SET_IF(ifnum, alt, eps, class, subclass, protocol, istring) \
do \
{ \
/* Interface Descriptor */ \
pIfDesc = ((USBD_IfDescTypedef *)((uint32_t)pConf + *Sze)); \
pIfDesc->bLength = (uint8_t)sizeof(USBD_IfDescTypedef); \
pIfDesc->bDescriptorType = USB_DESC_TYPE_INTERFACE; \
pIfDesc->bInterfaceNumber = (ifnum); \
pIfDesc->bAlternateSetting = (alt); \
pIfDesc->bNumEndpoints = (eps); \
pIfDesc->bInterfaceClass = (class); \
pIfDesc->bInterfaceSubClass = (subclass); \
pIfDesc->bInterfaceProtocol = (protocol); \
pIfDesc->iInterface = (istring); \
*Sze += (uint32_t)sizeof(USBD_IfDescTypedef); \
} \
while(0)
#ifdef __cplusplus
}
#endif
#endif /* __UX_DEVICE_DESCRIPTORS_H__ */
發送和接收在 usbx 中的實踐#
管你這那的，看代碼。開了一共 3 個 buffer，這是必須的，因為 USB 傳輸線路會佔用一個 buffer，接收到的完整語句的寄存需要一個，發送寄存需要一個。值得注意的是，_ux_device_class_dpump_tmc_read 函數哪怕經過我的改造，也依然是一個阻塞的函數，所以 TMC_Engine () 的 TMC 收發支持需要獨立佔用一個線程。
TMC_Dpump 指針將會在 TMC_Device 的 activate 和 deactivate 中進行綁定和解绑。
/********************************************************************************
**** Copyright (C), 2024, Yuanlong Xu <[email protected]> ****
**** All rights reserved ****
********************************************************************************
* File Name : ux_device_tmc.c
* Author : yono
* Date : 2025-01-07
* Version : 1.0
********************************************************************************/
/**************************************************************************/
/*
tmc用戶解析
*/
/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include "ux_api.h"
#include "ux_device_class_dpump.h"
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
#define UX_HOST_CLASS_DPUMP_PACKET_SIZE 255
extern UX_SLAVE_CLASS_DPUMP *TMC_Dpump;
/* 信道buffer */
uint8_t device_buffer[UX_HOST_CLASS_DPUMP_PACKET_SIZE];
/* 幀信息 */
uint8_t TransferEMO = 0; // 傳輸結束標誌 0x00繼續傳輸 0x01傳輸結束
uint8_t TransferTag = 0; // 傳輸令牌，回覆時複製
/* 信息buffer */
uint8_t SCPI_Read[255];
uint32_t SCPI_Read_Length = 0;
uint8_t SCPI_Write[255];
uint32_t SCPI_Write_Length = 0;
/* Private Constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
uint32_t TMC_Write(uint8_t *data, uint32_t len);
extern UINT _ux_device_class_dpump_tmc_read(UX_SLAVE_CLASS_DPUMP *dpump, UCHAR *buffer, ULONG requested_length, ULONG *actual_length);
/* Private functions ---------------------------------------------------------*/
void TMC_Engine(void)
{
UINT status;
ULONG actual_length;
if(TMC_Dpump != UX_NULL)
{
/* 收取部分 */
status = _ux_device_class_dpump_tmc_read(TMC_Dpump, device_buffer, UX_HOST_CLASS_DPUMP_PACKET_SIZE, &actual_length);
if(status == UX_SUCCESS)
{
if((0xff ^ device_buffer[1] ^ device_buffer[2]) || device_buffer[3] != 0)
return; // 不良報文
switch(device_buffer[0]) // 命令
{
case 0x01:
// 接收分支
ux_utility_memory_copy(&SCPI_Read[0 + SCPI_Read_Length], // 兼容分包傳輸，以前一次傳輸的長度為起始
&device_buffer[12], // 真實攜帶數據的起始位置
*(uint32_t *)(&device_buffer[4])); // 4~7字節以小端組成數據長度
SCPI_Read_Length += *(uint32_t *)(&device_buffer[4]);
TransferEMO = device_buffer[8] & 0x01;
if(TransferEMO)
{
/* 回環測試 */
TMC_Write(SCPI_Read, SCPI_Read_Length);
/* 結尾兼容 */
// 傳輸結束 觸發解析
SCPI_Read_Length = 0;
}
else
{
// 傳輸未結束 不處理
}
break;
case 0x02:
TransferTag = device_buffer[1]; // 寄存令牌
/* 0~3 是請求及令牌，無需更改*/
*(uint32_t *)(&device_buffer[4]) = SCPI_Write_Length; // 4~7字節以小端組成數據長度
/* 成功固定數據 */
device_buffer[8] = 0x1; // 成功回覆
device_buffer[9] = 0x00;
device_buffer[10] = 0x00;
device_buffer[11] = 0x00;
/* 填充發送數據 */
ux_utility_memory_copy(&device_buffer[12], SCPI_Write, SCPI_Write_Length);
/* 填充0x00 此處如果原本就是4字節對齊，將多補4個0 */
for(uint32_t i = 12 + SCPI_Write_Length; i < ((12 + SCPI_Write_Length + 0x3) & ~0x3U); i++)
{
device_buffer[i] = 0x00;
}
/* 請求發送 */
status = _ux_device_class_dpump_write(TMC_Dpump, device_buffer, ((12 + SCPI_Write_Length + 0x3) & ~0x3U), &actual_length);
/* 清理發送請求 */
SCPI_Write_Length = 0;
break;
default:
break;
}
}
}
}
uint32_t TMC_Write(uint8_t *data, uint32_t len)
{
if(sizeof(SCPI_Write) < (SCPI_Write_Length + len))
return 1;
ux_utility_memory_copy(&SCPI_Write[0 + SCPI_Write_Length], // 兼容分包填充
data,
len);
SCPI_Write_Length += len;
return 0;
}
/**************************************************************************/
/* */
/* Copyright (c) Microsoft Corporation. All rights reserved. */
/* */
/* This software is licensed under the Microsoft Software License */
/* Terms for Microsoft Azure RTOS. Full text of the license can be */
/* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */
/* and in the root directory of this software. */
/* */
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** USBX Component */
/** */
/** Device DPUMP Class */
/** */
/**************************************************************************/
/**************************************************************************/
#define UX_SOURCE_CODE
/* Include necessary system files. */
#include "ux_api.h"
#include "ux_device_class_dpump.h"
#include "ux_device_stack.h"
/**
* @brief 基於ux_device_class_dpump_read 的非完全阻塞版，適合TMC設備的接收
*/
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _ux_device_class_dpump_tmc_read PORTABLE C */
/* 6.1 */
/* AUTHOR */
/* */
/* yono, yono233.cn */
/* */
/* DESCRIPTION */
/* */
/* This function reads from the DPUMP class of TMC, */
/* non-blocking of function _ux_device_class_dpump_write. */
/* */
/* INPUT */
/* */
/* dpump Address of dpump class */
/* instance */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* _ux_device_stack_transfer_request Request transfer */
/* _ux_utility_memory_copy Copy memory */
/* */
/* CALLED BY */
/* */
/* ThreadX */
/* */
/* RELEASE HISTORY */
/* */
/* DATE NAME DESCRIPTION */
/* */
/* 05-19-2020 Chaoqiong Xiao Initial Version 6.0 */
/* 09-30-2020 Chaoqiong Xiao Modified comment(s), */
/* verified memset and memcpy */
/* cases, */
/* resulting in version 6.1 */
/* 01-07-2025 yono Copy and modify to */
/* non-blocking */
/* */
/**************************************************************************/
UINT _ux_device_class_dpump_tmc_read(UX_SLAVE_CLASS_DPUMP *dpump, UCHAR *buffer, ULONG requested_length, ULONG *actual_length)
{
UX_SLAVE_ENDPOINT *endpoint;
UX_SLAVE_DEVICE *device;
UX_SLAVE_TRANSFER *transfer_request;
UINT status;
ULONG local_requested_length;
/* If trace is enabled, insert this event into the trace buffer. */
UX_TRACE_IN_LINE_INSERT(UX_TRACE_DEVICE_CLASS_DPUMP_READ, dpump, buffer, requested_length, 0, UX_TRACE_DEVICE_CLASS_EVENTS, 0, 0)
/* Get the pointer to the device. */
device = &_ux_system_slave->ux_system_slave_device;
/* As long as the device is in the CONFIGURED state. */
if(device->ux_slave_device_state != UX_DEVICE_CONFIGURED)
{
/* Error trap. */
_ux_system_error_handler(UX_SYSTEM_LEVEL_THREAD, UX_SYSTEM_CONTEXT_CLASS, UX_CONFIGURATION_HANDLE_UNKNOWN);
/* If trace is enabled, insert this event into the trace buffer. */
UX_TRACE_IN_LINE_INSERT(UX_TRACE_ERROR, UX_CONFIGURATION_HANDLE_UNKNOWN, device, 0, 0, UX_TRACE_ERRORS, 0, 0)
/* Cannot proceed with command, the interface is down. */
return (UX_CONFIGURATION_HANDLE_UNKNOWN);
}
/* Locate the OUT endpoint. */
endpoint = dpump->ux_slave_class_dpump_bulkout_endpoint;
/* Check endpoint. If NULL, we have not yet received the proper SET_INTERFACE command. */
if(endpoint == UX_NULL)
{
/* Error trap. */
_ux_system_error_handler(UX_SYSTEM_LEVEL_THREAD, UX_SYSTEM_CONTEXT_CLASS, UX_ENDPOINT_HANDLE_UNKNOWN);
return (UX_ENDPOINT_HANDLE_UNKNOWN);
}
/* All DP