#include "sr_gpio.h"

//端口地址映射,与GPIO_PORT_E一一对应
static GPIO_TypeDef  * _portAddr[] = {
#ifdef GPIOA
    GPIOA, 
#endif

#ifdef GPIOB
    GPIOB,
#endif

#ifdef GPIOC  
    GPIOC,  
#endif
    
#ifdef GPIOD  
    GPIOD,  
#endif
    
#ifdef GPIOE
    GPIOE,  
#endif

#ifdef GPIOF
    GPIOF,   
#endif
    
#ifdef GPIOG 
    GPIOG,     
#endif
    
#ifdef GPIOH  
    GPIOH
#endif
    
};
//PIN映射
#define PIN_MAP(id) ((uint16_t)(1u << _GPIO_INDEX(id)))

//引脚中断使能掩码。bit位记录哪个index的引脚中断被使能，因为有很多引脚共用一个EXIT中断线，只有当所有引脚都禁止后才关闭中断线
static uint32_t gs_gpioIrqEnableMask = 0;



//GPIO中断回调结构体
typedef struct GPIO_IQR_HDR
{
    int        id;      //gpio ID
    uint32_t   mode;    //中断触发模式
    void (*hdr)(void *args);  //中断回调处理函数
    void       *args;   //中断回调处理函数参数
}GPIO_IQR_HDR_T;

//GPIO中断回调结构体数组，分别记录16个EXIT线的中断处理函数、触发模式、id
static GPIO_IQR_HDR_T gpioIrqHdlTab[] =
{
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
    {-1, 0, SR_NULL, SR_NULL},
};

//中断irq句柄映射
static const IRQn_Type gpioIrqMap[] =
{
#if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32L0) || defined(SOC_SERIES_STM32G0)
    EXTI0_1_IRQn,
    EXTI0_1_IRQn,
    EXTI2_3_IRQn,
    EXTI2_3_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
    EXTI4_15_IRQn,
#elif defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32L5) || defined(SOC_SERIES_STM32U5)
    EXTI0_IRQn,
    EXTI1_IRQn,
    EXTI2_IRQn,
    EXTI3_IRQn,
    EXTI4_IRQn,
    EXTI5_IRQn,
    EXTI6_IRQn,
    EXTI7_IRQn,
    EXTI8_IRQn,
    EXTI9_IRQn,
    EXTI10_IRQn,
    EXTI11_IRQn,
    EXTI12_IRQn,
    EXTI13_IRQn,
    EXTI14_IRQn,
    EXTI15_IRQn,
#elif defined(SOC_SERIES_STM32F3)
    EXTI0_IRQn,
    EXTI1_IRQn,
    EXTI2_TSC_IRQn,
    EXTI3_IRQn,
    EXTI4_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
#else
    EXTI0_IRQn,
    EXTI1_IRQn,
    EXTI2_IRQn,
    EXTI3_IRQn,
    EXTI4_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI9_5_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
    EXTI15_10_IRQn,
#endif
};


static int _GpioIrqEnable(int gpioId, uint8_t enabled);
static int _GpioRccEnable(int gpioId);



int BspGpioInit(int gpioId, SR_GPIO_CFG_T *gpioCfg)
{

    //参数有效性检查
    if (_GPIO_PORT(gpioId) >= ST_PORT_MAX || _GPIO_INDEX(gpioId) > ST_PIN_MAX) return SR_INVALID;
    if(!gpioCfg) return SR_INVALID;
    

    /*原厂接口初始化GPIO*/
    GPIO_TypeDef  * port = _portAddr[_GPIO_PORT(gpioId)];
    uint32_t pin = PIN_MAP(gpioId);
    //打开时钟
    _GpioRccEnable(gpioId);

    GPIO_InitTypeDef GPIO_InitStruct = {0};

    GPIO_InitStruct.Pin = pin;
    GPIO_InitStruct.Pull = gpioCfg->pull;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;  //默认

    if(gpioCfg->gpioMode == SR_GPIO_IRQ)  //中断模式
    {
        if(gpioCfg->irqMode == 0xFF) return SR_INVALID;  //不支持的中断触发模式
        GPIO_InitStruct.Mode = gpioCfg->irqMode;  //中断触发模式
    }
    else 
    {
        GPIO_InitStruct.Mode = gpioCfg->gpioMode;
    }
    
    HAL_GPIO_Init(port, &GPIO_InitStruct);

    /* 中断初始化*/
    if(gpioCfg->gpioMode == SR_GPIO_IRQ)
    {
        //中断回调注册
        BspGpioSetCb(gpioId, gpioCfg->irqMode, gpioCfg->irqCb);
        
        //中断使能和优先级
        _GpioIrqEnable(gpioId, 1);

    }
    
    //初始输出电平设置
    if(gpioCfg->gpioMode == SR_GPIO_OUTPUT)  HAL_GPIO_WritePin(port, pin, (GPIO_PinState)gpioCfg->initLvl);

    return 0;
}

int BspGpioDeinit(int gpioId)
{
    GPIO_TypeDef  * port = _portAddr[_GPIO_PORT(gpioId)];
    uint32_t pin = PIN_MAP(gpioId);

    //参数有效性检查
    if (_GPIO_PORT(gpioId) >= ST_PORT_MAX || _GPIO_INDEX(gpioId) > ST_PIN_MAX) return SR_INVALID;
    
    //调用原厂接口
    HAL_GPIO_DeInit(port,pin);

    return 0;
}

int BspGpioRead(int gpioId)
{
    GPIO_TypeDef  * port = _portAddr[_GPIO_PORT(gpioId)];
    uint32_t pin = PIN_MAP(gpioId);

    //参数有效性检查
    if (_GPIO_PORT(gpioId) >= ST_PORT_MAX || _GPIO_INDEX(gpioId) > ST_PIN_MAX) return SR_INVALID;
    
    //调用原厂接口
    return HAL_GPIO_ReadPin(port, pin);  
}

int BspGpioWrite(int gpioId, uint8_t value)
{
    GPIO_TypeDef  * port = _portAddr[_GPIO_PORT(gpioId)];
    uint32_t pin = PIN_MAP(gpioId);

    //参数有效性检查
    if (_GPIO_PORT(gpioId) >= ST_PORT_MAX || _GPIO_INDEX(gpioId) > ST_PIN_MAX) return SR_INVALID;
    
    //调用原厂接口
    if (SR_GPIO_TOGGLE == value)
        HAL_GPIO_TogglePin(port, pin);
    else if(SR_GPIO_HIGH == value || SR_GPIO_LOW == value)
        HAL_GPIO_WritePin(port, pin, (GPIO_PinState)value);
    else
        return SR_INVALID;

    return 0;
}


int BspGpioEnableIrq(int gpioId)
{  
    return _GpioIrqEnable(gpioId, 1);
}

int BspGpioDisableIrq(int gpioId)
{
   return _GpioIrqEnable(gpioId, 0);
}

int BspGpioSetCb(int gpioId, SR_GPIO_IRQ_MODE_E irqMode, SR_GPIO_IRQ_CB_T *gpioIrqCb)
{
    uint32_t irqIndex ;
    irqIndex = _GPIO_INDEX(gpioId);

    //参数有效性检查
    if (_GPIO_PORT(gpioId) >= ST_PORT_MAX || _GPIO_INDEX(gpioId) > ST_PIN_MAX) return SR_INVALID;
    
    //进入临界保护
    gpioIrqHdlTab[irqIndex].id = gpioId;
    gpioIrqHdlTab[irqIndex].hdr = gpioIrqCb->func;
    gpioIrqHdlTab[irqIndex].mode = irqMode;
    gpioIrqHdlTab[irqIndex].args = gpioIrqCb->args;
    //退出临界保护

    return SR_OK;
}

int BspGpioUnsetCb(int gpioId)
{
    uint32_t irqIndex ;
    irqIndex = _GPIO_INDEX(gpioId);

    //参数有效性检查
    if (_GPIO_PORT(gpioId) >= ST_PORT_MAX || _GPIO_INDEX(gpioId) > ST_PIN_MAX) return SR_INVALID;
    
    //进入临界保护
    gpioIrqHdlTab[irqIndex].id = -1;
    gpioIrqHdlTab[irqIndex].hdr = SR_NULL;
    gpioIrqHdlTab[irqIndex].mode = 0;
    gpioIrqHdlTab[irqIndex].args = SR_NULL;
    //退出临界保护
    return SR_OK;
}


static int _GpioIrqEnable(int gpioId, uint8_t enabled)
{ 
    uint32_t irqIndex = _GPIO_INDEX(gpioId);;
    GPIO_TypeDef  *port = _portAddr[_GPIO_PORT(gpioId)];
    uint32_t pin = PIN_MAP(gpioId);

    GPIO_InitTypeDef GPIO_InitStruct={0};

    //参数有效性检查
    if (_GPIO_PORT(gpioId) >= ST_PORT_MAX || _GPIO_INDEX(gpioId) > ST_PIN_MAX) return SR_INVALID;
    
    
    if (enabled==1)
    {
        //进入临界保护

        if (gpioIrqHdlTab[irqIndex].id == -1)
        {
            //退出临界保护
            return SR_EINIT;   //引脚未配置
        }    

        /* Configure GPIO_InitStructure */
        GPIO_InitStruct.Pin = pin;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        switch (gpioIrqHdlTab[irqIndex].mode)
        {
            case SR_GPIO_IRQ_RISING:
                GPIO_InitStruct.Pull = SR_GPIO_PD;
                GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
                break;
            case SR_GPIO_IRQ_FALLING:
                GPIO_InitStruct.Pull = SR_GPIO_PU;
                GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
                break;
            case SR_GPIO_IRQ_DOUBLE:
                GPIO_InitStruct.Pull = SR_GPIO_NP;
                GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
                break;
        }
        HAL_GPIO_Init(port, &GPIO_InitStruct);

        HAL_NVIC_SetPriority(gpioIrqMap[irqIndex], 5, 0);
        HAL_NVIC_EnableIRQ(gpioIrqMap[irqIndex]);
        gs_gpioIrqEnableMask |= (1<<irqIndex);

        //退出临界保护
    }
    else
    {
        //进入临界保护

        HAL_GPIO_DeInit(port, pin);

        gs_gpioIrqEnableMask &= ~(1<<irqIndex);
#if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0)
        if ((pin >= GPIO_PIN_0) && (pin <= GPIO_PIN_1))
        {
            //当共用同一EXIT中断线的所有脚都被禁用时，才禁用该中断线
            if (!(gs_gpioIrqEnableMask & (GPIO_PIN_0 | GPIO_PIN_1)))
            {
                HAL_NVIC_DisableIRQ(gpioIrqMap[irqIndex]);
            }
        }
        else if ((pin >= GPIO_PIN_2) && (pin <= GPIO_PIN_3))
        {
            if (!(gs_gpioIrqEnableMask & (GPIO_PIN_2 | GPIO_PIN_3)))
            {
                HAL_NVIC_DisableIRQ(gpioIrqMap[irqIndex]);
            }
        }
        else if ((pin >= GPIO_PIN_4) && (pin <= GPIO_PIN_15))
        {
            if (!(gs_gpioIrqEnableMask & (GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9 |
                                         GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15)))
            {
                HAL_NVIC_DisableIRQ(gpioIrqMap[irqIndex]);
            }
        }
        else
        {
            HAL_NVIC_DisableIRQ(gpioIrqMap[irqIndex]);
        }
#else
        if ((pin >= GPIO_PIN_5) && (pin <= GPIO_PIN_9))
        {
            //当共用同一EXIT中断线的所有脚都被禁用时，才禁用该中断线
            if (!(gs_gpioIrqEnableMask & (GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9)))
            {
                HAL_NVIC_DisableIRQ(gpioIrqMap[irqIndex]);  
            }
        }
        else if ((pin >= GPIO_PIN_10) && (pin <= GPIO_PIN_15))
        {
            if (!(gs_gpioIrqEnableMask & (GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15)))
            {
                HAL_NVIC_DisableIRQ(gpioIrqMap[irqIndex]);
            }
        }
        else
        {
            HAL_NVIC_DisableIRQ(gpioIrqMap[irqIndex]);
        }
#endif
        //退出临界保护
    }
    
    return SR_OK;
}

static int _GpioRccEnable(int gpioId)
{
    uint16_t portIdx = _GPIO_PORT(gpioId);
    
    switch(portIdx)
    {
    #ifdef GPIOA
        case PA:
            __HAL_RCC_GPIOA_CLK_ENABLE();
        break;
    #endif

    #ifdef GPIOB
        case PB:
            __HAL_RCC_GPIOB_CLK_ENABLE();          
        break;
    #endif

    #ifdef GPIOC    
        case PC:
            __HAL_RCC_GPIOC_CLK_ENABLE();         
        break;
    #endif

    #ifdef GPIOD      
        case PD:
            __HAL_RCC_GPIOD_CLK_ENABLE();    
        break;   
    #endif

    #ifdef GPIOE       
        case PE:
            __HAL_RCC_GPIOE_CLK_ENABLE();         
        break;    
    #endif

    #ifdef GPIOF
        case PF:
            __HAL_RCC_GPIOF_CLK_ENABLE();    
        break; 
    #endif

    #ifdef GPIOG   
        case PG:
            __HAL_RCC_GPIOG_CLK_ENABLE();    
        break;   
    #endif

    #ifdef GPIOH      
        case PH:
            __HAL_RCC_GPIOH_CLK_ENABLE();   
        break;     
    #endif

    }
		
		return 0;
}

//判断是第几个bit位置1
SR_INLINE int _Bit2Bitnum(uint32_t bit)
{
    int i;
    for (i = 0; i < 32; i++)
    {
        if (((uint32_t)0x01 << i) == bit)
        {
            return i;
        }
    }
    return -1;
}

SR_INLINE void _GpioIrqHdl(int irqno)
{
    if (gpioIrqHdlTab[irqno].hdr)
    {
        gpioIrqHdlTab[irqno].hdr(gpioIrqHdlTab[irqno].args);
    }
}

#if defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32MP1)
void HAL_GPIO_EXTI_Rising_Callback(uint16_t GPIO_Pin)
{
    _GpioIrqHdl(_Bit2Bitnum(GPIO_Pin));
}

void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
{
    _GpioIrqHdl(_Bit2Bitnum(GPIO_Pin));
}
#else
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
		//原厂回调中，调用朝阳的回调
    _GpioIrqHdl(_Bit2Bitnum(GPIO_Pin));
}
#endif

#if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0) || defined(SOC_SERIES_STM32L0)
void EXTI0_1_IRQHandler(void)
{
    ////rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1);
    //rt_interrupt_leave();
}

void EXTI2_3_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_3);
    rt_interrupt_leave();
}
void EXTI4_15_IRQHandler(void)
{
    ////rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_4);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_6);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_7);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_10);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_11);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
    rt_interrupt_leave();
}

#elif defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32U5)
void EXTI0_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
    rt_interrupt_leave();
}

void EXTI1_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1);
    //rt_interrupt_leave();
}

void EXTI2_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2);
    //rt_interrupt_leave();
}

void EXTI3_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_3);
    //rt_interrupt_leave();
}

void EXTI4_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_4);
    //rt_interrupt_leave();
}

void EXTI5_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5);
    //rt_interrupt_leave();
}

void EXTI6_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_6);
    //rt_interrupt_leave();
}

void EXTI7_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_7);
    //rt_interrupt_leave();
}

void EXTI8_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8);
    //rt_interrupt_leave();
}

void EXTI9_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9);
    //rt_interrupt_leave();
}

void EXTI10_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_10);
    //rt_interrupt_leave();
}

void EXTI11_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_11);
    //rt_interrupt_leave();
}

void EXTI12_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12);
    //rt_interrupt_leave();
}

void EXTI13_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
    //rt_interrupt_leave();
}

void EXTI14_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
    //rt_interrupt_leave();
}

void EXTI15_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
    //rt_interrupt_leave();
}

#else

void EXTI0_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
    //rt_interrupt_leave();
}

void EXTI1_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1);
    //rt_interrupt_leave();
}

void EXTI2_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2);
    //rt_interrupt_leave();
}

void EXTI3_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_3);
    //rt_interrupt_leave();
}

void EXTI4_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_4);
    //rt_interrupt_leave();
}

void EXTI9_5_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_6);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_7);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9);
    //rt_interrupt_leave();
}

void EXTI15_10_IRQHandler(void)
{
    //rt_interrupt_enter();
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_10);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_11);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
    //rt_interrupt_leave();
}
#endif