/* Handle Connection event Interrupt */
    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT))
    {
      HAL_PCD_ConnectCallback(hpcd);
      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT);
    }

#define __HAL_PCD_CLEAR_FLAG(__HANDLE__, __INTERRUPT__)    (((__HANDLE__)->Instance->GINTSTS) &= (__INTERRUPT__))

GINTSTS &= 0x40000000;

GINTSTS |= 0x40000000;

void UARTPrint(char *s)
{
    for(;;)
    {
        while((USART1->SR & USART_SR_TXE) == 0);
        USART1->DR = *s++;
        if (*s == 0) break;
    }
}

{
   volatile uint32_t x;
   for (x = 0; x < 2000000; x++);
}

    UARTPrint("\r\n-IRQ");

NVIC_ClearPendingIRQ((IRQn_Type) ID_UDP);
NVIC_SetPriority((IRQn_Type) ID_UDP, 0);
NVIC_EnableIRQ((IRQn_Type) ID_UDP);

static void MX_USART1_UART_Init(void)
{
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief Initializes the UART mode according to the specified parameters in
* the UART_InitTypeDef and create the associated handle.
* @param huart: pointer to a UART_HandleTypeDef structure that contains
* the configuration information for the specified UART module.
* @retval HAL status
*/
HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
{
/* Check the UART handle allocation */
if(huart == NULL)
{
return HAL_ERROR;
}

/* Check the parameters */
if(huart->Init.HwFlowCtl != UART_HWCONTROL_NONE)
{
/* The hardware flow control is available only for USART1, USART2, USART3 and USART6 */
assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance));
assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl));
}
else
{
assert_param(IS_UART_INSTANCE(huart->Instance));
}
assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));
assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

if(huart->gState == HAL_UART_STATE_RESET)
{
/* Allocate lock resource and initialize it */
huart->Lock = HAL_UNLOCKED;
/* Init the low level hardware */
HAL_UART_MspInit(huart);
}

huart->gState = HAL_UART_STATE_BUSY;

/* Disable the peripheral */
__HAL_UART_DISABLE(huart);

/* Set the UART Communication parameters */
UART_SetConfig(huart);

/* In asynchronous mode, the following bits must be kept cleared:
- LINEN and CLKEN bits in the USART_CR2 register,
- SCEN, HDSEL and IREN bits in the USART_CR3 register.*/
CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));

/* Enable the peripheral */
__HAL_UART_ENABLE(huart);

/* Initialize the UART state */
huart->ErrorCode = HAL_UART_ERROR_NONE;
huart->gState= HAL_UART_STATE_READY;
huart->RxState= HAL_UART_STATE_READY;

return HAL_OK;
}

/**
* @brief Initializes the half-duplex mode according to the specified
* parameters in the UART_InitTypeDef and create the associated handle.
* @param huart: pointer to a UART_HandleTypeDef structure that contains
* the configuration information for the specified UART module.
* @retval HAL status
*/
HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart)
{
/* Check the UART handle allocation */
if(huart == NULL)
{
return HAL_ERROR;
}

/* Check the parameters */
assert_param(IS_UART_INSTANCE(huart->Instance));
assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));
assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

if(huart->gState == HAL_UART_STATE_RESET)
{
/* Allocate lock resource and initialize it */
huart->Lock = HAL_UNLOCKED;
/* Init the low level hardware */
HAL_UART_MspInit(huart);
}

huart->gState = HAL_UART_STATE_BUSY;

/* Disable the peripheral */
__HAL_UART_DISABLE(huart);

/* Set the UART Communication parameters */
UART_SetConfig(huart);

/* In half-duplex mode, the following bits must be kept cleared:
- LINEN and CLKEN bits in the USART_CR2 register,
- SCEN and IREN bits in the USART_CR3 register.*/
CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
CLEAR_BIT(huart->Instance->CR3, (USART_CR3_IREN | USART_CR3_SCEN));

/* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */
SET_BIT(huart->Instance->CR3, USART_CR3_HDSEL);

/* Enable the peripheral */
__HAL_UART_ENABLE(huart);

/* Initialize the UART state*/
huart->ErrorCode = HAL_UART_ERROR_NONE;
huart->gState= HAL_UART_STATE_READY;
huart->RxState= HAL_UART_STATE_READY;

return HAL_OK;
}

void up(void)
{
    volatile char *s = mem;
    for(;;)
    {
        while((USART1->SR & USART_SR_TXE) == 0);
        USART1->DR = *s++;
        if (*s == 0) break;
    }
}

static char mem[16384];
static volatile uint32_t p;


void up(void)
{
    HAL_UART_Transmit(&huart1,(uint8_t *)mem,strlen(mem),100);
}

void dbgInit(void)
{
    memset(mem,0,16384);
    p = 0;
}

void UARTPrint(char *s)
{
    volatile uint32_t x;
    if(p > 16000) return;
  for(;;)
  {
        mem[p++] = *s++;
        if(*s == 0) break;
  }
}

void up(void)
{
    volatile char *s = mem;
    for(;;)
    {
        while((USART1->SR & USART_SR_TXE) == 0);
        USART1->DR = *s++;
        if (*s == 0) break;
    }
}

GINTSTS |= 0x40000000;

GINTSTS = 0x40000000;

void UARTPrint(char *s)
{
    for(;;)
    {
        while((USART1->SR & USART_SR_TXE) == 0);
        USART1->DR = *s++;
        if (*s == 0) break;
    }
}