map/das-dn/comm/public.cpp

#include "public.h"
#include "soe.h"
#include "ycbw.h"
#include "yxbw.h"
#include "yklog.h"
#include "ytlog.h"
#include "process.h"
#include "iec_101_104_lib.h"

#include <signal.h>
#include <iostream>
#include <fstream> 

#ifdef USE_SQLITE3
    #include "KompexSQLitePrerequisites.h"
    #include "KompexSQLiteDatabase.h"
    #include "KompexSQLiteStatement.h"
    #include "KompexSQLiteException.h"
    #include "KompexSQLiteStreamRedirection.h"
    #include "KompexSQLiteBlob.h"
    using namespace Kompex;
#endif

#include "json.h"

#include "ry.h"

#define PARAMTER_TYPE_MODBUS    1
#define PARAMTER_TYPE_104       2
#define PARAMTER_TYPE_9712      3

#define MAX_THREAD_NUM  2
#define THREAD_ID_MAIN  0
#define THREAD_ID_IDLE  1

BOOLEAN             systemRunFlag   = FALSE;
BOOLEAN             synchronized    = FALSE;
BOOLEAN             zlog_inited     = FALSE;

struSystem          system32;
struConfig          config;
struDatabase        database;
CYCBW               ycbw;
CYXBW               yxbw;
CSOE                soe;
CYKLog              yklog;
CYTLog              ytlog;
CProcess*           procs[PROCESSES_NUM];
struUnitStatic      static_units[UNIT_NUM];
struDispBuffer      channelBuffer;
struMsgBuffer       msgBuffer;
struNodeOption      nodes;
char                configpath[MAX_PATH] = "./conf";            //配置文件所在目录
char                configfile[MAX_PATH] = "./conf/config.db";  //配置文件

QWORD               system_timems;
#ifndef USE_NOPOLL_WEBSOCKET
CRYDevice*   g_conn;
#else
noPollConn          *g_conn;
#endif
Snowflake           g_sf = {1, 1, 0, 0};

static eLogLevel    eLevelMax = LOG_DEBUG;   //LOG_DEBUG;
static const char*  arszLevel2Str[] = { "NULL", "ERROR", "WARN", "INFO", "DEBUG" };
static pthread_t    p_id[MAX_THREAD_NUM];

static DWORD WriteMsgRingBuff(const char *wbuff, DWORD len)
{
    DWORD l;
    if (msgBuffer.buf == NULL) return -1;
    len = wMin(len, MAX_DISPLAY_BUFFER_SIZE - msgBuffer.save + msgBuffer.load);
    /* 第一部分的拷贝:从环形缓冲区写入数据直至缓冲区最后一个地址 */
    l = wMin(len, MAX_DISPLAY_BUFFER_SIZE - (msgBuffer.save & (MAX_DISPLAY_BUFFER_SIZE - 1)));
    memcpy(msgBuffer.buf + (msgBuffer.save & (MAX_DISPLAY_BUFFER_SIZE - 1)), wbuff, l);
    /* 如果溢出则在缓冲区头写入剩余的部分如果没溢出这句代码相当于无效 */
    memcpy(msgBuffer.buf, wbuff + l, len - l);
    msgBuffer.save += len;
    return len;
}

DWORD ReadMsgRingBuff(char *rbuff, DWORD len)
{
    DWORD l;
    if (msgBuffer.buf == NULL) return -1;
    len = wMin(len, msgBuffer.save - msgBuffer.load);
    /* 第一部分的拷贝:从环形缓冲区读取数据直至缓冲区最后一个 */
    l = wMin(len, MAX_DISPLAY_BUFFER_SIZE - (msgBuffer.load & (MAX_DISPLAY_BUFFER_SIZE - 1)));
    memcpy(rbuff, msgBuffer.buf + (msgBuffer.load & (MAX_DISPLAY_BUFFER_SIZE - 1)), l);
    /* 如果溢出则在缓冲区头读取剩余的部分如果没溢出这句代码相当于无效 */
    memcpy(rbuff + l, msgBuffer.buf, len - l);
    msgBuffer.load += len;
    return len;
}

void vLog(eLogLevel eLevel, const char* szFmt, ...)
{
    if (eLevel <= eLevelMax)
    {
        int     len;
        char    buffer[4096];   //dlt698.45-1867可能会比较长的报文.此处避免错误
        va_list args;

        len = snprintf(buffer, sizeof(buffer), "%04d/%02d/%02d %02d:%02d:%02d.%03d ",\
                system32.now.year+2000, system32.now.month, system32.now.dayofmonth,\
                system32.now.hour, system32.now.minute, system32.now.millisecond / 1000, system32.now.millisecond % 1000);
        WriteMsgRingBuff(buffer, len);
        len = snprintf(buffer, sizeof(buffer), "%s: ", arszLevel2Str[eLevel]);
        WriteMsgRingBuff(buffer, len);
        
        va_start(args, szFmt);
        len = vsnprintf(buffer, sizeof(buffer), szFmt, args);
        va_end(args);
        WriteMsgRingBuff(buffer, len);

        if (zlog_inited)
        {
            if      (eLevel == LOG_DEBUG)   dzlog_debug("%s", buffer);
            else if (eLevel == LOG_INFO)    dzlog_info("%s", buffer);
            else if (eLevel == LOG_WARN)    dzlog_warn("%s", buffer);
            else if (eLevel == LOG_ERROR)   dzlog_error("%s", buffer);
        }
    }
}

int GetFileSize(const char* fname)
{
    struct stat statbuf;
    if (stat(fname,&statbuf) == 0)
    {
        return statbuf.st_size;
    }
    return -1;
}

const char* match_strval_idx(DWORD val, const value_string* vs, int* idx)
{
    int i = 0;
    if (vs)
    {
        while (vs[i].strptr)
        {
            if (vs[i].value == val)
            {
                *idx = i;
                return(vs[i].strptr);
            }
            i++;
        }
    }
    *idx = -1;
    return NULL;
}

char* ep_strdup_printf(const char* fmt, ...)
{
    va_list ap;
    char* dst;

    dst = new char[2048];
    if (dst == NULL) return NULL;
    memset(dst, 0, 2048);
    va_start(ap, fmt);
    vsnprintf(dst, 2048, fmt, ap);
    va_end(ap);
    return dst;
}

const char* match_strval(DWORD val, const value_string* vs)
{
    int ignore_me;
    return match_strval_idx(val, vs, &ignore_me);
}

const char* val_to_str(DWORD val, const value_string* vs, const char* fmt)
{
    const char* ret;
    if (fmt == NULL) return NULL;
    ret = match_strval(val, vs);
    if (ret != NULL) return ret;
    return ep_strdup_printf(fmt, val);
}

void StringToHex(const char* pStr, BYTE* pData)
{
    int i;
    BYTE data;
    int len = strlen(pStr);
    char* pBuf = (char*)pStr;

    for (i = 0; i < len; i++, pBuf++)
    {
        if (*pBuf >= '0' && *pBuf <= '9')
        {
            data = *pBuf - '0';
        }
        else if (*pBuf >= 'a' && *pBuf <= 'f')
        {
            data = *pBuf - 'a' + 0x0a;
        }
        else if (*pBuf >= 'A' && *pBuf <= 'F')
        {
            data = *pBuf - 'A' + 0x0a;
        }
        else
        {
            break;
        }
        data = data << 4;
        i++, pBuf++;
        if (*pBuf >= '0' && *pBuf <= '9')
        {
            data |= *pBuf - '0';
        }
        else if (*pBuf >= 'a' && *pBuf <= 'f')
        {
            data |= *pBuf - 'a' + 0x0a;
        }
        else if (*pBuf >= 'A' && *pBuf <= 'F')
        {
            data |= *pBuf - 'A' + 0x0a;
        }
        else
        {
            break;
        }
        *pData = data;
        pData++;
    }
}

void HexToString(const BYTE* pData, char* pStr, int count)
{
    int i;
    char text[16];
    BYTE* pCurData = (BYTE*)pData;

    strcpy(pStr, "");
    for (i = 0; i < count; i++, pCurData++)
    {
        sprintf(text, "%02X", (int)(*pCurData));
        strcat(pStr, text);
    }
    count = count << 1;
    for (i = count-1; i > 0; i -= 2)
    {
        if (pStr[i] == '0' && pStr[i-1] == '0')
        {
            pStr[i-1] = '\0';
        }
        else
        {
            break;
        }
    }
    if (pStr[0] == '\0')
    {
        strcpy(pStr, "00");
    }
}

DWORD bcd_to_int(const BYTE *bcd, int length)
{
    DWORD   result = 0;

    for (; length > 0;)
    {
        length--;
        result *= 10;
        result += (bcd[length] >> 4) & 0x0f;
        result *= 10;
        result += bcd[length] & 0x0f;
    }
    return result;
}

void int_to_bcd(int dec, BYTE *bcd, int length)
{
    int i;
    int temp;
    for (i = length - 1; i >= 0; i--)
    {
        temp = dec % 100;
        bcd[i] = ((temp / 10) << 4) + ((temp % 10) & 0x0F);
        dec /= 100;
    }
}

int ValToBuf(BYTE* buf, DWORD val, int lenth, BOOLEAN bBigEndian)
{
    if (lenth <= 0) return 0;
    
    for (int i = 0; i < lenth; i++)
    {
		if (bBigEndian)
		{
			buf[lenth - (i + 1)] = (val >> (i << 3)) & 0xff;
		}
		else
		{
			buf[i] = (val >> (i << 3)) & 0xff;
		}
    }

	return lenth;
}

DWORD BufToVal(BYTE* buf, int lenth, BOOLEAN bBigEndian)
{
    DWORD sum = 0;
    
    if (lenth <= 0) return 0;
    
    for (int i = 0; i < lenth; i++)
    {
        if (bBigEndian)
		{
			sum += buf[lenth - (i + 1)] << (i << 3);
		}
		else
		{
			sum += buf[i] << (i << 3);
		}
		
	}

	return sum;
}

std::vector<std::string> split(const std::string &s, char delimiter)
{  
    std::vector<std::string> tokens;  
    std::istringstream tokenStream(s);  
    std::string token;  
    while (std::getline(tokenStream, token, delimiter)) {  
        tokens.push_back(token);  
    }  
    return tokens;  
}
// 计算新字符串的长度，考虑到每个指定字符都可能被替换为更长的转义序列
size_t calculate_escaped_length(const char *str, char escape_char)
{
    size_t length = 0;
    size_t i;
    for (i = 0; str[i] != '\0'; i++)
    {
        if (str[i] == escape_char)
        {
            length += 3; // 每个指定字符替换为"\xXX"形式，长度为3
        }
        else
        {
            length += 1; // 其他字符保持不变
        }
    }
    return length + 1; // 加1是为了字符串末尾的空字符
}

// 实现字符转义
char* escape_char_in_string(const char *str, char escape_char)
{
    size_t new_length = calculate_escaped_length(str, escape_char);

    char *escaped_str = (char *)malloc(new_length);
    if (escaped_str == NULL)
    {
        return NULL; // 内存分配失败
    }

    size_t j = 0;
    for (size_t i = 0; str[i] != '\0'; i++)
    {
        if (str[i] == escape_char)
        {
            sprintf(escaped_str + j, "%s", "\%20");
            j += 3;
        }
        else
        {
            escaped_str[j++] = str[i];
        }
    }
    escaped_str[j] = '\0'; // 添加字符串末尾的空字符

    return escaped_str;
}

int unionCP56TimeToBuf(BYTE* buf, unionCP56Time st)
{
    int len = 0;
    len = ValToBuf(buf, st.millisecond, 2);
    buf[len++] = st.minute;
    buf[len++] = st.hour;
    buf[len++] = st.dayofmonth;
    buf[len++] = st.month;
    buf[len++] = st.year;

    return len;
}

QWORD getTimeInMs()
{
    return system_timems;
}

BOOLEAN get_system_time(unionCP56Time* lpSystemTime)
{
    struct timeval  tv;
    struct tm       stru_tmp;

    if (gettimeofday(&tv, NULL) < 0) return FALSE;

    localtime_r(&tv.tv_sec, &stru_tmp);
    lpSystemTime->millisecond = (WORD)((stru_tmp.tm_sec * 1000) + (tv.tv_usec / 1000));
    lpSystemTime->minute = stru_tmp.tm_min;
    lpSystemTime->hour = stru_tmp.tm_hour;
    lpSystemTime->dayofmonth = stru_tmp.tm_mday;
    lpSystemTime->dayofweek = stru_tmp.tm_wday;
    lpSystemTime->month = stru_tmp.tm_mon + 1;
    lpSystemTime->year = stru_tmp.tm_year + 1900 - 2000;

    system32.timers = (DWORD)tv.tv_sec;

    system_timems = ((QWORD) tv.tv_sec * 1000LL) + (tv.tv_usec / 1000);

    return TRUE;
}

int write_to_hardclock()// for linux
{
    FILE *fp = NULL;
    fp = popen("hwclock -w","r");
    if (fp == NULL) return 0;
    pclose(fp);
    return 1;
}

BOOLEAN set_system_time(unionCP56Time* lpSystemTime)
{
    struct timeval  tv;
    struct tm       p;
    time_t          temp;
    if (gettimeofday(&tv, NULL) < 0)
    {
        vLog(LOG_ERROR, "gettimeofday error(%d,%s).\n", errno, strerror(errno));
        return FALSE;
    }
    
    localtime_r(&tv.tv_sec, &p);
    p.tm_year = lpSystemTime->year + 2000 - 1900;
    p.tm_mon = lpSystemTime->month - 1;
    p.tm_mday = lpSystemTime->dayofmonth;
    p.tm_hour = lpSystemTime->hour;
    p.tm_min = lpSystemTime->minute;
    p.tm_sec = lpSystemTime->millisecond / 1000;
    temp = mktime(&p);
    tv.tv_sec = (long)temp;
    tv.tv_usec = lpSystemTime->millisecond % 1000;

    if (settimeofday(&tv, NULL) < 0)
    {
        vLog(LOG_ERROR, "settimeofday error(%d,%s).\n", errno, strerror(errno));
        return FALSE;
    }
    vLog(LOG_DEBUG, "system synchronized!\r\n");
    synchronized = TRUE;
    
    vLog(LOG_DEBUG, "system clock synchronized! %04d/%02d/%02d %02d:%02d:%02d=>%04d/%02d/%02d %02d:%02d:%02d\n",
        system32.now.year+2000, system32.now.month, system32.now.dayofmonth,
        system32.now.hour, system32.now.minute, system32.now.millisecond / 1000,
        lpSystemTime->year + 2000, lpSystemTime->month, lpSystemTime->dayofmonth,
        lpSystemTime->hour, lpSystemTime->minute, lpSystemTime->millisecond / 1000);

    return TRUE;
}

time_t unionCP56TimetoTime_t(unionCP56Time* st)
{
    time_t          temp;
    struct timeval  tv;
    struct tm       p;
    if (gettimeofday(&tv, NULL) < 0)
    {
        vLog(LOG_ERROR, "gettimeofday error(%d,%s).\n", errno, strerror(errno));
        return FALSE;
    }
    
    localtime_r(&tv.tv_sec, &p);
    p.tm_year = st->year + 2000 - 1900;
    p.tm_mon = st->month - 1;
    p.tm_mday = st->dayofmonth;
    p.tm_hour = st->hour;
    p.tm_min = st->minute;
    p.tm_sec = st->millisecond / 1000;
    temp = mktime(&p);
    return temp;
}

unionCP56Time Time_ttounionCP56Time(time_t st)
{
    unionCP56Time   ct;
    struct tm       stru_tmp;

    localtime_r((long *)&st, &stru_tmp);
    ct.millisecond = (stru_tmp.tm_sec * 1000);
    ct.minute = stru_tmp.tm_min;
    ct.hour = stru_tmp.tm_hour;
    ct.dayofmonth = stru_tmp.tm_mday;
    ct.dayofweek = stru_tmp.tm_wday;
    ct.month = stru_tmp.tm_mon + 1;
    ct.year = stru_tmp.tm_year + 1900 - 2000;
    
    return ct;
}

QLONG filetime_to_unix(QLONG ft)
{
    uint64_t winTime = ft;
    // 将100纳秒间隔转换为毫秒
    winTime /= 10000;
    // 减去从1601年到1970年的毫秒数
    winTime -= 11644473600000LL;
    // 将毫秒转换为秒
    return (winTime);
}


QWORD current_time()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
}

QWORD snowflake_next_id(void)
{
    QWORD timestamp = current_time();
    if (timestamp < g_sf.last_timestamp) {
        return 0;
    }
    if (g_sf.last_timestamp == timestamp) {
        g_sf.sequence = (g_sf.sequence + 1) & SEQUENCE_MASK;
        if (g_sf.sequence == 0) {
            while (current_time() <= g_sf.last_timestamp);
        }
    } else {
        g_sf.sequence = 0; // reset sequence
    }
    g_sf.last_timestamp = timestamp;
    return  ((timestamp - EPOCH) << (WORKER_ID_BITS + DATA_CENTER_ID_BITS + SEQUENCE_BITS)) |
            (g_sf.data_center_id << (WORKER_ID_BITS + SEQUENCE_BITS)) |
            (g_sf.worker_id << SEQUENCE_BITS) |
            g_sf.sequence;
}

void alarm(void)
{
}

BOOLEAN InitializeMemory(void)
{
    int i, j;

    synchronized = FALSE;
    systemRunFlag = FALSE;

    memset(&system32, 0, sizeof(system32));
    memset(&config, 0, sizeof(config));
    memset(&database, 0, sizeof(database));
    memset(procs, 0, sizeof(procs));
    memset(&channelBuffer, 0, sizeof(channelBuffer));
    memset(&msgBuffer, 0, sizeof(msgBuffer));
    memset(&nodes, 0, sizeof(nodes));
//    memset(units_state, 0, sizeof(units_state));    //为UI添加专用单元状态
    
    database.yxs = new struYX[DATABASE_YX_NUM];
    if (database.yxs == NULL) return FALSE;
    memset(database.yxs, 0, sizeof(struYX) * DATABASE_YX_NUM);

    database.ycs = new struYC[DATABASE_YC_NUM];
    if (database.ycs == NULL) return FALSE;
    memset(database.ycs, 0, sizeof(struYC) * DATABASE_YC_NUM);

    database.yms = new struYM[DATABASE_YM_NUM];
    if (database.yms == NULL) return FALSE;
    memset(database.yms, 0, sizeof(struYM) * DATABASE_YM_NUM);

    database.yks = new struYK[DATABASE_YK_NUM];
    if (database.yks == NULL) return FALSE;
    memset(database.yks, 0, sizeof(struYK) * DATABASE_YK_NUM);

    database.yts = new struYT[DATABASE_YT_NUM];
    if (database.yts == NULL) return FALSE;
    memset(database.yts, 0, sizeof(struYT) * DATABASE_YT_NUM);

    msgBuffer.buf = new char[MAX_DISPLAY_BUFFER_SIZE];
    if (msgBuffer.buf != NULL) 
    {
        memset(msgBuffer.buf, 0, sizeof(char) * MAX_DISPLAY_BUFFER_SIZE);
    }
    
    channelBuffer.buf = new char[MAX_DISPLAY_BUFFER_SIZE];
    if (channelBuffer.buf != NULL)
    {
        memset(channelBuffer.buf, 0, sizeof(char) * MAX_DISPLAY_BUFFER_SIZE);
    }

    strcpy(system32.yk_pass, "12345");
    system32.yk_keep = 30;
    system32.interval_time = 2;
    system32.log_enabled = FALSE;
    system32.zjd_log_bind_addr = INADDR_ANY;
    system32.zjd_log_bind_port = 0;
    for (i = 0; i < HARDWARE_PORTS_NUM; i++)
    {
        snprintf(config.hardware.ports[i].name, MAX_NAME_SIZE, "ttyS%d", i + 100);
        config.hardware.ports[i].baud = 9600;
        config.hardware.ports[i].data = 8;
        config.hardware.ports[i].parity = 0;
        config.hardware.ports[i].stop = 0;
        config.hardware.ports[i].timeout = 1000;    //1s
    }
    for (i = 0; i < PROCESSES_NUM; i++)
    {
        snprintf(config.processes[i].name, MAX_NAME_SIZE, "PROC%02d", i);
        //config.processes[i].softdog = 0;
        config.processes[i].real_softdog = 0;
        config.processes[i].ftp_softdog = 0;
        for (j = 0; j < PROCESS_UNIT_NUM; j++)
        {
            config.processes[i].units[j] = -1;
        }
    }
    for (i = 0; i < UNIT_NUM; i++)
    {
        //config.units[i].softdog = 0;
        config.units[i].real_softdog = 0;
        config.units[i].ftp_softdog = 0;
    }
    
    return TRUE;
}

BOOLEAN ReadSystemCFG(void)
{
    FILE *pf;
    char pathName[512];
    
    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_SYSTEM_CONFIG);
    pf = fopen(pathName, "rb");
    if (pf != NULL)
    {
        fread(&system32, sizeof(system32), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN WriteSystemCFG(void)
{
    FILE* pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_SYSTEM_CONFIG);
    pf = fopen(pathName, "wb+");
    if (pf != NULL)
    {
        fwrite(&system32, sizeof(system32), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN ReadNodeCFG(void)
{
    FILE    *pf;
    char    pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_NODE_CONFIG);
    pf = fopen(pathName, "rb");
    if (pf != NULL)
    {
        fread(&nodes, sizeof(nodes), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN WriteNodeCFG(void)
{
    FILE    *pf;
    char    pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_NODE_CONFIG);
    pf = fopen(pathName, "wb+");
    if (pf != NULL)
    {
        fwrite(&nodes, sizeof(nodes), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN ReadHardwareCFG(void)
{
    FILE *pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_HARDWARE_CONFIG);
    pf = fopen(pathName, "rb");
    if (pf != NULL)
    {
        fread(&config.hardware, sizeof(config.hardware), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN WriteHardwareCFG(void)
{
    FILE* pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_HARDWARE_CONFIG);
    pf = fopen(pathName, "wb+");
    if (pf != NULL)
    {
        fwrite(&config.hardware, sizeof(config.hardware), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN ReadProcessCFG(void)
{
    FILE *pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_PROCESS_CONFIG);
    pf = fopen(pathName, "rb");
    if (pf != NULL)
    {
        fread(&config.processes, sizeof(config.processes), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN WriteProcessCFG(void)
{
    FILE* pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_PROCESS_CONFIG);
    pf = fopen(pathName, "wb+");
    if (pf != NULL)
    {
        fwrite(&config.processes, sizeof(config.processes), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN ReadUnitCFG(void)
{
    int i, j;
    char pathName[512];
    char filename[512];
    FILE *pf = NULL;
    FILE *pfPoint = NULL;

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_UNIT_CONFIG);
    pf = fopen(pathName, "rb");
    if (pf != NULL)
    {
        for (i = 0; i < UNIT_NUM; i++)
        {
            if (feof(pf)) break;
            if (fread(&config.units[i], sizeof(config.units[i]), 1, pf) != 1) break;
            config.units[i].yxs = NULL;
            config.units[i].ycs = NULL;
            config.units[i].yms = NULL;
            config.units[i].yks = NULL;
            config.units[i].yts = NULL;
            if (config.units[i].yxcount > 0)
            {
                config.units[i].yxs = new struUnitYX[config.units[i].yxcount];
                if (NULL == config.units[i].yxs) return FALSE;
                memset(config.units[i].yxs, 0, sizeof(struUnitYX)*config.units[i].yxcount);
                snprintf(filename, sizeof(filename), FILE_UNIT_YX_CONFIG, configpath, i);
                pfPoint = fopen(filename, "rb");
                if (pfPoint != NULL)
                {
                    fread(config.units[i].yxs, sizeof(struUnitYX)*config.units[i].yxcount, 1, pfPoint);
                    fclose(pfPoint);
                }
                else
                {
                    for (j = 0; j < config.units[i].yxcount; j++)
                    {
                        config.units[i].yxs[j].order = -1;
                        config.units[i].yxs[j].qds = 0x80;
                    }
                }
            }
            if (config.units[i].yccount > 0)
            {
                config.units[i].ycs = new struUnitYC[config.units[i].yccount];
                if (NULL == config.units[i].ycs) return FALSE;
                memset(config.units[i].ycs, 0, sizeof(struUnitYC)*config.units[i].yccount);
                snprintf(filename, sizeof(filename), FILE_UNIT_YC_CONFIG, configpath, i);
                pfPoint = fopen(filename, "rb");
                if (pfPoint != NULL)
                {
                    fread(config.units[i].ycs, sizeof(struUnitYC)*config.units[i].yccount, 1, pfPoint);
                    fclose(pfPoint);
                }
                else
                {
                    for (j = 0; j < config.units[i].yccount; j++)
                    {
                        config.units[i].ycs[j].order = -1;
                        config.units[i].ycs[j].factor = 1;
                        config.units[i].ycs[j].qds = 0x80;
                    }
                }
            }
            if (config.units[i].ymcount > 0)
            {
                config.units[i].yms = new struUnitYM[config.units[i].ymcount];
                if (NULL == config.units[i].yms) return FALSE;
                memset(config.units[i].yms, 0,sizeof(struUnitYM)*config.units[i].ymcount);
                snprintf(filename, sizeof(filename), FILE_UNIT_YM_CONFIG, configpath, i);
                pfPoint = fopen(filename, "rb");
                if (pfPoint != NULL)
                {
                    fread(config.units[i].yms, sizeof(struUnitYM)*config.units[i].ymcount, 1, pfPoint);
                    fclose(pfPoint);
                }
                else
                {
                    for (j = 0; j < config.units[i].ymcount; j++)
                    {
                        config.units[i].yms[j].order = -1;
                    }
                }
            }
            if (config.units[i].ykcount > 0)
            {
                config.units[i].yks = new struUnitYK[config.units[i].ykcount];
                if (NULL == config.units[i].yks) return FALSE;
                memset(config.units[i].yks, 0, sizeof(struUnitYK)*config.units[i].ykcount);
                snprintf(filename, sizeof(filename), FILE_UNIT_YK_CONFIG, configpath, i);
                pfPoint = fopen(filename, "rb");
                if (pfPoint != NULL)
                {
                    fread(config.units[i].yks, sizeof(struUnitYK)*config.units[i].ykcount, 1, pfPoint);
                    fclose(pfPoint);
                }
                else
                {
                    for (j = 0; j < config.units[i].ykcount; j++)
                    {
                        config.units[i].yks[j].order = -1;
                    }
                }
            }
            if (config.units[i].ytcount > 0)
            {
                config.units[i].yts = new struUnitYT[config.units[i].ytcount];
                if (NULL == config.units[i].yts) return FALSE;
                memset(config.units[i].yts, 0, sizeof(struUnitYT)*config.units[i].ytcount);
                snprintf(filename, sizeof(filename), FILE_UNIT_YT_CONFIG, configpath, i);
                pfPoint = fopen(filename, "rb");
                if (pfPoint != NULL)
                {
                    fread(config.units[i].yts, sizeof(struUnitYT)*config.units[i].ytcount, 1, pfPoint);
                    fclose(pfPoint);
                }
                else
                {
                    for (j = 0; j < config.units[i].ytcount; j++)
                    {
                        config.units[i].yts[j].order = -1;
                    }
                }
            }
        }
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN WriteUnitCFG(void)
{
    int i;
    char filename[512];
    char pathName[512];
    FILE *pf = NULL;
    FILE *pfPoint = NULL;
    
    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_UNIT_CONFIG);
    pf = fopen(pathName, "wb+");
    if (pf != NULL)
    {
        for (i = 0; i < UNIT_NUM; i++)
        {
            if (fwrite(&config.units[i], sizeof(config.units[i]), 1, pf) != 1) break;
            if (config.units[i].yxcount > 0)
            {
                if (config.units[i].yxs != NULL)
                {
                    snprintf(filename, sizeof(filename), FILE_UNIT_YX_CONFIG, configpath, i);
                    pfPoint = fopen(filename, "wb+");
                    if (pfPoint != NULL)
                    {
                        fwrite(config.units[i].yxs, sizeof(struUnitYX)*config.units[i].yxcount, 1, pfPoint);
                        fclose(pfPoint);
                    }
                }
            }
            if (config.units[i].yccount > 0)
            {
                if (config.units[i].ycs != NULL)
                {
                    snprintf(filename, sizeof(filename), FILE_UNIT_YC_CONFIG, configpath, i);
                    pfPoint = fopen(filename, "wb+");
                    if (pfPoint != NULL)
                    {
                        fwrite(config.units[i].ycs, sizeof(struUnitYC)*config.units[i].yccount, 1, pfPoint);
                        fclose(pfPoint);
                    }
                }
            }
            if (config.units[i].ymcount > 0)
            {
                if (config.units[i].yms != NULL)
                {
                    snprintf(filename, sizeof(filename), FILE_UNIT_YM_CONFIG, configpath, i);
                    pfPoint = fopen(filename, "wb+");
                    if (pfPoint != NULL)
                    {
                        fwrite(config.units[i].yms, sizeof(struUnitYM)*config.units[i].ymcount, 1, pfPoint);
                        fclose(pfPoint);
                    }
                }
            }
            if (config.units[i].ykcount > 0)
            {
                if (config.units[i].yks != NULL)
                {
                    snprintf(filename, sizeof(filename), FILE_UNIT_YK_CONFIG, configpath, i);
                    pfPoint = fopen(filename, "wb+");
                    if (pfPoint != NULL)
                    {
                        fwrite(config.units[i].yks, sizeof(struUnitYK)*config.units[i].ykcount, 1, pfPoint);
                        fclose(pfPoint);
                    }
                }
            }
            if (config.units[i].ytcount > 0)
            {
                if (config.units[i].yts != NULL)
                {
                    snprintf(filename, sizeof(filename), FILE_UNIT_YT_CONFIG, configpath, i);
                    pfPoint = fopen(filename, "wb+");
                    if (pfPoint != NULL)
                    {
                        fwrite(config.units[i].yts, sizeof(struUnitYT)*config.units[i].ytcount, 1, pfPoint);
                        fclose(pfPoint);
                    }
                }
            }
        }
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}


BOOLEAN ReadStaticUnitCFG(void)
{
    FILE *pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_UNIT_STATIC);
    pf = fopen(pathName, "rb");
    if (pf)
    {
        fread(static_units, sizeof(static_units), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN WriteStaticUnitCFG(void)
{
    FILE *pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_UNIT_STATIC);
    pf = fopen(pathName, "w+");
    if (pf != NULL)
    {
        fwrite(static_units, sizeof(static_units), 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN ReadDatabaseCFG(void)
{
    FILE *pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_DATABASE_CONFIG);
    pf = fopen(pathName, "rb");
    if (pf != NULL)
    {
        if (!feof(pf))
        {
            fread(database.yxs, sizeof(struYX) * DATABASE_YX_NUM, 1, pf);
        }
        if (!feof(pf))
        {
            fread(database.ycs, sizeof(struYC) * DATABASE_YC_NUM, 1, pf);
        }
        if (!feof(pf))
        {
            fread(database.yms, sizeof(struYM) * DATABASE_YM_NUM, 1, pf);
        }
        if (!feof(pf))
        {
            fread(database.yks, sizeof(struYK) * DATABASE_YK_NUM, 1, pf);
        }
        if (!feof(pf))
        {
            fread(database.yts, sizeof(struYT) * DATABASE_YT_NUM, 1, pf);
        }
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

BOOLEAN WriteDatabaseCFG(void)
{
    FILE *pf;
    char pathName[512];

    snprintf(pathName, sizeof(pathName), "%s/%s", configpath, FILE_DATABASE_CONFIG);
    pf = fopen(pathName, "wb+");
    if (pf != NULL)
    {
        fwrite(database.yxs, sizeof(struYX) * DATABASE_YX_NUM, 1, pf);
        fwrite(database.ycs, sizeof(struYC) * DATABASE_YC_NUM, 1, pf);
        fwrite(database.yms, sizeof(struYM) * DATABASE_YM_NUM, 1, pf);
        fwrite(database.yks, sizeof(struYK) * DATABASE_YK_NUM, 1, pf);
        fwrite(database.yts, sizeof(struYT) * DATABASE_YT_NUM, 1, pf);
        fclose(pf);
        return TRUE;
    }
    return FALSE;
}

void dumpLogs(void)
{
    if (system32.log_enabled)
    {     //保存日志
        yxbw.DumpYXBW();
        soe.DumpSOE();
        yklog.DumpYKLog();
        ytlog.DumpYTLog();
    }
    WriteDatabaseCFG();
    FILE* pf = fopen("./stop.log", "w+");
    if (pf)
    {
        fwrite(&system32.now, sizeof(unionCP56Time), 1, pf);
        fwrite(&system32.timers, sizeof(DWORD), 1, pf);
        fclose(pf);
    }
}

////////////////////////////////
// 空闲进程
////////////////////////////////

void yk(void)
{
    int i;
    struYK* pYK;
    
    for (i = 0; i < DATABASE_YK_NUM; i++)
    {
        pYK = &database.yks[i];
        if (pYK->state != YKS_IDLE)
        {
            if (pYK->result == YKR_IDLE || pYK->result == YKR_OPER)
            {
                if ((short)(system32.timers - pYK->op_time) > system32.yk_keep)
                {
                    pYK->result = YKR_OVER;
                    if (pYK->state == YKS_EXEREQ || pYK->state == YKS_EXEING)
                    {
                        yklog.PushYKLog(system32.now, i, pYK->value, YKT_EXEOUT, YKS_AUTO, -1);
                    }
                    else
                    {
                        yklog.PushYKLog(system32.now, i, pYK->value, YKT_SELOUT, YKS_AUTO, -1);
                    }
                }
            }
            else if (pYK->result == YKR_SUCC)
            {
                if (pYK->state == YKS_EXEED)
                {
                    if ((short)(system32.timers - pYK->op_time) > system32.yk_keep)
                    {
                        pYK->state = YKS_IDLE;
                        pYK->result = YKR_IDLE;
                        pYK->op_unit = -1;
                    }
                }
                else
                {
                    if ((short)(system32.timers - pYK->op_time) > system32.yk_keep)
                    {
                        pYK->result = YKR_OVER;
                        yklog.PushYKLog(system32.now, i, pYK->value, YKT_SELOUT, YKS_AUTO, -1);
                    }
                }
            }
            else if (pYK->result == YKR_OVER)
            {
                if ((short)(system32.timers - pYK->op_time) > (system32.yk_keep + 5))
                {
                    pYK->state = YKS_IDLE;
                    pYK->result = YKR_IDLE;
                    pYK->op_unit = -1;
                }
            }
        }
        else
        {
            pYK->op_unit = -1;
        }
    }
}

void yt(void)
{
    int i;
    struYT* pYT;
    for (i = 0; i < DATABASE_YT_NUM; i++)
    {
        pYT = &database.yts[i];
        if (pYT->state != YTS_IDLE)
        {
            if (pYT->result == YTR_IDLE || pYT->result == YTR_OPER)
            {
                if ((short)(system32.timers - pYT->op_time) > system32.yk_keep)
                {
                    pYT->result = YTR_OVER;
                    if (pYT->state == YTS_EXEREQ || pYT->state == YTS_EXEING)
                    {
                        ytlog.PushYTLog(system32.now, i, pYT->value, YTT_EXEOUT, YTS_AUTO, -1);
                    }
                    else
                    {
                        ytlog.PushYTLog(system32.now, i, pYT->value, YTT_SELOUT, YTS_AUTO, -1);
                    }
                }
            }
            else if (pYT->result == YTR_SUCC)
            {
                if (pYT->state == YTS_EXEED)
                {
                    if ((short)(system32.timers - pYT->op_time) > system32.yk_keep)
                    {
                        pYT->state = YTS_IDLE;
                        pYT->result = YTR_IDLE;
                        pYT->op_unit = -1;
                    }
                }
                else
                {
                    if ((short)(system32.timers - pYT->op_time) > system32.yk_keep)
                    {
                        pYT->result = YTR_OVER;
                        ytlog.PushYTLog(system32.now, i, pYT->value, YTT_SELOUT, YTS_AUTO, 1);
                    }
                }
            }
            else if (pYT->result == YTR_OVER)
            {
                if ((short)(system32.timers - pYT->op_time) > (system32.yk_keep + 5))
                {
                    pYT->state = YTS_IDLE;
                    pYT->result = YTR_IDLE;
                    pYT->op_unit = -1;
                }
            }
        }
        else
        {
            pYT->op_unit = -1;
        }
    }
}

void* idle_process(void* param)
{
    int     yxbw_save = 0, yxbw_load = 0;

    while (systemRunFlag)
    {
        sleep(1);
        yk();
        yt();
        //操作，保存系统操作Log
        if ((system32.timers % 3600) == 0) {   //过整点保存
            if (system32.log_enabled) {
                yxbw.DumpYXBW();
                soe.DumpSOE();
                yklog.DumpYKLog();
                ytlog.DumpYTLog();
            }
            yxbw_save = yxbw.GetSavePos();
            if (yxbw_load != yxbw_save) {   //有变位信息
                WriteDatabaseCFG();
                yxbw_load = yxbw_save;
            }
        }
        for (int i = 0; i < PROCESSES_NUM; i++) {
            config.processes[i].real_softdog++;
            if (config.processes[i].real_softdog > PROCESS_WATCHDOG_TIME) {
                config.processes[i].real_softdog = PROCESS_WATCHDOG_TIME;
            }
            config.processes[i].ftp_softdog++;
            if (config.processes[i].ftp_softdog > PROCESS_WATCHDOG_TIME) {
                config.processes[i].ftp_softdog = PROCESS_WATCHDOG_TIME;
            }
        }
        for (int i = 0; i < UNIT_NUM; i++) {
            config.units[i].real_softdog++;
            if (config.units[i].real_softdog > UNIT_WATCHDOG_TIME) {
                config.units[i].real_softdog = UNIT_WATCHDOG_TIME;
                config.units[i].value |= SPI_ON;
            } else {
                config.units[i].value &= ~SPI_ON;
            }
            config.units[i].ftp_softdog++;
            if (config.units[i].ftp_softdog > UNIT_WATCHDOG_TIME) {
                config.units[i].ftp_softdog = UNIT_WATCHDOG_TIME;
            }
        }
    }
    pthread_exit(0);
    return ((void*)0);
}

////////////////////////////////
// 主进程，用于系统时间的更新
////////////////////////////////
void* main_process(void* param)
{
    while (systemRunFlag)
    {
        struct timeval tv;
        tv.tv_sec = 0;
        //tv.tv_usec = 20000;
        tv.tv_usec = TIME_TICKS;
        select(0, NULL, NULL, NULL, &tv);
        system32.ticks++;    //每20ms累加一次
        if (get_system_time(&system32.now))
        {
            system32.now.SU = FALSE;
            //if (synchronized)
            {
                system32.now.IV = FALSE;
            }
        }
    }
    pthread_exit(0);

    return ((void*)0);
}

void main_process_timer_handler(int signum)
{
    system32.ticks++;    //每20ms累加一次
    if (get_system_time(&system32.now))
    {
        system32.now.SU = FALSE;
        //if (synchronized)
        {
            system32.now.IV = FALSE;
        }
    }
}

BOOLEAN initialize_system(BOOLEAN usesqlite, BOOLEAN enable_auto_platform, const char* pathName, char *codeName)
{
    if (!InitializeMemory())
    {
        vLog(LOG_ERROR, "Fail initialize memory!\n");
        return FALSE;
    }

    if (usesqlite)
    {
        vLog(LOG_DEBUG, "read configuration from sqlite3 db file.\n");
        BOOLEAN ret = FALSE;
#if 0
        ret = ReadConfigFromSQLite(enable_auto_platform, pathName, codeName);
        if (ret) 
        {
            WriteSystemCFG();
            WriteNodeCFG();
            WriteHardwareCFG();
            WriteProcessCFG();
            WriteUnitCFG();
            WriteStaticUnitCFG();
        }
#endif 
        return ret;       
    }
    else
    {
        vLog(LOG_DEBUG, "read configuration from struct files.\n");
        vLog(LOG_DEBUG, "Loading system config...\n");
        if (!ReadSystemCFG())
        {
            vLog(LOG_ERROR, "Fail load system config!\n");
            alarm();
            return FALSE;
        }

        vLog(LOG_DEBUG, "Loading node config...\n");
        if (!ReadNodeCFG())
        {
            vLog(LOG_ERROR, "Fail load node config!\n");
            alarm();
            return FALSE;
        }

        vLog(LOG_DEBUG, "Loading database config...\n");
        if (!ReadDatabaseCFG())
        {
            vLog(LOG_ERROR, "Fail load database config!\n");
            alarm();
            return FALSE;
        }

        vLog(LOG_DEBUG, "Loading hardware config...\n");
        if (!ReadHardwareCFG())
        {
            vLog(LOG_ERROR, "Fail load hardware config!\n");
            alarm();
            return FALSE;
        }

        vLog(LOG_DEBUG, "Loading process config...\n");
        if (!ReadProcessCFG())
        {
            vLog(LOG_ERROR, "Fail load processes config!\n");
            alarm();
            return FALSE;
        }

        vLog(LOG_DEBUG, "Loading unit config...\n");
        if (!ReadUnitCFG())
        {
            vLog(LOG_ERROR, "Fail load unit config!\n");
            alarm();
            return FALSE;
        }
        
        vLog(LOG_DEBUG, "Loading static unit config...\n");
        if (!ReadStaticUnitCFG())
        {
            vLog(LOG_ERROR, "Fail load static unit config!\n");
            alarm();
            return FALSE;
        }
    }
    return TRUE;
}

BOOLEAN destroy_thread(void)
{
    int i = 0;

    if (!systemRunFlag) return FALSE;
    
    dumpLogs();
    systemRunFlag = FALSE;

    for (i = 0; i < MAX_THREAD_NUM; i++)
    {
        if (p_id[i] != 0) 
        {
            char name[16];
            memset(name, '\0', sizeof(name));
            if (pthread_getname_np(p_id[i], name, sizeof(name)) != 0)
            {
                memset(name, '\0', sizeof(name));
            }
            vLog(LOG_DEBUG, "waiting for system thread [%d,%s] destroy.\n", i, (name[0] != '\0') ? name : "unknow");
            pthread_join(p_id[i], NULL);
            vLog(LOG_DEBUG, "system protocol thread [%d,%s] is destroyed.\n", i, (name[0] != '\0') ? name : "unknow");
        }
    }

    return TRUE;
}

BOOLEAN initialize_thread(void)
{
    int ret;
    pthread_attr_t  attr;
    systemRunFlag = TRUE;

    pthread_attr_init(&attr);
    pthread_attr_setstacksize(&attr, MEMERY_1M);
    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
    //pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    ret = pthread_create(&p_id[THREAD_ID_MAIN], &attr, main_process, NULL);
    if (ret < 0)
    {
        vLog(LOG_ERROR, "Create main_process thread error(%d,%s)!\n", errno, strerror(errno));
        return FALSE;
    }
#if 1
    pthread_setname_np(p_id[THREAD_ID_MAIN], "main process");
#endif
    ret = pthread_create(&p_id[THREAD_ID_IDLE], &attr, idle_process, NULL);
    if (ret < 0)
    {
        vLog(LOG_ERROR, "Create idle_process thread error(%d,%s)!\n", errno, strerror(errno));
        return FALSE;
    }
#if 1
    pthread_setname_np(p_id[THREAD_ID_IDLE], "idle process");
#endif
    pthread_attr_destroy(&attr);

    sleep(1);
    if (!synchronized)
    {
        vLog(LOG_DEBUG, "system clock does't synchronized!\n");
    }
    
    return TRUE;
}