URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [CORTEX_LM3S811_GCC/] [hw_include/] [comp.c] - Rev 637
Go to most recent revision | Compare with Previous | Blame | View Log
//***************************************************************************** // // comp.c - Driver for the analog comparator. // // Copyright (c) 2005,2006 Luminary Micro, Inc. All rights reserved. // // Software License Agreement // // Luminary Micro, Inc. (LMI) is supplying this software for use solely and // exclusively on LMI's Stellaris Family of microcontroller products. // // The software is owned by LMI and/or its suppliers, and is protected under // applicable copyright laws. All rights are reserved. Any use in violation // of the foregoing restrictions may subject the user to criminal sanctions // under applicable laws, as well as to civil liability for the breach of the // terms and conditions of this license. // // THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED // OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. // LMI SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR // CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. // // This is part of revision 991 of the Stellaris Driver Library. // //***************************************************************************** //***************************************************************************** // //! \addtogroup comp_api //! @{ // //***************************************************************************** #include "../hw_comp.h" #include "../hw_ints.h" #include "../hw_memmap.h" #include "../hw_types.h" #include "comp.h" #include "debug.h" #include "interrupt.h" //***************************************************************************** // //! Configures a comparator. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator to configure. //! \param ulConfig is the configuration of the comparator. //! //! This function will configure a comparator. The \e ulConfig parameter is //! the result of a logical OR operation between the \b COMP_TRIG_xxx, //! \b COMP_INT_xxx, \b COMP_ASRCP_xxx, and \b COMP_OUTPUT_xxx values. //! //! The \b COMP_TRIG_xxx term can take on the following values: //! //! - \b COMP_TRIG_NONE to have no trigger to the ADC. //! - \b COMP_TRIG_HIGH to trigger the ADC when the comparator output is high. //! - \b COMP_TRIG_LOW to trigger the ADC when the comparator output is low. //! - \b COMP_TRIG_FALL to trigger the ADC when the comparator output goes low. //! - \b COMP_TRIG_RISE to trigger the ADC when the comparator output goes //! high. //! - \b COMP_TRIG_BOTH to trigger the ADC when the comparator output goes low //! or high. //! //! The \b COMP_INT_xxx term can take on the following values: //! //! - \b COMP_INT_HIGH to generate an interrupt when the comparator output is //! high. //! - \b COMP_INT_LOW to generate an interrupt when the comparator output is //! low. //! - \b COMP_INT_FALL to generate an interrupt when the comparator output goes //! low. //! - \b COMP_INT_RISE to generate an interrupt when the comparator output goes //! high. //! - \b COMP_INT_BOTH to generate an interrupt when the comparator output goes //! low or high. //! //! The \b COMP_ASRCP_xxx term can take on the following values: //! //! - \b COMP_ASRCP_PIN to use the dedicated Comp+ pin as the reference //! voltage. //! - \b COMP_ASRCP_PIN0 to use the Comp0+ pin as the reference voltage (this //! the same as \b COMP_ASRCP_PIN for the comparator 0). //! - \b COMP_ASRCP_REF to use the internally generated voltage as the //! reference voltage. //! //! The \b COMP_OUTPUT_xxx term can take on the following values: //! //! - \b COMP_OUTPUT_NONE to disable the output from the comparator to a device //! pin. //! - \b COMP_OUTPUT_NORMAL to enable a non-inverted output from the comparator //! to a device pin. //! - \b COMP_OUTPUT_INVERT to enable an inverted output from the comparator to //! a device pin. //! //! \return None. // //***************************************************************************** #if defined(GROUP_configure) || defined(BUILD_ALL) || defined(DOXYGEN) void ComparatorConfigure(unsigned long ulBase, unsigned long ulComp, unsigned long ulConfig) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Configure this comparator. // HWREG(ulBase + (ulComp * 0x20) + COMP_O_ACCTL0) = ulConfig; } #endif //***************************************************************************** // //! Sets the internal reference voltage. //! //! \param ulBase is the base address of the comparator module. //! \param ulRef is the desired reference voltage. //! //! This function will set the internal reference voltage value. The voltage //! is specified as one of the following values: //! //! - \b COMP_REF_OFF to turn off the reference voltage //! - \b COMP_REF_0V to set the reference voltage to 0 V //! - \b COMP_REF_0_1375V to set the reference voltage to 0.1375 V //! - \b COMP_REF_0_275V to set the reference voltage to 0.275 V //! - \b COMP_REF_0_4125V to set the reference voltage to 0.4125 V //! - \b COMP_REF_0_55V to set the reference voltage to 0.55 V //! - \b COMP_REF_0_6875V to set the reference voltage to 0.6875 V //! - \b COMP_REF_0_825V to set the reference voltage to 0.825 V //! - \b COMP_REF_0_928125V to set the reference voltage to 0.928125 V //! - \b COMP_REF_0_9625V to set the reference voltage to 0.9625 V //! - \b COMP_REF_1_03125V to set the reference voltage to 1.03125 V //! - \b COMP_REF_1_134375V to set the reference voltage to 1.134375 V //! - \b COMP_REF_1_1V to set the reference voltage to 1.1 V //! - \b COMP_REF_1_2375V to set the reference voltage to 1.2375 V //! - \b COMP_REF_1_340625V to set the reference voltage to 1.340625 V //! - \b COMP_REF_1_375V to set the reference voltage to 1.375 V //! - \b COMP_REF_1_44375V to set the reference voltage to 1.44375 V //! - \b COMP_REF_1_5125V to set the reference voltage to 1.5125 V //! - \b COMP_REF_1_546875V to set the reference voltage to 1.546875 V //! - \b COMP_REF_1_65V to set the reference voltage to 1.65 V //! - \b COMP_REF_1_753125V to set the reference voltage to 1.753125 V //! - \b COMP_REF_1_7875V to set the reference voltage to 1.7875 V //! - \b COMP_REF_1_85625V to set the reference voltage to 1.85625 V //! - \b COMP_REF_1_925V to set the reference voltage to 1.925 V //! - \b COMP_REF_1_959375V to set the reference voltage to 1.959375 V //! - \b COMP_REF_2_0625V to set the reference voltage to 2.0625 V //! - \b COMP_REF_2_165625V to set the reference voltage to 2.165625 V //! - \b COMP_REF_2_26875V to set the reference voltage to 2.26875 V //! - \b COMP_REF_2_371875V to set the reference voltage to 2.371875 V //! //! \return None. // //***************************************************************************** #if defined(GROUP_refset) || defined(BUILD_ALL) || defined(DOXYGEN) void ComparatorRefSet(unsigned long ulBase, unsigned long ulRef) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); // // Set the voltage reference voltage as requested. // HWREG(ulBase + COMP_O_REFCTL) = ulRef; } #endif //***************************************************************************** // //! Gets the current comparator output value. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator. //! //! This function retrieves the current value of the comparator output. //! //! \return Returns \b true if the comparator output is high and \b false if //! the comparator output is low. // //***************************************************************************** #if defined(GROUP_valueget) || defined(BUILD_ALL) || defined(DOXYGEN) tBoolean ComparatorValueGet(unsigned long ulBase, unsigned long ulComp) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Return the appropriate value based on the comparator's present output // value. // if(HWREG(ulBase + (ulComp * 0x20) + COMP_O_ACSTAT0) & COMP_ACSTAT_OVAL) { return(true); } else { return(false); } } #endif //***************************************************************************** // //! Registers an interrupt handler for the comparator interrupt. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator. //! \param pfnHandler is a pointer to the function to be called when the //! comparator interrupt occurs. //! //! This sets the handler to be called when the comparator interrupt occurs. //! This will enable the interrupt in the interrupt controller; it is the //! interrupt-handler's responsibility to clear the interrupt source via //! ComparatorIntClear(). //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** #if defined(GROUP_intregister) || defined(BUILD_ALL) || defined(DOXYGEN) void ComparatorIntRegister(unsigned long ulBase, unsigned long ulComp, void (*pfnHandler)(void)) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Register the interrupt handler, returning an error if an error occurs. // IntRegister(INT_COMP0 + ulComp, pfnHandler); // // Enable the interrupt in the interrupt controller. // IntEnable(INT_COMP0 + ulComp); // // Enable the comparator interrupt. // HWREG(ulBase + COMP_O_INTEN) |= 1 << ulComp; } #endif //***************************************************************************** // //! Unregisters an interrupt handler for a comparator interrupt. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator. //! //! This function will clear the handler to be called when a comparator //! interrupt occurs. This will also mask off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** #if defined(GROUP_intunregister) || defined(BUILD_ALL) || defined(DOXYGEN) void ComparatorIntUnregister(unsigned long ulBase, unsigned long ulComp) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Disable the comparator interrupt. // HWREG(ulBase + COMP_O_INTEN) &= ~(1 << ulComp); // // Disable the interrupt in the interrupt controller. // IntDisable(INT_COMP0 + ulComp); // // Unregister the interrupt handler. // IntUnregister(INT_COMP0 + ulComp); } #endif //***************************************************************************** // //! Enables the comparator interrupt. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator. //! //! This function enables generation of an interrupt from the specified //! comparator. Only comparators whose interrupts are enabled can be reflected //! to the processor. //! //! \return None. // //***************************************************************************** #if defined(GROUP_intenable) || defined(BUILD_ALL) || defined(DOXYGEN) void ComparatorIntEnable(unsigned long ulBase, unsigned long ulComp) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Enable the comparator interrupt. // HWREG(ulBase + COMP_O_INTEN) |= 1 << ulComp; } #endif //***************************************************************************** // //! Disables the comparator interrupt. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator. //! //! This function disables generation of an interrupt from the specified //! comparator. Only comparators whose interrupts are enabled can be reflected //! to the processor. //! //! \return None. // //***************************************************************************** #if defined(GROUP_intdisable) || defined(BUILD_ALL) || defined(DOXYGEN) void ComparatorIntDisable(unsigned long ulBase, unsigned long ulComp) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Disable the comparator interrupt. // HWREG(ulBase + COMP_O_INTEN) &= ~(1 << ulComp); } #endif //***************************************************************************** // //! Gets the current interrupt status. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator. //! \param bMasked is \b false if the raw interrupt status is required and //! \b true if the masked interrupt status is required. //! //! This returns the interrupt status for the comparator. Either the raw or //! the masked interrupt status can be returned. //! //! \return \b true if the interrupt is asserted and \b false if it is not //! asserted. // //***************************************************************************** #if defined(GROUP_intstatus) || defined(BUILD_ALL) || defined(DOXYGEN) tBoolean ComparatorIntStatus(unsigned long ulBase, unsigned long ulComp, tBoolean bMasked) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Return either the interrupt status or the raw interrupt status as // requested. // if(bMasked) { return(((HWREG(ulBase + COMP_O_MIS) >> ulComp) & 1) ? true : false); } else { return(((HWREG(ulBase + COMP_O_RIS) >> ulComp) & 1) ? true : false); } } #endif //***************************************************************************** // //! Clears a comparator interrupt. //! //! \param ulBase is the base address of the comparator module. //! \param ulComp is the index of the comparator. //! //! The comparator interrupt is cleared, so that it no longer asserts. This //! must be done in the interrupt handler to keep it from being called again //! immediately upon exit. Note that for a level triggered interrupt, the //! interrupt cannot be cleared until it stops asserting. //! //! \return None. // //***************************************************************************** #if defined(GROUP_intclear) || defined(BUILD_ALL) || defined(DOXYGEN) void ComparatorIntClear(unsigned long ulBase, unsigned long ulComp) { // // Check the arguments. // ASSERT(ulBase == COMP_BASE); ASSERT(ulComp < 3); // // Clear the interrupt. // HWREG(ulBase + COMP_O_MIS) = 1 << ulComp; } #endif //***************************************************************************** // // Close the Doxygen group. //! @} // //*****************************************************************************
Go to most recent revision | Compare with Previous | Blame | View Log