/* --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__ |