smart-green-house/project_ZigBee/Components/osal/common/OSAL_Clock.c

365 lines
11 KiB
C
Raw Permalink Normal View History

2023-10-28 18:00:47 +08:00
/******************************************************************************
Filename: OSAL_Clock.c
Revised: $Date: 2012-03-02 15:52:01 -0800 (Fri, 02 Mar 2012) $
Revision: $Revision: 29608 $
Description: OSAL Clock definition and manipulation functions.
Copyright 2008-2012 Texas Instruments Incorporated. All rights reserved.
IMPORTANT: Your use of this Software is limited to those specific rights
granted under the terms of a software license agreement between the user
who downloaded the software, his/her employer (which must be your employer)
and Texas Instruments Incorporated (the "License"). You may not use this
Software unless you agree to abide by the terms of the License. The License
limits your use, and you acknowledge, that the Software may not be modified,
copied or distributed unless embedded on a Texas Instruments microcontroller
or used solely and exclusively in conjunction with a Texas Instruments radio
frequency transceiver, which is integrated into your product. Other than for
the foregoing purpose, you may not use, reproduce, copy, prepare derivative
works of, modify, distribute, perform, display or sell this Software and/or
its documentation for any purpose.
YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
PROVIDED <EFBFBD>AS IS<EFBFBD> WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
(INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
Should you have any questions regarding your right to use this Software,
contact Texas Instruments Incorporated at www.TI.com.
******************************************************************************/
/*********************************************************************
* INCLUDES
*/
#include "comdef.h"
#include "OnBoard.h"
#include "OSAL.h"
#include "OSAL_Clock.h"
/*********************************************************************
* MACROS
*/
#define YearLength(yr) ((uint16)(IsLeapYear(yr) ? 366 : 365))
/*********************************************************************
* CONSTANTS
*/
#define BEGYEAR 2000 // UTC started at 00:00:00 January 1, 2000
#define DAY 86400UL // 24 hours * 60 minutes * 60 seconds
/*********************************************************************
* TYPEDEFS
*/
/*********************************************************************
* GLOBAL VARIABLES
*/
/*********************************************************************
* EXTERNAL VARIABLES
*/
/*********************************************************************
* EXTERNAL FUNCTIONS
*/
extern uint32 macMcuPrecisionCount(void);
#if (defined HAL_MCU_CC2430) || (defined HAL_MCU_CC2530) || (defined HAL_MCU_CC2533)
/* This function is used to divide a 31 bit dividend by a 16 bit
* divisor and return a packed 16 bit quotient and 16 bit
* remainder.
*
* Note: This routine takes ~25.6us @32MHz. With C overhead, the
* time is ~32us.
*
* dividend - 31 bit dividend.
* divisor - 16 bit divisor.
*
* return - MSW divisor; LSW quotient
*/
extern __near_func uint32 osalMcuDivide31By16To16( uint32 dividend, uint16 divisor );
#define CONVERT_320US_TO_MS_ELAPSED_REMAINDER( x, y, z ) st( \
\
/* The 16 bit quotient is in MSW and */ \
/* the 16 bit remainder is in LSW. */ \
x = osalMcuDivide31By16To16( x, 25 ); \
\
/* Add quotient to y */ \
y += (x >> 16); \
\
/* Copy remainder to z */ \
z = (uint16)(x & 0x0FFFF); \
)
#else /* (defined HAL_MCU_CC2430) || (defined HAL_MCU_CC2530) || (defined HAL_MCU_CC2533) */
#define CONVERT_320US_TO_MS_ELAPSED_REMAINDER( x, y, z ) st( \
y += x / 25; \
z = x % 25; \
)
#endif /* (defined HAL_MCU_CC2430) || (defined HAL_MCU_CC2530) || (defined HAL_MCU_CC2533) */
/*********************************************************************
* LOCAL VARIABLES
*/
static uint32 previousMacTimerTick = 0;
static uint16 remUsTicks = 0;
static uint16 timeMSec = 0;
// number of seconds since 0 hrs, 0 minutes, 0 seconds, on the
// 1st of January 2000 UTC
UTCTime OSAL_timeSeconds = 0;
/*********************************************************************
* LOCAL FUNCTION PROTOTYPES
*/
static uint8 monthLength( uint8 lpyr, uint8 mon );
static void osalClockUpdate( uint16 elapsedMSec );
/*********************************************************************
* FUNCTIONS
*********************************************************************/
/*********************************************************************
* @fn osalTimeUpdate
*
* @brief Uses the free running rollover count of the MAC backoff timer;
* this timer runs freely with a constant 320 usec interval. The
* count of 320-usec ticks is converted to msecs and used to update
* the OSAL clock and Timers by invoking osalClockUpdate() and
* osalTimerUpdate(). This function is intended to be invoked
* from the background, not interrupt level.
*
* @param None.
*
* @return None.
*/
void osalTimeUpdate( void )
{
halIntState_t intState;
uint32 tmp;
uint32 ticks320us;
uint16 elapsedMSec = 0;
HAL_ENTER_CRITICAL_SECTION(intState);
// Get the free-running count of 320us timer ticks
tmp = macMcuPrecisionCount();
HAL_EXIT_CRITICAL_SECTION(intState);
if ( tmp != previousMacTimerTick )
{
// Calculate the elapsed ticks of the free-running timer.
ticks320us = (tmp - previousMacTimerTick) & 0xffffffffu;
// Store the MAC Timer tick count for the next time through this function.
previousMacTimerTick = tmp;
// update converted number with remaining ticks from loop and the
// accumulated remainder from loop
tmp = (ticks320us * 8) + remUsTicks;
// Convert the 320 us ticks into milliseconds and a remainder
CONVERT_320US_TO_MS_ELAPSED_REMAINDER( tmp, elapsedMSec, remUsTicks );
// Update OSAL Clock and Timers
if ( elapsedMSec )
{
osalClockUpdate( elapsedMSec );
osalTimerUpdate( elapsedMSec );
}
}
}
/*********************************************************************
* @fn osalClockUpdate
*
* @brief Updates the OSAL Clock time with elapsed milliseconds.
*
* @param elapsedMSec - elapsed milliseconds
*
* @return none
*/
static void osalClockUpdate( uint16 elapsedMSec )
{
// Add elapsed milliseconds to the saved millisecond portion of time
timeMSec += elapsedMSec;
// Roll up milliseconds to the number of seconds
if ( timeMSec >= 1000 )
{
OSAL_timeSeconds += timeMSec / 1000;
timeMSec = timeMSec % 1000;
}
}
/*********************************************************************
* @fn osal_setClock
*
* @brief Set the new time. This will only set the seconds portion
* of time and doesn't change the factional second counter.
*
* @param newTime - number of seconds since 0 hrs, 0 minutes,
* 0 seconds, on the 1st of January 2000 UTC
*
* @return none
*/
void osal_setClock( UTCTime newTime )
{
OSAL_timeSeconds = newTime;
}
/*********************************************************************
* @fn osal_getClock
*
* @brief Gets the current time. This will only return the seconds
* portion of time and doesn't include the factional second
* counter.
*
* @param none
*
* @return number of seconds since 0 hrs, 0 minutes, 0 seconds,
* on the 1st of January 2000 UTC
*/
UTCTime osal_getClock( void )
{
return ( OSAL_timeSeconds );
}
/*********************************************************************
* @fn osal_ConvertUTCTime
*
* @brief Converts UTCTime to UTCTimeStruct
*
* @param tm - pointer to breakdown struct
*
* @param secTime - number of seconds since 0 hrs, 0 minutes,
* 0 seconds, on the 1st of January 2000 UTC
*
* @return none
*/
void osal_ConvertUTCTime( UTCTimeStruct *tm, UTCTime secTime )
{
// calculate the time less than a day - hours, minutes, seconds
{
uint32 day = secTime % DAY;
tm->seconds = day % 60UL;
tm->minutes = (day % 3600UL) / 60UL;
tm->hour = day / 3600UL;
}
// Fill in the calendar - day, month, year
{
uint16 numDays = secTime / DAY;
tm->year = BEGYEAR;
while ( numDays >= YearLength( tm->year ) )
{
numDays -= YearLength( tm->year );
tm->year++;
}
tm->month = 0;
while ( numDays >= monthLength( IsLeapYear( tm->year ), tm->month ) )
{
numDays -= monthLength( IsLeapYear( tm->year ), tm->month );
tm->month++;
}
tm->day = numDays;
}
}
/*********************************************************************
* @fn monthLength
*
* @param lpyr - 1 for leap year, 0 if not
*
* @param mon - 0 - 11 (jan - dec)
*
* @return number of days in specified month
*/
static uint8 monthLength( uint8 lpyr, uint8 mon )
{
uint8 days = 31;
if ( mon == 1 ) // feb
{
days = ( 28 + lpyr );
}
else
{
if ( mon > 6 ) // aug-dec
{
mon--;
}
if ( mon & 1 )
{
days = 30;
}
}
return ( days );
}
/*********************************************************************
* @fn osal_ConvertUTCSecs
*
* @brief Converts a UTCTimeStruct to UTCTime
*
* @param tm - pointer to provided struct
*
* @return number of seconds since 00:00:00 on 01/01/2000 (UTC)
*/
UTCTime osal_ConvertUTCSecs( UTCTimeStruct *tm )
{
uint32 seconds;
/* Seconds for the partial day */
seconds = (((tm->hour * 60UL) + tm->minutes) * 60UL) + tm->seconds;
/* Account for previous complete days */
{
/* Start with complete days in current month */
uint16 days = tm->day;
/* Next, complete months in current year */
{
int8 month = tm->month;
while ( --month >= 0 )
{
days += monthLength( IsLeapYear( tm->year ), month );
}
}
/* Next, complete years before current year */
{
uint16 year = tm->year;
while ( --year >= BEGYEAR )
{
days += YearLength( year );
}
}
/* Add total seconds before partial day */
seconds += (days * DAY);
}
return ( seconds );
}