573 lines
13 KiB
C
573 lines
13 KiB
C
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include <sys/prctl.h>
|
|
#include <dirent.h>
|
|
#include <sys/types.h>
|
|
#include <sys/dir.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <time.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <signal.h>
|
|
|
|
|
|
#include "../inc/type.h"
|
|
#include "../inc/isys_com.h"
|
|
#include "../inc/ipara_cfg.h"
|
|
#include "../inc/eeprom.h"
|
|
#include "../inc/i2c_drv.h"
|
|
|
|
|
|
#define SYNC_PARA_TO_BKP_FILE "sh /aw/anywave/sync_to_bkp_file.sh"
|
|
#define LOAD_PARA_TO_CFG_FILE "sh /aw/anywave/load_to_cfg_file.sh"
|
|
extern int executeCMD(const char *cmd, char *result, u16 result_size);
|
|
|
|
typedef void (*sighandler_t)(int);
|
|
|
|
|
|
int read_file_data(char *file_name,char *buff, int len)
|
|
{
|
|
int fd;
|
|
int ret = 0;
|
|
|
|
fd = open(file_name,O_RDONLY);
|
|
if(fd == -1) {
|
|
log_printf(LOG_ERR,I_NOUSED," open %s failed\n",file_name);
|
|
return -1;
|
|
}
|
|
|
|
if(read(fd,buff,len)==-1) {
|
|
log_printf(LOG_ERR,I_NOUSED,"read %d bytes from %s failed\n", len, file_name);
|
|
close(fd);
|
|
return -1;
|
|
} else {
|
|
close(fd);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int check_file_exist(char *filename)
|
|
{
|
|
if(filename == NULL) {
|
|
log_printf(LOG_ERR,I_NOUSED,"filename is null. \n");
|
|
return -1;
|
|
}
|
|
|
|
int ret;
|
|
if(!access(filename, F_OK))
|
|
return 0;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
#if 1//verify_sys_com
|
|
|
|
unsigned long get_sys_tick(void) // 10ms
|
|
{
|
|
struct timeval tv;
|
|
struct timezone tz;
|
|
|
|
gettimeofday(&tv, &tz);
|
|
|
|
return (unsigned long)(tv.tv_sec*1000+tv.tv_usec/1000);
|
|
|
|
//return ((unsigned long) time( NULL)); // us
|
|
}
|
|
|
|
int get_sys_time(S_SYS_TIME *ptime)
|
|
{
|
|
if(!ptime)
|
|
return -1;
|
|
|
|
/*ptime->hour = date_time.hour;
|
|
ptime->min = date_time.min;
|
|
ptime->sec = date_time.sec;
|
|
ptime->date = date_time.date;
|
|
ptime->month= date_time.month;
|
|
ptime->year = date_time.year;*/
|
|
|
|
struct tm *tim;
|
|
struct timeval t;
|
|
time_t b_time;
|
|
|
|
|
|
b_time = time(NULL);
|
|
tim = localtime(&b_time);
|
|
// gettimeofday(&t, NULL);
|
|
|
|
ptime->hour = tim->tm_hour;
|
|
ptime->min = tim->tm_min;
|
|
ptime->sec = tim->tm_sec;
|
|
|
|
ptime->date = tim->tm_mday;
|
|
ptime->month= tim->tm_mon + 1;
|
|
ptime->year = tim->tm_year + 1900;
|
|
|
|
//printf("%d-%d-%d %d:%d:%d\n",ptime->year,ptime->month, ptime->date, ptime->hour,ptime->min,ptime->sec );
|
|
|
|
return ((int)tim->tm_wday);
|
|
}
|
|
|
|
|
|
void utc2localtime(time_t tUtcTime, struct tm *ptNow, int iZoneOffset)
|
|
{
|
|
int month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
|
|
|
if (tUtcTime <= 0 || ptNow == NULL) {
|
|
return;
|
|
}
|
|
|
|
gmtime_r(&tUtcTime, ptNow);
|
|
|
|
ptNow->tm_year += 1900;
|
|
ptNow->tm_mon += 1;
|
|
|
|
ptNow->tm_hour += iZoneOffset;
|
|
|
|
if (ptNow->tm_hour >= 24) {
|
|
ptNow->tm_hour -= 24;
|
|
ptNow->tm_mday += 1;
|
|
} else if (ptNow->tm_hour < 0) {
|
|
ptNow->tm_hour += 24;
|
|
ptNow->tm_mday -= 1;
|
|
}
|
|
|
|
int current_month_max = month[ptNow->tm_mon];
|
|
if (ptNow->tm_mon == 2) {
|
|
if ((ptNow->tm_year % 400 == 0) || (ptNow->tm_year % 4 == 0 && ptNow->tm_year % 100 != 0)) {
|
|
current_month_max = 29;
|
|
}
|
|
}
|
|
|
|
if (ptNow->tm_mday > current_month_max) {
|
|
ptNow->tm_mday = 1;
|
|
ptNow->tm_mon += 1;
|
|
} else if (ptNow->tm_mday < 1) {
|
|
ptNow->tm_mon -= 1;
|
|
if (ptNow->tm_mon < 1) {
|
|
ptNow->tm_mon = 12;
|
|
ptNow->tm_year -= 1;
|
|
}
|
|
|
|
int prev_month = ptNow->tm_mon;
|
|
int prev_month_max = month[prev_month];
|
|
if (prev_month == 2) {
|
|
if ((ptNow->tm_year % 400 == 0) || (ptNow->tm_year % 4 == 0 && ptNow->tm_year % 100 != 0)) {
|
|
prev_month_max = 29;
|
|
}
|
|
}
|
|
ptNow->tm_mday = prev_month_max;
|
|
}
|
|
|
|
if (ptNow->tm_mon > 12) {
|
|
ptNow->tm_mon = 1;
|
|
ptNow->tm_year += 1;
|
|
} else if (ptNow->tm_mon < 1) {
|
|
ptNow->tm_mon = 12;
|
|
ptNow->tm_year -= 1;
|
|
}
|
|
}
|
|
|
|
|
|
void get_beijing_time(struct tm *ptmBJ)
|
|
{
|
|
time_t time_cur = 0;
|
|
int BeiJing_zone_dffset = 8; //Beijing +8
|
|
|
|
memset(ptmBJ, 0, sizeof(struct tm));
|
|
|
|
time_cur = time(NULL);
|
|
|
|
utc2localtime(time_cur, ptmBJ, BeiJing_zone_dffset);
|
|
}
|
|
|
|
void set_sys_time(S_SYS_TIME *p)
|
|
{
|
|
#if 1
|
|
struct tm tptr;
|
|
struct timeval tv;
|
|
|
|
if(!p) {
|
|
return;
|
|
}
|
|
|
|
tptr.tm_year = p->year - 1900;
|
|
tptr.tm_mon = p->month - 1;
|
|
tptr.tm_mday = p->date;
|
|
tptr.tm_hour = p->hour;
|
|
tptr.tm_min = p->min;
|
|
tptr.tm_sec = p->sec;
|
|
|
|
tv.tv_sec = mktime(&tptr);
|
|
tv.tv_usec = 0;
|
|
settimeofday(&tv, NULL);
|
|
|
|
#else
|
|
|
|
RTC_DateTypeDef date;
|
|
RTC_TimeTypeDef time;
|
|
|
|
if(!p) {
|
|
return;
|
|
}
|
|
|
|
date.RTC_Year = p->year-2000;
|
|
date.RTC_Date = p->date;
|
|
date.RTC_Month= p->month;
|
|
|
|
time.RTC_Hours = p->hour;
|
|
time.RTC_Minutes= p->min;
|
|
time.RTC_Seconds= p->sec;
|
|
|
|
rtc_set_date_time(&date,&time);
|
|
#endif
|
|
|
|
}
|
|
|
|
void usr_print_current_time(void)
|
|
{
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"time: %d.%d\n",tv.tv_sec,tv.tv_usec/1000);
|
|
}
|
|
|
|
uint32 usr_get_cur_time_ms(void)
|
|
{
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return (tv.tv_sec*1000+tv.tv_usec/1000);
|
|
// printf("time: %d.%d\n",tv.tv_sec,tv.tv_usec/1000);
|
|
}
|
|
|
|
|
|
void thread_setnamev(const char* pname)
|
|
{
|
|
prctl(PR_SET_NAME,pname,NULL,NULL,NULL);
|
|
}
|
|
|
|
#if 1
|
|
#include <stdarg.h>
|
|
static struct tm bkp_time={0};
|
|
|
|
int check_sec_change(void)
|
|
{
|
|
int ret=-1;
|
|
struct tm *tim;
|
|
struct tm *bk_tim;
|
|
static struct tm bkp_time={0};
|
|
time_t t_time;
|
|
|
|
t_time = time(NULL);
|
|
tim = localtime(&t_time);
|
|
if(tim->tm_sec != bkp_time.tm_sec){
|
|
bkp_time.tm_sec = tim->tm_sec;
|
|
//printf("sec=%d\n",tim->tm_sec);
|
|
ret = 1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
void printf_wrapperV(const char* format, va_list args_list)
|
|
{
|
|
vprintf(format, args_list);
|
|
}
|
|
|
|
void usr_sec_printf(const char* format, ...)
|
|
{
|
|
va_list marker;
|
|
|
|
if(check_sec_change()>0)
|
|
{
|
|
va_start(marker, format);
|
|
printf_wrapperV(format, marker);
|
|
va_end(marker);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
int pox_system(const char *cmd_line)
|
|
{
|
|
int ret = 0;
|
|
sighandler_t old_handler;
|
|
old_handler = signal(SIGCHLD, SIG_DFL);
|
|
ret = system(cmd_line);
|
|
signal(SIGCHLD, old_handler);
|
|
return ret;
|
|
}
|
|
|
|
int usr_set_sys_rtc_time(S_SYS_TIME *psys_time)
|
|
{
|
|
char cmd[100] = {0};
|
|
struct tm usr_tm;
|
|
struct tm *p_utc_tm;
|
|
int zone_offset = 0; // beijing +8
|
|
|
|
|
|
usr_tm.tm_year = psys_time->year;// 2022-1900
|
|
usr_tm.tm_mon = psys_time->month-1;
|
|
usr_tm.tm_mday = psys_time->date;
|
|
usr_tm.tm_hour = psys_time->hour;
|
|
usr_tm.tm_min = psys_time->min;
|
|
usr_tm.tm_sec = psys_time->sec;
|
|
|
|
time_t timestamp = mktime(&usr_tm) - (zone_offset*60*60);
|
|
|
|
p_utc_tm = localtime(×tamp);
|
|
if(p_utc_tm==NULL)
|
|
return -1;
|
|
|
|
memset(cmd, 0, sizeof(cmd));
|
|
sprintf(cmd, "date -s '%d-%02d-%02d %02d:%02d:%02d'",
|
|
p_utc_tm->tm_year+1900,
|
|
p_utc_tm->tm_mon+1,
|
|
p_utc_tm->tm_mday,
|
|
p_utc_tm->tm_hour,
|
|
p_utc_tm->tm_min,
|
|
p_utc_tm->tm_sec);
|
|
|
|
|
|
log_printf(LOG_DEBUG,I_NOUSED,"cmd=%s\n", cmd);
|
|
|
|
system(cmd);
|
|
|
|
system("hwclock -w");
|
|
|
|
}
|
|
|
|
void usr_get_sys_rtc_time(S_SYS_TIME *psys_time,S_ADVANCE_DT_PARA *pdt_time)
|
|
{
|
|
time_t time_cur = 0;
|
|
struct tm tmBJ;
|
|
int BeiJing_zone_dffset = 8; //Beijing +8
|
|
|
|
|
|
memset(&tmBJ, 0, sizeof(struct tm));
|
|
time_cur = time(NULL);
|
|
utc2localtime(time_cur, &tmBJ, BeiJing_zone_dffset);
|
|
|
|
if(pdt_time!=NULL){
|
|
pdt_time->dd.RTC_Year = tmBJ.tm_year-1900;
|
|
pdt_time->dd.RTC_Month = tmBJ.tm_mon;
|
|
pdt_time->dd.RTC_Date = tmBJ.tm_mday;
|
|
|
|
pdt_time->tt.RTC_Hours = tmBJ.tm_hour;
|
|
pdt_time->tt.RTC_Minutes = tmBJ.tm_min;
|
|
pdt_time->tt.RTC_Seconds = tmBJ.tm_sec;
|
|
pdt_time->tt.RTC_H12 = 0;// 0-AM24h 1-PM12h*/
|
|
}
|
|
|
|
if(psys_time!=NULL){
|
|
psys_time->year = tmBJ.tm_year-1900;
|
|
psys_time->month= tmBJ.tm_mon;
|
|
psys_time->date = tmBJ.tm_mday;
|
|
|
|
psys_time->hour = tmBJ.tm_hour;
|
|
psys_time->min = tmBJ.tm_min;
|
|
psys_time->sec = tmBJ.tm_sec;
|
|
}
|
|
}
|
|
|
|
#if 1
|
|
extern char release_ver[30];
|
|
|
|
enum
|
|
{
|
|
RUN_INFO_LOG_STEP_START=0,
|
|
RUN_INFO_LOG_TOTAL_CPU_STEP,
|
|
RUN_INFO_LOG_TOTAL_MEM_STEP,
|
|
RUN_INFO_LOG_TOTAL_DISK_STEP,
|
|
RUN_INFO_LOG_RUNTIME_STEP,
|
|
RUN_INFO_LOG_APP_CPU_RAM_STEP,
|
|
RUN_INFO_LOG_STEP_END
|
|
};
|
|
|
|
static void hardware_log_info(unsigned char log_step)
|
|
{
|
|
int ret=0;
|
|
char shellCmd[300];
|
|
|
|
if(log_step >= RUN_INFO_LOG_STEP_END)
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch(log_step)
|
|
{
|
|
case RUN_INFO_LOG_STEP_START:
|
|
//version
|
|
//usr_normal_printf("log imx-app-ver:%s\n",release_ver);
|
|
log_printf(LOG_INFO, I_RUN_STATUS, "log imx-app-ver:%s\n",release_ver);
|
|
break;
|
|
|
|
case RUN_INFO_LOG_TOTAL_CPU_STEP:
|
|
//cpu
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"top -n 1 -b | grep CPU | head -n 1 >&1");//len=54
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "Err.shell cmd get total CPU err.\n");
|
|
break;
|
|
case RUN_INFO_LOG_TOTAL_MEM_STEP:
|
|
//mem
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"top -n 1 -b | grep Mem | head -n 1 >&1");
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "Err.shell cmd get total Mem err.\n");
|
|
break;
|
|
case RUN_INFO_LOG_TOTAL_DISK_STEP:
|
|
//disk
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"df -h | grep Size >&1");
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "shell cmd df err.\n");
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"df -h | grep / | head -n 1 >&1");
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "Err.shell cmd df err.\n");
|
|
//usr_normal_printf("Err.shell cmd df err.\n");
|
|
break;
|
|
case RUN_INFO_LOG_RUNTIME_STEP:
|
|
//runtime
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"uptime >&1");
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "Err.shell cmd uptime err.\n");
|
|
break;
|
|
case RUN_INFO_LOG_APP_CPU_RAM_STEP:
|
|
//app cpu/ram
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"top -n 1 -b | grep VSZ | head -n 1 >&1");
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "Err.shell cmd uptime err.\n");
|
|
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"top -n 1 -b | grep imx_atsc_app | head -n 1 >&1");
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "Err.shell cmd uptime err.\n");
|
|
|
|
memset(shellCmd,0,sizeof(shellCmd));
|
|
sprintf(shellCmd,"top -n 1 -b | grep http | head -n 1 >&1");
|
|
ret = pox_system(shellCmd);
|
|
if(ret<0)
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "Err.shell cmd uptime err.\n");
|
|
break;
|
|
default:break;
|
|
}
|
|
}
|
|
|
|
|
|
void check_and_load_bkppara_to_cfgfile()
|
|
{
|
|
u8 ret;
|
|
char shellCmd[100] = {0};
|
|
|
|
//cfg
|
|
ret = check_file_exist(F_EXC_CFG_PARA_FILE);
|
|
if(ret==0)
|
|
log_printf(LOG_INFO, I_RUN_STATUS, "cfg_file exist\n");
|
|
else
|
|
log_printf(LOG_INFO, I_RUN_STATUS, "cfg_file is non-exist\n");
|
|
|
|
//bkp
|
|
ret = check_file_exist(F_EXC_CFG_PARA_BKP_FILE);
|
|
|
|
if(ret==0){
|
|
//memset(shellCmd,0,sizeof(shellCmd));
|
|
//sprintf(shellCmd,"%s");//len=54
|
|
ret = pox_system(LOAD_PARA_TO_CFG_FILE);
|
|
|
|
//ret = executeCMD(LOAD_PARA_TO_CFG_FILE, msg);
|
|
if(ret==0)
|
|
log_printf(LOG_INFO, I_RUN_STATUS, "bkp_file is load to cfg_file\n");
|
|
else
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "bkp_file failed load to cfg_file\n");
|
|
}else{
|
|
log_printf(LOG_WARN, I_RUN_STATUS, "bkp_file is non-existent\n");
|
|
}
|
|
}
|
|
|
|
static void sync_cfgpara_to_bkpfile()
|
|
{
|
|
u8 ret;
|
|
char msg[20] = {0};
|
|
|
|
ret = check_file_exist(F_EXC_CFG_PARA_FILE);
|
|
|
|
|
|
if(ret==0 && (E2PROM_MAGIC_WORD==c256_byteread(EEPROM_DEFAULT_PARAM_ADDR))){
|
|
ret = pox_system(SYNC_PARA_TO_BKP_FILE);
|
|
//ret = executeCMD(SYNC_PARA_TO_BKP_FILE, msg);
|
|
if(ret==0)
|
|
log_printf(LOG_INFO, I_RUN_STATUS, "cfg file is sync to bkp file\n");
|
|
else
|
|
log_printf(LOG_ERR, I_RUN_STATUS, "cfg file failed sync to bkp file\n");
|
|
}else{
|
|
log_printf(LOG_WARN, I_RUN_STATUS, "cfg file is non-existent\n");
|
|
}
|
|
}
|
|
|
|
void syslog_thr(void * pvParameters)
|
|
{
|
|
static int sec_cnt=0;
|
|
static char log_record_flg=0;
|
|
static char log_step=RUN_INFO_LOG_STEP_START;
|
|
static char boot_flg=1;
|
|
|
|
log_printf(LOG_INFO, I_NOUSED, "===syslog_thr start===\n");
|
|
|
|
while(1)
|
|
{
|
|
sec_cnt++;
|
|
// 2hour || boot 2min
|
|
if( (sec_cnt%(2*60*60)==0) || (sec_cnt>=120 && boot_flg) ){
|
|
boot_flg=0;
|
|
log_record_flg=1;
|
|
}
|
|
|
|
if(log_record_flg)
|
|
{
|
|
if(log_step >= RUN_INFO_LOG_STEP_END){
|
|
log_record_flg = 0;
|
|
log_step = RUN_INFO_LOG_STEP_START;
|
|
//usr_normal_printf("Sta.finish record run info to log.\n");
|
|
log_printf(LOG_INFO, I_RUN_STATUS, "Sta.finish record run info to log.\n");
|
|
|
|
sync_cfgpara_to_bkpfile();
|
|
}
|
|
else{
|
|
hardware_log_info(log_step);
|
|
log_step++;
|
|
}
|
|
}
|
|
|
|
|
|
sleep(1);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
|
|
#endif//verify_sys_com
|
|
|
|
|
|
|
|
|
|
|
|
|