661 lines
15 KiB
C
661 lines
15 KiB
C
/**
|
|
******************************************************************************
|
|
* File Name : brtc.c
|
|
* Description : This file provides code for the configuration
|
|
* of board real time clock.
|
|
******************************************************************************
|
|
* @attention
|
|
*
|
|
* <h2><center>© Copyright (c) 2019 STMicroelectronics.
|
|
* All rights reserved.</center></h2>
|
|
*
|
|
* This software component is licensed by ST under Ultimate Liberty license
|
|
* SLA0044, the "License"; You may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at:
|
|
* www.st.com/SLA0044
|
|
*
|
|
******************************************************************************
|
|
*/
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include "brtc.h"
|
|
#include "includes.h"
|
|
#include "date_calc.h"
|
|
#include "app_ver.h"
|
|
#include "asutil.h"
|
|
#include "device_param.h"
|
|
#include "dflash_sf1.h"
|
|
#include "dflash_chg_ctrl.h"
|
|
#include "vi.h"
|
|
#include "io.h"
|
|
#include "calc_soc.h"
|
|
#include "alarm.h"
|
|
#include "pl455_comm.h"
|
|
#include "task_manager.h"
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
/* Private define ------------------------------------------------------------*/
|
|
/* Uncomment the corresponding line to select the RTC Clock source */
|
|
#define RTC_CLOCK_SOURCE_LSE /* LSE used as RTC source clock */
|
|
/*#define RTC_CLOCK_SOURCE_LSI *//* LSI used as RTC source clock. The RTC Clock
|
|
may varies due to LSI frequency dispersion. */
|
|
|
|
#define FIRST_DATA 0x32F2
|
|
/* Private macro -------------------------------------------------------------*/
|
|
/* Private variables ---------------------------------------------------------*/
|
|
RTC_TimeTypeDef RTC_TimeStructure;
|
|
RTC_InitTypeDef RTC_InitStructure;
|
|
RTC_DateTypeDef RTC_DateStructure;
|
|
|
|
vu32 AsynchPrediv = 0, SynchPrediv = 0;
|
|
|
|
vu32 LocalTime; /* this variable is used to create a time reference incremented by 10ms */
|
|
|
|
u32 UnixTimeStamp, BakUnixTimeStamp, disUnixTimeStamp, SetUnixTimeStamp;
|
|
u32 BuildTimeStamp;
|
|
|
|
struct DateAndTime aDateAndTime;
|
|
|
|
u32 OptimeStamp, disOptimeStamp;
|
|
|
|
_TTIME DEVICE_TIME, SetTime;
|
|
u8 bak_sec;
|
|
|
|
OS_TMR RTC_TMR;
|
|
|
|
u8 reset_flag = 0;
|
|
u8 set_time_flag = 0;
|
|
|
|
u32 WarmingUp = WARMING_UP_TIME;
|
|
|
|
const uint8_t samurai[] = {31,28,31,30,31,30,31,31,30,31,30,31};
|
|
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
void Get_Time(void);
|
|
|
|
void RTC_Config(void);
|
|
void RTC_TimeRegulate(void);
|
|
void Real_RTC_Init(void);
|
|
void RTC_Update(_PTIME datetime);
|
|
u32 GetRealTimeStamp(void);
|
|
|
|
/* Private functions ---------------------------------------------------------*/
|
|
|
|
void Init_RTC(void)
|
|
{
|
|
OS_ERR err;
|
|
|
|
#ifdef CONSOLE_DEBUG
|
|
BuildTimeStamp = GetBuildTimeStamp();
|
|
#endif // #ifdef CONSOLE_DEBUG
|
|
|
|
|
|
OSTmrCreate (&RTC_TMR,
|
|
"RTC Timer",
|
|
100,
|
|
1,
|
|
OS_OPT_TMR_PERIODIC,
|
|
(OS_TMR_CALLBACK_PTR)&Time_Update,
|
|
NULL,
|
|
&err);
|
|
OSTmrStart (&RTC_TMR,
|
|
&err);
|
|
|
|
Real_RTC_Init();
|
|
|
|
UnixTimeStamp = GetRealTimeStamp();
|
|
|
|
aDateAndTime.year = reverse16(2016);
|
|
aDateAndTime.month = 5;
|
|
aDateAndTime.day = 2;
|
|
aDateAndTime.hour = 10;
|
|
aDateAndTime.minutes = 46;
|
|
aDateAndTime.seconds = 30;
|
|
aDateAndTime.deci_seconds = 3;
|
|
aDateAndTime.UTC_direction = '+';
|
|
aDateAndTime.UTC_hours = 8;
|
|
aDateAndTime.UTC_minutes = 0;
|
|
|
|
OptimeStamp = 0;
|
|
}
|
|
|
|
void Real_RTC_Init(void)
|
|
{
|
|
if (RTC_ReadBackupRegister(RTC_BKP_DR0) != FIRST_DATA)
|
|
{
|
|
/* RTC configuration */
|
|
RTC_Config();
|
|
|
|
/* Configure the RTC data register and RTC prescaler */
|
|
RTC_InitStructure.RTC_AsynchPrediv = AsynchPrediv;
|
|
RTC_InitStructure.RTC_SynchPrediv = SynchPrediv;
|
|
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
|
|
|
|
/* Check on RTC init */
|
|
if (RTC_Init(&RTC_InitStructure) == ERROR)
|
|
{
|
|
// APP_TRACE("\r\n /!\\***** RTC Prescaler Config failed ********/!\\ \n\r");
|
|
}
|
|
|
|
/* Configure the time register */
|
|
RTC_TimeRegulate();
|
|
}
|
|
else
|
|
{
|
|
/* Check if the Power On Reset flag is set */
|
|
if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
|
|
{
|
|
reset_flag = 1;
|
|
}
|
|
/* Check if the Pin Reset flag is set */
|
|
else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
|
|
{
|
|
reset_flag = 2;
|
|
}
|
|
/* Enable the PWR clock */
|
|
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
|
|
|
|
/* Allow access to RTC */
|
|
PWR_BackupAccessCmd(ENABLE);
|
|
|
|
/* Wait for RTC APB registers synchronisation */
|
|
RTC_WaitForSynchro();
|
|
}
|
|
}
|
|
|
|
u8 GetResetFlag(void)
|
|
{
|
|
u8 result = reset_flag;
|
|
|
|
reset_flag = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
u16 GetTimeYear(void)
|
|
{
|
|
return (DEVICE_TIME.year + UTC_YEAR);
|
|
}
|
|
|
|
u16 GetTimeMonth(void)
|
|
{
|
|
return DEVICE_TIME.month;
|
|
}
|
|
|
|
u16 GetTimeDate(void)
|
|
{
|
|
return DEVICE_TIME.date;
|
|
}
|
|
|
|
u16 GetTimeHour(void)
|
|
{
|
|
return DEVICE_TIME.hour;
|
|
}
|
|
|
|
u16 GetTimeMinute(void)
|
|
{
|
|
return DEVICE_TIME.min;
|
|
}
|
|
|
|
u16 GetTimeSec(void)
|
|
{
|
|
return DEVICE_TIME.sec;
|
|
}
|
|
|
|
u16 GetTimeSubSec(void)
|
|
{
|
|
return DEVICE_TIME.sub_sec;
|
|
}
|
|
|
|
u32 GetTimeStamp(void)
|
|
{
|
|
return UnixTimeStamp;
|
|
}
|
|
|
|
/**
|
|
* @brief Configure the RTC peripheral by selecting the clock source.
|
|
* @param None
|
|
* @retval None
|
|
*/
|
|
void RTC_Config(void)
|
|
{
|
|
/* Enable the PWR clock */
|
|
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
|
|
|
|
/* Allow access to RTC */
|
|
PWR_BackupAccessCmd(ENABLE);
|
|
|
|
/* Enable the LSE OSC */
|
|
RCC_LSEConfig(RCC_LSE_ON);
|
|
|
|
/* Wait till LSE is ready */
|
|
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
|
|
{
|
|
}
|
|
|
|
/* Select the RTC Clock Source */
|
|
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
|
|
|
|
SynchPrediv = 0xFF;
|
|
AsynchPrediv = 0x7F;
|
|
|
|
/* Enable the RTC Clock */
|
|
RCC_RTCCLKCmd(ENABLE);
|
|
|
|
/* Wait for RTC APB registers synchronisation */
|
|
RTC_WaitForSynchro();
|
|
}
|
|
|
|
void RTC_TimeRegulate(void)
|
|
{
|
|
Get_Time();
|
|
|
|
RTC_TimeStructure.RTC_Hours = DEVICE_TIME.hour;
|
|
RTC_TimeStructure.RTC_Minutes = DEVICE_TIME.min;
|
|
RTC_TimeStructure.RTC_Seconds = DEVICE_TIME.sec;
|
|
|
|
/* Set the Date */
|
|
RTC_DateStructure.RTC_Month = DEVICE_TIME.month;
|
|
RTC_DateStructure.RTC_Date = DEVICE_TIME.date;
|
|
RTC_DateStructure.RTC_Year = (DEVICE_TIME.year + 1970) % 100;
|
|
RTC_DateStructure.RTC_WeekDay = DEVICE_TIME.wday;
|
|
|
|
/* Configure the RTC time register */
|
|
RTC_SetTime(RTC_Format_BIN, &RTC_TimeStructure);
|
|
RTC_SetDate(RTC_Format_BIN, &RTC_DateStructure);
|
|
|
|
RTC_TimeShow();
|
|
/* Indicator for the RTC configuration */
|
|
RTC_WriteBackupRegister(RTC_BKP_DR0, FIRST_DATA);
|
|
}
|
|
|
|
void RTC_TimeSet(_TTIME *aTIME)
|
|
{
|
|
int diffhour = DEVICE_TIME.hour - aTIME->hour;
|
|
int diffmin = DEVICE_TIME.min - aTIME->min;
|
|
|
|
if ((diffhour > 0) || ((diffmin > 2) || (diffmin < -2)))
|
|
{
|
|
RTC_TimeStructure.RTC_Hours = aTIME->hour;
|
|
RTC_TimeStructure.RTC_Minutes = aTIME->min;
|
|
RTC_TimeStructure.RTC_Seconds = aTIME->sec;
|
|
|
|
/* Set the Date */
|
|
RTC_DateStructure.RTC_Month = aTIME->month;
|
|
RTC_DateStructure.RTC_Date = aTIME->date;
|
|
RTC_DateStructure.RTC_Year = (aTIME->year) % 100;
|
|
RTC_DateStructure.RTC_WeekDay = aTIME->wday;
|
|
|
|
/* Configure the RTC time register */
|
|
RTC_SetTime(RTC_Format_BIN, &RTC_TimeStructure);
|
|
RTC_SetDate(RTC_Format_BIN, &RTC_DateStructure);
|
|
}
|
|
}
|
|
|
|
void RTC_TimeShow(void)
|
|
{
|
|
u32 aa[2];
|
|
|
|
/* Get the current Time */
|
|
RTC_GetDate(RTC_Format_BIN, &RTC_DateStructure);
|
|
aa[0] = (u32)RTC->TR;
|
|
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
|
|
aa[1] = (u32)RTC->DR;
|
|
|
|
printf("\r\nDate : 0x%08X[0x%08X]", aa[0], aa[1]);
|
|
printf("\r\nThe current datetime is : %0.2d/%0.2d/%0.2d %0.2d:%0.2d:%0.2d \r\n",
|
|
RTC_DateStructure.RTC_Year,
|
|
RTC_DateStructure.RTC_Month,
|
|
RTC_DateStructure.RTC_Date,
|
|
RTC_TimeStructure.RTC_Hours,
|
|
RTC_TimeStructure.RTC_Minutes,
|
|
RTC_TimeStructure.RTC_Seconds
|
|
);
|
|
}
|
|
|
|
u32 Get_Local_Time(void)
|
|
{
|
|
return LocalTime;
|
|
}
|
|
|
|
void Set_Local_Time(u32 localtime)
|
|
{
|
|
LocalTime = localtime;
|
|
}
|
|
|
|
u32 GetRealTimeStamp(void)
|
|
{
|
|
u32 DateTimeStamp;
|
|
u32 iTotalDays;
|
|
_TTIME aTime;
|
|
|
|
/* Get the current Time */
|
|
RTC_GetDate(RTC_Format_BIN, &RTC_DateStructure);
|
|
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
|
|
|
|
aTime.hour = RTC_TimeStructure.RTC_Hours;
|
|
aTime.min = RTC_TimeStructure.RTC_Minutes;
|
|
aTime.sec = RTC_TimeStructure.RTC_Seconds;
|
|
|
|
aTime.month = RTC_DateStructure.RTC_Month;
|
|
aTime.date = RTC_DateStructure.RTC_Date;
|
|
aTime.year = ((CPU_INT16U)RTC_DateStructure.RTC_Year + 2000)- UTC_YEAR;
|
|
aTime.wday = RTC_DateStructure.RTC_WeekDay;
|
|
|
|
iTotalDays = CalcDay((u32)aTime.year + UTC_YEAR,
|
|
aTime.month,
|
|
aTime.date);
|
|
|
|
DateTimeStamp = iTotalDays - UTC_TIMESTAMP;
|
|
|
|
return (DateStampToTimeStamp(DateTimeStamp) +
|
|
((u32)aTime.hour * 60 * 60) +
|
|
((u32)aTime.min * 60) +
|
|
((u32)aTime.sec));
|
|
}
|
|
|
|
void SetRealTimeStamp(u32 NewTimeStamp)
|
|
{
|
|
UnixTimeStamp = NewTimeStamp;
|
|
|
|
Get_Time();
|
|
|
|
RTC_TimeRegulate();
|
|
}
|
|
|
|
void SetUpTimeStamp(s16 value, u8 MsbLsb)
|
|
{
|
|
if (MsbLsb == 1) {
|
|
if (set_time_flag == 0) {
|
|
SetUnixTimeStamp = 0;
|
|
SetUnixTimeStamp |= ((u32)((value << 16)& 0xFFFF0000));
|
|
set_time_flag = 1;
|
|
}
|
|
} else {
|
|
if (set_time_flag == 1) {
|
|
SetUnixTimeStamp |= (u32)((value << 0)& 0x0000FFFF);
|
|
set_time_flag = 2;
|
|
}
|
|
}
|
|
|
|
if (set_time_flag == 2) {
|
|
SetRealTimeStamp(SetUnixTimeStamp);
|
|
set_time_flag = 0;
|
|
}
|
|
}
|
|
|
|
void *GetDateAndTimeEx(void)
|
|
{
|
|
return (void *)&aDateAndTime;
|
|
}
|
|
|
|
void Get_Time(void)
|
|
{
|
|
UnixTimeStamp = GetRealTimeStamp();
|
|
|
|
if (UnixTimeStamp != BakUnixTimeStamp)
|
|
{
|
|
CalcTimeStampToDateTime(UnixTimeStamp + UTC_KOREA, &DEVICE_TIME);
|
|
BakUnixTimeStamp = UnixTimeStamp;
|
|
}
|
|
}
|
|
|
|
#ifdef CONSOLE_DEBUG
|
|
|
|
u32 GetBuildTimeStamp(void)
|
|
{
|
|
u8 datetime[15];
|
|
u32 DateTimeStamp;
|
|
u32 iTotalDays;
|
|
_TTIME aTime;
|
|
|
|
GET_BUILD_DATETIME(datetime);
|
|
datetime[14] = 0;
|
|
|
|
printf("Build : %s", datetime);
|
|
|
|
aTime.year = StrToInt32(&datetime[ 0], 4) - UTC_YEAR;
|
|
aTime.month = StrToInt32(&datetime[ 4], 2);
|
|
aTime.date = StrToInt32(&datetime[ 6], 2);
|
|
aTime.hour = StrToInt32(&datetime[ 8], 2);
|
|
aTime.min = StrToInt32(&datetime[10], 2);
|
|
aTime.sec = StrToInt32(&datetime[12], 2);
|
|
|
|
iTotalDays = CalcDay((u32)aTime.year + UTC_YEAR,
|
|
aTime.month,
|
|
aTime.date);
|
|
|
|
DateTimeStamp = iTotalDays - UTC_TIMESTAMP;
|
|
|
|
return (DateStampToTimeStamp(DateTimeStamp) +
|
|
((u32)aTime.hour * 60 * 60) +
|
|
((u32)aTime.min * 60) +
|
|
((u32)aTime.sec));
|
|
}
|
|
|
|
void Get_TimeStr(u8 *text)
|
|
{
|
|
Int32ToStr((DEVICE_TIME.year % 100)+ 1970, text, 4);
|
|
Int32ToStr((DEVICE_TIME.month % 100), &text[ 4], 2);
|
|
Int32ToStr((DEVICE_TIME.date % 100), &text[ 6], 2);
|
|
Int32ToStr((DEVICE_TIME.hour % 100), &text[ 8], 2);
|
|
Int32ToStr((DEVICE_TIME.min % 100), &text[10], 2);
|
|
Int32ToStr((DEVICE_TIME.sec % 100), &text[12], 2);
|
|
}
|
|
|
|
/* input(ASCII) : YYYYMMDDhhmmss */
|
|
s8 Set_Time(u8 *time)
|
|
{
|
|
u16 size, i;
|
|
|
|
size = 0;
|
|
|
|
while (time[size] != 0x00) size++; /* Measure total string length */
|
|
|
|
if (size != 14 ) return 1;
|
|
|
|
i = 0;
|
|
|
|
DEVICE_TIME.year = (StrToInt(&time[i], 4)) - 1970; i += 4;
|
|
DEVICE_TIME.month = StrToInt(&time[i], 2); i += 2;
|
|
DEVICE_TIME.date = StrToInt(&time[i], 2); i += 2;
|
|
DEVICE_TIME.hour = StrToInt(&time[i], 2); i += 2;
|
|
DEVICE_TIME.min = StrToInt(&time[i], 2); i += 2;
|
|
DEVICE_TIME.sec = StrToInt(&time[i], 2); i += 2;
|
|
DEVICE_TIME.sub_sec = 0;
|
|
|
|
/* Allow access to RTC */
|
|
PWR_BackupAccessCmd(ENABLE);
|
|
|
|
/* Wait for RTC APB registers synchronisation */
|
|
RTC_WaitForSynchro();
|
|
|
|
RTC_TimeStructure.RTC_Hours = DEVICE_TIME.hour;
|
|
RTC_TimeStructure.RTC_Minutes = DEVICE_TIME.min;
|
|
RTC_TimeStructure.RTC_Seconds = DEVICE_TIME.sec;
|
|
|
|
/* Set the Date */
|
|
RTC_DateStructure.RTC_Month = DEVICE_TIME.month;
|
|
RTC_DateStructure.RTC_Date = DEVICE_TIME.date;
|
|
RTC_DateStructure.RTC_Year = (DEVICE_TIME.year + 1970) % 100;
|
|
RTC_DateStructure.RTC_WeekDay = DEVICE_TIME.wday;
|
|
|
|
/* Configure the RTC time register */
|
|
RTC_SetTime(RTC_Format_BIN, &RTC_TimeStructure);
|
|
RTC_SetDate(RTC_Format_BIN, &RTC_DateStructure);
|
|
|
|
RTC_TimeShow();
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif // #ifdef CONSOLE_DEBUG
|
|
|
|
/*------------------------------------------*/
|
|
/* Get time in UTC */
|
|
/*------------------------------------------*/
|
|
|
|
int rtc_getutc (uint32_t* tmr)
|
|
{
|
|
*tmr = UnixTimeStamp;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*------------------------------------------*/
|
|
/* Get time in calendar form */
|
|
/*------------------------------------------*/
|
|
|
|
int rtc_gettime (_TTIME* rtc)
|
|
{
|
|
rtc->year = DEVICE_TIME.year + UTC_YEAR;
|
|
rtc->month = DEVICE_TIME.month;
|
|
rtc->date = DEVICE_TIME.date;
|
|
rtc->wday = DEVICE_TIME.wday;
|
|
|
|
rtc->hour = DEVICE_TIME.hour;
|
|
rtc->min = DEVICE_TIME.min;
|
|
rtc->sec = DEVICE_TIME.sec;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int rtc_gettime1 (_TTIME* rtc)
|
|
{
|
|
uint32_t utc, n, i, d;
|
|
|
|
if (!rtc_getutc(&utc)) return 0;
|
|
|
|
utc += (long)(UTC_KOREA);
|
|
|
|
rtc->sec = (uint8_t)(utc % 60); utc /= 60;
|
|
rtc->min = (uint8_t)(utc % 60); utc /= 60;
|
|
rtc->hour = (uint8_t)(utc % 24); utc /= 24;
|
|
rtc->date = (uint8_t)((utc + 4) % 7);
|
|
rtc->year = (uint16_t)(1970 + utc / 1461 * 4); utc %= 1461;
|
|
n = ((utc >= 1096) ? utc - 1 : utc) / 365;
|
|
rtc->year += n;
|
|
utc -= n * 365 + (n > 2 ? 1 : 0);
|
|
for (i = 0; i < 12; i++) {
|
|
d = samurai[i];
|
|
if (i == 1 && n == 2) d++;
|
|
if (utc < d) break;
|
|
utc -= d;
|
|
}
|
|
rtc->month = (uint8_t)(1 + i);
|
|
rtc->date = (uint8_t)(1 + utc);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the current time in milliseconds
|
|
* when LWIP_TIMERS == 1 and NO_SYS == 1
|
|
* @param None
|
|
* @retval Time
|
|
*/
|
|
u32 sys_now(void)
|
|
{
|
|
// return HAL_GetTick();
|
|
return LocalTime;
|
|
}
|
|
|
|
u32 GetWarmingUp(void)
|
|
{
|
|
return WarmingUp;
|
|
}
|
|
|
|
void WarmingUp_Process(u16 tick)
|
|
{
|
|
if (WarmingUp > tick)
|
|
{
|
|
WarmingUp -= tick;
|
|
}
|
|
else
|
|
{
|
|
device_status.battery_status.bit.INIT = true;
|
|
}
|
|
}
|
|
|
|
void Time_Update(void *ptmr, void *parg)
|
|
{
|
|
LocalTime += RTC_TMR_PERIOD_TIME;
|
|
|
|
DEVICE_TIME.sub_sec++;
|
|
|
|
if (DEVICE_TIME.sub_sec >= 100)
|
|
{
|
|
OptimeStamp++;
|
|
DEVICE_TIME.sub_sec = 0;
|
|
}
|
|
Get_Time();
|
|
|
|
WarmingUp_Process(RTC_TMR_PERIOD_TIME);
|
|
DecIOTaskTick(RTC_TMR_PERIOD_TIME);
|
|
|
|
Calculation_10ms_Current(RTC_TMR_PERIOD_TIME);
|
|
|
|
dec_cb_tick(RTC_TMR_PERIOD_TIME);
|
|
dec_soc_tick(RTC_TMR_PERIOD_TIME);
|
|
|
|
dec_relexation_tick(RTC_TMR_PERIOD_TIME);
|
|
dec_tapper_tick(RTC_TMR_PERIOD_TIME);
|
|
|
|
dec_alarm_tick(RTC_TMR_PERIOD_TIME);
|
|
|
|
#ifdef CONSOLE_DEBUG
|
|
CalOSTaskCtxSwCtrPerSec(RTC_TMR_PERIOD_TIME);
|
|
#endif // #ifdef CONSOLE_DEBUG
|
|
|
|
IWDG_ReloadCounter();
|
|
}
|
|
|
|
/* Display Function *************************************************/
|
|
#ifdef CONSOLE_DEBUG
|
|
|
|
void ODisplayDateTime(u8 p)
|
|
{
|
|
u8 text[30];
|
|
|
|
if (p || (DEVICE_TIME.sec != bak_sec))
|
|
{
|
|
sprintf((char *)text, "%04d/%02d/%02d",
|
|
DEVICE_TIME.year + UTC_YEAR,
|
|
DEVICE_TIME.month,
|
|
DEVICE_TIME.date
|
|
);
|
|
GreenOutXY(70, 19, text);
|
|
|
|
sprintf((char *)text, "%02d:%02d:%02d",
|
|
DEVICE_TIME.hour,
|
|
DEVICE_TIME.min,
|
|
DEVICE_TIME.sec
|
|
);
|
|
GreenOutXY(71, 20, text);
|
|
bak_sec = DEVICE_TIME.sec;
|
|
}
|
|
}
|
|
|
|
void SDisplayDateTime(u8 p)
|
|
{
|
|
u8 text[30];
|
|
|
|
if (p || (DEVICE_TIME.sec != bak_sec))
|
|
{
|
|
sprintf((char *)text, "%04d%02d%02d%02d%02d%02d",
|
|
DEVICE_TIME.year + UTC_YEAR,
|
|
DEVICE_TIME.month,
|
|
DEVICE_TIME.date,
|
|
DEVICE_TIME.hour,
|
|
DEVICE_TIME.min,
|
|
DEVICE_TIME.sec
|
|
);
|
|
GreenOutXY(65, 16, text);
|
|
|
|
bak_sec = DEVICE_TIME.sec;
|
|
}
|
|
}
|
|
|
|
#endif // #ifdef CONSOLE_DEBUG
|
|
|