mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-06-05 03:49:03 -04:00
857 lines
39 KiB
C
857 lines
39 KiB
C
/* --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__
|