예제 #1
0
파일: uart.c 프로젝트: coocox/Mplib
/**
  * @brief  SIO Configuration.
  * @param  SCx
  * @retval None
  */
void SIO_Configuration(TSB_SC_TypeDef * SCx)
{
    if (SCx == UART1) {
        GPIO_SetOutputEnableReg(GPIO_PA, GPIO_BIT_5, ENABLE);
        GPIO_EnableFuncReg(GPIO_PA, GPIO_FUNC_REG_1, GPIO_BIT_5);
        GPIO_EnableFuncReg(GPIO_PA, GPIO_FUNC_REG_1, GPIO_BIT_6);
        GPIO_SetInputEnableReg(GPIO_PA, GPIO_BIT_6, ENABLE);
    } else {
        /*  Do Nothing */
    }
}
예제 #2
0
파일: SBI_SLAVE.c 프로젝트: coocox/Mplib
/**
  * @brief  Config the GPIO for SBI1
  * @param  None
  * @retval None
  */
void SBI1_IO_Configuration(void)
{
    GPIO_EnableFuncReg(GPIO_PD, GPIO_FUNC_REG_2, GPIO_BIT_0);
    GPIO_EnableFuncReg(GPIO_PD, GPIO_FUNC_REG_2, GPIO_BIT_1);
    GPIO_SetOutputEnableReg(GPIO_PD, GPIO_BIT_0, ENABLE);
    GPIO_SetOutputEnableReg(GPIO_PD, GPIO_BIT_1, ENABLE);
    GPIO_SetInputEnableReg(GPIO_PD, GPIO_BIT_0, ENABLE);
    GPIO_SetInputEnableReg(GPIO_PD, GPIO_BIT_1, ENABLE);
    GPIO_SetOpenDrain(GPIO_PD, GPIO_BIT_0, ENABLE);
    GPIO_SetOpenDrain(GPIO_PD, GPIO_BIT_1, ENABLE);
    /* Pull up for SDA&SCL */
    GPIO_SetPullUp(GPIO_PD, GPIO_BIT_1, ENABLE);
    GPIO_SetPullUp(GPIO_PD, GPIO_BIT_0, ENABLE);
}
예제 #3
0
static void ENC_IOInit(unsigned char channel_number)
{
  GPIO_Port     ENCPort=GPIO_PF;
  unsigned char ENCMask=0;
  
  switch (channel_number)
  {
#ifdef __TMPM_370__
  case 0:
    ENCPort = GPIO_PD;
    ENCMask = GPIO_BIT_0 | GPIO_BIT_1 | GPIO_BIT_2;
    break;
#endif    
  case 1:
    ENCPort = GPIO_PF;
    ENCMask = GPIO_BIT_2 | GPIO_BIT_3 | GPIO_BIT_4;
    break;
  default:
    assert_param(0);
    break;
  }
  
  GPIO_Init             (ENCPort, ENCMask, &portConfigENC);
  GPIO_SetInputEnableReg(ENCPort, ENCMask, ENABLE);

  GPIO_EnableFuncReg    (ENCPort, GPIO_FUNC_REG_1, ENCMask);
  GPIO_DisableFuncReg   (ENCPort, GPIO_FUNC_REG_2, ENCMask);
}
예제 #4
0
/**
  * @brief  TMRB_PPG demo
  * @param  None
  * @retval None
  */
void Example_TimerPpg(void)
{
    uint8_t Rate = 0U;
    uint32_t Duty[5] = { 0x8CAU, 0x753U, 0x4E2U, 0x271U, 0xFAU };       /* duty: 10%, 25%, 50%, 75%, 90% */
    uint8_t keyvalue;

    TMRB_InitTypeDef m_tmrb;
    TMRB_FFOutputTypeDef PPGFFInital;

    GPIO_SetInput(KEYPORT, GPIO_BIT_0); /* set KEY port to input */ 

    /* Set PF1 as TB7OUT for PPG output */
    GPIO_SetOutput(GPIO_PF, GPIO_BIT_1);
    GPIO_EnableFuncReg(GPIO_PF, GPIO_FUNC_REG_1, GPIO_BIT_1);
    GPIO_SetPullUp(GPIO_PF, GPIO_BIT_1, ENABLE);

    m_tmrb.Mode = TMRB_INTERVAL_TIMER;
    m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
    m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
    m_tmrb.Cycle = TMRB7TIME;   /* T = 250us */
    m_tmrb.Duty = Duty[Rate];
    PPGFFInital.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
    PPGFFInital.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_CYCLE | TMRB_FLIPFLOP_MATCH_DUTY;

    TMRB_Enable(TSB_TB7);
    TMRB_Init(TSB_TB7, &m_tmrb);
    TMRB_SetFlipFlop(TSB_TB7, &PPGFFInital);
    TMRB_SetDoubleBuf(TSB_TB7, ENABLE, TMRB_WRITE_REG_SEPARATE);        /* enable double buffer */
    TMRB_SetRunState(TSB_TB7, TMRB_RUN);

    do {                        /* wait if key is pressed */
        keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
    } while (GPIO_BIT_VALUE_1 == keyvalue);

    delay(0xFFFU);              /* noise cancel */

    while (1) {
        do {                    /* wait if key is released */
            keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
        } while (GPIO_BIT_VALUE_0 == keyvalue);

        delay(0xFFFU);          /* noise cancel */

        Rate++;
        if (Rate >= DUTYMAX) {  /* change duty rate */
            Rate = DUTYINIT;
        } else {
            /* Do nothing */
        }

        TMRB_ChangeDuty(TSB_TB7, Duty[Rate]); /* change duty rate */

        do {                    /* wait if key is pressed */
            keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
        } while (GPIO_BIT_VALUE_1 == keyvalue);

        delay(0xFFFU);          /* noise cancel */
    }
}
예제 #5
0
/**
  * @brief  CAN port initialization
  * @param  None.
  * @retval None.
  */
void CAN_PortInit(void)
{
    GPIO_SetOutput(GPIO_PE, GPIO_BIT_4);        /* Set TX pin as output */
    GPIO_SetInput(GPIO_PE, GPIO_BIT_5); /* Set RX pin as input */
    GPIO_EnableFuncReg(GPIO_PE, GPIO_FUNC_REG_3, (uint8_t) (GPIO_BIT_4 | GPIO_BIT_5));  /* Enable TX and RX pin functions */
    GPIO_SetOpenDrain(GPIO_PE, GPIO_BIT_4, DISABLE);    /* Set TX pin as CMOS output */
    GPIO_SetPullUp(GPIO_PE, (uint8_t) (GPIO_BIT_4 | GPIO_BIT_5), DISABLE);      /* Disable pull-ups for CAN pins */
}
예제 #6
0
/**
  * @brief  The main function of TMRB_PPG demo
  * @param  None
  * @retval None
  */
void Example_TMRB_PPG(void)
{

    uint32_t Duty[5] = { 0x1194U, 0xEA6U, 0x9C4U, 0x4E2U, 0x1F4U };     /* duty: 10%, 25%, 50%, 75%, 90% */
    uint8_t keyvalue;

    TMRB_InitTypeDef m_tmrb;
    TMRB_FFOutputTypeDef PPGFFInital;

    /* LCD & switch initialization */
    LCD_Configuration();
    SW_Init();

    /* Set PA5 as TB6OUT for PPG output */
    GPIO_SetOutput(GPIO_PA, GPIO_BIT_5);
    GPIO_EnableFuncReg(GPIO_PA, GPIO_FUNC_REG_2, GPIO_BIT_5);

    m_tmrb.Mode = TMRB_INTERVAL_TIMER;
    m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
    m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
    m_tmrb.Cycle = TMRB6TIME;   /* T = 500us */
    m_tmrb.Duty = Duty[Rate];
    PPGFFInital.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
    PPGFFInital.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_CYCLE | TMRB_FLIPFLOP_MATCH_DUTY;

    TMRB_Enable(TSB_TB6);
    TMRB_Init(TSB_TB6, &m_tmrb);
    TMRB_SetFlipFlop(TSB_TB6, &PPGFFInital);
    TMRB_SetDoubleBuf(TSB_TB6, ENABLE, TMRB_WRITE_REG_SEPARATE);        /* enable double buffer */
    TMRB_SetRunState(TSB_TB6, TMRB_RUN);

    do {                        /* Handle the condition that start with the SW0 is high*/
        keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
        duty_display();
    } while (GPIO_BIT_VALUE_1 == keyvalue);

    delay(0xFFFFU);             /* noise cancel */

    while (1) {       
        do {
            keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);   /* display when switch is low */
            duty_display();
        } while (GPIO_BIT_VALUE_0 == keyvalue);
        delay(0xFFFFU);         /* noise cancel */
        Rate++;
        if (Rate >= DUTYMAX) {  /* change duty rate */
            Rate = DUTYINIT;
        } else {
            /* Do nothing */
        }
        TMRB_ChangeDuty(TSB_TB6, Duty[Rate]);
        do {
            keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);   /* display when switch is high */
            duty_display();
        } while (GPIO_BIT_VALUE_1  == keyvalue);
        delay(0xFFFFU);         /* noise cancel */
    }
}
예제 #7
0
파일: uart.c 프로젝트: coocox/Mplib
/**
  * @brief  SIO Configuration.
  * @param  SCx
  * @retval None
  */
void SIO_Configuration(TSB_SC_TypeDef * SCx)
{
    if (SCx == UART0) {
        GPIO_SetOutputEnableReg(GPIO_PE, GPIO_BIT_0, ENABLE);
        GPIO_EnableFuncReg(GPIO_PE, GPIO_FUNC_REG_1, GPIO_BIT_0);
        GPIO_EnableFuncReg(GPIO_PE, GPIO_FUNC_REG_1, GPIO_BIT_1);
        GPIO_SetInputEnableReg(GPIO_PE, GPIO_BIT_1, ENABLE);
        GPIO_SetPullUp(GPIO_PE, GPIO_BIT_1, ENABLE);
        GPIO_SetPullUp(GPIO_PE, GPIO_BIT_0, ENABLE);
    } else if (SCx == UART1) {
        GPIO_SetOutputEnableReg(GPIO_PC, GPIO_BIT_0, ENABLE);
        GPIO_EnableFuncReg(GPIO_PC, GPIO_FUNC_REG_2, GPIO_BIT_0);;
        GPIO_EnableFuncReg(GPIO_PC, GPIO_FUNC_REG_2, GPIO_BIT_1);;
        GPIO_SetInputEnableReg(GPIO_PC, GPIO_BIT_1, ENABLE);
        GPIO_SetPullUp(GPIO_PC, GPIO_BIT_0, ENABLE);
        GPIO_SetPullUp(GPIO_PC, GPIO_BIT_1, ENABLE);
    } else if (SCx == UART2) {
        GPIO_SetOutputEnableReg(GPIO_PC, GPIO_BIT_4, ENABLE);
        GPIO_EnableFuncReg(GPIO_PC, GPIO_FUNC_REG_2, GPIO_BIT_4);;
        GPIO_EnableFuncReg(GPIO_PC, GPIO_FUNC_REG_2, GPIO_BIT_5);;
        GPIO_SetInputEnableReg(GPIO_PC, GPIO_BIT_5, ENABLE);
        GPIO_SetPullUp(GPIO_PC, GPIO_BIT_4, ENABLE);
        GPIO_SetPullUp(GPIO_PC, GPIO_BIT_5, ENABLE);
    } else if (SCx == UART3) {
        GPIO_SetOutputEnableReg(GPIO_PG, GPIO_BIT_4, ENABLE);
        GPIO_EnableFuncReg(GPIO_PG, GPIO_FUNC_REG_2, GPIO_BIT_4);
        GPIO_EnableFuncReg(GPIO_PG, GPIO_FUNC_REG_2, GPIO_BIT_5);
        GPIO_SetInputEnableReg(GPIO_PG, GPIO_BIT_5, ENABLE);
        GPIO_SetPullUp(GPIO_PG, GPIO_BIT_4, ENABLE);
        GPIO_SetPullUp(GPIO_PG, GPIO_BIT_5, ENABLE);
    } else if (SCx == UART4) {
        GPIO_SetOutputEnableReg(GPIO_PH, GPIO_BIT_0, ENABLE);
        GPIO_EnableFuncReg(GPIO_PH, GPIO_FUNC_REG_2, GPIO_BIT_0);;
        GPIO_EnableFuncReg(GPIO_PH, GPIO_FUNC_REG_2, GPIO_BIT_1);;
        GPIO_SetInputEnableReg(GPIO_PH, GPIO_BIT_1, ENABLE);
        GPIO_SetPullUp(GPIO_PH, GPIO_BIT_0, ENABLE);
        GPIO_SetPullUp(GPIO_PH, GPIO_BIT_1, ENABLE);
    } else {
        /*  Do Nothing */
    }
}
예제 #8
0
파일: pinmap.c 프로젝트: sg-/mbed-os
void pin_function(PinName pin, int function)
{
    uint32_t port = 0;
    uint8_t bit = 0;
    uint8_t i = 0;
    uint8_t func = 0;
    uint8_t dir = 0;

    // Assert that pin is valid
    MBED_ASSERT(pin != NC);

    // Calculate pin function and pin direction
    func = PIN_FUNC(function);
    dir  = PIN_DIR(function);
    // Calculate port and pin position
    port = PIN_PORT(pin);
    bit  = PIN_POS(pin);
    // Set function if function is in range
    if (func <= PIN_FUNC_MAX) {
        // Disable other functions
        for (i = 0; i < PIN_FUNC_MAX; i++) {
            if (i != (func - 1)) {
                GPIO_DisableFuncReg((GPIO_Port)port, i, (1 << bit));
            }
        }
        // Set pin function
        if (func) {
            GPIO_EnableFuncReg((GPIO_Port)port, (uint8_t)(func - 1), (1 << bit));
        }
    }

    // Set direction if direction is in range
    switch (dir) {
        case PIN_INPUT:
            GPIO_SetInputEnableReg((GPIO_Port)port, (1 << bit), ENABLE);
            GPIO_SetOutputEnableReg((GPIO_Port)port, (1 << bit), DISABLE);
            break;
        case PIN_OUTPUT:
            GPIO_SetOutputEnableReg((GPIO_Port)port, (1 << bit), ENABLE);
            GPIO_SetInputEnableReg((GPIO_Port)port, (1 << bit), DISABLE);
            break;
        case PIN_INOUT:
            GPIO_SetOutputEnableReg((GPIO_Port)port, (1 << bit), ENABLE);
            GPIO_SetInputEnableReg((GPIO_Port)port, (1 << bit), ENABLE);
            break;
        default:
            break;
    }
}
예제 #9
0
/**
  * @brief  Configure I/O ports for INT
  * @param  None
  * @retval None
  */
void GPIO_SetINT(void)
{
    //for INT0
    GPIO_SetOutputEnableReg(GPIO_PG, GPIO_BIT_3, DISABLE);
    GPIO_EnableFuncReg(GPIO_PG, GPIO_FUNC_REG_2, GPIO_BIT_3);
    GPIO_SetInputEnableReg(GPIO_PG, GPIO_BIT_3, ENABLE);
    GPIO_SetOpenDrain(GPIO_PG, GPIO_BIT_3, DISABLE);

    //for SW1
#ifdef M341_SK_BOARD
    GPIO_SetOutputEnableReg(GPIO_PE, GPIO_BIT_3, DISABLE);
    GPIO_SetInputEnableReg(GPIO_PE, GPIO_BIT_3, ENABLE);
    GPIO_SetPullUp(GPIO_PE, GPIO_BIT_3, ENABLE);
#else
    GPIO_SetOutputEnableReg(GPIO_PG, GPIO_BIT_7, DISABLE);
    GPIO_SetInputEnableReg(GPIO_PG, GPIO_BIT_7, ENABLE);
    GPIO_SetPullUp(GPIO_PG, GPIO_BIT_7, ENABLE);
#endif

}
예제 #10
0
파일: IGBT_OnePPG.c 프로젝트: coocox/Mplib
/**
  * @brief  SIO Configuration.
  * @param  None
  * @retval None
  */
void SIO_Configuration(void)
{ 
     GPIO_SetOutputEnableReg(GPIO_PE, GPIO_BIT_2, ENABLE);
     GPIO_SetInputEnableReg(GPIO_PE, GPIO_BIT_2, DISABLE);
     GPIO_EnableFuncReg(GPIO_PE, GPIO_FUNC_REG_1, GPIO_BIT_2);
}
예제 #11
0
파일: IGBT_OnePPG.c 프로젝트: coocox/Mplib
/**
  * @brief  IGBT port initialization
  * @param  IGBTx: IGBT channel.
  *         InitTypeDef: initialization structure.
  * @retval None.
  */
void IGBT_IO_Configuration(TSB_MT_TypeDef * IGBTx, IGBT_InitTypeDef * InitTypeDef)
{
    if (IGBTx == IGBT0) {
        /* Check whether the trigger is used to start */
        if ((InitTypeDef->StartMode != IGBT_CMD_START) ||
            (InitTypeDef->StartMode != IGBT_CMD_START_NO_START_INT)) {
            GPIO_SetInputEnableReg(GPIO_PG, GPIO_BIT_0, ENABLE);        /* Enable PG0 input */
            GPIO_EnableFuncReg(GPIO_PG, GPIO_FUNC_REG_3, GPIO_BIT_0);   /* Set PG0 as MT0IN */
        } else {
            GPIO_SetInputEnableReg(GPIO_PG, GPIO_BIT_0, DISABLE);
            GPIO_DisableFuncReg(GPIO_PG, GPIO_FUNC_REG_3, GPIO_BIT_0);
        }
        /* Enable ouput0 or not */
        if (InitTypeDef->Output0Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PG, GPIO_BIT_3, ENABLE);       /* Enable PG3 output */
            GPIO_EnableFuncReg(GPIO_PG, GPIO_FUNC_REG_3, GPIO_BIT_3);   /* Set PG3 as MTOUT00 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PG, GPIO_BIT_3, DISABLE);
            GPIO_DisableFuncReg(GPIO_PG, GPIO_FUNC_REG_3, GPIO_BIT_3);
        }
        /* Enable ouput1 or not */
        if (InitTypeDef->Output1Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PG, GPIO_BIT_2, ENABLE);       /* Enable PG2 output */
            GPIO_EnableFuncReg(GPIO_PG, GPIO_FUNC_REG_3, GPIO_BIT_2);   /* Set PG2 as MTOUT10 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PG, GPIO_BIT_2, DISABLE);
            GPIO_DisableFuncReg(GPIO_PG, GPIO_FUNC_REG_3, GPIO_BIT_2);
        }

        GPIO_SetInputEnableReg(GPIO_PG, GPIO_BIT_1, ENABLE);    /* Enable PG1 input */
        GPIO_EnableFuncReg(GPIO_PG, GPIO_FUNC_REG_3, GPIO_BIT_1);       /* Set PG1 as GEMG0 */
    }


    if (IGBTx == IGBT1) {
        /* Check whether the trigger is used to start */
        if ((InitTypeDef->StartMode != IGBT_CMD_START) ||
            (InitTypeDef->StartMode != IGBT_CMD_START_NO_START_INT)) {
            GPIO_SetInputEnableReg(GPIO_PL, GPIO_BIT_0, ENABLE);        /* Enable PL0 input */
            GPIO_EnableFuncReg(GPIO_PL, GPIO_FUNC_REG_3, GPIO_BIT_0);   /* Set PL0 as MT1IN */
        } else {
            GPIO_SetInputEnableReg(GPIO_PL, GPIO_BIT_0, DISABLE);
            GPIO_DisableFuncReg(GPIO_PL, GPIO_FUNC_REG_3, GPIO_BIT_0);
        }
        /* Enable ouput0 or not */
        if (InitTypeDef->Output0Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PL, GPIO_BIT_3, ENABLE);       /* Enable PL3 output */
            GPIO_EnableFuncReg(GPIO_PL, GPIO_FUNC_REG_3, GPIO_BIT_3);   /* Set PL3 as MTOUT01 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PL, GPIO_BIT_3, DISABLE);
            GPIO_DisableFuncReg(GPIO_PL, GPIO_FUNC_REG_3, GPIO_BIT_3);
        }
        /* Enable ouput1 or not */
        if (InitTypeDef->Output1Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PL, GPIO_BIT_2, ENABLE);       /* Enable PL2 output */
            GPIO_EnableFuncReg(GPIO_PL, GPIO_FUNC_REG_3, GPIO_BIT_2);   /* Set PL2 as MTOUT11 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PL, GPIO_BIT_2, DISABLE);
            GPIO_DisableFuncReg(GPIO_PL, GPIO_FUNC_REG_3, GPIO_BIT_2);
        }

        GPIO_SetInputEnableReg(GPIO_PL, GPIO_BIT_1, ENABLE);    /* Enable PL1 input */
        GPIO_EnableFuncReg(GPIO_PL, GPIO_FUNC_REG_3, GPIO_BIT_1);       /* Set PL1 as GEMG1 */
    }

    if (IGBTx == IGBT2) {
        /* Check whether the trigger is used to start */
        if ((InitTypeDef->StartMode != IGBT_CMD_START) ||
            (InitTypeDef->StartMode != IGBT_CMD_START_NO_START_INT)) {
            GPIO_SetInputEnableReg(GPIO_PH, GPIO_BIT_0, ENABLE);        /* Enable PH0 input */
            GPIO_EnableFuncReg(GPIO_PH, GPIO_FUNC_REG_3, GPIO_BIT_0);   /* Set PH0 as MT2IN */
        } else {
            GPIO_SetInputEnableReg(GPIO_PH, GPIO_BIT_0, DISABLE);
            GPIO_DisableFuncReg(GPIO_PH, GPIO_FUNC_REG_3, GPIO_BIT_0);
        }
        /* Enable ouput0 or not */
        if (InitTypeDef->Output0Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PH, GPIO_BIT_3, ENABLE);       /* Enable PH3 output */
            GPIO_EnableFuncReg(GPIO_PH, GPIO_FUNC_REG_3, GPIO_BIT_3);   /* Set PH3 as MTOUT02 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PH, GPIO_BIT_3, DISABLE);
            GPIO_DisableFuncReg(GPIO_PH, GPIO_FUNC_REG_3, GPIO_BIT_3);
        }
        /* Enable ouput1 or not */
        if (InitTypeDef->Output1Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PH, GPIO_BIT_2, ENABLE);       /* Enable PH2 output */
            GPIO_EnableFuncReg(GPIO_PH, GPIO_FUNC_REG_3, GPIO_BIT_2);   /* Set PH2 as MTOUT12 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PH, GPIO_BIT_2, DISABLE);
            GPIO_DisableFuncReg(GPIO_PH, GPIO_FUNC_REG_3, GPIO_BIT_2);
        }

        GPIO_SetInputEnableReg(GPIO_PH, GPIO_BIT_1, ENABLE);    /* Enable PH1 input */
        GPIO_EnableFuncReg(GPIO_PH, GPIO_FUNC_REG_3, GPIO_BIT_1);       /* Set PH1 as GEMG2 */
    }

    if (IGBTx == IGBT3) {
        /* Check whether the trigger is used to start */
        if ((InitTypeDef->StartMode != IGBT_CMD_START) ||
            (InitTypeDef->StartMode != IGBT_CMD_START_NO_START_INT)) {
            GPIO_SetInputEnableReg(GPIO_PB, GPIO_BIT_5, ENABLE);        /* Enable PB5 input */
            GPIO_EnableFuncReg(GPIO_PB, GPIO_FUNC_REG_3, GPIO_BIT_5);   /* Set PB5 as MT3IN */
        } else {
            GPIO_SetInputEnableReg(GPIO_PB, GPIO_BIT_5, DISABLE);
            GPIO_DisableFuncReg(GPIO_PB, GPIO_FUNC_REG_3, GPIO_BIT_5);
        }
        /* Enable ouput0 or not */
        if (InitTypeDef->Output0Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PB, GPIO_BIT_2, ENABLE);       /* Enable PB2 output */
            GPIO_EnableFuncReg(GPIO_PB, GPIO_FUNC_REG_3, GPIO_BIT_2);   /* Set PB2 as MTOUT03 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PB, GPIO_BIT_2, DISABLE);
            GPIO_DisableFuncReg(GPIO_PB, GPIO_FUNC_REG_3, GPIO_BIT_2);
        }
        /* Enable ouput1 or not */
        if (InitTypeDef->Output1Init != IGBT_OUTPUT_DISABLE) {
            GPIO_SetOutputEnableReg(GPIO_PB, GPIO_BIT_3, ENABLE);       /* Enable PB3 output */
            GPIO_EnableFuncReg(GPIO_PB, GPIO_FUNC_REG_3, GPIO_BIT_3);   /* Set PB3 as MTOUT13 */
        } else {
            GPIO_SetOutputEnableReg(GPIO_PB, GPIO_BIT_3, DISABLE);
            GPIO_DisableFuncReg(GPIO_PB, GPIO_FUNC_REG_3, GPIO_BIT_3);
        }

        GPIO_SetInputEnableReg(GPIO_PB, GPIO_BIT_4, ENABLE);    /* Enable PB4 input */
        GPIO_EnableFuncReg(GPIO_PB, GPIO_FUNC_REG_3, GPIO_BIT_4);       /* Set PB4 as GEMG3 */
    }
}