Example #1
0
/*******************************************************************************
* Function Name: USBFS_Resume
********************************************************************************
*
* Summary:
*  This function enables the USBFS block after power down mode.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
* Global variables:
*  USBFS_backup - checked.
*
* Reentrant:
*  No.
*
*******************************************************************************/
void USBFS_Resume(void) 
{
    uint8 enableInterrupts;
    enableInterrupts = CyEnterCriticalSection();

    if(USBFS_backup.enableState != 0u)
    {
        #if(USBFS_DP_ISR_REMOVE == 0u)
            CyIntDisable(USBFS_DP_INTC_VECT_NUM);
        #endif /*  USBFS_DP_ISR_REMOVE */

        /* Enable USB block */
        USBFS_PM_ACT_CFG_REG |= USBFS_PM_ACT_EN_FSUSB;
        /* Enable USB block for Standby Power Mode */
        USBFS_PM_STBY_CFG_REG |= USBFS_PM_STBY_EN_FSUSB;
        /* Enable core clock */
        USBFS_USB_CLK_EN_REG |= USBFS_USB_CLK_ENABLE;

        /* Enable the USBIO reference by setting PM.USB_CR0.fsusbio_ref_en.*/
        USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_REF_EN;
        /* The reference will be available ~40us after power restored */
        CyDelayUs(40u);
        /* Return VRegulator*/
        USBFS_CR1_REG |= USBFS_backup.mode;
        CyDelayUs(0u);  /*~50ns delay */
        /* Enable USBIO */
        USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_PD_N;
        CyDelayUs(2u);
        /* Set the USBIO pull-up enable */
        USBFS_PM_USB_CR0_REG |= USBFS_PM_USB_CR0_PD_PULLUP_N;

        /* Re-init Arbiter configuration for DMA transfers */
        #if(USBFS_EP_MM != USBFS__EP_MANUAL)
            /* Usb arb interrupt enable */
            USBFS_ARB_INT_EN_REG = USBFS_ARB_INT_MASK;
            #if(USBFS_EP_MM == USBFS__EP_DMAMANUAL)
                USBFS_ARB_CFG_REG = USBFS_ARB_CFG_MANUAL_DMA;
            #endif   /*  USBFS_EP_MM == USBFS__EP_DMAMANUAL */
            #if(USBFS_EP_MM == USBFS__EP_DMAAUTO)
                /*Set cfg cmplt this rises DMA request when the full configuration is done */
                USBFS_ARB_CFG_REG = USBFS_ARB_CFG_AUTO_DMA | USBFS_ARB_CFG_AUTO_MEM;
            #endif   /*  USBFS_EP_MM == USBFS__EP_DMAAUTO */
        #endif   /*  USBFS_EP_MM != USBFS__EP_MANUAL */

        /* STALL_IN_OUT */
        CY_SET_REG8(USBFS_EP0_CR_PTR, USBFS_MODE_STALL_IN_OUT);
        /* Enable the SIE with a last address */
        USBFS_CR0_REG |= USBFS_CR0_ENABLE;
        CyDelayCycles(1u);
        /* Finally, Enable d+ pullup and select iomode to USB mode*/
        CY_SET_REG8(USBFS_USBIO_CR1_PTR, USBFS_USBIO_CR1_USBPUEN);

        /* Restore USB register settings */
        USBFS_RestoreConfig();
    }

    CyExitCriticalSection(enableInterrupts);
}
Example #2
0
/*******************************************************************************
* Function Name: USBFS_Suspend
********************************************************************************
*
* Summary:
*  This function disables the USBFS block and prepares for power down mode.
*
* Parameters:
*  None.
*
* Return:
*   None.
*
* Global variables:
*  USBFS_backup.enable:  modified.
*
* Reentrant:
*  No.
*
*******************************************************************************/
void USBFS_Suspend(void) 
{
    uint8 enableInterrupts;
    enableInterrupts = CyEnterCriticalSection();

    if((CY_GET_REG8(USBFS_CR0_PTR) & USBFS_CR0_ENABLE) != 0u)
    {   /* USB block is enabled */
        USBFS_backup.enableState = 1u;

        #if(USBFS_EP_MM != USBFS__EP_MANUAL)
            USBFS_Stop_DMA(USBFS_MAX_EP);     /* Stop all DMAs */
        #endif   /*  USBFS_EP_MM != USBFS__EP_MANUAL */

        /* Ensure USB transmit enable is low (USB_USBIO_CR0.ten). - Manual Transmission - Disabled */
        USBFS_USBIO_CR0_REG &= (uint8)~USBFS_USBIO_CR0_TEN;
        CyDelayUs(0u);  /*~50ns delay */

        /* Disable the USBIO by asserting PM.USB_CR0.fsusbio_pd_n(Inverted) and pd_pullup_hv(Inverted) high. */
        USBFS_PM_USB_CR0_REG &=
                                (uint8)~(USBFS_PM_USB_CR0_PD_N | USBFS_PM_USB_CR0_PD_PULLUP_N);

        /* Disable the SIE */
        USBFS_CR0_REG &= (uint8)~USBFS_CR0_ENABLE;

        CyDelayUs(0u);  /* ~50ns delay */
        /* Store mode and Disable VRegulator*/
        USBFS_backup.mode = USBFS_CR1_REG & USBFS_CR1_REG_ENABLE;
        USBFS_CR1_REG &= (uint8)~USBFS_CR1_REG_ENABLE;

        CyDelayUs(1u);  /* 0.5 us min delay */
        /* Disable the USBIO reference by setting PM.USB_CR0.fsusbio_ref_en.*/
        USBFS_PM_USB_CR0_REG &= (uint8)~USBFS_PM_USB_CR0_REF_EN;

        /* Switch DP and DM terminals to GPIO mode and disconnect 1.5k pullup*/
        USBFS_USBIO_CR1_REG |= USBFS_USBIO_CR1_IOMODE;

        /* Disable USB in ACT PM */
        USBFS_PM_ACT_CFG_REG &= (uint8)~USBFS_PM_ACT_EN_FSUSB;
        /* Disable USB block for Standby Power Mode */
        USBFS_PM_STBY_CFG_REG &= (uint8)~USBFS_PM_STBY_EN_FSUSB;
        CyDelayUs(1u); /* min  0.5us delay required */

    }
    else
    {
        USBFS_backup.enableState = 0u;
    }
    
    CyExitCriticalSection(enableInterrupts);

    /* Set the DP Interrupt for wake-up from sleep mode. */
    #if(USBFS_DP_ISR_REMOVE == 0u)
        (void) CyIntSetVector(USBFS_DP_INTC_VECT_NUM, &USBFS_DP_ISR);
        CyIntSetPriority(USBFS_DP_INTC_VECT_NUM, USBFS_DP_INTC_PRIOR);
        CyIntClearPending(USBFS_DP_INTC_VECT_NUM);
        CyIntEnable(USBFS_DP_INTC_VECT_NUM);
    #endif /* (USBFS_DP_ISR_REMOVE == 0u) */
}
/*******************************************************************************
* Function Name: EzI2C_RestoreConfig
********************************************************************************
*
* Summary:
*  The Enable wakeup from Sleep Mode selection influences this function
*  implementation:
*   Unchecked: Restores the component non-retention configuration registers
*              to the state they were in before I2C_Sleep() or I2C_SaveConfig()
*              was called.
*   Checked:   Disables the backup regulator of the I2C hardware. Sets up the
*              regular component interrupt handler and generates the component
*              interrupt if it was wake up source to release the bus and
*              continue in-coming I2C transaction.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
* Global variables:
*  EzI2C_backup - the non-retention registers are restored from.
*
* Reentrant:
*  No.
*
* Side Effects:
*  Calling this function before EzI2C_SaveConfig() or
*  EzI2C_Sleep() may produce unexpected behavior.
*
*******************************************************************************/
void EzI2C_RestoreConfig(void) 
{
    uint8 intState;

    if (0u != (EzI2C_PWRSYS_CR1_I2C_BACKUP & EzI2C_PWRSYS_CR1_REG))
    /* Exit from Sleep */
    {
        /* Disable I2C backup regulator */
        intState = CyEnterCriticalSection();
        EzI2C_PWRSYS_CR1_REG &= (uint8) ~EzI2C_PWRSYS_CR1_I2C_BACKUP;
        CyExitCriticalSection(intState);
    }
    else /* Exit from Hibernate (bit is cleared) or wakeup disabled */
    {
    #if (EzI2C_WAKEUP_ENABLED)
        /* Disable power to I2C block before register restore */
        intState = CyEnterCriticalSection();
        EzI2C_PM_ACT_CFG_REG  &= (uint8) ~EzI2C_ACT_PWR_EN;
        EzI2C_PM_STBY_CFG_REG &= (uint8) ~EzI2C_STBY_PWR_EN;
        CyExitCriticalSection(intState);

        /* Enable component after restore complete */
        EzI2C_backup.enableState = EzI2C_ENABLED;
    #endif /* (EzI2C_WAKEUP_ENABLED) */

        /* Restore component registers: Hibernate disable power */
        EzI2C_CFG_REG     = EzI2C_backup.cfg;
        EzI2C_XCFG_REG    = EzI2C_backup.xcfg;
        EzI2C_ADDR_REG    = EzI2C_backup.adr;
        EzI2C_CLKDIV1_REG = EzI2C_backup.clkDiv1;
        EzI2C_CLKDIV2_REG = EzI2C_backup.clkDiv2;
    }

#if (EzI2C_WAKEUP_ENABLED)
    /* Set I2C interrupt to be pending if component is source of wake up */
    EzI2C_DisableInt();
    (void) CyIntSetVector(EzI2C_ISR_NUMBER, &EzI2C_ISR);
    if (0u != EzI2C_wakeupSource)
    {
        /* Generate interrupt to release I2C bus */
        (void) CyIntSetPending(EzI2C_ISR_NUMBER);
    }
    EzI2C_EnableInt();
#endif /* (EzI2C_WAKEUP_ENABLED) */
}
Example #4
0
/*******************************************************************************
* Function Name: Backlight_PWM_Stop
********************************************************************************
*
* Summary:
*  Disables the Backlight_PWM.
*
* Parameters:
*  None
*
* Return:
*  None
*
*******************************************************************************/
void Backlight_PWM_Stop(void)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    Backlight_PWM_BLOCK_CONTROL_REG &= (uint32)~Backlight_PWM_MASK;

    CyExitCriticalSection(enableInterrupts);
}
Example #5
0
/*******************************************************************************
* Function Name: Backlight_PWM_TriggerCommand
********************************************************************************
*
* Summary:
*  Triggers the designated command to occur on the designated TCPWM instances.
*  The mask can be used to apply this command simultaneously to more than one
*  instance.  This allows multiple TCPWM instances to be synchronized.
*
* Parameters:
*  mask: Combination of mask bits for each instance of the TCPWM that the
*        command should apply to.  This function from one instance can be used
*        to apply the command to any of the instances in the design.
*        The mask value for a specific instance is available with the MASK
*        define.
*  command: Enumerated command values. Capture command only applicable for
*           Timer/Counter with Capture and PWM modes.
*   Values:
*     - Backlight_PWM_CMD_CAPTURE    - Trigger Capture command
*     - Backlight_PWM_CMD_RELOAD     - Trigger Reload command
*     - Backlight_PWM_CMD_STOP       - Trigger Stop command
*     - Backlight_PWM_CMD_START      - Trigger Start command
*
* Return:
*  None
*
*******************************************************************************/
void Backlight_PWM_TriggerCommand(uint32 mask, uint32 command)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    Backlight_PWM_COMMAND_REG = ((uint32)(mask << command));

    CyExitCriticalSection(enableInterrupts);
}
Example #6
0
/*******************************************************************************
* Function Name: TILT_Stop
********************************************************************************
*
* Summary:
*  Disables the TILT.
*
* Parameters:
*  None
*
* Return:
*  None
*
*******************************************************************************/
void TILT_Stop(void)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    TILT_BLOCK_CONTROL_REG &= (uint32)~TILT_MASK;

    CyExitCriticalSection(enableInterrupts);
}
/*******************************************************************************
* Function Name: MessageReceived_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. Note calling MessageReceived_Start
*   or MessageReceived_StartEx will override any effect this method would 
*   have had. This method should only be called after MessageReceived_Start or 
*   MessageReceived_StartEx has been called. To set the initial
*   priority for the component use the cydwr file in the tool.
*
* Parameters:
*   priority: Priority of the interrupt. 0 - 3, 0 being the highest.
*
* Return:
*   None
*
*******************************************************************************/
void MessageReceived_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((MessageReceived__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *MessageReceived_INTC_PRIOR = (*MessageReceived_INTC_PRIOR & (uint32)(~MessageReceived__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
/*******************************************************************************
* Function Name: PhaseCounter_Intr_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling PhaseCounter_Intr_Start or PhaseCounter_Intr_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after PhaseCounter_Intr_Start or PhaseCounter_Intr_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void PhaseCounter_Intr_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((PhaseCounter_Intr__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *PhaseCounter_Intr_INTC_PRIOR = (*PhaseCounter_Intr_INTC_PRIOR & (uint32)(~PhaseCounter_Intr__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
/*******************************************************************************
* Function Name: start_int_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling start_int_Start or start_int_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after start_int_Start or start_int_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void start_int_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((start_int__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *start_int_INTC_PRIOR = (*start_int_INTC_PRIOR & (uint32)(~start_int__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #10
0
/*******************************************************************************
* Function Name: XBEE_RX_INT_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling XBEE_RX_INT_Start or XBEE_RX_INT_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after XBEE_RX_INT_Start or XBEE_RX_INT_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void XBEE_RX_INT_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((XBEE_RX_INT__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *XBEE_RX_INT_INTC_PRIOR = (*XBEE_RX_INT_INTC_PRIOR & (uint32)(~XBEE_RX_INT__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #11
0
void Tuner_RunTuner(void)
{
    uint8 interruptState;
    uint8 suspended = 0;
    uint16 command;
    uint16 previousCompleteBit; /* COMPLETE_BIT in tunerCmd at time of last send to tuner host */

    Tuner_SendBuffer();

    /* Handle suspend command to avoid deadlock later in CapSense_RunTuner */
    do 
    {
        Tuner_RefreshBuffer();
        interruptState = CyEnterCriticalSection();  /* Avoid ints between read and modify tunerCmd */
        command = CapSense_dsRam.tunerCmd;
        switch (command)
        {
            case CapSense_TU_CMD_SUSPEND_E:
                suspended = 1;
                CapSense_dsRam.tunerCmd |= CapSense_TU_CMD_COMPLETE_BIT;
                CyExitCriticalSection(interruptState); /* Enable ints during SendBuffer */
                Tuner_SendBuffer(); /* Send buffer with updated COMPLETE_BIT to tuner host */
                interruptState = CyEnterCriticalSection();
                break;
                
            case CapSense_TU_CMD_RESUME_E:    
            case CapSense_TU_CMD_RESTART_E:
            case CapSense_TU_CMD_RUN_SNR_TEST_E:
                suspended = 0;
                break;
                
            default:
                break;
        }
        CyExitCriticalSection(interruptState);
    } while (suspended); 

    previousCompleteBit = CapSense_dsRam.tunerCmd & CapSense_TU_CMD_COMPLETE_BIT;
    CapSense_RunTuner(); 
    
    if ( previousCompleteBit != (CapSense_dsRam.tunerCmd & CapSense_TU_CMD_COMPLETE_BIT) )
        Tuner_SendBuffer(); /* Send buffer with updated COMPLETE_BIT to tuner host */
}
Example #12
0
/*******************************************************************************
* Function Name: CYBLE_bless_isr_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling CYBLE_bless_isr_Start or CYBLE_bless_isr_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after CYBLE_bless_isr_Start or CYBLE_bless_isr_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void CYBLE_bless_isr_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((CYBLE_bless_isr__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *CYBLE_bless_isr_INTC_PRIOR = (*CYBLE_bless_isr_INTC_PRIOR & (uint32)(~CYBLE_bless_isr__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #13
0
    /*******************************************************************************
    * Function Name: I2S_DisableRx
    ********************************************************************************
    *
    * Summary:
    *  Disables the Rx direction of the I2S interface.
    *
    * Parameters:
    *  None.
    *
    * Return:
    *  None.
    *
    *******************************************************************************/
    void I2S_DisableRx(void) 
    {
        uint8 enableInterrupts;

        I2S_CONTROL_REG &= ((uint8) ~I2S_RX_EN);

        enableInterrupts = CyEnterCriticalSection();
        I2S_RX_STATUS_AUX_CONTROL_REG &= ((uint8) ~I2S_RX_INT_EN);
        CyExitCriticalSection(enableInterrupts);
    }
Example #14
0
/*******************************************************************************
* Function Name: I2S_Enable
********************************************************************************
*
* Summary:
*  Enables I2S interface.
*
* Parameters:
*  None.
*
* Return:
*  None.
*
*******************************************************************************/
void I2S_Enable(void) 
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();
    I2S_AUX_CONTROL_REG |= I2S_CNTR7_EN;
    CyExitCriticalSection(enableInterrupts);

    I2S_CONTROL_REG |= I2S_EN;
}
Example #15
0
/*******************************************************************************
* Function Name: Ramp_LED_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling Ramp_LED_Start or Ramp_LED_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after Ramp_LED_Start or Ramp_LED_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void Ramp_LED_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((Ramp_LED__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *Ramp_LED_INTC_PRIOR = (*Ramp_LED_INTC_PRIOR & (uint32)(~Ramp_LED__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #16
0
    /*******************************************************************************
    * Function Name: I2S_EnableRx
    ********************************************************************************
    *
    * Summary:
    *  Enables the Rx direction of the I2S interface.  At the next word
    *  select falling edge reception of data will begin.
    *
    * Parameters:
    *  None.
    *
    * Return:
    *  None.
    *
    *******************************************************************************/
    void I2S_EnableRx(void) 
    {
        uint8 enableInterrupts;

        I2S_CONTROL_REG |= I2S_RX_EN;

        enableInterrupts = CyEnterCriticalSection();
        I2S_RX_STATUS_AUX_CONTROL_REG |= I2S_RX_INT_EN;
        CyExitCriticalSection(enableInterrupts);
    }
Example #17
0
/*******************************************************************************
* Function Name: console_SCB_IRQ_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling console_SCB_IRQ_Start or console_SCB_IRQ_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after console_SCB_IRQ_Start or console_SCB_IRQ_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void console_SCB_IRQ_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((console_SCB_IRQ__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *console_SCB_IRQ_INTC_PRIOR = (*console_SCB_IRQ_INTC_PRIOR & (uint32)(~console_SCB_IRQ__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
/*******************************************************************************
* Function Name: isr_10ms_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling isr_10ms_Start or isr_10ms_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after isr_10ms_Start or isr_10ms_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void isr_10ms_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((isr_10ms__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *isr_10ms_INTC_PRIOR = (*isr_10ms_INTC_PRIOR & (uint32)(~isr_10ms__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
/*******************************************************************************
* Function Name: messageTimerInterrupt_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. Note calling messageTimerInterrupt_Start
*   or messageTimerInterrupt_StartEx will override any effect this method would 
*   have had. This method should only be called after messageTimerInterrupt_Start or 
*   messageTimerInterrupt_StartEx has been called. To set the initial
*   priority for the component use the cydwr file in the tool.
*
* Parameters:
*   priority: Priority of the interrupt. 0 - 3, 0 being the highest.
*
* Return:
*   None
*
*******************************************************************************/
void messageTimerInterrupt_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((messageTimerInterrupt__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *messageTimerInterrupt_INTC_PRIOR = (*messageTimerInterrupt_INTC_PRIOR & (uint32)(~messageTimerInterrupt__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #20
0
/*******************************************************************************
* Function Name: ADC_SAR_SEQ_IRQ_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling ADC_SAR_SEQ_IRQ_Start or ADC_SAR_SEQ_IRQ_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after ADC_SAR_SEQ_IRQ_Start or ADC_SAR_SEQ_IRQ_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void ADC_SAR_SEQ_IRQ_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((ADC_SAR_SEQ_IRQ__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *ADC_SAR_SEQ_IRQ_INTC_PRIOR = (*ADC_SAR_SEQ_IRQ_INTC_PRIOR & (uint32)(~ADC_SAR_SEQ_IRQ__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #21
0
/*******************************************************************************
* Function Name: StripLights_cisr_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling StripLights_cisr_Start or StripLights_cisr_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after StripLights_cisr_Start or StripLights_cisr_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void StripLights_cisr_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((StripLights_cisr__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *StripLights_cisr_INTC_PRIOR = (*StripLights_cisr_INTC_PRIOR & (uint32)(~StripLights_cisr__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #22
0
/*******************************************************************************
* Function Name: battery_charging_isr_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling battery_charging_isr_Start or battery_charging_isr_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after battery_charging_isr_Start or battery_charging_isr_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void battery_charging_isr_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((battery_charging_isr__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *battery_charging_isr_INTC_PRIOR = (*battery_charging_isr_INTC_PRIOR & (uint32)(~battery_charging_isr__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #23
0
/*******************************************************************************
* Function Name: Count7_Stop
********************************************************************************
*
* Summary:
*  Disables the software enable of the counter.
*
* Parameters:
*  None
*
* Return:
*  None
*
*******************************************************************************/
void Count7_Stop(void) 
{
    uint8 interruptState;

    interruptState = CyEnterCriticalSection();
    /* Clear the counter start bit in auxiliary control. */
    Count7_AUX_CONTROL_REG &= (uint8) ~((uint8) Count7_COUNTER_START);

    CyExitCriticalSection(interruptState);
}
Example #24
0
/*******************************************************************************
* Function Name: Button_ISR_SetPriority
********************************************************************************
*
* Summary:
*   Sets the Priority of the Interrupt. 
*
*   Note calling Button_ISR_Start or Button_ISR_StartEx will 
*   override any effect this API would have had. This API should only be called
*   after Button_ISR_Start or Button_ISR_StartEx has been called. 
*   To set the initial priority for the component, use the Design-Wide Resources
*   Interrupt Editor.
*
*   Note This API has no effect on Non-maskable interrupt NMI).
*
* Parameters:
*   priority: Priority of the interrupt, 0 being the highest priority
*             PSoC 3 and PSoC 5LP: Priority is from 0 to 7.
*             PSoC 4: Priority is from 0 to 3.
*
* Return:
*   None
*
*******************************************************************************/
void Button_ISR_SetPriority(uint8 priority)
{
	uint8 interruptState;
    uint32 priorityOffset = ((Button_ISR__INTC_NUMBER % 4u) * 8u) + 6u;
    
	interruptState = CyEnterCriticalSection();
    *Button_ISR_INTC_PRIOR = (*Button_ISR_INTC_PRIOR & (uint32)(~Button_ISR__INTC_PRIOR_MASK)) |
                                    ((uint32)priority << priorityOffset);
	CyExitCriticalSection(interruptState);
}
Example #25
0
/*******************************************************************************
* Function Name: Backlight_PWM_SetPWMInvert
********************************************************************************
*
* Summary:
*  Writes the bits that control whether the line and line_n outputs are
*  inverted from their normal output values.  This functionality is only
*  applicable to the three PWM modes.
*
* Parameters:
*  mask: Mask of outputs to invert.
*   Values:
*         - Backlight_PWM_INVERT_LINE   - Inverts the line output
*         - Backlight_PWM_INVERT_LINE_N - Inverts the line_n output
*
* Return:
*  None
*
*******************************************************************************/
void Backlight_PWM_SetPWMInvert(uint32 mask)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    Backlight_PWM_CONTROL_REG &= (uint32)~Backlight_PWM_INV_OUT_MASK;
    Backlight_PWM_CONTROL_REG |= mask;

    CyExitCriticalSection(enableInterrupts);
}
Example #26
0
/*******************************************************************************
* Function Name: Backlight_PWM_SetPrescaler
********************************************************************************
*
* Summary:
*  Sets the prescaler value that is applied to the clock input.  Not applicable
*  to PWM with dead time mode or Quadrature Decoder mode.
*
* Parameters:
*  prescaler: Prescaler divider value
*   Values:
*         - Backlight_PWM_PRESCALE_DIVBY1    - Divide by 1 (no prescaling)
*         - Backlight_PWM_PRESCALE_DIVBY2    - Divide by 2
*         - Backlight_PWM_PRESCALE_DIVBY4    - Divide by 4
*         - Backlight_PWM_PRESCALE_DIVBY8    - Divide by 8
*         - Backlight_PWM_PRESCALE_DIVBY16   - Divide by 16
*         - Backlight_PWM_PRESCALE_DIVBY32   - Divide by 32
*         - Backlight_PWM_PRESCALE_DIVBY64   - Divide by 64
*         - Backlight_PWM_PRESCALE_DIVBY128  - Divide by 128
*
* Return:
*  None
*
*******************************************************************************/
void Backlight_PWM_SetPrescaler(uint32 prescaler)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    Backlight_PWM_CONTROL_REG &= (uint32)~Backlight_PWM_PRESCALER_MASK;
    Backlight_PWM_CONTROL_REG |= prescaler;

    CyExitCriticalSection(enableInterrupts);
}
Example #27
0
/*******************************************************************************
* Function Name: CySpcStart
********************************************************************************
* Summary:
*  Starts the SPC.
*
* Parameters:
*  None
*
* Return:
*  None
*
*******************************************************************************/
void CySpcStart(void) 
{
    /* Save current global interrupt enable and disable it */
    uint8 interruptState = CyEnterCriticalSection();

    CY_SPC_PM_ACT_REG  |= PM_SPC_PM_EN;
    CY_SPC_PM_STBY_REG |= PM_SPC_PM_EN;

    /* Restore global interrupt enable state */
    CyExitCriticalSection(interruptState);
}
Example #28
0
/*******************************************************************************
* Function Name: Backlight_PWM_SetCaptureMode
********************************************************************************
*
* Summary:
*  Sets the capture trigger mode. For PWM mode this is the switch input.
*  This input is not applicable to the Timer/Counter without Capture and
*  Quadrature Decoder modes.
*
* Parameters:
*  triggerMode: Enumerated trigger mode value
*   Values:
*     - Backlight_PWM_TRIG_LEVEL     - Level
*     - Backlight_PWM_TRIG_RISING    - Rising edge
*     - Backlight_PWM_TRIG_FALLING   - Falling edge
*     - Backlight_PWM_TRIG_BOTH      - Both rising and falling edge
*
* Return:
*  None
*
*******************************************************************************/
void Backlight_PWM_SetCaptureMode(uint32 triggerMode)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    Backlight_PWM_TRIG_CONTROL1_REG &= (uint32)~Backlight_PWM_CAPTURE_MASK;
    Backlight_PWM_TRIG_CONTROL1_REG |= triggerMode;

    CyExitCriticalSection(enableInterrupts);
}
Example #29
0
/*******************************************************************************
* Function Name: Backlight_PWM_SetCompareSwap
********************************************************************************
*
* Summary:
*  Writes the register that controls whether the compare registers are
*  swapped. When enabled in Timer/Counter mode(without capture) the swap occurs
*  at a TC event. In PWM mode the swap occurs at the next TC event following
*  a hardware switch event.
*
* Parameters:
*  swapEnable
*   Values:
*     - 0 - Disable swap
*     - 1 - Enable swap
*
* Return:
*  None
*
*******************************************************************************/
void Backlight_PWM_SetCompareSwap(uint32 swapEnable)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    Backlight_PWM_CONTROL_REG &= (uint32)~Backlight_PWM_RELOAD_CC_MASK;
    Backlight_PWM_CONTROL_REG |= (swapEnable & Backlight_PWM_1BIT_MASK);

    CyExitCriticalSection(enableInterrupts);
}
Example #30
0
/*******************************************************************************
* Function Name: Backlight_PWM_SetCounterMode
********************************************************************************
*
* Summary:
*  Sets the counter mode.  Applicable to all modes except Quadrature Decoder
*  and PWM with pseudo random output.
*
* Parameters:
*  counterMode: Enumerated couner type values
*   Values:
*     - Backlight_PWM_COUNT_UP       - Counts up
*     - Backlight_PWM_COUNT_DOWN     - Counts down
*     - Backlight_PWM_COUNT_UPDOWN0  - Counts up and down. Terminal count
*                                         generated when counter reaches 0
*     - Backlight_PWM_COUNT_UPDOWN1  - Counts up and down. Terminal count
*                                         generated both when counter reaches 0
*                                         and period
*
* Return:
*  None
*
*******************************************************************************/
void Backlight_PWM_SetCounterMode(uint32 counterMode)
{
    uint8 enableInterrupts;

    enableInterrupts = CyEnterCriticalSection();

    Backlight_PWM_CONTROL_REG &= (uint32)~Backlight_PWM_UPDOWN_MASK;
    Backlight_PWM_CONTROL_REG |= counterMode;

    CyExitCriticalSection(enableInterrupts);
}