/* --COPYRIGHT--,BSD * Copyright (c) 2014, Texas Instruments Incorporated * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * * Neither the name of Texas Instruments Incorporated nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * --/COPYRIGHT--*/ //***************************************************************************** // // rtc_c.h - Driver for the RTC_C Module. // //***************************************************************************** #ifndef __MSP430WARE_RTC_C_H__ #define __MSP430WARE_RTC_C_H__ #include "inc/hw_memmap.h" #ifdef __MSP430_HAS_RTC_C__ //***************************************************************************** // // If building with a C++ compiler, make all of the definitions in this header // have a C binding. // //***************************************************************************** #ifdef __cplusplus extern "C" { #endif #include "inc/hw_regaccess.h" //***************************************************************************** // //! \brief Used in the RTC_C_initCalendar() function as the CalendarTime //! parameter. // //***************************************************************************** typedef struct Calendar { //! Seconds of minute between 0-59 uint8_t Seconds; //! Minutes of hour between 0-59 uint8_t Minutes; //! Hour of day between 0-23 uint8_t Hours; //! Day of week between 0-6 uint8_t DayOfWeek; //! Day of month between 1-31 uint8_t DayOfMonth; //! Month between 0-11 uint8_t Month; //! Year between 0-4095 uint16_t Year; } Calendar; //***************************************************************************** // //! \brief Used in the RTC_C_configureCalendarAlarm() function as the param //! parameter. // //***************************************************************************** typedef struct RTC_C_configureCalendarAlarmParam { //! Is the alarm condition for the minutes. //! \n Valid values are: //! - \b RTC_C_ALARMCONDITION_OFF [Default] uint8_t minutesAlarm; //! Is the alarm condition for the hours. //! \n Valid values are: //! - \b RTC_C_ALARMCONDITION_OFF [Default] uint8_t hoursAlarm; //! Is the alarm condition for the day of week. //! \n Valid values are: //! - \b RTC_C_ALARMCONDITION_OFF [Default] uint8_t dayOfWeekAlarm; //! Is the alarm condition for the day of the month. //! \n Valid values are: //! - \b RTC_C_ALARMCONDITION_OFF [Default] uint8_t dayOfMonthAlarm; } RTC_C_configureCalendarAlarmParam; //***************************************************************************** // // The following are values that can be passed to the frequencySelect parameter // for functions: RTC_C_setCalibrationFrequency(). // //***************************************************************************** #define RTC_C_CALIBRATIONFREQ_OFF (RTCCALF_0) #define RTC_C_CALIBRATIONFREQ_512HZ (RTCCALF_1) #define RTC_C_CALIBRATIONFREQ_256HZ (RTCCALF_2) #define RTC_C_CALIBRATIONFREQ_1HZ (RTCCALF_3) //***************************************************************************** // // The following are values that can be passed to the offsetDirection parameter // for functions: RTC_C_setCalibrationData(). // //***************************************************************************** #define RTC_C_CALIBRATION_DOWN1PPM (!(RTCCALS)) #define RTC_C_CALIBRATION_UP1PPM (RTCCALS) //***************************************************************************** // // The following are values that can be passed to the offsetDirection parameter // for functions: RTC_C_setTemperatureCompensation(). // //***************************************************************************** #define RTC_C_COMPENSATION_DOWN1PPM (!(RTCTCMPS)) #define RTC_C_COMPENSATION_UP1PPM (RTCTCMPS) //***************************************************************************** // // The following are values that can be passed to the clockSelect parameter for // functions: RTC_C_initCounter(). // //***************************************************************************** #define RTC_C_CLOCKSELECT_32KHZ_OSC (RTCSSEL_0) #define RTC_C_CLOCKSELECT_RT1PS (RTCSSEL_2) //***************************************************************************** // // The following are values that can be passed to the counterSizeSelect // parameter for functions: RTC_C_initCounter(). // //***************************************************************************** #define RTC_C_COUNTERSIZE_8BIT (RTCTEV_0) #define RTC_C_COUNTERSIZE_16BIT (RTCTEV_1) #define RTC_C_COUNTERSIZE_24BIT (RTCTEV_2) #define RTC_C_COUNTERSIZE_32BIT (RTCTEV_3) //***************************************************************************** // // The following are values that can be passed to the formatSelect parameter // for functions: RTC_C_initCalendar(). // //***************************************************************************** #define RTC_C_FORMAT_BINARY (!(RTCBCD)) #define RTC_C_FORMAT_BCD (RTCBCD) //***************************************************************************** // // The following are values that can be passed to the param parameter for // functions: RTC_C_configureCalendarAlarm(), RTC_C_configureCalendarAlarm(), // RTC_C_configureCalendarAlarm(), and RTC_C_configureCalendarAlarm(). // //***************************************************************************** #define RTC_C_ALARMCONDITION_OFF (0x80) //***************************************************************************** // // The following are values that can be passed to the eventSelect parameter for // functions: RTC_C_setCalendarEvent(). // //***************************************************************************** #define RTC_C_CALENDAREVENT_MINUTECHANGE (RTCTEV_0) #define RTC_C_CALENDAREVENT_HOURCHANGE (RTCTEV_1) #define RTC_C_CALENDAREVENT_NOON (RTCTEV_2) #define RTC_C_CALENDAREVENT_MIDNIGHT (RTCTEV_3) //***************************************************************************** // // The following are values that can be passed to the prescaleDivider parameter // for functions: RTC_C_initCounterPrescale(). // //***************************************************************************** #define RTC_C_PSDIVIDER_2 (RT0PSDIV_0) #define RTC_C_PSDIVIDER_4 (RT0PSDIV_1) #define RTC_C_PSDIVIDER_8 (RT0PSDIV_2) #define RTC_C_PSDIVIDER_16 (RT0PSDIV_3) #define RTC_C_PSDIVIDER_32 (RT0PSDIV_4) #define RTC_C_PSDIVIDER_64 (RT0PSDIV_5) #define RTC_C_PSDIVIDER_128 (RT0PSDIV_6) #define RTC_C_PSDIVIDER_256 (RT0PSDIV_7) //***************************************************************************** // // The following are values that can be passed to the prescaleClockSelect // parameter for functions: RTC_C_initCounterPrescale(). // //***************************************************************************** #define RTC_C_PSCLOCKSELECT_ACLK (RT1SSEL_0) #define RTC_C_PSCLOCKSELECT_SMCLK (RT1SSEL_1) #define RTC_C_PSCLOCKSELECT_RT0PS (RT1SSEL_2) //***************************************************************************** // // The following are values that can be passed to the prescaleEventDivider // parameter for functions: RTC_C_definePrescaleEvent(). // //***************************************************************************** #define RTC_C_PSEVENTDIVIDER_2 (RT0IP_0) #define RTC_C_PSEVENTDIVIDER_4 (RT0IP_1) #define RTC_C_PSEVENTDIVIDER_8 (RT0IP_2) #define RTC_C_PSEVENTDIVIDER_16 (RT0IP_3) #define RTC_C_PSEVENTDIVIDER_32 (RT0IP_4) #define RTC_C_PSEVENTDIVIDER_64 (RT0IP_5) #define RTC_C_PSEVENTDIVIDER_128 (RT0IP_6) #define RTC_C_PSEVENTDIVIDER_256 (RT0IP_7) //***************************************************************************** // // The following are values that can be passed to the prescaleSelect parameter // for functions: RTC_C_initCounterPrescale(), RTC_C_holdCounterPrescale(), // RTC_C_startCounterPrescale(), RTC_C_definePrescaleEvent(), // RTC_C_getPrescaleValue(), and RTC_C_setPrescaleValue(). // //***************************************************************************** #define RTC_C_PRESCALE_0 (0x0) #define RTC_C_PRESCALE_1 (0x2) //***************************************************************************** // // The following are values that can be passed to the interruptMask parameter // for functions: RTC_C_enableInterrupt(), and RTC_C_disableInterrupt(); the // interruptFlagMask parameter for functions: RTC_C_getInterruptStatus(), and // RTC_C_clearInterrupt() as well as returned by the RTC_C_getInterruptStatus() // function. // //***************************************************************************** #define RTC_C_TIME_EVENT_INTERRUPT RTCTEVIE #define RTC_C_CLOCK_ALARM_INTERRUPT RTCAIE #define RTC_C_CLOCK_READ_READY_INTERRUPT RTCRDYIE #define RTC_C_PRESCALE_TIMER0_INTERRUPT 0x02 #define RTC_C_PRESCALE_TIMER1_INTERRUPT 0x01 #define RTC_C_OSCILLATOR_FAULT_INTERRUPT RTCOFIE //***************************************************************************** // // Prototypes for the APIs. // //***************************************************************************** //***************************************************************************** // //! \brief Starts the RTC. //! //! This function clears the RTC main hold bit to allow the RTC to function. //! //! \param baseAddress is the base address of the RTC_C module. //! //! \return None // //***************************************************************************** extern void RTC_C_startClock(uint16_t baseAddress); //***************************************************************************** // //! \brief Holds the RTC. //! //! This function sets the RTC main hold bit to disable RTC functionality. //! //! \param baseAddress is the base address of the RTC_C module. //! //! \return None // //***************************************************************************** extern void RTC_C_holdClock(uint16_t baseAddress); //***************************************************************************** // //! \brief Allows and Sets the frequency output to RTCCLK pin for calibration //! measurement. //! //! This function sets a frequency to measure at the RTCCLK output pin. After //! testing the set frequency, the calibration could be set accordingly. //! //! \param baseAddress is the base address of the RTC_C module. //! \param frequencySelect is the frequency output to RTCCLK. //! Valid values are: //! - \b RTC_C_CALIBRATIONFREQ_OFF [Default] - turn off calibration //! output //! - \b RTC_C_CALIBRATIONFREQ_512HZ - output signal at 512Hz for //! calibration //! - \b RTC_C_CALIBRATIONFREQ_256HZ - output signal at 256Hz for //! calibration //! - \b RTC_C_CALIBRATIONFREQ_1HZ - output signal at 1Hz for //! calibration //! \n Modified bits are \b RTCCALF of \b RTCCTL3 register. //! //! \return None // //***************************************************************************** extern void RTC_C_setCalibrationFrequency(uint16_t baseAddress, uint16_t frequencySelect); //***************************************************************************** // //! \brief Sets the specified calibration for the RTC. //! //! This function sets the calibration offset to make the RTC as accurate as //! possible. The offsetDirection can be either +4-ppm or -2-ppm, and the //! offsetValue should be from 1-63 and is multiplied by the direction setting //! (i.e. +4-ppm * 8 (offsetValue) = +32-ppm). //! //! \param baseAddress is the base address of the RTC_C module. //! \param offsetDirection is the direction that the calibration offset will //! go. //! Valid values are: //! - \b RTC_C_CALIBRATION_DOWN1PPM - calibrate at steps of -1 //! - \b RTC_C_CALIBRATION_UP1PPM - calibrate at steps of +1 //! \n Modified bits are \b RTC0CALS of \b RTC0CAL register. //! \param offsetValue is the value that the offset will be a factor of; a //! valid value is any integer from 1-240. //! \n Modified bits are \b RTC0CALx of \b RTC0CAL register. //! //! \return None // //***************************************************************************** extern void RTC_C_setCalibrationData(uint16_t baseAddress, uint8_t offsetDirection, uint8_t offsetValue); //***************************************************************************** // //! \brief Initializes the settings to operate the RTC in Counter mode. //! //! This function initializes the Counter mode of the RTC_C. Setting the clock //! source and counter size will allow an interrupt from the RTCTEVIFG once an //! overflow to the counter register occurs. //! //! \param baseAddress is the base address of the RTC_C module. //! \param clockSelect is the selected clock for the counter mode to use. //! Valid values are: //! - \b RTC_C_CLOCKSELECT_32KHZ_OSC //! - \b RTC_C_CLOCKSELECT_RT1PS //! \n Modified bits are \b RTCSSEL of \b RTCCTL1 register. //! \param counterSizeSelect is the size of the counter. //! Valid values are: //! - \b RTC_C_COUNTERSIZE_8BIT [Default] //! - \b RTC_C_COUNTERSIZE_16BIT //! - \b RTC_C_COUNTERSIZE_24BIT //! - \b RTC_C_COUNTERSIZE_32BIT //! \n Modified bits are \b RTCTEV of \b RTCCTL1 register. //! //! \return None // //***************************************************************************** extern void RTC_C_initCounter(uint16_t baseAddress, uint16_t clockSelect, uint16_t counterSizeSelect); //***************************************************************************** // //! \brief Sets the specified temperature compensation for the RTC. //! //! This function sets the calibration offset to make the RTC as accurate as //! possible. The offsetDirection can be either +1-ppm or -1-ppm, and the //! offsetValue should be from 1-240 and is multiplied by the direction setting //! (i.e. +1-ppm * 8 (offsetValue) = +8-ppm). //! //! \param baseAddress is the base address of the RTC_C module. //! \param offsetDirection is the direction that the calibration offset wil go //! Valid values are: //! - \b RTC_C_COMPENSATION_DOWN1PPM //! - \b RTC_C_COMPENSATION_UP1PPM //! \n Modified bits are \b RTCTCMPS of \b RTCTCMP register. //! \param offsetValue is the value that the offset will be a factor of; a //! valid value is any integer from 1-240. //! \n Modified bits are \b RTCTCMPx of \b RTCTCMP register. //! //! \return STATUS_SUCCESS or STATUS_FAILURE of setting the temperature //! compensation // //***************************************************************************** extern bool RTC_C_setTemperatureCompensation(uint16_t baseAddress, uint16_t offsetDirection, uint8_t offsetValue); //***************************************************************************** // //! \brief Initializes the settings to operate the RTC in calendar mode //! //! This function initializes the Calendar mode of the RTC module. To prevent //! potential erroneous alarm conditions from occurring, the alarm should be //! disabled by clearing the RTCAIE, RTCAIFG and AE bits with APIs: //! RTC_C_disableInterrupt(), RTC_C_clearInterrupt() and //! RTC_C_configureCalendarAlarm() before calendar initialization. //! //! \param baseAddress is the base address of the RTC_C module. //! \param CalendarTime is the pointer to the structure containing the values //! for the Calendar to be initialized to. Valid values should be of //! type pointer to Calendar and should contain the following members //! and corresponding values: \b Seconds between 0-59 \b Minutes between //! 0-59 \b Hours between 0-23 \b DayOfWeek between 0-6 \b DayOfMonth //! between 1-31 \b Year between 0-4095 NOTE: Values beyond the ones //! specified may result in erratic behavior. //! \param formatSelect is the format for the Calendar registers to use. //! Valid values are: //! - \b RTC_C_FORMAT_BINARY [Default] //! - \b RTC_C_FORMAT_BCD //! \n Modified bits are \b RTCBCD of \b RTCCTL1 register. //! //! \return None // //***************************************************************************** extern void RTC_C_initCalendar(uint16_t baseAddress, Calendar *CalendarTime, uint16_t formatSelect); //***************************************************************************** // //! \brief Returns the Calendar Time stored in the Calendar registers of the //! RTC. //! //! This function returns the current Calendar time in the form of a Calendar //! structure. The RTCRDY polling is used in this function to prevent reading //! invalid time. //! //! \param baseAddress is the base address of the RTC_C module. //! //! \return A Calendar structure containing the current time. // //***************************************************************************** extern Calendar RTC_C_getCalendarTime(uint16_t baseAddress); //***************************************************************************** // //! \brief Sets and Enables the desired Calendar Alarm settings. //! //! This function sets a Calendar interrupt condition to assert the RTCAIFG //! interrupt flag. The condition is a logical and of all of the parameters. //! For example if the minutes and hours alarm is set, then the interrupt will //! only assert when the minutes AND the hours change to the specified setting. //! Use the RTC_C_ALARM_OFF for any alarm settings that should not be apart of //! the alarm condition. //! //! \param baseAddress is the base address of the RTC_C module. //! \param param is the pointer to struct for calendar alarm configuration. //! //! \return None // //***************************************************************************** extern void RTC_C_configureCalendarAlarm(uint16_t baseAddress, RTC_C_configureCalendarAlarmParam *param); //***************************************************************************** // //! \brief Sets a single specified Calendar interrupt condition //! //! This function sets a specified event to assert the RTCTEVIFG interrupt. //! This interrupt is independent from the Calendar alarm interrupt. //! //! \param baseAddress is the base address of the RTC_C module. //! \param eventSelect is the condition selected. //! Valid values are: //! - \b RTC_C_CALENDAREVENT_MINUTECHANGE - assert interrupt on every //! minute //! - \b RTC_C_CALENDAREVENT_HOURCHANGE - assert interrupt on every hour //! - \b RTC_C_CALENDAREVENT_NOON - assert interrupt when hour is 12 //! - \b RTC_C_CALENDAREVENT_MIDNIGHT - assert interrupt when hour is 0 //! \n Modified bits are \b RTCTEV of \b RTCCTL register. //! //! \return None // //***************************************************************************** extern void RTC_C_setCalendarEvent(uint16_t baseAddress, uint16_t eventSelect); //***************************************************************************** // //! \brief Returns the value of the Counter register. //! //! This function returns the value of the counter register for the RTC_C //! module. It will return the 32-bit value no matter the size set during //! initialization. The RTC should be held before trying to use this function. //! //! \param baseAddress is the base address of the RTC_C module. //! //! \return The raw value of the full 32-bit Counter Register. // //***************************************************************************** extern uint32_t RTC_C_getCounterValue(uint16_t baseAddress); //***************************************************************************** // //! \brief Sets the value of the Counter register //! //! This function sets the counter register of the RTC_C module. //! //! \param baseAddress is the base address of the RTC_C module. //! \param counterValue is the value to set the Counter register to; a valid //! value may be any 32-bit integer. //! //! \return None // //***************************************************************************** extern void RTC_C_setCounterValue(uint16_t baseAddress, uint32_t counterValue); //***************************************************************************** // //! \brief Initializes the Prescaler for Counter mode. //! //! This function initializes the selected prescaler for the counter mode in //! the RTC_C module. If the RTC is initialized in Calendar mode, then these //! are automatically initialized. The Prescalers can be used to divide a clock //! source additionally before it gets to the main RTC clock. //! //! \param baseAddress is the base address of the RTC_C module. //! \param prescaleSelect is the prescaler to initialize. //! Valid values are: //! - \b RTC_C_PRESCALE_0 //! - \b RTC_C_PRESCALE_1 //! \param prescaleClockSelect is the clock to drive the selected prescaler. //! Valid values are: //! - \b RTC_C_PSCLOCKSELECT_ACLK //! - \b RTC_C_PSCLOCKSELECT_SMCLK //! - \b RTC_C_PSCLOCKSELECT_RT0PS - use Prescaler 0 as source to //! Prescaler 1 (May only be used if prescaleSelect is //! RTC_C_PRESCALE_1) //! \n Modified bits are \b RTxSSEL of \b RTCPSxCTL register. //! \param prescaleDivider is the divider for the selected clock source. //! Valid values are: //! - \b RTC_C_PSDIVIDER_2 [Default] //! - \b RTC_C_PSDIVIDER_4 //! - \b RTC_C_PSDIVIDER_8 //! - \b RTC_C_PSDIVIDER_16 //! - \b RTC_C_PSDIVIDER_32 //! - \b RTC_C_PSDIVIDER_64 //! - \b RTC_C_PSDIVIDER_128 //! - \b RTC_C_PSDIVIDER_256 //! \n Modified bits are \b RTxPSDIV of \b RTCPSxCTL register. //! //! \return None // //***************************************************************************** extern void RTC_C_initCounterPrescale(uint16_t baseAddress, uint8_t prescaleSelect, uint16_t prescaleClockSelect, uint16_t prescaleDivider); //***************************************************************************** // //! \brief Holds the selected Prescaler. //! //! This function holds the prescale counter from continuing. This will only //! work in counter mode, in Calendar mode, the RTC_C_holdClock() must be used. //! In counter mode, if using both prescalers in conjunction with the main RTC //! counter, then stopping RT0PS will stop RT1PS, but stopping RT1PS will not //! stop RT0PS. //! //! \param baseAddress is the base address of the RTC_C module. //! \param prescaleSelect is the prescaler to hold. //! Valid values are: //! - \b RTC_C_PRESCALE_0 //! - \b RTC_C_PRESCALE_1 //! //! \return None // //***************************************************************************** extern void RTC_C_holdCounterPrescale(uint16_t baseAddress, uint8_t prescaleSelect); //***************************************************************************** // //! \brief Starts the selected Prescaler. //! //! This function starts the selected prescale counter. This function will only //! work if the RTC is in counter mode. //! //! \param baseAddress is the base address of the RTC_C module. //! \param prescaleSelect is the prescaler to start. //! Valid values are: //! - \b RTC_C_PRESCALE_0 //! - \b RTC_C_PRESCALE_1 //! //! \return None // //***************************************************************************** extern void RTC_C_startCounterPrescale(uint16_t baseAddress, uint8_t prescaleSelect); //***************************************************************************** // //! \brief Sets up an interrupt condition for the selected Prescaler. //! //! This function sets the condition for an interrupt to assert based on the //! individual prescalers. //! //! \param baseAddress is the base address of the RTC_C module. //! \param prescaleSelect is the prescaler to define an interrupt for. //! Valid values are: //! - \b RTC_C_PRESCALE_0 //! - \b RTC_C_PRESCALE_1 //! \param prescaleEventDivider is a divider to specify when an interrupt can //! occur based on the clock source of the selected prescaler. (Does not //! affect timer of the selected prescaler). //! Valid values are: //! - \b RTC_C_PSEVENTDIVIDER_2 [Default] //! - \b RTC_C_PSEVENTDIVIDER_4 //! - \b RTC_C_PSEVENTDIVIDER_8 //! - \b RTC_C_PSEVENTDIVIDER_16 //! - \b RTC_C_PSEVENTDIVIDER_32 //! - \b RTC_C_PSEVENTDIVIDER_64 //! - \b RTC_C_PSEVENTDIVIDER_128 //! - \b RTC_C_PSEVENTDIVIDER_256 //! \n Modified bits are \b RTxIP of \b RTCPSxCTL register. //! //! \return None // //***************************************************************************** extern void RTC_C_definePrescaleEvent(uint16_t baseAddress, uint8_t prescaleSelect, uint8_t prescaleEventDivider); //***************************************************************************** // //! \brief Returns the selected prescaler value. //! //! This function returns the value of the selected prescale counter register. //! Note that the counter value should be held by calling RTC_C_holdClock() //! before calling this API. //! //! \param baseAddress is the base address of the RTC_C module. //! \param prescaleSelect is the prescaler to obtain the value of. //! Valid values are: //! - \b RTC_C_PRESCALE_0 //! - \b RTC_C_PRESCALE_1 //! //! \return The value of the specified prescaler count register // //***************************************************************************** extern uint8_t RTC_C_getPrescaleValue(uint16_t baseAddress, uint8_t prescaleSelect); //***************************************************************************** // //! \brief Sets the selected Prescaler value. //! //! This function sets the prescale counter value. Before setting the prescale //! counter, it should be held by calling RTC_C_holdClock(). //! //! \param baseAddress is the base address of the RTC_C module. //! \param prescaleSelect is the prescaler to set the value for. //! Valid values are: //! - \b RTC_C_PRESCALE_0 //! - \b RTC_C_PRESCALE_1 //! \param prescaleCounterValue is the specified value to set the prescaler to. //! Valid values are any integer between 0-255 //! \n Modified bits are \b RTxPS of \b RTxPS register. //! //! \return None // //***************************************************************************** extern void RTC_C_setPrescaleValue(uint16_t baseAddress, uint8_t prescaleSelect, uint8_t prescaleCounterValue); //***************************************************************************** // //! \brief Enables selected RTC interrupt sources. //! //! This function enables the selected RTC interrupt source. Only the sources //! that are enabled can be reflected to the processor interrupt; disabled //! sources have no effect on the processor. Does not clear interrupt flags. //! //! \param baseAddress is the base address of the RTC_C module. //! \param interruptMask is a bit mask of the interrupts to enable. //! Mask value is the logical OR of any of the following: //! - \b RTC_C_TIME_EVENT_INTERRUPT - asserts when counter overflows in //! counter mode or when Calendar event condition defined by //! defineCalendarEvent() is met. //! - \b RTC_C_CLOCK_ALARM_INTERRUPT - asserts when alarm condition in //! Calendar mode is met. //! - \b RTC_C_CLOCK_READ_READY_INTERRUPT - asserts when Calendar //! registers are settled. //! - \b RTC_C_PRESCALE_TIMER0_INTERRUPT - asserts when Prescaler 0 //! event condition is met. //! - \b RTC_C_PRESCALE_TIMER1_INTERRUPT - asserts when Prescaler 1 //! event condition is met. //! - \b RTC_C_OSCILLATOR_FAULT_INTERRUPT - asserts if there is a //! problem with the 32kHz oscillator, while the RTC is running. //! //! \return None // //***************************************************************************** extern void RTC_C_enableInterrupt(uint16_t baseAddress, uint8_t interruptMask); //***************************************************************************** // //! \brief Disables selected RTC interrupt sources. //! //! This function disables the selected RTC interrupt source. Only the sources //! that are enabled can be reflected to the processor interrupt; disabled //! sources have no effect on the processor. //! //! \param baseAddress is the base address of the RTC_C module. //! \param interruptMask is a bit mask of the interrupts to disable. //! Mask value is the logical OR of any of the following: //! - \b RTC_C_TIME_EVENT_INTERRUPT - asserts when counter overflows in //! counter mode or when Calendar event condition defined by //! defineCalendarEvent() is met. //! - \b RTC_C_CLOCK_ALARM_INTERRUPT - asserts when alarm condition in //! Calendar mode is met. //! - \b RTC_C_CLOCK_READ_READY_INTERRUPT - asserts when Calendar //! registers are settled. //! - \b RTC_C_PRESCALE_TIMER0_INTERRUPT - asserts when Prescaler 0 //! event condition is met. //! - \b RTC_C_PRESCALE_TIMER1_INTERRUPT - asserts when Prescaler 1 //! event condition is met. //! - \b RTC_C_OSCILLATOR_FAULT_INTERRUPT - asserts if there is a //! problem with the 32kHz oscillator, while the RTC is running. //! //! \return None // //***************************************************************************** extern void RTC_C_disableInterrupt(uint16_t baseAddress, uint8_t interruptMask); //***************************************************************************** // //! \brief Returns the status of the selected interrupts flags. //! //! This function returns the status of the interrupt flag for the selected //! channel. //! //! \param baseAddress is the base address of the RTC_C module. //! \param interruptFlagMask is a bit mask of the interrupt flags to return the //! status of. //! Mask value is the logical OR of any of the following: //! - \b RTC_C_TIME_EVENT_INTERRUPT - asserts when counter overflows in //! counter mode or when Calendar event condition defined by //! defineCalendarEvent() is met. //! - \b RTC_C_CLOCK_ALARM_INTERRUPT - asserts when alarm condition in //! Calendar mode is met. //! - \b RTC_C_CLOCK_READ_READY_INTERRUPT - asserts when Calendar //! registers are settled. //! - \b RTC_C_PRESCALE_TIMER0_INTERRUPT - asserts when Prescaler 0 //! event condition is met. //! - \b RTC_C_PRESCALE_TIMER1_INTERRUPT - asserts when Prescaler 1 //! event condition is met. //! - \b RTC_C_OSCILLATOR_FAULT_INTERRUPT - asserts if there is a //! problem with the 32kHz oscillator, while the RTC is running. //! //! \return Logical OR of any of the following: //! - \b RTC_C_TIME_EVENT_INTERRUPT asserts when counter overflows in //! counter mode or when Calendar event condition defined by //! defineCalendarEvent() is met. //! - \b RTC_C_CLOCK_ALARM_INTERRUPT asserts when alarm condition in //! Calendar mode is met. //! - \b RTC_C_CLOCK_READ_READY_INTERRUPT asserts when Calendar //! registers are settled. //! - \b RTC_C_PRESCALE_TIMER0_INTERRUPT asserts when Prescaler 0 event //! condition is met. //! - \b RTC_C_PRESCALE_TIMER1_INTERRUPT asserts when Prescaler 1 event //! condition is met. //! - \b RTC_C_OSCILLATOR_FAULT_INTERRUPT asserts if there is a problem //! with the 32kHz oscillator, while the RTC is running. //! \n indicating the status of the masked interrupts // //***************************************************************************** extern uint8_t RTC_C_getInterruptStatus(uint16_t baseAddress, uint8_t interruptFlagMask); //***************************************************************************** // //! \brief Clears selected RTC interrupt flags. //! //! This function clears the RTC interrupt flag is cleared, so that it no //! longer asserts. //! //! \param baseAddress is the base address of the RTC_C module. //! \param interruptFlagMask is a bit mask of the interrupt flags to be //! cleared. //! Mask value is the logical OR of any of the following: //! - \b RTC_C_TIME_EVENT_INTERRUPT - asserts when counter overflows in //! counter mode or when Calendar event condition defined by //! defineCalendarEvent() is met. //! - \b RTC_C_CLOCK_ALARM_INTERRUPT - asserts when alarm condition in //! Calendar mode is met. //! - \b RTC_C_CLOCK_READ_READY_INTERRUPT - asserts when Calendar //! registers are settled. //! - \b RTC_C_PRESCALE_TIMER0_INTERRUPT - asserts when Prescaler 0 //! event condition is met. //! - \b RTC_C_PRESCALE_TIMER1_INTERRUPT - asserts when Prescaler 1 //! event condition is met. //! - \b RTC_C_OSCILLATOR_FAULT_INTERRUPT - asserts if there is a //! problem with the 32kHz oscillator, while the RTC is running. //! //! \return None // //***************************************************************************** extern void RTC_C_clearInterrupt(uint16_t baseAddress, uint8_t interruptFlagMask); //***************************************************************************** // //! \brief Convert the given BCD value to binary format //! //! This function converts BCD values to binary format. This API uses the //! hardware registers to perform the conversion rather than a software method. //! //! \param baseAddress is the base address of the RTC_C module. //! \param valueToConvert is the raw value in BCD format to convert to Binary. //! \n Modified bits are \b BCD2BIN of \b BCD2BIN register. //! //! \return The binary version of the input parameter // //***************************************************************************** extern uint16_t RTC_C_convertBCDToBinary(uint16_t baseAddress, uint16_t valueToConvert); //***************************************************************************** // //! \brief Convert the given binary value to BCD format //! //! This function converts binary values to BCD format. This API uses the //! hardware registers to perform the conversion rather than a software method. //! //! \param baseAddress is the base address of the RTC_C module. //! \param valueToConvert is the raw value in Binary format to convert to BCD. //! \n Modified bits are \b BIN2BCD of \b BIN2BCD register. //! //! \return The BCD version of the valueToConvert parameter // //***************************************************************************** extern uint16_t RTC_C_convertBinaryToBCD(uint16_t baseAddress, uint16_t valueToConvert); //***************************************************************************** // // Mark the end of the C bindings section for C++ compilers. // //***************************************************************************** #ifdef __cplusplus } #endif #endif #endif // __MSP430WARE_RTC_C_H__