Clock System module responsible for setting up and manipulating MSP432's various clocking systems.
More...
Clock System module responsible for setting up and manipulating MSP432's various clocking systems.
Clock System (CS) Module Operation
The clock system module for DriverLib gives users the ability to fully configure and control all aspects of the MSP432L clock system. This includes initializing and maintaining the MCLK, ACLK, HSMCLK, SMCLK, and BCLK clock systems. Additionally, APIs exist for configuring connected crystal oscillators as well as configuring/manipulating the DCO and reference oscillator.
Timeout Parameters
For crystal configuration APIs (starting the LFXT and HFXT), a "timeout" API exists that will return control of execution back to the user application if a specified duration passes. The variable that is passed into these functions is a unit of time specified by how many "loop iterations" elapse before unsuccessful stabilization of the respected crystal. The API will attempt to check to see if there was a crystal fault, clear the crystal fault flag, and repeat the check until no fault exists. If the user calls the API with a specified timeout, the loop will only check the given number of loop iterations for a successfully stabilized crystal.
Custom DCO Frequency
NOTE: Tuning the DCO frequency is not supported on early version of the MSP432 silicon. While this feature will be added to the final release version of the MSP432 silicon, for pre-release silicon the DCO is restricted to use the pre-calibrated center frequencies provided by the CS_setDCOCenteredFrequency function.
For tuning the DCO frequency to a specific frequency, a convenient CS_setDCOFrequency function is provided to users. This function accepts any uint32_t frequency and automatically calculates the appropriate tuning parameters to get the DCO frequency as close as possible to the provided frequency. Note that with this function, floating point math is involved so if efficiency is a concern the user should enable the FPU using the FPU_enableModule function.
Specifying External Crystal Frequencies
MSP432 DriverLib has a variety of convenience functions for obtaining the specific frequency of a clock source ( such as CS_getMCLK ). If a clock source is sourced from an external crystal, the crystal frequency must be specified explicitly using the CS_setExternalClockSourceFrequency function. This function must be used prior to the getters for the clock source if an external crystal is used.
Programming Example
The DriverLib package contains a variety of different code examples that demonstrate the usage of the CS module. These code examples are accessible under the examples/ folder of the MSPWare release as well as through TI Resource Explorer if using Code Composer Studio. These code examples provide a comprehensive list of use cases as well as practical applications involving each module.
Below is a very brief code example showing how to start the external high frequency crystal and source MCLK from this crystal. An LED is configured as an output in this example as well. For a set of more detailed code examples, please refer to the code examples in the examples/ directory of the MSPWare release:
Referenced by CS_clearInterruptFlag(), CS_disableClockRequest(), CS_disableDCOExternalResistor(), CS_disableFaultCounter(), CS_disableInterrupt(), CS_enableClockRequest(), CS_enableDCOExternalResistor(), CS_enableFaultCounter(), CS_enableInterrupt(), CS_initClockSignal(), CS_resetFaultCounter(), CS_setDCOCenteredFrequency(), CS_setReferenceOscillatorFrequency(), CS_startFaultCounter(), CS_startHFXTWithTimeout(), and CS_startLFXTWithTimeout().
#define CS_ACLK_DIV_BITPOS 0x04 |
#define CS_MCLK_DIV_BITPOS 0x0C |
#define CS_SMCLK_DIV_BITPOS 0x00 |
#define CS_HSMCLK_DIV_BITPOS 0x08 |
#define CS_ACLK_SRC_BITPOS 0x08 |
#define CS_MCLK_SRC_BITPOS 0x00 |
#define CS_SMCLK_SRC_BITPOS 0x04 |
#define CS_HSMCLK_SRC_BITPOS 0x04 |
#define CS_REFO_32KHZ 0x00 |
#define CS_REFO_128KHZ 0x01 |
#define CS_VLOCLK_FREQUENCY 10000 |
#define CS_MODCLK_FREQUENCY 24000000 |
#define CS_HFXT_DRIVE0 CS_CTL2_HFXTDRIVE__0 |
#define CS_HFXT_DRIVE1 CS_CTL2_HFXTDRIVE__1 |
#define CS_12MHZ 12000000 |
#define CS_16MHZ 16000000 |
#define CS_24MHZ 24000000 |
#define CS_32MHZ 32000000 |
#define CS_40MHZ 40000000 |
#define CS_48MHZ 48000000 |
#define CS_HFXT_FAULT_COUNTER 0x01 |
#define CS_LFXT_FAULT_COUNTER 0x02 |
void CS_setExternalClockSourceFrequency |
( |
uint32_t |
lfxt_XT_CLK_frequency, |
|
|
uint32_t |
hfxt_XT_CLK_frequency |
|
) |
| |
This function sets the external clock sources LFXT and HFXT crystal oscillator frequency values. This function must be called if an external crystal LFXT or HFXT is used and the user intends to call CS_getSMCLK, CS_getMCLK, CS_getBCLK, CS_getHSMCLK, CS_getACLK and any of the HFXT oscillator control functions
- Parameters
-
lfxt_XT_CLK_frequency | is the LFXT crystal frequencies in Hz |
hfxt_XT_CLK_frequency | is the HFXT crystal frequencies in Hz |
- Returns
- None
void CS_initClockSignal |
( |
uint32_t |
selectedClockSignal, |
|
|
uint32_t |
clockSource, |
|
|
uint32_t |
clockSourceDivider |
|
) |
| |
This function initializes each of the clock signals. The user must ensure that this function is called for each clock signal. If not, the default state is assumed for the particular clock signal. Refer to DriverLib documentation for CS module or Device Family User's Guide for details of default clock signal states.
Note that this function is blocking and will wait on the appropriate bit to be set in the CSSTAT READY register to be set before setting the clock source
HFXTCLK is not available for BCLK or ACLK.
- Parameters
-
selectedClockSignal | Clock signal to initialize.
- CS_ACLK,
- CS_MCLK,
- CS_HSMCLK
- CS_SMCLK
- CS_BCLK [clockSourceDivider is ignored for this parameter]
|
clockSource | Clock source for the selectedClockSignal signal.
- CS_LFXTCLK_SELECT,
- CS_HFXTCLK_SELECT,
- CS_VLOCLK_SELECT, [Not available for BCLK]
- CS_DCOCLK_SELECT, [Not available for ACLK, BCLK]
- CS_REFOCLK_SELECT,
- CS_MODOSC_SELECT [Not available for ACLK, BCLK]
|
clockSourceDivider | - selected the clock divider to calculate clock signal from clock source. This parameter is ignored when setting BLCK. Valid values are:
- CS_CLOCK_DIVIDER_1,
- CS_CLOCK_DIVIDER_2,
- CS_CLOCK_DIVIDER_4,
- CS_CLOCK_DIVIDER_8,
- CS_CLOCK_DIVIDER_16,
- CS_CLOCK_DIVIDER_32,
- CS_CLOCK_DIVIDER_64,
- CS_CLOCK_DIVIDER_128
|
- Returns
- NONE
References ASSERT, CS_ACLK, CS_ACLK_DIV_BITPOS, CS_ACLK_SRC_BITPOS, CS_BCLK, CS_CTL1_DIVA__M, CS_CTL1_DIVHS__M, CS_CTL1_DIVM__M, CS_CTL1_DIVS__M, CS_CTL1_SELA__M, CS_CTL1_SELM__M, CS_CTL1_SELS__M, CS_DCOCLK_SELECT, CS_HFXTCLK_SELECT, CS_HSMCLK, CS_HSMCLK_DIV_BITPOS, CS_HSMCLK_SRC_BITPOS, CS_KEY, CS_LFXTCLK_SELECT, CS_MCLK, CS_MCLK_DIV_BITPOS, CS_MCLK_SRC_BITPOS, CS_MODOSC_SELECT, CS_REFOCLK_SELECT, CS_SMCLK, and CS_SMCLK_DIV_BITPOS.
void CS_startHFXT |
( |
bool |
bypassMode | ) |
|
Initializes the HFXT crystal oscillator, which supports crystal frequencies between 0 MHz and 48 MHz, depending on the selected drive strength. Loops until all oscillator fault flags are cleared, with no timeout. See the device-specific data sheet for appropriate drive settings. NOTE: User must call CS_setExternalClockSourceFrequency to set frequency of external clocks before calling this function.
- Parameters
-
bypassMode | When this variable is set, the oscillator will start in bypass mode and the signal can be generated by a digital square wave. |
- Returns
- NONE
References CS_startHFXTWithTimeout().
void CS_startHFXTWithTimeout |
( |
bool |
bypassMode, |
|
|
uint32_t |
timeout |
|
) |
| |
Initializes the HFXT crystal oscillator, which supports crystal frequencies between 0 MHz and 48 MHz, depending on the selected drive strength. Loops until all oscillator fault flags are cleared, with no timeout. See the device-specific data sheet for appropriate drive settings. NOTE: User must call CS_setExternalClockSourceFrequency to set frequency of external clocks before calling this function. This function has a timeout associated with stabilizing the oscillator.
- Parameters
-
bypassMode | When this variable is set, the oscillator will start in bypass mode and the signal can be generated by a digital square wave. |
timeout | is the count value that gets decremented every time the loop that clears oscillator fault flags gets executed. |
- Returns
- NONE
References CS_CTL2_HFXTFREQ__0, CS_CTL2_HFXTFREQ__M, CS_KEY, SYSCTL_CS_SRC, SysCtl_disableNMISource(), SysCtl_enableNMISource(), and SysCtl_getNMISourceStatus().
Referenced by CS_startHFXT().
void CS_startLFXT |
( |
uint32_t |
xtDrive | ) |
|
Initializes the LFXT crystal oscillator, which supports crystal frequencies up to 50kHz, depending on the selected drive strength. Loops until all oscillator fault flags are cleared, with no timeout. See the device-specific data sheet for appropriate drive settings. NOTE: User must call CS_setExternalClockSourceFrequency to set frequency of external clocks before calling this function.
- Parameters
-
xtDrive | is the target drive strength for the LFXT crystal oscillator. Valid values are:
- CS_LFXT_DRIVE0,
- CS_LFXT_DRIVE1,
- CS_LFXT_DRIVE2,
- CS_LFXT_DRIVE3, [Default Value]
- CS_LFXT_BYPASS
|
- Note
- When CS_LFXT_BYPASS is passed as a parameter the oscillator will start in bypass mode and the signal can be generated by a digital square wave.
- Returns
- NONE
References CS_startLFXTWithTimeout().
void CS_startLFXTWithTimeout |
( |
uint32_t |
xtDrive, |
|
|
uint32_t |
timeout |
|
) |
| |
Initializes the LFXT crystal oscillator, which supports crystal frequencies up to 50kHz, depending on the selected drive strength. Loops until all oscillator fault flags are cleared. See the device-specific data sheet for appropriate drive settings. NOTE: User must call CS_setExternalClockSourceFrequency to set frequency of external clocks before calling this function. This function has a timeout associated with stabilizing the oscillator.
- Parameters
-
xtDrive | is the target drive strength for the LFXT crystal oscillator. Valid values are:
- CS_LFXT_DRIVE0,
- CS_LFXT_DRIVE1,
- CS_LFXT_DRIVE2,
- CS_LFXT_DRIVE3,
- CS_LFXT_DRIVE4,
- CS_LFXT_DRIVE5,
- CS_LFXT_DRIVE6,
- CS_LFXT_DRIVE7, [Default Value]
- CS_LFXT_BYPASS
|
- Note
- When CS_LFXT_BYPASS is passed as a parameter the oscillator will start in bypass mode and the signal can be generated by a digital square wave.
- Parameters
-
timeout | is the count value that gets decremented every time the loop that clears oscillator fault flags gets executed. |
- Returns
- NONE
References ASSERT, CS_KEY, CS_LFXT_BYPASS, CS_LFXT_DRIVE0, CS_LFXT_DRIVE1, CS_LFXT_DRIVE2, CS_LFXT_DRIVE3, SYSCTL_CS_SRC, SysCtl_disableNMISource(), SysCtl_enableNMISource(), and SysCtl_getNMISourceStatus().
Referenced by CS_startLFXT().
void CS_setReferenceOscillatorFrequency |
( |
uint8_t |
referenceFrequency | ) |
|
Selects between the frequency of the internal REFO clock source
- Parameters
-
referenceFrequency | selects between the valid frequencies:
- CS_REFO_32KHZ,
- CS_REFO_128KHZ,
|
- Returns
- NONE
References ASSERT, CS_KEY, CS_REFO_128KHZ, and CS_REFO_32KHZ.
void CS_enableClockRequest |
( |
uint32_t |
selectClock | ) |
|
Enables conditional module requests
- Parameters
-
selectClock | selects specific request enables. Valid values are are a logical OR of the following values:
- CS_ACLK,
- CS_HSMCLK,
- CS_SMCLK,
- CS_MCLK
|
- Returns
- NONE
References ASSERT, CS_ACLK, CS_HSMCLK, CS_KEY, CS_MCLK, and CS_SMCLK.
void CS_disableClockRequest |
( |
uint32_t |
selectClock | ) |
|
Disables conditional module requests
- Parameters
-
selectClock | selects specific request disables. Valid values are are a logical OR of the following values:
- CS_ACLK,
- CS_HSMCLK,
- CS_SMCLK,
- CS_MCLK
|
- Returns
- NONE
References ASSERT, CS_ACLK, CS_HSMCLK, CS_KEY, CS_MCLK, and CS_SMCLK.
uint32_t CS_getACLK |
( |
void |
| ) |
|
uint32_t CS_getSMCLK |
( |
void |
| ) |
|
Get the current SMCLK frequency.
If a oscillator fault is set, the frequency returned will be based on the fail safe mechanism of CS module. The user of this API must ensure that CS_setExternalClockSourceFrequency API was invoked before in case LFXT or HFXT is being used.
- Returns
- Current SMCLK frequency in Hz
References CS_CTL1_DIVS__M, CS_CTL1_SELS__M, and CS_HSMCLK_SRC_BITPOS.
uint32_t CS_getMCLK |
( |
void |
| ) |
|
Get the current MCLK frequency.
If a oscillator fault is set, the frequency returned will be based on the fail safe mechanism of CS module. The user of this API must ensure that CS_setExternalClockSourceFrequency API was invoked before in case LFXT or HFXT is being used.
- Returns
- Current MCLK frequency in Hz
References CS_CTL1_DIVM__M, CS_CTL1_SELM__M, CS_MCLK_DIV_BITPOS, and CS_MCLK_SRC_BITPOS.
uint32_t CS_getBCLK |
( |
void |
| ) |
|
uint32_t CS_getHSMCLK |
( |
void |
| ) |
|
void CS_setDCOCenteredFrequency |
( |
uint32_t |
dcoFreq | ) |
|
Sets the centered frequency of DCO operation. Each frequency represents the centred frequency of a particular frequency range. Further tuning can be achieved by using the CS_tuneDCOFrequency function. Note that setting the nominal frequency will reset the tuning parameters.
- Parameters
-
dcoFreq | selects between the valid frequencies:
- CS_DCO_FREQUENCY_1_5, [1MHz to 2MHz]
- CS_DCO_FREQUENCY_3, [2MHz to 4MHz]
- CS_DCO_FREQUENCY_6, [4MHz to 8MHz]
- CS_DCO_FREQUENCY_12, [8MHz to 16MHz]
- CS_DCO_FREQUENCY_24, [16MHz to 32MHz]
- CS_DCO_FREQUENCY_48 [32MHz to 64MHz]
|
- Returns
- NONE
References ASSERT, CS_CTL0_DCORSEL__M, CS_DCO_FREQUENCY_12, CS_DCO_FREQUENCY_1_5, CS_DCO_FREQUENCY_24, CS_DCO_FREQUENCY_3, CS_DCO_FREQUENCY_48, CS_DCO_FREQUENCY_6, and CS_KEY.
void CS_tuneDCOFrequency |
( |
int16_t |
tuneParameter | ) |
|
Tunes the DCO to a specific frequency. Tuning of the DCO is based off of the following equation in the user's guide:
See the user's guide for more detailed information about DCO tuning.
- Note
- This function is not currently available on pre-release MSP432 devices. On early release versions of MSP432, the DCO calibration information has not been populated making the DCO only able to operate at the pre-calibrated centered frequencies accessible by the CS_setDCOCenteredFrequency function. While this function will be added on the final devices being released, for early silicon please default to the pre-calibrated DCO center frequencies.
- Parameters
-
tuneParameter | Tuning parameter in 2's Compliment representation. Can be negative or positive. |
- Returns
- NONE
void CS_enableDCOExternalResistor |
( |
void |
| ) |
|
Enables the external resistor for DCO operation
- Returns
- NONE
References CS_KEY.
void CS_disableDCOExternalResistor |
( |
void |
| ) |
|
Disables the external resistor for DCO operation
- Returns
- NONE
References CS_KEY.
void CS_setDCOExternalResistorCalibration |
( |
uint_fast8_t |
uiCalData | ) |
|
Sets the calibration value for the DCO when using the external resistor mode. This value is used for tuning the DCO to custom frequencies. By default, the value in the CS module is populated by the calibration data of the suggested external resistor (see device datasheet).
- Parameters
-
uiCalData | is the calibration data constant for the external resistor. |
- Returns
- None
uint32_t CS_getDCOFrequency |
( |
void |
| ) |
|
Gets the current tuned DCO frequency. If no tuning has been done, this returns the nominal DCO frequency of the current DCO range. Note that this function will grab any constant/calibration data from the DDDS table without any user interaction needed.
- Note
- This function uses floating point math to calculate the DCO tuning parameter. If efficiency is a concern, the user should use the FPU_enableModule function (if available) to enable the floating point co-processor.
- Returns
- Current DCO frequency in Hz
References __DDDS_BASE__, CS_DCOERCAL_DCO_FTRIM__M, and OFS_DDDS_CSDCOCONST.
void CS_setDCOFrequency |
( |
uint32_t |
dcoFrequency | ) |
|
Automatically sets/tunes the DCO to the given frequency. Any valid value up to (and including) 64Mhz can be given to this function and the API will do its best to determine the correct tuning parameter.
- Note
- This function is not currently available on pre-release MSP432 devices. On early release versions of MSP432, the DCO calibration information has not been populated making the DCO only able to operate at the pre-calibrated centered frequencies accessible by the CS_setDCOCenteredFrequency function. While this function will be added on the final devices being released, for early silicon please default to the pre-calibrated DCO center frequencies.
- Parameters
-
dcoFrequency | Frequency in Hz (1500000 - 64000000) that the user wants to set the DCO to. |
- Note
- This function uses floating point math to calculate the DCO tuning parameter. If efficiency is a concern, the user should use the FPU_enableModule function (if available) to enable the floating point co-processor.
- Returns
- None
void CS_enableFaultCounter |
( |
uint_fast8_t |
counterSelect | ) |
|
Enables the fault counter for the CS module. This function can enable either the HFXT fault counter or the LFXT fault counter.
- Parameters
-
counterSelect | selects the fault counter to enable
- CS_HFXT_FAULT_COUNTER
- CS_LFXT_FAULT_COUNTER
|
- Returns
- NONE
References ASSERT, CS_HFXT_FAULT_COUNTER, and CS_KEY.
void CS_disableFaultCounter |
( |
uint_fast8_t |
counterSelect | ) |
|
Disables the fault counter for the CS module. This function can disable either the HFXT fault counter or the LFXT fault counter.
- Parameters
-
counterSelect | selects the fault counter to disable
- CS_HFXT_FAULT_COUNTER
- CS_LFXT_FAULT_COUNTER
|
- Returns
- NONE
References ASSERT, CS_HFXT_FAULT_COUNTER, and CS_KEY.
void CS_resetFaultCounter |
( |
uint_fast8_t |
counterSelect | ) |
|
Resets the fault counter for the CS module. This function can reset either the HFXT fault counter or the LFXT fault counter.
- Parameters
-
counterSelect | selects the fault counter to reset
- CS_HFXT_FAULT_COUNTER
- CS_LFXT_FAULT_COUNTER
|
- Returns
- NONE
References ASSERT, CS_HFXT_FAULT_COUNTER, and CS_KEY.
void CS_startFaultCounter |
( |
uint_fast8_t |
counterSelect, |
|
|
uint_fast8_t |
countValue |
|
) |
| |
void CS_enableInterrupt |
( |
uint32_t |
flags | ) |
|
Enables individual clock control interrupt sources.
- Parameters
-
flags | is a bit mask of the interrupt sources to be enabled. Must be a logical OR of:
- CS_LFXT_FAULT,
- CS_HFXT_FAULT,
- CS_DCOMIN_FAULT,
- CS_DCOMAX_FAULT,
- CS_DCORESISTOR_FAULT,
- CS_STARTCOUNT_LFXT_FAULT,
- CS_STARTCOUNT_HFXT_FAULT,
- CS_PLL_OUTOFLOCK,
- CS_PLL_OUTOFSIGNAL,
- CS_PLL_OUTOFRANGE,
- CS_REFCNT_PERIOD_COUNTER
|
This function enables the indicated clock system interrupt sources. Only the sources that are enabled can be reflected to the processor interrupt; disabled sources have no effect on the processor.
- Note
- The interrupt sources vary based on the part in use. Please consult the data sheet for the part you are using to determine which interrupt sources are available.
- Returns
- None.
References CS_KEY.
void CS_disableInterrupt |
( |
uint32_t |
flags | ) |
|
Disables individual clock system interrupt sources.
- Parameters
-
flags | is a bit mask of the interrupt sources to be disabled. Must be a logical OR of:
- CS_LFXT_FAULT,
- CS_HFXT_FAULT,
- CS_DCOMIN_FAULT,
- CS_DCOMAX_FAULT,
- CS_DCORESISTOR_FAULT,
- CS_STARTCOUNT_LFXT_FAULT,
- CS_STARTCOUNT_HFXT_FAULT,
- CS_PLL_OUTOFLOCK,
- CS_PLL_OUTOFSIGNAL,
- CS_PLL_OUTOFRANGE,
- CS_REFCNT_PERIOD_COUNTER
|
- Note
- The interrupt sources vary based on the part in use. Please consult the data sheet for the part you are using to determine which interrupt sources are available.
- Returns
- None.
References CS_KEY.
uint32_t CS_getEnabledInterruptStatus |
( |
void |
| ) |
|
Gets the current interrupt status masked with the enabled interrupts. This function is useful to call in ISRs to get a list of pending interrupts that are actually enabled and could have caused the ISR.
- Returns
- The current interrupt status, enumerated as a bit field of
- CS_LFXT_FAULT,
- CS_HFXT_FAULT,
- CS_DCOMIN_FAULT,
- CS_DCOMAX_FAULT,
- CS_DCORESISTOR_FAULT,
- CS_STARTCOUNT_LFXT_FAULT,
- CS_STARTCOUNT_HFXT_FAULT,
- CS_PLL_OUTOFLOCK,
- CS_PLL_OUTOFSIGNAL,
- CS_PLL_OUTOFRANGE,
- CS_REFCNT_PERIOD_COUNTER
- Note
- The interrupt sources vary based on the part in use. Please consult the data sheet for the part you are using to determine which interrupt sources are available.
References CS_getInterruptStatus().
uint32_t CS_getInterruptStatus |
( |
void |
| ) |
|
Gets the current interrupt status.
- Returns
- The current interrupt status, enumerated as a bit field of:
- CS_LFXT_FAULT,
- CS_HFXT_FAULT,
- CS_DCOMIN_FAULT,
- CS_DCOMAX_FAULT,
- CS_DCORESISTOR_FAULT,
- CS_STARTCOUNT_LFXT_FAULT,
- CS_STARTCOUNT_HFXT_FAULT,
- CS_PLL_OUTOFLOCK,
- CS_PLL_OUTOFSIGNAL,
- CS_PLL_OUTOFRANGE,
- CS_REFCNT_PERIOD_COUNTER
- Note
- The interrupt sources vary based on the part in use. Please consult the data sheet for the part you are using to determine which interrupt sources are available.
Referenced by CS_getEnabledInterruptStatus().
void CS_clearInterruptFlag |
( |
uint32_t |
flags | ) |
|
Clears clock system interrupt sources.
- Parameters
-
flags | is a bit mask of the interrupt sources to be cleared. Must be a logical OR of:
- CS_LFXT_FAULT,
- CS_HFXT_FAULT,
- CS_DCOMIN_FAULT,
- CS_DCOMAX_FAULT,
- CS_DCORESISTOR_FAULT,
- CS_STARTCOUNT_LFXT_FAULT,
- CS_STARTCOUNT_HFXT_FAULT,
- CS_PLL_OUTOFLOCK,
- CS_PLL_OUTOFSIGNAL,
- CS_PLL_OUTOFRANGE,
- CS_REFCNT_PERIOD_COUNTER
|
The specified clock system interrupt sources are cleared, so that they no longer assert. This function must be called in the interrupt handler to keep it from being called again immediately upon exit.
- Note
- Because there is a write buffer in the Cortex-M processor, it may take several clock cycles before the interrupt source is actually cleared. Therefore, it is recommended that the interrupt source be cleared early in the interrupt handler (as opposed to the very last action) to avoid returning from the interrupt handler before the interrupt source is actually cleared. Failure to do so may result in the interrupt handler being immediately reentered (because the interrupt controller still sees the interrupt source asserted).
-
The interrupt sources vary based on the part in use. Please consult the data sheet for the part you are using to determine which interrupt sources are available.
- Returns
- None.
References CS_KEY.
void CS_registerInterrupt |
( |
void(*)(void) |
intHandler | ) |
|
Registers an interrupt handler for the clock system interrupt.
- Parameters
-
intHandler | is a pointer to the function to be called when the clock system interrupt occurs. |
This function registers the handler to be called when a clock system interrupt occurs. This function enables the global interrupt in the interrupt controller; specific clock system interrupts must be enabled via CS_enableInterrupt(). It is the interrupt handler's responsibility to clear the interrupt source via CS_clearInterruptFlag().
Clock System can generate interrupts when
- See also
- Interrupt_registerInterrupt() for important information about registering interrupt handlers.
- Returns
- None.
References Interrupt_enableInterrupt(), and Interrupt_registerInterrupt().
void CS_unregisterInterrupt |
( |
void |
| ) |
|
Unregisters the interrupt handler for the clock system.
This function unregisters the handler to be called when a clock system interrupt occurs. This function also masks off the interrupt in the interrupt controller so that the interrupt handler no longer is called.
- See also
- Interrupt_registerInterrupt() for important information about registering interrupt handlers.
- Returns
- None.
References Interrupt_disableInterrupt(), and Interrupt_unregisterInterrupt().