自学教程：C++ CY_GET_REG8函数代码示例

//.........这里部分代码省略.........            USBFS_MIDI_IN_EP_Service();        }    }    else    {        midiInWaitTimer = MIDI_IN_EP_WAIT_TIME;    }    #endif            /* USBFS_IsConfigurationChanged() is a clear on read status update therefore, only one read of      * USBFS_IsConfigurationChanged() should ever exist in user code */    if(USBFS_IsConfigurationChanged())    {        macPC_flag = IsMacPCConnected();		#ifndef ENABLE_DIGITAL_AUDIO_IN_ONLY                    /* Get Alternate setting */        altSetting[AUDIO_OUT_INTERFACE_INDEX] = (macPC_flag? USBFS_GetInterfaceSetting(1):USBFS_GetInterfaceSetting(2));                 /* ByteSwap control register bit is set to 1 if alt setting 2 is selected so that           * Byte swap digital logic processes data as 16 bits. ByteSwap control register is set to 0          * if alt setting 1 is selected and byte swap processes data as 24 bits */        if (altSetting[AUDIO_OUT_INTERFACE_INDEX]==ALT_SETTING_ACTIVE_24_BIT)        {            ByteSwap_Tx_CONTROL_REG = ByteSwap_Tx_CONTROL_REG & (~ByteSwap_Tx_RES_CTRL_16);          }        else if (altSetting[AUDIO_OUT_INTERFACE_INDEX]==ALT_SETTING_ACTIVE_16_BIT)        {            ByteSwap_Tx_CONTROL_REG = ByteSwap_Tx_CONTROL_REG | ByteSwap_Tx_RES_CTRL_16;                    }                /* Arming the audio out EP if it is not zero bandwidth alt setting */        if (altSetting[AUDIO_OUT_INTERFACE_INDEX]!= ALT_SETTING_ZERO_BANDWIDTH &&             (CY_GET_REG8(USBFS_SIE_EP1_CR0_PTR + ((AUDIO_OUT_ENDPOINT - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT)) & USBFS_MODE_MASK)                                                                                     == USBFS_MODE_NAK_IN_OUT)        {            /* Init DMA configurations for audio OUT EP */            USBFS_ReadOutEP(AUDIO_OUT_ENDPOINT, &outRam[0], OUT_AUDIOMAXPKT);            USBFS_EnableOutEP(AUDIO_OUT_ENDPOINT);        }        #endif                #ifndef ENABLE_DIGITAL_AUDIO_OUT_ONLY            #ifndef ENABLE_DIGITAL_AUDIO_IN_ONLY             if(altSetting[AUDIO_IN_INTERFACE_INDEX] != (macPC_flag? USBFS_GetInterfaceSetting(2):USBFS_GetInterfaceSetting(3)))        {                  altSetting[AUDIO_IN_INTERFACE_INDEX] = (macPC_flag? USBFS_GetInterfaceSetting(2):USBFS_GetInterfaceSetting(3));            #else            if(altSetting[AUDIO_IN_INTERFACE_INDEX] != (macPC_flag? USBFS_GetInterfaceSetting(1):USBFS_GetInterfaceSetting(2)))        {                  altSetting[AUDIO_IN_INTERFACE_INDEX] = (macPC_flag? USBFS_GetInterfaceSetting(1):USBFS_GetInterfaceSetting(2));            #endif                        /* Setting the ByteSwap control register bit to 0 regardless of alt setting is selected. Because audio in             *  interface both the alternate settings alt setting1 and alt setting 2 both use 3 byte subframe size. */                        ByteSwap_Rx_CONTROL_REG = ByteSwap_Rx_CONTROL_REG & (~ByteSwap_Rx_RES_CTRL_16);                         /* Arming the audio in EP if it is not zero bandwidth alt setting */            if (altSetting[AUDIO_IN_INTERFACE_INDEX]!= ALT_SETTING_ZERO_BANDWIDTH &&                (CY_GET_REG8(USBFS_SIE_EP1_CR0_PTR + ((AUDIO_IN_ENDPOINT - USBFS_EP1) << USBFS_EPX_CNTX_ADDR_SHIFT)) & USBFS_MODE_MASK)                                                                                         == USBFS_MODE_NAK_IN_OUT)            {                /* Init DMA configurations for audio IN EP */                  inCnt = IN_AUDIOMAXPKT;                USBFS_LoadInEP(AUDIO_IN_ENDPOINT, &inRam[0], inCnt);                /* Pre-arm first audio IN request */

 /******************************************************************************* * Function Name: PWM_3_ReadStatusRegister ******************************************************************************** * * Summary: *  This function returns the current state of the status register. * * Parameters: *  None * * Return: *  uint8 : Current status register value. The status register bits are: *  [7:6] : Unused(0) *  [5]   : Kill event output *  [4]   : FIFO not empty *  [3]   : FIFO full *  [2]   : Terminal count *  [1]   : Compare output 2 *  [0]   : Compare output 1 * *******************************************************************************/ uint8 PWM_3_ReadStatusRegister(void)  {     return (CY_GET_REG8(PWM_3_STATUS_PTR)); }

 /******************************************************************************* * Function Name: PWM_3_ReadCompare2 ******************************************************************************** * * Summary: *  Reads the compare value for the compare2 output. * * Parameters: *  None * * Return: *  uint8/uint16: Current compare value. * *******************************************************************************/ uint8 PWM_3_ReadCompare2(void)  {     return (CY_GET_REG8(PWM_3_COMPARE2_LSB_PTR)); }

/******************************************************************************** FUNCTION NAME:   PrISM_2_ReadSeed********************************************************************************** Summary:*  Reads the PrISM Seed register.** Parameters:*  None.** Return:*  Current Period register value.********************************************************************************/uint8 PrISM_2_ReadSeed(void) {    return( CY_GET_REG8(PrISM_2_SEED_PTR) );}

/******************************************************************************** FUNCTION NAME:   PrISM_2_ReadPulse1********************************************************************************** Summary:*  Reads the PrISM Pulse Density1 register.** Parameters:*  None.** Return:*  Pulse Density1 register value.********************************************************************************/uint8 PrISM_2_ReadPulse1(void) {    return( CY_GET_REG8(PrISM_2_DENSITY1_PTR) );}

/******************************************************************************** Function Name: pwm_ReadKillTime********************************************************************************** Summary:*  Reads the kill time value used by the hardware when the Kill Mode is set*  to Minimum Time.** Parameters:*  None** Return:*  uint8: The current Minimum Time kill counts********************************************************************************/uint8 pwm_ReadKillTime(void){    return (CY_GET_REG8(pwm_KILLMODEMINTIME_PTR));}

/******************************************************************************** FUNCTION NAME:   RedGreenPrISM_ReadPolynomial********************************************************************************** Summary:*  Reads the PrISM polynomial.** Parameters:*  None.** Return:*  PrISM polynomial.********************************************************************************/uint8 RedGreenPrISM_ReadPolynomial(void){    return( CY_GET_REG8(RedGreenPrISM_POLYNOM_PTR) );}

    /*******************************************************************************    * Function Name: PWM_BC_ReadCompare1    ********************************************************************************    *     * Summary:    *  Reads the compare value for the compare1 output.    *    * Parameters:      *  None    *    * Return:     *  uint8/uint16: Current compare value.    *    *******************************************************************************/      uint8 PWM_BC_ReadCompare1(void)     {		return (CY_GET_REG8(PWM_BC_COMPARE1_LSB_PTR));    }

/******************************************************************************** Function Name: MainTimer_SoftwareCapture********************************************************************************** Summary:*  This function forces a capture independent of the capture signal.** Parameters:*  void** Return:*  void** Side Effects:*  An existing hardware capture could be overwritten.** Reentrant*  Yes********************************************************************************/void MainTimer_SoftwareCapture(void) {    /* Generate a software capture by reading the counter register */    CY_GET_REG8(MainTimer_COUNTER_LSB_PTR);    /* Capture Data is now in the FIFO */}

/******************************************************************************** Function Name: hallTickCounter_ReadCompare********************************************************************************* Summary:* Returns the compare value.** Parameters:  *  void:** Return: *  (uint8) Present compare value.********************************************************************************/uint8 hallTickCounter_ReadCompare(void) {    return (CY_GET_REG8(hallTickCounter_COMPARE_LSB_PTR));}

//.........这里部分代码省略.........#ifdef SPECIAL_EDITION    disp_str("Calibration Edition",19,(64-57),64-6,FONT6X6);#else    disp_str("Open Devices",12,(64-36),64-6,FONT6X6);#endif    FB_update();        GPIO_Init();    DummyLoad_Init();    USBMux_Init();    I2C_Init();    PWM_Init();    ADC_Init();        uint16_t ctr=0;        for(;;)    {        char buffah[22];        uint8_t num;        float vbatvolt,vbatcur,vbusvolt,vbuscur;                I2C_Work();        vbatvolt=(float)I2C_Get_VBAT_VoltAvg() * 0.001f;        vbatcur=I2C_Get_VBAT_CurAvg();        PWM_Work(I2C_Get_VBAT_Volt(),I2C_Get_VBAT_CurRaw());        DummyLoad_Work(I2C_Get_VBAT_Volt());                ADC_Work();        uint8_t vrefok = ADC_VtargetValid();        static uint8_t oldvrefok = 2;                if( vrefok != oldvrefok ) {            if( vrefok ) {                CyPins_ClearPin(LED_Vref_0);                GPIO_SetTXDrive( 1 );            } else {                CyPins_SetPin(LED_Vref_0);                GPIO_SetTXDrive( 0 );                SIORefGen_SetValue(62); // Default 1V ref            }            oldvrefok = vrefok;        }        if(ctr == 0) {            vbusvolt=(float)I2C_Get_VBUS_Volt() * 0.001f;            vbuscur=I2C_Get_VBUS_Cur();            USBMux_UpdateMeasurements(vbusvolt,vbuscur);                        num = snprintf(buffah, sizeof(buffah), "VBAT %5.2fV %6.1fmA", vbatvolt,vbatcur);            disp_str(buffah, num, 0, 8, FONT6X6);            num = snprintf(buffah, sizeof(buffah), "VBUS %5.2fV %6.1fmA", vbusvolt,vbuscur);            disp_str(buffah, num, 0, 8+6, FONT6X6);            DummyLoad_ADCWork();            float loadcur = DummyLoad_GetCur();            float loadtemp = DummyLoad_GetTemp();            num = snprintf(buffah, sizeof(buffah), "Load %5.1f` %6.1fmA", loadtemp,loadcur);            disp_str(buffah, num, 0, 8+12, FONT6X6);            float tmp = ADC_GetVoltage(VBATSENSE);            num = snprintf(buffah, sizeof(buffah), "VBAT %5.2fV", tmp);            disp_str(buffah, num, 0, 8+18, FONT6X6);            tmp = ADC_GetVoltage(USB2SENSE);            num = snprintf(buffah, sizeof(buffah), "USB2 %5.2fV", tmp);            disp_str(buffah, num, 0, 8+24, FONT6X6);            tmp = ADC_GetVoltage(USB3SENSE);            num = snprintf(buffah, sizeof(buffah), "USB3 %5.2fV", tmp);            disp_str(buffah, num, 0, 8+30, FONT6X6);            tmp = ADC_GetVoltage(VTARGETSENSE);            if( tmp > 4.5f ) { // Assume 5V, disable regulated output                CY_SET_REG8(DTMS__SIO_CFG, (CY_GET_REG8(DTMS__SIO_CFG) & 0xcf) | 0x20);                CY_SET_REG8(DTMS__SIO_DIFF, (CY_GET_REG8(DTMS__SIO_DIFF) & 0xcf) | 0x00);                CY_SET_REG8(DTMS__SIO_HYST_EN, (CY_GET_REG8(DTMS__SIO_HYST_EN) & 0xcf) | 0x00);            } else if( tmp > 0.89f ) {                float val = tmp * 255.0f / 4.096f;                if(val > 255.0f) val = 255.0f;                SIORefGen_SetValue((uint8_t)val);                CY_SET_REG8(DTMS__SIO_CFG, (CY_GET_REG8(DTMS__SIO_CFG) & 0xcf) | 0x30); // Regulated output buffer                CY_SET_REG8(DTMS__SIO_DIFF, (CY_GET_REG8(DTMS__SIO_DIFF) & 0xcf) | 0x20);                CY_SET_REG8(DTMS__SIO_HYST_EN, (CY_GET_REG8(DTMS__SIO_HYST_EN) & 0xcf) | 0x20);            }            num = snprintf(buffah, sizeof(buffah), "VTGT %5.2fV", tmp);            disp_str(buffah, num, 0, 8+36, FONT6X6);            FB_update();            UpdateCtrl();            ctr=256;        } else {            ctr--;        }        USB_Work();    }}

/******************************************************************************** FUNCTION NAME:   LED1_ReadPulse1********************************************************************************** Summary:*  Reads the PrISM Pulse Density1 register.** Parameters:*  None.** Return:*  Pulse Density1 register value.********************************************************************************/uint8 LED1_ReadPulse1(void) {    return( CY_GET_REG8(LED1_DENSITY1_PTR) );}

/******************************************************************************** FUNCTION NAME:   LED1_ReadPolynomial********************************************************************************** Summary:*  Reads the PrISM polynomial.** Parameters:*  None.** Return:*  PrISM polynomial.********************************************************************************/uint8 LED1_ReadPolynomial(void) {    return( CY_GET_REG8(LED1_POLYNOM_PTR) );}

/******************************************************************************** FUNCTION NAME:   LED1_ReadSeed********************************************************************************** Summary:*  Reads the PrISM Seed register.** Parameters:*  None.** Return:*  Current Period register value.********************************************************************************/uint8 LED1_ReadSeed(void) {    return( CY_GET_REG8(LED1_SEED_PTR) );}

/******************************************************************************** Function Name: pwm_ReadCapture********************************************************************************** Summary:*  Reads the capture value from the capture FIFO.** Parameters:*  None** Return:*  uint8/uint16: The current capture value********************************************************************************/uint8 pwm_ReadCapture(void){    return (CY_GET_REG8(pwm_CAPTURE_LSB_PTR));}

/******************************************************************************** Function Name: Counter_reset_gen_ReadCompare********************************************************************************* Summary:* Returns the compare value.** Parameters:  *  void:** Return: *  (uint8) Present compare value.********************************************************************************/uint8 Counter_reset_gen_ReadCompare(void) {    return (CY_GET_REG8(Counter_reset_gen_COMPARE_LSB_PTR));}

/******************************************************************************** Function Name: pwm_ReadCompare2********************************************************************************** Summary:*  Reads the compare value for the compare2 output.** Parameters:*  None** Return:*  uint8/uint16: Current compare value.********************************************************************************/uint8 pwm_ReadCompare2(void){    return (CY_GET_REG8(pwm_COMPARE2_LSB_PTR));}

 /******************************************************************************* * Function Name: CsBtns_PWM_ReadStatusRegister ******************************************************************************** * * Summary: *  This function returns the current state of the status register. * * Parameters: *  None * * Return: *  uint8 : Current status register value. The status register bits are: *  [7:6] : Unused(0) *  [5]   : Kill event output *  [4]   : FIFO not empty *  [3]   : FIFO full *  [2]   : Terminal count *  [1]   : Compare output 2 *  [0]   : Compare output 1 * *******************************************************************************/ uint8 CsBtns_PWM_ReadStatusRegister(void)  {     return (CY_GET_REG8(CsBtns_PWM_STATUS_PTR)); }

/******************************************************************************** FUNCTION NAME:   RedGreenPrISM_ReadSeed********************************************************************************** Summary:*  Reads the PrISM Seed register.** Parameters:*  None.** Return:*  Current Period register value.********************************************************************************/uint8 RedGreenPrISM_ReadSeed(void){    return( CY_GET_REG8(RedGreenPrISM_SEED_PTR) );}

 /******************************************************************************* * Function Name: CsBtns_PWM_ReadKillTime ******************************************************************************** * * Summary: *  Reads the kill time value used by the hardware when the Kill Mode is set *  to Minimum Time. * * Parameters: *  None * * Return: *  uint8: The current Minimum Time kill counts * *******************************************************************************/ uint8 CsBtns_PWM_ReadKillTime(void)  {     return (CY_GET_REG8(CsBtns_PWM_KILLMODEMINTIME_PTR)); }

/******************************************************************************** FUNCTION NAME:   RedGreenPrISM_ReadPulse1********************************************************************************** Summary:*  Reads the PrISM Pulse Density1 register.** Parameters:*  None.** Return:*  Pulse Density1 register value.********************************************************************************/uint8 RedGreenPrISM_ReadPulse1(void){    return( CY_GET_REG8(RedGreenPrISM_DENSITY1_PTR) );}

/******************************************************************************** FUNCTION NAME:   PrISM_1_ReadPulse0********************************************************************************** Summary:*  Reads the PrISM Pulse Density0 register.** Parameters:*  None.** Return:*  Pulse Density0 register value.********************************************************************************/uint8 PrISM_1_ReadPulse0(void) {    return( CY_GET_REG8(PrISM_1_DENSITY0_PTR) );}

/******************************************************************************** FUNCTION NAME:   PrISM_2_ReadPolynomial********************************************************************************** Summary:*  Reads the PrISM polynomial.** Parameters:*  None.** Return:*  PrISM polynomial.********************************************************************************/uint8 PrISM_2_ReadPolynomial(void) {    return( CY_GET_REG8(PrISM_2_POLYNOM_PTR) );}

void cyfitter_cfg(void){#ifdef CYGlobalIntDisable	/* Disable interrupts by default. Let user enable if/when they want. */	CYGlobalIntDisable#endif	/* Enable/Disable Debug functionality based on settings from System DWR */	CY_SET_XTND_REG8((void CYFAR *)CYREG_MLOGIC_DEBUG, (CY_GET_XTND_REG8((void CYFAR *)CYREG_MLOGIC_DEBUG) | 0x04u));	{		CYPACKED typedef struct {			void CYFAR *address;			uint16 size;		} CYPACKED_ATTR cfg_memset_t;		static const cfg_memset_t CYCODE cfg_memset_list [] = {			/* address, size */			{(void CYFAR *)(CYREG_TMR0_CFG0), 12u},			{(void CYFAR *)(CYREG_PRT0_DR), 32u},			{(void CYFAR *)(CYREG_PRT3_DR), 32u},			{(void CYFAR *)(CYREG_PRT12_DR), 16u},			{(void CYFAR *)(CYDEV_UCFG_B0_P0_U0_BASE), 4096u},			{(void CYFAR *)(CYDEV_UCFG_B1_P2_U0_BASE), 2048u},			{(void CYFAR *)(CYDEV_UCFG_DSI0_BASE), 2560u},			{(void CYFAR *)(CYDEV_UCFG_DSI12_BASE), 512u},			{(void CYFAR *)(CYREG_BCTL0_MDCLK_EN), 32u},		};		uint8 CYDATA i;		/* Zero out critical memory blocks before beginning configuration */		for (i = 0u; i < (sizeof(cfg_memset_list)/sizeof(cfg_memset_list[0])); i++)		{			const cfg_memset_t CYCODE * CYDATA ms = &cfg_memset_list[i];			CYMEMZERO(ms->address, (size_t)(uint32)(ms->size));		}		cfg_write_bytes32(cy_cfg_addr_table, cy_cfg_data_table);		/* Perform normal device configuration. Order is not critical for these items. */		CY_SET_XTND_REG16((void CYFAR *)(CYREG_LUT0_CR), 0x0003u);		CY_SET_XTND_REG16((void CYFAR *)(CYREG_LUT1_CR), 0x0103u);		CY_SET_XTND_REG16((void CYFAR *)(CYREG_LUT3_CR), 0x0303u);		/* Enable digital routing */		CY_SET_XTND_REG8((void CYFAR *)CYREG_BCTL0_BANK_CTL, CY_GET_XTND_REG8((void CYFAR *)CYREG_BCTL0_BANK_CTL) | 0x02u);		CY_SET_XTND_REG8((void CYFAR *)CYREG_BCTL1_BANK_CTL, CY_GET_XTND_REG8((void CYFAR *)CYREG_BCTL1_BANK_CTL) | 0x02u);		/* Enable UDB array */		CY_SET_XTND_REG8((void CYFAR *)CYREG_PM_ACT_CFG0, CY_GET_XTND_REG8((void CYFAR *)CYREG_PM_ACT_CFG0) | 0x40u);		CY_SET_XTND_REG8((void CYFAR *)CYREG_PM_AVAIL_CR2, CY_GET_XTND_REG8((void CYFAR *)CYREG_PM_AVAIL_CR2) | 0x10u);	}	/* Perform second pass device configuration. These items must be configured in specific order after the regular configuration is done. */	CYCONFIGCPY((void CYFAR *)(CYREG_PRT15_DR), (const void CYFAR *)(BS_IOPINS0_8_VAL), 10u);	CYCONFIGCPY((void CYFAR *)(CYREG_PRT2_DR), (const void CYFAR *)(BS_IOPINS0_2_VAL), 10u);	CYCONFIGCPY((void CYFAR *)(CYREG_PRT5_DM0), (const void CYFAR *)(BS_IOPINS0_5_VAL), 8u);	CYCONFIGCPY((void CYFAR *)(CYREG_PRT6_DR), (const void CYFAR *)(BS_IOPINS0_6_VAL), 10u);	/* Switch Boost to the precision bandgap reference from its internal reference */	CY_SET_REG8((void CYXDATA *)CYREG_BOOST_CR2, (CY_GET_REG8((void CYXDATA *)CYREG_BOOST_CR2) | 0x08u));	/* Set Flash Cycles based on max possible frequency in case a glitch occurs during ClockSetup(). */	CY_SET_XTND_REG8((void CYFAR *)(CYREG_CACHE_CC_CTL), (((CYDEV_INSTRUCT_CACHE_ENABLED) != 0) ? 0x01u : 0x00u));	/* Setup clocks based on selections from Clock DWR */	ClockSetup();	/* Set Flash Cycles based on newly configured 12.00MHz Bus Clock. */	CY_SET_XTND_REG8((void CYFAR *)(CYREG_CACHE_CC_CTL), (((CYDEV_INSTRUCT_CACHE_ENABLED) != 0) ? 0x41u : 0x40u));	CY_SET_XTND_REG8((void CYFAR *)(CYREG_PANTHER_WAITPIPE), 0x01u);	/* Perform basic analog initialization to defaults */	AnalogSetDefault();	/* Configure alternate active mode */	CYCONFIGCPY((void CYFAR *)CYDEV_PM_STBY_BASE, (const void CYFAR *)CYDEV_PM_ACT_BASE, 14u);}

/******************************************************************************** Function Name: USBUART_1_DispatchHIDClassRqst********************************************************************************** Summary:*  This routine dispatches class requests** Parameters:*  None.** Return:*  requestHandled** Reentrant:*  No.********************************************************************************/uint8 USBUART_1_DispatchHIDClassRqst(void) {    uint8 requestHandled = USBUART_1_FALSE;    uint8 interfaceNumber;    interfaceNumber = CY_GET_REG8(USBUART_1_wIndexLo);    if ((CY_GET_REG8(USBUART_1_bmRequestType) & USBUART_1_RQST_DIR_MASK) == USBUART_1_RQST_DIR_D2H)    {   /* Control Read */        switch (CY_GET_REG8(USBUART_1_bRequest))        {            case USBUART_1_GET_DESCRIPTOR:                if (CY_GET_REG8(USBUART_1_wValueHi) == USBUART_1_DESCR_HID_CLASS)                {                    USBUART_1_FindHidClassDecriptor();                    if (USBUART_1_currentTD.count != 0u)                    {                        requestHandled = USBUART_1_InitControlRead();                    }                }                else if (CY_GET_REG8(USBUART_1_wValueHi) == USBUART_1_DESCR_HID_REPORT)                {                    USBUART_1_FindReportDescriptor();                    if (USBUART_1_currentTD.count != 0u)                    {                        requestHandled = USBUART_1_InitControlRead();                    }                }                else                {   /* requestHandled is initialezed as FALSE by default */                }                break;            case USBUART_1_HID_GET_REPORT:                USBUART_1_FindReport();                if (USBUART_1_currentTD.count != 0u)                {                    requestHandled = USBUART_1_InitControlRead();                }                break;            case USBUART_1_HID_GET_IDLE:                /* This function does not support multiple reports per interface*/                /* Validate interfaceNumber and Report ID (should be 0) */                if( (interfaceNumber < USBUART_1_MAX_INTERFACES_NUMBER) &&                    (CY_GET_REG8(USBUART_1_wValueLo) == 0u ) ) /* Do not support Idle per Report ID */                {                    USBUART_1_currentTD.count = 1u;                    USBUART_1_currentTD.pData = &USBUART_1_hidIdleRate[interfaceNumber];                    requestHandled  = USBUART_1_InitControlRead();                }                break;            case USBUART_1_HID_GET_PROTOCOL:                /* Validate interfaceNumber */                if( interfaceNumber < USBUART_1_MAX_INTERFACES_NUMBER)                {                    USBUART_1_currentTD.count = 1u;                    USBUART_1_currentTD.pData = &USBUART_1_hidProtocol[interfaceNumber];                    requestHandled  = USBUART_1_InitControlRead();                }                break;            default:    /* requestHandled is initialized as FALSE by default */                break;        }    }    else if ((CY_GET_REG8(USBUART_1_bmRequestType) & USBUART_1_RQST_DIR_MASK) ==                                                                            USBUART_1_RQST_DIR_H2D)    {   /* Control Write */        switch (CY_GET_REG8(USBUART_1_bRequest))        {            case USBUART_1_HID_SET_REPORT:                USBUART_1_FindReport();                if (USBUART_1_currentTD.count != 0u)                {                    requestHandled = USBUART_1_InitControlWrite();                }                break;            case USBUART_1_HID_SET_IDLE:                /* This function does not support multiple reports per interface */                /* Validate interfaceNumber and Report ID (should be 0) */                if( (interfaceNumber < USBUART_1_MAX_INTERFACES_NUMBER) &&                    (CY_GET_REG8(USBUART_1_wValueLo) == 0u ) ) /* Do not support Idle per Report ID */                {                    USBUART_1_hidIdleRate[interfaceNumber] = CY_GET_REG8(USBUART_1_wValueHi);                    /* With regards to HID spec: "7.2.4 Set_Idle Request"//.........这里部分代码省略.........

/******************************************************************************** Function Name: USB_Bootloader_Suspend********************************************************************************** Summary:*  This function disables the USBFS block and prepares for power donwn mode.** Parameters:*  None.** Return:*   None.** Global variables:*  USB_Bootloader_backup.enable:  modified.** Reentrant:*  No.********************************************************************************/void USB_Bootloader_Suspend(void) {    uint8 enableInterrupts;    enableInterrupts = CyEnterCriticalSection();    if((CY_GET_REG8(USB_Bootloader_CR0_PTR) & USB_Bootloader_CR0_ENABLE) != 0u)    {   /* USB block is enabled */        USB_Bootloader_backup.enableState = 1u;        #if(USB_Bootloader_EP_MM != USB_Bootloader__EP_MANUAL)            USB_Bootloader_Stop_DMA(USB_Bootloader_MAX_EP);     /* Stop all DMAs */        #endif   /* End USB_Bootloader_EP_MM != USB_Bootloader__EP_MANUAL */        #if(CY_PSOC3_ES2 || CY_PSOC5_ES1)            /* Disable USBIO for TO3 */            USB_Bootloader_PM_AVAIL_CR_REG &= ~USB_Bootloader_PM_AVAIL_EN_FSUSBIO;        #endif /* End CY_PSOC3_ES2 || CY_PSOC5_ES1 */        /* Power Down Sequencing for USBIO for TO4*/        #if(CY_PSOC3_ES3 || CY_PSOC5_ES2)            /* Ensure USB transmit enable is low (USB_USBIO_CR0.ten). - Manual Transmission - Disabled */            USB_Bootloader_USBIO_CR0_REG &= ~USB_Bootloader_USBIO_CR0_TEN;            CyDelayUs(0);  /*~50ns delay */            /* Disable the USBIO by asserting PM.USB_CR0.fsusbio_pd_n(Inverted) and pd_pullup_hv(Inverted) high. */            USB_Bootloader_PM_USB_CR0_REG &= /                                    ~(USB_Bootloader_PM_USB_CR0_PD_N | USB_Bootloader_PM_USB_CR0_PD_PULLUP_N);         #endif /* End CY_PSOC3_ES3 || CY_PSOC5_ES2 */        /* Disable the SIE */        USB_Bootloader_CR0_REG &= ~USB_Bootloader_CR0_ENABLE;        #if(CY_PSOC3_ES3 || CY_PSOC5_ES2)            CyDelayUs(0);  /*~50ns delay */            /* Store mode and Disable VRegulator*/            USB_Bootloader_backup.mode = USB_Bootloader_CR1_REG & USB_Bootloader_CR1_REG_ENABLE;            USB_Bootloader_CR1_REG &= ~USB_Bootloader_CR1_REG_ENABLE;            CyDelayUs(1);  /* 0.5 us min delay */            /* Disable the USBIO reference by setting PM.USB_CR0.fsusbio_ref_en.*/            USB_Bootloader_PM_USB_CR0_REG &= ~USB_Bootloader_PM_USB_CR0_REF_EN;            /* Switch DP and DM terminals to GPIO mode and disconnect 1.5k pullup*/            USB_Bootloader_USBIO_CR1_REG |= USB_Bootloader_USBIO_CR1_IOMODE;        #endif /* End CY_PSOC3_ES3 || CY_PSOC5_ES2*/        /* Disable USB in ACT PM */        USB_Bootloader_PM_ACT_CFG_REG &= ~USB_Bootloader_PM_ACT_EN_FSUSB;        /* Disable USB block for Standby Power Mode */        USB_Bootloader_PM_STBY_CFG_REG &= ~USB_Bootloader_PM_STBY_EN_FSUSB;        CyDelayUs(1); /* min  0.5us delay required */    }    else    {        USB_Bootloader_backup.enableState = 0u;    }    CyExitCriticalSection(enableInterrupts);    /* Set the DP Interrupt for wake-up from sleep mode. */    #if(USB_Bootloader_DP_ISR_REMOVE == 0u)        CyIntSetVector(USB_Bootloader_DP_INTC_VECT_NUM,   USB_Bootloader_DP_ISR);        CyIntSetPriority(USB_Bootloader_DP_INTC_VECT_NUM, USB_Bootloader_DP_INTC_PRIOR);        CyIntClearPending(USB_Bootloader_DP_INTC_VECT_NUM);        CyIntEnable(USB_Bootloader_DP_INTC_VECT_NUM);    #endif /* End USB_Bootloader_DP_ISR_REMOVE */}

 /******************************************************************************* * Function Name: PWM_3_ReadCapture ******************************************************************************** * * Summary: *  Reads the capture value from the capture FIFO. * * Parameters: *  None * * Return: *  uint8/uint16: The current capture value * *******************************************************************************/ uint8 PWM_3_ReadCapture(void)  {     return (CY_GET_REG8(PWM_3_CAPTURE_LSB_PTR)); }

/******************************************************************************** Function Name: pwm_ReadStatusRegister********************************************************************************** Summary:*  This function returns the current state of the status register.** Parameters:*  None** Return:*  uint8 : Current status register value. The status register bits are:*  [7:6] : Unused(0)*  [5]   : Kill event output*  [4]   : FIFO not empty*  [3]   : FIFO full*  [2]   : Terminal count*  [1]   : Compare output 2*  [0]   : Compare output 1********************************************************************************/uint8 pwm_ReadStatusRegister(void){    return (CY_GET_REG8(pwm_STATUS_PTR));}

 /******************************************************************************* * Function Name: PWM_3_ReadKillTime ******************************************************************************** * * Summary: *  Reads the kill time value used by the hardware when the Kill Mode is set *  to Minimum Time. * * Parameters: *  None * * Return: *  uint8: The current Minimum Time kill counts * *******************************************************************************/ uint8 PWM_3_ReadKillTime(void)  {     return (CY_GET_REG8(PWM_3_KILLMODEMINTIME_PTR)); }

 /******************************************************************************* * Function Name: ChargeDelay_ReadKillTime ******************************************************************************** * * Summary: *  Reads the kill time value used by the hardware when the Kill Mode is set *  to Minimum Time. * * Parameters: *  None * * Return: *  uint8: The current Minimum Time kill counts * *******************************************************************************/ uint8 ChargeDelay_ReadKillTime(void)  {     return (CY_GET_REG8(ChargeDelay_KILLMODEMINTIME_PTR)); }