.import "modbus.js" as ModbusJs

//试验运行标志
var running = false
var runningBackup = false
//开启压力测试计时时间
var openPressureTimeMax = 10
//密封压力测试计时时间
var sealPressureTimemax = 5
//安全阀默认整定压力
var setPressure = 0

//盲测开启压力
var estimate_Pressure = 0

var setPressure_real = 100
//次参数不用
var exit = false


var pthreshold_Setzero = 0.5
var delaycount_Setzero = 5

var delayInterval = 5 // ms
//var maxPressureStableTime = 20
var releasePressureTimeOut = 180


function playStart_Voice(controlSerial){
    ModbusJs.voiceplayer_Play(controlSerial, ModbusJs.safevalvestart_voice)
}

function playStop_Voice(controlSerial){
    ModbusJs.voiceplayer_Play(controlSerial, ModbusJs.teststop_voice)
}

function gripPressDown(controlSerial, processWindow, spy){
    var ret = false
    var time_count = 0

    do{

        if(ret === false){
            ret = ModbusJs.electriccylinderDownCtrl(controlSerial,true)
            time_count = 0
        }

        spy.wait(1000)
        time_count++

    }while(time_count <= 10)


    if(ret ===  true){
        ModbusJs.electriccylinderDownCtrl(controlSerial,false)
    }

    return ret
}

function gripRiseUp(controlSerial, processWindow, spy){
    var ret = false
    var time_count = 0

    do{

        // if(running === false){
        //     console.log("停止测试")
        //     break;
        // }

        if(ret === false){
            ret = ModbusJs.electriccylinderUpCtrl(controlSerial,true)
            time_count = 0
        }

        spy.wait(1000)
        time_count++

    }while(time_count <= 10)


    if(ret ===  true){
        ModbusJs.electriccylinderUpCtrl(controlSerial,false)
    }

    return ret

}


//罐体压力检查 用于液压升降时 压力检查
function valvePressureCheckStop(controlSerial,processWindow,pressureDisplaySigFun,spy,log)
{
    spy.wait(300)
    //关闭高压高速进气阀门
    ModbusJs.hphs_IntakeCtrl(controlSerial,false)
    console.log("关闭高压高速进气阀门")

    //关闭高压中速进气阀门
    ModbusJs.hpms_IntakeCtrl(controlSerial,false)
    console.log("关闭高压中速进气阀门")

    //关闭高压低速进气阀门
    ModbusJs.hpls_IntakeCtrl(controlSerial,false)
    console.log("关闭高压低速进气阀门")

    //打开安全阀测试口
    ModbusJs.safeValve_TestIO(controlSerial,true)
    console.log("打开安全阀测试口")

    //打开高压高速泄气阀门
    ModbusJs.hphs_ReleaseCtrl(controlSerial,true)
    console.log("打开高压高速泄气阀门")

    var timeout = 0
    //查看高压传感器值 等待正压罐头压力降到最低值
    do{

        if(runningBackup === false && running === true){
            console.log("停止检查")
            ModbusJs.relay1CloseAll(controlSerial)
            return false
        }
        var obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
        if(obj.ret === false){
            log.show("高传感器通讯错误")
            return false
        }
        // signal 压力显示函数
        pressureDisplaySigFun(obj.pressureNumber)

        if(obj.pressureNumber > pthreshold_Setzero){
            //延时
            spy.wait(900)
            timeout++
        }


    }while(obj.pressureNumber > pthreshold_Setzero  && timeout < 10)
    // ModbusJs.closeAllValve(controlSerial)

    //关闭安全阀测试口
    ModbusJs.safeValve_TestIO(controlSerial,false)
    console.log("关闭安全阀测试口")

    //关闭高压高速泄气阀门
    ModbusJs.hphs_ReleaseCtrl(controlSerial,false)
    console.log("关闭高压高速泄气阀门")

    if(timeout === 10){
        return false
    }else{
        return true
    }

}

//试验异常中止退出 泄压操作
/*  controlSerial           控制串口对象
 *  pressureDisplaySigFun   压力显示信号函数(回调函数)
 *  resultSigFun            结果显示信号函数(回调函数)
 *  spy                     仅用于延时的对象
 *  log                     异常显示对象
 */
function valveStop(controlSerial,pressureDisplaySigFun,spy,log){

    spy.wait(300)
    //关闭高压高速进气阀门
    ModbusJs.hphs_IntakeCtrl(controlSerial,false)
    console.log("关闭高压高速进气阀门")

    //关闭高压中速进气阀门
    ModbusJs.hpms_IntakeCtrl(controlSerial,false)
    console.log("关闭高压中速进气阀门")

    //关闭高压低速进气阀门
    ModbusJs.hpls_IntakeCtrl(controlSerial,false)
    console.log("关闭高压低速进气阀门")

    //打开安全阀测试口
    ModbusJs.safeValve_TestIO(controlSerial,true)
    console.log("打开安全阀测试口")

    //打开高压高速泄气阀门
    ModbusJs.hphs_ReleaseCtrl(controlSerial,true)
    console.log("打开高压高速泄气阀门")

    var timeout = 0
    var end_count = 0
    //查看高压传感器值 等待正压罐头压力降到最低值
    do{
        if(runningBackup === false && running === true){
            console.log("停止测试")
            ModbusJs.relay1CloseAll(controlSerial)
            return
        }

        if(exit === true)
            return

        var obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
        if(obj.ret === false){
            log.show("高传感器通讯错误")
            return false
        }
        // signal 压力显示函数
        pressureDisplaySigFun(obj.pressureNumber)
        //延时
        spy.wait(900)
        timeout++
        if(obj.pressureNumber < pthreshold_Setzero ){
            end_count++
        }

    }while(end_count < delaycount_Setzero && timeout < releasePressureTimeOut )


    ModbusJs.relay1CloseAll(controlSerial)
    console.log("关闭 关闭所有阀门")
}

//正压开启压力和密封试验
/*  currentIndex            当前第几次试验
 *  controlSerial           控制串口对象
 *  sensorSerial            压力传感器串口对象
 *  pressureDisplaySigFun   压力显示信号函数(回调函数)
 *  resultSigFun            结果显示信号函数(回调函数)
 *  spy                     仅用于延时的对象
 *  log                     异常显示对象
 *  openPressureModel       测试整定压力记录压力的数据模型
 *  sealPressureModel       测试密封压力记录压力的数据模型
 *  blindTestpressureSigFun
 */
function valveStartBlindTest(currentIndex,processWindow,controlSerial,sensorSerial,
                    pressureDisplaySigFun,resultSigFun,blindTestpressureSigFun,spy,log)
{


    runningBackup = running
    var ret = true
    //var StablePressureCount = maxPressureStableTime*1000/readPressureInterval

    var openPressureNumber
    var sealPressureNumber

    console.log("安全阀测试开始")

    //step 1
    // 关闭所有气路电磁阀
    ModbusJs.relay1CloseAll(controlSerial)
    console.log("关闭所有气路电磁阀")

    spy.wait(500)

    //盲测压力

    //打开安全阀测试口
    ModbusJs.safeValve_TestIO(controlSerial,true)
    console.log("打开安全阀测试口")


    processWindow.show("开始盲测压力")
    estimate_Pressure = 0
    var prevTime  = Date.now()
    var keepCnt = 0
    var delta = 0
    var preDelta = 0

    ModbusJs.hphs_IntakeCtrl(controlSerial,true)
    console.log("打开高压高速进气阀门")
    //打开高压中速进气阀门
    ModbusJs.hpms_IntakeCtrl(controlSerial,true)
    console.log("打开高压中速进气阀门")

    var obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
    if(obj.ret === false){
        log.show("高压传感器通讯错误")
        return false
    }

    var pre_pressure = obj.pressureNumber
    var pre_pressure2 = obj.pressureNumber2

    ret = true

    do{
        //延时
        spy.wait(delayInterval)

        if(running === false){
            console.log("安全阀整定压力--停止测试")
            ModbusJs.relay1CloseAll(controlSerial)
            console.log("关闭所有气路阀门")
            return false
        }


        var curTime  = Date.now()
        var deltaTime = curTime - prevTime



        if(deltaTime >= 980){

            obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
            if(obj.ret === false){
                log.show("高压传感器通讯错误")
                ModbusJs.relay1CloseAll(controlSerial)
                console.log("关闭所有气路阀门")
                return false
            }

            delta = obj.pressureNumber2 - pre_pressure2

            if((obj.pressureNumber2 - pre_pressure2) < 0.5){
                keepCnt++
                if(keepCnt ==1){
                    estimate_Pressure = obj.pressureNumber
                    setPressure = estimate_Pressure
                }
            }else{
                keepCnt=0
            }

            if(keepCnt >= 6){
                //console.log("keepCnt > StablePressureCount")
                break;
            }

            prevTime = curTime

            pre_pressure = obj.pressureNumber
            pre_pressure2 = obj.pressureNumber2

            pressureDisplaySigFun(obj.pressureNumber)
            // add  pressure table
            // var table={}
            // table.pressure=obj.pressureNumber
            // //开启压力模型赋值
            // openPressureModel.append(table)
        }

    }while(1)

    ModbusJs.hphs_IntakeCtrl(controlSerial,false)
    console.log("关闭高压高速进气阀门")
    //关闭高压中速进气阀门
    ModbusJs.hpms_IntakeCtrl(controlSerial,false)
    console.log("关闭高压中速进气阀门")

    blindTestpressureSigFun(estimate_Pressure)

}

//正压开启压力和密封试验
/*  currentIndex            当前第几次试验
 *  controlSerial           控制串口对象
 *  sensorSerial            压力传感器串口对象
 *  pressureDisplaySigFun   压力显示信号函数(回调函数)
 *  resultSigFun            结果显示信号函数(回调函数)
 *  spy                     仅用于延时的对象
 *  log                     异常显示对象
 *  openPressureModel       测试整定压力记录压力的数据模型
 *  sealPressureModel       测试密封压力记录压力的数据模型
 */
function valveStart(currentIndex,tabView,processWindow,controlSerial,sensorSerial,
                    openPressureModel,sealPressureModel,
                    pressureDisplaySigFun,resultSigFun,spy,log)
{

    runningBackup = running
    var ret = true
    //var StablePressureCount = maxPressureStableTime*1000/readPressureInterval

    var openPressureNumber
    var sealPressureNumber

    console.log("安全阀测试开始")

    //step 1
    // 关闭所有气路电磁阀
    ModbusJs.relay1CloseAll(controlSerial)
    console.log("关闭所有气路电磁阀")

    spy.wait(500)

    //盲测压力

    // //打开安全阀测试口
    // ModbusJs.safeValve_TestIO(controlSerial,true)
    // console.log("打开安全阀测试口")


    // processWindow.show("开始盲测压力")
    var prevTime  = Date.now()
    var keepCnt = 0
    var delta = 0
    var preDelta = 0

    /*
    ModbusJs.hphs_IntakeCtrl(controlSerial,true)
    console.log("打开高压高速进气阀门")
    //打开高压中速进气阀门
    ModbusJs.hpms_IntakeCtrl(controlSerial,true)
    console.log("打开高压中速进气阀门")

    var obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
    if(obj.ret === false){
        log.show("高压传感器通讯错误")
        return false
    }

    var pre_pressure = obj.pressureNumber
    var pre_pressure2 = obj.pressureNumber2

    ret = true

    do{
        //延时
        spy.wait(delayInterval)

        if(running === false){
            console.log("安全阀整定压力--停止测试")
            ModbusJs.relay1CloseAll(controlSerial)
            console.log("关闭所有气路阀门")
            return false
        }


        var curTime  = Date.now()
        var deltaTime = curTime - prevTime



        if(deltaTime >= 980){

            obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
            if(obj.ret === false){
                log.show("高压传感器通讯错误")
                ModbusJs.relay1CloseAll(controlSerial)
                console.log("关闭所有气路阀门")
                return false
            }

            delta = obj.pressureNumber2 - pre_pressure2

            if((obj.pressureNumber2 - pre_pressure2) < 0.5){
                keepCnt++
                if(keepCnt ==1){
                    estimate_Pressure = obj.pressureNumber
                    setPressure = estimate_Pressure
                }
            }else{
                keepCnt=0
            }

            if(keepCnt >= 6){
                //console.log("keepCnt > StablePressureCount")
                break;
            }

            prevTime = curTime

            pre_pressure = obj.pressureNumber
            pre_pressure2 = obj.pressureNumber2

            pressureDisplaySigFun(obj.pressureNumber)
            // add  pressure table
            // var table={}
            // table.pressure=obj.pressureNumber
            // //开启压力模型赋值
            // openPressureModel.append(table)
        }

    }while(1)

    ModbusJs.hphs_IntakeCtrl(controlSerial,false)
    console.log("关闭高压高速进气阀门")
    //关闭高压中速进气阀门
    ModbusJs.hpms_IntakeCtrl(controlSerial,false)
    console.log("关闭高压中速进气阀门")

    */

    //step 2
    //压力清零

    //打开安全阀测试口
    ModbusJs.safeValve_TestIO(controlSerial,true)
    console.log("打开安全阀测试口")

    //打开高压高速泄气阀门
    ModbusJs.hphs_ReleaseCtrl(controlSerial,true)
    console.log("打开高压高速泄气阀门")

    //查看高压传感器值 等待压力罐压力为0
    processWindow.show("等待压力降到0")

    var timeout = 0
    var end_count = 0

    do{
        //延时
        spy.wait(900)

        if(running === false){
            console.log("停止测试")
            return false
        }
        var obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
        if(obj.ret === false){
            log.show("高压传感器通讯错误")
            return false
        }

        // signal 压力显示函数
        pressureDisplaySigFun(obj.pressureNumber)

        timeout++
        if(obj.pressureNumber <= pthreshold_Setzero){
            end_count++;
        }

    }while(end_count < 2 && timeout < releasePressureTimeOut)
    console.log("压力降压到 0 kPa")

    if(timeout === releasePressureTimeOut){
        log.show("泄压超时")
        ModbusJs.relay1CloseAll(controlSerial)
        console.log("关闭所有气路阀门")
        return false
    }

    //关闭高压高速泄气阀门
    ModbusJs.hphs_ReleaseCtrl(controlSerial,false)
    console.log("关闭高压高速泄气阀门")


    //step 3 整定压力测试

    /*********测试整定压力*************/

    // //打开高压高速进气阀门
    // ModbusJs.hphs_IntakeCtrl(controlSerial,true)
    // console.log("打开高压高速进气阀门")

    // //打开高压中速进气阀门
    // ModbusJs.hpms_IntakeCtrl(controlSerial,true)
    // console.log("打开高压中速进气阀门")

    //打开高压低速进气阀门
    ModbusJs.hpls_IntakeCtrl(controlSerial,true)
    console.log("打开高压低速进气阀门")

    processWindow.show("整定压力测试")
    console.log("整定压力测试开始")

    //切换当前tab页面
    tabView.currentIndex = currentIndex

    delta = 0
    keepCnt = 0
    prevTime  = Date.now()
    preDelta = 0
    var min = 0.8*estimate_Pressure
    var max = 1.2*estimate_Pressure

    //var setPressure = 100
    var highspeed_open = false
    var middlespeed_open = false
    var switch_pressure = estimate_Pressure-35
    var last_pressure = 0.1*estimate_Pressure

     if(estimate_Pressure >= 100){
        //打开高压高速进气阀门
        ModbusJs.hphs_IntakeCtrl(controlSerial,true)
        console.log("打开高压高速进气阀门")
        highspeed_open = true

        //打开高压中速进气阀门
        ModbusJs.hpms_IntakeCtrl(controlSerial,true)
        console.log("打开高压中速进气阀门")
         middlespeed_open = true

     }else if(estimate_Pressure >= 40){
         //打开高压中速进气阀门
        ModbusJs.hpms_IntakeCtrl(controlSerial,true)
        console.log("打开高压中速进气阀门")
        middlespeed_open = true

        min = 0.5*estimate_Pressure
        max = 1.5*estimate_Pressure
    }else{
        min = 0.2*estimate_Pressure
        max = 2*estimate_Pressure
    }

    obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
    if(obj.ret === false){
        log.show("高压传感器通讯错误")
        ModbusJs.relay1CloseAll(controlSerial)
        console.log("关闭所有气路阀门")
        return false
    }

    var pre_pressure = obj.pressureNumber
    var pre_pressure2 = obj.pressureNumber2

    ret = true

    do{
        //延时
        spy.wait(delayInterval)

        if(running === false){
            console.log("安全阀整定压力--停止测试")
            ModbusJs.relay1CloseAll(controlSerial)
            console.log("关闭所有气路阀门")
            return false
        }


        var curTime  = Date.now()
        var deltaTime = curTime - prevTime
        if(deltaTime >= 980){

            obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
            if(obj.ret === false){
                log.show("高压传感器通讯错误")
                ModbusJs.relay1CloseAll(controlSerial)
                console.log("关闭所有气路阀门")
                return false
            }

            // //开启压力超出范围了
            // if(obj.pressureNumber > max){
            //     log.show("安全阀无法开启")
            //     ret = false
            //     ModbusJs.relay1CloseAll(controlSerial)
            //     console.log("关闭所有气路阀门")
            //     return false
            // }


            if(obj.pressureNumber > switch_pressure){

                // if(last_pressure > 30){
                //     if(highspeed_open === true){
                //         //关闭高压高速进气阀门
                //         ModbusJs.hphs_IntakeCtrl(controlSerial,false)
                //         console.log("关闭高压高速进气阀门")
                //         highspeed_open = false
                //     }

                // }else {

                    if(highspeed_open === true){
                        //关闭高压高速进气阀门
                        ModbusJs.hphs_IntakeCtrl(controlSerial,false)
                        console.log("关闭高压高速进气阀门")
                        highspeed_open = false
                    }else{
                        if(middlespeed_open === true){
                            //关闭高压中速进气阀门
                            ModbusJs.hpms_IntakeCtrl(controlSerial,false)
                            console.log("关闭高压中速进气阀门")
                            middlespeed_open = false
                        }
                    }

                //}

            }



            delta = obj.pressureNumber2 - pre_pressure2

            if((delta < 1.0) && ((delta < (preDelta-0.03)) || (delta <= 0.2))){
                keepCnt++
                if(keepCnt === 1){
                    openPressureNumber = obj.pressureNumber
                }
            }else{
                keepCnt=0
            }

            // console.log("current pressure:"+obj.pressureNumber2+", delta:"+delta+", preDelta: "+preDelta)
            // console.log("keepCnt:"+ keepCnt +" ")

            if(keepCnt >= openPressureTimeMax){
                //console.log("keepCnt > StablePressureCount")
                break;
            }

            preDelta = delta
            prevTime = curTime

            pre_pressure = obj.pressureNumber
            pre_pressure2 = obj.pressureNumber2

            pressureDisplaySigFun(obj.pressureNumber)
            // add  pressure table
            var table={}
            table.pressure=obj.pressureNumber
            //开启压力模型赋值
            openPressureModel.append(table)
        }

    }while(1)

    //通知数据
    pressureDisplaySigFun(obj.pressureNumber)
    // add  pressure table
    table={}
    table.pressure=obj.pressureNumber
    openPressureModel.append(table)

    if(ret === false){
        openPressureNumber = obj.pressureNumber
    }

    setPressure_real = openPressureNumber

    //openPressureNumber = obj.pressureNumber
    var result={}
    result.openPressureNumber = openPressureNumber
    result.sealPressureNumber = ""
    resultSigFun(result)

    console.log("安全阀整定压力:",openPressureNumber)
    console.log("安全阀整定压力测试结束")

    //关闭高压高速进气阀门
    ModbusJs.hphs_IntakeCtrl(controlSerial,false)
    console.log("关闭高压高速进气阀门")

    //关闭高压中速进气阀门
    ModbusJs.hpms_IntakeCtrl(controlSerial,false)
    console.log("关闭高压中速进气阀门")

    //关闭高压低速进气阀门
    ModbusJs.hpls_IntakeCtrl(controlSerial,false)
    console.log("关闭高压低速进气阀门")

    // if(setPressure_real < 30){
    //     console.log("整定压力过小")
    //     log.show("整定压力过小")
    //     return false
    // }

    /*
    //step 3.1 泄压到60%*setPressure_real

    console.log("泄压到60%*setPressure_real")

    var addPressure_target = 0

    if(setPressure_real > 300.0){
        addPressure_target = 0.9*setPressure_real
    }else{
        addPressure_target = setPressure_real-30
    }

    //处理为负值情况
    if(addPressure_target < 10){
        addPressure_target = 10
    }

    processWindow.show("泄放压力到："+(addPressure_target-5)+"kPa")

    //打开高压低速泄气阀门
    ModbusJs.hpls_ReleaseCtrl(controlSerial,true)
    console.log("打开高压低速泄气阀门")

    prevTime = Date.now()
    var prevTime2 = prevTime
    do{
        //延时
        spy.wait(delayInterval)

        if(running === false){
            console.log("停止测试")
            return false
        }

        //压力数据通知
        curTime  = Date.now()
        deltaTime = curTime - prevTime
        if(deltaTime >=20){
            prevTime = curTime
            obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
            if(obj.ret === false){
                log.show("高压传感器通讯错误")
                return false
            }

            // add  pressure table
            // table={}
            // table.pressure=obj.pressureNumber
            // sealPressureModel.append(table)

            if(obj.pressureNumber2 <= (addPressure_target- 5)){
                break
            }

        }

        curTime  = Date.now()
        deltaTime = curTime - prevTime2
        if(deltaTime >= 980){
            prevTime2 = curTime
            pressureDisplaySigFun(obj.pressureNumber)
        }

    }while(1)

    //关闭高压低速泄气阀门
    ModbusJs.hpls_ReleaseCtrl(controlSerial,false)
    console.log("关闭高压低速泄气阀门")

    processWindow.text("等待压力稳定")
    var stableCnt = 0
    do{
        //延时
        spy.wait(980)

        if(running === false){
            console.log("停止测试")
            return false
        }

        obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
        if(obj.ret === false){
            log.show("高压传感器通讯错误")
            return false
        }

        pressureDisplaySigFun(obj.pressureNumber)
        stableCnt++
    }while(stableCnt<5)


    //step 3.2 加压到90%*setPressure_real
     processWindow.show("加压到："+(addPressure_target)+"kPa")

    //打开高压低速进气阀门
    ModbusJs.hpls_IntakeCtrl(controlSerial,true)
    console.log("打开高压低速进气阀门")

    prevTime = Date.now()
     prevTime2 = prevTime
    do{
        //延时
        spy.wait(delayInterval)

        if(running === false){
            console.log("停止测试")
            //关闭高压低速进气阀门
            ModbusJs.hpls_IntakeCtrl(controlSerial,false)
            console.log("关闭高压低速进气阀门")
            return false
        }

        //压力数据通知
        curTime  = Date.now()
        deltaTime = curTime - prevTime
        if(deltaTime >=5){

            prevTime = curTime
            obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
            if(obj.ret === false){
                log.show("高压传感器通讯错误")
                return false
            }

            // add  pressure table
            // table={}
            // table.pressure=obj.pressureNumber
            // sealPressureModel.append(table)

            if(obj.pressureNumber2 >= (addPressure_target-0.8)){
                break
            }

        }

        curTime  = Date.now()
        deltaTime = curTime - prevTime2
        if(deltaTime >= 980){
            prevTime2 = curTime
            pressureDisplaySigFun(obj.pressureNumber)
        }


    }while(1)

    //关闭高压低速进气阀门
    ModbusJs.hpls_IntakeCtrl(controlSerial,false)
    console.log("关闭高压低速进气阀门")



    //step 4
    //*********测试密封压力************
    console.log("密封压力开始")
    processWindow.show("密封压力试验开始")
    tabView.currentIndex = currentIndex+3

    obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
    if(obj.ret === false){
        log.show("高压传感器通讯错误")
        return false
    }

    pre_pressure = obj.pressureNumber
    prevTime = Date.now()
    keepCnt = 0
    preDelta = 0
    //StablePressureCount = sealPressureTimemax*1000/readPressureInterval

    do{
        //延时
        spy.wait(delayInterval)

        if(running === false){
            console.log("停止测试")
            return false
        }

        //压力数据通知
        curTime  = Date.now()
        deltaTime = curTime - prevTime
        if(deltaTime >=980){

            prevTime = curTime
            obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
            if(obj.ret === false){
                log.show("高压传感器通讯错误")
                return false
            }

            keepCnt++
            pressureDisplaySigFun(obj.pressureNumber)
            // add  pressure table
            table={}
            table.pressure=obj.pressureNumber
            sealPressureModel.append(table)
            processWindow.text("密封压力试验时间"+(sealPressureTimemax-keepCnt)+"s")
            //processWindow.text("21kPa压力进气时间"+(sealPressureTimemax-sealCnt)+"s")

        }

    }while(keepCnt < sealPressureTimemax)

    pressureDisplaySigFun(obj.pressureNumber)
    // add  pressure table
    table={}
    table.pressure=obj.pressureNumber
    sealPressureModel.append(table)

    sealPressureNumber = obj.pressureNumber//.toString()
    result={}
    result.openPressureNumber = openPressureNumber
    result.sealPressureNumber = sealPressureNumber
    resultSigFun(result)
    console.log("密封压力:",obj.pressureNumber)
    console.log("密封压力结束")

    */

    //setp 5
    //打开正压罐头泄气阀门
    //打开高压高速泄气阀门
    ModbusJs.hphs_ReleaseCtrl(controlSerial,true)
    console.log("打开高压高速泄气阀门")

    console.log("等待压力 0kPa")
    //查看低压传感器值 等待正压罐头压力降到最低值
    processWindow.show("试验结束，泄压中")
    timeout = 0
    end_count = 0
    do{
        if(running === false){
            console.log("停止测试")
            return false
        }

        obj = ModbusJs.highPressureSensorReadReq(sensorSerial)
        if(obj.ret === false){
            log.show("低压传感器通讯错误")
            return false
        }
        // signal 压力显示函数
        pressureDisplaySigFun(obj.pressureNumber)
        //延时
        spy.wait(950)
        timeout++
        if(obj.pressureNumber <= pthreshold_Setzero){
            end_count++;
        }
    }while(end_count < delaycount_Setzero && timeout < 180)

    //step 6
    //ModbusJs.closeAllValve(controlSerial)
    //ModbusJs.closeAllValve(controlSerial)
    //console.log("关闭所有阀门")

    // 关闭所有气路电磁阀
    ModbusJs.relay1CloseAll(controlSerial)
    console.log("关闭所有气路电磁阀")

    return true

}