USBFS的EP1端点收发过程中,EP1一直发送数据,不停止

屏幕截图 2024-05-09 141629.png

image.png能不能只发送一次呢?EP1设置为NAK的话只发送一次,之后就不再发送了

void USBFS_IRQHandler( void )

{


    uint8_t  intflag, intst, errflag;

    uint16_t len;


    intflag = USBFSD->INT_FG;

    intst   = USBFSD->INT_ST;



    if( intflag & USBFS_UIF_TRANSFER )

    {

        switch (intst & USBFS_UIS_TOKEN_MASK)

        {

            /* data-in stage processing */

            case USBFS_UIS_TOKEN_IN:

            {

                switch ( intst & ( USBFS_UIS_TOKEN_MASK | USBFS_UIS_ENDP_MASK ) )

                {

                    /* end-point 0 data in interrupt */

                    case USBFS_UIS_TOKEN_IN | DEF_UEP0:

                    {

                        if( USBFS_SetupReqLen == 0 )

                        {

                            USBFSD->UEP0_CTRL_H = USBFS_UEP_R_TOG | USBFS_UEP_R_RES_ACK;

                        }

                        if ( ( USBFS_SetupReqType & USB_REQ_TYP_MASK ) != USB_REQ_TYP_STANDARD )

                        {

                            /* Non-standard request endpoint 0 Data upload */

                        }

                        else

                        {

                            /* Standard request endpoint 0 Data upload */

                            switch( USBFS_SetupReqCode )

                            {

                                case USB_GET_DESCRIPTOR:

                                        len = USBFS_SetupReqLen >= DEF_USBD_UEP0_SIZE ? DEF_USBD_UEP0_SIZE : USBFS_SetupReqLen;

                                        memcpy( USBFS_EP0_Buf, pUSBFS_Descr, len );

                                        USBFS_SetupReqLen -= len;

                                        pUSBFS_Descr += len;

                                        USBFSD->UEP0_TX_LEN   = len;

                                        USBFSD->UEP0_CTRL_H ^= USBFS_UEP_T_TOG;

                                        break;


                                case USB_SET_ADDRESS:

                                        USBFSD->DEV_ADDR = (USBFSD->DEV_ADDR & USBFS_UDA_GP_BIT) | USBFS_DevAddr;

                                        break;


                                default:

                                        break;

                            }

                        }

                        break;

                    }

                    case USBFS_UIS_TOKEN_IN | DEF_UEP1:

                       USBFSD->UEP1_CTRL_H = ( USBFSD->UEP1_CTRL_H & ~USBFS_UEP_T_RES_MASK ) | USBFS_UEP_T_RES_ACK;//ACK///

                       USBFSD->UEP1_CTRL_H ^= USBFS_UEP_T_AUTO_TOG;


                    break;

                    default :

                        break;

                }

            }

           break;

            /* data-out stage processing */

            case USBFS_UIS_TOKEN_OUT:

                switch ( intst & ( USBFS_UIS_TOKEN_MASK | USBFS_UIS_ENDP_MASK ) )

                {

                    /* end-point 0 data out interrupt */

                    case USBFS_UIS_TOKEN_OUT | DEF_UEP0:

                        len = USBFSD->RX_LEN;

                        break;


                    /* end-point 1 data out interrupt */

                    case USBFS_UIS_TOKEN_OUT | DEF_UEP1:

                        if ( intst & USBFS_UIS_TOG_OK )

                        {

                            USBFSD->UEP1_CTRL_H ^= USBFS_UEP_T_AUTO_TOG;

                            UsbRxDataHandle();

                        }

                    break;

                }

            break;


            /* Setup stage processing */

            case USBFS_UIS_TOKEN_SETUP:

            {

                USBFSD->UEP0_CTRL_H = USBFS_UEP_T_TOG|USBFS_UEP_T_RES_NAK|USBFS_UEP_R_TOG|USBFS_UEP_R_RES_NAK;


                /* Store All Setup Values */

                USBFS_SetupReqType  = pUSBFS_SetupReqPak->bRequestType;

                USBFS_SetupReqCode  = pUSBFS_SetupReqPak->bRequest;//??????

                USBFS_SetupReqLen   = pUSBFS_SetupReqPak->wLength;

                USBFS_SetupReqValue = pUSBFS_SetupReqPak->wValue;

                USBFS_SetupReqIndex = pUSBFS_SetupReqPak->wIndex;

                len = 0;

                errflag = 0;

                    /* usb standard request processing */

                    switch( USBFS_SetupReqCode )

                    {

                        /* get device/configuration/string/report/... descriptors */

                        case USB_GET_DESCRIPTOR:

                        {

                            switch( (uint8_t)( USBFS_SetupReqValue >> 8 ) )

                            {

                                /* get usb device descriptor */

                                case USB_DESCR_TYP_DEVICE:

                                    pUSBFS_Descr = MyDevDescr;

                                    len = DEF_USBD_DEVICE_DESC_LEN;

                                    break;


                                /* get usb configuration descriptor */

                                case USB_DESCR_TYP_CONFIG:

                                    pUSBFS_Descr = MyCfgDescr;

                                    len = MyCfgDescr[2];

                                    break;

//                                /* get usb REPORT descriptor */

                                case USB_DESCR_TYP_REPORT:

                                    pUSBFS_Descr=KeyRepDesc;

                                    len=35;

                                    break;

                                /* get usb string descriptor */

                                case USB_DESCR_TYP_STRING:

                                    switch( (uint8_t)( USBFS_SetupReqValue & 0xFF ) )

                                    {

                                        /* Descriptor 0, Language descriptor */

                                        case DEF_STRING_DESC_LANG:

                                            pUSBFS_Descr = MyLangDescr;

                                            len = MyLangDescr[0];

                                            break;


                                        /* Descriptor 1, Manufacturers String descriptor */

                                        case DEF_STRING_DESC_MANU:

                                            pUSBFS_Descr = MyManuInfo;

                                            len = MyManuInfo[0];

                                            break;


                                        /* Descriptor 2, Product String descriptor */

                                        case DEF_STRING_DESC_PROD:

                                            pUSBFS_Descr = MyProdInfo;

                                            len = MyProdInfo[0];

                                            break;


                                        default:

                                            errflag = 0xFF;

                                        break;

                                    }

                                    break;

                                default :

                                    errflag = 0xFF;

                                break;

                            }


                            /* Copy Descriptors to Endp0 DMA buffer */

                            if( USBFS_SetupReqLen>len )

                            {

                                USBFS_SetupReqLen = len;

                            }

                            len = (USBFS_SetupReqLen >= DEF_USBD_UEP0_SIZE) ? DEF_USBD_UEP0_SIZE : USBFS_SetupReqLen;

                            memcpy( USBFS_EP0_Buf, pUSBFS_Descr, len );

                            pUSBFS_Descr += len;

                            break;

                        }

                        /* Set usb address */

                        case USB_SET_ADDRESS:

                            USBFS_DevAddr = (uint8_t)( USBFS_SetupReqValue & 0xFF );

                            break;


                        /* Get usb configuration now set */

                        case USB_GET_CONFIGURATION:

                            USBFS_EP0_Buf[0] = USBFS_DevConfig;

                            if ( USBFS_SetupReqLen > 1 )

                            {

                                USBFS_SetupReqLen = 1;

                            }

                            break;


                        /* Set usb configuration to use */

                        case USB_SET_CONFIGURATION:

                            USBFS_DevConfig = (uint8_t)( USBFS_SetupReqValue & 0xFF );

                            USBFS_DevEnumStatus = 0x01;

                        break;


                        /* Clear or disable one usb feature */

                        case USB_CLEAR_FEATURE://????????

                        {

                            if( ( USBFS_SetupReqType & USB_REQ_RECIP_MASK ) == USB_REQ_RECIP_ENDP )

                            {

                                /* Set End-point Feature */

//                                if( (uint8_t)( USBFS_SetupReqValue & 0xFF ) == USB_REQ_FEAT_ENDP_HALT ){

                                    /* Set end-points status stall */

                                    switch( (uint8_t)( USBFS_SetupReqIndex & 0xFF ) )//?????

                                    {

                                        case ( DEF_UEP_OUT | DEF_UEP1 ):

                                            /* Set End-point 1 OUT STALL */

                                            USBFSD->UEP1_CTRL_H =(USBFSD->UEP1_CTRL_H & ~USBFS_UEP_R_RES_MASK)| USBFS_UEP_R_RES_ACK;

                                            break;

                                        case (DEF_UEP_IN|DEF_UEP1):

                                            USBFSD->UEP1_CTRL_H =(USBFSD->UEP1_CTRL_H & ~USBFS_UEP_T_RES_MASK)| USBFS_UEP_T_RES_NAK;//

                                            break;

                                        default:

                                            errflag = 0xFF;

                                        break;

                                    }

//                                }

                            }

                            else

                            {

                                errflag = 0xFF;

                            }

                            break;

                        }

                        /* set or enable one usb feature */

                        case USB_SET_FEATURE:


                            break;


                        /* This request allows the host to select another setting for the specified interface  */

                        case USB_GET_INTERFACE:

                            USBFS_EP0_Buf[0] = 0x00;

                            if ( USBFS_SetupReqLen > 1 )

                            {

                                USBFS_SetupReqLen = 1;

                            }

                            break;

//

//                        case USB_SET_INTERFACE:

//                            break;


                        /* host get status of specified device/interface/end-points */

                        case USB_GET_STATUS:

                            USBFS_EP0_Buf[ 0 ] = 0x00;

                            USBFS_EP0_Buf[ 1 ] = 0x00;

                            if( USBFS_SetupReqLen > 2 )

                            {

                                USBFS_SetupReqLen = 2;

                            }

                            break;


                        default:

                            errflag = 0xFF;

                            break;

                    }

                /* errflag = 0xFF means a request not support or some errors occurred, else correct */

                if( errflag == 0xff)

                {

                    /* if one request not support, return stall */

                    USBFSD->UEP0_CTRL_H = USBFS_UEP_T_TOG|USBFS_UEP_T_RES_STALL|USBFS_UEP_R_TOG|USBFS_UEP_R_RES_STALL;

                }

                else

                {

                    /* end-point 0 data Tx/Rx */

                    if( USBFS_SetupReqType & DEF_UEP_IN )

                    {

                        /* tx */

                        len = (USBFS_SetupReqLen>DEF_USBD_UEP0_SIZE) ? DEF_USBD_UEP0_SIZE : USBFS_SetupReqLen;

                        USBFS_SetupReqLen -= len;

                        USBFSD->UEP0_TX_LEN  = len;

                        USBFSD->UEP0_CTRL_H = USBFS_UEP_T_TOG|USBFS_UEP_T_RES_ACK;

                    }

                    else

                    {

                        /* rx */

                        if( USBFS_SetupReqLen == 0 )

                       {

                           USBFSD->UEP0_TX_LEN  = 0;

                           USBFSD->UEP0_CTRL_H = USBFS_UEP_T_TOG|USBFS_UEP_T_RES_ACK;

                       }

                       else

                       {

                           USBFSD->UEP0_CTRL_H = USBFS_UEP_R_TOG|USBFS_UEP_R_RES_ACK;

                       }

                    }

                }

                break;

            }

                /* Sof pack processing */

                case USBFS_UIS_TOKEN_SOF:

                    break;


            default :

                break;

        }

        USBFSD->INT_FG = USBFS_UIF_TRANSFER;//一个USB数据发送完成

    }

    else if( intflag & USBFS_UIF_BUS_RST )

    {

        /* usb reset interrupt processing */

        USBFS_DevConfig = 0;

        USBFS_DevAddr = 0;

        USBFS_DevSleepStatus = 0;

        USBFS_DevEnumStatus = 0;


        USBFSD->DEV_ADDR = 0;

        USBFS_Device_Endp_Init( );

        USBFSD->INT_FG = USBFS_UIF_BUS_RST;

    }

    else if( intflag & USBFS_UIF_SUSPEND )

    {

        /* usb suspend interrupt processing */

        if ( USBFSD->MIS_ST & USBFS_UMS_SUSPEND )

        {

//            USBFS_DevSleepStatus |= 0x02;

        }

        else

        {

//            USBFS_DevSleepStatus &= ~0x02; ;

        }

        USBFSD->INT_FG = USBFS_UIF_SUSPEND;

    }

    else

    {

        /* other interrupts */

        USBFSD->INT_FG = intflag;

    }

}




OK了,我改成

USBFS_UEP_T_TOG

就行了



只有登录才能回复,可以选择微信账号登录