14、USBH HOST对接RTT系统(CDC+MSC)

最新推荐文章于 2024-09-26 20:13:00 发布
最新推荐文章于 2024-09-26 20:13:00 发布
阅读量1.6k 收藏 5
点赞数 1
分类专栏： USB 文章标签： usb stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a986096115/article/details/122314446
版权
本文档详细介绍了如何将USBHHOST与RTT系统进行对接，以实现CDC（通用串行总线通信设备类）和MSC（存储设备类）设备的驱动。首先，介绍了CDC设备的驱动实现，包括接收和发送数据的流程，以及驱动文件的修改。接着，阐述了MSC设备驱动的实现思路，主要涉及设备的打开、关闭、读写和控制操作。通过这些步骤，开发者可以利用RTT标准接口进行CDC通信和对MSC设备进行文件读写。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

USBH HOST对接RTT

将USBH host注册到RTT中需要进行以下几步.

  1. 实现设备驱动
  2. 设备注册.

1.1 CDC设备实现

1.1.1 CDC类实现思路

官方驱动修改思路.

  1. 将CDC类中的状态机一直置为接收状态.
  2. 接收完成后，通过USBH_CDC_ReceiveCallback函数通知上层应用.

设备实现思路.

  1. 通过官方提供的接收回调函数将接收到的数据存放到ringbuf内，用户可通过rt_device_read接口调用usbh_cdc_class_read函数读取缓冲区内容.
  2. 发送时指定发送数据,直接发送指定数据(无缓冲区).如有需要，可将发送数据存入指定缓冲区，然后创建一个线程用于发送.

1.1.2 CDC类驱动文件修改

修改usbh_cdc.c文件中的CDC_ProcessReception函数为如下所示.

static void CDC_ProcessReception(USBH_HandleTypeDef *phost)
{

    CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef *) phost->pActiveClass->pData[USBH_CDC_INDEX];
    USBH_URBStateTypeDef URB_Status = USBH_URB_IDLE;
    switch(CDC_Handle->data_rx_state)
    {

    case CDC_RECEIVE_DATA:
        USBH_BulkReceiveData(phost,
                             CDC_Handle->pRxData,
                             CDC_Handle->DataItf.InEpSize,
                             CDC_Handle->DataItf.InPipe);

        CDC_Handle->data_rx_state = CDC_RECEIVE_DATA_WAIT;

        break;

    case CDC_RECEIVE_DATA_WAIT:

        URB_Status = USBH_LL_GetURBState(phost, CDC_Handle->DataItf.InPipe);

        /*Check the status done for reception*/
        if(URB_Status == USBH_URB_DONE)
        {
            USBH_CDC_ReceiveCallback(phost);
            CDC_Handle->data_rx_state = CDC_RECEIVE_DATA;
        }

        break;

    default:
        break;
    }
}

1.1.3 CDC类设备文件实现

实现usbh_cdc_device.h.

#ifndef __USBH_CDC_DEVICE__H__
#define __USBH_CDC_DEVICE__H__

#include "usbh_core.h"

#define USBH_CDC_NAME	"USBH_CDC"


#define CDC_RX_BUFSIZE 256


#define CDC_DEVICE_CMD_GET_SPCAE_LEN 	(0X0100)
#define CDC_DEVICE_CMD_GET_DATA_LEN		(0X0200)
#define CDC_DEVICE_CMD_BUF_RESET		(0X0400)
#define CDC_DEVICE_CMD_GET_DEV_STATE	(0X0800)
#define CDC_DEVICE_CMD_START_RECV		(0X1000)
#define CDC_DEVICE_CMD_MASK				(CDC_DEVICE_CMD_START_RECV | CDC_DEVICE_CMD_GET_SPCAE_LEN | CDC_DEVICE_CMD_GET_DATA_LEN | CDC_DEVICE_CMD_BUF_RESET)


struct rt_cdc_device
{
    struct rt_device device;

    struct rt_ringbuffer rx_ringbuffer;

    uint8_t *p_rx_buf;
};
typedef struct rt_cdc_device *rt_cdc_device_t;

rt_cdc_device_t cdc_device_creat(void);
#endif

实现usbh_cdc_device.c.

#include "usbh_cdc_device.h"
#include "usbh_cdc.h"

extern USBH_HandleTypeDef hUsbHostHS;

static rt_err_t usbh_cdc_class_open(rt_device_t dev, rt_uint16_t oflag);
static rt_err_t usbh_cdc_class_close(rt_device_t dev);
static rt_size_t usbh_cdc_class_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
static rt_size_t usbh_cdc_class_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
static rt_err_t usbh_cdc_class_control(rt_device_t dev, int cmd, void *args);

static rt_cdc_device_t  cdc_device_t = RT_NULL;
rt_cdc_device_t cdc_device_creat()
{
    rt_err_t result = RT_EOK;

    cdc_device_t = rt_malloc(sizeof(struct rt_cdc_device));

    if(cdc_device_t == NULL)
    {
        USBH_ErrLog("cdc device init failed");
        rt_free(cdc_device_t);
        return RT_NULL;
    }

    rt_memset(cdc_device_t, 0, sizeof(struct rt_cdc_device));

    cdc_device_t->device.parent.type = RT_Object_Class_Device;
    cdc_device_t->device.type = RT_Device_Class_Char;
    cdc_device_t->device.open = usbh_cdc_class_open;
    cdc_device_t->device.close = usbh_cdc_class_close;
    cdc_device_t->device.write = usbh_cdc_class_write;
    cdc_device_t->device.read = usbh_cdc_class_read;
    cdc_device_t->device.control = usbh_cdc_class_control;

    result = rt_device_register(&(cdc_device_t->device), USBH_CDC_NAME, RT_DEVICE_FLAG_RDWR);

    if(result != RT_EOK)
    {
        USBH_DbgLog("cdc device register failed");
        rt_free(cdc_device_t);
        return RT_NULL;
    }

    USBH_DbgLog("cdc device init ok");

    return cdc_device_t;
}

static rt_err_t usbh_cdc_class_open(rt_device_t dev, rt_uint16_t oflag)
{
    rt_cdc_device_t cdc_handler = (rt_cdc_device_t)dev;
    cdc_handler->p_rx_buf = rt_malloc(CDC_RX_BUFSIZE);

    if(cdc_handler->p_rx_buf == NULL)
    {
        return RT_ENOMEM;
    }

    USBH_memset(cdc_handler->p_rx_buf, 0, CDC_RX_BUFSIZE);
    rt_ringbuffer_init(&(cdc_handler->rx_ringbuffer), cdc_handler->p_rx_buf, CDC_RX_BUFSIZE);

	USBH_CDC_Receive(&hUsbHostHS, NULL, 128);

    return RT_EOK;
}
static rt_err_t usbh_cdc_class_close(rt_device_t dev)
{
    rt_cdc_device_t cdc_handler = (rt_cdc_device_t)dev;

    if(cdc_handler->p_rx_buf)
        rt_free(cdc_handler->p_rx_buf);

    cdc_handler->p_rx_buf = RT_NULL;

    rt_ringbuffer_reset(&cdc_handler->rx_ringbuffer);
	
	USBH_Stop(&hUsbHostHS);
    return RT_EOK;
}

static rt_size_t usbh_cdc_class_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    extern USBH_StatusTypeDef  USBH_CDC_Transmit(USBH_HandleTypeDef * phost, uint8_t * buf, uint32_t length);
	USBH_CDC_Stop(&hUsbHostHS);
    if(USBH_CDC_Transmit(&hUsbHostHS, (uint8_t *)buffer, size) == RT_EOK)
        return size;

    return 0;
}
void USBH_CDC_TransmitCallback(USBH_HandleTypeDef *phost)
{
	if(cdc_device_t)
		rt_device_control(&(cdc_device_t->device),CDC_DEVICE_CMD_START_RECV,NULL);
}
void USBH_CDC_ReceiveCallback(USBH_HandleTypeDef * phost)
{
    extern CDC_HandleTypeDef usbh_cdc_handler;
    uint32_t len = USBH_CDC_GetLastReceivedDataSize(phost);

    if(len)
    {
        rt_ringbuffer_put(&(cdc_device_t->rx_ringbuffer), usbh_cdc_handler.pRxData, len);

        cdc_device_t->device.rx_indicate((rt_device_t)cdc_device_t, len);
    }
}

static rt_size_t usbh_cdc_class_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
    rt_cdc_device_t cdc_handler = (rt_cdc_device_t)dev;

    if(rt_ringbuffer_get(&(cdc_handler->rx_ringbuffer), buffer, size) == size)
        return size;
    else
        return 0;
}

static rt_err_t usbh_cdc_class_control(rt_device_t dev, int cmd, void *args)
{
    extern CDC_HandleTypeDef usbh_cdc_handler;

    rt_cdc_device_t cdc_handler = (rt_cdc_device_t)dev;
    uint32_t *len = (uint32_t *)args;
    struct rt_ringbuffer *p_ringbuf = NULL;
    rt_err_t status = RT_EOK;
    p_ringbuf = &(cdc_handler->rx_ringbuffer);

    switch(cmd & 0XFF00)
    {
    case CDC_DEVICE_CMD_BUF_RESET:
        rt_ringbuffer_reset(p_ringbuf);
        break;

    case CDC_DEVICE_CMD_GET_SPCAE_LEN:
        *len = rt_ringbuffer_space_len(p_ringbuf);
        break;

    case CDC_DEVICE_CMD_GET_DATA_LEN:
        *len = rt_ringbuffer_data_len(p_ringbuf);
        break;

    case CDC_DEVICE_CMD_GET_DEV_STATE:
        break;

    case CDC_DEVICE_CMD_START_RECV:
        USBH_CDC_Stop(&hUsbHostHS);
        USBH_CDC_Receive(&hUsbHostHS, NULL, 64);
        USBH_DbgLog("start recv");
    default:
        status = RT_EINVAL;
        break;
    }

    return status;
}

2.1 MSC类设备驱动实现

2.1.1 MSC类设备实现思路

沿用ST官方例程，在此基础上模仿SPI_FLASH，SD卡的设备驱动即可.

2.1.2 MSC类设备实现

msc类不需要对底层驱动进行修改，专注于设备层功能实现即可.

添加usbh_msc_device.c文件如下所示.

#include "usbh_msc_device.h"
#include "usbh_msc.h"

extern USBH_HandleTypeDef hUsbHostHS;
#define USB_DEFAULT_BLOCK_SIZE 512

static struct rt_msc_device msc_device_handler;
static rt_err_t usbh_msc_class_init(rt_device_t dev);
static rt_err_t usbh_msc_class_close(rt_device_t dev);
static rt_size_t usbh_msc_class_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
static rt_size_t usbh_msc_class_read(rt_device_t dev, rt_off_t pos,  void *buffer, rt_size_t size);
static rt_err_t usbh_msc_class_control(rt_device_t dev, int cmd, void *args);
rt_msc_device_t msc_device_init()
{
    rt_err_t result = RT_EOK;

    rt_memset(&msc_device_handler, 0, sizeof(struct rt_msc_device));

    msc_device_handler.dev.init    = usbh_msc_class_init;
    msc_device_handler.dev.close   = usbh_msc_class_close;
    msc_device_handler.dev.write   = usbh_msc_class_write;
    msc_device_handler.dev.read    = usbh_msc_class_read;
    msc_device_handler.dev.control = usbh_msc_class_control;

    if(result != RT_EOK)
    {
        USBH_ErrLog("msc device sem failed");
    }

    result = rt_device_register(&(msc_device_handler.dev), USBH_MSC_NAME, RT_DEVICE_FLAG_RDWR);

    if(result != RT_EOK)
    {
        USBH_ErrLog("msc device register failed");
        return NULL;
    }

    return &msc_device_handler;
}

static rt_err_t usbh_msc_class_close(rt_device_t dev)
{
    return RT_EOK;
}

static rt_err_t usbh_msc_class_init(rt_device_t dev)
{
    return RT_EOK;
}
static rt_size_t usbh_msc_class_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    uint8_t lun;
    MSC_LUNTypeDef info;
    rt_err_t res = RT_ERROR;

    RT_ASSERT(dev != RT_NULL);
    RT_ASSERT(buffer != RT_NULL);

    lun = USBH_MSC_GetCurLUN(&hUsbHostHS);

//    rt_enter_critical();

    if(USBH_MSC_Write(&hUsbHostHS, lun, pos, (uint8_t *)buffer, size) == USBH_OK)
    {
        res = size;
    }
    else
    {
        USBH_MSC_GetLUNInfo(&hUsbHostHS, lun, &info);

        switch(info.sense.asc)
        {
        case SCSI_ASC_WRITE_PROTECTED:
            USBH_ErrLog("USB Disk is Write protected!");
            res = -RT_EBUSY;
            break;

        case SCSI_ASC_LOGICAL_UNIT_NOT_READY:
        case SCSI_ASC_MEDIUM_NOT_PRESENT:
        case SCSI_ASC_NOT_READY_TO_READY_CHANGE:
            USBH_ErrLog("USB Disk write is not ready!");
            res = -RT_EBUSY;
            break;

        default:
            res = -RT_ERROR;
            break;
        }
    }

//    rt_exit_critical();
    return res;
}
static rt_size_t usbh_msc_class_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
    uint8_t lun;
    MSC_LUNTypeDef info;
    rt_err_t res = RT_ERROR;

    RT_ASSERT(dev != RT_NULL);
    RT_ASSERT(buffer != RT_NULL);

    lun = USBH_MSC_GetCurLUN(&hUsbHostHS);

//    rt_enter_critical();

    if(USBH_MSC_Read(&hUsbHostHS, lun, pos, (uint8_t *)buffer, size) == USBH_OK)
    {
        res = size;
    }
    else
    {
        USBH_MSC_GetLUNInfo(&hUsbHostHS, lun, &info);

        switch(info.sense.asc)
        {
        case SCSI_ASC_LOGICAL_UNIT_NOT_READY:
        case SCSI_ASC_MEDIUM_NOT_PRESENT:
        case SCSI_ASC_NOT_READY_TO_READY_CHANGE:
            USBH_ErrLog("USB Disk read is not ready!");
            res = -RT_EBUSY;
            break;

        default:
            res = -RT_ERROR;
            break;
        }
    }

//    rt_exit_critical();
    return res;
}
static rt_err_t usbh_msc_class_control(rt_device_t dev, int cmd, void *args)
{
    uint8_t lun;
    MSC_LUNTypeDef info;
    rt_err_t res = RT_EOK;
    struct rt_device_blk_geometry *geometry = NULL;

    RT_ASSERT(dev != RT_NULL);

    lun = USBH_MSC_GetCurLUN(&hUsbHostHS);
    geometry = (struct rt_device_blk_geometry *) args;

    switch(cmd)
    {
        /* GET_SECTOR_COUNT  &  GET_SECTOR_SIZE & GET_BLOCK_SIZE*/
    case RT_DEVICE_CTRL_BLK_GETGEOME :
        if(USBH_MSC_GetLUNInfo(&hUsbHostHS, lun, &info) == USBH_OK)
        {
            geometry->sector_count = info.capacity.block_nbr;
            geometry->block_size = USB_DEFAULT_BLOCK_SIZE;
            geometry->bytes_per_sector = info.capacity.block_size;
        }
        else
        {
            res = RT_ERROR;
        }

        break;

        /* Get erase block size in unit of sector (DWORD) */
    case RT_DEVICE_CTRL_BLK_SYNC :
        break;

    case RT_DEVICE_CTRL_BLK_ERASE:

        break;

    default:
        res = RT_EINVAL;
    }

    return res;
}

添加usbh_msc_device.h文件如下所示.

#ifndef __USBh_MSC_DEVICE__H__
#define __USBh_MSC_DEVICE__H__
#include "usbh_core.h"

#define USBH_MSC_NAME	"USBH_MSC"
struct rt_msc_device
{
    struct rt_device 	 dev;
};
typedef struct rt_msc_device* rt_msc_device_t;
rt_msc_device_t msc_device_init(void);

#endif

至此，可通过RTT标准接口进行CDC通讯，及通过RTT文件系统标准接口对MSC从设备进行文件读写.

STM32 之四 标准外设版 USB 驱动 + MSC(Host) + Fatfs 移植
技术干货
01-01 2万+
写在前面 现在，网上关于STM32的USB的文章数不胜数。写这篇文章仅仅是对于自我学习的一个记录。主要是对实际学习中遇到的一些棘手问题做个备忘录。使用的芯片为STM32F407VG 。 目前，ST的USB驱动有两套，一套是早期的独立版USB驱动，最新版为2.2.0；一套为针对其Cube系列的驱动，根据芯片不同可能有区别，具体见对应芯片的Cube驱动包 。 本文使用的为独立版USB驱动。即：HA
STM32 USBH CDC开发及应用
loveliu928的博客
04-17 8744
USB，是英文 Universal Serial BUS （通用串行总线）的缩写，而其中文简称为通串线是一个外部总线标准，用于规范USB主机与外部设备的连接和通讯。由于项目需要，需要开发基于STM32USB主机（HOST）的CDC的开发，用于编队表演系统中底座跟无人机间的数据交互，同时usb提供了给无人机充电的功能。 在做usb主机（HOST）开发之前，我们需要先了解一个概念，USB设备（DEVI......
Cortex-M4 USB Host CDC驱动
02-11
TI cortex-M4 USB Host CDC驱动，含有USB lib库文件、USB驱动工程示例 TI cortex-M4 USB Host CDC驱动，含有USB lib库文件、USB驱动工程示例
STM32 USB HOST CDC 驱动CH340
09-18 1286
初始化CDC 接口.修改相应的类接口和 通讯端点，让USB HOST 枚举成功。接收数据可以通过回调 内的 UserCb.Receive(）读取数据。通过调用往USB cdc设备发送数据。
STM32 USB HOST CDC 驱动CH340串口
k1542308627的博客
07-11 1万+
本文主要讲述的是在STM32F407VE板子上通过STMCube生成的USB HOST CDC 程序驱动CH340进行数据传输。 创作背景： 打算用RT1052开发一个项目，由于项目中用到的传感器比较多，像雷达，ublox等需要通过UART进行通讯，基本分配之后占用了8个串口。而RT1052只有8个串口，没有预留串口也没有调试串口，考虑到RT1052有两路USB-OTG而且内置高速PHY,打算一路用作USB-PC接口做U盘用，一路通过USB-HOST扩展接口，其中包括USB-UART，初...
AT32 WorkBench常用功能15—USB Device Printer
08-15 293
注意：对于USB_OTGFS来说，步骤相似，但可以不开启12M高速外部时钟，且输入到OTGFS控制器的时钟必须是48MHz。若选择hick to usbfs则可以解锁外设AAC功能，可以在AT32 WorkBench时钟配置界面进行确认。AT32 WorkBench常用功能15—USB Device Printer。本文主要介绍如何基于AT32 WorkBench配置USB打印机。USB Printer工程建立。
USB Host 驱动CDC设备超详细资料-原创
08-11
USB Host驱动 CDC（Communications Device Class）设备是嵌入式系统中实现与串口设备通信的一种常见方式。本文档详细介绍了USB Host驱动CDC设备的原理、框架、协议、波形分析以及实验平台，旨在帮助学习者理解如何使...
STM32F407-USBH-FS-CDC与广和通4G模块USB通信，USB基础知识与驱动移植说明
09-03
STM32F407-USBH-FS-CDC与广和通4G模块USB通信，USB基础知识与驱动移植说明 随着物联网技术的迅速发展，越来越多的嵌入式设备需要通过无线网络与外部世界进行数据交换。STM32F407微控制器因其高性能和丰富的外设接口...
STM32_USB_HOST_MSC
04-23
STM32_USB_HOST_MSC是基于STM32微控制器的USB主机存储类（Mass Storage Class, MSC）的应用实例。这个库允许STM32设备作为USB主机来与外部USB存储设备，如U盘或硬盘，进行数据交换。在本文中，我们将深入探讨STM32 ...
usb.rar usb host cdc 调试 ch340
09-11
我调试用的工程
USB协议以及USB HOST MSC类通信过程
09-26
该文章主要是讲解了USB协议的基础知识，包括域、包、事务、传输。USB HOST MSC类的通信过程，以及FAT32的基本知识。
GD32F4xx USB cdc host驱动demo
03-29
标题中的“GD32F4xx USB CDC Host驱动demo”是指基于GD32F4系列微控制器（MCU）的USB设备类（CDC）主机驱动程序的示例代码。GD32F4xx系列是由GD Microsystems推出的高性能 Arm Cortex-M4 内核的单片机，具有高速浮点...
TI Cortex-M4 USB Host CDC 驱动详解及源代码
xhoufei2010的专栏
06-01 8546
1、 USB CDC介绍         USB的CDC类是USB通信设备类（Communication Device Class）的简称。CDC类是USB组织定义的一类专门给各种通信设备（电信通信设备和中速网络通信设备）使用的USB子类。         USB CDC具备两个类接口：通信接口类（Communication Interface Class）和数据接口类(Data Inte
STM32F407标准库作USB Host CDC 与广和通 mc665 AT通信
weixin_51077191的博客
03-11 2264
STM32f4移植官方USB Host CDC驱动，标准库
使用stm32cubemx的usb-host-cdc库驱动EC20模块
热门推荐
gyzw_mx的博客
12-19 1万+
使用stm32cubemx的usb-host-cdc库驱动EC20模块开发环境：实现功能：开始1、使用STM32CubeMX配置工程，生成基础代码2、修改cubemx生成的代码3、 编译下载运行，成功发送at并接收到at指令回复。总结 开发环境： 开发板：正点原子F407探索者 代码生成工具：STM32CubeMX v5.4.0 IDE: eclipse + ac6工具链 实现功能： 单片...
【学习记录】RTthread U盘（usb host）华大HC32F46
Kevin_ZXW的博客
02-05 863
在弄这个U盘挂载，花了我好多时间，一直借鉴别人的例子做，移植都不成功，最终发现最新的BSP版本有drv_usbh.c这个关键性驱动文件，直接搬过来移植。
深入探索USB Host驱动CDC设备：一份超详细的原创资料
最新发布
gitblog_06612的博客
09-26 1117
深入探索USB Host驱动CDC设备：一份超详细的原创资料 【下载地址】USBHost驱动CDC设备超详细资料-原创 本资料为原创内容，详细介绍了USB Host驱动CDC设备的相关知识。从USB驱动CDC设备的原理、框架、具体协议、分析波形，到实验平台和实验条件等方面进行了全面而深入的描述。经过近一个月的梳理和学习整...
7、STM32HAL_USB_DEVICE库概述
a986096115的博客
08-30 3911
1、USB库简介 环境： CUBEMX 5.6.1 STM32Cube MCU Package for STM32F1 Series 1.8.0 STM32F1xx HAL Driver version number V1.1.4 STM32官方提供了两套USB的库，一套用于HOST，一套用于DEVICE，且提供了一些参考资料，如下. UM1720用户手册(HOST) UM1734用户手册(DEVICE) 在这里，我只使用了DEVICE，所以笔记也只有DEVICE库的一些个人理解. 2、
uC-USBH：嵌入式系统高效USB主机堆栈解决方案
资源摘要信息:"uC-USBH是一款专为嵌入式系统设计的高效USB主机堆栈软件，适用于具备USB主机或OTG(On-The-Go)功能的微控制器。该堆栈实现了USB通信协议的主机端，并包含了多个特定类的驱动程序，如大容量存储类(MSC)...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值