/********************************************************************
版权所有：
文件版本： V1.00
文件名称： Mmidata.c
生成日期： 2008年09月9日
作    者：
使用范围：

功    能：菜单调用的各种处理函数
更新信息：
更新日志1：
修改者:
修改日期:
修改内容:
修改原因:
*********************************************************************/
#include "head.h"
#if defined LINUX_KERNEL_APP
#include <linux/delay.h>
#endif
#include "uart_user.h"

#define LCD_SIZE 160

UINT m_ScreenNum;
UINT m_CurrentScreen;
UINT m_SwNo;

DATA_MENU_DEF g_tDataMenu1; // 数据菜单定义
DATA_MENU_DEF g_tDataMenu2; // 数据菜单定义
DATA_MENU_DEF g_tExtraMenu;

char m_WarningStr[PARA_NAME_LEN]; // 提示信息字符
char m_errInf[24];                // 错误信息保存

UINT m_Password;    // 密码
UINT m_NewPassword; // 密码修改时新密码

char m_strPassword[10];
char m_strPassword2[10];

char m_YdYcHalfOfRateValue[16] = "";

UINT m_AllSection;   // 全部定值区选择时选择的定值区
UINT m_ValidSection; // 有效定值区选择时选择的定值区
UINT m_CtrlWord;     // 当前显示控制子

char m_set_name[24];     // 定值名称
char m_set_name_ext[24]; // 定值名称
char m_set_inf[24];      // 定值信息1 ，显示提示信息

// #ifdef DISP_LIST_NUM
char LIST_tmp[MAX_SET_NUMBER][MOD_NAME_LEN]; // 存放定值选项字符串及对应数字的数组(如:"0:退出"、"1:投入")
// #endif

#ifdef CPU_FUXI
char menu_tmp[MAX_SET_NUMBER][MOD_NAME_LEN];
#endif

SET_VALUE m_SetBuf[MAX_SET_NUMBER]; // 定义定值查看及整定时的buf

INDEX_DEF g_tIndex[INDEX_NUM]; // 名称 值索引结构定义

const char *TestDo_Hz = "合";

WORD g_sw_index;
char m_equipstr[22];
u8 m_setgroup[GROUP_NUM];
u8 bPubSetMenuShow[SET_PUB_NUM];
u8 bSwSetMenuShow[SET_NUM];
u8 bParaSetMenuShow[PARA_NUM];
u8 bCstSetMenuShow[CSTSET_NUM];

char m_Ledgoose[12];
char m_Ledbh[12];
char m_Ledfa[12];
char m_Fa_sl[12];
char m_Bh_chr[12];
char m_Fa_chr[12];
char m_Goose_chr[12];
char m_Ledjzs[12];

char m_TzCount[12];
char m_HzCount[12];

WORD m_selsection;
WORD m_sectionnum;
char m_selsec_char[10];

char m_Mode_chr[20];
char m_Tqhz_chr[20];
char m_Zdjl_chr[20];
char m_StopFun_chr[20];
char m_Yftr_chr[20];

bool mmd_CheckPassword2(void)
{
    u8 passstr[10];
#ifdef PASSWORD_4_STR
    strcpy(passstr, INTER_PASSWORD_STR_4);
#else
    strcpy(passstr, INTER_PASSWORD_STR);
#endif
    if ((strcmp(m_strPassword, tRunPara.wPasswordstr2) != 0) && (strcmp(m_strPassword, passstr) != 0))
    {
        m_Password = 0;
        mmi_zero_passwordstr();
        strcpy(m_WarningStr, "输入密码错误!");
        return false;
    }
    m_Password = 0;
    mmi_zero_passwordstr();
    return true;
}

/**************************************************************************
函数名称：mmd_RenewDataMenu
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：刷新动态菜单
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static int mmd_RenewDataMenu(DATA_MENU_DEF *pt)
{
    int i;
    int index = (pt->sFocusIndex / pt->sScreenNum) * pt->sScreenNum; // 当前显示的动态数据的索引
    for (i = 0; i < pt->sScreenNum; i++)                             // 更新显示项
    {
        (*pt->GetValueFuncAddr)(index, &pt->tDataFields[i]);
        if (++index > pt->sTotalNum - 1)
            break; // 最后一个CPU
    }
    m_CurrentScreen = (pt->sFocusIndex / pt->sScreenNum) + 1; // 当前屏数
    return M_OK;
}
/**************************************************************************
函数名称：mmd_initDataMenu
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：初始化动态菜单
输入参数：pt 动态显示数据结构,num最大显示数目
                           fun_next，转下一屏处理函数，
                           fun_value  取值函数
                           menuno,fieldno 要显示的屏号和域号
                           type，轮询召唤的类型
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
static void mmd_initDataMenu(DATA_MENU_DEF *pt, int num, void *fun_next, void *fun_value, unsigned char menuno, unsigned char fieldno)
{
    int i;
    int (*pfun)(int i, DATA_FIELD_DEF *pd);
    int screennum;
    pfun = (int (*)(int i, DATA_FIELD_DEF *pF))fun_value; // 更新显示数据的函数
    screennum = mmi_GetScreenNum(menuno, fieldno);        // 取当前屏幕最大显示树木
    if (fun_value != NULL)
    {
        for (i = 0; i < screennum; i++) // 更新显示数据
        {
            (*pfun)(i, &pt->tDataFields[i]);
            if (i >= num - 1)
                break;
        }
    }
    if (screennum <= 0)
        screennum = 1;
    m_ScreenNum = num / screennum;
    if (num % screennum > 0)
        m_ScreenNum += 1;
    pt->sFocusIndex = 0; // 第一个显示的动态菜单的索引
    pt->sTotalNum = num; // 总的动态菜单数
    pt->sScreenNum = screennum;
    pt->GetPrevFuncAddr = fun_next; // 44
    pt->GetNextFuncAddr = fun_next; // 44
    pt->GetValueFuncAddr = fun_value;
    m_CurrentScreen = 1;
}

/**************************************************************************
函数名称：mmd_IndexMenuKey
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：列表选择时，按键的处理函数
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_IndexMenuKey(int key)
{
    int t;
    INDEX_DEF *pt;
    t = mmi_GetActiveFieldPara(); // 取得当前列表结构的下标
    if (t >= INDEX_NUM)
        return M_ERROR;
    pt = &g_tIndex[t];
    if (pt->num <= 0)
        return M_ERROR;

    if (key == HA_KEY_ENTER) // 确认键处理
    {
        int ret;
        *pt->pValue = pt->value[pt->bCurrent]; // 赋值
        if (pt->EnterFunc != NULL)
        {
            ret = (*pt->EnterFunc)(); // 执行函数
            return ret;
        }
        return M_OK;
    }
    if (key != HA_KEY_ADD && key != HA_KEY_SUB)
        return M_ERROR;
    if (key == HA_KEY_ADD) // +键处理
    {
        pt->bCurrent++;
    }
    else if (key == HA_KEY_SUB) // +键处理
    {
        if (pt->bCurrent == 0)
        {
            pt->bCurrent = pt->num - 1;
        }
        else
        {
            pt->bCurrent--;
        }
    }
    if (pt->bCurrent >= pt->num)
    {
        pt->bCurrent = 0;
    }

    strcpy(pt->str, pt->name[pt->bCurrent]); // 更新列表显示
    *pt->pValue = pt->value[pt->bCurrent];
    return M_OK;
}

/***********************定值修改**********************************/

/**************************************************************************
函数名称：mmd_IsIntegType
函数版本：1.00
作者：
创建日期：2008.9.23
函数功能说明： 判断参数类型是否为整型类型的
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
static bool mmd_IsIntegType(WORD type)
{

    if (type == SETTYPE_KG || type == SETTYPE_LIST || type == SETTYPE_UINT || type == SETTYPE_LINT || type == SETTYPE_5INT || type == SETTYPE_4INT)
    {
        return true;
    }
    return false;
}

static bool mmd_IsHexType(WORD type)
{

    if (type == SETTYPE_YMD || type == SETTYPE_HMS || type == SETTYPE_IP)
    {
        return true;
    }
    return false;
}

/**************************************************************************
函数名称：mmd_ChangeList
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：改变下拉列表的值
输入参数：
输出参数：
返回值：若是列表，返回真值

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static bool mmd_ChangeList(const TSETTABLE *pSetTable, int key, SET_VALUE *setbuf)
{

    int setno;
    const TSETTABLE *pTable;
    long listvalue;
    // 判断是否是列表
    setno = g_set_disp.no[mmi_GetActiveFieldIndex()]; // 取得当前定值的索引，判断是否是列表项
    pTable = &pSetTable[setno];
    if (pTable->wType == SETTYPE_LIST) // 列表项
    {

        listvalue = setbuf[setno].tt; // 取得控制字的值

        if (key == HA_KEY_ADD)
        {
            listvalue++;
            if (listvalue >= pTable->listnum)
            {
                listvalue = pTable->fMin;
            }
        }
        else if (key == HA_KEY_SUB)
        {
            if (listvalue > pTable->fMin)
            {
                listvalue--;
            }
            else
            {
                listvalue = pTable->listnum - 1;
            }
        }

        setbuf[setno].tt = listvalue; // pTable->list[listvalue].dat;操作列表定值出问题
        return true;
    }
    return false;
}

/**************************************************************************
函数名称：mmd_ChangeSet
函数版本：1.00
作者：
创建日期：2008.9.11
函数功能说明：转换定值，将EEPROM中的值转换为菜单整定时使用的值，主要是控制字
              由浮点数转为定点数
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
bool mmd_checkset_yb(u8 index) // 判断定值分类对应的压板是否有效
{
    u8 yb, group_sub;
    int sw = 0;
    // if(index==0)return true;
    // index-=1;
    u8 yb_fa_g = g_tRelay[sw].run_stu.fa_g_tt;

    yb = SetGroups[index].set_yb;

#ifdef YB_AUTO_SELECT
    yb_fa_g = goose_yb_enable(sw) && (yb == SET_HYB_GOOSE);
#else
#ifndef GD_AREA_ZHONGSHAN // 非中山的地区，开关定值显示直接关联硬件压板。中山要求智能分布式模式下显示所有开关定值
#ifndef GD_AREA_ZHONGSHAN_2020
    yb_fa_g = g_tRelay[sw].run_stu.fa_g_tt && (yb == SET_HYB_GOOSE);
#endif
#endif
#endif

    group_sub = SetGroups[index].group_sub;

    if (yb == 0)
        return true;

#ifdef GD_AREA_ECZD_2020
    if (yb == SET_HYB_TQ)
    {
        if (group_sub == GROUP_SET_TQHZ)
        {
            return (g_tRelay[sw].run_stu.cgbhtt) || yb_fa_g;
        }
        else
        {
            return g_tRelay[sw].run_stu.cgbhtt || yb_fa_g;
        }
    }
#endif

    if (yb == SET_HYB_BH)
    {
        if (group_sub == GROUP_SET_JLTT)
        {
            return g_tRelay[sw].run_stu.cgbhtt || yb_fa_g;
        }
        else if (group_sub == GROUP_SET_TQHZ)
        {
            return (g_tRelay[sw].run_stu.cgbhtt) || yb_fa_g;
        }
        else
        {
#ifdef YB_AUTO_SELECT
            return bh_yb_enable(sw) || yb_fa_g;
#else
            return g_tRelay[sw].run_stu.cgbhtt || yb_fa_g;
#endif
        }
    }

    if (yb == SET_HYB_FA)
    {
#ifdef YB_AUTO_SELECT
        return fa_yb_enable(sw) || yb_fa_g;
#else
        return g_tRelay[sw].run_stu.fatt || yb_fa_g;
#endif
    }
    if (yb == SET_HYB_GOOSE)
    {
#ifdef YB_AUTO_SELECT
        return goose_yb_enable(sw);
#else
        return g_tRelay[sw].run_stu.fa_g_tt;
#endif
    }
    return true;
}

int mmd_ChangeSet(const TSETTABLE *pSet, int num, SET_VALUE *setbuf) // ext为不需显示的定值组
{
    int i;
    for (i = 0; i < num; i++)
    {
        if (mmd_IsIntegType(pSet[i].wType))
        {

            float ff = setbuf[i].ff;
            setbuf[i].tt = (uint32_t)ff;
        }
    }
    return 0;
}
bool mmd_checkset_menucfg(const TSETTABLE *pSet, int i, u8 group) // 判断定值分类对应的压板是否有效
{
    if (pSet == &tPubSetTable[0])
    {
        return bPubSetMenuShow[i] && (tPubSetTable[i].group == group);
    }
    else if (pSet == &tSwSetTable[0])
    {

        return bSwSetMenuShow[i] && (tSwSetTable[i].group == group);
    }
    else if (pSet == &tEquipParaTable[0])
    {

        return bParaSetMenuShow[i] && (tEquipParaTable[i].group == group);
    }
    else if (pSet == &tCstSetTable[0])
    {

        return bCstSetMenuShow[i] && (tCstSetTable[i].group == group);
    }

    return (pSet[i].group == group);
}
int mmd_GetshowSetNum(const TSETTABLE *pSet, int num, u8 group)
{
    int i;
    for (i = 0; i < num; i++)
    {
        if (pSet[i].wType != SETTYPE_LABEL)
        {
            bool bYB_set;
            bool bmenu_set;
            bmenu_set = mmd_checkset_menucfg(pSet, i, group);
            bYB_set = mmd_checkset_yb(pSet[i].group);
            if ((m_setgroup[pSet[i].group]) && bYB_set && bmenu_set) // 定值分类组为0 或显示定制为1
            {
                g_set_disp.no[g_set_disp.num] = i;
                g_set_disp.num++;
            }
        }
    }
    return g_set_disp.num;
}

/**************************************************************************
函数名称：mmd_CheckSet
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：检查参数
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static bool mmd_CheckSet(const TSETTABLE *pSet, int num, SET_VALUE *setbuf)
{
    int i;
    char tmpstr[32];
    for (i = 0; i < num; i++)
    {
        if (mmd_IsIntegType(pSet[i].wType))
        {
            float ff = setbuf[i].ff;
            if (CheckFloatSet((void *)&ff, pSet[i].fMax, pSet[i].fMin) > 0)
                break;
        }
        else if (mmd_IsHexType(pSet[i].wType))
        {
            // float ff=setbuf[i].ff;
            // if(CheckFloatSet((void *)&ff,pSet[i].fMax,pSet[i].fMin)>0)break;
        }
        else
        {
            if (CheckFloatSet((void *)&setbuf[i].ff, pSet[i].fMax, pSet[i].fMin) > 0)
                break;
        }
    }
    if (i < num)
    {
        strcpy(m_WarningStr, pSet[i].szName);
        if (mmd_IsIntegType(pSet[i].wType))
        {
            sprintf(m_errInf, "RA:%.0f~%.0f", pSet[i].fMin, pSet[i].fMax);
        }
        else
        {
            strcpy(m_errInf, "RA:");
            switch (mmi_GetFloatFactor((void *)&pSet[i].fMin))
            {

            case 0: // 浮点数
                sprintf(tmpstr, "%.0f", pSet[i].fMin);
                break;
            case 1: // 浮点数
                sprintf(tmpstr, "%.1f", pSet[i].fMin);
                break;
            case 2: // 浮点数
                sprintf(tmpstr, "%.2f", pSet[i].fMin);
                break;
            case 3: // 浮点数
                sprintf(tmpstr, "%.3f", pSet[i].fMin);
                break;
            default:
                sprintf(tmpstr, "%.2f", pSet[i].fMin);
                break;
            }
            strcat(m_errInf, tmpstr);
            strcat(m_errInf, "~");
            switch (mmi_GetFloatFactor((void *)&pSet[i].fMax))
            {
            case 0: // 浮点数
                sprintf(tmpstr, "%.0f", pSet[i].fMax);
                break;
            case 1: // 浮点数
                sprintf(tmpstr, "%.1f", pSet[i].fMax);
                break;
            case 2: // 浮点数
                sprintf(tmpstr, "%.2f", pSet[i].fMax);
                break;
            case 3: // 浮点数
                sprintf(tmpstr, "%.3f", pSet[i].fMax);
                break;
            default:
                sprintf(tmpstr, "%.2f", pSet[i].fMax);
                break;
            }
            strcat(m_errInf, tmpstr);
        }
        return false;
    }
    return true; // 弹出定值固化菜单，需选择输入区号
}

int m_SetSwNo = 0;

/**************************************************************************
函数名称：mmd_ReChangeSet
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：将整定值转换为要保存的值
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

void mmd_ReChangeSet(const TSETTABLE *pSet, int num, SET_VALUE *setbuf)
{
    int i;
    for (i = 0; i < num; i++)
    {
        if (mmd_IsIntegType(pSet[i].wType))
        {
            uint32_t tt = setbuf[i].tt;
            setbuf[i].ff = tt;
        }
    }
}

bool bSetChange = false;
u8 SetGroupIndex;
u8 set_show_group[GROUP_NUM];

void GetDefSetGroup(u8 *dat)
{
    int i;
    for (i = 0; i < GROUP_NUM; i++)
    {
        dat[i] = (u8)SetGroups[i].defval;
    }
}

int mmd_GetDefaultPubSet(int value)
{
    GetDefPara((void *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]);
    mmd_ChangeSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf);
    return M_OK;
}
int mmd_GetDefaultBhSet(int value)
{
    GetDefPara((void *)m_SetBuf, SW_SET_NUMBER, &tSwSetTable[0]);
    mmd_ChangeSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf);
    return M_OK;
}

int mmd_GetDefaultParaSet(int value)
{
    GetDefPara((void *)m_SetBuf, EQUIP_PARA_NUMBER, &tEquipParaTable[0]);
    mmd_ChangeSet(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf);
    return M_OK;
}
int mmd_GetDefaultCstSet(int value)
{
    GetDefPara((void *)m_SetBuf, CSTSET_NUMBER, &tCstSetTable[0]);
    mmd_ChangeSet(&tCstSetTable[0], CSTSET_NUMBER, m_SetBuf);
    return M_OK;
}
void mmd_split_setname(unsigned char *str, int len, DATA_FIELD_DEF *pt, int index)
{
    int lineoff;
    unsigned char tmpstr[24];
    lineoff = mmd_splitstr(str, len);
    if (lineoff == 0)
    {
        sprintf(pt[index].FmtStr, "%-20.20s", str);
    }
    else
    {
        lineoff = mmd_splitstr(str, len);
        sprintf(pt[index + 1].FmtStr, "    %-16.16s", &str[lineoff]);
        strcpy(tmpstr, str);
        tmpstr[lineoff] = '\0';
        sprintf(pt[index].FmtStr, "%-20.20s", tmpstr);
    }
}

void mmd_analyse(const TSETTABLE *pTable, int screennum)
{
    int i;
    int offset = 0;
    int addlines = 2;
    int screencnt = 0;
    int bgn = 0;
    unsigned char tmpstr[PARA_NAME_LEN];
    for (i = 0; i < g_set_disp.num; i++)
    {
        g_set_disp.Y_offset[i] = offset;
        g_set_disp.screennum[i] = 0;
        if (offset == 0)
            bgn = i;
        g_set_disp.bgn[i] = bgn;
        sprintf(tmpstr, "%02d.%s", i, pTable[g_set_disp.no[i]].szName);
        if ((mmd_splitstr(tmpstr, 20)) == 0) // 定值名称一行可现实
        {
            addlines = 2;
        }
        else
        {
            addlines = 3;
        }
        screencnt++;
        offset += addlines;
        if (offset == screennum)
        {
            int j;
            for (j = 0; j < screencnt; j++)
            {
                g_set_disp.screennum[bgn + j] = screencnt;
            }
            offset = 0;
            screencnt = 0;
        }
        else if (offset > screennum)
        {
            int j;
            for (j = 0; j < screencnt - 1; j++)
            {
                g_set_disp.screennum[bgn + j] = screencnt - 1;
            }
            g_set_disp.Y_offset[i] = 0;
            g_set_disp.bgn[i] = i;
            bgn = i;
            offset = addlines;
            screencnt = 1;
        }
    }
    if (screencnt > 0)
    {
        int j;
        for (j = 0; j < screencnt; j++)
        {
            g_set_disp.screennum[bgn + j] = screencnt;
        }
    }
}

void mmd_GetSet(int index, DATA_FIELD_DEF *pt, const TSETTABLE *pTable, SET_VALUE *setbuf)
{
    float ff;
    DATA_FIELD_DEF *pex = &g_tExtraMenu.tDataFields[0];
    int setno;
    int lineoff;
    // #ifdef DISP_LIST_NUM
    int i = 0;
// #endif
#ifdef DISP_LIST_NUM
    DWORD dat;
#endif
    u8 tmp_len;
    const char fill_content[] = "                  ";

    // 定值汉字描述
    m_set_name[0] = 0;
    m_set_name_ext[0] = 0;
    m_set_inf[0] = 0;
    pt->bEdit = false;
    setno = g_set_disp.no[index];
    pTable += setno;
    // 定值名称处理
    {
        unsigned char tmpstr[PARA_NAME_LEN];
        sprintf(tmpstr, "%02d.%s", index + 1, pTable->szName);
        lineoff = mmd_splitstr(tmpstr, 20);
        pex[g_tExtraMenu.sTotalNum].offset = g_set_disp.Y_offset[index];
        if (lineoff == 0)
        {
            sprintf(pex[g_tExtraMenu.sTotalNum].FmtStr, "%-20.20s", tmpstr);
            g_tExtraMenu.sTotalNum++;
        }
        else
        {
            sprintf(pex[g_tExtraMenu.sTotalNum + 1].FmtStr, "  %-18.18s", &tmpstr[lineoff]);
            tmpstr[lineoff] = '\0';
            sprintf(pex[g_tExtraMenu.sTotalNum].FmtStr, "%-20.20s", tmpstr);
            pex[g_tExtraMenu.sTotalNum + 1].offset = pex[g_tExtraMenu.sTotalNum].offset + 1;
            g_tExtraMenu.sTotalNum += 2;
        }
    }
    switch (pTable->wType)
    {

    case SETTYPE_YMD:               // 年月日
        strcpy(pt->FmtStr, "20%y"); // 对齐符号位
        pt->pData = (void *)&setbuf[setno].tt;
        break;

    case SETTYPE_IP:              // 年月日
        strcpy(pt->FmtStr, "%p"); // 对齐符号位
        pt->pData = (void *)&setbuf[setno].tt;
        break;

    case SETTYPE_KG:                 // 16进制显示  控制字
        strcpy(pt->FmtStr, "%*4XH"); // 对齐符号位
        if (bSetChange)
        {
            strcpy(m_set_inf, "长按->键选择整定");
        }
        else
        {
            sprintf(m_set_inf, "RA:%04XH~%04XH", (long)pTable->fMin, (long)pTable->fMax);
        }
        pt->pData = (void *)&setbuf[setno].tt;
        break;

    case SETTYPE_UINT:              // 16进制显示  控制字
        strcpy(pt->FmtStr, "%*3u"); // 对齐符号位
        sprintf(m_set_inf, "RA:%03u~%03u", (long)pTable->fMin, (long)pTable->fMax);
        pt->pData = (void *)&setbuf[setno].tt;
        break;

    case SETTYPE_5INT:              // 10进制显示  5位
        strcpy(pt->FmtStr, "%*5u"); // 对齐符号位
        sprintf(m_set_inf, "RA:%05u~%05u", (long)pTable->fMin, (long)pTable->fMax);
        pt->pData = (void *)&setbuf[setno].tt;
        break;

    case SETTYPE_LINT:              // 16进制显示  控制字
        strcpy(pt->FmtStr, "%*6u"); // 对齐符号位
        sprintf(m_set_inf, "RA:%06u~%06u", (long)pTable->fMin, (long)pTable->fMax);
        pt->pData = (void *)&setbuf[setno].tt;
        break;
    case SETTYPE_LIST: // 列表选择
    {
        int j;
        int len = 0;
        for (i = 0; i < pTable->listnum; i++) // 查找最长的字符串
        {
            j = strlen(pTable->list[i].str);
            if (len < j)
            {
                len = j;
            }
        }
        if (len < 10)
        {
            strcpy(pt->FmtStr, "%s");
        }
        else if (len < 12)
        {
            strcpy(pt->FmtStr, "%s");
        }
        else if (len < 14)
        {
            strcpy(pt->FmtStr, "%s");
        }
        else
        {
            strcpy(pt->FmtStr, "%s");
        }

        pt->bEdit = true;

        i = 0;
#ifdef DISP_LIST_NUM
        // 串口波特率在液晶会显示(600:600)(1200:1200)...，改成(0:600)(1:1200)...序号从0开始
        if (pTable->list == BaudList)
        {
            dat = setbuf[setno].tt;
        }
        else
        {
            dat = pTable->list[setbuf[setno].tt].dat;
        }
        i = sprintf(LIST_tmp[setno], "%d:", dat);
#endif

#ifdef CPU_FUXI
        strcpy(menu_tmp[setno], pTable->list[setbuf[setno].tt].str);
        pt->pData = (void *)menu_tmp[setno];
#else
        tmp_len = strlen(pTable->list[setbuf[setno].tt].str);
        i = sprintf((LIST_tmp[setno] + i), "%s", pTable->list[setbuf[setno].tt].str);
        strncat((LIST_tmp[setno] + i), fill_content, len - tmp_len); // 用空白填充剩余区域，防止显示上一个列表项的部分内容
        pt->pData = (void *)LIST_tmp[setno];
#endif
    }
    break;

    default:
        ff = setbuf[setno].ff;
        switch (mmi_GetFloatFactor((void *)&ff))
        {

        case 0: // 浮点数
            strcpy(pt->FmtStr, "%+-6.1f");
            break;
        case 1: // 浮点数
            strcpy(pt->FmtStr, "%+-6.1f");
            break;
        case 2: // 浮点数
            strcpy(pt->FmtStr, "%+-6.2f");
            break;
        case 3: // 浮点数
            strcpy(pt->FmtStr, "%+-6.3f");
            break;
        default:
            strcpy(pt->FmtStr, "%+-6.1f");
            break;
        }
        ff = pTable->fMin;
        switch (mmi_GetFloatFactor((void *)&ff))
        {

        case 0: // 浮点数
            sprintf(m_set_inf, "RA:%-5.1f", ff);
            break;
        case 1: // 浮点数
            sprintf(m_set_inf, "RA:%-5.1f", ff);
            break;
        case 2: // 浮点数
            sprintf(m_set_inf, "RA:%-5.2f", ff);
            break;
        case 3: // 浮点数
            sprintf(m_set_inf, "RA:%-5.3f", ff);
            break;
        default:
            sprintf(m_set_inf, "RA:%-5.1f", ff);
            break;
        }
        ff = pTable->fMax;
        switch (mmi_GetFloatFactor((void *)&ff))
        {

        case 0: // 浮点数
            sprintf(m_set_name, "%-5.1f", ff);
            break;
        case 1: // 浮点数
            sprintf(m_set_name, "%-5.1f", ff);
            break;
        case 2: // 浮点数
            sprintf(m_set_name, "%-5.2f", ff);
            break;
        case 3: // 浮点数
            sprintf(m_set_name, "%-5.3f", ff);
            break;
        default:
            sprintf(m_set_name, "%-5.1f", ff);
            break;
        }
        strcat(m_set_inf, "~");
        strcat(m_set_inf, m_set_name);
        pt->pData = (void *)&setbuf[setno].ff;
        break;
    }

    strcat(pt->FmtStr, " ");                                                                       // 单位
    strcat(pt->FmtStr, SetUints[pTable->wUnit]);                                                   // 单位
    pt->offset = (lineoff == 0) ? g_set_disp.Y_offset[index] + 1 : g_set_disp.Y_offset[index] + 2; // 偏移地址
    sprintf(m_equipstr, "%s", SetGroups[pTable->group].item_name);
}

/**************************************************************************
函数名称：mmd_RenewPubSet
函数版本：1.00
作者：
创建日期：2008.9.11
函数功能说明：刷新定值显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_RenewPubSet(void)
{
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    DATA_MENU_DEF *pext = &g_tExtraMenu;
    int i;
    int bgn;
    bgn = g_set_disp.bgn[pt->sFocusIndex];
    pext->sTotalNum = 0; // 总的动态菜单数
    for (i = 0; i < g_set_disp.screennum[pt->sFocusIndex]; i++)
    {
        mmd_GetSet(bgn + i, &g_tDataMenu1.tDataFields[i], &tPubSetTable[0], m_SetBuf);
    }
    pt->sScreenNum = g_set_disp.screennum[pt->sFocusIndex];
    pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
    pext->sScreenNum = pext->sTotalNum;
    return M_OK;
}

int mmd_RenewPubSetGroup(void)
{
    mmd_RenewDataMenu(&g_tDataMenu2);
    return M_OK;
}

static void mmd_GetSetGroupName(int i, DATA_FIELD_DEF *pF)
{
    // strcpy(pF->FmtStr,SetGroups[set_show_group[i]].item_name);
    sprintf(pF->FmtStr, "%d.%s", i + 1, SetGroups[set_show_group[i]].item_name);
}

int mmd_backPubSet(int value)
{

    mmd_InitPubSetGroup(-1);
    g_tDataMenu2.sFocusIndex = SetGroupIndex;
    mmi_FormsInit(42, 1); //  更新最后修改的数据
    mmd_RenewPubSetGroup();
    return M_OK;
}

int mmd_ValueJump(void)
{
#ifdef SEC_SETVALUE_7
    return M_JUMP1;
#else
    return M_JUMP0;
#endif
}

int mmd_InitPubSetGroup(int value)
{
    int i, num = 0;
    for (i = 0; i < GROUP_NUM; i++)
    {
        if (SetGroups[i].group == SETGROUP_TYPE_PUB && (m_setgroup[i] > 0))
        {
            int j;
            for (j = 0; j < PUB_SET_NUMBER; j++)
            {
                if ((bPubSetMenuShow[j] > 0) && (tPubSetTable[j].group == i) && (tPubSetTable[j].wType != SETTYPE_LABEL))
                {
                    set_show_group[num++] = i;
                    break;
                }
            }
        }
    }
    if (num == 0)
    {
        strcpy(m_WarningStr, "公共定值未配置");
        return M_JUMP2;
    }
    mmd_initDataMenu(&g_tDataMenu2, num, mmd_RenewPubSetGroup, mmd_GetSetGroupName, 42, 1);

    /*读取公共定值*/
    if (!ReadPara((void *)m_SetBuf, EEP_PUB_ADDR + (PUB_SETSIZE * m_selsection), PUB_SET_NUMBER, &tPubSetTable[0]))
    {
        if (value == -1)
        {
            GetDefPara((void *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]);
        }
        else
        {
            strcpy(m_WarningStr, "定值读取错误，请整定");
            return M_JUMP3;
        }
    }

    mmd_ChangeSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf);

    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_InitSetSolid
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：初始化定值整定的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_InitPubSet(int value)
{
    int num = PUB_SET_NUMBER;
    int screennum;
    int i;
    m_AllSection = 0;
    g_set_disp.num = 0;
    num = mmd_GetshowSetNum(&tPubSetTable[0], PUB_SET_NUMBER, set_show_group[value]);
    SetGroupIndex = value;
    screennum = mmi_GetScreenNum(43, 1); // 取当前屏幕最大显示数目
    bSetChange = true;
    mmd_analyse(&tPubSetTable[0], screennum);
    {
        DATA_MENU_DEF *pt = &g_tDataMenu1;
        DATA_MENU_DEF *pext = &g_tExtraMenu;
        pext->sTotalNum = 0;
        for (i = 0; i < g_set_disp.screennum[0]; i++)
        {
            mmd_GetSet(i, &g_tDataMenu1.tDataFields[i], &tPubSetTable[0], m_SetBuf);
        }
        m_ScreenNum = num;
        pt->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pt->sTotalNum = num; // 总的动态菜单数
        pt->sScreenNum = g_set_disp.screennum[0];
        pt->GetPrevFuncAddr = mmd_RenewPubSet; // 44
        pt->GetNextFuncAddr = mmd_RenewPubSet; // 44

        pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pext->sScreenNum = pext->sTotalNum;
        pext->GetPrevFuncAddr = NULL; // 44
        pext->GetNextFuncAddr = NULL; // 44
        m_CurrentScreen = 1;
    }
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_SetKey
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：列表项选择
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SetPubKey(int key)
{
    if (key == HA_KEY_UP && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_ADD;
    if (key == HA_KEY_DOWN && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_SUB;

    if (key == HA_KEY_ADD || key == HA_KEY_SUB) // +键增加列表
    {
        if (!g_bModify)
            return M_ERROR; // 只在修改状态下执行此函数
        if (mmd_ChangeList(&tPubSetTable[0], key, m_SetBuf))
        {
            mmd_RenewPubSet(); // 刷新修改后的值
            return M_OK;
        }
    }
    return M_ERROR;
}

int mmd_SavePubSet(int value)
{
#ifdef PUB_SET_SECTION
    WORD save_section;
    int i;
    bool b_section_change = false; // 局部变量初始化，避免下面if中判断为随机态
#endif

    if (mmd_CheckPassword2() == false)
    {
        return M_JUMP2;
    }
    mmd_ReChangeSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf);
    if (!mmd_CheckSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf))
    {
        mmd_ChangeSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf);
        return M_JUMP3;
    }

#ifdef PUB_SET_SECTION
    save_section = m_SetBuf[1].ff;
    if (save_section != m_runsection)
    {
        b_section_change = true;
    }
    if (SavePara((void *)m_SetBuf, EEP_PUB_ADDR + (PUB_SETSIZE * save_section), PUB_SET_NUMBER, &tPubSetTable[0]))
    {
        strcpy(m_WarningStr, "公共定值保存成功");
        soe_record_opt(EV_PUBSET_OK, 0);
        MakeRunSet(false);
        rt_err_clr(ERR_CODE_SET_PUB, 0);
        m_runsection = save_section;
    }
    else
    {
        strcpy(m_WarningStr, "公共定值保存失败");
        soe_record_opt(EV_PUBSET_FAIL, 0);
        b_section_change = false;
    }

    // 将其他公共定值区的定值区定值也做修改
    if (b_section_change)
    {
        for (i = 0; i < SEC_NUMBER; i++)
        {
            if (i == save_section)
                continue;

            /*读取公共定值*/
            if (!ReadPara((void *)m_SetBuf, EEP_PUB_ADDR + PUB_SETSIZE * i, PUB_SET_NUMBER, &tPubSetTable[0]))
            {
                rt_err_set(ERR_CODE_SET_PUB, 0);
                GetDefPara((void *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]);
            }
            else
            {
                rt_err_clr(ERR_CODE_SET_PUB, 0);
            }

            m_SetBuf[SET_SECTION].ff = m_runsection;

            if (SavePara((void *)m_SetBuf, EEP_PUB_ADDR + (PUB_SETSIZE * i), PUB_SET_NUMBER, &tPubSetTable[0]))
            {
                strcpy(m_WarningStr, "公共定值保存成功");
                soe_record_opt(EV_PUBSET_OK, 0);
                MakeRunSet(false);
                rt_err_clr(ERR_CODE_SET_PUB, 0);
                m_runsection = save_section;
            }
            else
            {
                strcpy(m_WarningStr, "公共定值保存失败");
                soe_record_opt(EV_PUBSET_FAIL, 0);
            }
        }
    }

#else
    if (SavePara((void *)m_SetBuf, EEP_PUB_ADDR, PUB_SET_NUMBER, &tPubSetTable[0]))
    {
        strcpy(m_WarningStr, "公共定值保存成功");
        soe_record_opt(EV_PUBSET_OK, 0);
        MakeRunSet(false);
        rt_err_clr(ERR_CODE_SET_PUB, 0);
    }
    else
    {
        strcpy(m_WarningStr, "公共定值保存失败");
        soe_record_opt(EV_PUBSET_FAIL, 0);
    }
#endif
    return M_JUMP0;
}

int mmd_SavePubPassword2(int value)
{
#ifndef PASSWORD_2_INVALID
    return M_JUMP1;
#endif
    return mmd_SavePubSet(0);
}

int mmd_SaveBhPassword2(int value)
{
#ifndef PASSWORD_2_INVALID
    return M_JUMP1;
#endif
    return mmd_SaveBhSet(0);
}

int mmd_SaveParaPassword2(int value)
{
#ifndef PASSWORD_2_INVALID
    return M_JUMP1;
#endif
    return mmd_SaveParaSet(0);
}

int mmd_SaveAzPassword2(int value)
{
#ifndef PASSWORD_2_INVALID
    return M_JUMP1;
#endif
    return mmd_SaveAzSet(0);
}

int mmd_RenewBhSet(void)
{
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    DATA_MENU_DEF *pext = &g_tExtraMenu;
    int i;
    int bgn;
    bgn = g_set_disp.bgn[pt->sFocusIndex];
    pext->sTotalNum = 0; // 总的动态菜单数
    for (i = 0; i < g_set_disp.screennum[pt->sFocusIndex]; i++)
    {
        mmd_GetSet(bgn + i, &g_tDataMenu1.tDataFields[i], &tSwSetTable[0], m_SetBuf);
    }
    pt->sScreenNum = g_set_disp.screennum[pt->sFocusIndex];
    pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
    pext->sScreenNum = pext->sTotalNum;
    return M_OK;
}

int mmd_RenewBhSetGroup(void)
{
    mmd_RenewDataMenu(&g_tDataMenu2);
    return M_OK;
}

int mmd_backBhSet(int value)
{
    mmd_InitBhSetGroup(-1);
    g_tDataMenu2.sFocusIndex = SetGroupIndex;
    mmi_FormsInit(44, 1); //  更新最后修改的数据
    mmd_RenewBhSetGroup();
    return M_OK;
}

int mmd_InitBhSetGroup(int value)
{
    int i, num = 0;
    for (i = 0; i < GROUP_NUM; i++)
    {
        if (SetGroups[i].group == SETGROUP_TYPE_BH && (m_setgroup[i] > 0))
        {
            int j;
            bool bYB;
            bYB = mmd_checkset_yb(i);
            for (j = 0; j < SW_SET_NUMBER; j++)
            {
                if ((bSwSetMenuShow[j] > 0) && (tSwSetTable[j].group == i) && (tSwSetTable[j].wType != SETTYPE_LABEL) && bYB)
                {
                    set_show_group[num++] = i;
                    break;
                }
            }
        }
    }
    if (num == 0)
    {
        strcpy(m_WarningStr, "保护定值未配置");
        return M_JUMP2;
    }
    mmd_initDataMenu(&g_tDataMenu2, num, mmd_RenewBhSetGroup, mmd_GetSetGroupName, 44, 1);

    /*读定值*/
    if (!ReadPara((void *)m_SetBuf, EEP_SET_ADDR + SETSIZE * (m_runsection), SW_SET_NUMBER, &tSwSetTable[0]))
    {
        if (value == -1)
        {
            GetDefPara((void *)m_SetBuf, SW_SET_NUMBER, &tSwSetTable[0]);
        }
        else
        {
            strcpy(m_WarningStr, "定值读取错误，请整定");
            return M_JUMP3;
        }
    }
    mmd_ChangeSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf);
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_InitSetSolid
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：初始化定值整定的显示
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_InitBhSet(int value)
{
    int num = SW_SET_NUMBER;
    int screennum;
    int i;
    m_AllSection = 0;
    g_set_disp.num = 0;
    num = mmd_GetshowSetNum(&tSwSetTable[0], SW_SET_NUMBER, set_show_group[value]);
    SetGroupIndex = value;
    screennum = mmi_GetScreenNum(45, 1); // 取当前屏幕最大显示数目
    bSetChange = true;
    mmd_analyse(&tSwSetTable[0], screennum);
    {
        DATA_MENU_DEF *pt = &g_tDataMenu1;
        DATA_MENU_DEF *pext = &g_tExtraMenu;
        pext->sTotalNum = 0;
        for (i = 0; i < g_set_disp.screennum[0]; i++)
        {
            mmd_GetSet(i, &g_tDataMenu1.tDataFields[i], &tSwSetTable[0], m_SetBuf);
        }
        m_ScreenNum = num;
        pt->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pt->sTotalNum = num; // 总的动态菜单数
        pt->sScreenNum = g_set_disp.screennum[0];
        pt->GetPrevFuncAddr = mmd_RenewBhSet; // 44
        pt->GetNextFuncAddr = mmd_RenewBhSet; // 44

        pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pext->sScreenNum = pext->sTotalNum;
        pext->GetPrevFuncAddr = NULL; // 44
        pext->GetNextFuncAddr = NULL; // 44
        m_CurrentScreen = 1;
    }
    return M_JUMP0;
}

/**************************************************************************
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SetBhKey(int key)
{
    if (key == HA_KEY_UP && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_ADD;
    if (key == HA_KEY_DOWN && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_SUB;

    if (key == HA_KEY_ADD || key == HA_KEY_SUB) // +键增加列表
    {
        if (!g_bModify)
            return M_ERROR; // 只在修改状态下执行此函数
        if (mmd_ChangeList(&tSwSetTable[0], key, m_SetBuf))
        {
            mmd_RenewBhSet(); // 刷新修改后的值
            return M_OK;
        }
    }
    return M_ERROR;
}

int mmd_SaveBhSet(int value)
{

    if (mmd_CheckPassword2() == false)
    {
        return M_JUMP2;
    }
    mmd_ReChangeSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf);

    if (!mmd_CheckSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf))
    {
        mmd_ChangeSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf);
        return M_JUMP3;
    }
    // if(SavePara((void *)m_SetBuf,EEP_SET_ADDR+(m_runsection)*SETSIZE,SW_SET_NUMBER,&tSwSetTable[0]))
    if (SavePara((void *)m_SetBuf, EEP_SET_ADDR + (m_selsection)*SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
    {
        strcpy(m_WarningStr, "定值保存成功");
        soe_record_opt(EV_SET_OK, 0);
        MakeRunSet(false);
        rt_err_clr(ERR_CODE_SET, 0);
    }
    else
    {
        strcpy(m_WarningStr, "定值保存失败");
        soe_record_opt(EV_SET_FAIL, 0);
    }
    return M_JUMP0;
}

int mmd_RenewAzSet(void)
{
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    DATA_MENU_DEF *pext = &g_tExtraMenu;
    int i;
    int bgn;
    bgn = g_set_disp.bgn[pt->sFocusIndex];
    pext->sTotalNum = 0; // 总的动态菜单数
    for (i = 0; i < g_set_disp.screennum[pt->sFocusIndex]; i++)
    {
        mmd_GetSet(bgn + i, &g_tDataMenu1.tDataFields[i], &tSwSetTable[0], m_SetBuf);
    }
    pt->sScreenNum = g_set_disp.screennum[pt->sFocusIndex];
    pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
    pext->sScreenNum = pext->sTotalNum;
    return M_OK;
}

int mmd_RenewAzSetGroup(void)
{
    mmd_RenewDataMenu(&g_tDataMenu2);
    return M_OK;
}

int mmd_InitAzSetGroup(int value)
{

    int i, num = 0;
    unsigned char menuno = 0; //**
    int bYB1 = 1;

    menuno = g_tScreen.cActiveMenuNo;

    switch (menuno)
    {
    case 150:
    case 64:
    case 66:
        bYB1 = 1;
        break;
    case 96:
    case 90:
        bYB1 = 0;
        break;
    }
    for (i = 0; i < GROUP_NUM; i++)
    {
#ifdef GD_AREA_ECZD_2020
        if ((SetGroups[i].group == SETGROUP_TYPE_AZ || SetGroups[i].group == SETGROUP_TYPE_JL) && (m_setgroup[i] > 0))
#else
        if (SetGroups[i].group == SETGROUP_TYPE_AZ && (m_setgroup[i] > 0))
#endif
        {
            int j;
            bool bYB;
            if (bYB1)
            {
                bYB = mmd_checkset_yb(i);
            }
            else
            {
                bYB = true; // 查看定值时全部定值要显示出来
            }
            for (j = 0; j < SW_SET_NUMBER; j++)
            {
                if ((bSwSetMenuShow[j] > 0) && (tSwSetTable[j].group == i) && (tSwSetTable[j].wType != SETTYPE_LABEL) && bYB)
                {
                    set_show_group[num++] = i;
                    break;
                }
            }
        }
    }
    if (num == 0)
    {
        strcpy(m_WarningStr, "安自定值未配置");
        return M_JUMP2;
    }

    if (bYB1)
    {
        mmd_initDataMenu(&g_tDataMenu2, num, mmd_RenewAzSetGroup, mmd_GetSetGroupName, 62, 1);
    }
    else
    {
        mmd_initDataMenu(&g_tDataMenu2, num, mmd_RenewAzSetGroup, mmd_GetSetGroupName, 95, 1);
    }

    /*读定值*/
    // if(!ReadPara((void*)m_SetBuf,EEP_SET_ADDR+SETSIZE*(m_runsection),SW_SET_NUMBER,&tSwSetTable[0]))
    if (!ReadPara((void *)m_SetBuf, EEP_SET_ADDR + SETSIZE * (m_selsection), SW_SET_NUMBER, &tSwSetTable[0]))
    {
        if (value == -1)
        {
            GetDefPara((void *)m_SetBuf, SW_SET_NUMBER, &tSwSetTable[0]);
        }
        else
        {
            strcpy(m_WarningStr, "定值读取错误，请整定");
            return M_JUMP3;
        }
    }
    mmd_ChangeSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf);
    return M_JUMP0;
}

int mmd_backAzSet(int value)
{
    mmd_InitAzSetGroup(-1);
    g_tDataMenu2.sFocusIndex = SetGroupIndex;
    mmi_FormsInit(62, 1); //  更新最后修改的数据
    mmd_RenewAzSetGroup();
    return M_OK;
}

int mmd_backPubSetPoll(int key)
{
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        mmd_InitPubSetGroup(-1);
        g_tDataMenu2.sFocusIndex = SetGroupIndex;
        mmi_FormsInit(91, 1); //  更新最后修改的数据
        mmd_RenewPubSetGroup();
    }
    return M_OK;
}
int mmd_backBhSetPoll(int key)
{
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        mmd_InitBhSetGroup(-1);
        g_tDataMenu2.sFocusIndex = SetGroupIndex;
        mmi_FormsInit(93, 1); //  更新最后修改的数据
        mmd_RenewBhSetGroup();
    }
    return M_OK;
}
int mmd_backAzSetPoll(int key)
{
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //	老版本按键6键，左键为取消键
    {
        mmd_InitAzSetGroup(-1);
        g_tDataMenu2.sFocusIndex = SetGroupIndex;
        mmi_FormsInit(95, 1); //  更新最后修改的数据
        mmd_RenewAzSetGroup();
    }
    return M_OK;
}

int mmd_SetGroupInit(int value)
{
    bool bret;
    bret = ReadEppData(EEP_SETGROUP_ADDR, m_setgroup, GROUP_NUM);
    if (!bret)
    {
        GetDefSetGroup(m_setgroup);
    }
    return M_OK;
}

int mmd_CheckSecValue(void)
{
    int selsec;

    selsec = atoi(m_selsec_char);
    if (selsec > m_sectionnum || selsec < 0)
    {
        m_selsection = 0;
        strcpy(m_selsec_char, "00");
        strcpy(m_WarningStr, "输入区号错误!");
        return M_JUMP3;
    }
    m_selsection = selsec;
    rt_printf("%s:Current Section = %d\r\n", __func__, m_selsection);
    mmd_SetGroupInit(0);
    return M_JUMP0;
}

int mmd_CheckCopyPassword(int value)
{
    u8 passstr[10];
#ifdef PASSWORD_4_STR
    strcpy(passstr, PASS_WORD_STR_4);
#else
    strcpy(passstr, PASS_WORD_STR);
#endif
    if ((strcmp(m_strPassword, tRunPara.wPasswordstr) != 0) && (strcmp(m_strPassword, passstr) != 0))
    {
        m_Password = 0;
        mmi_zero_passwordstr();
        strcpy(m_WarningStr, "输入密码错误!");
        return M_JUMP3;
    }
    return M_JUMP0;
}
int mmd_GetshowAzSetNum(const TSETTABLE *pSet, int bgn, int end, u8 group)
{
    int i;
    // 152 86
    unsigned char menuno = 0; //**
    int bYB1 = 1;
    rt_printf("g_tScreen.cActiveMenuNo =%d,g_tScreen.cActiveFieldNo =%d\r\n", g_tScreen.cActiveMenuNo, g_tScreen.cActiveFieldNo);

    menuno = g_tScreen.cActiveMenuNo;

    switch (menuno)
    {
    case 152:
    case 192:
    case 62:
    case 202:
    case 172:
    case 162:

        bYB1 = 1;
        break;
    case 86:
    case 79:
    case 88:
    case 95:
    case 97:
    case 93:
        bYB1 = 0;
        break;
    }
    for (i = bgn; i <= end; i++)
    {
        if (pSet[i].wType != SETTYPE_LABEL)
        {
            bool bYB_set;
            bool bmenu_set;
            bmenu_set = mmd_checkset_menucfg(pSet, i, group);
            if (bYB1)
            {
                bYB_set = mmd_checkset_yb(pSet[i].group);
            }
            else
            {
                bYB_set = true;
            }

            if ((m_setgroup[pSet[i].group]) && bYB_set && bmenu_set) // 定值分类组为0 或显示定制为1
            {
                g_set_disp.no[g_set_disp.num] = i;
                g_set_disp.num++;
            }
        }
    }
    return g_set_disp.num;
}

/**************************************************************************
函数名称：mmd_InitSetSolid
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：初始化定值整定的显示
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_InitAzSet(int value)
{
    int num = SW_SET_NUMBER;
    int screennum;
    int i;
    m_AllSection = 0;
    g_set_disp.num = 0;
    num = mmd_GetshowAzSetNum(&tSwSetTable[0], SET_LABLE_TQ, SET_LABLE_FATT - 1, set_show_group[value]);
    SetGroupIndex = value;
    screennum = mmi_GetScreenNum(63, 1); // 取当前屏幕最大显示数目
    bSetChange = true;
    mmd_analyse(&tSwSetTable[0], screennum);
    {
        DATA_MENU_DEF *pt = &g_tDataMenu1;
        DATA_MENU_DEF *pext = &g_tExtraMenu;
        pext->sTotalNum = 0;
        for (i = 0; i < g_set_disp.screennum[0]; i++)
        {
            mmd_GetSet(i, &g_tDataMenu1.tDataFields[i], &tSwSetTable[0], m_SetBuf);
        }
        m_ScreenNum = num;
        pt->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pt->sTotalNum = num; // 总的动态菜单数
        pt->sScreenNum = g_set_disp.screennum[0];
        pt->GetPrevFuncAddr = mmd_RenewAzSet; // 44
        pt->GetNextFuncAddr = mmd_RenewAzSet; // 44

        pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pext->sScreenNum = pext->sTotalNum;
        pext->GetPrevFuncAddr = NULL; // 44
        pext->GetNextFuncAddr = NULL; // 44
        m_CurrentScreen = 1;
    }
    return M_JUMP0;
}

/**************************************************************************
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SetAzKey(int key)
{
    if (key == HA_KEY_UP && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_ADD;
    if (key == HA_KEY_DOWN && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_SUB;

    if (key == HA_KEY_ADD || key == HA_KEY_SUB) // +键增加列表
    {
        if (!g_bModify)
            return M_ERROR; // 只在修改状态下执行此函数
        if (mmd_ChangeList(&tSwSetTable[0], key, m_SetBuf))
        {
            mmd_RenewAzSet(); // 刷新修改后的值
            return M_OK;
        }
    }
    return M_ERROR;
}

int mmd_SaveAzSet(int value)
{

    if (mmd_CheckPassword2() == false)
    {
        return M_JUMP2;
    }

    mmd_ReChangeSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf);

    if (!mmd_CheckSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf))
    {
        mmd_ChangeSet(&tSwSetTable[0], SW_SET_NUMBER, m_SetBuf);
        return M_JUMP3;
    }
    // if(SavePara((void *)m_SetBuf,EEP_SET_ADDR+(m_runsection)*SETSIZE,SW_SET_NUMBER,&tSwSetTable[0]))
    if (SavePara((void *)m_SetBuf, EEP_SET_ADDR + (m_selsection)*SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
    {
        strcpy(m_WarningStr, "定值保存成功");
        soe_record_opt(EV_SET_OK, 0);
        MakeRunSet(false);
        rt_err_clr(ERR_CODE_SET, 0);
    }
    else
    {
        strcpy(m_WarningStr, "定值保存失败");
        soe_record_opt(EV_SET_FAIL, 0);
    }
    return M_JUMP0;
}

int mmd_ChangeYBSet(const TSETTABLE *pSet, int num, SET_VALUE *setbuf) // ext为不需显示的定值组
{
    int i;
    int sw = 0;
    for (i = 0; i < num; i++)
    {
        if (mmd_IsIntegType(pSet[i].wType))
        {
            float ff = setbuf[i].ff;
            setbuf[i].tt = (uint32_t)ff;
        }
        if (pSet[i].wType != SETTYPE_LABEL)
        {
            // xj 2019.10.21
            if (pSet[i].group == GROUP_SET_YB_GN && (g_tRelay[sw].run_stu.cgbhtt == 1 || g_tRelay[sw].run_stu.fatt || g_tRelay[sw].run_stu.fa_g_tt) && (bPubSetMenuShow[i] > 0)) // 定值分类组为0 或显示定制为1
            {
                g_set_disp.no[g_set_disp.num] = i;
                g_set_disp.num++;
            }
        }
    }
    return g_set_disp.num;
}

/**************************************************************************
函数名称：mmd_RenewYBSet
函数版本：1.00
作者：
创建日期：2008.9.11
函数功能说明：刷新定值显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_RenewYBSet(void)
{
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    int i;
    int index = (pt->sFocusIndex / pt->sScreenNum) * pt->sScreenNum;
    for (i = 0; i < pt->sScreenNum; i++)
    {
        mmd_GetSet(index, &g_tDataMenu1.tDataFields[i], &tPubSetTable[0], m_SetBuf);
        if (++index > pt->sTotalNum - 1)
            break; // 最后一个CPU
    }
    m_CurrentScreen = (pt->sFocusIndex / pt->sScreenNum) + 1;
    return M_OK;
}

/**************************************************************************
函数名称：mmd_InitSetSolid
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：初始化定值整定的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_InitYBSet(int value)
{
    int num = PUB_SET_NUMBER;
    m_AllSection = 0;
    g_set_disp.num = 0;
    if (value >= 0)
    {
        /*读取压板定值*/
        if (!ReadPara((void *)m_SetBuf, EEP_PUB_ADDR + (PUB_SETSIZE * m_runsection), PUB_SET_NUMBER, &tPubSetTable[0]))
        {
            return M_JUMP3;
        }
    }

    num = mmd_ChangeYBSet(&tPubSetTable[0], PUB_SET_NUMBER, &m_SetBuf[0]);
    if (num == 0)
    {
        strcpy(m_WarningStr, "无可整定定值!");
        return M_JUMP2;
    }

    bSetChange = true;
    {
        DATA_MENU_DEF *pt = &g_tDataMenu1;
        mmd_GetSet(0, &g_tDataMenu1.tDataFields[0], &tPubSetTable[0], m_SetBuf);
        m_ScreenNum = num;
        pt->sFocusIndex = 0;                  // 第一个显示的动态菜单的索引
        pt->sTotalNum = num;                  // 总的动态菜单数
        pt->GetPrevFuncAddr = mmd_RenewYBSet; // 44
        pt->GetNextFuncAddr = mmd_RenewYBSet; // 44
        m_CurrentScreen = 1;
    }
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_SetKey
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：列表项选择
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SetYBKey(int key)
{
    if (key == HA_KEY_UP && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_ADD;
    if (key == HA_KEY_DOWN && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_SUB;

    if (key == HA_KEY_ADD || key == HA_KEY_SUB) // +键增加列表
    {
        if (!g_bModify)
            return M_ERROR; // 只在修改状态下执行此函数
        if (mmd_ChangeList(&tPubSetTable[0], key, m_SetBuf))
        {
            mmd_RenewYBSet(); // 刷新修改后的值
            return M_OK;
        }
    }
    return M_ERROR;
}

int mmd_SaveYBSet(int value)
{
    mmd_ReChangeSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf);
    if (!mmd_CheckSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf))
    {
        mmd_ChangeSet(&tPubSetTable[0], PUB_SET_NUMBER, m_SetBuf);
        return M_JUMP3;
    }

    if (SavePara((void *)m_SetBuf, EEP_PUB_ADDR + (PUB_SETSIZE * m_runsection), PUB_SET_NUMBER, &tPubSetTable[0]))
    {
        strcpy(m_WarningStr, "压板保存成功");
        soe_record_opt(EV_PUBSET_OK, 0);
        MakeRunSet(false);
        rt_err_clr(ERR_CODE_SET_PUB, 0);
    }
    else
    {
        strcpy(m_WarningStr, "压板保存失败");
        soe_record_opt(EV_PUBSET_FAIL, 0);
    }
    return M_JUMP0; // 弹出定值固化菜单，需选择输入区号
}

int mmd_GetDefaultYBSet(int value)
{
    GetDefPara((void *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]);
    mmd_InitYBSet(-1);
    return M_OK;
}

/**************************************************************************
函数名称：mmd_CheckDzPassword
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：检查定值密码，
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_CheckDzPassword(int value)
{
    bool bret;
    // if(m_Password!=tRunPara.wPassword&&m_Password!=PASS_WORD)
    u8 passstr[10];

#ifdef PASSWORD_4_STR
    strcpy(passstr, PASS_WORD_STR_4);
#else
    strcpy(passstr, PASS_WORD_STR);
#endif
    if ((strcmp(m_strPassword, tRunPara.wPasswordstr) != 0) && (strcmp(m_strPassword, passstr) != 0))
    {
        m_Password = 0;
        mmi_zero_passwordstr();
        strcpy(m_WarningStr, "输入密码错误!");
        return M_JUMP3;
    }
    m_Password = 0;
    mmi_zero_passwordstr();
    bret = ReadEppData(EEP_SETGROUP_ADDR, m_setgroup, GROUP_NUM);
    if (!bret)
    {
        GetDefSetGroup(m_setgroup);
    }
    return M_JUMP0;
}
/**************************************************************************
函数名称：mmd_CheckXTPassword
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：检查系统维护密码
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_CheckXTPassword(int value) // 系统维护密码
{
    // if(m_Password==INTER_PASSWORD)  // 特殊密码，进特内部设置菜单
    u8 passstr[10];

#ifdef PASSWORD_4_STR
    strcpy(passstr, INTER_PASSWORD_STR_4);
#else
    strcpy(passstr, INTER_PASSWORD_STR);
#endif
    if (strcmp(m_strPassword, passstr) == 0)
    {
        m_Password = 0;
        mmi_zero_passwordstr();
        return M_JUMP1;
    }

#ifdef PASSWORD_4_STR
    strcpy(passstr, PASS_WORD_STR_4);
#else
    strcpy(passstr, PASS_WORD_STR);
#endif
    // if(m_Password!=tRunPara.wPassword&&m_Password!=PASS_WORD)
    if ((strcmp(m_strPassword, tRunPara.wPasswordstr) != 0) && (strcmp(m_strPassword, passstr) != 0))
    {
        m_Password = 0;
        mmi_zero_passwordstr();
        strcpy(m_WarningStr, "输入密码错误!");
        return M_JUMP3;
    }
    m_Password = 0;
    mmi_zero_passwordstr();
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_CheckCopyPassword
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：检查定值复制密码,并取有效定值区及全部定值区到相应的buf中
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_CheckParaPassword(int value)
{
    bool bret;
    u8 passstr[10];
    // if(m_Password!=tRunPara.wPassword&&m_Password!=PASS_WORD)
#ifdef PASSWORD_4_STR
    strcpy(passstr, INTER_PASSWORD_STR_4);
#else
    strcpy(passstr, INTER_PASSWORD_STR);
#endif
    if ((strcmp(m_strPassword, tRunPara.wPasswordstr) != 0) && (strcmp(m_strPassword, passstr) != 0))
    {
        m_Password = 0;
        mmi_zero_passwordstr();
        strcpy(m_WarningStr, "输入密码错误!");
        return M_JUMP3;
    }
    m_Password = 0;
    mmi_zero_passwordstr();
    bret = ReadEppData(EEP_SETGROUP_ADDR, m_setgroup, GROUP_NUM);
    if (!bret)
    {
        GetDefSetGroup(m_setgroup);
    }
    return mmd_InitParaSetGroup(0);
}

/**************************************************************************
函数名称：mmd_RenewEquipPara
函数版本：1.00
作者：
创建日期：2008.9.23
函数功能说明： 刷新装置参数的显示
输入参数：
输出参数：
返回值：
更新信息：
更新日志1
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

// 下面是参数修改

int mmd_RenewParaSet(void)
{
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    DATA_MENU_DEF *pext = &g_tExtraMenu;
    int i;
    int bgn;
    bgn = g_set_disp.bgn[pt->sFocusIndex];
    pext->sTotalNum = 0; // 总的动态菜单数
    for (i = 0; i < g_set_disp.screennum[pt->sFocusIndex]; i++)
    {
        mmd_GetSet(bgn + i, &g_tDataMenu1.tDataFields[i], &tEquipParaTable[0], m_SetBuf);
    }
    pt->sScreenNum = g_set_disp.screennum[pt->sFocusIndex];
    pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
    pext->sScreenNum = pext->sTotalNum;
    return M_OK;
}

int mmd_RenewParaSetGroup(void)
{
    mmd_RenewDataMenu(&g_tDataMenu2);
    return M_OK;
}

int mmd_backParaSet(int value)
{

    mmd_InitParaSetGroup(-1);
    g_tDataMenu2.sFocusIndex = SetGroupIndex;
    mmi_FormsInit(70, 1); //  更新最后修改的数据
    mmd_RenewParaSetGroup();
    return M_OK;
}

int mmd_InitParaSetGroup(int value)
{
    int i, num = 0;
    for (i = 0; i < GROUP_NUM; i++)
    {
        if (SetGroups[i].group == SETGROUP_TYPE_PARA && (m_setgroup[i] > 0))
        {
            int j;
            for (j = 0; j < EQUIP_PARA_NUMBER; j++)
            {
                if ((bParaSetMenuShow[j] > 0) && (tEquipParaTable[j].group == i) && (tEquipParaTable[j].wType != SETTYPE_LABEL))
                    if (tEquipParaTable[j].group == i)
                    {
                        set_show_group[num++] = i;
                        break;
                    }
            }
        }
    }
    if (num == 0)
    {
        strcpy(m_WarningStr, "装置参数未配置");
        return M_JUMP3;
    }
    mmd_initDataMenu(&g_tDataMenu2, num, mmd_RenewParaSetGroup, mmd_GetSetGroupName, 70, 1);
    if (!ReadPara((void *)m_SetBuf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0]))
    {
        if (value == -1)
        {
            GetDefPara((float *)m_SetBuf, EQUIP_PARA_NUMBER, &tEquipParaTable[0]);
        }
        else
        {
            return M_JUMP2;
        }
    }
    mmd_ChangeSet(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf);
    return M_JUMP0;
}

int mmd_SaveParaSet(int value)
{
    if (mmd_CheckPassword2() == false)
    {
        return M_JUMP2;
    }

    mmd_ReChangeSet(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf);

    if (!mmd_CheckSet(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf))
    {
        mmd_ChangeSet(&tEquipParaTable[0], EQUIP_PARA_NUMBER, m_SetBuf);
        return M_JUMP3;
    }

    if (SavePara((void *)m_SetBuf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0]))
    {
        strcpy(m_WarningStr, "参数保存成功");
        soe_record_opt(EV_EQUPARA_OK, 0);
        MakeRunPara(false, false);
        rt_err_clr(ERR_CODE_EQU_PARA, 0);
    }
    else
    {
        strcpy(m_WarningStr, "参数保存失败");
        soe_record_opt(EV_EQUPARA_FAIL, 0);
    }
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_InitSetSolid
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：初始化定值整定的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_InitParaSet(int value)
{
    int num = EQUIP_PARA_NUMBER;
    int screennum;
    int i;
    m_AllSection = 0;
    g_set_disp.num = 0;
    num = mmd_GetshowSetNum(&tEquipParaTable[0], EQUIP_PARA_NUMBER, set_show_group[value]);
    SetGroupIndex = value;
    screennum = mmi_GetScreenNum(71, 1); // 取当前屏幕最大显示数目
    bSetChange = true;
    mmd_analyse(&tEquipParaTable[0], screennum);
    {
        DATA_MENU_DEF *pt = &g_tDataMenu1;
        DATA_MENU_DEF *pext = &g_tExtraMenu;
        pext->sTotalNum = 0;
        for (i = 0; i < g_set_disp.screennum[0]; i++)
        {
            mmd_GetSet(i, &g_tDataMenu1.tDataFields[i], &tEquipParaTable[0], m_SetBuf);
        }
        m_ScreenNum = num;
        pt->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pt->sTotalNum = num; // 总的动态菜单数
        pt->sScreenNum = g_set_disp.screennum[0];
        pt->GetPrevFuncAddr = mmd_RenewParaSet; // 44
        pt->GetNextFuncAddr = mmd_RenewParaSet; // 44

        pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pext->sScreenNum = pext->sTotalNum;
        pext->GetPrevFuncAddr = NULL; // 44
        pext->GetNextFuncAddr = NULL; // 44

        m_CurrentScreen = 1;
    }
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_SetKey
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：列表项选择
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SetParaKey(int key)
{
    if (key == HA_KEY_UP && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_ADD;
    if (key == HA_KEY_DOWN && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_SUB;

    if (key == HA_KEY_ADD || key == HA_KEY_SUB) // +键增加列表
    {
        if (!g_bModify)
            return M_ERROR; // 只在修改状态下执行此函数
        if (mmd_ChangeList(&tEquipParaTable[0], key, m_SetBuf))
        {
            mmd_RenewParaSet(); // 刷新修改后的值
            return M_OK;
        }
    }
    return M_ERROR;
}

/**************************************************************************
函数名称：mmd_GetEventShow
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：事件及记录显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

EVENT_SHOW m_tEvent;  // 查询事件的结构
EVENT_SHOW m_tAutoEv; // 自动弹出事件的结构

int mmd_splitstr(unsigned char *str, int lcdsize) // 根据lcd宽度，分析一行可显示的字符串
{
    int i;
    int len = strlen(str);
    if (len <= lcdsize)
        return 0; // 一行可以显示
    for (i = 0; i < len;)
    {
        if (str[i] > 0x80) // 是汉字
        {
            i += 2;
        }
        else
        {
            i++;
        }
        if (((i >= lcdsize - 1) && str[i] >= 0x80) || i >= lcdsize)
        {
            return i;
        }
    }
    return 0;
}

void mmd_GetEventShow(EVENT_SHOW *pe, bool bPDA)
{
    EVENT_STRUCT *er = &pe->tEv;
    char tmpstr[64], tmpstr1[64];
    char namestr[64];
    char valstr[3][20];
    BYTE paranum = 0;
    int lineoff;
    int i;
    struct rtc_time_t tTime;
    u8 ev_type;
    timespec_to_rtc(er->ts, &tTime, 1);

    pe->year = tTime.year;
    pe->month = tTime.month;
    pe->day = tTime.day;
    pe->hour = tTime.hour;
    pe->min = tTime.min;
    pe->sec = (tTime.ms / 1000);
    pe->ms = (tTime.ms % 1000);
    pe->sParaCur = 0;
    pe->sParaNum = 0;

    ev_type = er->ev_type & SOE_TYPE_MASK;

    if (ev_type == SOE_TYPE_EV || ev_type == SOE_TYPE_OPT) // 不是遥信变位
    {
        int i;
        const SOE_DEF *psoe;
        int ev_sw = 0;
        u16 code;

        if (er->ev_code >= EV_NUMBER)
        {
            sprintf(namestr, "错误代码:%d", er->ev_code);
            return;
        }
        else
        {
            strcpy(namestr, "");

            if (er->ev_code < EV_PUB_START)
            {
                code = er->ev_code % EV_SW_NUM;
                ev_sw = (er->ev_code / EV_SW_NUM) + 1;
            }
            else
            {
                code = er->ev_code - EV_SW_NUM * (SWITCH_NUM_MAX - 1);
                ev_sw = 0;
            }

#if SWITCH_NUM_MAX != 1
            {
                if ((ev_sw > 0) && (ev_sw < SWITCH_NUM_MAX))
                {
                    sprintf(namestr, "开关%d", ev_sw);
                }
            }
#endif
            psoe = &tAllSOE[code];
            strcat(namestr, psoe->strName);        // soe 名称
            if (er->ev_code == EV_SET_CHANGE_PARA) // 定值修改soe，特殊处理
            {
                u16 type = (u16)(er->ev_arg[0] >> 16);
                u16 soeno = (u16)er->ev_arg[0];
                const TSETTABLE *pTable;
                SET_VALUE ft;
                if (type == 1) // 公共参数
                {
                    pTable = &tPubSetTable[soeno];
                }
                else if (type == 2) // 开关参数
                {
                    pTable = &tSwSetTable[soeno];
                }
                else if (type == 3) // 装置参数
                {

                    pTable = &tEquipParaTable[soeno];
                }
                else
                {
                    pTable = &tCstSetTable[soeno];
                }
                sprintf(namestr, "%s(%s)", pTable->szName, SetGroups[pTable->group].item_name);
                switch (pTable->wType)
                {
                case SETTYPE_F:
                    ft.tt = er->ev_arg[1];
                    sprintf(tmpstr, "由:%.3f", ft.ff);
                    strcpy(valstr[paranum++], tmpstr);
                    ft.tt = er->ev_arg[2];
                    sprintf(tmpstr, "改:%.3f", ft.ff);
                    strcpy(valstr[paranum++], tmpstr);
                    break;
                case SETTYPE_UINT: // 16进制显示  控制字
                case SETTYPE_4INT: // 10进制显示  4位
                case SETTYPE_5INT: // 10进制显示  5位
                case SETTYPE_LINT: // 16进制显示  控制字
                    ft.tt = er->ev_arg[1];
                    sprintf(tmpstr, "由:%d", (u16)ft.tt);
                    strcpy(valstr[paranum++], tmpstr);
                    ft.tt = er->ev_arg[2];
                    sprintf(tmpstr, "改:%d", (u16)ft.tt);
                    strcpy(valstr[paranum++], tmpstr);
                    break;
                case SETTYPE_LIST: // 列表选择
                {
                    ft.tt = er->ev_arg[1];
                    sprintf(tmpstr, "由:%s", pTable->list[(u16)ft.tt].str);
                    strcpy(valstr[paranum++], tmpstr);
                    ft.tt = er->ev_arg[2];
                    sprintf(tmpstr, "改:%s", pTable->list[(u16)ft.tt].str);
                    strcpy(valstr[paranum++], tmpstr);
                }
                break;
                case SETTYPE_IP:
                {
                    u32 dat;
                    ft.tt = er->ev_arg[1];
                    dat = (u32)ft.tt;
                    sprintf(tmpstr, "由:%d.%d.%d.%d", (dat >> 24) & 0xFF, (dat >> 16) & 0xFF, (dat >> 8) & 0xFF, (dat >> 0) & 0xFF);
                    strcpy(valstr[paranum++], tmpstr);

                    ft.tt = er->ev_arg[2];
                    dat = (u32)ft.tt;
                    sprintf(tmpstr, "改:%d.%d.%d.%d", (dat >> 24) & 0xFF, (dat >> 16) & 0xFF, (dat >> 8) & 0xFF, (dat >> 0) & 0xFF);
                    strcpy(valstr[paranum++], tmpstr);
                }
                break;
                case SETTYPE_YMD:
                {
                    struct timespec ts;
                    struct rtc_time_t tTime;

                    memset(&ts, 0, sizeof(ts));
                    memset(&tTime, 0, sizeof(tTime));
                    ft.tt = er->ev_arg[1];
                    ts.tv_sec = (long)ft.tt;
                    timespec_to_rtc(ts, &tTime, 1);
                    sprintf(tmpstr, "由:%04d-%02d-%02d", 2000 + tTime.year, tTime.month, tTime.day);
                    strcpy(valstr[paranum++], tmpstr);
                    ft.tt = er->ev_arg[2];
                    ts.tv_sec = (long)ft.tt;
                    timespec_to_rtc(ts, &tTime, 1);
                    sprintf(tmpstr, "改:%04d-%02d-%02d", 2000 + tTime.year, tTime.month, tTime.day);
                    strcpy(valstr[paranum++], tmpstr);
                }
                break;
                case SETTYPE_HMS:
                {
                    struct timespec ts;
                    struct rtc_time_t tTime;
                    extern int timespec_to_rtchms(struct timespec ts, struct rtc_time_t * p_rtc, int is_round);

                    memset(&ts, 0, sizeof(ts));
                    memset(&tTime, 0, sizeof(tTime));
                    ft.tt = er->ev_arg[1];
                    ts.tv_sec = (long)ft.tt;
                    timespec_to_rtchms(ts, &tTime, 1);
                    sprintf(tmpstr, "由:%02d:%02d:%02d", tTime.hour, tTime.min, tTime.ms % 1000);
                    strcpy(valstr[paranum++], tmpstr);

                    memset(&ts, 0, sizeof(ts));
                    memset(&tTime, 0, sizeof(tTime));
                    ft.tt = er->ev_arg[2];
                    ts.tv_sec = (long)ft.tt;
                    timespec_to_rtchms(ts, &tTime, 1);
                    sprintf(tmpstr, "改:%02d:%02d:%02d", tTime.hour, tTime.min, tTime.ms % 1000);
                    strcpy(valstr[paranum++], tmpstr);
                }
                default:
                    break;
                }
            }
            else
            {
                if (er->ev_value) // 置1 ,产生，显示参数
                {
                    for (i = 0; i < 3; i++)
                    {
                        BYTE index = (psoe->Attrib[i] & 0x1f);
                        if (index)
                        {
                            switch ((psoe->Attrib[i] >> 5) & 0x07)
                            {
                            case 0: // 浮点数
                                FUC_Get_LongValue_String(er->ev_arg[i], tmpstr1);
                                sprintf((char *)tmpstr, "%s=%s%s", ev_para[index].strName, tmpstr1, g_unit[ev_para[index].byNo].name);
                                break;
                            case 1: // 整型值
                                sprintf(tmpstr, "%s=%d%s", ev_para[index].strName, er->ev_arg[i], g_unit[ev_para[index].byNo].name);
                                break;
                            case 2: // 遥控操作
                            {
                                BYTE sw = (er->ev_arg[0] >> 8) & 0xff; // 开关号
                                BYTE no = (er->ev_arg[0] >> 0) & 0xff; // 序号
                                char *ykowner;
                                ykowner = get_yk_owner((er->ev_arg[0] >> 16) & 0xff);
                                if (i == 0)
                                {
                                    sprintf(tmpstr, "通道:%s", ykowner);
                                }
                                else if (i == 1)
                                {
                                    // tmpstr[0]=0;
                                    /*if(sw==0)
                                    {
                                        sprintf(tmpstr,"公共开出%d",no);
                                    }
                                    else
                                    {
                                        #if SWITCH_NUM_MAX != 1
                                            sprintf(tmpstr,"开关%d开出%d",sw,no);
                                        #else
                                            sprintf(tmpstr,"%s",g_equ_config_do[no].name);
                                        #endif
                                    }*/
                                    // if(no==0)
                                    //{
                                    //   tmpstr[0]=0;
                                    // }
                                    // else
                                    {
                                        if (sw == 0)
                                        {
                                            sprintf(tmpstr, "%s", g_pub_do_name[no - 1]);
                                        }
                                        else
                                        {
#if SWITCH_NUM_MAX != 1
                                            sprintf(tmpstr, "开关%d%s", sw, g_sw_do_name[no - 1]);
#else
                                            sprintf(tmpstr, "%s", g_sw_do_name[no - 1]);
#endif
                                        }
                                    }
                                }
                            }
                            break;
                            case 3: // 压板操作
                            {
                                strcat(namestr, " 投入");
                                strcpy(tmpstr, "");
                            }
                            break;

                            default:
                                strcpy(tmpstr, "参数错误");
                                break;
                            }
                            strcpy(valstr[paranum++], tmpstr);
                        }
                    }
                }
                else // 置 0，显示返回值
                {
                    strcat(namestr, ev_back[(psoe->soe_def & SOE_TYPE_QUIT)]);
                }
            }
        }
    }
    // 遥信变位记录
    else if (ev_type == SOE_TYPE_YX)
    {
        u8 solt = (u8)(er->ev_code >> 8); // 板卡号
        u8 dino = (u8)(er->ev_code);      // 遥信号

        // 第三行
        // 填写事件名称

#if SWITCH_NUM_MAX == 1
        sprintf(namestr, "%s:", equ_di_name(solt, dino)); // 板卡xx开入xx变位
#else
        sprintf(namestr, "板卡%d开入%d(%s):", solt, dino + 1, equ_di_name(solt, dino)); // 板卡xx开入xx变位
#endif

        if (soe_ev_is_on(er)) // 置1 ,产生，显示参数
        {
            strcpy(tmpstr, SOE_YX_H);
        }
        else
        {
            strcpy(tmpstr, SOE_YX_F);
        }
        strcat(namestr, tmpstr);
    }

    else if (ev_type == SOE_TYPE_LNK)
    {
        u32 cp_s = er->ev_arg[2]; // 通道号+地址

        sprintf(namestr, "通道%d地址%d(点号%04x:%04x)变位", (u8)((cp_s >> 21) & 0x0f), (u8)((cp_s >> 16) & 0x1f), er->ev_code, (cp_s) & 0xffff);

        if (soe_ev_is_on(er)) // 置1 ,产生，显示参数
        {
            strcpy(tmpstr, SOE_YX_H);
        }
        else
        {
            strcpy(tmpstr, SOE_YX_F);
        }
        strcat(namestr, tmpstr);
    }
    // 双点变位记录
    else if (ev_type == SOE_TYPE_DPI)
    {
        if (er->ev_value == SW_DI_TYPE_ON)
        {
            strcpy(tmpstr, "值=2");
        }
        else if (er->ev_value == SW_DI_TYPE_OFF)
        {
            strcpy(tmpstr, "值=1");
        }
        else
        {
            sprintf(tmpstr, "异常(值=%d)", er->ev_value);
        }

        sprintf(namestr, "双点%02d(点号=0x%04x): %s", er->ev_code, g_di_db_table[er->ev_code].cp, tmpstr);
    }
    // PLC变位记录
    else if (ev_type == SOE_TYPE_PLC)
    {
        sprintf(namestr, "PLC(点号=%04x): %d", g_plc[er->ev_code].cp, er->ev_value);
    }
    else
    {
        sprintf(namestr, "未知类型:%d", er->ev_code);
    }

    for (i = 0; i < 5; i++)
    {
        sprintf(pe->str[i], "%-20.20s", "");
    }

    sprintf(pe->namestr, "%-20.20s", "");
    sprintf(pe->valuestr, "%-20.20s", "");

#if LCD_SIZE == 128 //  128*64液晶
    lineoff = mmd_splitstr(namestr, 16);
    if (lineoff == 0)
    {
        sprintf(pe->namestr, "%-16.16s", namestr);
        for (i = 0; i < paranum; i++)
        {
            sprintf(pe->str[i], "%-15.15s", valstr[i]);
            if (paranum > 1)
            {
                strcat(pe->str[i], "+");
            }
        }
        if (paranum > 0)
        {
            strcpy(pe->valuestr, pe->str[0]);
        }
    }
    else
    {
        sprintf(pe->valuestr, "%-15.15s", &namestr[lineoff]);
        namestr[lineoff] = '\0';
        sprintf(pe->namestr, "%-16.16s", namestr);
        if (paranum > 0)
        {
            strcat(pe->valuestr, "+");
        }
        for (i = 0; i < paranum; i++)
        {
            sprintf(pe->str[i], "%-15.15s+", valstr[i]);
        }
    }
#else
    lineoff = mmd_splitstr(namestr, 20);
    if (lineoff == 0)
    {
        sprintf(pe->str[0], "%-20.20s", namestr);
        for (i = 0; i < paranum; i++)
        {
            sprintf(pe->str[i + 1], "%-20.20s", valstr[i]);
        }
    }
    else
    {
        sprintf(pe->str[1], "%-20.20s", &namestr[lineoff]);
        namestr[lineoff] = '\0';
        sprintf(pe->str[0], "%-20.20s", namestr);
        for (i = 0; i < paranum; i++)
        {
            sprintf(pe->str[i + 2], "%-20.20s", valstr[i]);
        }
    }
#endif
    pe->sParaNum = paranum;
}

/**************************************************************************
函数名称：mmd_GetEvent
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取事件记录信息
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_GetEvent(int value)
{
    DWORD addr;
    if (g_soe_info.wEvNumber == 0)
    {
        strcpy(m_WarningStr, "无事件记录信息");
        return M_JUMP3;
    }
    addr = EEP_SOE_ADDR + g_soe_info.wEvIndex * (sizeof(EVENT_SAVE)) + 4;
    e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
    mmd_GetEventShow(&m_tEvent, false);
    m_tEvent.wCurrent = g_soe_info.wEvNumber;
    m_tEvent.wNumber = g_soe_info.wEvNumber;
    m_tEvent.wIndex = g_soe_info.wEvIndex;
    return M_JUMP0;
}

int mmd_GetVipEvent(int value)
{
    DWORD addr;
    if (g_soe_info.wVipNumber == 0)
    {
        strcpy(m_WarningStr, "无关键记录信息");
        return M_JUMP3;
    }
    addr = EEP_VIP_ADDR + g_soe_info.wVipIndex * (sizeof(EVENT_SAVE)) + 4;
    e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
    mmd_GetEventShow(&m_tEvent, false);
    m_tEvent.wCurrent = g_soe_info.wVipNumber;
    m_tEvent.wNumber = g_soe_info.wVipNumber;
    m_tEvent.wIndex = g_soe_info.wVipIndex;
    return M_JUMP0;
}

int mmd_GetDebugEvent(int value)
{
    DWORD addr;

#ifndef ADD_DEBUG_RECORD_FUN // 未配置调试记录的功能则每次进入菜单则需把关键记录的参数传入调试记录参数中
    g_soe_info.wDebugNumber = g_soe_info.wVipNumber;
    g_soe_info.wDebugIndex = g_soe_info.wVipIndex;
#endif
    if (g_soe_info.wDebugNumber == 0)
    {
        strcpy(m_WarningStr, "无调试记录信息");
        return M_JUMP3;
    }
    addr = EEP_DEBUG_RECORD_ADDR + g_soe_info.wDebugIndex * (sizeof(EVENT_SAVE)) + 4;
    e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
    mmd_GetEventShow(&m_tEvent, false);
    m_tEvent.wCurrent = g_soe_info.wDebugNumber;
    m_tEvent.wNumber = g_soe_info.wDebugNumber;
    m_tEvent.wIndex = g_soe_info.wDebugIndex;
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_GetOpe
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取操作记录信息
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_GetOpe(int value)
{
    DWORD addr;
    if (g_soe_info.wOpNumber == 0)
    {
        strcpy(m_WarningStr, "无操作记录信息");
        return M_JUMP3;
    }
    addr = EEP_OPERATE_ADDR + g_soe_info.wOpIndex * (sizeof(EVENT_SAVE)) + 4;
    e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
    mmd_GetEventShow(&m_tEvent, false);
    m_tEvent.wCurrent = g_soe_info.wOpNumber;
    m_tEvent.wNumber = g_soe_info.wOpNumber;
    m_tEvent.wIndex = g_soe_info.wOpIndex;
    return M_JUMP0;
}
/**************************************************************************
函数名称：mmd_GetSoePara
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取记录显示的参数
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static int mmd_GetSoePara(EVENT_SHOW *es)
{
    if (g_tScreen.lcd_type != LCD_TYPE_12232) // 是160*160液晶，参数一屏可以显示
    {
        return M_OK;
    }

    if (es->sParaNum < 1)
    {
        return M_OK;
    }
    es->sParaCur++;
    if (es->sParaCur >= es->sParaNum)
    {
        es->sParaCur = 0;
    }
    sprintf(es->valuestr, "%-16.16s", es->str[es->sParaCur]);
    return M_OK;
}
#ifdef SOE_PARA_ALL_SAVE
static int mmd_GetAllSoePara(EVENT_SHOW *pe)
{
    EVENT_STRUCT *er = &pe->tEv;
    u8 ev_type;
    ev_type = er->ev_type & SOE_TYPE_MASK;
    if (ev_type == SOE_TYPE_EV) // 事件
    {
        u16 code = 0;
        if (er->ev_code < EV_NUMBER && er->ev_value)
        {
            if (er->ev_code < EV_PUB_START)
            {
                code = er->ev_code % EV_SW_NUM;
            }
            else
            {
                code = er->ev_code - EV_SW_NUM * (SWITCH_NUM_MAX - 1);
            }
            if (tAllSOE[code].soe_def & SOE_TYPE_VIP)
            {
                DATA_MENU_DEF *pt = &g_tDataMenu2;
                u8 tmpstr[16];
                FUC_Get_LongValue_String(er->allarg[0], tmpstr);
                sprintf((char *)pt->tDataFields[0].FmtStr, "Uab=%s V", tmpstr);
                FUC_Get_LongValue_String(er->allarg[1], tmpstr);
                sprintf((char *)pt->tDataFields[1].FmtStr, "Ubc=%s V", tmpstr);
                FUC_Get_LongValue_String(er->allarg[2], tmpstr);
                sprintf((char *)pt->tDataFields[2].FmtStr, "Uca=%s V", tmpstr);
                FUC_Get_LongValue_String(er->allarg[3], tmpstr);
                sprintf((char *)pt->tDataFields[3].FmtStr, "U0=%s V", tmpstr);
                FUC_Get_LongValue_String(er->allarg[4], tmpstr);
                sprintf((char *)pt->tDataFields[4].FmtStr, "Ia= %s A", tmpstr);
                FUC_Get_LongValue_String(er->allarg[5], tmpstr);
                sprintf((char *)pt->tDataFields[5].FmtStr, "Ib= %s A", tmpstr);
                FUC_Get_LongValue_String(er->allarg[6], tmpstr);
                sprintf((char *)pt->tDataFields[6].FmtStr, "Ic= %s A", tmpstr);
                FUC_Get_LongValue_String(er->allarg[7], tmpstr);
                sprintf((char *)pt->tDataFields[7].FmtStr, "I0= %s A", tmpstr);
                pt->sFocusIndex = 0;
                pt->sTotalNum = 8;
                pt->GetNextFuncAddr = NULL;
                pt->GetPrevFuncAddr = NULL;
                pt->GetValueFuncAddr = NULL;
                return M_JUMP1;
            }
        }
    }
    return M_OK;
}
#endif
/**************************************************************************
函数名称：mmd_GetNextEv
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：根据按键，切换到上一记录或下一记录显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_GetNextEv(int key)
{
#ifdef SOE_PARA_ALL_SAVE

    if (key == HA_KEY_ENTER) // 全参数显示
    {
        return mmd_GetAllSoePara(&m_tEvent);
    }
#endif
    if (key == HA_KEY_ADD) // 参数显示
    {
        return mmd_GetSoePara(&m_tEvent);
    }
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        return M_ERROR;
    }
    if (key == HA_KEY_LEFT || key == HA_KEY_UP) // 上一条SOE
    {
        DWORD addr;
        if (g_soe_info.wEvNumber <= 1)
        {
            return M_ERROR;
        }

        if (m_tEvent.wCurrent <= 1)
        {
            m_tEvent.wCurrent = g_soe_info.wEvNumber;
        }
        else
        {
            m_tEvent.wCurrent--;
        }

        if (m_tEvent.wIndex > 0)
        {
            m_tEvent.wIndex--;
        }
        else
        {
            if (g_soe_info.wEvNumber == MAX_EVENT_NUMBER)
            {
                m_tEvent.wIndex = MAX_EVENT_NUMBER - 1;
            }
            else
            {
                m_tEvent.wIndex = g_soe_info.wEvIndex;
            }
        }
        addr = EEP_SOE_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wEvNumber;
        return M_JUMP0;
    }
    if (key == HA_KEY_RIGHT || key == HA_KEY_DOWN) // 下一条SOE
    {
        DWORD addr;
        if (g_soe_info.wEvNumber <= 1)
        {
            return M_ERROR;
        }

        m_tEvent.wCurrent++; // 标头个数调整
        if (m_tEvent.wCurrent > g_soe_info.wEvNumber)
        {
            m_tEvent.wCurrent = 1;
        }

        m_tEvent.wIndex++;
        if (g_soe_info.wEvNumber >= MAX_EVENT_NUMBER)
        {
            if (m_tEvent.wIndex >= MAX_EVENT_NUMBER)
            {
                m_tEvent.wIndex = 0;
            }
        }
        else
        {
            if (m_tEvent.wIndex > g_soe_info.wEvIndex)
            {
                m_tEvent.wIndex = 0;
            }
        }
        addr = EEP_SOE_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wEvNumber;
        return M_JUMP0;
    }

    return M_ERROR;
}

int mmd_GetNextVip(int key)
{
#ifdef SOE_PARA_ALL_SAVE
    if (key == HA_KEY_ENTER) // 全参数显示
    {
        return mmd_GetAllSoePara(&m_tEvent);
    }
#endif
    if (key == HA_KEY_ADD) // 参数显示
    {
        return mmd_GetSoePara(&m_tEvent);
    }
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        return M_ERROR;
    }

    if (key == HA_KEY_LEFT || key == HA_KEY_UP) // 上一条SOE
    {
        DWORD addr;
        if (g_soe_info.wVipNumber <= 1)
        {
            return M_ERROR;
        }

        if (m_tEvent.wCurrent <= 1)
        {
            m_tEvent.wCurrent = g_soe_info.wVipNumber;
        }
        else
        {
            m_tEvent.wCurrent--;
        }

        if (m_tEvent.wIndex > 0)
        {
            m_tEvent.wIndex--;
        }
        else
        {
            if (g_soe_info.wVipNumber == MAX_VIP_NUMBER)
            {
                m_tEvent.wIndex = MAX_VIP_NUMBER - 1;
            }
            else
            {
                m_tEvent.wIndex = g_soe_info.wVipIndex;
            }
        }
        addr = EEP_VIP_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wVipNumber;
        return M_JUMP0;
    }
    if (key == HA_KEY_RIGHT || key == HA_KEY_DOWN) // 下一条SOE
    {
        DWORD addr;
        if (g_soe_info.wVipNumber <= 1)
        {
            return M_ERROR;
        }

        m_tEvent.wCurrent++; // 标头个数调整
        if (m_tEvent.wCurrent > g_soe_info.wVipNumber)
        {
            m_tEvent.wCurrent = 1;
        }

        m_tEvent.wIndex++;
        if (g_soe_info.wVipNumber >= MAX_VIP_NUMBER)
        {
            if (m_tEvent.wIndex >= MAX_VIP_NUMBER)
            {
                m_tEvent.wIndex = 0;
            }
        }
        else
        {
            if (m_tEvent.wIndex > g_soe_info.wVipIndex)
            {
                m_tEvent.wIndex = 0;
            }
        }
        addr = EEP_VIP_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wVipNumber;
        return M_JUMP0;
    }
    return M_ERROR;
}
/**************************************************************************
函数名称：mmd_GetNextDebug
函数版本：1.00
作者：      jack.liu
创建日期：2020.12.21
函数功能说明：根据按键，切换到上一操作或下一操作记录显示
输入参数：
输出参数：
返回值：
***************************************************************************/
int mmd_GetNextDebug(int key)
{
#ifdef SOE_PARA_ALL_SAVE
    if (key == HA_KEY_ENTER) // 全参数显示
    {
        return mmd_GetAllSoePara(&m_tEvent);
    }
#endif
    if (key == HA_KEY_ADD) // 参数显示
    {
        return mmd_GetSoePara(&m_tEvent);
    }
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        return M_ERROR;
    }

    if (key == HA_KEY_LEFT || key == HA_KEY_UP) // 上一条SOE
    {
        DWORD addr;
        if (g_soe_info.wDebugNumber <= 1)
        {
            return M_ERROR;
        }

        if (m_tEvent.wCurrent <= 1)
        {
            m_tEvent.wCurrent = g_soe_info.wDebugNumber;
        }
        else
        {
            m_tEvent.wCurrent--;
        }

        if (m_tEvent.wIndex > 0)
        {
            m_tEvent.wIndex--;
        }
        else
        {
            if (g_soe_info.wDebugNumber == MAX_DEBUG_RECORD_NUMBER)
            {
                m_tEvent.wIndex = MAX_DEBUG_RECORD_NUMBER - 1;
            }
            else
            {
                m_tEvent.wIndex = g_soe_info.wDebugIndex;
            }
        }
        addr = EEP_DEBUG_RECORD_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wDebugNumber;
        return M_JUMP0;
    }
    if (key == HA_KEY_RIGHT || key == HA_KEY_DOWN) // 下一条SOE
    {
        DWORD addr;
        if (g_soe_info.wDebugNumber <= 1)
        {
            return M_ERROR;
        }

        m_tEvent.wCurrent++; // 标头个数调整
        if (m_tEvent.wCurrent > g_soe_info.wDebugNumber)
        {
            m_tEvent.wCurrent = 1;
        }

        m_tEvent.wIndex++;
        if (g_soe_info.wDebugNumber >= MAX_DEBUG_RECORD_NUMBER)
        {
            if (m_tEvent.wIndex >= MAX_DEBUG_RECORD_NUMBER)
            {
                m_tEvent.wIndex = 0;
            }
        }
        else
        {
            if (m_tEvent.wIndex > g_soe_info.wDebugIndex)
            {
                m_tEvent.wIndex = 0;
            }
        }
        addr = EEP_DEBUG_RECORD_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wDebugNumber;
        return M_JUMP0;
    }

    return M_ERROR;
}

/**************************************************************************
函数名称：mmd_GetNextOpe
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：根据按键，切换到上一操作或下一操作记录显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_GetNextOpe(int key)
{
    if (key == HA_KEY_ADD) // 参数显示
    {
        return mmd_GetSoePara(&m_tEvent);
    }
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        return M_ERROR;
    }
    if (key == HA_KEY_LEFT || key == HA_KEY_UP) // 上一条SOE
    {
        DWORD addr;
        if (g_soe_info.wOpNumber <= 1)
        {
            return M_ERROR;
        }

        if (m_tEvent.wCurrent <= 1)
        {
            m_tEvent.wCurrent = g_soe_info.wOpNumber;
        }
        else
        {
            m_tEvent.wCurrent--;
        }

        if (m_tEvent.wIndex > 0)
        {
            m_tEvent.wIndex--;
        }
        else
        {
            if (g_soe_info.wOpNumber == MAX_OPERATE_NUMBER)
            {
                m_tEvent.wIndex = MAX_OPERATE_NUMBER - 1;
            }
            else
            {
                m_tEvent.wIndex = g_soe_info.wOpIndex;
            }
        }
        addr = EEP_OPERATE_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wOpNumber;
        return M_JUMP0;
    }
    if (key == HA_KEY_RIGHT || key == HA_KEY_DOWN) // 下一条SOE
    {
        DWORD addr;
        if (g_soe_info.wOpNumber <= 1)
        {
            return M_ERROR;
        }

        m_tEvent.wCurrent++; // 标头个数调整
        if (m_tEvent.wCurrent > g_soe_info.wOpNumber)
        {
            m_tEvent.wCurrent = 1;
        }

        m_tEvent.wIndex++;
        if (g_soe_info.wOpNumber >= MAX_OPERATE_NUMBER)
        {
            if (m_tEvent.wIndex >= MAX_OPERATE_NUMBER)
            {
                m_tEvent.wIndex = 0;
            }
        }
        else
        {
            if (m_tEvent.wIndex > g_soe_info.wOpIndex)
            {
                m_tEvent.wIndex = 0;
            }
        }
        addr = EEP_OPERATE_ADDR + m_tEvent.wIndex * (sizeof(EVENT_SAVE)) + 4;
        e2prom_read(addr, (BYTE *)&m_tEvent.tEv, sizeof(EVENT_STRUCT));
        mmd_GetEventShow(&m_tEvent, false);
        m_tEvent.wNumber = g_soe_info.wOpNumber;
        return M_JUMP0;
    }
    return M_ERROR;
}
/**************************************************************************
函数名称：CheckAutoSOE
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：检查是否有自动弹出的事件要显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

bool CheckAutoSOE(void)
{

    if (g_run_stu.bHmiRmtTest && (g_tScreen.cActiveMenuNo < 124 || g_tScreen.cActiveMenuNo > 129)) // 退出测试模式
    {
        g_run_stu.bHmiRmtTest = false;
    }

    if (g_tScreen.cActiveMenuNo > 0)
    {
        g_soe_info.bDpNew = false; // 进入其他页面也不弹窗
        return false;
    }

    if (g_tLcdComm.bLock)
    {
        g_soe_info.bDpNew = false;
        return false;
    }

    if (!g_soe_info.bDpNew) // 没有事件产生
    {
        return false;
    }
    if (g_tScreen.cActiveMenuNo == 23)
        return false;
#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
    if ((g_tScreen.cActiveMenuNo == 124) || (g_tScreen.cActiveMenuNo == 126))
    {
        g_soe_info.bDpNew = false; // 进入其他页面也不弹窗
        return false;
    }
#endif
    g_soe_info.bDpNew = false;

    if (g_bVipSoe_show)
    {
        if (g_soe_info.bDpType)
        {
            mmd_GetOpe(0);
        }
        else
        {
#ifdef ADD_DEBUG_RECORD_FUN
            mmd_GetDebugEvent(0);
#else
            mmd_GetVipEvent(0);
#endif
        }
    }
    else
    {
        mmd_GetEvent(0);
    }
    return true;
}

/*下面是测量值显示*/

/**************************************************************************
函数名称：mmd_GetMeaPubValue
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：处理测量值的显示
输入参数：
                            i 显示的测量值的索引,
                            pF显示数据结构
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
void mmd_angle_to_str(char *str, qs16 angle)
{
    if (str == NULL)
    {
        return;
    }

    if (angle > 0)
    {
        angle += Q16_BASE >> 1;
    }
    else
    {
        angle -= Q16_BASE >> 1;
    }
#ifdef DISP_MEA_CN
    sprintf(str, "%3d°", angle / Q16_BASE);
#else
    sprintf(str, " %3d°", angle / Q16_BASE);
#endif
}
static void mmd_GetMeaPubValue(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[24];
    char meastr[24];
    char meaCal[4];

    // 幅值
    FUC_Get_LongValue_String(lMeaVal[i], tmpstr);
    strcpy(meaCal, " ");
    if (lMeaCal[i])
    {
        strcpy(meaCal, "*");
    }
    if (g_pub_ac_desc[i].unit_angle == UNIT_ANG) // 需要显示角度
    {
        sprintf(meastr, "%s%-4.4s=%-6.6s%s", meaCal, g_pub_ac_desc[i].name, tmpstr, g_unit[g_pub_ac_desc[i].unit].name); // 幅值
    }
    else
    {
        sprintf(meastr, "%s%-s=%-6.6s%s", meaCal, g_pub_ac_desc[i].name, tmpstr, g_unit[g_pub_ac_desc[i].unit].name); // 幅值
    }

    if (g_pub_ac_desc[i].unit_angle == UNIT_ANG) // 需要显示角度
    {
        if (lMeaAng[i] != ANGEL_INVALID)
        {
            mmd_angle_to_str(tmpstr, lMeaAng[i]);
        }
        else
        {
            strcpy(tmpstr, " ---  ");
        }
        strcat(meastr, tmpstr);
    }
    sprintf(pd, "%-20s", meastr);
}
/**************************************************************************
函数名称：mmd_RenewMeaPub
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：刷新测量值显示
输入参数：


输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_RenewMeaPub(void)
{
    FreshMeaPub(lMeaVal, lMeaAng, lMeaCal);
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetMeaPub
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得测量值的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_GetMeaPub(int value)
{

    FreshMeaPub(lMeaVal, lMeaAng, lMeaCal);
    mmd_initDataMenu(&g_tDataMenu1, PUB_AC_NUM_ALL, mmd_RenewMeaPub, mmd_GetMeaPubValue, 15, 1);
    return M_OK;
}
static void mmd_GetMeaSwValue(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[24];
    char meastr[24];
    char meaCal[4];

    // 幅值
    FUC_Get_LongValue_String(lMeaVal[i], tmpstr);
    strcpy(meaCal, " ");
    if (lMeaCal[i])
    {
        strcpy(meaCal, "*");
    }

    if (g_sw_ac_desc[i].unit_angle == UNIT_ANG) // 需要显示角度
    {
        sprintf(meastr, "%s%-4.4s=%-6.6s%s", meaCal, g_sw_ac_desc[i].name, tmpstr, g_unit[g_sw_ac_desc[i].unit].name); // 幅值//sprintf(meastr,"%s%-6.6s=%-6.6s%s",meaCal,g_sw_ac_desc[i].name,tmpstr,g_unit[g_sw_ac_desc[i].unit].name);  //幅值
    }
    else if (g_sw_ac_desc[i].unit == UNIT_GE) // 整型值
    {
        sprintf(meastr, "%s%-s=%d %s", meaCal, g_sw_ac_desc[i].name, lMeaVal[i], g_unit[g_sw_ac_desc[i].unit].name); // 幅值
    }
    else
    {
        sprintf(meastr, "%s%-s=%-6.6s%s", meaCal, g_sw_ac_desc[i].name, tmpstr, g_unit[g_sw_ac_desc[i].unit].name); // 幅值
    }
    if (g_sw_ac_desc[i].unit_angle == UNIT_ANG) // 需要显示角度
    {
        if (lMeaAng[i] != ANGEL_INVALID)
        {
            //			sprintf(tmpstr," %3d°",lMeaAng[i]/65536L);
            mmd_angle_to_str(tmpstr, lMeaAng[i]);
        }
        else
        {
            strcpy(tmpstr, " ---  ");
        }

        strcat(meastr, tmpstr);
    }
    sprintf(pd, "%-20s", meastr);
}

int mmd_RenewMeaSw(void)
{
    FreshMeaSw(lMeaVal, lMeaAng, lMeaCal, g_sw_index);
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetMeaSw(int value)
{
    g_sw_index = 1;
    FreshMeaSw(lMeaVal, lMeaAng, lMeaCal, g_sw_index);
    mmd_initDataMenu(&g_tDataMenu1, SW_AC_NUM_ALL, mmd_RenewMeaSw, mmd_GetMeaSwValue, 16, 1);
    return M_OK;
}

int mmd_ChangeSwMea(int key)
{
    if (key == HA_KEY_ADD || key == HA_KEY_SUB) // 显示下一个开关
    {
        if (key == HA_KEY_ADD)
        {
            g_sw_index++;
            if (g_sw_index > SWITCH_NUM_MAX)
            {
                g_sw_index = 1;
            }
        }
        else
        {
            if (g_sw_index > 1)
            {
                g_sw_index--;
            }
            else
            {
                g_sw_index = SWITCH_NUM_MAX;
            }
        }
        FreshMeaSw(lMeaVal, lMeaAng, lMeaCal, g_sw_index);
        mmd_initDataMenu(&g_tDataMenu1, SW_AC_NUM_ALL, mmd_RenewMeaSw, mmd_GetMeaSwValue, 16, 1);
    }

    return M_OK;
}

/*下面是遥信值显示*/

struct M_List
{
    WORD list[64];
    WORD num;
    WORD ftuswnum;
    WORD m_current;
} m_list;

struct M_board
{
    BYTE list[16];
    int list_num[16];
    BYTE num;
    BYTE m_current;
} m_board;

extern struct di g_di[];

static void mmd_GetPubYxValue(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[4];
    struct equ_config_di *ecd = &g_equ_config_di[g_sw_pub.di_cfg_index[m_list.list[i]]];

    // if(g_di[ecd->slot].value&(1<<ecd->index))
    if (dido_di_is_on(ecd->slot, ecd->index))
    {
        strcpy(tmpstr, YX_H);
    }
    else
    {
        strcpy(tmpstr, YX_F);
    }

    sprintf(pd, "%-16.16s %s", ecd->name, tmpstr);
}

int mmd_RenewPubYX(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetMeaPub
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得测量值的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_GetPubYX(int value)
{
    int i;
    memset(&m_list, 0, sizeof(m_list));
    for (i = 0; i < PUB_DI_NUM; i++)
    {
        if ((short)g_sw_pub.di_cfg_index[i] != INDEX_INVALLID) // 此遥信有配置
        {
            m_list.list[m_list.num] = i;
            m_list.num++;
        }
    }

    if (m_list.num == 0)
    {
        strcpy(m_WarningStr, "无公用遥信配置");
        return M_JUMP3;
    }
    m_list.m_current = 0;
    mmd_initDataMenu(&g_tDataMenu1, m_list.num, mmd_RenewPubYX, mmd_GetPubYxValue, 17, 1);
    return M_JUMP0;
}

static void mmd_GetSwYxValue(int i, DATA_FIELD_DEF *pF)
{

    char *pd = pF->FmtStr;
    char tmpstr[4];
    struct equ_config_di *ecd = &g_equ_config_di[g_sw[m_board.list[m_board.m_current]].di_cfg_index[m_list.list[i]]];

    // if(g_di[ecd->slot].value&(1<<ecd->index))
    if (dido_di_is_on(ecd->slot, ecd->index))
    {
        strcpy(tmpstr, YX_H);
    }
    else
    {
        strcpy(tmpstr, YX_F);
    }
    sprintf(pd, "%-16.16s %s", ecd->name, tmpstr);
}

int mmd_RenewSwYX(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetSwYX(int value)
{
    int i, sw;
    memset(&m_board, 0, sizeof(m_board));
    for (sw = 0; sw < SWITCH_NUM_MAX; sw++)
    {
        int sum = 0;

        for (i = 0; i < SW_DI_NUM; i++)
        {
            if ((short)g_sw[sw].di_cfg_index[i] != INDEX_INVALLID) // 此遥信有配置
            {

                sum++;
            }
        }
        if (sum) //  此开关配置有遥信
        {
            m_board.list[m_board.num] = sw;
            m_board.list_num[m_board.num] = sum;
            m_board.num++;
        }
    }
    if (m_board.num == 0)
    {
        strcpy(m_WarningStr, "线路无遥信配置");
        return M_JUMP3;
    }
    m_board.m_current = 0;
    memset(&m_list, 0, sizeof(m_list));
    sw = m_board.list[m_board.m_current];
    for (i = 0; i < SW_DI_NUM; i++)
    {
        if ((short)g_sw[sw].di_cfg_index[i] != INDEX_INVALLID) // 此遥信有配置
        {
            m_list.list[m_list.num] = i;
            m_list.num++;
        }
    }
    g_sw_index = sw + 1;
    mmd_initDataMenu(&g_tDataMenu1, m_list.num, mmd_RenewSwYX, mmd_GetSwYxValue, 18, 1);
    return M_JUMP0;
}

int mmd_ChangeYxSw(int key)
{
    int i, sw;
    if (m_board.num == 0)
        return M_OK;

    if (key == HA_KEY_ADD || key == HA_KEY_SUB)
    {
        if (key == HA_KEY_ADD) // 显示下一个开关
        {

            m_board.m_current++;
            if (m_board.m_current >= m_board.num)
            {
                m_board.m_current = 0;
            }
        }

        if (key == HA_KEY_SUB) // 显示上一个开关
        {
            if (m_board.m_current > 0)
            {
                m_board.m_current--;
            }
            else
            {
                m_board.m_current = m_board.num - 1;
            }
        }
        memset(&m_list, 0, sizeof(m_list));
        sw = m_board.list[m_board.m_current];

        for (i = 0; i < SW_DI_NUM; i++)
        {
            if ((short)g_sw[sw].di_cfg_index[i] != INDEX_INVALLID) // 此遥信有配置
            {
                m_list.list[m_list.num] = i;
                m_list.num++;
            }
        }
        g_sw_index = sw + 1;
        Add_Clear_Screen();
        mmd_initDataMenu(&g_tDataMenu1, m_list.num, mmd_RenewSwYX, mmd_GetSwYxValue, 18, 1);
    }
    return M_OK;
}

static void mmd_GetBoardYXValue(int no, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[8];
    int i, di_no;
    int num;

    strcpy(pd, "");
    di_no = no * 10;
    num = m_board.list_num[m_board.m_current];
    for (i = 0; i < 10; i++)
    {
        if (di_no >= num) // 超出有效遥信范围
        {
            strcpy(tmpstr, "  ");
        }
        else
        {
            //			// TODO:if(g_di[g_sw_index].value&(1<<di_no))
            if (dido_di_is_on(g_sw_index, di_no))
            {
                strcpy(tmpstr, "●");
            }
            else
            {
                strcpy(tmpstr, "○");
            }
            di_no++;
        }
        strcat(pd, tmpstr);
    }
}

int mmd_RenewBoardYX(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}

int mmd_GetBoardYX(int value)
{
    int i;
    memset(&m_board, 0, sizeof(m_board));
    for (i = 0; i < g_equ_config->equ_slot_num; i++)
    {
        int di_num = equ_get_di_num(i);
        if (di_num > 0)
        {
            m_board.list[m_board.num] = i;
            m_board.list_num[m_board.num] = di_num;
            m_board.num++;
        }
    }
    if (m_board.num == 0)
    {
        strcpy(m_WarningStr, "无遥信板卡配置");
        return M_JUMP3;
    }
    m_board.m_current = 0;
    g_sw_index = m_board.list[m_board.m_current];
    mmd_initDataMenu(&g_tDataMenu1, 3, mmd_RenewBoardYX, mmd_GetBoardYXValue, 19, 1);
    return M_JUMP0;
}

int mmd_ChangeYxBoard(int key)
{
    if (m_board.num <= 1)
        return M_OK;

    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        return M_ERROR;
    }

    if (key == HA_KEY_ADD || key == HA_KEY_DOWN || key == HA_KEY_RIGHT) // 显示下一个开关
    {

        m_board.m_current++;
        if (m_board.m_current >= m_board.num)
        {
            m_board.m_current = 0;
        }
    }

    if (key == HA_KEY_SUB || key == HA_KEY_UP || key == HA_KEY_LEFT) // 显示上一个开关
    {
        if (m_board.m_current > 0)
        {
            m_board.m_current--;
        }
        else
        {
            m_board.m_current = m_board.num - 1;
        }
    }
    g_sw_index = m_board.list[m_board.m_current];
    mmd_initDataMenu(&g_tDataMenu1, 3, mmd_RenewBoardYX, mmd_GetBoardYXValue, 19, 1);
    return M_OK;
}

/************下面是FTU遥测，遥信显示处理************************/

typedef struct MENU_MEA
{
    u8 index[MEA_MENU_MAX];
    u8 num;

} MENU_MEA;

MENU_MEA tMenuMea;

static void mmd_GetFtuMeaValue(int index, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[24];
    char meastr[24];
    char meaCal[4];
    u8 unit_angle;
    long lValue = 0;
    int i;
    float pt;

    if (tMenuMea.num == 0) // 没有额外显示配置文件
    {
        i = index;
    }
    else
    {
        i = tMenuMea.index[index];
    }
    lValue = lMeaVal[i];
    if (pRunSet->bTT_ShowOne)
    {
        if (i < SW_AC_MENU_NUM)
        {
            switch (g_sw_ac_desc[i].unit)
            {
            case UNIT_A5:
            case UNIT_BIA:
            case UNIT_I0A:
                if (strstr(g_sw_ac_desc[i].name, "I0")) // I0零序电流变比不一样
                {
                    if (pRunSet->ct0_two)
                        lValue = _MulFac_S(lMeaVal[i], ((DWORD)(pRunSet->ct0_one / pRunSet->ct0_two)) << 16);
                }
                else
                {
                    if (pRunSet->ct_two)
                        lValue = _MulFac_S(lMeaVal[i], ((DWORD)(pRunSet->ct_one / pRunSet->ct_two)) << 16); //((DWORD)(pRunSet->ct_one/pRunSet->ct_two));
                }
                break;
            case UNIT_W:
            case UNIT_Var:
            case UNIT_kW:
            case UNIT_kVar:
                if (pRunSet->a_pt_two)
                    lValue = (long)((float)lMeaVal[i] * (pRunSet->ct_one / pRunSet->ct_two * pRunSet->pt_rate / pRunSet->a_pt_two));
                break;
            default:
                break;
            }
        }
        else
        {
            switch (g_pub_ac_desc[i - SW_AC_MENU_NUM].unit)
            {
            case UNIT_V100:
            case UNIT_V220:
            case UNIT_kV:
                // 判断PT变比电源侧&&母线侧&&零序电压
                if (strchr(g_pub_ac_desc[i - SW_AC_MENU_NUM].name, '2'))
                    pt = pRunSet->b_pt_two;
                else
                    pt = pRunSet->a_pt_two;
                if (pt)
                    lValue = (long)((float)lMeaVal[i] * (pRunSet->pt_rate / pt));
                break;
            default:
                lValue = lMeaVal[i];
                break;
            }
        }
    }
    else
    {
        lValue = lMeaVal[i];
    }
    // 幅值
    FUC_Get_LongValue_String(lValue, tmpstr);
    meaCal[0] = 0;
#ifndef DISP_MEA_CN
    strcpy(meaCal, " ");
    if (lMeaCal[i])
    {
        strcpy(meaCal, "*");
    }
#endif
    if (i < SW_AC_MENU_NUM)
    {
        unit_angle = g_sw_ac_desc[i].unit_angle;

        if (g_sw_ac_desc[i].unit == UNIT_GE) // 整型值
        {
            sprintf(meastr, "%s%-s=%d %s", meaCal, g_sw_ac_desc[i].name, lValue, g_unit[g_sw_ac_desc[i].unit].name); // 幅值
        }
        else
        {
            if (pRunSet->bTT_ShowOne) // 单位显示
            {
                switch (g_sw_ac_desc[i].unit)
                {
                case UNIT_A5:
                case UNIT_BIA:
                case UNIT_I0A:
                    if (unit_angle == UNIT_ANG) // 需要显示角度
                    {
#ifdef DISP_MEA_CN
                        sprintf(meastr, "%s%-6.6s=%-6.6sA", meaCal, g_sw_ac_desc[i].name, tmpstr); // 幅值
#else
                        sprintf(meastr, "%s%-4.4s=%-6.6s A", meaCal, g_sw_ac_desc[i].name, tmpstr); // 幅值
#endif
                    }
                    else
                    {
                        sprintf(meastr, "%s%-s=%-6.6sA", meaCal, g_sw_ac_desc[i].name, tmpstr);
                    }
                    break;
                case UNIT_kW:
                case UNIT_W:
#ifdef DISP_MEA_CN
                    sprintf(meastr, "%s%-s=%-7.7sKW", meaCal, g_sw_ac_desc[i].name, tmpstr);
#else
                    sprintf(meastr, "%s%-s=%-7.7s KW", meaCal, g_sw_ac_desc[i].name, tmpstr);
#endif
                    break;
                case UNIT_kVar:
                case UNIT_Var:

#ifdef DISP_MEA_CN
                    sprintf(meastr, "%s%-s=%-7.7sKVar", meaCal, g_sw_ac_desc[i].name, tmpstr);
#else
                    sprintf(meastr, "%s%-s=%-7.7s KVar", meaCal, g_sw_ac_desc[i].name, tmpstr);
#endif
                    break;
                default:
#ifdef DISP_MEA_CN
                    sprintf(meastr, "%s%-s=%-6.6s%s", meaCal, g_sw_ac_desc[i].name, tmpstr, g_unit[g_sw_ac_desc[i].unit].name);
#else
                    sprintf(meastr, "%s%-s=%-6.6s%s ", meaCal, g_sw_ac_desc[i].name, tmpstr, g_unit[g_sw_ac_desc[i].unit].name);
#endif
                    break;
                }
            }
            else
            {
                if (unit_angle == UNIT_ANG) // 需要显示角度
                {
#ifdef DISP_MEA_CN
                    sprintf(meastr, "%s%-7.7s=%-5.5s%s", meaCal, g_sw_ac_desc[i].name, tmpstr, g_unit[g_sw_ac_desc[i].unit].name); // 幅值
#else
                    sprintf(meastr, "%s%-4.4s=%-6.6s%s", meaCal, g_sw_ac_desc[i].name, tmpstr, g_unit[g_sw_ac_desc[i].unit].name); // 幅值
#endif
                }
                else
                {
                    sprintf(meastr, "%s%-s=%-6.6s%s", meaCal, g_sw_ac_desc[i].name, tmpstr, g_unit[g_sw_ac_desc[i].unit].name);
                }
            }
        }
    }
    else
    {
        unit_angle = g_pub_ac_desc[i - SW_AC_MENU_NUM].unit_angle;
        if (pRunSet->bTT_ShowOne) // 单位显示
        {
            switch (g_pub_ac_desc[i - SW_AC_MENU_NUM].unit)
            {
            case UNIT_V100:
            case UNIT_V220:
            case UNIT_kV:
#ifdef DISP_MEA_CN
                sprintf(meastr, "%s%-7.7s=%-4.4sKV", meaCal, g_pub_ac_desc[i - SW_AC_MENU_NUM].name, tmpstr); // 幅值
#else
                sprintf(meastr, "%s%-4.4s=%-6.6sKV", meaCal, g_pub_ac_desc[i - SW_AC_MENU_NUM].name, tmpstr); // 幅值
#endif
                break;
            default:
#ifdef DISP_MEA_CN
                sprintf(meastr, "%s%-s=%-5.5s%s", meaCal, g_pub_ac_desc[i - SW_AC_MENU_NUM].name, tmpstr, g_unit[g_pub_ac_desc[i - SW_AC_MENU_NUM].unit].name); // 幅值
#else
                sprintf(meastr, "%s%-s=%-6.6s%s", meaCal, g_pub_ac_desc[i - SW_AC_MENU_NUM].name, tmpstr, g_unit[g_pub_ac_desc[i - SW_AC_MENU_NUM].unit].name); // 幅值
#endif
                break;
            }
        }
        else if (unit_angle == UNIT_ANG) // 需要显示角度
        {
#ifdef DISP_MEA_CN
            sprintf(meastr, "%s%-7.7s=%-5.5s%s", meaCal, g_pub_ac_desc[i - SW_AC_MENU_NUM].name, tmpstr, g_unit[g_pub_ac_desc[i - SW_AC_MENU_NUM].unit].name); // 幅值
#else
            sprintf(meastr, "%s%-4.4s=%-6.6s%s", meaCal, g_pub_ac_desc[i - SW_AC_MENU_NUM].name, tmpstr, g_unit[g_pub_ac_desc[i - SW_AC_MENU_NUM].unit].name); // 幅值
#endif
        }
        else
            sprintf(meastr, "%s%-s=%-6.6s%s", meaCal, g_pub_ac_desc[i - SW_AC_MENU_NUM].name, tmpstr, g_unit[g_pub_ac_desc[i - SW_AC_MENU_NUM].unit].name); // 幅值
    }
    if (unit_angle) // 需要显示角度
    {
        if (lMeaAng[i] != ANGEL_INVALID)
        {
            mmd_angle_to_str(tmpstr, lMeaAng[i]);
        }
        else
        {
            strcpy(tmpstr, " ---  ");
        }

#if LCD_SIZE == 160
        strcat(meastr, tmpstr);
#endif
    }

#if LCD_SIZE == 128
    sprintf(pd, "%-16.16s", meastr);
#else
    sprintf(pd, "%-20.20s", meastr);
#endif
}

int mmd_RenewFtuMea(void)
{
    FreshMeaSw(lMeaVal, lMeaAng, lMeaCal, 1);
    FreshMeaPub(&lMeaVal[SW_AC_MENU_NUM], &lMeaAng[SW_AC_MENU_NUM], &lMeaCal[SW_AC_MENU_NUM]);
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetFtuMea(int value)
{
    int num;
    num = (tMenuMea.num > 0) ? tMenuMea.num : MEA_MENU_MAX;
    FreshMeaSw(lMeaVal, lMeaAng, lMeaCal, 1);
    FreshMeaPub(&lMeaVal[SW_AC_MENU_NUM], &lMeaAng[SW_AC_MENU_NUM], &lMeaCal[SW_AC_MENU_NUM]);
    mmd_initDataMenu(&g_tDataMenu1, num, mmd_RenewFtuMea, mmd_GetFtuMeaValue, 21, 1);
    return M_OK;
}

static void mmd_GetFtuYxValue(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[4];
    struct equ_config_di *ecd;

    if (i < m_list.ftuswnum)
    {
        ecd = &g_equ_config_di[g_sw[0].di_cfg_index[m_list.list[i]]];
    }
    else
    {
        ecd = &g_equ_config_di[g_sw_pub.di_cfg_index[m_list.list[i]]];
    }
    // if(g_di[ecd->slot].value&(1<<ecd->index))
    if (dido_di_is_on(ecd->slot, ecd->index))
    {
        strcpy(tmpstr, YX_H);
    }
    else
    {
        strcpy(tmpstr, YX_F);
    }
    // 关联压板处理
    if (SW_DI_BSCH + 1 == ecd->type && ecd->owner != 0 && (!CHZ_ALL_EN(0))) // 闭锁重合压板
        strcpy(tmpstr, YX_H);
    if ((SW_DI_CHZ + 1 == ecd->type && ecd->owner != 0 && (!CHZ_ALL_EN(0))) ||   // 重合闸投入压板
        (SW_DI_BHZTT + 1 == ecd->type && ecd->owner != 0 && (!FUN_ALL_EN(0))) || // 保护总投入压板
        (ecd->owner != 0))                                                       // 同期压板
        strcpy(tmpstr, YX_F);

#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ECZD_2020
    if ((SW_DI_BHTT + 1 == ecd->type && ecd->owner != 0 && (!BH_ALL_EN(0))) ||     // 常规保护压板
        (SW_DI_FA_TT + 1 == ecd->type && ecd->owner != 0 && (!FA_ALL_EN(0))) ||    // FA压板
        (SW_DI_FA_GOOSE + 1 == ecd->type && ecd->owner != 0 && (!BH_GOOSE_EN(0)))) // 智能分布式压板
        strcpy(tmpstr, YX_F);
#endif
#ifdef GD_AREA_ECZD_2020
    if (ecd->owner != 0 && TYTQ_ALL_EN(0)) // 停用同期压板
        strcpy(tmpstr, YX_H);
    if (ecd->owner != 0 && !JL_ALL_EN(0)) // 自动解列软压板
        strcpy(tmpstr, YX_H);

    if (SW_DI_BHZTT + 1 == ecd->type && ecd->owner != 0 && !FUN_ALL_EN(0)) // 停用保护功能总
        strcpy(tmpstr, YX_H);
#endif

#if LCD_SIZE == 128
    sprintf(pd, "%-13.13s %s", shield_str(ecd), tmpstr);
#else
    sprintf(pd, "%-16.16s %s", shield_str(ecd), tmpstr);
#endif
}

int mmd_RenewFtuYX(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetMeaPub
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得测量值的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_GetFtuYX(int value)
{
    int i;
    memset(&m_list, 0, sizeof(m_list));
    for (i = 0; i < SW_DI_NUM; i++)
    {
        if ((short)g_sw[0].di_cfg_index[i] != INDEX_INVALLID) // 此遥信有配置
        {
            m_list.list[m_list.num] = i;
            m_list.num++;
        }
    }
    m_list.ftuswnum = m_list.num;

    for (i = 0; i < PUB_DI_NUM; i++)
    {
        if ((short)g_sw_pub.di_cfg_index[i] != INDEX_INVALLID) // 此遥信有配置
        {
            m_list.list[m_list.num] = i;
            m_list.num++;
        }
    }

    if (m_list.num == 0)
    {
        strcpy(m_WarningStr, "无遥信配置");
        return M_JUMP3;
    }
    m_list.m_current = 0;
    mmd_initDataMenu(&g_tDataMenu1, m_list.num, mmd_RenewFtuYX, mmd_GetFtuYxValue, 22, 1);
    return M_JUMP0;
}

static void mmd_GetGooseValue(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[16];
    sprintf(tmpstr, "%d", tFAg.inval[i]);
    sprintf(pd, "%-16.16s %s", g_goose_recv_tbl[i].name, tmpstr);
}
int mmd_RenewGoose(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetGoose(int value)
{
    mmd_initDataMenu(&g_tDataMenu1, GOOSE_RECV_TBL_NUMBER, mmd_RenewGoose, mmd_GetGooseValue, 23, 1);
    return M_JUMP0;
}

static void mmd_GetFaStatusValue(int i, DATA_FIELD_DEF *pF)
{
    sprintf(pF->FmtStr, "%-20.20s", strGprsInf[i]);
}

void mmd_RefreshFAStatus(void)
{
    int num = 0;
    sprintf(strGprsInf[num++], "电流型    :  %s", m_Ledbh);
    sprintf(strGprsInf[num++], "集中式    :  %s", m_Ledjzs);
    sprintf(strGprsInf[num++], "重合闸充电:  %s", m_Bh_chr);
    sprintf(strGprsInf[num++], "电压电流型:  %s", m_Ledfa);
    sprintf(strGprsInf[num++], "联络/分段 :  %s", m_Fa_sl);
    sprintf(strGprsInf[num++], "联络充电  :  %s", m_Fa_chr);
    sprintf(strGprsInf[num++], "智能分布式:  %s", m_Ledgoose);
    sprintf(strGprsInf[num++], "分布式充电:  %s", m_Goose_chr);

    g_gprs_info_num = num;
}

int mmd_RenewFAStatus(void)
{
    mmd_RefreshFAStatus();
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetFaStatus(int value)
{
    mmd_RefreshFAStatus();
    mmd_initDataMenu(&g_tDataMenu1, g_gprs_info_num, mmd_RenewFAStatus, mmd_GetFaStatusValue, 8, 1);
    return M_OK;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
// GD_AREA_ECZD_2020
static void mmd_GetFunmodSetValue(int i, DATA_FIELD_DEF *pF)
{
    sprintf(pF->FmtStr, "%-20.20s", strGprsInf[i]);
}
void mmd_RefreshFunmodSet(void)
{
    int num = 0;

#if (!defined(GD_AREA_ZHONGSHAN_2020)) && (!defined(GD_AREA_ECZD_2020))

    mmd_RefreshFAStatus();
    return;
#endif

#ifdef GD_AREA_ZHONGSHAN_2020
    sprintf(strGprsInf[num++], "控制开入");
#else
    sprintf(strGprsInf[num++], "控制字");
#endif
    sprintf(strGprsInf[num++], " 保护/FA: %s", m_Mode_chr);
    sprintf(strGprsInf[num++], " 同期合闸: %s", m_Tqhz_chr);
    sprintf(strGprsInf[num++], " 自动解列: %s", m_Zdjl_chr);
    sprintf(strGprsInf[num++], " 停用: %s", m_StopFun_chr);
    sprintf(strGprsInf[num++], "软压板");
#ifdef GD_AREA_ZHONGSHAN_2020
    sprintf(strGprsInf[num++], " 远方修改功能: %s", m_Yftr_chr);
#else
    sprintf(strGprsInf[num++], " 远方投入: %s", m_Yftr_chr);
#endif

    g_gprs_info_num = num;
}
int mmd_RenewFunmodSet(void)
{
    mmd_RefreshFunmodSet();
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetFunmodSet(int value)
{
    mmd_RefreshFunmodSet();
    mmd_initDataMenu(&g_tDataMenu1, g_gprs_info_num, mmd_RenewFunmodSet, mmd_GetFunmodSetValue, 28, 1);
    return M_OK;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////

int mmd_GetFtuIfo(int value)
{
    return M_OK;
}

int mmd_TestDiDo(int value)
{
    return M_OK;
}

/**************************************************************************
函数名称：mmd_GetSectionInf
函数版本：1.00
作者：
创建日期：2008.10.21
函数功能说明：获取有效定值区
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：	 sunxi
修改内容：
修改原因：
***************************************************************************/
int mmd_GetSectionInf(int value)
{
    int i, j;
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    char *pd;
    char tmpstr[4];
    pd = g_tDataMenu1.tDataFields[0].FmtStr;
    strcpy(pd, "有效定值区: ");
    for (i = 0, j = 0; i < SEC_NUMBER; i++)
    {
        if (tSecInfo.szSections[i] == 0x55)
        {
            sprintf(tmpstr, "%02u ", i);
            strcat(pd, tmpstr);
            if (strlen(pd) >= 15)
            {
                j++;
                pd = g_tDataMenu1.tDataFields[j].FmtStr;
                strcpy(pd, " ");
            }
        }
    }
    if (strlen(pd) > 0)
        j++;

    pt->sFocusIndex = 0;        // 第一个显示的动态菜单的索引
    pt->sTotalNum = j;          // 将菜单总数置于小于菜单数,保证不清屏
    pt->GetPrevFuncAddr = NULL; // 44
    pt->GetNextFuncAddr = NULL; // 44
    return M_JUMP0;
}

/*系统时间显示*/

TIME_SHOW m_ShowTime;
TIME_SHOW m_SetTime;

int mmd_GetSetTime(int value)
{
    struct timespec ts;
    struct rtc_time_t rtc;

    clk_time_get(&ts);
    timespec_to_rtc(ts, &rtc, 1);

    m_SetTime.year = rtc.year;
    m_SetTime.month = rtc.month;
    m_SetTime.day = rtc.day;
    m_SetTime.hour = rtc.hour;
    m_SetTime.min = rtc.min;
    m_SetTime.sec = rtc.ms / 1000;
    return M_OK;
}

/**************************************************************************
函数名称：mmd_SetTime
函数版本：1.00
作者：
创建日期：2008.10.21
函数功能说明：校验并设置系统时间
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：	 sunxi
修改内容：
修改原因：
***************************************************************************/

int mmd_SetTime(int value)
{
    TIME mt;
    if (m_SetTime.year > 99)
    {
        strcpy(m_WarningStr, "年设置错误");
        return M_JUMP3;
    }
    if (m_SetTime.month > 12 || m_SetTime.month < 1)
    {
        strcpy(m_WarningStr, "月设置错误");
        return M_JUMP3;
    }
    if (m_SetTime.day > 31 || m_SetTime.day < 1)
    {
        strcpy(m_WarningStr, "日设置错误");
        return M_JUMP3;
    }
    if (m_SetTime.hour > 23)
    {
        strcpy(m_WarningStr, "时设置错误");
        return M_JUMP3;
    }
    if (m_SetTime.min > 59)
    {
        strcpy(m_WarningStr, "分设置错误");
        return M_JUMP3;
    }
    if (m_SetTime.sec > 59)
    {
        strcpy(m_WarningStr, "秒设置错误");
        return M_JUMP3;
    }

    if (m_SetTime.month == 2) // 2月特殊处理
    {
        WORD year = m_SetTime.year + 2000;
        if (year % 4 == 0) // 闰年
        {
            if (m_SetTime.day > 29)
            {
                strcpy(m_WarningStr, "日设置错误");
                return M_JUMP3;
            }
        }
        else
        {
            if (m_SetTime.day > 28)
            {
                strcpy(m_WarningStr, "日设置错误");
                return M_JUMP3;
            }
        }
    }
    mt.year = m_SetTime.year;
    mt.month = m_SetTime.month;
    mt.day = m_SetTime.day;
    mt.hour = m_SetTime.hour;
    mt.min = m_SetTime.min;
    mt.ms = (WORD)m_SetTime.sec * 1000;
    if (sys_time_set(&mt) == 0)
    {
        strcpy(m_WarningStr, "时间设置成功");
    }
    else
    {
        strcpy(m_WarningStr, "读RTC失败");
    }

    return M_JUMP3;
}

/**************************************************************************
函数名称：mmd_ChangeSection
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：切换定值区
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
#if 0
static int  mmd_ChangeSection(int value)
{
	bool ret=false;
	UINT section=m_ValidSection;
	TSECTIONINFO tSec;
	if((short)section>=0&&section<SEC_NUMBER)
	{
		MakeRunSet(false); // 将当前运行定值区转换为运行定值区
		tSec=tSecInfo;
		tSec.sCurSec=section;
		if(SaveSection(&tSec))
		{
			soe_record_opt(EV_SECQH_OK,section);
			tSecInfo=tSec;
			ret=true;
			rt_err_clr(ERR_CODE_SET);		
		}
	}
	if(ret)
	{
		strcpy(m_WarningStr,"定值区切换成功");
	}
	else
	{
		strcpy(m_WarningStr,"定值区切换失败");
		soe_record_opt(EV_SECQH_FAIL,section);
	}
	return M_JUMP3;

}
#endif

/**************************************************************************
函数名称：mmd_ClearSOE
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：清除事件库
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_ClearSOE(int value) /*清除事件库 */
{
    soe_clear_ev(); // 清事件记录
    soe_record_opt(EV_CLEAR_SOE, 0);
    strcpy(m_WarningStr, "事件库清除完毕");
    return M_JUMP3;
}

/**************************************************************************
函数名称：mmd_ClearOperateSOE
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：清除操作记录
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_ClearOperateSOE(int value) /*清除操作记录 */
{
    soe_clear_opt();
    soe_record_opt(EV_CLEAR_OPE, 0);
    strcpy(m_WarningStr, "操作记录清除完毕");
    return M_JUMP3;
}
/**************************************************************************
函数名称：mmd_SavePassWord
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：保存密码
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SavePassWord(int value)
{
    int i;
    BYTE charnum = 0;
    for (i = 0; i < PASSWORD_LEN; i++)
    {
        if (m_strPassword[i] >= '0' && m_strPassword[i] <= '9') // 数字
        {
            charnum |= (0 << i);
        }
        if (m_strPassword[i] >= 'A' && m_strPassword[i] <= 'Z') // 数字
        {
            charnum |= (1 << i);
        }
    }
#ifndef PASSWORD_4_STR
    if (charnum == 0 || charnum == 0xFF)
    {
        m_NewPassword = 0;
        m_Password = 0;
        mmi_zero_passwordstr();
        strcpy(m_WarningStr, "输入一级密码非法");
        return M_JUMP3;
    }
#endif
    charnum = 0;
    for (i = 0; i < PASSWORD_LEN; i++)
    {
        if (m_strPassword2[i] >= '0' && m_strPassword2[i] <= '9') // 数字
        {
            charnum |= (0 << i);
        }
        if (m_strPassword2[i] >= 'A' && m_strPassword2[i] <= 'Z') // 数字
        {
            charnum |= (1 << i);
        }
    }
#ifndef PASSWORD_4_STR
    if (charnum == 0 || charnum == 0xFF)
    {
        m_NewPassword = 0;
        m_Password = 0;
        mmi_zero_passwordstr();
        strcpy(m_WarningStr, "输入二级密码非法");
        return M_JUMP3;
    }
#endif

    SavePassword(m_strPassword);
    SavePassword2(m_strPassword2);
    tRunPara.wPassword = ReadPassword();

    strcpy(m_WarningStr, "密码修改成功");
    m_Password = 0;
    m_NewPassword = 0;
    mmi_zero_passwordstr();
    return M_JUMP3;
}

/*************开出测试************************/

static void mmd_GetBoardDoValue(int no, DATA_FIELD_DEF *pF)
{
    // sprintf(pF->FmtStr,"%-15.15s",g_equ_config_do[no].name);
    sprintf(pF->FmtStr, "%-20.20s", g_equ_config_do[no].name);
}

int mmd_RenewBoardDo(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetBoardDO(int value)
{
    int i;
    memset(&m_board, 0, sizeof(m_board));
    for (i = 0; i < g_equ_config->equ_slot_num; i++)
    {
        int do_num = equ_get_do_num(i);
        if (do_num > 0)
        {
            m_board.list[m_board.num] = i;
            m_board.list_num[m_board.num] = do_num;
            m_board.num++;
        }
    }
    if (m_board.num == 0)
    {
        strcpy(m_WarningStr, "无开出板卡配置");
        return M_JUMP3;
    }
    m_board.m_current = 0;
    g_sw_index = m_board.list[m_board.m_current];
    mmd_initDataMenu(&g_tDataMenu1, m_board.list_num[m_board.m_current], mmd_RenewBoardDo, mmd_GetBoardDoValue, 112, 1);
    return M_JUMP0;
}

int mmd_ChangeDoBoard(int key)
{
    if (m_board.num == 0)
        return M_OK;

    if (key == HA_KEY_ADD) // 显示下一个开关
    {

        m_board.m_current++;
        if (m_board.m_current >= m_board.num)
        {
            m_board.m_current = 0;
        }
        g_sw_index = m_board.list[m_board.m_current];
        mmd_initDataMenu(&g_tDataMenu1, m_board.list_num[m_board.m_current], mmd_RenewBoardDo, mmd_GetBoardDoValue, 112, 1);
        return M_JUMP0;
    }

    if (key == HA_KEY_SUB) // 显示上一个开关
    {
        if (m_board.m_current > 0)
        {
            m_board.m_current--;
        }
        else
        {
            m_board.m_current = m_board.num - 1;
        }
        g_sw_index = m_board.list[m_board.m_current];
        mmd_initDataMenu(&g_tDataMenu1, m_board.list_num[m_board.m_current], mmd_RenewBoardDo, mmd_GetBoardDoValue, 112, 1);
        return M_JUMP0;
    }
    return M_OK;
}

/**************************************************************************
函数名称：mmd_TestHz
函数版本：1.00
作者：
创建日期：2008.9.23
函数功能说明： 进行测试开出
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_TestHz(int value)
{
    sprintf(m_WarningStr, "开出测试完毕");
    dido_do(m_board.list[m_board.m_current], (1 << value), 1);
    return M_JUMP3;
}

WORD g_RmtIndex;

static void mmd_GooseKcValue(int no, DATA_FIELD_DEF *pF)
{
    sprintf(pF->FmtStr, "%s", g_goose_send_tbl[no].name);
}

int mmd_RenewGooseKc(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
int mmd_GetGooseKc(int value)
{
    mmd_initDataMenu(&g_tDataMenu1, GOOSE_SEND_TBL_NUMBER, mmd_RenewGooseKc, mmd_GooseKcValue, 114, 1);

    return M_OK;
}

int mmd_GooseKcTest(int value)
{
    if (g_RmtIndex == 0)
    {
        tFAg.ug.bFlag.bTstgz = value;
    }
    else if (g_RmtIndex == 1)
    {
        tFAg.ug.bFlag.bTstglok = value;
    }

    else if (g_RmtIndex == 2)
    {
        tFAg.ug.bFlag.bTstjt = value;
    }

    else if (g_RmtIndex == 3)
    {
        tFAg.ug.bFlag.bTstglbs = value;
    }
    else if (g_RmtIndex == 4)
    {
        tFAg.ug.bFlag.bTstcomerr = value;
    }
    return M_OK;
}

/******主循环界面******/
/**************************************************************************
函数名称：mmd_RenewMain
函数版本：1.00
作者：
创建日期：2008.10.8
函数功能说明：刷新主循环界面
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

DWORD m_MainNoTime; // 主循环界面时间
int mmd_RenewMain(void)
{
    if ((dTCounter - m_MainNoTime) > 8 * SAM_FREQUENCY) // 8秒钟界面翻一屏
    {
        DATA_MENU_DEF *pt = &g_tDataMenu1;
        if (pt->sTotalNum <= pt->sScreenNum)
            return M_OK;
        if ((pt->sFocusIndex / pt->sScreenNum) * pt->sScreenNum + pt->sScreenNum >= pt->sTotalNum)
        {
            pt->sFocusIndex = 0;
        }
        else
        {
            pt->sFocusIndex = (pt->sFocusIndex / pt->sScreenNum) * pt->sScreenNum + pt->sScreenNum;
        }
        Add_Clear_Screen();
        m_MainNoTime = dTCounter;
    }
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}

/**************************************************************************
函数名称：mmd_KeyMain
函数版本：1.00
作者：
创建日期：2008.10.8
函数功能说明：判断是否有按键，有按键，将主循环界面时间清为当前值
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_KeyMain(int key)
{
    m_MainNoTime = dTCounter;
    return M_OK;
}
/**************************************************************************
函数名称：mmd_EnterMainMenu
函数版本：1.00
作者：
创建日期：2008.10.8
函数功能说明：进入主循环界面，并初始化测量值的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_EnterMainMenu(int key)
{

    if (key == HA_KEY_ENTER)
    {

#if 0
#if SWITCH_NUM_MAX == 1
#ifdef GD_AREA_ECZD_2020
			return M_JUMP3;
#else
			return M_JUMP2;
#endif
#else
			return M_JUMP2;
#endif
#else

        return M_JUMP3; // 全部显示功能模块配置 jack.liu 20201105
#endif
    }
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
#if SWITCH_NUM_MAX == 1
        mmd_GetFtuMea(0);
#endif
        if (g_tLcdComm.tImage.pBuf == NULL)
        {
            return M_JUMP0;
        }
        else
        {
            return M_JUMP1;
        }
    }
    return M_ERROR;
}

int mmd_BoardLedTest(int value)
{
    if (value == 1) // 辅助板
    {
        g_led_aux_test_st = (g_led_aux_test_st > 0) ? 0 : 1;
        g_led_kz_test_st = 0;
    }
    else if (value == 2) // 状态板
    {
        g_led_kz_test_st = (g_led_kz_test_st > 0) ? 0 : 1;
        g_led_aux_test_st = 0;
    }
    else if (value == 0) // 液晶板
    {
        add_led_test(TEST_LCD);
        g_led_aux_test_st = 0;
        g_led_kz_test_st = 0;
    }
    return M_OK;
}

/*内部定值处理*/
/**************************************************************************
函数名称：mmd_RenewCstSet
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：更新内部定值显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_RenewCstSet(void)
{
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    DATA_MENU_DEF *pext = &g_tExtraMenu;
    int i;
    int bgn;
    bgn = g_set_disp.bgn[pt->sFocusIndex];
    pext->sTotalNum = 0; // 总的动态菜单数
    for (i = 0; i < g_set_disp.screennum[pt->sFocusIndex]; i++)
    {
        mmd_GetSet(bgn + i, &g_tDataMenu1.tDataFields[i], &tCstSetTable[0], m_SetBuf);
    }
    pt->sScreenNum = g_set_disp.screennum[pt->sFocusIndex];
    pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
    pext->sScreenNum = pext->sTotalNum;
    return M_OK;
}

int mmd_RenewCstSetGroup(void)
{
    mmd_RenewDataMenu(&g_tDataMenu2);
    return M_OK;
}

int mmd_backCstSet(int value)
{

    mmd_InitCstSetGroup(-1);
    g_tDataMenu2.sFocusIndex = SetGroupIndex;
    mmi_FormsInit(182, 1); //  更新最后修改的数据
    mmd_RenewCstSetGroup();
    return M_OK;
}

int mmd_InitCstSetGroup(int value)
{
    int i, num = 0;
    bool bret;

    bret = ReadEppData(EEP_SETGROUP_ADDR, m_setgroup, GROUP_NUM);
    if (!bret)
    {
        GetDefSetGroup(m_setgroup);
    }
    for (i = 0; i < GROUP_NUM; i++)
    {
        if (SetGroups[i].group == SETGROUP_TYPE_CSTSET && (m_setgroup[i] > 0))
        {
            int j;
            for (j = 0; j < CSTSET_NUMBER; j++)
            {
                if (tCstSetTable[j].group == i)
                {
                    set_show_group[num++] = i;
                    break;
                }
            }
        }
    }
    if (num == 0)
    {
        strcpy(m_WarningStr, "内部定值未配置");
        return M_JUMP2;
    }
    mmd_initDataMenu(&g_tDataMenu2, num, mmd_RenewCstSetGroup, mmd_GetSetGroupName, 182, 1);
    if (!ReadPara((void *)m_SetBuf, EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0]))
    {
        if (value == -1)
        {
            GetDefPara((float *)m_SetBuf, CSTSET_NUMBER, &tCstSetTable[0]);
        }
        else
        {
            return M_JUMP3;
        }
    }
    mmd_ChangeSet(&tCstSetTable[0], CSTSET_NUMBER, m_SetBuf);
    return M_JUMP0;
}

int mmd_SaveCstSet(int value)
{
    mmd_ReChangeSet(&tCstSetTable[0], CSTSET_NUMBER, m_SetBuf);

    if (!mmd_CheckSet(&tCstSetTable[0], CSTSET_NUMBER, m_SetBuf))
    {
        mmd_ChangeSet(&tCstSetTable[0], CSTSET_NUMBER, m_SetBuf);
        return M_JUMP3;
    }

    if (SavePara((void *)m_SetBuf, EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0]))
    {
        strcpy(m_WarningStr, "定值保存成功");
        soe_record_opt(EV_CSTSET_OK, 0); // 内部定值整定成功
        MakeRunSet(false);               // 将当前运行定值区转换为运行定值区
        rt_err_clr(ERR_CODE_SET_IN, 0);
    }
    else
    {
        strcpy(m_WarningStr, "定值保存失败");
        soe_record_opt(EV_CSTSET_FAIL, 0); // 内部定值整定成功
    }
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_InitSetSolid
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：初始化定值整定的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_InitCstSet(int value)
{
    int num = CSTSET_NUMBER;
    int screennum;
    int i;
    m_AllSection = 0;
    g_set_disp.num = 0;
    num = mmd_GetshowSetNum(&tCstSetTable[0], CSTSET_NUMBER, set_show_group[value]);
    SetGroupIndex = value;
    screennum = mmi_GetScreenNum(183, 1); // 取当前屏幕最大显示数目
    bSetChange = true;
    mmd_analyse(&tCstSetTable[0], screennum);
    {
        DATA_MENU_DEF *pt = &g_tDataMenu1;
        DATA_MENU_DEF *pext = &g_tExtraMenu;
        pext->sTotalNum = 0;
        for (i = 0; i < g_set_disp.screennum[0]; i++)
        {
            mmd_GetSet(i, &g_tDataMenu1.tDataFields[i], &tCstSetTable[0], m_SetBuf);
        }
        m_ScreenNum = num;
        pt->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pt->sTotalNum = num; // 总的动态菜单数
        pt->sScreenNum = g_set_disp.screennum[0];
        pt->GetPrevFuncAddr = mmd_RenewCstSet; // 44
        pt->GetNextFuncAddr = mmd_RenewCstSet; // 44

        pext->sFocusIndex = 0; // 第一个显示的动态菜单的索引
        pext->sScreenNum = pext->sTotalNum;
        pext->GetPrevFuncAddr = NULL; // 44
        pext->GetNextFuncAddr = NULL; // 44
        m_CurrentScreen = 1;
    }
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_SetKey
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：列表项选择
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SetCstKey(int key)
{
    if (key == HA_KEY_UP && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_ADD;
    if (key == HA_KEY_DOWN && g_tScreen.lcd_type != LCD_TYPE_160_KEY9)
        key = HA_KEY_SUB;

    if (key == HA_KEY_ADD || key == HA_KEY_SUB) // +键增加列表
    {
        if (!g_bModify)
            return M_ERROR; // 只在修改状态下执行此函数
        if (mmd_ChangeList(&tCstSetTable[0], key, m_SetBuf))
        {
            mmd_RenewCstSet(); // 刷新修改后的值
            return M_OK;
        }
    }
    return M_ERROR;
}

/*下面是精度自校及手校处理*/

/**************************************************************************
函数名称：mmd_SaveAdjustValue
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：保存精度手校系数
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_SaveAdjustValue(int value)
{
    // TODO:增加恢复默认系数操作
    factor_restore_default();

    strcpy(m_WarningStr, "通道系数恢复为默认值");
    log_str_time(LOG_OPERATE, "面板恢复默认校准系数", 0, 0);
    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_StartAutojust
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：启动精度自校
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_StartAutojust(int value)
{
    int ret;

    ret = sw_auto_adjust(-1);
    switch (ret)
    {
    case 0:
        strcpy(m_WarningStr, "通道校正成功!");
        break;
    case -1:
        strcpy(m_WarningStr, "输入校正值太大");
        break;
    case -2:
        strcpy(m_WarningStr, "通道系数超范围");
        break;
    case -3:
        strcpy(m_WarningStr, "输入角度值太小");
        break;
    case -4:
        strcpy(m_WarningStr, "输入角度值太大");
        break;
    case -5:
        strcpy(m_WarningStr, "角度系数超范围");
        break;
    case -6:
        strcpy(m_WarningStr, "系数保存错误");
        break;
    default:
        strcpy(m_WarningStr, "未知错误");
        break;
    }

    return M_JUMP3;
}

int mmd_StartZljust1(int value)
{
    int ret;

    //	equ_power_adjust();
    ret = sw_adjust_dc_0();
    switch (ret)
    {
    case 0:
        sprintf(m_WarningStr, "直流%fV校正成功!", dc_adjust[0]);
        break;
    case -1:
        sprintf(m_WarningStr, "输入直流%0.1fV值太小", dc_adjust[0]);
        break;
    case -2:
        sprintf(m_WarningStr, "输入直流%0.1fV值太大", dc_adjust[0]);
        break;
    default:
        break;
    }

    if (ret == 0)
    {
        return M_JUMP0;
    }
    else
    {
        return M_JUMP3;
    }
}

int mmd_StartZljust2(int value)
{
    int ret;
    ret = sw_adjust_dc_1();
    switch (ret)
    {
    case 0:
        sprintf(m_WarningStr, "直流校正成功!");
        break;
    case -1:
        sprintf(m_WarningStr, "输入直流%0.1fV值太小", dc_adjust[1]);
        break;
    case -2:
        sprintf(m_WarningStr, "输入直流%0.1f值太大", dc_adjust[1]);
        break;
    default:
        break;
    }

    return M_JUMP3;
}

int mmd_StartPowerAjust(int value)
{
    int ret = 0;
    // ret = equ_power_adjust();
    switch (ret)
    {
    case 0:
        sprintf(m_WarningStr, "电源电压校正成功!");
        break;
    case -1:
        sprintf(m_WarningStr, "电源电压值超范围");
        break;
    case -2:
        sprintf(m_WarningStr, "系数保存错误");
        break;
    default:
        break;
    }

    return M_JUMP3;
}

void GetBoardName(BYTE type, char *name)
{
    extern struct board_res_head *g_board_res_head;

    struct board_res *br;
    int i;
    br = g_board_res;
    for (i = 0; i < g_board_res_head->br_num; i++)
    {

        if (br[i].type == type)
        {
            strcpy(name, br[i].name);
            return;
        }
    }
    strcpy(name, "未知");
}
void mmd_GetInfValue(int no, DATA_FIELD_DEF *pF)
{
    struct board_res *br;
    struct board_info *bi;
    char bName[24];
    int i = no;
    br = g_board_res;
    bi = g_board_info;

    GetBoardName(bi[i].type, bName);

#if LCD_SIZE == 128
    sprintf(pF->FmtStr, "%-4.4s %04X %01X%02X%02x", bName, bi[i].crc, (BYTE)(bi[i].version >> 16), (BYTE)(bi[i].version >> 8), (BYTE)(bi[i].version >> 0));
#else
    sprintf(pF->FmtStr, "板卡%d   %04X %01X.%02X.%02x",
            i, bi[i].crc, (BYTE)(bi[i].version >> 16), (BYTE)(bi[i].version >> 8), (BYTE)(bi[i].version >> 0));

#endif
}

int mmd_RenewInf(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetInf
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得装置信息
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_GetInf(int value)
{
    char tmpbuf[64];

    if (set_get_fixed_arg(FIXED_SET_TPE, tmpbuf, 32) == 0)
    {
        strncpy(m_equipstr, tmpbuf, 20);
    }
    else
    {
        strcpy(m_equipstr, "FYD830");
    }
    if (set_get_fixed_arg(FIXED_SET_CRC, tmpbuf, 32) == 0)
    {
        sprintf(m_errInf, "%sH", tmpbuf); // strncpy(m_errInf,tmpbuf,20);
    }
    else
    {
        sprintf(m_errInf, "%04XH", g_board_info[0].crc);
    }
    // sprintf(m_errInf,"%sH",CODE_CRC);
    if (set_get_fixed_arg(FIXED_SET_SVR, tmpbuf, 32) == 0)
        strncpy(m_set_inf, tmpbuf, 20);
    else
        sprintf(m_set_inf, "SV%02d.%03d", g_board_info[0].version / 1000, g_board_info[0].version % 1000);

    // sprintf(m_set_inf,"%01X.%02X.%02x",(BYTE)(g_board_info[0].version>>16),(BYTE)(g_board_info[0].version>>8),(BYTE)(g_board_info[0].version>>0));
    if (set_get_fixed_arg(FIXED_SET_CPT, tmpbuf, 32) == 0)
    {
        strcpy(m_WarningStr, tmpbuf);
    }
    else
    {
        strcpy(m_WarningStr, VER_TIME);
    }

    return M_OK;
}

BYTE strGprsInf[30][24];
int g_gprs_info_num;

static void mmd_GetConfigInfValue(int no, DATA_FIELD_DEF *pF)
{
    int i;
    int errno = 0;
    for (i = 0; i < ERR_CODE_NUM; i++)
    {
        if (rt_err_test(i) > 0)
        {
            errno++;
            if ((no + 1) == errno)
            {
                break;
            }
        }
    }
    if (i == ERR_CODE_NUM)
    {
        sprintf(pF->FmtStr, "无错误信息,代码:%d", no);
    }
    else
    {
        if (g_tScreen.lcd_type != LCD_TYPE_160160)
        {
            sprintf(pF->FmtStr, "%-16.16s", rt_err_msg(i));
        }
        else
        {
            sprintf(pF->FmtStr, "%02d.%-17.17s", no + 1, rt_err_msg(i));
        }
    }
}

int mmd_RenewConfigInf(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetInf
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得装置信息
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_GetConfigInf(int value)
{
    int i;
    int err_cnt = 0;
    for (i = 0; i < ERR_CODE_NUM; i++)
    {
        if (rt_err_test(i) > 0)
        {
            err_cnt++;
        }
    }
    if (err_cnt == 0)
    {
        strcpy(m_WarningStr, "无故障信息!");
        return M_JUMP3;
    }
    mmd_initDataMenu(&g_tDataMenu1, err_cnt, mmd_RenewConfigInf, mmd_GetConfigInfValue, 7, 1);
    return M_JUMP0;
}

static void mmd_GetExtInfValue(int no, DATA_FIELD_DEF *pF)
{
#if LCD_SIZE == 128
    sprintf(pF->FmtStr, "%-16.16s", strGprsInf[no]);
#else
    sprintf(pF->FmtStr, "%-20.20s", strGprsInf[no]);
#endif
}

int mmd_RenewExtInf(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}

int mmd_GetDebugInf(int value)
{
    int num = 0;
    int debug_port;
    char *acteth;
#ifdef FUN_JDXX
    u32 version_jdxx;
    version_jdxx = FUN_JDXX_VERSION;
#endif
    acteth = env_get_info(ENV_ETHACT);
    debug_port = 0;
#if LCD_SIZE == 128
    sprintf(strGprsInf[num++], "调试串口:%d", g_con_uart_index);
    sprintf(strGprsInf[num++], "波特率:115200");
    sprintf(strGprsInf[num++], "校验位:无校验");
    sprintf(strGprsInf[num++], "调试网口:%d", debug_port + 1);
    sprintf(strGprsInf[num++], "IP地址:", env_get_info(ENV_IPADDR));
    sprintf(strGprsInf[num++], "%s", env_get_info(ENV_IPADDR));
    sprintf(strGprsInf[num++], "子网掩码:", env_get_info(ENV_NETMASK));
    sprintf(strGprsInf[num++], "%s", env_get_info(ENV_NETMASK));
    sprintf(strGprsInf[num++], "网关:", env_get_info(ENV_GATEWAYIP));
    sprintf(strGprsInf[num++], "%s", env_get_info(ENV_GATEWAYIP));
#else
    sprintf(strGprsInf[num++], "调试串口:%d", g_con_uart_index);
    sprintf(strGprsInf[num++], "波特率:115200 无校验");
    sprintf(strGprsInf[num++], "调试网口:%d", debug_port + 1);
    printf("[%s:%d] debug_port = %d\r\n", __func__, __LINE__, debug_port);
    sprintf(strGprsInf[num++], "IP=%s", env_get_info(ENV_IPADDR));
    sprintf(strGprsInf[num++], "MASK=%s", env_get_info(ENV_NETMASK));
    sprintf(strGprsInf[num++], "GATE=%s", env_get_info(ENV_GATEWAYIP));
    sprintf(strGprsInf[num++], "编译脚本:");
    sprintf(strGprsInf[num++], "%s", SH_NAME);
#ifdef FUN_JDXX
    sprintf(strGprsInf[num++], "JDXX_Ver:V%02d.%03d", version_jdxx / 1000, version_jdxx % 1000);
#else
    sprintf(strGprsInf[num++], "JDXX_Ver:------");
#endif
#endif

    g_gprs_info_num = num;
    mmd_initDataMenu(&g_tDataMenu1, num, mmd_RenewExtInf, mmd_GetExtInfValue, 8, 1);
    return M_OK;
}

int mmd_GetFileInf(int value)
{
    int num = 0;
    int i;
    int index = 0;
    extern struct board_res_head *g_board_res_head;
    for (i = 0; i < g_board_res_head->br_num; i++)
    {
#if !defined CPU_FUXI
        if (g_board_res[i].type == g_board_info[EQU_SLOT_KZ].type)
        {
            index = i;
        }
#endif
    }
#if LCD_SIZE == 128
    sprintf(strGprsInf[num], "%d.装置资源:%04XH", num + 1, g_crc_rsc); // 显示面板上num排序应从1(num+1)开始
    num++;
    sprintf(strGprsInf[num], "%d.板卡资源:%04XH", num + 1, g_crc_brd_res);
    num++;
    sprintf(strGprsInf[num], "%d.通道配置:%04XH", num + 1, g_crc_equ_cfg);
    num++;
    sprintf(strGprsInf[num], "%d.转发点表:%04XH", num + 1, g_crc_rectable);
    num++;
    sprintf(strGprsInf[num], "%d.定值描述:%04XH", num + 1, g_crc_set_desc);
    num++;
    sprintf(strGprsInf[num], "%d.定值数据:%04XH", num + 1, g_crc_set_data);
    num++;
    sprintf(strGprsInf[num], "%d.HV:%s", num + 1, g_board_res[index].name);
    num++;
    sprintf(strGprsInf[num], "%d.KV:%s", num + 1, (env_get_info(ENV_KERNEL) + 15));
    strGprsInf[num][13] = 0;
    num++;
#else
    sprintf(strGprsInf[num], "%d.装置资源文件:%04XH", num + 1, g_crc_rsc); // 显示面板上num排序应从1(num+1)开始
    num++;
    sprintf(strGprsInf[num], "%d.板卡资源文件:%04XH", num + 1, g_crc_brd_res);
    num++;
    sprintf(strGprsInf[num], "%d.通道配置文件:%04XH", num + 1, g_crc_equ_cfg);
    num++;
    sprintf(strGprsInf[num], "%d.转发点表文件:%04XH", num + 1, g_crc_rectable);
    num++;
    sprintf(strGprsInf[num], "%d.定值描述文件:%04XH", num + 1, g_crc_set_desc);
    num++;
    sprintf(strGprsInf[num], "%d.定值数据文件:%04XH", num + 1, g_crc_set_data);
    num++;
    sprintf(strGprsInf[num], "%d.HV:%s", num + 1, g_board_res[index].name);
    num++;
    sprintf(strGprsInf[num], "%d.KV:%s", num + 1, (env_get_info(ENV_KERNEL) + 15));
    strGprsInf[num][13] = 0;
    num++;
#endif
    g_gprs_info_num = num;
    mmd_initDataMenu(&g_tDataMenu1, num, mmd_RenewExtInf, mmd_GetExtInfValue, 9, 1);
    return M_OK;
}

/****GPRS维护信息显示**********************/

static void mmd_GprsInf(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
#if LCD_SIZE == 128
    sprintf(pd, "%-16.16s", strGprsInf[i]);
#else
    sprintf(pd, "%-20.20s", strGprsInf[i]);
#endif
}

int mmd_RenewGprsInf(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}

int mmd_GetGprsInf(int value)
{
    int i;
    for (i = 0; i < 20; i++)
    {
        strcpy(strGprsInf[i], " ");
    }
    mmd_initDataMenu(&g_tDataMenu1, 3, mmd_RenewGprsInf, mmd_GprsInf, 11, 1);
    IEC101_PH_GprsInfo();
    return M_OK;
}

int mmd_GprsInfKey(int key)
{
    if (key == HA_KEY_ENTER) // +键增加列表
    {
        int i;
        for (i = 0; i < CFG_UART_NUM_MAX - 1; i++)
        {
            if (UART_CHANNEL[i] < 0)
            {
                continue;
            }
            // 外部通信报文处理
            if (tRunPara.tUartPara[i].wProtocol == PROTOCOL_101_PH) // 101规约
            {
                IEC101_DEF *pt = (IEC101_DEF *)g_tRsComm[i].ptBuf;
                pt->bCallGprsInf = true;
            }
        }
    }
    return M_OK;
}

int mmd_get_gprs_info(void)
{

    BYTE *pd = tGprsInf.data;
    int num = 0;
    if (!tGprsInf.bInf)
        return 0;
    tGprsInf.bInf = false;

    if (pd[0] == 1)
    {
        strcpy(strGprsInf[num++], "模块状态 :正常");
    }
    else
    {
        strcpy(strGprsInf[num++], "模块状态 :异常");
    }

    if (pd[1] == 1)
    {
        strcpy(strGprsInf[num++], "SIM卡状态:正常");
    }
    else
    {
        strcpy(strGprsInf[num++], "SIM卡状态:异常");
    }

    if (pd[2] == 1)
    {
        strcpy(strGprsInf[num++], "PPP拨号  :正常");
    }
    else
    {
        strcpy(strGprsInf[num++], "PPP拨号  :异常");
    }

    sprintf(strGprsInf[num++], "信号强度 :%2d", pd[9]);
    sprintf(strGprsInf[num++], "IP:%d.%d.%d.%d", pd[19], pd[20], pd[21], pd[22]);

    if (pd[10] == 1)
    {
        strcpy(strGprsInf[num++], "频段:900MHz");
    }
    else
    {
        strcpy(strGprsInf[num++], "频段:1800MHz(其他)");
    }

    sprintf(strGprsInf[num++], "ICMP延时:%d ms", (pd[24] | (pd[23] << 8)));

    sprintf(strGprsInf[num++], "上传字节数:%d", (pd[34] | (pd[33] << 8) | (pd[32] << 16) | (pd[31] << 24)));
    sprintf(strGprsInf[num++], "下载字节数:%d", (pd[38] | (pd[37] << 8) | (pd[36] << 16) | (pd[35] << 24)));

    g_gprs_info_num = num;

    return num;
}

int mmd_AuotGprsInf(void)
{
    int num;

    num = mmd_get_gprs_info();
    if (num)
    {
        g_tDataMenu1.sTotalNum = num; // 总的动态菜单数
    }

    mmd_RenewGprsInf();
    return M_OK;
}

u8 *goosefilebuf = NULL;
u8 *gooseinfbuf;
struct file *goosepfile = NULL;

int gooseinflenth = 0;
int gooseinfbgn = 0;

void mmd_printgooseinf(void)
{
    int i;
    DATA_MENU_DEF *pt = &g_tDataMenu1;
    int num = 0;
    u8 *buf = gooseinfbuf;
    char *ptstr;
    pt->sFocusIndex = 0;

    for (i = 0; i < 9; i++)
    {
        sprintf(pt->tDataFields[i].FmtStr, "%20.20s", " ");
    }

    if (gooseinfbgn >= gooseinflenth)
        return;
    ptstr = pt->tDataFields[pt->sFocusIndex].FmtStr;
    for (i = gooseinfbgn; i < gooseinflenth; i++)
    {
        if (buf[i] == 0x0A)
        {
            ptstr[20] = 0;
            pt->sFocusIndex++;
            if (pt->sFocusIndex >= 9)
            {
                i++;
                break;
            }
            num = 0;
            ptstr = pt->tDataFields[pt->sFocusIndex].FmtStr;
        }
        else if (buf[i] < 0x20)
        {
        }
        else
        {
            ptstr[num++] = buf[i];
            if (buf[i] > 0x80)
            {
                ptstr[num++] = buf[i + 1];
                i += 1;
            }
            if (num >= 19)
            {
                ptstr[20] = 0;
                pt->sFocusIndex++;
                if (pt->sFocusIndex >= 9)
                {
                    i++;
                    break;
                }
                num = 0;
                ptstr = pt->tDataFields[pt->sFocusIndex].FmtStr;
            }
        }
    }
    ptstr[20] = 0;
    gooseinfbgn = i;
    pt->sFocusIndex = 0; // 第一个显示的动态菜单的索引
    pt->sTotalNum = 9;   // 总的动态菜单数
    pt->sScreenNum = 9;
    pt->GetPrevFuncAddr = NULL; // 44
    pt->GetNextFuncAddr = NULL; // 44
    pt->GetValueFuncAddr = NULL;
}

int mmd_GetGooseInf(int value)
{
    u32 i, file_length;
    struct file *pfile;
    u8 *filebuf;
    u8 filestr[256], *pstr, strlenth;
    loff_t pos;
    // 打开文件
    pfile = rt_file_open("/tmp/kmsg", O_RDONLY, 0);
    if (IS_ERR(pfile))
    {
        sprintf(m_WarningStr, "无法打开kmsg文件");
        return M_JUMP3;
    }

    // 得到文件长度
    file_length = rt_file_getfile_size(pfile);
    if (file_length <= 0)
    {
        rt_file_close(pfile, 0);
        sprintf(m_WarningStr, "kmsg文件长度=0");
        return M_JUMP3;
    }

    // 分配内存
    filebuf = rt_malloc(file_length);
    if ((filebuf) == NULL)
    {
        rt_file_close(pfile, 0);
        sprintf(m_WarningStr, "内存分配失败");
        return M_JUMP3;
    }

    pos = 0;
    if (rt_file_read(pfile, filebuf, file_length, &pos) != file_length)
    {
        rt_file_close(pfile, 0);
        rt_free(filebuf);
        sprintf(m_WarningStr, "kmsg读取失败");
        return M_JUMP3;
    }
    pstr = filestr;
    strlenth = 0; // 纠错处理
    // 找到\r\n位置，得到一行长度
    for (i = 0; i < file_length; i++)
    {
        *pstr++ = filebuf[i];
        strlenth++;
        if (filebuf[i] == 0x0a || strlenth >= 256)
        {
            *pstr = 0;
            pstr = filestr;
            if (strstr(filestr, "goose_init...")) //
            {
                goosefilebuf = filebuf;
                goosepfile = pfile;
                gooseinfbuf = &filebuf[i + 1];
                gooseinfbgn = 0;
                gooseinflenth = file_length - i;
                mmd_printgooseinf();
                return M_JUMP0;
            }
        }
    }
    rt_file_close(pfile, 0); // 关闭文件
    rt_free(filebuf);        // 释放内存
    sprintf(m_WarningStr, "未找到 goose信息");
    return M_JUMP3;
}

int mmd_gooseKey(int key)
{
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //	老版本按键6键，左键为取消键
    {
        rt_file_close(goosepfile, 0); // 关闭文件
        rt_free(goosefilebuf);        // 释放内存
        return M_JUMP1;
    }

    if (key == HA_KEY_ENTER)
    {
        mmd_printgooseinf();
    }
    return M_OK;
}

/**************************************************************************
函数名称：mmd_InitDefaultEquipSet
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：恢复出厂设置，定值，定值区信息，压板，内部定值，参数均设为默认值，
              清事件记录、操作记录，运行定值区0 ，有效区一个 0
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_InitDefaultEquipSet(int value)
{
    if (rt_err_test(ERR_CODE_FACTOR)) // 装置配置若校验错误，置为默认值，若正确，不做处理
    {
        // 恢复错误的系数，正确的保留
        factor_restore_default();
        log_str_time(LOG_OPERATE, "装置恢复默认校准系数", 0, 0);
    }
    init_default_equip_set(0);
    strcpy(m_WarningStr, "恢复为出厂设置");
    return M_JUMP3;
}

int mmd_SoftReset(int value)
{
    watchdog_reset_cpu(3);
    return M_OK;
}

/*下面是远动测试的内容*/

double GetYdYcValue(int i)
{
    double ff;
    int ycvalue;
    DWORD lmeaval = 0;
    long lzero = 0;
    BYTE no = g_ac_table[i].indexno;
    u8 link_qds = 0;
    int sw = g_ac_table[i].owner;

    if (no > 0)
    {
        DWORD dwMax;
        DWORD dwDeadVal;
        float rate;
        float f_65536 = 65536.0;
        no -= 1;
        rate = (float)g_ac_table[i].rate / 65536.0;
        dwMax = (DWORD)g_ac_table[i].normal;
        // dwMax = (tRunPara.bDeadType==true) ? (DWORD)g_ac_table[i].normal:_AbsL(pt104->yc_save[i]);
        if (dwMax == 0) // 防止额定或者前一次保存值为0
            dwMax = 1;
        dwDeadVal = _Mul_Div_U(g_ac_table[i].dead_value, dwMax, 6553600);
        if (dwDeadVal == 0)
            dwDeadVal = 1;
        if (dwMax == 0)
            f_65536 = 1.0;
#if 0 // 远动测试情况下遥测数据测试值锁定功能 此处暂不开启
        lmeaval=GetRmtMeaVal(g_ac_table[i].owner,no,&link_qds);
#else

        if (sw == 0) // 公共测量值
        {
            if (no < PUB_AC_NUM_ALL)
            {
                lmeaval = g_sw_pub.ac_in[no];
            }
            lzero = g_unit[g_pub_ac_desc[no].unit].zero;
        }
        else if (sw <= SWITCH_NUM_EXT)
        {
            sw -= 1;
            if (no < SW_AC_NUM_ALL)
            {
                lmeaval = g_sw[sw].ac_in[no];
                if (link_qds)
                {
                    link_qds = g_sw[sw].link_qds[no];
                }
            }
            lzero = g_unit[g_sw_ac_desc[no].unit].zero;
        }

        if (lzero > 0 && _AbsL(lmeaval) < lzero && pRunSet->bTT_RET_ZERO)
        {
            lmeaval = 0;
        }

#endif
        // rt_printf("%d--",lmeaval);
        ff = ((double)lmeaval) / f_65536 * rate; // 转为浮点数

#ifdef VOLT_ADAPTIVE_FACTOR
        if (pRunSet->bTT_AdaptiveFactor)
        {
            if (0 == g_ac_table[i].owner)
            {
                if ((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
                {
                    ff = ((double)lmeaval) / f_65536 * 10 / pRunSet->a_pt_two;
                }
                else if ((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
                {
                    ff = ((double)lmeaval) / f_65536 * 10 / pRunSet->b_pt_two;
                }
            }
        }
#endif

        ycvalue = (int)rt_round(ff);
        if (tRunPara.bYcFloat)
        {
            if (_AbsL(lmeaval) > (dwMax * 10)) // 大于额定值的10倍*65536
            {
                // if(dwMax>0)QDS|=0x01;       //遥测溢出
            }
        }
        else
        {
            if (ycvalue >= 0)
            {
                if (ycvalue > 32767)
                {
                    ycvalue = 32767;
                    // QDS|=0x01;      //遥测溢出
                }
            }
            else
            {
                if (ycvalue < (-32768))
                {
                    ycvalue = -32768;
                    // QDS|=0x01;      //遥测溢出
                }
            }
        }
    }
    else // 备用点号，数值上送0
    {
        ycvalue = 0;
        ff = 0;
    }

    return ff;
}

static void mmd_GetRmtYCValue(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
    char tmpstr[16];
#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
    char flag = 0; // 溢出标志
    double v;
#endif
    strcpy(pd, "");
    if (g_ac_table[i].indexno != 0)
    {
#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
        tbl_getname(RES_TYPE_YC, i, pd);
#else
        tbl_getacname(g_ac_table[i].owner, g_ac_table[i].indexno, pd);
#endif
    }
    else
    {
        sprintf(pd, "备用遥测%d", i + 1);
    }

#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
    strcpy(tmpstr, "");
    v = GetYdYcValue(i);
    if ((v < -99999) || (v > 999999))
        flag = 1;
    sprintf(tmpstr, "%.4lf", v);
#if LCD_SIZE == 128
    sprintf(pd, "%-13.13s %s", pd, tmpstr);
#else
    if ((g_ac_table[i].owner) && (g_ac_table[i].indexno >= 21) && (g_ac_table[i].indexno <= 32))
    {
        if (flag)
            sprintf(pd, "%-12.12s : over", pd);
        else
            sprintf(pd, "%-12.12s :%-6.6s", pd, tmpstr);
    }
    else
        sprintf(pd, "%-8.8s :%-10.10s", pd, tmpstr);
#endif

#else
    sprintf(tmpstr, " :%.2f", (float)g_ac_table[i].normal / (65536 * 2)); // 额定值的一半
    strcat(pd, tmpstr);
#endif
}

/**************************************************************************
函数名称：mmd_RenewMea
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：刷新测量值显示
输入参数：


输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_RenewRmtYC(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetMea
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得测量值的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_GetRmtYC(int value)
{

    mmd_initDataMenu(&g_tDataMenu1, g_table_head->ac_num, mmd_RenewRmtYC, mmd_GetRmtYCValue, 126, 1);
    return M_OK;
}

/*下面是遥信测试处理*/

static void mmd_GetRmtYXValue(int i, DATA_FIELD_DEF *pF)
{
    char *pd = pF->FmtStr;
#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
    u8 data = 0;
    int sz_index;
    char valStr[5] = "";
#endif

    strcpy(pd, "");
    if (g_di_table[i].indexno == 0)
    {
        bool bMix = true;
        int m;
        for (m = 0; m < g_table_head->di_db_num; m++) // 双点
        {
            if (g_di_table[i].cp == g_di_db_table[m].cp)
            {
#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
                sz_index = tbl_get_sz_index_yx(i); // 找到双点在sz_table的位置(双点+x+x)
                // sz_index+=1;                          //合并点显示第一行名称
                if (tbl_getname_sz(RES_TYPE_YX, sz_index, pd) < 0)
#endif
                    tbl_getdiname(((g_di_db_table[m].no[0] >> 8) & 0xff), (g_di_db_table[m].no[0] & 0xff), pd);
                // sprintf(pd,"%s-%d-%d",pd,sz_index,i);
                strcat(pd, " (双点) ");
                bMix = false;
                break;
            }
        }
        if (bMix) // 合并点
        {
            for (m = 0; m < g_table_head->dimerge_num; m++)
            {
                if (g_di_table[i].cp == g_di_merge_table[m].cp)
                {
#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
                    sz_index = tbl_get_sz_index_yx(i); // 找到双点在sz_table的位置(合并点+x+x)
                    // sz_index+=1;                          //合并点显示第一行名称
                    if (tbl_getname_sz(RES_TYPE_YX, sz_index, pd) < 0)
#endif
                        // tbl_getdiname(((g_di_merge_table[m].no[0]>>12)&0x0f),(g_di_merge_table[m].no[0]&0xff),pd);
                        tbl_getdiname(((g_di_merge_table[m].no[0] >> 8) & 0xff), (g_di_merge_table[m].no[0] & 0xff), pd); // 高八位的低四位为归属 没有实点属性
                    strcat(pd, " (合并点) ");
                    bMix = false;
                    break;
                }
            }
        }
        if (bMix)
            sprintf(pd, "备用遥信%d", i + 1);
    }
    else
    {
#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
        tbl_getname(RES_TYPE_YX, i, pd);
#else
        tbl_getdiname(g_di_table[i].owner, g_di_table[i].indexno, pd);
#endif
    }

#ifdef YD_TEST_REALTIME_VALUE_DISPLAY
    data = tbl_get_yx(i, 1);
#if 1
    if (data == 1)
        strcpy(valStr, "  分");
    else if (data == 2)
        strcpy(valStr, "  合");
    else
        strcpy(valStr, "非法");

#endif

#if LCD_SIZE == 128
    sprintf(pd, "%-13.13s %d", pd, data);
#else
    // sprintf(pd,"%-16.16s %d",pd,data);
    sprintf(pd, "%-14.14s %-4.4s", pd, valStr);
#endif
#endif
}

/**************************************************************************
函数名称：mmd_RenewRmtYX
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：刷新遥信显示
输入参数：


输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_RenewRmtYX(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetRmtYX
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得遥信值的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_GetRmtYX(int value)
{

    mmd_initDataMenu(&g_tDataMenu1, g_table_head->di_num, mmd_RenewRmtYX, mmd_GetRmtYXValue, 124, 1);
    return M_OK;
}

int mmd_CheckRmtTbl(int value)
{
    if (rt_err_test(ERR_CODE_IEC_TABLE))
    {
        strcpy(m_WarningStr, "转发表加载错误!");
        return M_JUMP3;
    }
    return M_JUMP0;
}

int mmd_GetRmtIndex(int value)
{
    g_RmtIndex = value;
    sprintf(m_YdYcHalfOfRateValue, ":%.2f", (float)g_ac_table[g_RmtIndex].normal / (65536 * 2)); // 额定值的一半
    return M_OK;
}

int mmd_SendRmtYX(int value)
{
    int i = g_RmtIndex;
    u8 type = 0;
    u8 buf[12];
    if (g_di_table[i].indexno == 0)
    {
        int m;
        for (m = 0; m < g_table_head->di_db_num; m++) // 双点
        {
            if (g_di_table[i].cp == g_di_db_table[m].cp)
            {
                type = 3;
            }
        }
        for (m = 0; m < g_table_head->dimerge_num; m++)
        {
            if (g_di_table[i].cp == g_di_merge_table[m].cp)
            {
                type = 4;
            }
        }
    }

    // 点表类型
    buf[2] = type;
    // 点号
    buf[3] = (u8)g_di_table[i].cp;
    buf[4] = (u8)(g_di_table[i].cp >> 8);

    // 归属
    buf[5] = g_di_table[i].owner;
    // 实点、虚点
    buf[6] = 0;
    // 资源表中索引
    buf[7] = g_di_table[i].indexno;
    buf[8] = value;
    buf[9] = 0;
    buf[10] = 0;
    buf[11] = 0;
    send_rmt_yx(buf);
    g_run_stu.bHmiRmtTest = true;
    return M_OK;
}

int mmd_SendRmtYC(int value)
{
    DWORD val;
    u8 buf[12];
    val = g_ac_table[g_RmtIndex].normal / 2; // 额定值的一半
    buf[5] = g_ac_table[g_RmtIndex].owner;
    buf[7] = g_ac_table[g_RmtIndex].indexno;
    buf[8] = (u8)(val >> 0);
    buf[9] = (u8)(val >> 8);
    buf[10] = (u8)(val >> 16);
    buf[11] = (u8)(val >> 24);
    send_rmt_yc(buf);
    g_run_stu.bHmiRmtTest = true;
    return M_OK;
}

int mmd_SendRmtDD(int value)
{
    DWORD val;
    u8 buf[12];
    val = g_dd_table[g_RmtIndex].normal / 2; // 额定值的一半
    buf[5] = g_ac_table[g_RmtIndex].owner;
    buf[7] = g_ac_table[g_RmtIndex].indexno;
    buf[8] = (u8)(val >> 0);
    buf[9] = (u8)(val >> 8);
    buf[10] = (u8)(val >> 16);
    buf[11] = (u8)(val >> 24);
    send_rmt_dd(buf);
    g_run_stu.bHmiRmtTest = true;
    return M_OK;
}

// 电度远动测试
static void mmd_GetRmtDDValue(int i, DATA_FIELD_DEF *pF)
{

    char *pd = pF->FmtStr;
    char tmpstr[16];
    strcpy(pd, "");
    // if(g_dd_table[i].indexno!=0)
    if ((g_dd_table[i].indexno > 0) && (g_dd_table[i].indexno <= SW_DD_NUM_ALL))
    {
        tbl_getddname(g_dd_table[i].owner, g_dd_table[i].indexno, pd);
    }
    else
    {
        sprintf(pd, "备用电度%d", i + 1);
    }
    sprintf(tmpstr, " :%.2f", (float)g_dd_table[i].normal / (65536 * 2)); // 额定值的一半
    strcat(pd, tmpstr);
}

/**************************************************************************
函数名称：mmd_RenewMea
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：刷新测量值显示
输入参数：


输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

int mmd_RenewRmtDD(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}
/**************************************************************************
函数名称：mmd_GetMea
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：取得测量值的显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int mmd_GetRmtDD(int value)
{

    mmd_initDataMenu(&g_tDataMenu1, g_table_head->dd_num, mmd_RenewRmtDD, mmd_GetRmtDDValue, 128, 1);
    return M_OK;
}

int mmd_Jump0(int value)
{
    return M_JUMP0;
}

int mmd_BatActive(int value)
{
    if (bat_active(1) != 0)
    {
        strcpy(m_WarningStr, "电池活化启动失败!");
        rt_printf("%s\r\n", m_WarningStr);
        return M_JUMP3;
    }
    return M_JUMP0;
}

int mmd_BatActOff(int value)
{
#ifdef BATTERY_WITH_COMM
    StopBattAct();
#else
    if (sw_do_pub(PUB_DO_HHTC, SW_DO_TYPE_ON) != 0)
    {
        strcpy(m_WarningStr, "电池活化退出失败!");
        rt_printf("%s\r\n", m_WarningStr);
        return M_JUMP3;
    }
    soe_record_opt(EV_BAT_HANDACTOFF, 1);
#endif

    return M_JUMP0;
}

/**************************************************************************
函数名称：mmd_InitDefaultEquipSet
函数版本：1.00
作者：
创建日期：2008.9.1
函数功能说明：恢复出厂设置，定值，定值区信息，压板，内部定值，参数均设为默认值，
              清事件记录、操作记录，运行定值区0 ，有效区一个 0
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int init_default_equip_set(int value)
{
    int i;
    e2prom_reinit();
    GetDefPara((float *)m_SetBuf, EQUIP_PARA_NUMBER, &tEquipParaTable[0]); // 装置参数默认
    // 调试网口参数做特殊处理。调试网口的默认参数以UBOOT中的环境变量为默认值.
    GetDefDebugNetPara();
    SavePara((void *)m_SetBuf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0]);

#ifdef PUB_SET_SECTION
    for (i = 0; i < SEC_NUMBER; i++)
    {
        GetDefPara((float *)&m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]); // 定值默认
        SavePara((void *)&m_SetBuf, EEP_PUB_ADDR + i * PUB_SETSIZE, PUB_SET_NUMBER, &tPubSetTable[0]);
    }

#else
    GetDefPara((float *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]); // 定值默认
    SavePara((void *)m_SetBuf, EEP_PUB_ADDR, PUB_SET_NUMBER, &tPubSetTable[0]);
#endif

    for (i = 0; i < SEC_NUMBER; i++)
    {
        GetDefPara((float *)m_SetBuf, SW_SET_NUMBER, &tSwSetTable[0]); // 定值默认
        SavePara((void *)m_SetBuf, EEP_SET_ADDR + i * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]);
    }

    GetDefPara((float *)m_SetBuf, CSTSET_NUMBER, &tCstSetTable[0]); // 定值默认
    SavePara((void *)m_SetBuf, EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0]);
    m_runsection = 0; // 当前运行定值区为 0区

#ifdef PASSWORD_4_STR
    SavePassword(INIT_PASSWORD_STR_4);  // 密码初始化
    SavePassword2(INIT_PASSWORD_STR_4); // 密码初始化
#else
    SavePassword(INIT_PASSWORD_STR);  // 密码初始化
    SavePassword2(INIT_PASSWORD_STR); // 密码初始化
#endif

    soe_clear_ev();                   // 清事件记录
    soe_clear_opt();                  // 清操作记录
    soe_record_opt(EV_INIT_EQUIP, 0); // 记录操作记录
    MakeRunSet(true);                 // 将当前运行定值区转换为运行定值区
    MakeRunPara(false, true);         // 转换参数到运行参数区
    SaveUqua(true);
    GetDefSetGroup(m_setgroup);
    SaveEppData(EEP_SETGROUP_ADDR, m_setgroup, GROUP_NUM);
    {
        extern int led_save_flag; // 当前灯状态保存一下
        led_save_flag = 1;
    }
    rt_printf("恢复为出厂设置\r\n");
    return 0;
}
extern int gprs_net_get_gprs_info(void);

/******************************************************************************
函数名称：	gprs_get_info
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2014-12-30
函数说明：	获取当前屏分配的实体数
参数说明：	无
返回值：  	成功返回0.
修改记录：
*/
int gprs_get_info(void)
{
    u8 *pd = tGprsInf.data;
    int num = 0;

    // 获取内部GPRS状态信息
    num = mmd_get_gprs_info();

    g_gprs_info_num = num;
    if (num > 0)
    {
        return num;
    }

    if (!tGprsInf.bInf)
    {
        return 0;
    }
    tGprsInf.bInf = false;

    if ((pd[0] | (pd[1] << 8)) == 0x0001)
    {
        strcpy(strGprsInf[num++], "模块状态 :正常");
    }
    else
    {
        strcpy(strGprsInf[num++], "模块状态 :异常");
    }

    if ((pd[2] | (pd[3] << 8)) == 0x0001)
    {
        strcpy(strGprsInf[num++], "SIM卡状态:正常");
    }
    else
    {
        strcpy(strGprsInf[num++], "SIM卡状态:异常");
    }

    if ((pd[4] | (pd[5] << 8)) == 0x0001)
    {
        strcpy(strGprsInf[num++], "PPP拨号  :正常");
    }
    else
    {
        strcpy(strGprsInf[num++], "PPP拨号  :异常");
    }

    sprintf(strGprsInf[num++], "信号强度 :%2d", (pd[16] | (pd[17] << 8)));
    // SIM卡IP
    sprintf(strGprsInf[num++], "%d.%d.%d.%d", pd[36], pd[37], pd[38], pd[39]);

    // CH1是否正常，端口是多少,IP1
    if ((pd[6] | (pd[7] << 8)) == 0x0001)
    {
        sprintf(strGprsInf[num++], "CH1:正常 %d", (pd[44] | (pd[45] << 8)));
    }
    else
    {
        sprintf(strGprsInf[num++], "CH1:异常 %d", (pd[44] | (pd[45] << 8)));
    }
    sprintf(strGprsInf[num++], "%d.%d.%d.%d", pd[40], pd[41], pd[42], pd[43]);

    // CH2是否正常，端口是多少,IP2
    if ((pd[8] | (pd[9] << 8)) == 0x0001)
    {
        sprintf(strGprsInf[num++], "CH2:正常 %d", (pd[50] | (pd[51] << 8)));
    }
    else
    {
        sprintf(strGprsInf[num++], "CH2:异常 %d", (pd[50] | (pd[51] << 8)));
    }
    sprintf(strGprsInf[num++], "%d.%d.%d.%d", pd[46], pd[47], pd[48], pd[49]);

    strcpy(strGprsInf[num++], "频段:自适应");
    strcpy(strGprsInf[num++], "流量(秒):");
    sprintf(strGprsInf[num++], "%d", (pd[26] | (pd[27] << 8) | (pd[28] << 16) | (pd[29] << 24)));
    strcpy(strGprsInf[num++], "流量(B) :");
    sprintf(strGprsInf[num++], "%d", (pd[30] | (pd[31] << 8) | (pd[32] << 16) | (pd[33] << 24)));

    if ((pd[14] | (pd[15] << 8)) == 0x0001)
    {
        strcpy(strGprsInf[num++], "重启状态:重启");
    }
    else
    {
        strcpy(strGprsInf[num++], "重启状态:未重启");
    }

    g_gprs_info_num = num;

    return num;
}

int mmd_FreshTime(void)
{
    struct timespec ts;
    struct rtc_time_t rtc;
    clk_time_get(&ts);
    timespec_to_rtc(ts, &rtc, 1);
    m_ShowTime.year = rtc.year; // 显示时间刷新
    m_ShowTime.month = rtc.month;
    m_ShowTime.day = rtc.day;
    m_ShowTime.hour = rtc.hour;
    m_ShowTime.min = rtc.min;
    m_ShowTime.sec = rtc.ms / 1000;
    return M_OK;
}

extern unsigned int s_stat_get(int chnl, int type);
void mmd_freshmainunit(bool bfirst)
{
    MAIN_IMAGE_DEF *pm = &g_tLcdComm.tImage;
    int i;
    u8 owner, index;
    for (i = 0; i < pm->sYxNum; i++) // 遥信都转为双点处理
    {
        int val = 0;
        DWORD dotaddr;
        bool bfresh = false;
        D_UNIT_DEF *pu = &pm->tYxUnits[i];
        owner = (u8)(pu->yx_di >> 8);
        index = (u8)(pu->yx_di >> 0);
        if (owner == 0xFF) //  特殊遥信若充电标志等
        {
            if (index == 1) // 0xff01 为充电标志
            {
                int sw;
                bool bcd = false;
                for (sw = 0; sw < g_sw_num; sw++)
                {
                    RUN_STU_SW *prun = &g_tRelay[sw].run_stu;
                    bcd |= (prun->goose_qccd || prun->goose_glcd || prun->goose_ll_cd);
                }

                val = ((g_run_stu.cd > 0) || bcd) ? 2 : 1;
            }
        }
        else if (owner >= 0x20) // 板卡遥信
        {
            val = dido_di_is_on(owner - 0x20, index) + 1;
        }
        else
        {
            val = GetRmtYxVal(owner, index);
        }
        if (bfirst)
        {
            bfresh = true;
        }
        else if (pu->yx_value != val)
        {
            bfresh = true;
        }
        pu->yx_value = val;
        if (bfresh)
        {
            dotaddr = pu->addr_open;
            if (val == 1)
            {
                dotaddr = pu->addr_open;
            }
            else if (val == 2)
            {
                dotaddr = pu->addr_close;
            }
            else if (pu->yx_attrib != 0)
            {
                dotaddr = pu->addr_third;
            }
            lcd_DrawImage(pu->sx, pu->sy, &pm->pBuf[dotaddr], 0); // 主接线
        }
    }
    for (i = 0; i < pm->sYcNum; i++)
    {
        YC_UNIT_DEF *py = &pm->tYcUnits[i];
        owner = (u8)(py->yc_di >> 8);
        index = (u8)(py->yc_di >> 0);
        if (owner == 0xff) // 特殊遥测，管理板使用
        {
            int chnl, type;
            u32 ubytes = 0;
            float fbytes;
            u8 fmtstr[20];

            chnl = (index >> 4) & 0x0f;
            type = (index) & 0x0f;
            if (chnl > COMM_CHANNEL_NUM)
                return;
            ubytes = s_stat_get(chnl, type);
            strcpy(fmtstr, "%*6uB");
            if (ubytes >= 10000)
            {
                fbytes = ubytes;
                fbytes /= 1024;
                if (fbytes >= 1000)
                {
                    fbytes /= 1024;
                    if (fbytes >= 1000)
                    {
                        strcpy(fmtstr, "%*6.1fM");
                    }
                    else if (fbytes >= 100)
                    {
                        strcpy(fmtstr, "%*6.2fM");
                    }
                    else if (fbytes >= 10)
                    {
                        strcpy(fmtstr, "%*6.3fM");
                    }
                    else
                    {
                        strcpy(fmtstr, "%*6.4fM");
                    }
                }
                else
                {
                    if (fbytes >= 100)
                    {
                        strcpy(fmtstr, "%*6.2fK");
                    }
                    else if (fbytes >= 10)
                    {
                        strcpy(fmtstr, "%*6.3fK");
                    }
                }
                fmt_Printf(py->sx / 8, py->sy, MMI_FOCUS_ASC5_7, fmtstr, (void *)(&fbytes));
            }
            else
            {
                fmt_Printf(py->sx / 8, py->sy, MMI_FOCUS_ASC5_7, fmtstr, (void *)(&ubytes));
            }
        }
        else
        {
            float ycdata;
            if (index == 0)
            {
                ycdata = 0;
            }
            else
            {
                ycdata = GetRmtMeaVal(owner, index - 1, NULL) / 65536.0;
            }
            fmt_Printf(py->sx / 8, py->sy, MMI_FOCUS_ASC5_7, (char *)py->fmtstr, (void *)(&ycdata));
        }
    }
}

int mmd_freshmain(void)
{
    mmd_freshmainunit(false);
    return M_OK;
}
unsigned char m_LockIcon[2];
int mmd_mainimageKey(int key)
{

    if (key == HA_KEY_ENTER) //
    {
        g_tLcdComm.bLock = !g_tLcdComm.bLock;
        if (g_tLcdComm.bLock)
            m_LockIcon[0] = '\1';
        else
            m_LockIcon[0] = ' ';
        m_LockIcon[1] = 0;
    }
    if (key == ((g_tScreen.lcd_type == LCD_TYPE_6KEY) ? HA_KEY_LEFT : HA_KEY_ESC)) //   老版本按键6键，左键为取消键
    {
        g_tLcdComm.bLock = false;
        m_LockIcon[0] = ' ';
        m_LockIcon[1] = 0;
    }
    return M_OK;
}

int mmd_ClearQUA(int value)
{
    SaveUqua(true);
    strcpy(m_WarningStr, "电压合格率清零");
    return M_JUMP3;
}

int mmd_ClearIMP(int value)
{
    int sw;
    for (sw = 0; sw < SWITCH_NUM_MAX; sw++)
    {
        g_sw[sw].ac_in[SW_AC_IN_IMP1] = 0;
        g_sw[sw].ac_in[SW_AC_IN_IMP2] = 0;
    }
    strcpy(m_WarningStr, "脉冲计数值清零");
    return M_JUMP3;
}
int mmd_FA_Unlock(int value)
{
    g_run_stu.rmtjs = true;
#ifdef FUNC_ONLY_MMD_JS
    g_run_stu.b_mmdjs = true;
#endif
    strcpy(m_WarningStr, "FA闭锁解除");
    return M_JUMP3;
}
int mmd_testKey(int key)
{
    if (key == HA_KEY_LEFT)
        strcpy(m_WarningStr, "左键  ");
    else if (key == HA_KEY_RIGHT)
        strcpy(m_WarningStr, "右键  ");
    else if (key == HA_KEY_UP)
        strcpy(m_WarningStr, "上键  ");
    else if (key == HA_KEY_DOWN)
        strcpy(m_WarningStr, "下键  ");
    else if (key == HA_KEY_ENTER)
        strcpy(m_WarningStr, "确认键  ");
    else if (key == HA_KEY_ESC)
        strcpy(m_WarningStr, "取消键  ");
    else if (key == HA_KEY_RST)
        strcpy(m_WarningStr, "复归键  ");
    else if (key == HA_KEY_ADD)
        strcpy(m_WarningStr, "加键  ");
    else if (key == HA_KEY_SUB)
        strcpy(m_WarningStr, "减键  ");
    else
        return M_JUMP0;
    return M_OK;
}
int mmd_clearWarnStr(int val)
{
    strcpy(m_WarningStr, "");
    return M_OK;
}

int mmd_DIDOTest(int value)
{
    char tmpbuf[8], tmpstr[4];
    int i;
    bool bs = false;
    tmpbuf[0] = 1; // DO板卡
    tmpbuf[1] = 1; // DI板卡
    dido_auto_test(tmpbuf, 1);
    if (dido_buf[1]) // 开出异常
    {
        strcpy(m_WarningStr, "开出");
        for (i = 0; i < 5; i++)
        {
            if ((dido_buf[1] >> i) & 0x01)
            {
                sprintf(tmpstr, "%d ", i + 1);
                strcat(m_WarningStr, tmpstr);
            }
        }
        strcat(m_WarningStr, "异常");
        return M_JUMP3;
    }
    strcpy(m_WarningStr, "开入");
    if (dido_buf[6]) // 开如 1-8异常
    {
        bs = true;
        for (i = 0; i < 8; i++)
        {
            if ((dido_buf[6] >> i) & 0x01)
            {
                sprintf(tmpstr, "%d ", i + 1);
                strcat(m_WarningStr, tmpstr);

                if (strlen(m_WarningStr) >= 15)
                {
                    strcat(m_WarningStr, "异常");
                    return M_JUMP3;
                }
            }
        }
    }
    if (dido_buf[7]) // 开如 1-8异常
    {
        bs = true;
        for (i = 0; i < 8; i++)
        {
            if (((dido_buf[7] >> i) & 0x01) && bs)
            {
                sprintf(tmpstr, "%d ", i + 9);
                strcat(m_WarningStr, tmpstr);

                if (strlen(m_WarningStr) >= 15)
                {
                    strcat(m_WarningStr, "异常");
                    return M_JUMP3;
                }
            }
        }
    }
    if (dido_buf[8]) // 开如 1-8异常
    {
        bs = true;
        for (i = 0; i < 8; i++)
        {
            if (((dido_buf[8] >> i) & 0x01) && bs)
            {
                sprintf(tmpstr, "%d ", i + 17);
                strcat(m_WarningStr, tmpstr);
                if (strlen(m_WarningStr) >= 15)
                {
                    strcat(m_WarningStr, "异常");
                    return M_JUMP3;
                }
            }
        }
    }
    if (bs)
    {
        strcat(m_WarningStr, "异常");
    }
    else
    {
        strcpy(m_WarningStr, "开入开出测试正常");
    }

    return M_JUMP3;
}

static void mmd_GetSetGroupValue(int i, DATA_FIELD_DEF *pF)
{
    int index;
    if (m_setgroup[i])
    {
        sprintf(pF->FmtStr, "%-16.16s 投", SetGroups[i].item_name);
    }
    else
    {
        sprintf(pF->FmtStr, "%-16.16s 退", SetGroups[i].item_name);
    }
    index = mmi_GetActiveFieldIndex();
    sprintf(m_equipstr, "%s", SetGroups[index].group_name);
}

int mmd_RenewSetGroup(void)
{
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}

int mmd_InitSetGroup(int value)
{
    bool bret;
    bret = ReadEppData(EEP_SETGROUP_ADDR, m_setgroup, GROUP_NUM);
    if (!bret)
    {
        GetDefSetGroup(m_setgroup);
    }
    mmd_initDataMenu(&g_tDataMenu1, GROUP_NUM, mmd_RenewSetGroup, mmd_GetSetGroupValue, 188, 1);
    return M_OK;
}

int mmd_ChangeSetGroup(int value)
{
    int index = mmi_GetActiveFieldIndex();

    if (m_setgroup[index])
    {
        m_setgroup[index] = 0;
    }
    else
    {
        m_setgroup[index] = 1;
    }
    mmd_RenewDataMenu(&g_tDataMenu1);
    return M_OK;
}

int mmd_SaveSetGroup(int value)
{
    SaveEppData(EEP_SETGROUP_ADDR, m_setgroup, GROUP_NUM);
    return M_JUMP0;
}

WORD m_srcsection;
WORD m_dstsection;
WORD m_maxsection;
int mmd_changesection(int value)
{
#ifdef PUB_SET_SECTION
    int i;
#endif

    if (m_dstsection >= SEC_NUMBER || m_runsection == m_dstsection)
    {
        strcpy(m_WarningStr, "切换区号异常");
        return M_JUMP3;
    }
    // 切换定值区，重新初始化运行定值区
    m_runsection = m_dstsection;

#ifdef PUB_SET_SECTION
    for (i = 0; i < SEC_NUMBER; i++)
    {
        /*读取公共定值*/
        if (!ReadPara((void *)m_SetBuf, EEP_PUB_ADDR + PUB_SETSIZE * i, PUB_SET_NUMBER, &tPubSetTable[0]))
        {
            rt_err_set(ERR_CODE_SET_PUB, 0);
            GetDefPara((void *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]);
        }
        else
        {
            rt_err_clr(ERR_CODE_SET_PUB, 0);
        }
        m_SetBuf[SET_SECTION].ff = m_dstsection;
        SavePara((void *)m_SetBuf, EEP_PUB_ADDR + PUB_SETSIZE * i, PUB_SET_NUMBER, &tPubSetTable[0]);
        if (i == m_runsection)
        {
            MakeRunSet(false);
        }
    }

#else
    /*读取公共定值*/
    if (!ReadPara((void *)m_SetBuf, EEP_PUB_ADDR, PUB_SET_NUMBER, &tPubSetTable[0]))
    {
        rt_err_set(ERR_CODE_SET_PUB, 0);
        GetDefPara((void *)m_SetBuf, PUB_SET_NUMBER, &tPubSetTable[0]);
    }
    else
    {
        rt_err_clr(ERR_CODE_SET_PUB, 0);
    }
    m_SetBuf[SET_SECTION].ff = m_dstsection;
    SavePara((void *)m_SetBuf, EEP_PUB_ADDR, PUB_SET_NUMBER, &tPubSetTable[0]);
    MakeRunSet(false);

#endif
    return M_JUMP0;
}

int mmd_copysection(int value)
{
    if (m_runsection == m_dstsection)
    {
        strcpy(m_WarningStr, "运行区不能复制");
        return M_JUMP3;
    }
    if (m_dstsection >= SEC_NUMBER || m_srcsection >= SEC_NUMBER)
    {
        strcpy(m_WarningStr, "区号超出范围");
        return M_JUMP3;
    }

    /*读取公共定值*/
    if (!ReadPara((void *)m_SetBuf, EEP_SET_ADDR + (m_srcsection)*SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
    {
        strcpy(m_WarningStr, "源定值区读取错误");
        return M_JUMP3;
    }
    SavePara((void *)m_SetBuf, EEP_SET_ADDR + (m_dstsection)*SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]);
    strcpy(m_WarningStr, "定值区复制成功");
    return M_JUMP3;
}

int mmd_initSection(int value)
{
    m_maxsection = (SEC_NUMBER - 1);
    m_srcsection = m_runsection;
    m_dstsection = m_runsection + 1;
    if (m_dstsection >= SEC_NUMBER)
        m_dstsection = 0;
    return M_OK;
}

int _Run61850(void)
{
    int ret = 0;
    // char *envp[] = { NULL };
    // char *cmd[] = {"/app/fs61850.ko", "&",  NULL};	//调用shell脚本,关闭对应端口
    // ret=call_usermodehelper("/app/fs61850.ko",  cmd,  envp,  UMH_WAIT_PROC);
    // rt_printf("\r\n run 61850 ret=%d\r\n",ret);
    return ret;
}

static bool b61850run = true;
int _Stop61850(void)
{
    int ret = 0;
    // char *envp[] = { NULL };
    // char *cmd[] = {"/usr/bin/killall", "fs61850.ko",  NULL};	//调用shell脚本,关闭对应端口
    // ret=call_usermodehelper("/usr/bin/killall",  cmd,  envp,  UMH_WAIT_PROC);
    // rt_printf("\r\nkillall 61850 ret=%d\r\n",ret);
    return ret;
}

int mmd_Stop61850(int value)
{
    int ret = 0;

    if (b61850run)
    {
        ret = _Stop61850();
        sprintf(m_WarningStr, "停止61850库ret=%d", ret);
    }
    else
    {
        // ret=_Run61850();
        sprintf(m_WarningStr, "装置重启/", ret);
        watchdog_reset_cpu(2);
    }
    b61850run = !b61850run;
    return M_JUMP3;
}

static void mmd_getmenumea(u8 *buf)
{
    u8 str[128];
    u8 str1[128];
    int len, i;
    int index = -1;
    len = iec_findchardot(buf, str);
    if (len == 0)
        return;
    if (strcmp(str, "MEA") == 0) // 测量值
    {
        buf += len + 1;
        len = iec_findchardot(buf, str);
        if (len == 0)
            return;
        for (i = 0; i < SW_AC_NUM_ALL; i++)
        {
            if (strcmp(str, g_sw_ac_desc[i].name) == 0)
            {
                index = i;
                break;
            }
        }
        if (index == -1)
        {
            for (i = 0; i < PUB_AC_NUM_ALL; i++)
            {
                if (strcmp(str, g_pub_ac_desc[i].name) == 0)
                {
                    index = SW_AC_MENU_NUM + i;
                    break;
                }
            }
        }
        if (index >= 0)
        {
            int j;
            buf += len + 1;
            len = iec_findchardot(buf, str1);
            if (len == 0)
                return;
            j = strtoul(str1, NULL, 10);
            // j=strtoul(buf,NULL,10);
            if (j > 0)
            {
                j -= 1;
                if (j >= MEA_MENU_MAX)
                    return;
                tMenuMea.index[j] = index;
                tMenuMea.num++;
            }
        }
    }
}
// #ifdef YPARA_LINK
void print_yparatable(void)
{
    int i = 0;

    if (ParaIDNum > 0)
        rt_printf("-------ParaIDNum=%d\r\n", ParaIDNum);

    for (i = 0; i < ParaIDNum; i++)
    {
        if (i % 50 == 0)
            msleep(500);
        if (tParaID[i].link_ch == 0)
        {
            rt_printf("local----parId = %x,group_type=%d,setno = %d\r\n ", tParaID[i].parId, tParaID[i].group_type, tParaID[i].setno);
        }
        else
        {
            rt_printf("link----link_ch = %d,parId=%x,link_cp = %x\r\n ", tParaID[i].link_ch, tParaID[i].parId, tParaID[i].link_cp);
        }
    }
}

/*获取通道号类型*/
int get_chnl_index(char *name)
{
    int val = 0;
    if (strcmp(name, "网络") == 0) /*本地,不级联*/
    {
        val = LINK_NET;
    }
    else if (strstr(name, "串口")) /*本地,不级联*/
    {
        sscanf(name, "串口%d", &val); /*数据长度*/
        if (val >= (CFG_UART_NUM_MAX + 1))
            return -1;
        val += 1;
    }

    return val;
}
// #endif

static void mmd_getmenuset(u8 *buf)
{
    u8 str[128], str1[128], str2[128], strpara[128];
    int val_rd_only = 0;
    int len, i;
    int val;
    u32 paraid, chnl = 0, index = 0, link_cp = 0;

    // rt_printf("-----------------\r\n");
    len = iec_findchardot(buf, str);
    if (len == 0)
        return;
    if (strcmp(str, "SET") == 0) // 定值
    {
        buf += len + 1;
        len = iec_findchardot(buf, str);
        if (len == 0)
            return;

        buf += len + 1;
        len = iec_findchardot(buf, str1);
        if (len == 0)
            return;

        buf += len + 1;
        len = iec_findchardot(buf, str2);
        if (len == 0)
            return;

        buf += len + 1;
        len = iec_findchardot(buf, strpara);
        if (len == 0)
            return;
        val = strtoul(strpara, NULL, 10);

        // rt_printf("val=%d,len=%d\r\n",val,len);
        buf += len + 1;
        len = iec_findchardot(buf, strpara); // 通信点号
        if (len == 0)
            return;
        paraid = strtoul(strpara, NULL, 16);
        buf += len + 1;

        /*兼容老lcd,没相关字段不return,默认为0*/
        len = iec_findchardot(buf, strpara); // 只读
        if (len > 0)
        {
            val_rd_only = strtoul(strpara, NULL, 10);
            buf += len + 1;
        }

        len = iec_findchardot(buf, strpara); /*级联通道*/
        if (len > 0)
        {
            chnl = get_chnl_index(strpara);
            buf += len + 1;
        }

        len = iec_findchardot(buf, strpara); /*级联序号*/
        if (len > 0)
        {
            index = strtoul(strpara, NULL, 10);
            buf += len + 1;
        }

        len = iec_findchardot(buf, strpara);
        if (len > 0)
        {
            link_cp = strtoul(strpara, NULL, 16); /*级联点号*/
            buf += len + 1;
        }

        // if(paraid > 0)
        //{
        // rt_printf("paraid=%x,val_rd_only=%x,chnl=%x,index=%x,link_cp=%x\r\n",paraid,val_rd_only,chnl,index,link_cp);
        //}

        // len=iec_findchardot(buf,strpara); /*级联点号*/
        // if(len==0)return;

        if ((chnl == 0) && (index == 0))
        {
            for (i = 0; i < SET_PUB_NUM; i++)
            {
                if ((strcmp(str, tPubSetTable[i].szName) == 0) && (strcmp(str1, SetGroups[tPubSetTable[i].group].group_name) == 0) && (strcmp(str2, SetGroups[tPubSetTable[i].group].item_name) == 0))
                {
                    bPubSetMenuShow[i] = val;
                    if ((paraid > 0) && (ParaIDNum < MAX_SET_NUMBER)) // 定值参数修改的点号
                    {
                        tParaID[ParaIDNum].group_type = SETGROUP_TYPE_PUB;
                        tParaID[ParaIDNum].parId = paraid;
                        if (val_rd_only)
                            tParaID[ParaIDNum].b_rd_only = true;
                        tParaID[ParaIDNum].setno = i;
                        tParaID[ParaIDNum].link_ch = (chnl << 5) + (index & 0x1F);
                        ParaIDNum++;
                    }
                    return;
                }
            }
            for (i = 0; i < SET_NUM; i++)
            {
                if ((strcmp(str, tSwSetTable[i].szName) == 0) && (strcmp(str1, SetGroups[tSwSetTable[i].group].group_name) == 0) && (strcmp(str2, SetGroups[tSwSetTable[i].group].item_name) == 0))
                {
                    bSwSetMenuShow[i] = val;
                    if ((paraid > 0) && (ParaIDNum < MAX_SET_NUMBER)) // 定值参数修改的点号
                    {
                        tParaID[ParaIDNum].group_type = SETGROUP_TYPE_BH;
                        tParaID[ParaIDNum].parId = paraid;
                        if (val_rd_only)
                            tParaID[ParaIDNum].b_rd_only = true;
                        tParaID[ParaIDNum].setno = i;
                        tParaID[ParaIDNum].link_ch = (chnl << 5) + (index & 0x1F);
                        ParaIDNum++;
                    }
                    return;
                }
            }

            for (i = 0; i < PARA_NUM; i++)
            {
                if ((strcmp(str, tEquipParaTable[i].szName) == 0) && (strcmp(str1, SetGroups[tEquipParaTable[i].group].group_name) == 0) && (strcmp(str2, SetGroups[tEquipParaTable[i].group].item_name) == 0))
                {
                    bParaSetMenuShow[i] = val;
                    if ((paraid > 0) && (ParaIDNum < MAX_SET_NUMBER)) // 定值参数修改的点号
                    {
                        tParaID[ParaIDNum].group_type = SETGROUP_TYPE_PARA;
                        tParaID[ParaIDNum].parId = paraid;
                        if (val_rd_only)
                            tParaID[ParaIDNum].b_rd_only = true;
                        tParaID[ParaIDNum].setno = i;
                        tParaID[ParaIDNum].link_ch = (chnl << 5) + (index & 0x1F);
                        ParaIDNum++;
                    }
                    return;
                }
            }

            for (i = 0; i < CSTSET_NUM; i++)
            {
                if ((strcmp(str, tCstSetTable[i].szName) == 0) && (strcmp(str1, SetGroups[tCstSetTable[i].group].group_name) == 0) && (strcmp(str2, SetGroups[tCstSetTable[i].group].item_name) == 0))
                {
                    bCstSetMenuShow[i] = val;
                    if ((paraid > 0) && (ParaIDNum < MAX_SET_NUMBER)) // 定值参数修改的点号
                    {
                        tParaID[ParaIDNum].group_type = SETGROUP_TYPE_CSTSET;
                        tParaID[ParaIDNum].parId = paraid;
                        tParaID[ParaIDNum].setno = i;
                        tParaID[ParaIDNum].link_ch = (chnl << 5) + (index & 0x1F);
                        ParaIDNum++;
                    }
                    return;
                }
            }
        }
        else
        {
            if ((paraid > 0) && (ParaIDNum < MAX_SET_NUMBER)) // 定值参数修改的点号
            {
                tParaID[ParaIDNum].parId = paraid;
                tParaID[ParaIDNum].link_ch = (chnl << 5) + (index & 0x1F);
                tParaID[ParaIDNum].link_cp = link_cp;
                ParaIDNum++;
            }
        }
    }
}
bool g_bVipSoe_show;
static void mmd_getmenuSoeShow(u8 *buf)
{
    u8 str[128];
    u8 str1[128];
    int len;
    int val;
    len = iec_findchardot(buf, str);
    if (len == 0)
        return;
    if (strcmp(str, "EVENT_SHOW") == 0) // 关键记录显示定义
    {
        buf += len + 1;
        len = iec_findchardot(buf, str);
        if (len == 0)
            return;
        buf += len + 1;
        len = iec_findchardot(buf, str1);
        if (len == 0)
            return;
        val = strtoul(str1, NULL, 10);
        // val=strtoul(buf,NULL,10);
        if (val == 0)
        {
            g_bVipSoe_show = false;
            return;
        }
    }
}

#ifdef FUNC_YT_HARD_YB
const short sw_yt_hard_yb_index[] =
    {
        SW_DI_BHZTT,     // 保护总功能投退压板
        SW_DI_BHTT,      // 常规保护投退压板
        SW_DI_CHZ,       // 重合闸压板
        SW_DI_FA_TT,     // 就地FA压板
        SW_DI_FA_GOOSE,  // 智能FA压板
        SW_DI_FA_LS,     // 联络/分段模式
        SW_DI_SAFE_AUTO, // 安全自动控制
};
const int YT_SW_HARD_YB_NUM = (sizeof(sw_yt_hard_yb_index) / sizeof(sw_yt_hard_yb_index[0]));

const short pub_yt_hard_yb_index[] =
    {
        PUB_DI_JX, // 检修压板
        PUB_DI_YF, // 远方
        PUB_DI_JD, // 就地
};
const int YT_PUB_HARD_YB_NUM = (sizeof(pub_yt_hard_yb_index) / sizeof(pub_yt_hard_yb_index[0]));

#ifdef FUNC_YT_MIX
u32 tHardYBID[SW_DI_NUM + PUB_DI_NUM + MIX_YT_NUM];
#else
u32 tHardYBID[SW_DI_NUM + PUB_DI_NUM];
#endif

static void mmd_getmenuHardYB(u8 *buf)
{
    u8 str[128];
    u8 str1[128];
    int len;
    int i;
    u32 paraid = 0;
    len = iec_findchardot(buf, str);
    if (len == 0)
        return;

    if (strcmp(str, "HARD_YB") == 0)
    {
        buf += len + 1;
        len = iec_findchardot(buf, str);
        if (len == 0)
            return;

        buf += len + 1;
        len = iec_findchardot(buf, str1);
        if (len == 0)
            return;
        paraid = strtoul(str1, NULL, 16);
        // paraid=strtoul(buf,NULL,16);
    }

    for (i = 0; i < YT_SW_HARD_YB_NUM; i++)
    {
        if (strcmp(str, g_sw_di_name[sw_yt_hard_yb_index[i]]) == 0)
        {
            if (paraid > 0)
            {
                tHardYBID[i] = paraid;
            }
            return;
        }
    }

    for (i = 0; i < YT_PUB_HARD_YB_NUM; i++)
    {
        if (strcmp(str, g_pub_di_name[pub_yt_hard_yb_index[i]]) == 0)
        {
            if (paraid > 0)
            {
                tHardYBID[YT_SW_HARD_YB_NUM + i] = paraid;
            }
            return;
        }
    }

#ifdef FUNC_YT_MIX
    for (i = 0; i < MIX_YT_NUM; i++)
    {
        if (strcmp(str, mix_yt_index[i]) == 0)
        {
            if (paraid > 0)
            {
                tHardYBID[YT_SW_HARD_YB_NUM + YT_PUB_HARD_YB_NUM + i] = paraid;
            }
            return;
        }
    }
#endif
}
#endif

int mmd_menu_cfg_init(void)
{
    u32 i, file_length;
    struct file *pfile;
    u8 *filebuf;
    u8 filestr[128], *pstr, strlenth;
    loff_t pos;

    tMenuMea.num = 0;
    memset(bPubSetMenuShow, 1, SET_PUB_NUM);
    memset(bSwSetMenuShow, 1, SET_NUM);
    memset(bParaSetMenuShow, 1, PARA_NUM);
    memset(bCstSetMenuShow, 1, CSTSET_NUM);
    memset(&tParaID[0], 0, sizeof(SET_PARAID) * MAX_SET_NUMBER);
#ifdef FUNC_YT_HARD_YB
#ifdef FUNC_YT_MIX
    memset(tHardYBID, 0, (SW_DI_NUM + PUB_DI_NUM + MIX_YT_NUM));
#else
    memset(tHardYBID, 0, (SW_DI_NUM + PUB_DI_NUM));
#endif
#endif
    ParaIDNum = 0;
#ifdef YPARA_LINK
    memset(&tPara_val[0], 0, sizeof(SET_PARA_VAL) * MAX_SET_NUMBER);
#endif
    g_bVipSoe_show = true;
    // 打开文件
    pfile = rt_file_open("/app/data/lcd_menu.csv", O_RDONLY, 0);
    if (IS_ERR(pfile))
    {
        dp_err_n_c_rt("无法打开 lcd_menu.csv,新建...");
        mmd_create_menufile();
        pfile = rt_file_open("/app/data/lcd_menu.csv", O_RDONLY, 0);
        if (IS_ERR(pfile))
            return -1;
    }

    // 得到文件长度
    file_length = rt_file_getfile_size(pfile);
    if (file_length <= 0)
    {
        rt_file_close(pfile, 0);
        return -2;
    }

    // 分配内存
    filebuf = rt_malloc(file_length);
    if ((filebuf) == NULL)
    {
        rt_file_close(pfile, 0);
        return -3;
    }

    pos = 0;
    if (rt_file_read(pfile, filebuf, file_length, &pos) != file_length)
    {
        rt_file_close(pfile, 0);
        rt_free(filebuf);
        return -4;
    }
    pstr = filestr;
    strlenth = 0; // 纠错处理
    // 找到\r\n位置，得到一行长度
    for (i = 0; i < file_length; i++)
    {
        *pstr++ = filebuf[i];
        strlenth++;
        if (filebuf[i] == 0x0a || strlenth >= 128)
        {
            pstr -= 2;     //  去掉回车换行
            *pstr++ = ','; // 增加逗号
            *pstr = '\0';
            mmd_getmenumea(filestr);
            mmd_getmenuset(filestr);
            mmd_getmenuSoeShow(filestr);
#ifdef FUNC_YT_HARD_YB
            mmd_getmenuHardYB(filestr);
#endif
            pstr = filestr;
            strlenth = 0;
        }
    }
#if 0
	print_yparatable();
#endif
    rt_file_close(pfile, 0); // 关闭文件
    rt_free(filebuf);        // 释放内存

#if 0
	//打印调试信息
	for(i=0;i<tMenuMea.num;i++)
	{
		if(tMenuMea.index[i])rt_printf("\r\nMEA%d index=%d",i+1,tMenuMea.index[i]);
	}

	for(i=0;i<SET_PUB_NUM;i++)
	{
		if(bPubSetMenuShow[i]&&(tPubSetTable[i].wType!=SETTYPE_LABEL))rt_printf("\r\n%s ",tPubSetTable[i].szName);
	}

	for(i=0;i<SET_NUM;i++)
	{
		if(bSwSetMenuShow[i]&&(tSwSetTable[i].wType!=SETTYPE_LABEL)) rt_printf("\r\n%s ",tSwSetTable[i].szName);
	}

	for(i=0;i<ParaIDNum;i++)
	{
		if(tParaID[i].group_type==SETGROUP_TYPE_PUB)
		{
			rt_printf("\r\n%s %04x :%d",tPubSetTable[tParaID[i].setno].szName,	tParaID[i].parId,tParaID[i].setno);
		}
	}

	for(i=0;i<ParaIDNum;i++)
	{
		if(tParaID[i].group_type==SETGROUP_TYPE_BH)
		{
			rt_printf("\r\n%s %04x :%d",tSwSetTable[tParaID[i].setno].szName, tParaID[i].parId,tParaID[i].setno);
		}
	}
	
	for(i=0;i<ParaIDNum;i++)
	{
		if(tParaID[i].group_type==SETGROUP_TYPE_PARA)
		{
			rt_printf("\r\n%s %04x :%d",tEquipParaTable[tParaID[i].setno].szName, tParaID[i].parId,tParaID[i].setno);
		}
	}

#endif

    return 0;
}

void mmd_create_menufile(void)
{
    char *p;
    char tmpbuf[128];
    struct file *pfile;
    loff_t pos;
    int i;
    WORD addr = 0;

    p = tmpbuf;
    // 创建描述文件
    pfile = rt_file_open("/app/data/lcd_menu.csv", O_CREAT | O_RDWR | O_TRUNC, 0);
    if (IS_ERR(pfile))
    {
        return;
    }
    pos = 0;

    for (i = 0; i < SW_AC_MENU_NUM; i++)
    {
        sprintf(p, "MEA,%s,0\r\n", g_sw_ac_desc[i].name);
        rt_file_write(pfile, p, strlen(p), &pos);
    }
    for (i = 0; i < PUB_AC_MENU_NUM; i++)
    {
        sprintf(p, "MEA,%s,0\r\n", g_pub_ac_desc[i].name);
        rt_file_write(pfile, p, strlen(p), &pos);
    }
    sprintf(p, "my_set_desc,名称,组名,分组名,液晶显示,通信点号,只读,级联通道,级联地址,级联点号\r\n");
    rt_file_write(pfile, p, strlen(p), &pos);

    for (i = 0; i < PUB_SET_NUMBER; i++)
    {
        // if(tPubSetTable[i].wType!=SETTYPE_LABEL)
        {
            addr = GetCstValForwardAddr(SETGROUP_TYPE_PUB, i);
            sprintf(p, "SET,%s,%s,%s,1,0x%x,0,0,0,0\r\n", tPubSetTable[i].szName, SetGroups[tPubSetTable[i].group].group_name, SetGroups[tPubSetTable[i].group].item_name, addr);
            rt_file_write(pfile, p, strlen(p), &pos);
        }
    }

    for (i = 0; i < SW_SET_NUMBER; i++)
    {
        // if(tSwSetTable[i].wType!=SETTYPE_LABEL)
        {
            addr = GetCstValForwardAddr(SETGROUP_TYPE_BH, i);
            sprintf(p, "SET,%s,%s,%s,1,0x%x,0,0,0,0\r\n", tSwSetTable[i].szName, SetGroups[tSwSetTable[i].group].group_name, SetGroups[tSwSetTable[i].group].item_name, addr);
            rt_file_write(pfile, p, strlen(p), &pos);
        }
    }

    for (i = 0; i < EQUIP_PARA_NUMBER; i++)
    {
        // if(tEquipParaTable[i].wType!=SETTYPE_LABEL)
        {
            addr = GetCstValForwardAddr(SETGROUP_TYPE_PARA, i);
            sprintf(p, "SET,%s,%s,%s,1,0x%x,0,0,0,0\r\n", tEquipParaTable[i].szName, SetGroups[tEquipParaTable[i].group].group_name, SetGroups[tEquipParaTable[i].group].item_name, addr);
            rt_file_write(pfile, p, strlen(p), &pos);
        }
    }

    for (i = 0; i < CSTSET_NUMBER; i++)
    {
        // if(tEquipParaTable[i].wType!=SETTYPE_LABEL)
        {
            addr = GetCstValForwardAddr(SETGROUP_TYPE_CSTSET, i);
            sprintf(p, "SET,%s,%s,%s,1,0x%x,0,0,0,0\r\n", tCstSetTable[i].szName, SetGroups[tCstSetTable[i].group].group_name, SetGroups[tCstSetTable[i].group].item_name, addr);
            rt_file_write(pfile, p, strlen(p), &pos);
        }
    }

    strcpy(p, "EVENT_SHOW,SOE弹出关键记录,1\r\n");
    rt_file_write(pfile, p, strlen(p), &pos);

#ifdef FUNC_YT_HARD_YB
    for (i = 0; i < YT_SW_HARD_YB_NUM; i++)
    {
        sprintf(p, "HARD_YB,%s,0x0000\r\n", g_sw_di_name[sw_yt_hard_yb_index[i]]);
        rt_file_write(pfile, p, strlen(p), &pos);
    }
    for (i = 0; i < YT_PUB_HARD_YB_NUM; i++)
    {
        sprintf(p, "HARD_YB,%s,0x0000\r\n", g_pub_di_name[pub_yt_hard_yb_index[i]]);
        rt_file_write(pfile, p, strlen(p), &pos);
    }

#ifdef FUNC_YT_MIX
    for (i = 0; i < MIX_YT_NUM; i++)
    {
        sprintf(p, "HARD_YB,%s,0x0000\r\n", mix_yt_index[i]);
        rt_file_write(pfile, p, strlen(p), &pos);
    }
#endif
#endif

    rt_file_close(pfile, 0);

    return;
}

void log_operate_set_change(const TSETTABLE *pTable, u16 setno, long v1, long v2)
{
    char namestr[128];
    char tmpstr[64];
    SET_VALUE ft;
    sprintf(namestr, "%s(%s)", pTable->szName, SetGroups[pTable->group].item_name);
    switch (pTable->wType)
    {
    case SETTYPE_F:
        ft.tt = v1;
        sprintf(tmpstr, "由:%.3f", ft.ff);
        strcat(namestr, tmpstr);
        ft.tt = v2;
        sprintf(tmpstr, "改:%.3f", ft.ff);
        strcat(namestr, tmpstr);
        break;
    case SETTYPE_UINT: // 16进制显示  控制字
    case SETTYPE_4INT: // 10进制显示  4位
    case SETTYPE_5INT: // 10进制显示  5位
    case SETTYPE_LINT: // 16进制显示  控制字
        ft.tt = v1;
        sprintf(tmpstr, "由:%d", (u16)ft.tt);
        strcat(namestr, tmpstr);
        ft.tt = v2;
        sprintf(tmpstr, "改:%d", (u16)ft.tt);
        strcat(namestr, tmpstr);
        break;
    case SETTYPE_LIST: // 列表选择
    {
        ft.tt = v1;
        sprintf(tmpstr, "由:%s", pTable->list[(u16)ft.tt].str);
        strcat(namestr, tmpstr);
        ft.tt = v2;
        sprintf(tmpstr, "改:%s", pTable->list[(u16)ft.tt].str);
        strcat(namestr, tmpstr);
    }
    break;
    case SETTYPE_IP:
    {
        u32 dat;
        ft.tt = v1;
        dat = (u32)ft.tt;
        sprintf(tmpstr, "由:%d.%d.%d.%d", (dat >> 24) & 0xFF, (dat >> 16) & 0xFF, (dat >> 8) & 0xFF, (dat >> 0) & 0xFF);
        strcat(namestr, tmpstr);

        ft.tt = v2;
        dat = (u32)ft.tt;
        sprintf(tmpstr, "改:%d.%d.%d.%d", (dat >> 24) & 0xFF, (dat >> 16) & 0xFF, (dat >> 8) & 0xFF, (dat >> 0) & 0xFF);
        strcat(namestr, tmpstr);
    }
    break;
    case SETTYPE_YMD:
    {
        struct timespec ts;
        struct rtc_time_t tTime;

        memset(&ts, 0, sizeof(ts));
        memset(&tTime, 0, sizeof(tTime));
        ft.tt = v1;
        ts.tv_sec = (long)ft.tt;
        timespec_to_rtc(ts, &tTime, 1);
        sprintf(tmpstr, "由:%04d-%02d-%02d", 2000 + tTime.year, tTime.month, tTime.day);
        strcat(namestr, tmpstr);
        ft.tt = v2;
        ts.tv_sec = (long)ft.tt;
        timespec_to_rtc(ts, &tTime, 1);
        sprintf(tmpstr, "改:%04d-%02d-%02d", 2000 + tTime.year, tTime.month, tTime.day);
        strcat(namestr, tmpstr);
    }
    break;
    case SETTYPE_HMS:
    {
        struct timespec ts;
        struct rtc_time_t tTime;
        extern int timespec_to_rtchms(struct timespec ts, struct rtc_time_t * p_rtc, int is_round);

        memset(&ts, 0, sizeof(ts));
        memset(&tTime, 0, sizeof(tTime));
        ft.tt = v1;
        ts.tv_sec = (long)ft.tt;
        timespec_to_rtchms(ts, &tTime, 1);
        sprintf(tmpstr, "由:%02d:%02d:%02d", tTime.hour, tTime.min, tTime.ms % 1000);
        strcat(namestr, tmpstr);

        memset(&ts, 0, sizeof(ts));
        memset(&tTime, 0, sizeof(tTime));
        ft.tt = v2;
        ts.tv_sec = (long)ft.tt;
        timespec_to_rtchms(ts, &tTime, 1);
        sprintf(tmpstr, " 改为:%02d:%02d:%02d", tTime.hour, tTime.min, tTime.ms % 1000);
        strcat(namestr, tmpstr);
    }
    default:
        return;
    }

    log_str_time(LOG_FIXSET, namestr, 0, 0);
}
void para_change_check_soe(float *pf, DWORD wAddr, WORD num, const TSETTABLE *pTable)
{
    SET_VALUE *pbuf;
    int i;
    pbuf = rt_malloc(MAX_SET_NUMBER * 4);
    if (!pbuf)
    {
        rt_printf("\r\npara_change_check_soe 定值变化检查，分配缓存失败!\r\n");
        return;
    }
    if (!ReadPara((void *)pbuf, wAddr, num, pTable))
    {
        GetDefPara((void *)pbuf, num, pTable);
    }
    for (i = 0; i < num; i++)
    {
        SET_VALUE ft, fval;
        long v0 = 0;

        if (pTable == (&tPubSetTable[0])) // 公共定值
        {
            v0 = (1 << 16) | i;
        }
        else if (pTable == (&tSwSetTable[0])) // 开关定值
        {
            v0 = (2 << 16) | i;
        }
        else if (pTable == (&tEquipParaTable[0])) // 参数定值
        {
            v0 = (3 << 16) | i;
        }
        else if (pTable == (&tCstSetTable[0])) // 内部定值
        {
            v0 = (4 << 16) | i;
        }

        if (mmd_IsHexType(pTable[i].wType))
        {
            u32 *pt;
            pt = (u32 *)(&pf[i]);
            ft.tt = (u32)*pt;
            fval.tt = (u32)(pbuf[i].tt);
        }
        else if (mmd_IsIntegType(pTable[i].wType))
        {
            ft.tt = (u32)pf[i];
            fval.tt = (u32)pbuf[i].ff;
        }
        else
        {
            ft.ff = pf[i];
            fval.ff = pbuf[i].ff;
        }
        if (ft.tt != fval.tt)
        {
            soe_record_opt3(EV_SET_CHANGE_PARA, v0, fval.tt, ft.tt);
            log_operate_set_change(&pTable[i], i, fval.tt, ft.tt);
        }
    }
    rt_free(pbuf);
}