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

/******************************************************************************** Function Name: ShiftReg_1_RestoreConfig********************************************************************************** Summary:*  Restores Shift Register configuration.** Parameters:*  None.** Return:*  None.********************************************************************************/void ShiftReg_1_RestoreConfig(void) {    /* Restore tha data, saved by SaveConfig()function */    #if (CY_PSOC3_ES2 || CY_PSOC5_ES1)        CY_SET_REG16(ShiftReg_1_SHIFT_REG_LSB_PTR, ShiftReg_1_backup.saveSrA0Reg);            CY_SET_REG16(ShiftReg_1_SHIFT_REG_VALUE_LSB_PTR, ShiftReg_1_backup.saveSrA1Reg);            ShiftReg_1_SR_STATUS_MASK = ShiftReg_1_backup.saveSrIntMask;    #else            CY_SET_REG16(ShiftReg_1_SHIFT_REG_LSB_PTR, ShiftReg_1_backup.saveSrA0Reg);            CY_SET_REG16(ShiftReg_1_SHIFT_REG_VALUE_LSB_PTR, ShiftReg_1_backup.saveSrA1Reg);    #endif /*(CY_PSOC3_ES2 || CY_PSOC5_ES1)*/}

/******************************************************************************** Function Name: Timer_3_WriteCounter********************************************************************************** Summary:*  This funtion is used to set the counter to a specific value** Parameters:*  counter:  New counter value.** Return:*  void********************************************************************************/void Timer_3_WriteCounter(uint16 counter) /                                   {   #if(Timer_3_UsingFixedFunction)        /* This functionality is removed until a FixedFunction HW update to         * allow this register to be written         */        CY_SET_REG16(Timer_3_COUNTER_LSB_PTR, (uint16)counter);            #else        CY_SET_REG16(Timer_3_COUNTER_LSB_PTR, counter);    #endif /* Set Write Counter only for the UDB implementation (Write Counter not available in fixed function Timer */}

/******************************************************************************** Function Name: PWM_Counter_WriteCounter********************************************************************************* Summary:*   This funtion is used to set the counter to a specific value** Parameters:  *  counter:  New counter value. ** Return: *  void ********************************************************************************/void PWM_Counter_WriteCounter(uint16 counter) /                                   {    #if(PWM_Counter_UsingFixedFunction)        /* assert if block is already enabled */        CYASSERT (!(PWM_Counter_GLOBAL_ENABLE & PWM_Counter_BLOCK_EN_MASK));        /* If block is disabled, enable it and then write the counter */        PWM_Counter_GLOBAL_ENABLE |= PWM_Counter_BLOCK_EN_MASK;        CY_SET_REG16(PWM_Counter_COUNTER_LSB_PTR, (uint16)counter);        PWM_Counter_GLOBAL_ENABLE &= ~PWM_Counter_BLOCK_EN_MASK;    #else        CY_SET_REG16(PWM_Counter_COUNTER_LSB_PTR, counter);    #endif /* (PWM_Counter_UsingFixedFunction) */}

/******************************************************************************** Function Name: QuadDecoder_Cnt16_WriteCounter********************************************************************************* Summary:*   This funtion is used to set the counter to a specific value** Parameters:  *  counter:  New counter value. ** Return: *  void ********************************************************************************/void QuadDecoder_Cnt16_WriteCounter(uint16 counter) /                                   {    #if(QuadDecoder_Cnt16_UsingFixedFunction)        /* assert if block is already enabled */        CYASSERT (0u == (QuadDecoder_Cnt16_GLOBAL_ENABLE & QuadDecoder_Cnt16_BLOCK_EN_MASK));        /* If block is disabled, enable it and then write the counter */        QuadDecoder_Cnt16_GLOBAL_ENABLE |= QuadDecoder_Cnt16_BLOCK_EN_MASK;        CY_SET_REG16(QuadDecoder_Cnt16_COUNTER_LSB_PTR, (uint16)counter);        QuadDecoder_Cnt16_GLOBAL_ENABLE &= ((uint8)(~QuadDecoder_Cnt16_BLOCK_EN_MASK));    #else        CY_SET_REG16(QuadDecoder_Cnt16_COUNTER_LSB_PTR, counter);    #endif /* (QuadDecoder_Cnt16_UsingFixedFunction) */}

/******************************************************************************** Function Name: Counter_1_WriteCounter********************************************************************************* Summary:*   This funtion is used to set the counter to a specific value** Parameters:  *  counter:  New counter value. ** Return: *  void ********************************************************************************/void Counter_1_WriteCounter(uint16 counter) /                                   {    #if(Counter_1_UsingFixedFunction)        /* assert if block is already enabled */        CYASSERT (0u == (Counter_1_GLOBAL_ENABLE & Counter_1_BLOCK_EN_MASK));        /* If block is disabled, enable it and then write the counter */        Counter_1_GLOBAL_ENABLE |= Counter_1_BLOCK_EN_MASK;        CY_SET_REG16(Counter_1_COUNTER_LSB_PTR, (uint16)counter);        Counter_1_GLOBAL_ENABLE &= ((uint8)(~Counter_1_BLOCK_EN_MASK));    #else        CY_SET_REG16(Counter_1_COUNTER_LSB_PTR, counter);    #endif /* (Counter_1_UsingFixedFunction) */}

/******************************************************************************** Function Name: HeartbeatCounter_WritePeriod********************************************************************************* Summary:* Changes the period of the counter.  The new period * will be loaded the next time terminal count is detected.** Parameters:  *  period: (uint32) A value of 0 will result in*         the counter remaining at zero.  ** Return: *  void********************************************************************************/void HeartbeatCounter_WritePeriod(uint32 period) {    #if(HeartbeatCounter_UsingFixedFunction)        CY_SET_REG16(HeartbeatCounter_PERIOD_LSB_PTR,(uint16)period);    #else        CY_SET_REG32(HeartbeatCounter_PERIOD_LSB_PTR, period);    #endif /* (HeartbeatCounter_UsingFixedFunction) */}

    /*******************************************************************************    * Function Name: ChargeDelay_WriteCompare    ********************************************************************************    *    * Summary:    *  This funtion is used to change the compare1 value when the PWM is in Dither    *  mode. The compare output will reflect the new value on the next UDB clock.    *  The compare output will be driven high when the present counter value is    *  compared to the compare value based on the compare mode defined in    *  Dither Mode.    *    * Parameters:    *  compare:  New compare value.    *    * Return:    *  None    *    * Side Effects:    *  This function is only available if the PWM mode parameter is set to    *  Dither Mode, Center Aligned Mode or One Output Mode    *    *******************************************************************************/    void ChargeDelay_WriteCompare(uint8 compare) /                                           {        #if(ChargeDelay_UsingFixedFunction)            CY_SET_REG16(ChargeDelay_COMPARE1_LSB_PTR, (uint16)compare);        #else            CY_SET_REG8(ChargeDelay_COMPARE1_LSB_PTR, compare);        #endif /* (ChargeDelay_UsingFixedFunction) */        #if (ChargeDelay_PWMMode == ChargeDelay__B_PWM__DITHER)            #if(ChargeDelay_UsingFixedFunction)                CY_SET_REG16(ChargeDelay_COMPARE2_LSB_PTR, (uint16)(compare + 1u));            #else                CY_SET_REG8(ChargeDelay_COMPARE2_LSB_PTR, (compare + 1u));            #endif /* (ChargeDelay_UsingFixedFunction) */        #endif /* (ChargeDelay_PWMMode == ChargeDelay__B_PWM__DITHER) */    }

/******************************************************************************** Function Name: ChargeDelay_WritePeriod********************************************************************************** Summary:*  This function is used to change the period of the counter.  The new period*  will be loaded the next time terminal count is detected.** Parameters:*  period:  Period value. May be between 1 and (2^Resolution)-1.  A value of 0*           will result in the counter remaining at zero.** Return:*  None********************************************************************************/void ChargeDelay_WritePeriod(uint8 period) {    #if(ChargeDelay_UsingFixedFunction)        CY_SET_REG16(ChargeDelay_PERIOD_LSB_PTR, (uint16)period);    #else        CY_SET_REG8(ChargeDelay_PERIOD_LSB_PTR, period);    #endif /* (ChargeDelay_UsingFixedFunction) */}

/******************************************************************************** Function Name: hallTickCounter_WritePeriod********************************************************************************* Summary:* Changes the period of the counter.  The new period * will be loaded the next time terminal count is detected.** Parameters:  *  period: (uint8) A value of 0 will result in*         the counter remaining at zero.  ** Return: *  void********************************************************************************/void hallTickCounter_WritePeriod(uint8 period) {    #if(hallTickCounter_UsingFixedFunction)        CY_SET_REG16(hallTickCounter_PERIOD_LSB_PTR,(uint16)period);    #else        CY_SET_REG8(hallTickCounter_PERIOD_LSB_PTR, period);    #endif /* (hallTickCounter_UsingFixedFunction) */}

/******************************************************************************** Function Name: PWM_WriteCompare2********************************************************************************* * Summary:*  This funtion is used to change the compare value, for compare1 output.  *  The compare output will reflect the new value on the next UDB clock.  *  The compare output will be driven high when the present counter value is *  less than or less than or equal to the compare register, depending on the *  mode.** Parameters:  *  compare:  New compare value.  ** Return: *  void** Reentrant:*  Yes********************************************************************************/void PWM_WriteCompare2(uint8 compare) {    #if(PWM_UsingFixedFunction)        CY_SET_REG16(PWM_COMPARE2_LSB_PTR, compare);    #else        CY_SET_REG8(PWM_COMPARE2_LSB_PTR, compare);    #endif}

/******************************************************************************** Function Name: MotorPWM_WritePeriod********************************************************************************** Summary:*  This function is used to change the period of the counter.  The new period*  will be loaded the next time terminal count is detected.** Parameters:*  period:  Period value. May be between 1 and (2^Resolution)-1.  A value of 0*           will result in the counter remaining at zero.** Return:*  None********************************************************************************/void MotorPWM_WritePeriod(uint8 period) {    #if(MotorPWM_UsingFixedFunction)        CY_SET_REG16(MotorPWM_PERIOD_LSB_PTR, (uint16)period);    #else        CY_SET_REG8(MotorPWM_PERIOD_LSB_PTR, period);    #endif /* (MotorPWM_UsingFixedFunction) */}

/******************************************************************************** Function Name: PWM_3_WritePeriod********************************************************************************** Summary:*  This function is used to change the period of the counter.  The new period*  will be loaded the next time terminal count is detected.** Parameters:*  period:  Period value. May be between 1 and (2^Resolution)-1.  A value of 0*           will result in the counter remaining at zero.** Return:*  None********************************************************************************/void PWM_3_WritePeriod(uint8 period) {    #if(PWM_3_UsingFixedFunction)        CY_SET_REG16(PWM_3_PERIOD_LSB_PTR, (uint16)period);    #else        CY_SET_REG8(PWM_3_PERIOD_LSB_PTR, period);    #endif /* (PWM_3_UsingFixedFunction) */}

    /*******************************************************************************    * Function Name: CsBtns_PWM_WriteCompare    ********************************************************************************    *    * Summary:    *  This funtion is used to change the compare1 value when the PWM is in Dither    *  mode. The compare output will reflect the new value on the next UDB clock.    *  The compare output will be driven high when the present counter value is    *  compared to the compare value based on the compare mode defined in    *  Dither Mode.    *    * Parameters:    *  compare:  New compare value.    *    * Return:    *  None    *    * Side Effects:    *  This function is only available if the PWM mode parameter is set to    *  Dither Mode, Center Aligned Mode or One Output Mode    *    *******************************************************************************/    void CsBtns_PWM_WriteCompare(uint16 compare) /                                           {        #if(CsBtns_PWM_UsingFixedFunction)            CY_SET_REG16(CsBtns_PWM_COMPARE1_LSB_PTR, (uint16)compare);        #else            CY_SET_REG16(CsBtns_PWM_COMPARE1_LSB_PTR, compare);        #endif /* (CsBtns_PWM_UsingFixedFunction) */        #if (CsBtns_PWM_PWMMode == CsBtns_PWM__B_PWM__DITHER)            #if(CsBtns_PWM_UsingFixedFunction)                CY_SET_REG16(CsBtns_PWM_COMPARE2_LSB_PTR, (uint16)(compare + 1u));            #else                CY_SET_REG16(CsBtns_PWM_COMPARE2_LSB_PTR, (compare + 1u));            #endif /* (CsBtns_PWM_UsingFixedFunction) */        #endif /* (CsBtns_PWM_PWMMode == CsBtns_PWM__B_PWM__DITHER) */    }

/******************************************************************************** Function Name: Phase_Counter_WritePeriod********************************************************************************* Summary:* Changes the period of the counter.  The new period * will be loaded the next time terminal count is detected.** Parameters:  *  period: (uint32) A value of 0 will result in*         the counter remaining at zero.  ** Return: *  void********************************************************************************/void Phase_Counter_WritePeriod(uint32 period) {    #if(Phase_Counter_UsingFixedFunction)        CY_SET_REG16(Phase_Counter_PERIOD_LSB_PTR,(uint16)period);    #else        CY_SET_REG32(Phase_Counter_PERIOD_LSB_PTR, period);    #endif /* (Phase_Counter_UsingFixedFunction) */}

/******************************************************************************** Function Name: pwm_WritePeriod********************************************************************************** Summary:*  This function is used to change the period of the counter.  The new period*  will be loaded the next time terminal count is detected.** Parameters:*  period:  Period value. May be between 1 and (2^Resolution)-1.  A value of 0*           will result in the counter remaining at zero.** Return:*  None********************************************************************************/void pwm_WritePeriod(uint8 period){#if(pwm_UsingFixedFunction)    CY_SET_REG16(pwm_PERIOD_LSB_PTR, (uint16)period);#else    CY_SET_REG8(pwm_PERIOD_LSB_PTR, period);#endif /* (pwm_UsingFixedFunction) */}

    /*******************************************************************************    * Function Name: PWM_3_WriteCompare    ********************************************************************************    *    * Summary:    *  This funtion is used to change the compare1 value when the PWM is in Dither    *  mode. The compare output will reflect the new value on the next UDB clock.    *  The compare output will be driven high when the present counter value is    *  compared to the compare value based on the compare mode defined in    *  Dither Mode.    *    * Parameters:    *  compare:  New compare value.    *    * Return:    *  None    *    * Side Effects:    *  This function is only available if the PWM mode parameter is set to    *  Dither Mode, Center Aligned Mode or One Output Mode    *    *******************************************************************************/    void PWM_3_WriteCompare(uint8 compare) /                                           {        #if(PWM_3_UsingFixedFunction)            CY_SET_REG16(PWM_3_COMPARE1_LSB_PTR, (uint16)compare);        #else            CY_SET_REG8(PWM_3_COMPARE1_LSB_PTR, compare);        #endif /* (PWM_3_UsingFixedFunction) */        #if (PWM_3_PWMMode == PWM_3__B_PWM__DITHER)            #if(PWM_3_UsingFixedFunction)                CY_SET_REG16(PWM_3_COMPARE2_LSB_PTR, (uint16)(compare + 1u));            #else                CY_SET_REG8(PWM_3_COMPARE2_LSB_PTR, (compare + 1u));            #endif /* (PWM_3_UsingFixedFunction) */        #endif /* (PWM_3_PWMMode == PWM_3__B_PWM__DITHER) */    }

/******************************************************************************** Function Name: Counter_reset_gen_WritePeriod********************************************************************************* Summary:* Changes the period of the counter.  The new period * will be loaded the next time terminal count is detected.** Parameters:  *  period: (uint8) A value of 0 will result in*         the counter remaining at zero.  ** Return: *  void********************************************************************************/void Counter_reset_gen_WritePeriod(uint8 period) {    #if(Counter_reset_gen_UsingFixedFunction)        CY_SET_REG16(Counter_reset_gen_PERIOD_LSB_PTR,(uint16)period);    #else        CY_SET_REG8(Counter_reset_gen_PERIOD_LSB_PTR, period);    #endif /* (Counter_reset_gen_UsingFixedFunction) */}

/******************************************************************************** Function Name: QuadDecoder_Cnt8_WritePeriod********************************************************************************* Summary:* Changes the period of the counter.  The new period * will be loaded the next time terminal count is detected.** Parameters:  *  period: (uint8) A value of 0 will result in*         the counter remaining at zero.  ** Return: *  void********************************************************************************/void QuadDecoder_Cnt8_WritePeriod(uint8 period) {    #if(QuadDecoder_Cnt8_UsingFixedFunction)        CY_SET_REG16(QuadDecoder_Cnt8_PERIOD_LSB_PTR,(uint16)period);    #else        CY_SET_REG8(QuadDecoder_Cnt8_PERIOD_LSB_PTR, period);    #endif /* (QuadDecoder_Cnt8_UsingFixedFunction) */}

/******************************************************************************** Function Name: PWM_WriteCounter********************************************************************************* * Summary:*  This function is used to change the counter value.** Parameters:  *  counter:  This value may be between 1 and (2^Resolution)-1.   ** Return: *  void** Reentrant:*  Yes********************************************************************************/void PWM_WriteCounter(uint8 counter) {    #if(PWM_UsingFixedFunction)        CY_SET_REG16(PWM_COUNTER_LSB_PTR, (uint16)counter);    #else        CY_SET_REG8(PWM_COUNTER_LSB_PTR, counter);    #endif}

/******************************************************************************** Function Name: Phase_Counter_WriteCompare********************************************************************************* Summary:* Changes the compare value.  The compare output will * reflect the new value on the next UDB clock.  The compare output will be * driven high when the present counter value compares true based on the * configured compare mode setting. ** Parameters:  *  Compare:  New compare value. ** Return: *  void********************************************************************************/void Phase_Counter_WriteCompare(uint32 compare) /                                   {    #if(Phase_Counter_UsingFixedFunction)        CY_SET_REG16(Phase_Counter_COMPARE_LSB_PTR, (uint16)compare);    #else        CY_SET_REG32(Phase_Counter_COMPARE_LSB_PTR, compare);    #endif /* (Phase_Counter_UsingFixedFunction) */}

/******************************************************************************** Function Name: TIMER_ThreadTimer_WritePeriod********************************************************************************** Summary:*  This function is used to change the period of the counter.  The new period*  will be loaded the next time terminal count is detected.** Parameters:*  period: This value may be between 1 and (2^Resolution)-1.  A value of 0 will*          result in the counter remaining at zero.** Return:*  void********************************************************************************/void TIMER_ThreadTimer_WritePeriod(uint8 period) {    #if(TIMER_ThreadTimer_UsingFixedFunction)        uint16 period_temp = (uint16)period;        CY_SET_REG16(TIMER_ThreadTimer_PERIOD_LSB_PTR, period_temp);    #else        CY_SET_REG8(TIMER_ThreadTimer_PERIOD_LSB_PTR, period);    #endif /*Write Period value with appropriate resolution suffix depending on UDB or fixed function implementation */}

/******************************************************************************** Function Name: AppDelay_WritePeriod********************************************************************************** Summary:*  This function is used to change the period of the counter.  The new period*  will be loaded the next time terminal count is detected.** Parameters:*  period: This value may be between 1 and (2^Resolution)-1.  A value of 0 will*          result in the counter remaining at zero.** Return:*  void********************************************************************************/void AppDelay_WritePeriod(uint32 period) {    #if(AppDelay_UsingFixedFunction)        uint16 period_temp = (uint16)period;        CY_SET_REG16(AppDelay_PERIOD_LSB_PTR, period_temp);    #else        CY_SET_REG24(AppDelay_PERIOD_LSB_PTR, period);    #endif /*Write Period value with appropriate resolution suffix depending on UDB or fixed function implementation */}

/******************************************************************************** Function Name: pwm_WriteCompare2********************************************************************************** Summary:*  This funtion is used to change the compare value, for compare1 output.*  The compare output will reflect the new value on the next UDB clock.*  The compare output will be driven high when the present counter value is*  less than or less than or equal to the compare register, depending on the*  mode.** Parameters:*  compare:  New compare value.** Return:*  None********************************************************************************/void pwm_WriteCompare2(uint8 compare) /{#if(pwm_UsingFixedFunction)    CY_SET_REG16(pwm_COMPARE2_LSB_PTR, compare);#else    CY_SET_REG8(pwm_COMPARE2_LSB_PTR, compare);#endif /* (pwm_UsingFixedFunction) */}

/******************************************************************************** Function Name: HeartbeatCounter_WriteCompare********************************************************************************* Summary:* Changes the compare value.  The compare output will * reflect the new value on the next UDB clock.  The compare output will be * driven high when the present counter value compares true based on the * configured compare mode setting. ** Parameters:  *  Compare:  New compare value. ** Return: *  void********************************************************************************/void HeartbeatCounter_WriteCompare(uint32 compare) /                                   {    #if(HeartbeatCounter_UsingFixedFunction)        CY_SET_REG16(HeartbeatCounter_COMPARE_LSB_PTR, (uint16)compare);    #else        CY_SET_REG32(HeartbeatCounter_COMPARE_LSB_PTR, compare);    #endif /* (HeartbeatCounter_UsingFixedFunction) */}

/******************************************************************************** Function Name: OSC2_Freq_Timer_1_WritePeriod********************************************************************************** Summary:*  This function is used to change the period of the counter.  The new period*  will be loaded the next time terminal count is detected.** Parameters:*  period: This value may be between 1 and (2^Resolution)-1.  A value of 0 will*          result in the counter remaining at zero.** Return:*  void********************************************************************************/void OSC2_Freq_Timer_1_WritePeriod(uint32 period) {    #if(OSC2_Freq_Timer_1_UsingFixedFunction)        uint16 period_temp = (uint16)period;        CY_SET_REG16(OSC2_Freq_Timer_1_PERIOD_LSB_PTR, period_temp);    #else        CY_SET_REG32(OSC2_Freq_Timer_1_PERIOD_LSB_PTR, period);    #endif /*Write Period value with appropriate resolution suffix depending on UDB or fixed function implementation */}

 /******************************************************************************* * Function Name: PWM_MOTOR2_WriteCompare2 ******************************************************************************** * * Summary: *  This funtion is used to change the compare value, for compare1 output. *  The compare output will reflect the new value on the next UDB clock. *  The compare output will be driven high when the present counter value is *  less than or less than or equal to the compare register, depending on the *  mode. * * Parameters: *  compare:  New compare value. * * Return: *  None * *******************************************************************************/ void PWM_MOTOR2_WriteCompare2(uint8 compare) /                                      {     #if(PWM_MOTOR2_UsingFixedFunction)         CY_SET_REG16(PWM_MOTOR2_COMPARE2_LSB_PTR, compare);     #else         CY_SET_REG8(PWM_MOTOR2_COMPARE2_LSB_PTR, compare);     #endif /* (PWM_MOTOR2_UsingFixedFunction) */ }

/******************************************************************************** Function Name: Counter_reset_gen_WriteCompare********************************************************************************* Summary:* Changes the compare value.  The compare output will * reflect the new value on the next UDB clock.  The compare output will be * driven high when the present counter value compares true based on the * configured compare mode setting. ** Parameters:  *  Compare:  New compare value. ** Return: *  void********************************************************************************/void Counter_reset_gen_WriteCompare(uint8 compare) /                                   {    #if(Counter_reset_gen_UsingFixedFunction)        CY_SET_REG16(Counter_reset_gen_COMPARE_LSB_PTR, (uint16)compare);    #else        CY_SET_REG8(Counter_reset_gen_COMPARE_LSB_PTR, compare);    #endif /* (Counter_reset_gen_UsingFixedFunction) */}

/******************************************************************************** Function Name: CyDmaTdSetAddress********************************************************************************** Summary:*  Sets the lower 16 bits of the source and destination addresses for this TD*  only.** Parameters:*  uint8 tdHandle:*   A handle previously returned by CyDmaTdAlloc().**  uint16 source:*   The lower 16 address bits of the source of the data transfer.**  uint16 destination:*   The lower 16 address bits of the destination of the data transfer.** Return:*  CYRET_SUCCESS if successful.*  CYRET_BAD_PARAM if tdHandle is invalid.********************************************************************************/cystatus CyDmaTdSetAddress(uint8 tdHandle, uint16 source, uint16 destination) {    cystatus status = CYRET_BAD_PARAM;    if(tdHandle < CY_DMA_NUMBEROF_TDS)    {        /* Set source address */        reg16 *convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD1[0];        CY_SET_REG16(convert, source);        /* Set destination address */        CY_SET_REG16((reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD1[2], destination);        status = CYRET_SUCCESS;    }    return(status);}

 /******************************************************************************* * Function Name: PWM_3_WriteCompare1 ******************************************************************************** * * Summary: *  This funtion is used to change the compare1 value.  The compare output will *  reflect the new value on the next UDB clock.  The compare output will be *  driven high when the present counter value is less than or less than or *  equal to the compare register, depending on the mode. * * Parameters: *  compare:  New compare value. * * Return: *  None * *******************************************************************************/ void PWM_3_WriteCompare1(uint8 compare) /                                      {     #if(PWM_3_UsingFixedFunction)         CY_SET_REG16(PWM_3_COMPARE1_LSB_PTR, (uint16)compare);     #else         CY_SET_REG8(PWM_3_COMPARE1_LSB_PTR, compare);     #endif /* (PWM_3_UsingFixedFunction) */ }

/******************************************************************************** Function Name: hallTickCounter_WriteCompare********************************************************************************* Summary:* Changes the compare value.  The compare output will * reflect the new value on the next UDB clock.  The compare output will be * driven high when the present counter value compares true based on the * configured compare mode setting. ** Parameters:  *  Compare:  New compare value. ** Return: *  void********************************************************************************/void hallTickCounter_WriteCompare(uint8 compare) /                                   {    #if(hallTickCounter_UsingFixedFunction)        CY_SET_REG16(hallTickCounter_COMPARE_LSB_PTR, (uint16)compare);    #else        CY_SET_REG8(hallTickCounter_COMPARE_LSB_PTR, compare);    #endif /* (hallTickCounter_UsingFixedFunction) */}