沁恒CH583 USB 自定义HID调试记录

最新推荐文章于 2024-03-25 09:45:17 发布
最新推荐文章于 2024-03-25 09:45:17 发布
阅读量3k 收藏 16
点赞数
分类专栏： usb 文章标签： iot 物联网 mcu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hydfxy2018/article/details/125407286
版权

使用USB HID主要是为了免驱，通过自定义USB HID可以利用USB口来做很多事，比如串口打印，串口升级都可以通过usb口来实现，这样可以省去一个USB转串口器件同时也不用装驱动，如下实现可以通过usb hid进行自定义收发，类似串口自定义收发。

如下代码基本都是基于沁恒EVT改造而来，

GitHub - iot-lorawan/ch58x_usbhid_custom: custom usb hid in ch58x

usb配置相关，该配置声明了使用usb 自定义hid，

#include "CH58x_common.h"
#define RepDataLoadLen          64

#define DevEP0SIZE    0x40
// 设备描述符
/* Device Descriptor */
const UINT8  MyDevDescr[] =
{
    0x12, 0x01, 0x10, 0x01, 0x00, 0x00, 0x00, DevEP0SIZE,
    0x86, 0x1A, 0xE1, 0xE6,
    0x00, 0x01, 0x01, 0x02, 0x00, 0x01,
};

/* USB配置描述符(全速) */
UINT8  MyCfgDescr[ ] =
{
    0x09,0x02,0x29,0x00,0x01,0x01,0x04,0xA0,0x23,               //配置描述符
    0x09,0x04,0x00,0x00,0x02,0x03,0x00,0x00,0x05,               //接口描述符
    0x09,0x21,0x00,0x01,0x00,0x01,0x22,0x22,0x00,               //HID类描述符
    0x07,0x05,0x81,0x03,0x40,0x00,0x01,                         //端点描述符(全速间隔时间改成1ms)
    0x07,0x05,0x01,0x03,0x40,0x00,0x01,                         //端点描述符
};

/* USB报告描述符 */
const UINT8  CompatibilityHIDRepDesc[ ] =
{
        0x06, 0x00,0xff,
        0x09, 0x01,
        0xa1, 0x01,                                                   //集合开始
        0x09, 0x02,                                                   //Usage Page  用法
        0x15, 0x00,                                                   //Logical  Minimun
        0x26, 0x00,0xff,                                              //Logical  Maximun
        0x75, 0x08,                                                   //Report Size
        0x95, RepDataLoadLen,                                         //Report Counet
        0x81, 0x06,                                                   //Input
        0x09, 0x02,                                                   //Usage Page  用法
        0x15, 0x00,                                                   //Logical  Minimun
        0x26, 0x00,0xff,                                              //Logical  Maximun
        0x75, 0x08,                                                   //Report Size
        0x95, RepDataLoadLen,                                         //Report Counet
        0x91, 0x06,                                                   //Output
        0xC0
};

/* Language Descriptor */
const UINT8  MyLangDescr[] =
{
    0x04, 0x03, 0x09, 0x04
};

/* Manufactor Descriptor */
const UINT8  MyManuInfo[] =
{
    0x0E, 0x03, 'w', 0, 'c', 0, 'h', 0, '.', 0, 'c', 0, 'n', 0
};

/* Product Information */
const UINT8  MyProdInfo[] =
{
    0x0C, 0x03, 'C', 0, 'H', 0, '1', 0, '0', 0, 'x', 0
};

/* USB序列号字符串描述符 */
const UINT8  MySerNumInfo[ ] =
{
    /* 0123456789 */
    22,03,48,0,49,0,50,0,51,0,52,0,53,0,54,0,55,0,56,0,57,0
};

/* USB设备限定描述符 */
const UINT8 MyUSBQUADesc[ ] =
{
    0x0A, 0x06, 0x00, 0x02, 0xFF, 0x00, 0xFF, 0x40, 0x01, 0x00,
};


/**********************************************************/
uint8_t        DevConfig, Ready;
uint8_t        SetupReqCode;
uint16_t       SetupReqLen;
const uint8_t *pDescr;
uint8_t        Report_Value = 0x00;
uint8_t        Idle_Value = 0x00;
uint8_t        USB_SleepStatus = 0x00; /* USB睡眠状态 */

/*鼠标键盘数据*/
uint8_t HIDMouse[4] = {0x0, 0x0, 0x0, 0x0};
uint8_t HIDKey[8] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
/******** 用户自定义分配端点RAM ****************************************/
__attribute__((aligned(4))) uint8_t EP0_Databuf[64 + 64 + 64]; //ep0(64)+ep4_out(64)+ep4_in(64)
__attribute__((aligned(4))) uint8_t EP1_Databuf[64 + 64];      //ep1_out(64)+ep1_in(64)
__attribute__((aligned(4))) uint8_t EP2_Databuf[64 + 64];      //ep2_out(64)+ep2_in(64)
__attribute__((aligned(4))) uint8_t EP3_Databuf[64 + 64];      //ep3_out(64)+ep3_in(64)

USB逻辑交互，放在usb中断函数里执行

void USB_DevTransProcess(void)
{
    uint8_t len, chtype;
    uint8_t intflag, errflag = 0;

    intflag = R8_USB_INT_FG;
    if(intflag & RB_UIF_TRANSFER)
    {
        if((R8_USB_INT_ST & MASK_UIS_TOKEN) != MASK_UIS_TOKEN) // 非空闲
        {
            switch(R8_USB_INT_ST & (MASK_UIS_TOKEN | MASK_UIS_ENDP))
            // 分析操作令牌和端点号
            {
                case UIS_TOKEN_IN:
                {
                    switch(SetupReqCode)
                    {
                        case USB_GET_DESCRIPTOR:
                            len = SetupReqLen >= DevEP0SIZE ? DevEP0SIZE : SetupReqLen; // 本次传输长度
                            memcpy(pEP0_DataBuf, pDescr, len);                          /* 加载上传数据 */
                            SetupReqLen -= len;
                            pDescr += len;
                            R8_UEP0_T_LEN = len;
                            R8_UEP0_CTRL ^= RB_UEP_T_TOG; // 翻转
                            break;
                        case USB_SET_ADDRESS:
                            R8_USB_DEV_AD = (R8_USB_DEV_AD & RB_UDA_GP_BIT) | SetupReqLen;
                            R8_UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
                            break;

                        case USB_SET_FEATURE:
                            break;

                        default:
                            R8_UEP0_T_LEN = 0; // 状态阶段完成中断或者是强制上传0长度数据包结束控制传输
                            R8_UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
                            break;
                    }
                }
                break;

                case UIS_TOKEN_OUT:
                {
                    len = R8_USB_RX_LEN;
                    if(SetupReqCode == 0x09)
                    {
                        if(pEP0_DataBuf[0])
                            PRINT("Light on Num Lock LED!\n");
                        else if(pEP0_DataBuf[0] == 0)
                            PRINT("Light off Num Lock LED!\n");
                    }
                }
                break;

                case UIS_TOKEN_OUT | 1:
                {
                    if(R8_USB_INT_ST & RB_UIS_TOG_OK)
                    { // 不同步的数据包将丢弃
                        R8_UEP1_CTRL ^= RB_UEP_R_TOG;
                        len = R8_USB_RX_LEN;
                        DevEP1_OUT_Deal(len);
                    }
                }
                break;

                case UIS_TOKEN_IN | 1:
                    R8_UEP1_CTRL ^= RB_UEP_T_TOG;
                    R8_UEP1_CTRL = (R8_UEP1_CTRL & ~MASK_UEP_T_RES) | UEP_T_RES_NAK;
                    break;

                case UIS_TOKEN_OUT | 2:
                {
                    if(R8_USB_INT_ST & RB_UIS_TOG_OK)
                    { // 不同步的数据包将丢弃
                        R8_UEP2_CTRL ^= RB_UEP_R_TOG;
                        len = R8_USB_RX_LEN;
                        DevEP2_OUT_Deal(len);
                    }
                }
                break;

                case UIS_TOKEN_IN | 2:
                    R8_UEP2_CTRL ^= RB_UEP_T_TOG;
                    R8_UEP2_CTRL = (R8_UEP2_CTRL & ~MASK_UEP_T_RES) | UEP_T_RES_NAK;
                    break;

                case UIS_TOKEN_OUT | 3:
                {
                    if(R8_USB_INT_ST & RB_UIS_TOG_OK)
                    { // 不同步的数据包将丢弃
                        R8_UEP3_CTRL ^= RB_UEP_R_TOG;
                        len = R8_USB_RX_LEN;
                        DevEP3_OUT_Deal(len);
                    }
                }
                break;

                case UIS_TOKEN_IN | 3:
                    R8_UEP3_CTRL ^= RB_UEP_T_TOG;
                    R8_UEP3_CTRL = (R8_UEP3_CTRL & ~MASK_UEP_T_RES) | UEP_T_RES_NAK;
                    break;

                case UIS_TOKEN_OUT | 4:
                {
                    if(R8_USB_INT_ST & RB_UIS_TOG_OK)
                    {
                        R8_UEP4_CTRL ^= RB_UEP_R_TOG;
                        len = R8_USB_RX_LEN;
                        DevEP4_OUT_Deal(len);
                    }
                }
                break;

                case UIS_TOKEN_IN | 4:
                    R8_UEP4_CTRL ^= RB_UEP_T_TOG;
                    R8_UEP4_CTRL = (R8_UEP4_CTRL & ~MASK_UEP_T_RES) | UEP_T_RES_NAK;
                    break;

                default:
                    break;
            }
            R8_USB_INT_FG = RB_UIF_TRANSFER;
        }
        if(R8_USB_INT_ST & RB_UIS_SETUP_ACT) // Setup包处理
        {
            R8_UEP0_CTRL = RB_UEP_R_TOG | RB_UEP_T_TOG | UEP_R_RES_ACK | UEP_T_RES_NAK;
            SetupReqLen = pSetupReqPak->wLength;
            SetupReqCode = pSetupReqPak->bRequest;
            chtype = pSetupReqPak->bRequestType;

            len = 0;
            errflag = 0;
            if((pSetupReqPak->bRequestType & USB_REQ_TYP_MASK) != USB_REQ_TYP_STANDARD)
            {
                /* 非标准请求 */
                /* 其它请求,如类请求，产商请求等 */
                if(pSetupReqPak->bRequestType & 0x40)
                {
                    /* 厂商请求 */
                }
                else if(pSetupReqPak->bRequestType & 0x20)
                {
                    switch(SetupReqCode)
                    {
                        case DEF_USB_SET_IDLE: /* 0x0A: SET_IDLE */
                            Idle_Value = EP0_Databuf[3];
                            break; //这个一定要有

                        case DEF_USB_SET_REPORT: /* 0x09: SET_REPORT */
                            break;

                        case DEF_USB_SET_PROTOCOL: /* 0x0B: SET_PROTOCOL */
                            Report_Value = EP0_Databuf[2];
                            break;

                        case DEF_USB_GET_IDLE: /* 0x02: GET_IDLE */
                            EP0_Databuf[0] = Idle_Value;
                            len = 1;
                            break;

                        case DEF_USB_GET_PROTOCOL: /* 0x03: GET_PROTOCOL */
                            EP0_Databuf[0] = Report_Value;
                            len = 1;
                            break;

                        default:
                            errflag = 0xFF;
                    }
                }
            }
            else /* 标准请求 */
            {
                switch(SetupReqCode)
                {
                    case USB_GET_DESCRIPTOR:
                    {
                        switch(((pSetupReqPak->wValue) >> 8))
                        {
                                case USB_DESCR_TYP_DEVICE:
                                    /* 获取设备描述符 */
                                    pDescr = MyDevDescr;
                                    len = MyDevDescr[0];
                                    break;

                                case USB_DESCR_TYP_CONFIG:
                                    /* 获取配置描述符 */
                                    pDescr = MyCfgDescr;
                                    len = sizeof( MyCfgDescr );

                                    break;

                                case USB_DESCR_TYP_STRING:
                                    /* 获取字符串描述符 */
                                    switch( (pSetupReqPak->wValue)&0xff )
                                    {
                                        case 0:
                                            /* 语言字符串描述符 */
                                        pDescr = MyLangDescr;
                                        len = MyLangDescr[0];
                                            break;

                                        case 1:
                                            /* USB产商字符串描述符 */
                                            pDescr = MyManuInfo;
                                            len = MyManuInfo[0];
                                            break;

                                        case 2:
                                            /* USB产品字符串描述符 */
                                            pDescr = MyProdInfo;
                                            len = MyProdInfo[0];
                                            break;

                                        case 3:
                                            /* USB序列号字符串描述符 */
                                            pDescr = MySerNumInfo;
                                            len = sizeof( MySerNumInfo );
                                            break;

                                        default:
                                            errflag = 0xFF;
                                            break;
                                    }
                                    break;

                                case USB_DESCR_TYP_REPORT:
                                    /* USB设备报告描述符 */
                                    pDescr = CompatibilityHIDRepDesc;
                                    len = sizeof( CompatibilityHIDRepDesc );
                                    break;

                                case USB_DESCR_TYP_QUALIF:
                                    /* 设备限定描述符 */
                                    pDescr = ( PUINT8 )&MyUSBQUADesc[ 0 ];
                                    len = sizeof( MyUSBQUADesc );
                                    break;

                                case USB_DESCR_TYP_SPEED:
                                    /* 其他速度配置描述符 */
                                    errflag = 0xFF;
                                    break;

                               

                                default :
                                    errflag = 0xff;
                                    break;

                            }
                        if(SetupReqLen > len)
                            SetupReqLen = len; //实际需上传总长度
                        len = (SetupReqLen >= DevEP0SIZE) ? DevEP0SIZE : SetupReqLen;
                        memcpy(pEP0_DataBuf, pDescr, len);
                        pDescr += len;
                    }
                    break;

                    case USB_SET_ADDRESS:
                        SetupReqLen = (pSetupReqPak->wValue) & 0xff;
                        break;

                    case USB_GET_CONFIGURATION:
                        pEP0_DataBuf[0] = DevConfig;
                        if(SetupReqLen > 1)
                            SetupReqLen = 1;
                        break;

                    case USB_SET_CONFIGURATION:
                        DevConfig = (pSetupReqPak->wValue) & 0xff;
                        break;

                    case USB_CLEAR_FEATURE:
                    {
                        if((pSetupReqPak->bRequestType & USB_REQ_RECIP_MASK) == USB_REQ_RECIP_ENDP) // 端点
                        {
                            switch((pSetupReqPak->wIndex) & 0xff)
                            {
                                case 0x83:
                                    R8_UEP3_CTRL = (R8_UEP3_CTRL & ~(RB_UEP_T_TOG | MASK_UEP_T_RES)) | UEP_T_RES_NAK;
                                    break;
                                case 0x03:
                                    R8_UEP3_CTRL = (R8_UEP3_CTRL & ~(RB_UEP_R_TOG | MASK_UEP_R_RES)) | UEP_R_RES_ACK;
                                    break;
                                case 0x82:
                                    R8_UEP2_CTRL = (R8_UEP2_CTRL & ~(RB_UEP_T_TOG | MASK_UEP_T_RES)) | UEP_T_RES_NAK;
                                    break;
                                case 0x02:
                                    R8_UEP2_CTRL = (R8_UEP2_CTRL & ~(RB_UEP_R_TOG | MASK_UEP_R_RES)) | UEP_R_RES_ACK;
                                    break;
                                case 0x81:
                                    R8_UEP1_CTRL = (R8_UEP1_CTRL & ~(RB_UEP_T_TOG | MASK_UEP_T_RES)) | UEP_T_RES_NAK;
                                    break;
                                case 0x01:
                                    R8_UEP1_CTRL = (R8_UEP1_CTRL & ~(RB_UEP_R_TOG | MASK_UEP_R_RES)) | UEP_R_RES_ACK;
                                    break;
                                default:
                                    errflag = 0xFF; // 不支持的端点
                                    break;
                            }
                        }
                        else if((pSetupReqPak->bRequestType & USB_REQ_RECIP_MASK) == USB_REQ_RECIP_DEVICE)
                        {
                            if(pSetupReqPak->wValue == 1)
                            {
                                USB_SleepStatus &= ~0x01;
                            }
                        }
                        else
                        {
                            errflag = 0xFF;
                        }
                    }
                    break;

                    case USB_SET_FEATURE:
                        if((pSetupReqPak->bRequestType & USB_REQ_RECIP_MASK) == USB_REQ_RECIP_ENDP)
                        {
                            /* 端点 */
                            switch(pSetupReqPak->wIndex)
                            {
                                case 0x83:
                                    R8_UEP3_CTRL = (R8_UEP3_CTRL & ~(RB_UEP_T_TOG | MASK_UEP_T_RES)) | UEP_T_RES_STALL;
                                    break;
                                case 0x03:
                                    R8_UEP3_CTRL = (R8_UEP3_CTRL & ~(RB_UEP_R_TOG | MASK_UEP_R_RES)) | UEP_R_RES_STALL;
                                    break;
                                case 0x82:
                                    R8_UEP2_CTRL = (R8_UEP2_CTRL & ~(RB_UEP_T_TOG | MASK_UEP_T_RES)) | UEP_T_RES_STALL;
                                    break;
                                case 0x02:
                                    R8_UEP2_CTRL = (R8_UEP2_CTRL & ~(RB_UEP_R_TOG | MASK_UEP_R_RES)) | UEP_R_RES_STALL;
                                    break;
                                case 0x81:
                                    R8_UEP1_CTRL = (R8_UEP1_CTRL & ~(RB_UEP_T_TOG | MASK_UEP_T_RES)) | UEP_T_RES_STALL;
                                    break;
                                case 0x01:
                                    R8_UEP1_CTRL = (R8_UEP1_CTRL & ~(RB_UEP_R_TOG | MASK_UEP_R_RES)) | UEP_R_RES_STALL;
                                    break;
                                default:
                                    /* 不支持的端点 */
                                    errflag = 0xFF; // 不支持的端点
                                    break;
                            }
                        }
                        else if((pSetupReqPak->bRequestType & USB_REQ_RECIP_MASK) == USB_REQ_RECIP_DEVICE)
                        {
                            if(pSetupReqPak->wValue == 1)
                            {
                                /* 设置睡眠 */
                                USB_SleepStatus |= 0x01;
                            }
                        }
                        else
                        {
                            errflag = 0xFF;
                        }
                        break;

                    case USB_GET_INTERFACE:
                        pEP0_DataBuf[0] = 0x00;
                        if(SetupReqLen > 1)
                            SetupReqLen = 1;
                        break;

                    case USB_SET_INTERFACE:
                        break;

                    case USB_GET_STATUS:
                        if((pSetupReqPak->bRequestType & USB_REQ_RECIP_MASK) == USB_REQ_RECIP_ENDP)
                        {
                            /* 端点 */
                            pEP0_DataBuf[0] = 0x00;
                            switch(pSetupReqPak->wIndex)
                            {
                                case 0x83:
                                    if((R8_UEP3_CTRL & (RB_UEP_T_TOG | MASK_UEP_T_RES)) == UEP_T_RES_STALL)
                                    {
                                        pEP0_DataBuf[0] = 0x01;
                                    }
                                    break;

                                case 0x03:
                                    if((R8_UEP3_CTRL & (RB_UEP_R_TOG | MASK_UEP_R_RES)) == UEP_R_RES_STALL)
                                    {
                                        pEP0_DataBuf[0] = 0x01;
                                    }
                                    break;

                                case 0x82:
                                    if((R8_UEP2_CTRL & (RB_UEP_T_TOG | MASK_UEP_T_RES)) == UEP_T_RES_STALL)
                                    {
                                        pEP0_DataBuf[0] = 0x01;
                                    }
                                    break;

                                case 0x02:
                                    if((R8_UEP2_CTRL & (RB_UEP_R_TOG | MASK_UEP_R_RES)) == UEP_R_RES_STALL)
                                    {
                                        pEP0_DataBuf[0] = 0x01;
                                    }
                                    break;

                                case 0x81:
                                    if((R8_UEP1_CTRL & (RB_UEP_T_TOG | MASK_UEP_T_RES)) == UEP_T_RES_STALL)
                                    {
                                        pEP0_DataBuf[0] = 0x01;
                                    }
                                    break;

                                case 0x01:
                                    if((R8_UEP1_CTRL & (RB_UEP_R_TOG | MASK_UEP_R_RES)) == UEP_R_RES_STALL)
                                    {
                                        pEP0_DataBuf[0] = 0x01;
                                    }
                                    break;
                            }
                        }
                        else if((pSetupReqPak->bRequestType & USB_REQ_RECIP_MASK) == USB_REQ_RECIP_DEVICE)
                        {
                            pEP0_DataBuf[0] = 0x00;
                            if(USB_SleepStatus)
                            {
                                pEP0_DataBuf[0] = 0x02;
                            }
                            else
                            {
                                pEP0_DataBuf[0] = 0x00;
                            }
                        }
                        pEP0_DataBuf[1] = 0;
                        if(SetupReqLen >= 2)
                        {
                            SetupReqLen = 2;
                        }
                        break;

                    default:
                        errflag = 0xff;
                        break;
                }
            }
            if(errflag == 0xff) // 错误或不支持
            {
                //                  SetupReqCode = 0xFF;
                R8_UEP0_CTRL = RB_UEP_R_TOG | RB_UEP_T_TOG | UEP_R_RES_STALL | UEP_T_RES_STALL; // STALL
            }
            else
            {
                if(chtype & 0x80) // 上传
                {
                    len = (SetupReqLen > DevEP0SIZE) ? DevEP0SIZE : SetupReqLen;
                    SetupReqLen -= len;
                }
                else
                    len = 0; // 下传
                R8_UEP0_T_LEN = len;
                R8_UEP0_CTRL = RB_UEP_R_TOG | RB_UEP_T_TOG | UEP_R_RES_ACK | UEP_T_RES_ACK; // 默认数据包是DATA1
            }

            R8_USB_INT_FG = RB_UIF_TRANSFER;
        }
    }
    else if(intflag & RB_UIF_BUS_RST)
    {
        R8_USB_DEV_AD = 0;
        R8_UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
        R8_UEP1_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
        R8_UEP2_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
        R8_UEP3_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
        R8_USB_INT_FG = RB_UIF_BUS_RST;
    }
    else if(intflag & RB_UIF_SUSPEND)
    {
        if(R8_USB_MIS_ST & RB_UMS_SUSPEND)
        {
            ;
        } // 挂起
        else
        {
            ;
        } // 唤醒
        R8_USB_INT_FG = RB_UIF_SUSPEND;
    }
    else
    {
        R8_USB_INT_FG = intflag;
    }
}


__INTERRUPT
__HIGH_CODE
void USB_IRQHandler(void) /* USB中断服务程序,使用寄存器组1 */
{
    USB_DevTransProcess();
}

USB端点收发部分接口，IN OUT都是从host端即电脑端而言

/*********************************************************************
 * @fn      DevEP1_OUT_Deal
 *
 * @brief   端点1数据处理
 *
 * @return  none
 */
void DevEP1_OUT_Deal(uint8_t l)
{ /* 用户可自定义 */
    uint8_t i;

    for(i = 0; i < l; i++)
    {
        pEP1_IN_DataBuf[i] = pEP1_OUT_DataBuf[i];
    }
    DevEP1_IN_Deal(l);
	
    PRINT("DevEP1_OUT_Deal:%d\r\n",l);
}

/*********************************************************************
 * @fn      DevEP2_OUT_Deal
 *
 * @brief   端点2数据处理
 *
 * @return  none
 */
void DevEP2_OUT_Deal(uint8_t l)
{ /* 用户可自定义 */
    uint8_t i;
    PRINT("DevEP2_OUT_Deal:%d\r\n",l);

    for(i = 0; i < l; i++)
    {
        pEP2_IN_DataBuf[i] = pEP2_OUT_DataBuf[i];
    }
    DevEP2_IN_Deal(l);
}

/*********************************************************************
 * @fn      DevEP3_OUT_Deal
 *
 * @brief   端点3数据处理
 *
 * @return  none
 */
void DevEP3_OUT_Deal(uint8_t l)
{ /* 用户可自定义 */
    uint8_t i;
    PRINT("DevEP3_OUT_Deal:%d\r\n",l);

    for(i = 0; i < l; i++)
    {
        pEP3_IN_DataBuf[i] = pEP3_OUT_DataBuf[i];
    }
    DevEP3_IN_Deal(l);
}

/*********************************************************************
 * @fn      DevEP4_OUT_Deal
 *
 * @brief   端点4数据处理
 *
 * @return  none
 */
void DevEP4_OUT_Deal(uint8_t l)
{ /* 用户可自定义 */
    uint8_t i;
    PRINT("DevEP4_OUT_Deal:%d\r\n",l);

    for(i = 0; i < l; i++)
    {
        pEP4_IN_DataBuf[i] = pEP4_OUT_DataBuf[i];
    }
    DevEP4_IN_Deal(l);
}

主函数：

int main()
{
    SetSysClock(CLK_SOURCE_PLL_60MHz);

    DebugInit();
    PRINT("start\n");

    pEP0_RAM_Addr = EP0_Databuf;
    pEP1_RAM_Addr = EP1_Databuf;
    pEP2_RAM_Addr = EP2_Databuf;
    pEP3_RAM_Addr = EP3_Databuf;

    USB_DeviceInit();

    PFIC_EnableIRQ(USB_IRQn);

    while(1)
    {
      mDelaymS(100);

	  #if 0
	  uint8_t i;
	  for(i = 0; i < 64; i++)
	  {
		  pEP1_IN_DataBuf[i] = 0x30+i;
	  }
	  DevEP1_IN_Deal(64);
	  #endif
	  

    }
}

使用usb hid收发助手调试

iot-lorawan
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Usb 通信调试软件（HID）.exe
03-05
usb hid通信测试工具
USB调试助手功能完善
donghailin的专栏
09-14 5403
对USB(HID) 调试助手进行了完善，增加了hid设备插入和拔出后自动检测功能（自用检测新插入到系统中的hid设备并自动添加VID和PID）还增加了RECV域的自动到文档尾的功能。程序已经上传到网络，地址是：https://download.csdn.net/download/donghailin/11965800 ...
HID-USB调试工具大全
最新发布
T76230169的专栏
03-25 639
HID类是USB的一个分支，除过其HID规范这个类文档外，还有一大堆的关于报告描述符的PDF规范。另外，对于自定义的HID设备，其通讯在市面上有很多的接口，用用HID.dll(微软源生态的）的，也有用开源github的HIDAPI的。这些资料USB中文网也整理了一些相关，不过这些都是关于自定义HID通讯的。自定义HID应用程序开发（Windows） - USB中文网USB中文网致力于USB技术的传播与技术开发，这里也做了一些资料上的准备。
USB HID测试工具(C#) USB HID测试工具(C#)
05-07
USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB HID测试工具(C#)USB H
USB(HID)调试助手(V1.4)
12-01
1.4版增加了USB（HID）设备报告描述符查询功能，向HID设备发送的数据字节之间允许出现空格并对数据合法性进行检查，修改了一些BUG。
usb hid 2.1调试工具
08-16
可以对自定义的usb hid类设备进行调试测试，可以收发数据， set report set feature get report 等都可以实现。方便好用。
全新高速HID调试工具
10-26
全新高速 HID 调试工具，程序袁USB开发利器 支持一下特性： *支持高速USB *自适应HID报告长度 *自动定时发送 *内置CRC小工具 *自定义显示
分享一个超强的HID调试助手
热门推荐
drinow的博客
05-26 1万+
HID调试助手、网络调试助手介绍
QT HID调试助手
odsdadada的博客
06-10 969
QT HID调试助手
usb hid调试助手_「正点原子NANO STM32F103开发板资料连载 第32章 USB 读卡器实验
weixin_39771775的博客
11-29 1190
1)实验平台：【正点原子】 NANO STM32F103 开发板2)摘自《正点原子STM32 F1 开发指南(NANO 板-HAL 库版)》关注官方微信号公众号，获取更多资料：正点原子第三十二章 USB 读卡器实验上一章我们向大家介绍了如何利用 STM32 的 USB 来做一个 USB 虚拟串口，本章我们将利用 STM32 的 USB 来做一个 USB 读卡器。本章分为如下几个部分：32.1 US...
USB 之枚举过程概述
EmbeddedOsprey
09-20 4621
来源：公众号【鱼鹰谈单片机】作者：鱼鹰OspreyID ：emOsprey上篇笔记我们大概了解了一下 USB 设备插入主机后经历了什么阶段，本篇笔记和接下来的笔记将详细介绍整个流程。...
HID调试助手-使用方便 软件小巧
01-03
USB HID 开发调试助手，使用方便 软件小巧 使你在硬件调节USB通讯时事半功倍。
HID调试助手win10可用
11-02
USB HID 开发调试助手，win10下可用，本人系统win10 64位亲测，使用方便 软件小巧 使你在硬件调节USB通讯时事半功倍。
USB HID 调试助手 及 程序源码
12-15
USB HID 调试助手 及 程序源码； 自定义 HID 设备VID PID
HID报告发送接收测试助手
10-19
自己写的HID报告发送接收测试工具。 根据VID、PID连接指定的自定义HID设备。 点击按键可发送报告，异步自动接收HID的输入报告。
南京沁恒CH32单片机模拟HID设备
09-07
本程序基于CH32F103C程序模拟自定义HID设备程序。
USB(HID)调试助手20181018(V1.3)
10-18
根据使用中的情况和大家的反馈意见，对USB(HID)调试助手进行了修改，主要修改了HID设备的读取方式，修改后的版本在指令下发后，在读HID设备信息时直到读完所有的信息为止。
打包下载---WCH沁恒CH55X最新USB应用实例2019-11-11.zip
03-09
单片机USB开发实用例程源码，包含常用的USB设备类型，覆盖大部分USB开发实例。有助于工程师直接导入开发，缩短USB的开发时间，节省工程师开发精力，提高开发效率。
沁恒CH582mi2c
08-21
根据引用的内容，沁恒CH582M是wch自研的青稞RISC处理器，该处理器使用沁恒出品的开发环境。而引用中提到的CH554芯片则是一款兼容MCS51指令集的增强型E8051内核单片机。它具有高速指令执行和较高的系统主频。根据引用给出的代码，可以看出该代码是用于编写程序并进行烧录的。 通过综合以上信息，可以得出结论：沁恒CH582M与CH554芯片是两种不同的芯片，分别属于不同的产品系列。CH582M是沁恒自研的青稞RISC处理器，而CH554是沁恒的一款兼容MCS51指令集的增强型E8051内核单片机。这两款芯片在架构和功能上有着明显的差异。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [沁恒CH582M开发板--点亮LED](https://blog.csdn.net/m0_61648995/article/details/126345252)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [沁恒CH554EVT开发包](https://download.csdn.net/download/gxzbj26/12913182)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值