签到

/*****************************************************************************************
文件：app_touch.c
编者：张永辉 2013年6月24日
      2013年6月25日    去掉了开机密码
*****************************************************************************************/
#include "includes.h"
#include "GUI.h"
#include "bsp.h"
#include "bsptouch.h"
#include "bspdbg.h"
#include "jpgfile.h"
#include "JpegToBmp.h"
#include "\embed\source\lib\basetype.h"
#include "fun.h"
/*****************************************************************************************
触摸屏按下检测
*****************************************************************************************/
#define    TOUCHC_NUM 16            //检测点数目
static struct g_CheakPiontChekd
{
    u32    beIsin;    //上次是否在本范围内
    u32    x0;
    u32    y0;
    u32    x1;
    u32    y1;
}chd[TOUCHC_NUM];
//***********************设置要检测的点***************************************************
void TouchcSet(u32 index,u32 x0,u32    y0,u32 x1,u32 y1)
{
    chd[index].x0 =    x0;
    chd[index].y0 =    y0;
    chd[index].x1 =    x1;
    chd[index].y1 =    y1;
}
/*************************检测某个点的按下，或者放开事件**********************************
返回：    0没有发生
1有进入该区域
2有离开该区域
*/
int    TouchcClickUpDown(u32 index)
{
    u32    x,y;
    u32    yes    = 0;
    if (index >= TOUCHC_NUM)
    {
        return 0;
    }
    x =    BspTouchGetX();
    y =    BspTouchGetY();

    //本次在范围内
    if((x >    chd[index].x0 && x < chd[index].x1)    && (y >    chd[index].y0 && y < chd[index].y1))
    {
        //若上次不在范围内===被按下了
        if(chd[index].beIsin ==    0)
        {
            yes    = 1;
            if(index !=0)    //0号测试用的，不叫
            {
                //蜂鸣器声音
                //BspBeepOne();
            }
        }
        chd[index].beIsin =    1;
    }else
        //本次不在范围内
    {
        //若上次在范围内===被按松开了
        if(chd[index].beIsin ==    1)
        {
            yes    = 2;
        }
        chd[index].beIsin =    0;    //不在范围内
    }
    return yes;
}
/*************************显示图片，并与某个键号绑定**************************************
参数：keyNum ==    0时表示不帮键号
注：  绑定后，便可以根据键号，查询是否按下或放开了
VS2008使用函数此处不能命中，于是用宏了
*/
GUI_JPEG_INFO jpeginfo;
#define    TouchcJpeg(pDATA,X0,Y0,keyNum)\
{\
    if(keyNum>=0)\
    {\
        GUI_JPEG_Draw(pDATA,sizeof(pDATA),X0,Y0);\
        if(keyNum >    0 )\
        {\
            GUI_JPEG_GetInfo(pDATA,sizeof(pDATA),&jpeginfo);\
            TouchcSet(keyNum,X0,Y0,(X0+jpeginfo.XSize),(Y0+jpeginfo.YSize));\
        }\
    }\
}

//从内存调用解码后的数据，直接显示，在M3上显示速度明显提高
//参数：keyNum == 0时表示不绑定键号
//换成本函数后，毛击VS2008会死机，原因不明
void TouchcBmp(GUI_BITMAP *    pBMP,int X0,int    Y0,int keyNum) //TouchcBmp(BMP
{
    int    x1;
    int    y1;
    x1 = X0    + pBMP->XSize;
    y1 = Y0+pBMP->YSize;
    if (keyNum >= 0)
    {
        //从内存显示图片
        GUI_DrawBitmap(pBMP,X0,Y0);
        if (keyNum > 0)
        {
            //绑定建号
            TouchcSet(keyNum,X0,Y0,x1,y1);
        }
    }
}

//输入框
void TouchcInput(int X0,int    Y0,int X1,int Y1,int keyNum)
{
    //实验
    GUI_DrawLine(X0,Y0,X1,Y0);
    GUI_DrawLine(X1,Y0,X1,Y1);
    GUI_DrawLine(X0,Y0,X0,Y1);
    GUI_DrawLine(X0,Y1,X1,Y1);
    TouchcSet(keyNum,X0,Y0,X1,Y1);
}
/*****************************************************************************************
功能函数支持
*****************************************************************************************/
void StateFun_j_jar_n(void);
void TouchcJpeg_beep(void);
u32     StateFun_PreSent_Covert(u32 i);//将百分比转换成指针的角度
void StateFun_Press_n(void);        //主页面要显示的指针和数值
void StateFun_Press_4page(void);    //4页面要显示的    指针和数值
void StateFun_GasCheck(void);        //气体检测时要显示的数值
void StateFun_DisAllFunKey(u32 KeyIndex);        //显示功能按键
/*****************************************************************************************
状态机
*****************************************************************************************/
//------------------状态定义------------
#define     C_SETUP_LOG        1    //启动显示LOG
#define     C_MAIN_PAGE        2    //主页面状态
#define     C_PASSWD            3    //输入密码状态
#define     C_GAS_CHECK        4    //检测
#define     C_SYS_ALARM        5    //系统报警
#define     C_HARD_ERR_CHECK    6    //
#define     C_4PAGE            7    //4页面
#define     C_PASSWD_SET        8    //密码设置
#define     C_4PAGE_SET        9    //气瓶参数设置
#define     C_SYS_SET            10    //系统设置
#define     C_IDLE                11    //启动显示LOG
#define     C_KEYBORD            12    //启动键盘输入

//------------------状态声明------------
u32    StateSetUp(void);
u32    StateMainPage(void);
u32    StatePassWd(void);
u32    StateGasCheck(void);
u32    StateSysAlarm(void);
u32    StateHardErrCheck(void);
u32    State4page(void);
u32    StatePasswdSet(void);
u32    State4pageSet(void);
u32    StateSysSet(void);
u32    StateKeyBord(void);

//------------------变量----------------
u32    StateBc    =    C_SETUP_LOG;        //前一个状态
u32    State =        C_SETUP_LOG;        //当前状态

u32    MainPageJarNum = 1;                //在主页面显示的瓶号
u32    StatNum    = 0;                    //进入某个状态的计数器，刚进入时等于0。
u32    StateChgReq    = 0;                //状态切换申请，由子状态发起，主状态在切换前清除
u32    StateMsgForm = 0;                //消息发出者 ==    状态值（状态间消息传递）
u32    StateMsg1;                        //消息内容
u32    StateMsg2;
u32    StateMsg3;
//**************************************状态机调度函数************************************
//调用总入口，每20ms调用一次
void app_touch_test(void)
{
    //---------------按键测试函数-------
    u32    x,y;
    BspTouchBeginOnce();
    x =    BspTouchGetX();
    y =    BspTouchGetY();
    TouchcSet(0,0,0,480,272);
    if(TouchcClickUpDown(0))
    {
        DBG_S("xxx = ");DBG_U32N(x);
        DBG_S("yyy = ");DBG_U32N(y);
    }
    //--------------状态机开始----------
    switch(State)
    {
    case C_SETUP_LOG:
        State =    StateSetUp();
        break;
    case C_IDLE:
    case C_MAIN_PAGE:
        State =    StateMainPage();
        break;
    case C_PASSWD:
        State =    StatePassWd();
        break;
    case C_GAS_CHECK:
        State =    StateGasCheck();
        break;
    case C_SYS_ALARM:
        State =    StateSysAlarm();
        break;
    case C_HARD_ERR_CHECK:
        State =    StateHardErrCheck();
        break;
    case C_4PAGE:
        State =    State4page();
        break;
    case C_PASSWD_SET:
        State =    StatePasswdSet();
        break;
    case C_4PAGE_SET:
        State =    State4pageSet();
        break;
    case C_SYS_SET:
        State=    StateSysSet();
        break;
    case C_KEYBORD:
        State=    StateKeyBord();
        break;

    default:
        State =    C_MAIN_PAGE;
        break;
    }
    //--------------状态改变时的操作----
    if(StateBc != State)
    {
        StateBc    = State;
        StatNum    = 0;    //保证刚进入状态时为0
    }else
    {
        StatNum++;
    }
}

/***************************************键盘输入*****************************************/
/*
入参：    StateMsgForm，    键盘输入结束后要返回的地方
        StateMsg1 键盘X位置
        StateMsg2 键盘Y位置
输出：    StateMsgForm = C_KEYBORD
        StateMsg1 =    0    取消
        StateMsg1 =    1    确定
        StateMsg2;        确定时，键盘输入的数值
*/
#define    KEYH 40            //每个键盘格子的长，宽
#define    KEYL 40
static int keyvaule    = 0;
static int keyvaulelen = 0;
u32    StateKeyBord(void)
{
    u32    Click;
    u32    i;
    //在此可以检测 StateMsgForm    判断键盘请求来源
    //刚开始进本状态
    if (StatNum==0)
    {
        //显示背景
        TouchcBmp(&BMP.j_keybord,StateMsg1,StateMsg2,0);

        //格子开始的相对位置
        StateMsg1 +=3;
        StateMsg2 +=50;
        TouchcInput(StateMsg1        ,StateMsg2,StateMsg1+KEYH  ,StateMsg2+KEYL,1);    //按键1
        TouchcInput(StateMsg1+KEYH    ,StateMsg2,StateMsg1+KEYH*2,StateMsg2+KEYL,2);    //按键2
        TouchcInput(StateMsg1+KEYH*2,StateMsg2,StateMsg1+KEYH*3,StateMsg2+KEYL,3);    //按键3
        TouchcInput(StateMsg1+KEYH*3,StateMsg2,StateMsg1+KEYH*4,StateMsg2+KEYL,11);    //按键 CLR

        StateMsg2 +=KEYL;
        TouchcInput(StateMsg1        ,StateMsg2,StateMsg1+KEYH  ,StateMsg2+KEYL,4);    //按键4
        TouchcInput(StateMsg1+KEYH    ,StateMsg2,StateMsg1+KEYH*2,StateMsg2+KEYL,5);    //按键5
        TouchcInput(StateMsg1+KEYH*2,StateMsg2,StateMsg1+KEYH*3,StateMsg2+KEYL,6);    //按键6
        TouchcInput(StateMsg1+KEYH*3,StateMsg2,StateMsg1+KEYH*4,StateMsg2+KEYL,12);    //按键 回退

        StateMsg2 +=KEYL;
        TouchcInput(StateMsg1        ,StateMsg2,StateMsg1+KEYH  ,StateMsg2+KEYL,7);    //按键7
        TouchcInput(StateMsg1+KEYH    ,StateMsg2,StateMsg1+KEYH*2,StateMsg2+KEYL,8);    //按键8
        TouchcInput(StateMsg1+KEYH*2,StateMsg2,StateMsg1+KEYH*3,StateMsg2+KEYL,9);    //按键9
        TouchcInput(StateMsg1+KEYH*3,StateMsg2,StateMsg1+KEYH*4,StateMsg2+KEYL,13);    //按键 - 取消

        StateMsg2 +=KEYL;
        TouchcInput(StateMsg1        ,StateMsg2,StateMsg1+KEYH  ,StateMsg2+KEYL,10);    //按键10 0
        TouchcInput(StateMsg1+KEYH    ,StateMsg2,StateMsg1+KEYH*2,StateMsg2+KEYL,14);    //按键11 .

        TouchcInput(StateMsg1+KEYH*2,StateMsg2,StateMsg1+KEYH*3+KEYH,StateMsg2+KEYL,15);//按键12 确定  占2个格子

        //还原其值
        StateMsg1 -= 3;
        StateMsg2 -=50;
        StateMsg2 -=KEYL*3;

        GUI_SetTextMode(GUI_TEXTMODE_NORMAL);
        GUI_SetColor(0);
        GUI_SetBkColor((GUI_COLOR)-1);                       //
        //GUI_SetTextMode(GUI_TEXTMODE_TRANS);    //文本模式==透明模式
        GUI_SetFont(&GUI_Font16B_ASCII);        //数字大小
        DBG_S("State = StateKeyBord.\n");

        //键值初始化
        keyvaulelen    = 0;
        keyvaule = 0;
    }

    //输入数字检测
    for    (i = 1;i<= 10;i++)
    {
        Click =    TouchcClickUpDown(i);
        if(Click==1)
        {
            //密码长度限制
            if (keyvaulelen>=6)
            {
                break;
            }
            keyvaulelen++;
            keyvaule = keyvaule*10 + i%10;        //10代表0
            DBG_U32N(i);
            GUI_DispDecAt(keyvaule,StateMsg1+20,StateMsg2+30,keyvaulelen);
        }
    }

    //清除
    Click =    TouchcClickUpDown(11);
    if(Click==1)
    {
        DBG_U32N(11);
        keyvaule = 0;
        keyvaulelen    = 0;
        GUI_DispStringAt("              ",StateMsg1+20,StateMsg2+30);
    }

    //回退
    Click =    TouchcClickUpDown(12);
    if(Click==1)
    {
        //密码长度限制
        if (keyvaulelen    > 0)
        {
            keyvaule = keyvaule/10;
            keyvaulelen--;
            DBG_U32N(11);
            GUI_DispStringAt("              ",StateMsg1+20,StateMsg2+30);
            GUI_DispDecAt(keyvaule,StateMsg1+20,StateMsg2+30,keyvaulelen);
            //GUI_SetTextMode(GUI_TEXTMODE_TRANS);      //文本模式==透明模式
        }
    }
    //取消
    Click =    TouchcClickUpDown(13);
    if(Click==1)
    {
        StateChgReq    = StateMsgForm;        //返回原来的状态
        StateMsgForm = C_KEYBORD;
        StateMsg1 =    0;                    //表示取消
        return C_IDLE;
    }
    //确定
    Click =    TouchcClickUpDown(15);        //返回原来的状态
    if(Click==1)
    {
        StateChgReq    = StateMsgForm;
        StateMsgForm = C_KEYBORD;
        StateMsg1 =    1;                    //表示确定
        StateMsg2 =    keyvaule;            //返回键值
        return C_IDLE;
    }
    return C_KEYBORD;
}

//**************************************主页面********************************************
u32    StateMainPage(void)
{
    u32    Click;

    //状态切换申请
    if(StateChgReq != 0)
    {

        switch(StateChgReq)
        {
            //此三个状态会相互转移，或回到主界面
        case C_SYS_SET:
            StateChgReq    = 0;
            return C_SYS_SET;

        case C_4PAGE_SET:
            StateChgReq    = 0;
            return C_4PAGE_SET;

        case C_PASSWD_SET:
            StateChgReq    = 0;
            return C_PASSWD_SET;

        case C_KEYBORD:
            StateChgReq    = 0;
            return C_KEYBORD;

        case C_PASSWD:
            StateChgReq    = 0;
            return C_PASSWD;

        default:
            StateChgReq    = 0;
            break;
        }
    }
    //如果没有输入密码则需要输入  开机密码暂时不要了
    //if (IsPasswordOk()!= TRUE)
    //{
    //    return C_PASSWD;
    //}

    //如果密码通过了，则是要系统设置了。出来的时候要去掉。
    //if (IsPasswordOk()== TRUE)
    //{
    //    return C_SYS_SET;
    //}
    //显示主页面
    if (StatNum==0)
    {
        //主页面
        TouchcBmp(&BMP.j_manpage,0,0,0);
        StateFun_j_jar_n();                //显示第n瓶

        JarSetnSet(MainPageJarNum);        //设置瓶号
        StateFun_Press_n();                //显示瓶子压力，应该有刷新

        //显示功能按钮，并绑定按键号
        TouchcBmp(&BMP.j_but_forward_up,    0  ,226,1);
        TouchcBmp(&BMP.j_but_back_up   ,    60 ,226,2);
        TouchcBmp(&BMP.j_but_4page_up  ,    120,226,3);
        TouchcBmp(&BMP.j_but_gas_up       ,    180,226,4);
        TouchcJpeg(       j_but_had_check_up,    240,226,5);
        TouchcBmp(&BMP.j_but_alarm_up,        300,226,6);
        TouchcJpeg_beep();                //显示声音是否关闭
        TouchcBmp(&BMP.j_but_set_up,        420,226,8);
        DBG_S("State = StateMainPage\n");
    }

    //根据按键号，检测每个按键的按下、放开状态
    //【按键1】    瓶号切换:递增
    Click =    TouchcClickUpDown(1);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_forward_down,0,226,0);
    }
    if(Click==2)    //放开
    {
        TouchcBmp(&BMP.j_but_forward_up,0,226,0);
        MainPageJarNum++;
        if(MainPageJarNum >    4)
        {
            MainPageJarNum = 1;
        }
        StateFun_j_jar_n();
    }

    //【按键2】瓶号切换:递减
    Click =    TouchcClickUpDown(2);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_back_down,60,226,0);
    }
    if(Click==2)    //放开
    {
        TouchcBmp(&BMP.j_but_back_up,60,226,0);
        MainPageJarNum--;
        if(MainPageJarNum <= 0)
        {
            MainPageJarNum = 4;
        }
        StateFun_j_jar_n();
    }

    //【按键3】显示4个页面
    Click =    TouchcClickUpDown(3);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_4page_down     ,    120,226,0);
    }
    if(Click==2)    //放开
    {
        TouchcBmp(&BMP.j_but_4page_up  ,    120,226,0);
        return C_4PAGE;
    }

    //【按键4】气体检测
    Click =    TouchcClickUpDown(4);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_gas_down  ,    180,226,0);
    }
    if(Click==2)    //放开
    {
        return C_GAS_CHECK;
    }

    //【按键5】    硬件故障检测
    Click =    TouchcClickUpDown(5);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_had_check_down,240,226,0);
    }
    if(Click==2)    //放开
    {
        return C_HARD_ERR_CHECK;
    }

    //【按键6 】系统报警检测
    Click =    TouchcClickUpDown(6);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_alarm_down,    300,226,0);
    }
    if(Click==2)    //放开状态转移
    {
        return C_SYS_ALARM;
    }

    //【按键7】    关闭/开启声音
    Click =    TouchcClickUpDown(7);
    if(Click==1)    //按下
    {
        if (BeepIsCloseGet())
        {
            BeepSet(false);
        }else
        {
            BeepSet(true);
        }
        TouchcJpeg_beep();
    }

    //【按键8】     系统设置
    Click =    TouchcClickUpDown(8);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_set_down,        420,226,0);
    }
    if(Click==2)    //放开
    {
        return C_SYS_SET;
    }
    return C_IDLE;
}
//**************************************系统设置******************************************
#define    CC 3
//是否显示指针
bool IsDisplayPointer =    true;
bool IsDisplayPointerGet(void)
{
    return IsDisplayPointer;
}
void IsDisplayPointerSet(bool yes)
{
    IsDisplayPointer = yes;
}
//是否显示指针
void StateSysSet_IsDisplayPointer(bool yes)
{
    if(yes == false)
    {
        TouchcBmp(&BMP.j_but_no,135,145,13);
        TouchcBmp(&BMP.j_but_yes,213,145,14);
    }else
    {
        TouchcBmp(&BMP.j_but_yes,135,145,13);
        TouchcBmp(&BMP.j_but_no,213,145,14);
    }
}
//是否可燃气体检测
void StateSysSet_IsGasCkeck(bool yes)
{
    if(yes == false)
    {
        TouchcBmp(&BMP.j_but_no,135,113,11);
        TouchcBmp(&BMP.j_but_yes,213,113,12);
    }else
    {
        TouchcBmp(&BMP.j_but_yes,135,113,11);
        TouchcBmp(&BMP.j_but_no,213,113,12);
    }
}
//是否低液位报警
void StateSysSet_IsLowAlarm(bool yes)
{

    if(yes == false)
    {
        TouchcBmp(&BMP.j_but_no,135,81,9);
        TouchcBmp(&BMP.j_but_yes,213,81,10);
    }else
    {
        TouchcBmp(&BMP.j_but_yes,135,81,9);
        TouchcBmp(&BMP.j_but_no,213,81,10);
    }
}

//复选框：瓶子个数
void StateSysSet_JarNumber(u32 num)
{
    //瓶个数选择
    TouchcBmp(&BMP.j_but_no,135,48,3);
    TouchcBmp(&BMP.j_but_no,213,48,4);
    TouchcBmp(&BMP.j_but_no,289,48,5);
    TouchcBmp(&BMP.j_but_no,363, 48,6);
    switch(num)
    {
    case 1:
            TouchcBmp(&BMP.j_but_yes,135,48,3);
        break;
    case 2:TouchcBmp(&BMP.j_but_yes,213,48,4);
        break;
    case 3:TouchcBmp(&BMP.j_but_yes,289,48,5);
        break;
    case 4:TouchcBmp(&BMP.j_but_yes,363, 48,6);
        break;
    }
}

u32    StateSysSet(void)
{
    u32    Click;
    int    i;

    //设置前要输入密码
    //if (IsPasswordOk()!= TRUE)
    //{
    //    StateChgReq    = C_PASSWD;
    //    return C_IDLE;
    //}

    //显示主页面
    if (StatNum==0)
    {
        //显示黑色底，以覆盖不必要的按钮
        TouchcBmp(&BMP.j_back_480x60,0,220,0);

        //主页面
        TouchcBmp(&BMP.j_sys_set,0,0,0);

        //横条显示
        TouchcBmp(&BMP.j_but_sys_set,0,0,0);

        //显示功能按钮，并绑定按键号
        TouchcBmp(&BMP.j_but_forward_up,    0  ,226,1);
        TouchcBmp(&BMP.j_but_back_up   ,    60 ,226,2);
        TouchcBmp(&BMP.j_but_manpage_up,    420,226,8);

        //复选框：瓶子个数
        StateSysSet_JarNumber(JarNumberGet());                    //键号 = 3 4 5 6

        //复选框：是否低液位报警
        StateSysSet_IsLowAlarm(IsLowAlarmGet());                //键号 = 9 10

        //复选框：是否进行气体浓度监测
        StateSysSet_IsGasCkeck(IsGasCkeckGet());                //键号 = 11    12

        //复选框：是否显示指针
        StateSysSet_IsDisplayPointer(IsDisplayPointerGet());    //键号 = 13    14

        DBG_S("State = StateSysSet\n");
    }

    //复选框：瓶个数选择
    for    (i = 1;    i <= 4;i++ )
    {
        Click =    TouchcClickUpDown(2+i);    //3    4 5    6
        if(Click==1)
        {
            JarNumberSet(i);
            StateSysSet_JarNumber(JarNumberGet());
        }
    }

    //复选框：是否低液位报警
    Click =    TouchcClickUpDown(9);
    if(Click ==    1)
    {
        IsLowAlarmSet(true);
        StateSysSet_IsLowAlarm(IsLowAlarmGet());
    }
    Click =    TouchcClickUpDown(10);
    if(Click ==    1)
    {
        IsLowAlarmSet(false);
        StateSysSet_IsLowAlarm(IsLowAlarmGet());
    }

    //复选框：是否进行气体浓度监测
    Click =    TouchcClickUpDown(11);
    if(Click ==    1)
    {
        IsGasCkeckSet(true);
        StateSysSet_IsGasCkeck(IsGasCkeckGet());
    }
    Click =    TouchcClickUpDown(12);
    if(Click ==    1)
    {
        IsGasCkeckSet(false);
        StateSysSet_IsGasCkeck(IsGasCkeckGet());
    }

    //复选框：是否显示指针
    Click =    TouchcClickUpDown(13);
    if(Click ==    1)
    {
        IsDisplayPointerSet(true);
        StateSysSet_IsDisplayPointer(IsDisplayPointerGet());
    }
    Click =    TouchcClickUpDown(14);
    if(Click ==    1)
    {
        IsDisplayPointerSet(false);
        StateSysSet_IsDisplayPointer(IsDisplayPointerGet());
    }

    //【按键1】
    Click =    TouchcClickUpDown(1);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_forward_down,0,226,0);
    }
    if(Click==2)
    {
        StateChgReq    = C_PASSWD_SET;
        return C_IDLE;
    }

    //【按键2】
    Click =    TouchcClickUpDown(2);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_back_down,60,226,0);
    }
    if(Click==2)
    {
        JarSetnSet(1);
        StateChgReq    = C_4PAGE_SET;
        return C_IDLE;
    }

    //【按键8】
    Click =    TouchcClickUpDown(8);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_manpage_dowm  ,    420,226,0);
    }
    if(Click==2)    //放开状态转移
    {
        //PasswordOkSet(false);        //
        return C_IDLE;
    }

    return C_SYS_SET;
}
//**************************************更改密码******************************************
u32    StatePasswdSet(void)
{
    int    static newpasd;
    u32    Click;
    u32    i;
    //显示主页面
    if (StatNum==0)
    {
        //
        //if(StateMsgForm!=C_KEYBORD)
        //{
            TouchcBmp(&BMP.j_passwd_set,0,0,0);
        //}

        TouchcBmp(&BMP.j_but_passwd_set,0,0,0);

        //显示功能按钮，并绑定按键号
        TouchcBmp(&BMP.j_but_forward_up,    0  ,226,1);
        TouchcBmp(&BMP.j_but_back_up   ,    60 ,226,2);
        TouchcBmp(&BMP.j_but_manpage_up,    420,226,8);

        ///输入框位置检测
        TouchcInput(181,46 ,285,59,3);        //源密码
        TouchcInput(181,84 ,285,96,4);        //新密码
        TouchcInput(181,123,285,135,5);        //新密码

        //
        GUI_SetTextMode(GUI_TEXTMODE_TRANS);    //文本模式==透明模式
        GUI_SetFont(&GUI_FontComic18B_ASCII);
        DBG_S("State = StateSysSet\n");
    }

    //【按键3,4,5】
    for    (i = 0;i < 3;i++)
    {
        Click =    TouchcClickUpDown(3+i);
        if(Click==1)
        {

            StateMsgForm = C_PASSWD_SET;    //键盘将返回到本状态
            StateMsg1 =    0;                    //键盘的起始位置
            StateMsg2 =    0;
            StateMsg3 =    3+i;                    //键盘不会改变此值，当有多个输入时需要
            //请求状态转移
            StateChgReq    = C_KEYBORD;
            return C_IDLE;
        }
    }

    //检测键盘的返回
    if(StateMsgForm==C_KEYBORD)
    {
        StateMsgForm = 0;
        //按键3，获取到键盘的值了
        if(StateMsg3==3)
        {
            //确定键
            if(StateMsg1==1)
            {
                //GUI_DispDecAt(keyvaule,240+2,128+2,keyvaulelen);
                GUI_DispStringAt("******",181+2,46+2);
                if(PasswordGet()==keyvaule)
                {
                    //密码通过
                    GUI_DispStringAt("ok ",295,46);
                    newpasd    = -2;
                }else
                {
                    //密码检测失败
                    GUI_DispStringAt("err",295,46);
                    newpasd    = -1;
                }
            }
            //取消键
            if(StateMsg1==0)
            {
                //获取到的键值
            }
        }
        //新密码
        if(StateMsg3==4)
        {
            //确定键
            if(StateMsg1==1)
            {
                GUI_DispStringAt("******",183,88);
                if(newpasd==-2)                //判断旧密码检验通过才行
                {
                    newpasd    = keyvaule;
                    GUI_DispStringAt("ok ",295,86);
                }else
                {
                    GUI_DispStringAt("err",295,86);
                }

            }
            //取消键
            if(StateMsg1==0)
            {
                //获取到的键值
            }
        }
        //新密码
        if(StateMsg3==5)
        {
            //确定键
            if(StateMsg1==1)
            {
                GUI_DispStringAt("******",183,125);
                //新密码设置成功
                if(newpasd == keyvaule)
                {
                    PasswordSet(keyvaule);
                    GUI_DispStringAt("ok ",295,123);
                }else
                {
                    GUI_DispStringAt("err",295,123);
                }
            }
            //取消键
            if(StateMsg1==0)
            {
                //获取到的键值
            }
        }
    }
    //【按键1】
    Click =    TouchcClickUpDown(1);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_forward_down,0,226,0);
    }
    if(Click==2)
    {
        JarSetnSet(4);
        StateChgReq    = C_4PAGE_SET;
        return C_IDLE;
    }

    //【按键2】
    Click =    TouchcClickUpDown(2);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_back_down,60,226,0);
    }
    if(Click==2)
    {
        StateChgReq    = C_SYS_SET;
        return C_IDLE;
    }

    //【按键8】
    Click =    TouchcClickUpDown(8);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_manpage_dowm  ,    420,226,0);
    }
    if(Click==2)//回主界面
    {
        return C_IDLE;
    }
    return    C_PASSWD_SET;
}
//**************************************4个气瓶设置***************************************
// 根据要设置的瓶号，显示标签
void State4pageSet_dis_page(u32    n)
{
    switch(n)
    {
    case 1:
        TouchcBmp(&BMP.j_but_jar1_set,0,0,0);
        break;
    case 2:TouchcBmp(&BMP.j_but_jar2_set,0,0,0);
        break;
    case 3:TouchcBmp(&BMP.j_but_jar3_set,0,0,0);
        break;
    case 4:TouchcBmp(&BMP.j_but_jar4_set,0,    0,0);
        break;
    }
}
u32    State4pageSet(void)
{
    u32    Click;
    int    i;
    //显示主页面
    if (StatNum==0)
    {
        //主页面
        TouchcBmp(&BMP.j_4page_set,0,0,0);

        //气瓶设置标签
        State4pageSet_dis_page(JarSetnGet());

        //显示功能按钮，并绑定按键号
        TouchcBmp(&BMP.j_but_forward_up,    0  ,226,1);
        TouchcBmp(&BMP.j_but_back_up   ,    60 ,226,2);
        TouchcBmp(&BMP.j_but_manpage_up,    420,226,8);

        //获取当前值
        TouchcBmp(&BMP.j_but_get_value_up,      384,107,3);
        TouchcBmp(&BMP.j_but_get_value_up,      384,158,4);

        //气瓶容量设置
        TouchcInput(385, 57,450,69,5);
        TouchcInput(385, 83,450,95,6);
        TouchcInput(385,136,450,148,7);

        //本状态字体颜色
        GUI_SetColor(GUI_RED);
        GUI_SetFont(&GUI_Font8x12_ASCII);

        //显示
        GUI_GotoXY(385,    57);GUI_DispDecMin(JarMaxGasGet());                //最大气罐容量
        GUI_GotoXY(385,    83);GUI_DispDecMin(JarGasLowPfGet());            //最小电容值
        GUI_GotoXY(385,    136);GUI_DispDecMin(JarGasHigPfGet());            //最大电容值

        //显示实时值
        GUI_GotoXY(161,    57);GUI_DispDecMin(JarGasNowPfGet());            //实时电容
        GUI_GotoXY(161,    83);GUI_DispDecMin(JarGasNowGet());                //实时液位
        GUI_GotoXY(161,    108);GUI_DispFloatFix(JarPressNowGet(),4,2);    //实时瓶压
        GUI_GotoXY(161,    136);GUI_DispFloatFix(JarBufferPressNowGet(),4,2);    //实时缓冲压
        GUI_GotoXY(161,    164);GUI_DispDecMin(JarTemperatureNowGet());    //实时温度
        //
        DBG_S("State = State4pageSet :");DBG_U32N(JarSetnGet());
    }

    //【按键3】获取当前值，空瓶电容
    Click =    TouchcClickUpDown(3);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_get_value_down,    384,107,0);
    }
    if(Click==2)
    {
        TouchcBmp(&BMP.j_but_get_value_up,      384,107,0);
    }

    //【按键4】获取当前值，满瓶电容
    Click =    TouchcClickUpDown(4);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_get_value_down,    384,158,0);
    }
    if(Click==2)
    {
        TouchcBmp(&BMP.j_but_get_value_up  ,    384,158,0);
    }

    for    (i = 0;i<3;i++)
    {
        //【按键5,6,7】气瓶容量设置     空瓶设置 满屏设置
        Click =    TouchcClickUpDown(5+i);
        if(Click==2)
        {
            StateMsgForm = C_4PAGE_SET;        //键盘将返回到本状态
            StateMsg1 =    0;                    //键盘的起始位置
            StateMsg2 =    0;
            StateMsg3 =    5+i;                //键盘不会改变此值，当有多个输入时需要
            //请求状态转移
            StateChgReq    = C_KEYBORD;
            return C_IDLE;
        }
    }

    //检测键盘的返回
    if(StateMsgForm==C_KEYBORD)
    {
        StateMsgForm = 0;
        if(StateMsg3==5)    //气瓶容量设置
        {
            //确定键
            if(StateMsg1==1)
            {
                //获取到的键值 keyvaule
                GUI_DispStringAt("        ",385, 57);
                GUI_GotoXY(385,    57);
                GUI_DispDecMin(keyvaule);
                JarMaxGasSet(keyvaule);
            }
        }
        if(StateMsg3==6)    //空瓶设置
        {
            //确定键
            if(StateMsg1==1)
            {
                //获取到的键值 keyvaule
                GUI_DispStringAt("        ",385, 83);
                GUI_GotoXY(385,    83);
                GUI_DispDecMin(keyvaule);
                JarGasLowPfSet(keyvaule);
            }
        }
        if(StateMsg3==7)    //满屏设置
        {
            //确定键
            if(StateMsg1==1)
            {
                //获取到的键值 keyvaule
                GUI_DispStringAt("        ",385, 136);
                GUI_GotoXY(385,    136);
                GUI_DispDecMin(keyvaule);
                JarGasHigPfSet(keyvaule);
            }
        }
    }

    //【按键1】
    Click =    TouchcClickUpDown(1);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_forward_down,0,226,0);
    }
    if(Click==2)
    {

        //根据标签，界面向前切换
        if(JarSetnGet()==1)
        {
            StateChgReq    = C_SYS_SET;
        }else
        {
            JarSetnSet(    JarSetnGet() - 1);
            StateChgReq    = C_4PAGE_SET;
        }
        return C_IDLE;
    }

    //【按键2】
    Click =    TouchcClickUpDown(2);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_back_down,60,226,0);
    }
    if(Click==2)
    {
        //根据标签，界面向后切换
        if(JarSetnGet()==4)
        {
            StateChgReq    = C_PASSWD_SET;
        }else
        {
            JarSetnSet(    JarSetnGet()+1);
            StateChgReq    = C_4PAGE_SET;
        }
        return C_IDLE;
    }

    //【按键8】
    Click =    TouchcClickUpDown(8);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_manpage_dowm  ,    420,226,0);
    }
    if(Click==2)
    {
        return C_IDLE;
    }
    return    C_4PAGE_SET;
}

//**************************************系统报警******************************************
void StateSysAlarm_fun(void)
{
    int    i;

    //低液位
    for(i=0;i<4;i++)
    {
        if(IsLngLow(i+1))
        {
            TouchcBmp(&BMP.j_alarm_yes,197,62+i*25,0);
        }
    }
    //高液位
    for(i=0;i<4;i++)
        {
        if(IsLngHig(i+1))
        {
            TouchcBmp(&BMP.j_alarm_yes,360,62+i*25,0);
        }
    }
}
u32    StateSysAlarm(void)
{
    u32    Click;
    //显示主页面
    if (StatNum==0)
    {
        TouchcBmp(&BMP.j_sys_alarm,0,0,0);                    //本页主界面
        StateSysAlarm_fun();                            //高低液位检测
        StateFun_DisAllFunKey(1);                        //显示所有的功能按键,绑定1号键
        TouchcBmp(&BMP.j_but_alarm_down,        300,226,0);//显示按下的功能键
    }
    //按键8
    Click =    TouchcClickUpDown(1);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_alarm_up,        300,226,0);
    }
    if(Click==2)    //放开状态转移
    {
        return C_IDLE;
    }
    return C_SYS_ALARM;
}
//**************************************硬件故障检测**************************************
void StateHardErrCheck_fun(void)
{
    int    i;

    //断路检测
    for(i=0;i<4;i++)
    {
        if(IsJarCapBreak(i+1))
        {
            TouchcBmp(&BMP.j_alarm_yes,427,58+i*28,0);
        }
    }
    //短路检测
    for(i=0;i<4;i++)
    {
        if(IsJarCapShort(i+1))
        {
            TouchcBmp(&BMP.j_alarm_yes,206,58+i*28,0);
        }
    }

}

u32    StateHardErrCheck(void)
{
    u32    Click;
    //显示主页面
    if (StatNum==0)
    {
        TouchcBmp(&BMP.j_hard_err_check,0,0,0);                //本页主界面
        StateHardErrCheck_fun();

        StateFun_DisAllFunKey(1);                        //显示所有的功能按键,绑定1号键
        TouchcBmp(&BMP.j_but_had_check_down,    240,226,0);    //显示按下的功能键
    }
    //按键8
    Click =    TouchcClickUpDown(1);
    if(Click==1)    //按下
    {
        TouchcJpeg(j_but_had_check_up,    240,226,0);
    }
    if(Click==2)    //放开状态转移
    {
        return C_IDLE;
    }
    return C_HARD_ERR_CHECK;
}
//**************************************气体检测******************************************
u32    StateGasCheck(void)
{
    u32    Click;
    //显示主页面
    if (StatNum==0)
    {
        TouchcBmp(&BMP.j_gas_check,0,0,0);                    //本页主界面
        StateFun_DisAllFunKey(1);                        //显示所有的功能按键,绑定1号键
        TouchcBmp(&BMP.j_but_gas_down      ,    180,226,0);        //显示按下的功能键
        StateFun_GasCheck();                            //气体检测，并报警
    }

    //按键1
    Click =    TouchcClickUpDown(1);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_gas_up      ,    180,226,0);
    }
    if(Click==2)    //放开状态转移
    {
        return C_IDLE;
    }
    return C_GAS_CHECK;
}
/***************************************显示4个页面**************************************/
u32    State4page(void)
{
    u32    Click;
    //显示主页面
    if (StatNum==0)
    {
        TouchcBmp(&BMP.j_4page,0,0,0);
        StateFun_DisAllFunKey(1);                        //显示所有的功能按键,绑定1号键
        TouchcBmp(&BMP.j_but_4page_down     ,    120,226,0);        //显示被按下的按键，
        StateFun_Press_4page();                            //指针显示
    }
    //按键1
    Click =    TouchcClickUpDown(1);
    if(Click==1)    //按下
    {
        TouchcBmp(&BMP.j_but_4page_up  ,    120,226,0);
    }
    if(Click==2)    //放开状态转移
    {
        return C_IDLE;
    }
    return C_4PAGE;
}
/***************************************输入密码*****************************************/
u32    StatePassWd(void)
{
                                        //输入开机密码
    int    i =    0;
    u32    Click;
    i =    i;
    if(StatNum==0)
    {
        TouchcBmp(&BMP.j_passwd,0,0,0);

        TouchcBmp(&BMP.j_but_enter_up,165,165,1);            //确定
        TouchcBmp(&BMP.j_but_cancel_up,265,165,2);            //取消

        //输入框位置检测
        TouchcInput(240,128,352,150,3);
        GUI_SetColor(GUI_RED);
        GUI_SetFont(&GUI_FontComic18B_ASCII);
        DBG_S("State = StatePassWd...\n");
    }
    //确定
    Click =    TouchcClickUpDown(1);
    if(Click==1)
    {
        TouchcBmp(&BMP.j_but_4page_down,165,165,1);
    }
    //取消
    Click =    TouchcClickUpDown(2);
    if(Click==1)
    {
    }

    //请求键盘输入
    Click =    TouchcClickUpDown(3);
    if(Click==2)
    {
        StateMsgForm = C_PASSWD;        //键盘将返回到本状态
        StateMsg1 =    0;                    //键盘的起始位置
        StateMsg2 =    0;
        StateMsg3 =    3;                    //键盘不会改变此值，当有多个输入时需要
        //请求状态转移
        StateChgReq    = C_KEYBORD;
        return C_IDLE;
    }

    //检测键盘的返回
    if(StateMsgForm==C_KEYBORD)
    {
        StateMsgForm = 0;    //清除，否则重复检测到键盘
        //按键3，获取到键盘的值了
        if(StateMsg3==3)
        {
            //确定键
            if(StateMsg1==1)
            {
                //获取到的键值
                //GUI_DispDecAt(keyvaule,240+2,128+2,keyvaulelen);
                GUI_DispStringAt("******",240+2,128+2);
                //StateMsg2
                if(PasswordGet()==keyvaule)
                {
                    //密码检测通过
                    PasswordOkSet(true);
                    return C_IDLE;
                }else
                {
                    //密码检测失败
                    GUI_DispStringAt("Passwd Error!",240+2,200+2);
                }
            }
            //取消键
            if(StateMsg1==0)
            {
                //获取到的键值
            }
        }
    }
    return C_PASSWD;
    //return C_IDLE;
}
/***************************************开机启动*****************************************/
u32    StateSetUp(void)
{
    //刚开始进本状态
    if (StatNum==0)
    {
        TouchcJpeg(j_log,0,0,0);    //解码前，只能用此函数显示图片
        DBG_S("State = StateSetUp...\n");
        JpegToBmpAtMem();            //图片解码到内存
        //JpegToBmpTest();            //测试函数
    }
    //while(1)
    //{
    //    dis_bmp_test();
    //    OSTimeDly(10);
    //}
    //2秒后退出本状态
    if(StatNum > 20)
    {
        return C_IDLE;
    }
    return C_SETUP_LOG;
}
//======================================状态机的功能函数==================================
//**************************************是否需要声音提示**********************************
void TouchcJpeg_beep(void)
{
    if (BeepIsCloseGet())
    {
        TouchcBmp(&BMP.j_but_voice_yes,        360,226,7);
    }else
    {
        TouchcBmp(&BMP.j_but_voice_no,        360,226,7);
    }
}
//**************************************显示主页面左上角的瓶号****************************
void StateFun_j_jar_n(void)
{
    switch(MainPageJarNum)
    {
    case 1:
        TouchcBmp(&BMP.j_jar1,0,0,0);
        break;
    case 2:
        TouchcBmp(&BMP.j_jar2,0,0,0);
        break;
    case 3:
        TouchcBmp(&BMP.j_jar3,0,0,0);
        break;
    case 4:
        TouchcBmp(&BMP.j_jar4,0,0,0);
        break;
    default:
        break;
    }
}
//**************************************主界面的指针 数组显示*****************************
#define    countofarry(arry) (sizeof(arry)/sizeof(arry[0]))            //求数组的组数
#define    ANGLE(C)    (C*100*3.14159265/18000)                        //角度，与幅度的转换

const GUI_POINT    Points1[] =    {{0,39},{-3,9},{0,10},{3,9}};            //主页面，小圈仪表的指针. 0°时在6点钟方向
GUI_POINT        Points1c[countofarry(Points1)];                        //副本，画图时使用

const GUI_POINT    Points2[] =    {{0,46},{-4,9},{0,10},{4,9}};            //主页面，大圈仪表的指针. 0°时在6点钟方向
GUI_POINT        Points2c[countofarry(Points1)];
//将百分比转换成可以显示的角度
u32    StateFun_PreSent_Covert(u32    i)
{
    //在图形上显示时 72    是满的，287是空的  287-72=215
    i =    100    - i;
    i =    (i*215 + 2)/100;    //[0,100]=[0,215]
    i += 72;
    return i;
}
void StateFun_Press_n(void)
{
    int    i =    0;
    //在图形上显示时 72    是满的，287是空的  287-72=215
    GUI_SetColor(GUI_RED);                                //设置颜色
    GUI_SetDrawMode(GUI_DRAWMODE_TRANS);                //这也是默认模式   异或模式    GUI_DRAWMODE_XOR

    //----仪表盘指针绘制----
    //瓶压 指针
    //GUI_MagnifyPolygon(MainLittlePointsCopy,MainLittlePoints,countof(MainLittlePoints),1);//对多边形放大1倍    有复制作用
    i =    JarPressNowPerSentGet();
    i =    StateFun_PreSent_Covert(i);
    GUI_RotatePolygon(Points1c,Points1,countofarry(Points1),ANGLE(i));    //旋转多边形,有数据复制作用
    GUI_FillPolygon(Points1c,countofarry(Points1),102,126);                //绘制一个填充多边形

    //缓冲压 指针
    i =    JarBufferPressNowPerSentGet();
    i =    StateFun_PreSent_Covert(i);
    GUI_RotatePolygon(Points1c,Points1,countofarry(Points1),ANGLE(i));    //旋转多边形,有数据复制作用
    GUI_FillPolygon(Points1c,countofarry(Points1),375,126);                //绘制一个填充多边形

    //液位 指针
    i =    JarGasNowPerSentGet();
    i =    StateFun_PreSent_Covert(i);
    GUI_RotatePolygon(Points2c,Points2,countofarry(Points2),ANGLE(i));    //旋转多边形,有数据复制作用
    GUI_FillPolygon(Points2c,countofarry(Points2),237,114);                //绘制一个填充多边形

    //----显示数值：罐体容量 瓶压 缓冲压----
    //显示文本
    GUI_SetTextMode(GUI_TEXTMODE_TRANS);    //文本模式==透明模式
    GUI_SetBkColor((GUI_COLOR)-1);            //设置背景色==白色
    GUI_SetColor(GUI_GREEN);                //设置前景色，即字体颜色

    GUI_SetFont(&GUI_FontComic18B_ASCII);  //GUI_FontComic24B_ASCII    大了   GUI_FontComic18B_1系统崩溃
    GUI_GotoXY(220,158);
    GUI_DispDec(JarGasNowGet(),3);            //罐体容量

    GUI_SetFont(&GUI_Font16B_ASCII);        //GUI_FontComic24B_ASCII 大了    GUI_FontComic18B_1系统崩溃
    GUI_GotoXY(85,160);
    GUI_DispFloatFix(JarPressNowGet(),4,2);    //瓶压

    GUI_GotoXY(360,160);
    GUI_DispFloatFix(JarBufferPressNowGet(),4,2);       //缓冲压
}

//**************************************4个页面时的指针    数值显示**************************
void StateFun_Press_4page(void)
{
    static int i = 90;
    GUI_SetColor(GUI_RED);                                //设置颜色
    GUI_SetDrawMode(GUI_DRAWMODE_TRANS);                //这也是默认模式   异或模式    GUI_DRAWMODE_XOR

    //----仪表盘指针绘制----
    //瓶1 瓶压 指针
    JarSetnSet(1);
    i =    JarGasNowPerSentGet();
    i =    StateFun_PreSent_Covert(i);
    GUI_RotatePolygon(Points1c,Points1,countofarry(Points1),ANGLE(i));
    GUI_FillPolygon(Points1c,countofarry(Points1),119,65);        //中心点

    //瓶2 瓶压 指针
    JarSetnSet(2);
    i =    JarGasNowPerSentGet();
    i =    StateFun_PreSent_Covert(i);
    GUI_RotatePolygon(Points1c,Points1,countofarry(Points1),ANGLE(i));
    GUI_FillPolygon(Points1c,countofarry(Points1),360,65);

    //瓶3 瓶压 指针
    JarSetnSet(3);
    i =    JarGasNowPerSentGet();
    i =    StateFun_PreSent_Covert(i);
    GUI_RotatePolygon(Points1c,Points1,countofarry(Points1),ANGLE(i));
    GUI_FillPolygon(Points1c,countofarry(Points1),119,176);

    //瓶4 瓶压 指针
    JarSetnSet(4);
    i =    JarGasNowPerSentGet();
    i =    StateFun_PreSent_Covert(i);
    GUI_RotatePolygon(Points1c,Points1,countofarry(Points1),ANGLE(i));
    GUI_FillPolygon(Points1c,countofarry(Points1),360,176);

    GUI_SetTextMode(GUI_TEXTMODE_TRANS);    //文本模式==透明模式
    GUI_SetBkColor((GUI_COLOR)-1);            //设置背景色==白色
    GUI_SetColor(GUI_GREEN);                //设置前景色，即字体颜色

    //罐体容量
    GUI_SetFont(&GUI_FontComic18B_ASCII);

    i =    6;
    JarSetnSet(1);//设置将要取的瓶号
    GUI_GotoXY(103,97);
    GUI_DispDec(JarGasNowGet(),3);                       //罐1

    JarSetnSet(2);
    GUI_GotoXY(344,97);
    GUI_DispDec(JarGasNowGet(),3);                       //罐2

    JarSetnSet(3);
    GUI_GotoXY(103,208);
    GUI_DispDec(JarGasNowGet(),3);                       //罐3

    JarSetnSet(4);
    GUI_GotoXY(344,208);
    GUI_DispDec(JarGasNowGet(),3);                       //罐4

    //瓶压
    GUI_SetFont(&GUI_Font16B_ASCII);
    JarSetnSet(1);
    GUI_GotoXY(32,97);
    GUI_DispFloatFix(JarPressNowGet(),4,2);                //瓶压1

    JarSetnSet(2);
    GUI_GotoXY(270,97);
    GUI_DispFloatFix(JarPressNowGet(),4,2);                //瓶压2

    JarSetnSet(3);
    GUI_GotoXY(32,210);
    GUI_DispFloatFix(JarPressNowGet(),4,2);                //瓶压3

    JarSetnSet(4);
    GUI_GotoXY(270,210);
    GUI_DispFloatFix(JarPressNowGet(),4,2);                //瓶压4

    //缓冲压
    JarSetnSet(1);
    GUI_GotoXY(174,100);
    GUI_DispFloatFix(JarBufferPressNowGet(),4,2);        //瓶1

    JarSetnSet(2);
    GUI_GotoXY(413,100);
    GUI_DispFloatFix(JarBufferPressNowGet(),4,2);        //瓶2

    JarSetnSet(3);
    GUI_GotoXY(174,211);
    GUI_DispFloatFix(JarBufferPressNowGet(),4,2);        //瓶3

    JarSetnSet(4);
    GUI_GotoXY(413,211);
    GUI_DispFloatFix(JarBufferPressNowGet(),4,2);        //瓶4
}

//**************************************气体检测******************************************
void StateFun_GasCheck(void)
{
    //可燃气体浓度 0--100
    u32    i;
    GUI_SetFont(&GUI_Font16B_ASCII);
    GUI_SetColor(GUI_GREEN);                //设置前景色，即字体颜色

    i =    BurntGasCheckGet(1);
    GUI_GotoXY(210,42);
    GUI_DispDec(i,2);                       //罐1

    i =    BurntGasCheckGet(2);
    GUI_GotoXY(428,42);
    GUI_DispDec(i,2);                       //罐2

    i =    BurntGasCheckGet(3);
    GUI_GotoXY(210,67);
    GUI_DispDec(i,2);                       //罐3

    i =    BurntGasCheckGet(4);
    GUI_GotoXY(428,67);
    GUI_DispDec(i,2);                       //罐4

    i =    BurntGasCheckGet(5);
    GUI_GotoXY(210,91);
    GUI_DispDec(i,2);                       //罐5
}

//**************************************显示功能按键***************************************
//仅进行位置
void StateFun_DisAllFunKey(u32 KeyIndex)
{
    //显示全部的功能按键
    TouchcBmp(&BMP.j_but_forward_up,    0  ,226,0);
    TouchcBmp(&BMP.j_but_back_up   ,    60 ,226,0);
    TouchcBmp(&BMP.j_but_4page_up  ,    120,226,0);
    TouchcBmp(&BMP.j_but_gas_up       ,    180,226,0);
    TouchcJpeg(       j_but_had_check_up,    240,226,0);
    TouchcBmp(&BMP.j_but_alarm_up,        300,226,0);
    TouchcJpeg_beep();                //显示声音是否关闭
    TouchcBmp(&BMP.j_but_set_up,        420,226,0);

    //绑定键号，使按下任意键，即可检测到。
    if(KeyIndex!= 0)
    {
        //绑定键号
        TouchcSet(KeyIndex,0,226,480,272);
    }
}

 

 /*****************************************************************************************
                                    功能函数
文件：fun.c
编者：张永辉 2013年6月24日
*****************************************************************************************/
#include "includes.h"
#include "fun.h"
#include "bsp.h"
#include "math1.h"
//****************************数据结构定义************************************************
//系统设置
typedef    struct
{
    u16    JarNumber;                //当前使用的瓶子数量
    u32    IsGasLowAlarm:1;        //是否低液位报警
    u32    IsGasCkeck:1;            //是否气体浓度监测
    u32    IsBeepOn:1;                //是否开启声音
    u32    IsUsePionter:1;            //是否使用指针
}SYSSET;
SYSSET SysSet;

typedef    struct
{
    u32     passd;                    //密码
    bool IsPassdPas;            //是否通过了密码验证
}PASSWORD;
PASSWORD psd;

typedef    struct                    //气体参数
{
    u16 GasMax;
    u16 GasLowPf;
    u16 GasHigPf;
}GASPART;

typedef    struct                    //要保存到EE的数据
{
    U32    IsFist;                //第一次未使用则要初始化
    SYSSET SysSet;
    PASSWORD psd;
    GASPART GasParn[4];            //有4个瓶子
}EEPROM;
EEPROM eeprom;
#define  EE_ADDR_SATRT  0        //要使用的开始地址

//****************************可燃气体浓度************************************************
#define    BRUNT_GAS_NUM 5            //可燃气体的个数
typedef    struct
{
    u16    BurntGasPerSent;        //可燃气体百分比0--100
    u16    BurntGasAlarmVlue;        //报警的阀值
}BURNT;
BURNT BurntGas[BRUNT_GAS_NUM];
//输入：1--    BRUNT_GAS_NUM 气体检测器位置
//返回：百分比0--99
u32    BurntGasCheckGet(u32 id)
{
    //static u32 test;
    if(id >    BRUNT_GAS_NUM || id    < 1)
    {
        while(1);

    }
    
    //不检测则是0%
    if(IsGasCkeckGet()!=true)
    {
        return 0;
    }
    return BurntGas[id-1].BurntGasPerSent;
}
//气体是否达到报警的值。
bool IsBurntGasAlarm(u32 id)
{
    //不检测则不报警
    if(IsGasCkeckGet()!=true)
    {
        return false;
    }
    if(BurntGas[id-1].BurntGasPerSent >= BurntGas[id-1].BurntGasAlarmVlue)
    {
        return true;
    }
    return false;
}
//*****************************系统设定***************************************************
//将系统设置保存到ee            //设置页面的 确定按钮用
void SysSet_ee(void)
{
    int i;
    eeprom.SysSet.IsBeepOn = SysSet.IsBeepOn;
    eeprom.SysSet.IsGasCkeck = SysSet.IsGasCkeck;
    eeprom.SysSet.IsGasLowAlarm = SysSet.IsGasLowAlarm;
    eeprom.SysSet.IsUsePionter = SysSet.IsUsePionter;
    eeprom.SysSet.JarNumber = SysSet.JarNumber;
    i =  (int)&eeprom.SysSet -  (int)&eeprom;
    BspEeWrites(EE_ADDR_SATRT + i,(u8*)&eeprom.SysSet,sizeof(eeprom.SysSet));
}

//将系统设到ee读取                //开机后读取
void SysGet_ee(void)
{
    int i;
    i =  (int)&eeprom.SysSet -  (int)&eeprom;
    BspEeReads(EE_ADDR_SATRT + i,(u8*)&eeprom.SysSet,sizeof(eeprom.SysSet));
    SysSet.IsBeepOn = eeprom.SysSet.IsBeepOn;
    SysSet.IsGasCkeck = eeprom.SysSet.IsGasCkeck;
    SysSet.IsGasLowAlarm = eeprom.SysSet.IsGasLowAlarm;
    SysSet.IsUsePionter = eeprom.SysSet.IsUsePionter;
    SysSet.JarNumber = eeprom.SysSet.JarNumber;
}
//是否开启报警声音(所有故障时的声音)
bool BeepIsOnGet(void)
{
    return SysSet.IsBeepOn;
}
void BeepSet(bool ison)
{
    SysSet.IsBeepOn    = ison;
}
//瓶子数量
U32    JarNumberGet()
{
    return SysSet.JarNumber;
}
void JarNumberSet(int n)
{
    SysSet.JarNumber =    n;
}
//是否低液位报警
void IsGasLowAlarmSet(bool    yes)
{
    SysSet.IsGasLowAlarm = yes;
}
bool IsGasLowAlarmGet(void)
{
    return SysSet.IsGasLowAlarm;
}
//是否气体浓度监测
bool IsGasCkeckGet(void)
{
    return SysSet.IsGasCkeck;
}
void IsGasCkeckSet(bool    yes)
{
    SysSet.IsGasCkeck =    yes;
}
//是影藏指针
//***************************用户密码管理*************************************************
bool IsPasswordOk(void)            //查询是否通过密码检测
{
    return psd.IsPassdPas;
}
void PasswordOkSet(bool    pas)    //设置密码验证通过
{
    psd.IsPassdPas = pas;
}
void PasswordSet(u32 pas)        //设置密码
{
    psd.passd =    pas;
}
u32     PasswordGet(void)            //获取密码
{
    return psd.passd;
}
//是否显示指针
bool IsDisplayPointerGet(void)
{
    return SysSet.IsUsePionter;
}
void IsDisplayPointerSet(bool yes)
{
    SysSet.IsUsePionter = yes;
}
void PasswordSet_ee(u32 pas)    //保持密码到EEPROM  点击确定后保持
{
    int i;
    i =  (int)&eeprom.psd -  (int)&eeprom;
    psd.passd = pas;
    eeprom.psd.passd = pas;
    eeprom.psd.IsPassdPas = psd.IsPassdPas;
    BspEeWrites(EE_ADDR_SATRT + i,(u8*)&eeprom.psd,sizeof(eeprom.psd));
}
u32  PasswordGet_ee(void)        //开机是读取密码
{
    int i;
    i =  (int)&eeprom.psd -  (int)&eeprom;
    BspEeReads(EE_ADDR_SATRT + i,(u8*)&eeprom.psd,sizeof(eeprom.psd));
    psd.passd = eeprom.psd.passd;
    psd.IsPassdPas = eeprom.psd.IsPassdPas;
    return  psd.passd;
}
//***************************************************************************************
//***************************************************************************************
#define    GAS_MAX_DFT            436        //默认罐体容量
#define    GAS_LOW_PF_DFT        4200    //默认最小电容值
#define    GAS_HIG_PF_DFT        5600    //默认最da电容值  0.1PF
#define    GAS_LOW_ALM_VLUE    80        //默认低液位报警值 L
#define    GAS_HIG_ALM_VLUE    450        //默认低液位报警值 H

#define    PRESS_MAX_DFT        200        //压力的最大值
#define    PRESS_HIG_ALM_VLUE    120        //压力高报警门限
#define    PRESS_LOW_ALM_VLUE     20        //压力低报警门限
#define    PRESS_BUFFER_MAX_DFT        200        //缓冲压的最大值,用于计算百分比
#define    PRESS_BUFFER_HIG_ALM_VLUE    120        //压力高报警门限
#define    PRESS_BUFFER_LOW_ALM_VLUE     20        //压力低报警门限
//通信的数据传输结构体
typedef    struct
{
    u16    GasNowPf;                    //当前电容值    0-65535    0.1pf
    u8    PressNow;                    //当前压力        0-255    0-2.55MP
    u8    PressBufferNow;                //当前缓冲压    0-255    0-2.55MP
    u16    TemperatureNow;                //当前温度        0-65535
    u8    NC;
    u8    IsGasBreak:1;                //断路                *.
    u8    IsGasShort:1;                //断路                *.
    u8    IsPressHardFault:1;            //压力故障            *.
    u8    IsPressBufferHardFault:1;    //缓冲压故障        *.
}Tran;
//气瓶参数设置与修改
static u32    JarSetn    =1;                //当前正在设置的瓶号 1--4
typedef    struct
{
    u16    GasNow;                        //当前值
    u16    GasNowPerSent;                //百分比
    u16    GasMax;                        //最大值            计算得出
    u16    GasNowPf;                    //当前电容            由通信获取数据
    u16    GasLowPf;                    //低值                计算得出
    u16    GasHigPf;                    //高值                计算得出
    u16    PressNow;                    //当前压力            由通信获取数据
    u16    PressNowPerSent;            //压力百分比
    u16    PressBufferNow;                //当前缓冲压        由通信获取数据
    u16    PressBufferNowPerSent;        //缓冲压百分比
    u16    TemperatureNow;                //当前温度            由通信获取数据
    u32    IsTransOk:1;                //通信是否正常        由通信获取数据
    u32    IsGasBreak:1;                //断路                由通信获取数据
    u32    IsGasShort:1;                //断路                由通信获取数据
    u32    IsGasLowAlarming:1;            //低报警
    u32    IsGasHigAlarming:1;            //高报警
    u32    IsPressHardFault:1;            //压力故障            由通信获取数据
    u32    IsPressLowAlarming:1;        //压力低
    u32    IsPressHigAlarming:1;        //压力高
    u32    IsPressBufferHardFault:1;    //缓冲压故障        由通信获取数据
    u32    IsPressBufferLowAlarming:1;    //缓冲压低
    u32    IsPressBufferHigAlarming:1;    //缓冲压高
}LNG;
static LNG Lng[4];
/*****************************************************************************************
                                    数据处理
*****************************************************************************************/

//内部函数声明
int    FunTrans(Tran *trans,u32 *id);
//功能项初始化
void FunInit(void)
{
    int j;
    int    i;
    
    BspEeReads(EE_ADDR_SATRT,(u8*)&eeprom,sizeof(EEPROM));
    if (eeprom.IsFist != 0xa5a5a5a3)
    {
        eeprom.IsFist = 0xa5a5a5a3;
        i =  (int)&eeprom.IsFist -  (int)&eeprom;    //地址偏移
        BspEeWrites(EE_ADDR_SATRT + i,(u8*)&eeprom.IsFist,sizeof(eeprom.IsFist));
        
        PasswordSet_ee(11);                            //初始密码

        SysSet.IsBeepOn = true;                        // 初始化系统设置
        SysSet.IsGasCkeck = false;
        SysSet.IsGasLowAlarm = true;
        SysSet.IsUsePionter = false;
        SysSet.JarNumber = 1;
        SysSet_ee();
        
        for (j = 0;j<4;j++)                            //罐子初始化
        {
            Lng[j].GasMax = GAS_MAX_DFT;
            Lng[j].GasLowPf = GAS_LOW_PF_DFT;
            Lng[j].GasHigPf = GAS_HIG_PF_DFT;
            JarGasSet_ee(j+1);
        }
    }

    //密码初始化
    i = PasswordGet_ee();
    PasswordSet(i);
    
    //系统设置
    SysGet_ee();                                //从EE读取

    //气体设置初始化
    for(i =    1;i    < 5;i++)
    {
        JarGasGet_ee(i);
    }
    
    //可燃气体
    for(i =    0;i    < BRUNT_GAS_NUM;i++)
    {
        BurntGas[i].BurntGasPerSent    = 0;        //浓度
        BurntGas[i].BurntGasAlarmVlue =    12;        //设置报警阀值
    }
}

void FunTask_FaultSet(LNG *lng);
//功能任务函数
void FunTask(void)
{
    Tran tr;
    u32    id = 0;
    u32    i;
    u8    TransOk[4];        //用于检测通信是否正常
    while(1)
    {
        //进行4次通信检测
        TransOk[0] = 0;
        TransOk[1] = 0;
        TransOk[2] = 0;
        TransOk[3] = 0;
        for(i =    0;i    < 4;i++)
        {
            if(1==FunTrans(&tr,&id))
            {
                //返回id值==[1-4]
                id--;
                TransOk[id]    = 1;
                //通信正常,并获取相应的值
                Lng[id].IsTransOk =    true;
                Lng[id].GasNowPf = tr.GasNowPf;
                Lng[id].PressNow = tr.PressNow;
                Lng[id].PressBufferNow = tr.PressBufferNow;
                Lng[id].TemperatureNow = tr.TemperatureNow;
                Lng[id].IsGasBreak = tr.IsGasBreak;
                Lng[id].IsGasShort = tr.IsGasShort;
                Lng[id].IsPressHardFault = tr.IsPressHardFault;
                Lng[id].IsPressBufferHardFault = tr.IsPressBufferHardFault;
                //根据值，计算和判断相应的标志
                FunLngChecks(id);
            }
        }
        Lng[0].IsTransOk = TransOk[0];
        Lng[1].IsTransOk = TransOk[1];
        Lng[2].IsTransOk = TransOk[2];
        Lng[3].IsTransOk = TransOk[3];
        FunTask_FaultSet(&Lng[0]);
        FunTask_FaultSet(&Lng[1]);
        FunTask_FaultSet(&Lng[2]);
        FunTask_FaultSet(&Lng[3]);
        OSTimeDlyMs(1000);
    }
}
//当通信故障时，清除以前的数据
void FunTask_FaultSet(LNG *lng)
{
    //无故障则不处理
    if(lng->IsTransOk)
    {
        return;
    }
    //清楚硬件故障
    lng->IsGasBreak    = 0;
    lng->IsGasShort    = 0;
    lng->IsPressHardFault =    0;
    lng->IsPressBufferHardFault    = 0;
    
    //清除报警标志
    lng->IsGasHigAlarming =    0;
    lng->IsGasLowAlarming =    0;
    lng->IsPressBufferHigAlarming =    0;
    lng->IsPressBufferLowAlarming =    0;
    lng->IsPressHigAlarming    = 0;
    lng->IsPressLowAlarming    = 0;


    //对所有值清零
    lng->GasNow    = 0;
    lng->GasNowPerSent = 0;
    lng->GasNowPf =    0;
    lng->PressBufferNow    = 0;
    lng->PressBufferNowPerSent = 0;
    lng->PressNow =    0;
    lng->PressNowPerSent = 0;
    lng->TemperatureNow    = 0;
}
//进行转换及换算功能
void FunLngChecks(u32 id)
{
    u32    max;
    u32    min;
    u32    now;
    if(id >= 4)
    {
        while(1);
    }
    //-------------------计算液位 按线性计算---------------
    max    = Lng[id].GasHigPf;
    min    = Lng[id].GasLowPf;
    now    = Lng[id].GasNowPf;
    if(now > max)
    {
        now    = max;
    }
    if(now < min)
    {
        now    = min;
    }
    now    = now -    min;
    now    = (now*1000)/(max -    min);        //得到千分比
    Lng[id].GasNowPerSent =    now/10;        //=>百分比
    now    = Lng[id].GasMax*now / 1000;    //=>实际量
    Lng[id].GasNow = now;
    Lng[id].IsGasLowAlarming = 0;        //=>高低液位报警
    if(now <= GAS_LOW_ALM_VLUE)
    {
        Lng[id].IsGasLowAlarming = 1;
    }
    Lng[id].IsGasHigAlarming = 0;
    if(now >= GAS_HIG_ALM_VLUE)
    {
        Lng[id].IsGasHigAlarming = 1;
    }
    //--------------压力计算----------------------
    Lng[id].IsPressHigAlarming = 0;
    Lng[id].IsPressLowAlarming = 0;
    if(Lng[id].IsPressHardFault)
    {
        Lng[id].PressNow = 0;
    }else
    {
        if(Lng[id].PressNow    > PRESS_HIG_ALM_VLUE)
        {
            Lng[id].IsPressHigAlarming = 1;
        }
        if(Lng[id].PressNow    < PRESS_LOW_ALM_VLUE)
        {
            Lng[id].IsPressLowAlarming = 1;
        }
        //计算百分比
        if (Lng[id].PressNow > PRESS_BUFFER_MAX_DFT)
        {
            Lng[id].PressNow = PRESS_BUFFER_MAX_DFT;
        }
        max    = Lng[id].PressNow * 100/PRESS_BUFFER_MAX_DFT;
        Lng[id].PressNowPerSent    = max;
    }
    //-------------------缓冲压计算------------------
    Lng[id].IsPressBufferHigAlarming = 0;
    Lng[id].IsPressBufferLowAlarming = 0;
    if(Lng[id].IsPressBufferHardFault)
    {
        Lng[id].PressBufferNow = 0;
        Lng[id].PressBufferNowPerSent =    0;
    }else
    {
        //报警值测试
        if(Lng[id].PressBufferNow >    PRESS_BUFFER_HIG_ALM_VLUE)
        {
            Lng[id].IsPressBufferHigAlarming = 1;
        }
        if(Lng[id].PressBufferNow <    PRESS_BUFFER_LOW_ALM_VLUE)
        {
            Lng[id].IsPressBufferLowAlarming = 1;
        }
        //计算百分比
        if (Lng[id].PressBufferNow > PRESS_BUFFER_MAX_DFT)
        {
            Lng[id].PressBufferNow = PRESS_BUFFER_MAX_DFT;
        }
        max    = Lng[id].PressBufferNow * 100/PRESS_BUFFER_MAX_DFT;
        Lng[id].PressBufferNowPerSent =    max;
    }
}
/*****************************************************************************************
                                    通信
*****************************************************************************************/
//显示收到的消息,调试用
void FunTrans_dis(Tran *trans);
//通信函数
//返回 1有通信    0无通信
static Tran    TranBuf[2];                                //通信缓冲器
int    FunTrans(Tran *trans,u32 *id)
{
    int    i;
    //接收数据
    i =    BspUart2Recvs((u8*)&TranBuf[0],16,100);        //多接收是容错
    //DBG_S_U32N("recv",i);

    if(i !=    8)
    {
        return 0;
    }
    trans->GasNowPf    = TranBuf[0].GasNowPf;
    trans->IsGasBreak =    TranBuf[0].IsGasBreak;
    trans->IsGasShort =    TranBuf[0].IsGasShort;
    trans->IsPressBufferHardFault =    TranBuf[0].IsPressBufferHardFault;
    trans->IsPressHardFault    = TranBuf[0].IsPressHardFault;
    trans->PressBufferNow =    TranBuf[0].PressBufferNow;
    trans->PressNow    = TranBuf[0].PressNow;
    trans->TemperatureNow =    TranBuf[0].TemperatureNow;
    trans->NC =    TranBuf[0].NC;
    *id    = trans->NC;
    FunTrans_dis(trans);
    return 1;
}

void FunTrans_dis(Tran *Tn)
{
    //测试信息
    DBG_S_U32N("GasNowPf",Tn->GasNowPf);
    DBG_S_U32N("PressNow",Tn->PressNow);
    DBG_S_U32N("PressBufferNow",Tn->PressBufferNow);
    DBG_S_U32N("TemperatureNow",Tn->TemperatureNow);
    OSTimeDlyMs(100);
    DBG_S_U32N("id",Tn->NC);
    DBG_S_U32N("IsGasBreak",Tn->IsGasBreak);
    DBG_S_U32N("IsGasShort",Tn->IsGasShort);
    DBG_S_U32N("IsPressHardFault",Tn->IsPressHardFault);
    DBG_S_U32N("IsPressBufferHardFault",Tn->IsPressBufferHardFault);
    OSTimeDlyMs(100);    
}


//通信函数
//返回 1有通信    0无通信     在没用通信时的初始函数
int    FunTrans_(Tran *trans,u32 *id)
{
    //通信检测
    //return BspCanRecvs(id,(u8    *)trans);
    static int pf =    0;
    static int i = 1;

    if(pf == 1)
    {
        trans->GasNowPf    = 4500;
        trans->IsGasBreak =    0;
        trans->IsGasShort =    0;
        trans->IsPressBufferHardFault =    0;
        trans->IsPressHardFault    = 0;
        trans->PressBufferNow =     100;
        trans->PressNow    = 100;
        trans->TemperatureNow =    15;
    }
    if(pf == 20)
    {
        trans->GasNowPf    = 4800;
        trans->IsGasBreak =    1;
        trans->IsGasShort =    1;
        trans->IsPressBufferHardFault =    1;
        trans->IsPressHardFault    = 1;
        trans->PressBufferNow =     150;
        trans->PressNow    = 160;
        trans->TemperatureNow =    15;
    }
    if(pf == 40)
    {
        trans->GasNowPf    = 5900;
        trans->IsGasBreak =    0;
        trans->IsGasShort =    0;
        trans->IsPressBufferHardFault =    0;
        trans->IsPressHardFault    = 0;
        trans->PressBufferNow =     100;
        trans->PressNow    = 100;
        trans->TemperatureNow =    15;
    }

    if(pf >= 60)
    {
        pf = 0;
    }
    pf ++;
    
    *id    = i;
    i++;
    if (i >4)
    {
        i =    1;
    }
    return 1;
}

/*****************************************************************************************
                                    与界面的交互
*****************************************************************************************/
void JarGasSet_ee(u32    n)                //设置当前瓶号1--4，将设置保存到ee
{
    int i;
    //最大电容值
    //最小电容值
    //满灌时的容量值
    eeprom.GasParn[n-1].GasMax = Lng[n-1].GasMax;
    eeprom.GasParn[n-1].GasLowPf = Lng[n-1].GasLowPf;
    eeprom.GasParn[n-1].GasHigPf = Lng[n-1].GasHigPf;
    i =  (int)&eeprom.GasParn[n-1] -  (int)&eeprom;
    BspEeWrites(EE_ADDR_SATRT + i,(u8*)&eeprom.GasParn[n-1],sizeof(eeprom.GasParn[n-1]));
}
void JarGasGet_ee(u32    n)                //获取设置当前瓶号1--4，从ee读取
{    
    int i;
    i =  (int)&eeprom.GasParn[n-1] -  (int)&eeprom;
    BspEeReads(EE_ADDR_SATRT + i,(u8*)&eeprom.GasParn[n-1],sizeof(eeprom.GasParn[n-1]));
    Lng[n-1].GasMax = eeprom.GasParn[n-1].GasMax;
    Lng[n-1].GasLowPf = eeprom.GasParn[n-1].GasLowPf;
    Lng[n-1].GasHigPf = eeprom.GasParn[n-1].GasHigPf;
}

u32     JarSetnGet(void)                    //获取当前瓶号1--4
{
    return JarSetn;
}
void JarSetnSet(u32    n)                    //设置当前瓶号1--4
{
    if(JarSetn > 4)
    {
        JarSetn    = 4;
    }
    if(    JarSetn    < 1)
    {
        JarSetn    = 1;
    }
    JarSetn    = n;
}
//----液位相关--------------------------
u32    JarGasNowPerSentGet(void)            //获取当前瓶号的实时_液位值_百分比0--100
{
    return Lng[JarSetn-1].GasNowPerSent;
}
u32    JarGasNowGet(void)                    //获取当前瓶号的实时_液位值
{
    return Lng[JarSetn-1].GasNow;
}
u32    JarMaxGasGet(void)                    //获取当前瓶号的_最大容量
{
    return Lng[JarSetn-1].GasMax;
}
void JarMaxGasSet(u32 maxgas)            //设置当前瓶号的_最大容量
{
    Lng[JarSetn-1].GasMax =    maxgas;
}
//----电容值相关------------------------
u32    JarGasNowPfGet(void)                //获取当前瓶号的_实时电容值
{
    return Lng[JarSetn-1].GasNowPf/10;
}
u32    JarGasLowPfGet(void)                //获取当前瓶号的_最小电容值
{
    return Lng[JarSetn-1].GasLowPf/10;
}
void JarGasLowPfSet(u32    vlue)            //设置当前瓶号的_最小电容值
{
    Lng[JarSetn-1].GasLowPf    = vlue*10;
}
u32    JarGasHigPfGet(void)                //获取当前瓶号的_最大电容值
{
    return Lng[JarSetn-1].GasHigPf/10;;
}
void JarGasHigPfSet(u32    vlue)            //设置当前瓶号的_最大电容值
{
    Lng[JarSetn-1].GasHigPf    = vlue*10;
}
//----压力相关--------------------------
u32      JarPressNowPerSentGet(void)        //获取当前瓶号的实时_瓶压_百分比
{
    //此处保证返回0--100
    return Lng[JarSetn-1].PressNowPerSent;
}
float JarPressNowGet(void)                //获取当前瓶号的实时_瓶压
{
    float f;
    f =    ((float)Lng[JarSetn-1].PressNow)/100;
    return f;
}
//---- 缓冲压力相关---------------------
u32      JarBufferPressNowPerSentGet()        //获取当前瓶号的实时_缓冲压_百分比
{
    //此处保证返回0--100
    return Lng[JarSetn-1].PressBufferNowPerSent;
}
float JarBufferPressNowGet(void)        //获取当前瓶号的实时_缓冲压
{
    float f;
    f =    ((float)Lng[JarSetn-1].PressBufferNow)/100;
    return f;
}
u32    JarTemperatureNowGet(void)            //获取当前瓶号的实时_温度
{
    return Lng[JarSetn-1].TemperatureNow;
}
//---------硬件故障检测-----------------
//电容检测器断路检测
bool IsJarCapBreak(u32 JarSetn)            //输入1--4
{
    return Lng[JarSetn-1].IsGasBreak;
}
//电容检测器短路检测
bool IsJarCapShort(u32 JarSetn)
{
    return Lng[JarSetn-1].IsGasShort;
}
//低液位检测
bool IsLngLow(u32 JarSetn)
{
    return Lng[JarSetn-1].IsGasLowAlarming;
}
//高液位检测
bool IsLngHig(u32 JarSetn)
{
    return Lng[JarSetn-1].IsGasHigAlarming;
}
//气瓶压力高
bool IsPressHig(u32    JarSetn)
{
    //故障时不报警
    if (Lng[JarSetn-1].IsPressHardFault)
    {
        return false;
    }
    return Lng[JarSetn-1].IsPressHigAlarming;
}
//气瓶压力低
bool IsPressLow(u32    JarSetn)
{
    //故障时不报警
    if (Lng[JarSetn-1].IsPressHardFault)
    {
        return false;
    }
    return Lng[JarSetn-1].IsPressLowAlarming;
}
//缓冲压力高
bool IsPressBufferHig(u32 JarSetn)
{
    //故障时不报警
    if (Lng[JarSetn-1].IsPressBufferHardFault)
    {
        return false;
    }
    return Lng[JarSetn-1].IsPressBufferHigAlarming;
}
//缓冲压力低
bool IsPressBufferLow(u32 JarSetn)
{
    //故障时不报警
    if (Lng[JarSetn-1].IsPressBufferHardFault)
    {
        return false;
    }
    return Lng[JarSetn-1].IsPressBufferLowAlarming;
}
//通信故障检测
bool IsTranFault(u32 JarSetn)
{
    return !Lng[JarSetn-1].IsTransOk;
}
//气瓶压力传感器故障
bool IsPressFault(u32 JarSetn)
{
    return Lng[JarSetn-1].IsPressHardFault;
}
//缓冲压传感器故障
bool IsPressBufferFault(u32    JarSetn)
{
    return Lng[JarSetn-1].IsPressBufferHardFault;
}