#

lsh

2024-06-26 2cebd39fd1514c991da647f08124e18a0b02abe9

#

 src/main/java/com/zy/asrs/entity/WrkMastExecute.java

@@ -102,6 +102,13 @@
    private Integer rgvId;

    /**
     * RGV
     */
    @ApiModelProperty(value= "RGV")
    @TableField("rgv_end_id")
    private Integer rgvEndId;

    /**
     * 作业时间
     */
    @ApiModelProperty(value= "作业时间")
@@ -134,6 +141,14 @@

    /**
     * 工作状态
     * 0:初始  wrk_type
     * 1：RGV小车避让、2：避让完成、3：开门中、4：开门完成、5：更新完成    //io_type = 1、3
     * 1：RGV小车避让、2：避让完成、3：关门中、4：关门完成、5：更新完成    //io_type = 2、4
     * 1：RGV小车移动、2：RGV小车到位、3：rgv取货、4：rgv取货完成、5：Ste穿梭版入硫化罐、6：入罐完成、7：更新完成   //io_type = 5
     * 1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版取货、4：取货完成等待下一步、5：Ste穿梭版放货至冷却池、6：放货完成、7：更新完成   //io_type = 6
     * 1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版移动中、4：移动完成、5：更新完成   //io_type = 7、8
     * 1：Ste穿梭版取放货中、2：放货完成等待下一步、3：输送线任务下发完成、4：更新完成   //io_type = 9
     * 1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版移动中、4：移动完成、5：更新完成   //io_type = 10、11
     */
    @ApiModelProperty(value= "工作状态")
    @TableField("wrk_sts")

 src/main/java/com/zy/asrs/mapper/BasJarMastMapper.java

@@ -6,6 +6,7 @@
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

import java.util.Date;
import java.util.List;

@Mapper
@@ -26,4 +27,7 @@

    Integer selectJarMastOperationByStatusList(@Param("jarId") Integer jarId,@Param("statusList") List<Integer> statusList);

    Integer updateStatus(@Param("jarId") Integer jarId, @Param("status") Integer status, @Param("statusUpdate") Integer statusUpdate);


}

 src/main/java/com/zy/asrs/mapper/WrkMastExecuteMapper.java

@@ -16,11 +16,15 @@

    List<WrkMastExecute> getWrkMastByJarId(@Param("jarId") Integer jarId);

    List<WrkMastExecute> sselectWrkMastExecuteByType(@Param("type") Integer type);
    List<WrkMastExecute> selectWrkMastExecuteByType(@Param("type") Integer type);

    List<WrkMastExecute> sselectWrkMastExecuteByTypeAndIoTyper(@Param("type")Integer type,@Param("ioType")Integer ioType);
    List<WrkMastExecute> selectWrkMastExecuteByTypeAndIoTyperAndWrkType(@Param("type")Integer type,@Param("ioType")Integer ioType,@Param("wrkType")Integer wrkType);

    List<WrkMastExecute> selectWrkMastExecuteByWrk(@Param("type")Integer type,@Param("ioType")Integer ioType,
                                                   @Param("wrkType")Integer wrkType,@Param("steNo")Integer steNo,
                                                   @Param("jarNo")Integer jarNo,@Param("rgvNo")Integer rgvNo);


    Integer getWrkMastByJarIdCount(@Param("jarId") Integer jarId);
    Integer getWrkMastExecuteByJarIdCount(@Param("jarId") Integer jarId);

}

 src/main/java/com/zy/asrs/service/BasJarMastService.java

@@ -33,4 +33,6 @@

    Integer selectJarMastOperation(Integer jarId,Integer type);

    Integer updateStatus(Integer jarId,Integer status,Integer statusUpdate);

}

 src/main/java/com/zy/asrs/service/WrkMastExecuteService.java

@@ -11,9 +11,11 @@

    List<WrkMastExecute> getWrkMastExecuteByJarNo(Integer jarId);

    List<WrkMastExecute> sselectWrkMastExecuteByType(Integer type);
    List<WrkMastExecute> selectWrkMastExecuteByType(Integer type);

    List<WrkMastExecute> sselectWrkMastExecuteByTypeAndIoTyper(Integer type,Integer ioType);
    List<WrkMastExecute> selectWrkMastExecuteByTypeAndIoTyperAndWrkType(Integer type,Integer ioType,Integer wrkType);

    List<WrkMastExecute> selectWrkMastExecuteByWrk(WrkMastExecute wrkMastExecute);

    Integer getWrkMastExecuteByJarIdCount(Integer jarId);


 src/main/java/com/zy/asrs/service/impl/BasJarMastServiceImpl.java

@@ -204,4 +204,9 @@
        return this.baseMapper.selectJarMastOperationByStatusList(jarId,statusList);
    }

    @Override
    public Integer updateStatus(Integer jarId,Integer status,Integer statusUpdate) {
        return this.baseMapper.updateStatus(jarId,status,statusUpdate);
    }

}

 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java

@@ -4414,7 +4414,7 @@
    }

    /**
     *  Jar任务创建  //完成
     *  Jar任务创建  初始  //完成
     */
    public synchronized void jarMastGenerate() {
        for (JarSlave jarSlave : slaveProperties.getJar()) {
@@ -4528,9 +4528,8 @@
            }

            //自动、空闲、右门关闭、   Other左门关闭
            if (jarProtocol.isAutoing() && !jarProtocol.isRightDoor() && jarProtocol.jarErr==0
                    && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0
                    && !jarOtherProtocol.isLeftDoor() && jarOtherProtocol.leftDoorOpen==0  && jarOtherProtocol.leftDoorClose==0){
            if (jarProtocol.isAutoing() && jarProtocol.jarErr==0
                    && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){
                if (jarProtocol.statusType == JarStatusType.IDLE || jarProtocol.statusType == JarStatusType.MOVING){
                    BasJarMast basJarMast = new BasJarMast(basJar, wrkMast, jarLocDigit);
                    basJarMast.setJarEnterStaNo(staNo);//入硫化罐站点
@@ -4790,7 +4789,7 @@
            }});

            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1)){
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1,SteStatusType.IDLE)){
                return false;
            }

@@ -4903,7 +4902,7 @@
                return false;
            }
            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1)){
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1,SteStatusType.IDLE)){
                return false;
            }

@@ -4932,7 +4931,7 @@

                //门作业  无
                if (jarProtocol.isAutoing() && jarProtocol.statusType == JarStatusType.WAITING3 && jarProtocol.jarErr==0
                        && !jarProtocol.isRightDoor() && jarProtocol.isLeftDoor()
                        && jarProtocol.isRightDoor() && jarProtocol.isLeftDoor()
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){
                    //关进料门
                    if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMastSign,basJar.getJarNo(),new int[]{basJar.getEnterSteNo(),basJar.getEnterRgvNo(),2,1})){
@@ -4975,7 +4974,7 @@
                return false;
            }
            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),2)){
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),2,SteStatusType.IDLE)){
                return false;
            }

@@ -5045,7 +5044,7 @@
                return false;
            }
            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),2)){
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),2,SteStatusType.IDLE)){
                return false;
            }

@@ -5116,7 +5115,7 @@
            }

            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),2)){
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),2,SteStatusType.IDLE)){
                return false;
            }

@@ -5165,7 +5164,7 @@
     *  2：B面 出料面
     *  3：冷却槽B面 上输送线
     */
    public synchronized boolean jarWrkMastExecuteGenerateSteStatus(Integer steNo,Integer type) {
    public synchronized boolean jarWrkMastExecuteGenerateSteStatus(Integer steNo,Integer type,SteStatusType steStatusType) {
        try{
            //判断小车状态
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
@@ -5176,12 +5175,16 @@
            if (steProtocol == null) {
                return false;
            }
            if (steProtocol.getMode() == 0) {
            if (steProtocol.getMode() != (short)1) {
                log.error(steNo + "号小车离线，无法操作");
                return false;
            }
            if (!steProtocol.getStatusType().equals(SteStatusType.IDLE)) {
                log.error(steNo + "号小车不是空闲，无法操作");
            if (steProtocol.getChargeStatus()!=0){
                log.error(steNo + "号小车在充电，等待....");
                return false;
            }
            if (!steProtocol.getStatusType().equals(steStatusType)) {
                log.error(steNo + "号小车状态不是"+JSON.toJSONString(steStatusType)+"，等待....");
                return false;
            }
            switch (type){
@@ -5251,7 +5254,8 @@
            WrkMastExecute wrkMastExecute = new WrkMastExecute(basJarMast);
            wrkMastExecute.setJarId(id);
            wrkMastExecute.setSteId(digit[0]);//穿梭板ID
            wrkMastExecute.setRgvId(digit[1]);//RGV ID
            wrkMastExecute.setRgvId(basJar.getEnterRgvNo());//RGV ID  enter
            wrkMastExecute.setRgvEndId(basJar.getOutRgvNo());//RGV ID  out
            wrkMastExecute.setIoType(digit[2]);//任务类型 0: 未知  1: 开进料门  2: 关进料门  3: 开出料门  4: 关出料门  5: 入硫化罐  6: 入冷却槽  7: 穿梭车进冷却槽  8: 穿梭车离开冷却槽  9: 出冷却槽 10：A=>B 11:B=>A
            wrkMastExecute.setType(digit[3]);//设备  0: 未知  1: 硫化罐  2: 冷却槽  3: 硫化罐==>冷却槽
            return wrkMastExecuteService.insert(wrkMastExecute);
@@ -5267,7 +5271,7 @@
    * */
    public synchronized void jarWrkMastExecuteAction(Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteList = wrkMastExecuteService.sselectWrkMastExecuteByTypeAndIoTyper(0, 0);
            List<WrkMastExecute> wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, null,0);
            for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){
                /*
                * 任务类型 0: 未知
@@ -5279,20 +5283,45 @@
                * 10：A=>B 11:B=>A
                * */
                switch (wrkMastExecute.getIoType()){
                    case 1:
                        jarWrkMastExecuteActionExecute1(wrkMastExecute,sign);
                    case 1://1: 开进料门
                    case 3://3: 开出料门
                        if (jarWrkMastExecuteActionExecute1(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                    case 2:
                    case 3:
                    case 4:
                        if (jarWrkMastExecuteActionExecute2(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                    case 5:
                        if (jarWrkMastExecuteActionExecute5(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                    case 6:
                        if (jarWrkMastExecuteActionExecute6(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                    case 7:
                    case 8:
                        if (jarWrkMastExecuteActionExecute7(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                    case 9:
                        if (jarWrkMastExecuteActionExecute9(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                    case 10:
                    case 11:
                    case 12:
                    case 13:
                        if (jarWrkMastExecuteActionExecute10(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                }
            }
        } catch (Exception e){
@@ -5302,19 +5331,8 @@
    }

    /**
     *  JarWrkMastExecute任务完成   //未完成
     */
    public synchronized void jarWrkMastExecuteGenerateComplete() {
        try{

        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
    }

    /**
     *  JarWrkMastExecute任务创建==>下发 //未完成
     *  开进料门
     *  JarWrkMastExecute任务==>下发 //完成
     *  1、3开进料门
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute1(WrkMastExecute wrkMastExecute,Integer sign) {
@@ -5340,10 +5358,10 @@
                return false;
            }

            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
                return false;
            }
//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
//                return false;
//            }
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
@@ -5354,25 +5372,827 @@
            if (staProtocolRGV == null) {
                return false;
            }
            if (staProtocolRGV.rgvBoolean(1)){

            StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo());
            if (staProtocolRGVOther == null) {
                return false;
            } else {
                staProtocolRGVOther = staProtocolRGVOther.clone();
            }
            if (staProtocolRGVOther == null) {
                return false;
            }


            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
                    return true;
                }
                //门作业  无
                //自动、空闲、  进料们关闭需打开
                if (jarProtocol.isAutoing() && jarProtocol.jarErr==0
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){
                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //移走  == > 2
                    } else {
                        //直接开门
                    if (!jarProtocol.isLeftDoor() && !jarProtocol.isRightDoor()){
                        if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                            //移走  == > 2
                            if (jarRgvMoveTake(wrkMastExecute,2)){
                                log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkType(1);
                            wrkMastExecute.setWrkSts(1);
                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                        } else {
                            //直接开门/关门
                            if (jarDoorTake(wrkMastExecute,JarTaskModeType.OPEN_THE_DOOR)){
                                log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkType(1);
                            wrkMastExecute.setWrkSts(3);

                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                        }
                    }else if (jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()){
                        //直接完成
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(4);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    }

                    return true;
                }
                return false;
            } else {
                log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute));
                return false;
            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  2、4:关进料门
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute2(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }

            // 获取硫化罐信息
            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId());
            JarProtocol jarProtocol = jarThread.getJarProtocol();
            if (jarProtocol == null) {
                return false;
            }
            if (jarProtocol.modeType != JarModeType.AUTO){
                return false;
            }

            BasJar basJar = basJarMapper.selectByJarNo(jarProtocol.getJarNo());
            if (Cools.isEmpty(basJar)){
                log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo());
                return false;
            }

//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
//                return false;
//            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
                return false;
            } else {
                staProtocolRGV = staProtocolRGV.clone();
            }
            if (staProtocolRGV == null) {
                return false;
            }

            StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo());
            if (staProtocolRGVOther == null) {
                return false;
            } else {
                staProtocolRGVOther = staProtocolRGVOther.clone();
            }
            if (staProtocolRGVOther == null) {
                return false;
            }

            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
                    return true;
                }
                //门作业  无
                //自动、空闲、  进料们打开需关闭
                if (jarProtocol.isAutoing() && jarProtocol.jarErr==0
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){
                    if (jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()){
                        if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                            //移走  == > 2
                            if (jarRgvMoveTake(wrkMastExecute,2)){
                                log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkType(1);
                            wrkMastExecute.setWrkSts(1);

                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                        } else {
                            //直接关门
                            if (jarDoorTake(wrkMastExecute,JarTaskModeType.CLOSE_THE_DOOR)){
                                log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkType(1);
                            wrkMastExecute.setWrkSts(3);

                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                        }
                    } else if (!jarProtocol.isLeftDoor() && !jarProtocol.isRightDoor()){
                        //直接完成
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(4);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    }
                    return true;
                }
                return false;
            } else {
                log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute));
                return false;
            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  5:入硫化罐
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute5(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }

            // 获取硫化罐信息
            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId());
            JarProtocol jarProtocol = jarThread.getJarProtocol();
            if (jarProtocol == null) {
                return false;
            }
            if (jarProtocol.modeType != JarModeType.AUTO){
                return false;
            }

            BasJar basJar = basJarMapper.selectByJarNo(jarProtocol.getJarNo());
            if (Cools.isEmpty(basJar)){
                log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo());
                return false;
            }

//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
//                return false;
//            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
                return false;
            } else {
                staProtocolRGV = staProtocolRGV.clone();
            }
            if (staProtocolRGV == null) {
                return false;
            }

            StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo());
            if (staProtocolRGVOther == null) {
                return false;
            } else {
                staProtocolRGVOther = staProtocolRGVOther.clone();
            }
            if (staProtocolRGVOther == null) {
                return false;
            }

            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
                    return true;
                }
                //门作业  无
                //自动、空闲、  进料们打开需关闭
                if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){

                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //判断小车状态
                        if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                            return false;
                        }
                        //调车  == > 取货
                        if (jarRgvGetTake(wrkMastExecute
                                ,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarEnterStaNo())==1
                                ,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarEnterStaNo())==2)){
                            log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(3);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    } else {
                        //调车  == > endRow
                        if (jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){
                            log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(1);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    }
                    return true;
                }
                return false;
            } else {
                log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute));
                return false;
            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  6:入冷却槽
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute6(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }

            // 获取硫化罐信息
            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId());
            JarProtocol jarProtocol = jarThread.getJarProtocol();
            if (jarProtocol == null) {
                return false;
            }
            if (jarProtocol.modeType != JarModeType.AUTO){
                return false;
            }

            BasJar basJar = basJarMapper.selectByJarNo(jarProtocol.getJarNo());
            if (Cools.isEmpty(basJar)){
                log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo());
                return false;
            }

//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
//                return false;
//            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
                return false;
            } else {
                staProtocolRGV = staProtocolRGV.clone();
            }
            if (staProtocolRGV == null) {
                return false;
            }

            StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo());
            if (staProtocolRGVOther == null) {
                return false;
            } else {
                staProtocolRGVOther = staProtocolRGVOther.clone();
            }
            if (staProtocolRGVOther == null) {
                return false;
            }

            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
                    return true;
                }
                //门作业  无
                //自动、空闲、
                if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){

                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //判断小车状态
                        if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                            return false;
                        }
                        //调车  == > 取货
                        if (jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT21.id,SteTaskModeType.STE_WFQH_12,false)){
                            log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(3);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    } else {
                        //调车  == > endRow
                        if (jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){
                            log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(1);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    }
                    return true;
                }
                return false;
            } else {
                log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute));
                return false;
            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  7：穿梭车进冷却槽\8：穿梭车离开冷却槽
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute7(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }

            // 获取硫化罐信息
            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId());
            JarProtocol jarProtocol = jarThread.getJarProtocol();
            if (jarProtocol == null) {
                return false;
            }
            if (jarProtocol.modeType != JarModeType.AUTO){
                return false;
            }

            BasJar basJar = basJarMapper.selectByJarNo(jarProtocol.getJarNo());
            if (Cools.isEmpty(basJar)){
                log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo());
                return false;
            }

            // 获取硫化罐信息
            JarThread jarThreadOther = (JarThread) SlaveConnection.get(SlaveType.Jar, SteAndJarUtil.getRgvJarNo(wrkMastExecute.getJarId()));
            JarProtocol jarProtocolOther = jarThreadOther.getJarProtocol();
            if (jarProtocolOther == null) {
                return false;
            }
            if (jarProtocolOther.modeType != JarModeType.AUTO){
                return false;
            }

            BasJar basJarOther = basJarMapper.selectByJarNo(jarProtocolOther.getJarNo());
            if (Cools.isEmpty(basJarOther)){
                log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocolOther.getJarNo());
                return false;
            }

//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
//                return false;
//            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
                return false;
            } else {
                staProtocolRGV = staProtocolRGV.clone();
            }
            if (staProtocolRGV == null) {
                return false;
            }

            StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo());
            if (staProtocolRGVOther == null) {
                return false;
            } else {
                staProtocolRGVOther = staProtocolRGVOther.clone();
            }
            if (staProtocolRGVOther == null) {
                return false;
            }

            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
                    return true;
                }
                //门作业  无
                //自动、空闲、
                if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0
                        && jarProtocolOther.isLeftDoor() && jarProtocolOther.isRightDoor()
                ){

                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocolOther.getJarNo())){
                        //判断小车状态
                        if (wrkMastExecute.getIoType()==7){
                            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                                //调车  == > 移动
                                if (jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT26.id,SteTaskModeType.STE_WFQH_12,false)){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(3);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            } else if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            }
                        } else {
                            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE)){
                                //调车  == > 移动
                                if (jarSteTake(wrkMastExecute,SteLocaType.POINT26.id,SteLocaType.POINT23.id,SteTaskModeType.STE_WFQH_12,false)){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(3);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            } else if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            }
                        }

                    } else {
                        //调车  == > endRow
                        if (jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){
                            log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(1);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    }
                    return true;
                }
                return false;
            } else {
                log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute));
                return false;
            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  9：出冷却槽
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute9(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }

//            // 获取硫化罐信息
//            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId());
//            JarProtocol jarProtocol = jarThread.getJarProtocol();
//            if (jarProtocol == null) {
//                return false;
//            }
//            if (jarProtocol.modeType != JarModeType.AUTO){
//                return false;
//            }

            BasJar basJar = basJarMapper.selectByJarNo(wrkMastExecute.getJarId());
            if (Cools.isEmpty(basJar)){
                log.error("{}号冷却槽查询设备档案无信息！！！",wrkMastExecute.getJarId());
                return false;
            }

//            // 获取硫化罐信息
//            JarThread jarThreadOther = (JarThread) SlaveConnection.get(SlaveType.Jar, SteAndJarUtil.getRgvJarNo(wrkMastExecute.getJarId()));
//            JarProtocol jarProtocolOther = jarThreadOther.getJarProtocol();
//            if (jarProtocolOther == null) {
//                return false;
//            }
//            if (jarProtocolOther.modeType != JarModeType.AUTO){
//                return false;
//            }
//
//            BasJar basJarOther = basJarMapper.selectByJarNo(jarProtocolOther.getJarNo());
//            if (Cools.isEmpty(basJarOther)){
//                log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocolOther.getJarNo());
//                return false;
//            }

//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
//                return false;
//            }
//
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocol = devpThread.getStation().get(basJar.getStaNo());
            if (staProtocol == null) {
                return false;
            } else {
                staProtocol = staProtocol.clone();
            }
            if (staProtocol == null) {
                return false;
            }
            if (staProtocol.getWorkNo()!=0 || !staProtocol.isAutoing() || staProtocol.isLoading()){
                return false;
            }
//
//            StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo());
//            if (staProtocolRGVOther == null) {
//                return false;
//            } else {
//                staProtocolRGVOther = staProtocolRGVOther.clone();
//            }
//            if (staProtocolRGVOther == null) {
//                return false;
//            }
//
//            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
//                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
//                    //移走  == > 2
//                    if (jarRgvTake(wrkMastExecute,2)){
//                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
//                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
//                    }
//                    return true;
//                }
                //门作业  无
                //自动、空闲、
//                if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()
//                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0
//                ){
                    //判断小车状态
                    if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE)){
                        //调车  == > 取货
                        if (jarSteTake(wrkMastExecute,SteLocaType.POINT26.id,SteLocaType.POINT24.id,SteTaskModeType.STE_WFQH_12,false)){
                            log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},冷却槽数据={},sign={}",
                                    wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(basJar),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(1);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},冷却槽数据={},sign={}",
                                    wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(basJar),sign);
                        }
                    }
                    return true;
//                }
//                return false;
//            } else {
//                log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute));
//                return false;
//            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  10：A=>B\11：B=>A
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute10(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }

            // 获取硫化罐信息
            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, wrkMastExecute.getJarId());
            JarProtocol jarProtocol = jarThread.getJarProtocol();
            if (jarProtocol == null) {
                return false;
            }
            if (jarProtocol.modeType != JarModeType.AUTO){
                return false;
            }

            BasJar basJar = basJarMapper.selectByJarNo(jarProtocol.getJarNo());
            if (Cools.isEmpty(basJar)){
                log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo());
                return false;
            }

//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1)){
//                return false;
//            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
                return false;
            } else {
                staProtocolRGV = staProtocolRGV.clone();
            }
            if (staProtocolRGV == null) {
                return false;
            }

            StaProtocol staProtocolRGVOther = devpThread.getStation().get(basJar.getOutRgvNo());
            if (staProtocolRGVOther == null) {
                return false;
            } else {
                staProtocolRGVOther = staProtocolRGVOther.clone();
            }
            if (staProtocolRGVOther == null) {
                return false;
            }

            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
                    return true;
                }
                //门作业  无
                //自动、空闲、
                if (jarProtocol.isAutoing() && jarProtocol.jarErr==0 && jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0
                ){

                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //判断小车状态
                        if (wrkMastExecute.getIoType()==10){
                            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                                //调车  == > 移动
                                if (jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT23.id,SteTaskModeType.STE_WFQH_12,false)){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(3);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            } else if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            }
                        } else {
                            if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                                //调车  == > 移动
                                if (jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT20.id,SteTaskModeType.STE_WFQH_12,false)){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(3);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            } else if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                }
                            }
                        }

                    } else {
                        //调车  == > endRow
                        if (jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){
                            log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(1);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                    }
                    return true;
                }
                return false;
            } else {
                log.error("jarWrkMastExecuteActionExecute1===>执行异常===》RGV不满足条件，等待===》异常数据：BasJar:"+ JSON.toJSONString(basJar.getEnterRgvNo())+";WrkMastExecute:"+JSON.toJSONString(wrkMastExecute));
                return false;
            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
@@ -5380,9 +6200,9 @@
    }

    /*
     * Rgv  动作
     * Rgv  动作  移动
     * */
    public synchronized boolean jarRgvTake(WrkMastExecute wrkMastExecute,Integer endRow){
    public synchronized boolean jarRgvMoveTake(WrkMastExecute wrkMastExecute,Integer endRow){
        try {
            StaProtocol staProtocol = new StaProtocol();
            staProtocol.setSiteId(wrkMastExecute.getRgvId());
@@ -5400,6 +6220,27 @@
    }

    /*
     * Rgv  动作  取货
     * */
    public synchronized boolean jarRgvGetTake(WrkMastExecute wrkMastExecute,boolean RGV4,boolean RGV5){
        try {
            StaProtocol staProtocol = new StaProtocol();
            staProtocol.setSiteId(wrkMastExecute.getRgvId());
            staProtocol.setRGV4(RGV4);
            staProtocol.setRGV5(RGV5);
            // 下发站点信息
            if (!MessageQueue.offer(SlaveType.Devp, 2, new Task(10, staProtocol))) {
                log.error("平衡车Rgv命令下发失败，堆垛机号={},任务数据={},下发数据={}", wrkMastExecute.getRgvId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocol));
                return false;
            }
            return true;
        }catch (Exception e){
            log.error("平衡车Rgv命令下发失败，Rgv号={},任务数据={},RGV4={},RGV5={}", wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(RGV4), JSON.toJSON(RGV5));
        }
        return false;
    }

    /*
     * Ste  动作
     * */
    public synchronized boolean jarSteTake(WrkMastExecute wrkMastExecute,Integer startLoad,Integer endLoad,SteTaskModeType steTaskModeType,boolean complete){
@@ -5410,6 +6251,7 @@
            steCommand.setEndLoad(endLoad);
            steCommand.setTaskModeType(steTaskModeType);
            steCommand.setComplete(complete);
            steCommand.setJarNo(wrkMastExecute.getJarId().shortValue());
            if (!MessageQueue.offer(SlaveType.Ste, steCommand.getSteNo(), new Task(2, steCommand))) {
                log.error("穿梭车Ste命令下发失败，堆垛机号={},任务数据={},下发数据={},complete={}", steCommand.getSteNo(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steCommand),complete);
                return false;
@@ -5440,4 +6282,298 @@
        return false;
    }

    /**
     *  JarWrkMastExecute任务完成   //未完成
     */
    public synchronized void jarWrkMastExecuteGenerateComplete(Integer sign) {
        try{
            switch (sign){
                case 1:
                case 5:
                case 9:
                    if (jarWrkMastExecuteGenerateSteComplete(sign)){
                        break;
                    }
                case 2:
                case 6:
                case 10:
                    if (jarWrkMastExecuteGenerateJarComplete(sign)){
                        break;
                    }
                case 3:
                case 7:
                case 11:
                    if (jarWrkMastExecuteGenerateRgvComplete1(sign)){
                        break;
                    }
                case 4:
                case 8:
                case 12:
                    if (jarWrkMastExecuteGenerateRgvComplete2(sign)){
                        break;
                    }
                default:
                    return;
            }
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
    }

    /**
     *  JarWrkMastExecute任务完成 ===>Ste   //完成
     */
    public synchronized boolean jarWrkMastExecuteGenerateSteComplete(Integer sign) {
        try{
            for (SteSlave steSlave : slaveProperties.getSte()) {
                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steSlave.getId());
                if (steThread == null) {
                    continue;
                }
                SteProtocol steProtocol = steThread.getSteProtocol();
                if (steProtocol == null) {
                    continue;
                }
                if (steProtocol.getMode()==(short)1 && steProtocol.taskNo!=0 && steProtocol.getChargeStatus()==0){
                    if (steProtocol.statusType.equals(SteStatusType.WAITING)){

                    }
                    WrkMastExecute wrkMastExecute = wrkMastExecuteService.getWrkMastExecuteByWrkNo(steProtocol.getTaskNo().longValue());
                    if (!Cools.isEmpty(wrkMastExecute)){
                        switch (wrkMastExecute.getIoType()){
                            case 6:
                                if (wrkMastExecute.getWrkSts()==3){//==>4
                                    //1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版取货、4：取货完成等待下一步、5：Ste穿梭版放货至冷却池、6：放货完成、7：更新完成   //io_type = 6
                                    //ste任务等待完成
                                    if (steProtocol.statusType.equals(SteStatusType.WAITING2)){
                                        //ste任务完成
                                        if (jarSteTake(wrkMastExecute,null,null,null,true)){
                                            wrkMastExecute.setWrkSts(4);
                                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                                log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                            }
                                        }
                                    }
                                    log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                    return true;
                                }
                            case 5:
                                if (wrkMastExecute.getWrkSts()==5){
                                    //1：RGV小车移动、2：RGV小车到位、3：rgv取货、4：rgv取货完成、5：Ste穿梭版入硫化罐、6：入罐完成、7：更新完成   //io_type = 5
                                    //ste任务完成
                                    if (wrkMastExecute.getWrkSts()==3){//==>4
                                        //1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版取货、4：取货完成等待下一步、5：Ste穿梭版放货至冷却池、6：放货完成、7：更新完成   //io_type = 6
                                        //ste任务等待完成
                                        if (steProtocol.statusType.equals(SteStatusType.WAITING)){
                                            //ste任务完成
                                            if (jarSteTake(wrkMastExecute,null,null,null,true)){
                                                wrkMastExecute.setWrkSts(6);
                                                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                                    log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                                }
                                            }
                                        }
                                        log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                        return true;
                                    }
                                    return true;
                                }
                                return false;
                            case 7:
                            case 8:
                            case 10:
                            case 11:
                                //1：RGV小车移动、2：RGV小车到位、3：Ste穿梭版移动中、4：移动完成、5：更新完成
                                if (wrkMastExecute.getWrkSts()==3){
                                    //ste任务完成
                                    if (steProtocol.statusType.equals(SteStatusType.WAITING)){
                                        //ste任务完成
                                        if (jarSteTake(wrkMastExecute,null,null,null,true)){
                                            wrkMastExecute.setWrkSts(4);
                                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                                log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                            }
                                        }
                                    }
                                    log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                    return true;
                                }
                                return false;
                            case 9:
                                if (wrkMastExecute.getWrkSts()==1){
                                    //1：Ste穿梭版取放货中、2：放货完成等待下一步、3：输送线任务下发完成、4：更新完成   //io_type = 9
                                    //ste任务完成
                                    if (steProtocol.statusType.equals(SteStatusType.WAITING)){
                                        //ste任务完成
                                        if (jarSteTake(wrkMastExecute,null,null,null,true)){
                                            wrkMastExecute.setWrkSts(2);
                                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                                log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                            }
                                        }
                                    }
                                    log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                    return true;
                                }
                            default: return false;
                        }
                    }
                }
            }
            return true;
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务完成 ===>Jar   //完成
     *  //硫化完成 修改任务状态
     */
    public synchronized boolean jarWrkMastExecuteGenerateJarComplete(Integer sign) {
        try{
            for (JarSlave jarSlave : slaveProperties.getJar()) {
                // 获取硫化罐信息
                JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId());
                JarProtocol jarProtocol = jarThread.getJarProtocol();
                if (jarProtocol == null) {
                    continue;
                }
                if (jarProtocol.modeType != JarModeType.AUTO){
                    continue;
                }
                BasJar basJar = basJarMapper.selectById(jarProtocol.getJarNo());
                if (Cools.isEmpty(basJar)){
                    log.error("{}号硫化罐查询设备档案无信息！！！",jarProtocol.getJarNo());
                    continue;
                }
                //WAITING2(4, "硫化完成"),
                if (jarProtocol.getJarErr()==0 && jarProtocol.getStatusType().equals(JarStatusType.WAITING2)
                        && jarProtocol.isRightDoor() && jarProtocol.isLeftDoor() ){
                    List<BasJarMast> basJarMastList = basJarMastService.getJarMastByJarIdAndStatusList(jarSlave.getId(), new ArrayList<Integer>() {{
                        add(5);//硫化中
                    }});
                    if (basJarMastList.isEmpty()){
                        continue;
                    }
                    Integer integer = basJarMastService.updateStatus(jarProtocol.getJarNo(), 5, 6);
                    if (basJarMastList.size()!=integer){
                        log.error("{}号硫化罐硫化完成修改硫化档案状态结果数量不一致！！！查询资料数量={}，更新返回数量={}",jarProtocol.getJarNo(),basJarMastList.size(),integer);
                    }
                }
            }
            return true;
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务完成 ===>RGV移动  //完成
     */
    public synchronized boolean jarWrkMastExecuteGenerateRgvComplete1(Integer sign) {
        try{
            WrkMastExecute wrkMastExecuteSou = new WrkMastExecute();
            wrkMastExecuteSou.setWrkType(1);
            List<WrkMastExecute> wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou);
            for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){
                if (wrkMastExecute.getIoType() == 9){
                    continue;
                }
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2);
                StaProtocol staProtocolRGV = devpThread.getStation().get(wrkMastExecute.getRgvId());
                if (staProtocolRGV == null) {
                    continue;
                } else {
                    staProtocolRGV = staProtocolRGV.clone();
                }
                if (staProtocolRGV == null) {
                    continue;
                }

                StaProtocol staProtocolRGVEnd = devpThread.getStation().get(wrkMastExecute.getRgvEndId());
                if (staProtocolRGVEnd == null) {
                    continue;
                } else {
                    staProtocolRGVEnd = staProtocolRGVEnd.clone();
                }
                if (staProtocolRGVEnd == null) {
                    continue;
                }
                if (staProtocolRGV.getNowRow() == staProtocolRGVEnd.getNowRow()
                        && staProtocolRGV.getNowRow() == SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId())){
                    wrkMastExecute.setWrkSts(2);
                    if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},平衡车Rgv数据={},sign={}",
                                wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocolRGV),sign);
                        return false;
                    }
                    return true;
                }
            }
            return true;
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务完成 ===>RGV取货  //完成
     */
    public synchronized boolean jarWrkMastExecuteGenerateRgvComplete2(Integer sign) {
        try{
            WrkMastExecute wrkMastExecuteSou = new WrkMastExecute();
            wrkMastExecuteSou.setWrkType(3);
            wrkMastExecuteSou.setIoType(5);
            List<WrkMastExecute> wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou);
            for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2);
                StaProtocol staProtocolRGV = devpThread.getStation().get(wrkMastExecute.getRgvId());
                if (staProtocolRGV == null) {
                    continue;
                } else {
                    staProtocolRGV = staProtocolRGV.clone();
                }
                if (staProtocolRGV == null) {
                    continue;
                }

                StaProtocol staProtocolRGVEnd = devpThread.getStation().get(wrkMastExecute.getRgvEndId());
                if (staProtocolRGVEnd == null) {
                    continue;
                } else {
                    staProtocolRGVEnd = staProtocolRGVEnd.clone();
                }
                if (staProtocolRGVEnd == null) {
                    continue;
                }
                if (staProtocolRGV.getNowRow() == staProtocolRGVEnd.getNowRow()
                        && staProtocolRGV.getNowRow() == SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId())){
                    wrkMastExecute.setWrkSts(4);
                    if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},平衡车Rgv数据={},sign={}",
                                wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocolRGV),sign);
                        return false;
                    }
                    return true;
                }
            }
            return true;
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
        return false;
    }

}

 src/main/java/com/zy/asrs/service/impl/WrkMastExecuteServiceImpl.java

@@ -22,17 +22,22 @@
    }

    @Override
    public List<WrkMastExecute> sselectWrkMastExecuteByType(Integer type) {
        return this.baseMapper.sselectWrkMastExecuteByType(type);
    public List<WrkMastExecute> selectWrkMastExecuteByType(Integer type) {
        return this.baseMapper.selectWrkMastExecuteByType(type);
    }

    @Override
    public List<WrkMastExecute> sselectWrkMastExecuteByTypeAndIoTyper(Integer type,Integer ioType) {
        return this.baseMapper.sselectWrkMastExecuteByTypeAndIoTyper(type,ioType);
    public List<WrkMastExecute> selectWrkMastExecuteByTypeAndIoTyperAndWrkType(Integer type,Integer ioType,Integer wrkType) {
        return this.baseMapper.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(type,ioType,wrkType);
    }

    @Override
    public List<WrkMastExecute> selectWrkMastExecuteByWrk(WrkMastExecute wrkMastExecute) {
        return this.baseMapper.selectWrkMastExecuteByWrk(wrkMastExecute.getType(),wrkMastExecute.getIoType(),wrkMastExecute.getWrkType(),wrkMastExecute.getSteId(),wrkMastExecute.getJarId(),wrkMastExecute.getRgvId());
    }

    @Override
    public Integer getWrkMastExecuteByJarIdCount(Integer jarId) {
        return this.baseMapper.getWrkMastByJarIdCount(jarId);
        return this.baseMapper.getWrkMastExecuteByJarIdCount(jarId);
    }
}

 src/main/java/com/zy/asrs/utils/SteAndJarUtil.java

@@ -11,6 +11,74 @@
        return (steNowRow==(short) 1 && (jarNo == 2 || jarNo == 4)) || (steNowRow==(short)3 && (jarNo == 1 || jarNo == 3));
    }

    /**
     * RGV位置正对获取
     */
    public static Integer getRgvJarNowRow(Integer jarNo){
        switch (jarNo){
            case 1:
            case 3:
                return 3;
            case 2:
            case 4:
            case 5:
            case 6:
                return 1;
        }
        return 2;
    }

    /**
     * RGV位置正对获取
     */
    public static boolean getRgvJarNowRow(Integer staNo,short nowRow){
        switch (staNo){
            case 615:
            case 622:
            case 628:
            case 627:
                return nowRow==(short) 1;
            case 612:
            case 619:
                return nowRow==(short) 2;
        }
        return false;
    }

    /**
     * RGV位置正对获取
     */
    public static Integer getRgvStaRow(Integer staNo){
        switch (staNo){
            case 615:
            case 622:
            case 628:
            case 627:
                return  1;
            case 612:
            case 619:
                return  2;
        }
        return 0;
    }

    /**
     * 获取正对冷却槽硫化罐
     */
    public static Integer getRgvJarNo(Integer jarNo){
        switch (jarNo){
            case 1:
            case 2:
                return  2;
            case 3:
            case 4:
            case 5:
            case 6:
                return  4;
        }
        return 0;
    }

    public static void main(String[] args) {

    }

 src/main/java/com/zy/core/MainProcess.java

@@ -90,19 +90,18 @@
                    mainService.storeEmptyPltLarge();
                    // 出库  ===>> 工作档信息写入led显示器
                    mainService.ledExecute();
                    // 其他  ===>> LED显示器复位，显示默认信息
                    // 其他   ===>> LED显示器复位，显示默认信息
                    mainService.ledReset();

                    /************************************JAR调度************************************/
                    //JarWrkMastExecute任务完成
                    mainService.jarWrkMastExecuteGenerateComplete(k);
                    //JarWrkMastExecute任务创建   //硫化罐
                    mainService.jarWrkMastExecuteGenerate(k);

                    //JarWrkMastExecute任务执行
                    mainService.jarWrkMastExecuteAction(k);
                    //Jar任务创建  //完成
                    mainService.jarMastGenerate();




                    /************************************JAR调度************************************/


 src/main/java/com/zy/core/enums/SlaveType.java

@@ -10,7 +10,8 @@
    Car,
    Rgv,
    Ste,
    Jar
    Jar,
    JarB
    ;

    public static SlaveType findInstance(String s){

 src/main/java/com/zy/core/enums/SteStatusType.java

@@ -2,11 +2,14 @@

public enum SteStatusType {

    OFF_LINE(-1, "未知"),
    IDLE(0, "空闲"),
    MOVING(1, "作业中"),
    SOS(2, "报警"),
    SOS(2, "停止中"),
    SOS2(3, "报警：故障中"),
    SOS3(4, "复位中"),
    WAITING(10, "等待确认"),
    OFF_LINE(-1, "未知"),
    WAITING2(11, "有物待作业"),
    OTHER(100, "其它"),
    ;


 src/main/java/com/zy/core/model/command/SteCommand.java

@@ -32,6 +32,9 @@
//
    @JSONField(serialize = false)
    private SteTaskModeType taskModeType;

    private Short jarNo;

//
//    // 起始设备号
//    private Short startSsbm;

 src/main/java/com/zy/core/model/protocol/StaProtocol.java

@@ -83,8 +83,8 @@
    private boolean RGV1;//小车无货空闲
    private boolean RGV2;//小车输送线取货到位
    private boolean RGV3;//小车运行中
    private boolean RGV4;//小车改左侧货物目标站   取1（左）货物
    private boolean RGV5;//小车改右侧货物目标站   取2（右）货物
    private boolean RGV4;//小车改左侧货物目标站   取1（左）货物  （面朝入料口）
    private boolean RGV5;//小车改右侧货物目标站   取2（右）货物  （面朝入料口）
    private boolean RGV6;//上位机清除平移车资料

    public BasDevp toSqlModel(){

 src/main/java/com/zy/core/model/protocol/SteProtocol.java

@@ -33,7 +33,9 @@
     IDLE(0, "空闲"),
     MOVING(1, "作业中"),
     SOS(2, "报警"),
     WAITING(3, "任务完成等待WCS确认"),
     WAITING(10, "等待确认"),
     OFF_LINE(-1, "未知"),
     OTHER(100, "其它"),
     */
    public Short status;


 src/main/java/com/zy/core/thread/JarThread.java

@@ -118,6 +118,9 @@
     */
    private void readStatus(){
        try {
            if (slave.getId()>4){
                return;
            }
            OperateResultExOne<byte[]> result = siemensS7Net.Read("V300", (short) 26);
            if (result.IsSuccess) {
                if (null == jarProtocol) {

 src/main/java/com/zy/core/thread/SiemensDevpThread.java

@@ -313,8 +313,8 @@
                    staProtocol.setRGV1(status[0]);  // 自动
                    staProtocol.setRGV2(status[1]);  // 有物
                    staProtocol.setRGV3(status[2]); // 可入
                    staProtocol.setRGV4(status[3]);// 可出
                    staProtocol.setRGV5(status[4]);  // 空板信号
                    staProtocol.setRGV4(status[3]);//
                    staProtocol.setRGV5(status[4]);  //
                    staProtocol.setRGV6(status[5]);  // 满托盘
                }
            }
@@ -541,30 +541,148 @@
    /**
     * 写入 ID+目标站 =====> 单站点写入
     */
    private void write10(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        boolean rgv4 = staProtocol.isRGV4();
        boolean rgv5 = staProtocol.isRGV5();
        OperateResult result1 = null;
        OperateResult result2 = null;
        String resultV1 = "";
        String resultV2 = "";
        switch (staProtocol.getSiteId()){
            case 623:
                resultV1 = "1804";
                resultV2 = "1804";
                break;
            case 624:
                resultV1 = "1810";
                resultV2 = "1810";
                break;
            case 625:
                resultV1 = "1816";
                resultV2 = "1816";
                break;
            case 626:
                resultV1 = "1822";
                resultV2 = "1822";
                break;
            default:
                return;
        }
        result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
        //硫化罐任务写入后，回读一次，看是否成功
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        int writeCount = 1;
        do {
            try{
                if(!result1.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead1 = siemensS7Net.Read(resultV1, (short) 2);
                if (resultRead1.IsSuccess) {
                    boolean[] status = siemensS7Net.getByteTransform().TransBool(resultRead1.Content, 0, 1);
                    boolean status1 = status[rgv4? 4:3];
                    if (status1 == rgv4?rgv5:rgv4){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                        result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);

        result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
        writeCount = 1;
        do {
            try{
                if(!result2.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead2 = siemensS7Net.Read(resultV2, (short) 1);
                if (resultRead2.IsSuccess) {
                    boolean[] status = siemensS7Net.getByteTransform().TransBool(resultRead2.Content, 0, 1);
                    boolean status1 = status[rgv4? 3:4];
                    if (status1 ==  rgv4?rgv4:rgv5){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                        result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);
    }
    private void write9(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        short resultS1 = staProtocol.getEndRow();
        OperateResult result1 = null;
        OperateResult result2 = null;
        String resultV1 = "";
        String resultV2 = "";
        switch (staProtocol.getSiteId()){
            case 623:
                resultV1 = "1800";
                resultV2 = "1812";
                break;
            case 624:
                resultV1 = "1806";
                resultV2 = "1818";
                break;
            case 625:
                resultV1 = "1812";
                resultV2 = "1800";
                break;
            case 626:
                resultV1 = "1818";
                resultV2 = "1806";
                break;
            default:
                return;
        }
        result1 = siemensS7Net.Write(resultV1, resultS1);
        result2 = siemensS7Net.Write(resultV2, resultS1);
        //硫化罐任务写入后，回读一次，看是否成功
        try {
            Thread.sleep(200);
@@ -585,7 +703,7 @@
                OperateResultExOne<byte[]> resultRead1 = siemensS7Net.Read(resultV1, (short) 2);
                if (resultRead1.IsSuccess) {
                    short transInt16 = siemensS7Net.getByteTransform().TransInt16(resultRead1.Content, 0);
                    if (transInt16 == resultS1 || transInt16 == (short) 2 || transInt16 == (short) 3){
                    if (transInt16 == resultS1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
@@ -607,6 +725,41 @@
            writeCount++;
        } while (writeCount<6);

        writeCount = 1;
        do {
            try{
                if(!result2.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV2, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead2 = siemensS7Net.Read(resultV2, (short) 2);
                if (resultRead2.IsSuccess) {
                    short transInt16 = siemensS7Net.getByteTransform().TransInt16(resultRead2.Content, 0);
                    if (transInt16 == resultS1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                        result2 = siemensS7Net.Write(resultV2, resultS1);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV2, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);

        if (!result1.IsSuccess) {
            staProtocol = station.get(staProtocol.getSiteId());
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));

 src/main/java/com/zy/core/thread/SteThread.java

@@ -226,7 +226,7 @@
            siemensS7Net.Write("DB100.12", (short) 0);//起始点位
            siemensS7Net.Write("DB100.14", (short) 0);//目的点位
            siemensS7Net.Write("DB100.16.0", false);//任务开始确认位
            siemensS7Net.Write("DB100.16.1", false);//任务完成确认
//            siemensS7Net.Write("DB100.18", (short) 0);//硫化罐号
            // 1.任务号
            OperateResult result0 = siemensS7Net.Write("DB100.2", command.getTaskNo().shortValue());
            try {
@@ -240,8 +240,9 @@
                OperateResult result1 = siemensS7Net.Write("DB100.4", command.getTaskMode());
                OperateResult result2 = siemensS7Net.Write("DB100.12", (short) command.getStartLoad().shortValue());//起始点位
                OperateResult result3 = siemensS7Net.Write("DB100.14", (short) command.getEndLoad().shortValue());//目的点位
                OperateResult result4 = siemensS7Net.Write("DB100.18", (short) command.getJarNo());//目的点位
                // 3.确认开始任务
                if (result0.IsSuccess && result1.IsSuccess && result2.IsSuccess && result3.IsSuccess) {
                if (result0.IsSuccess && result1.IsSuccess && result2.IsSuccess && result3.IsSuccess && result4.IsSuccess) {
                    result = siemensS7Net.Write("DB100.16.0", true);

                    try {

 src/main/resources/mapper/BasJarMastMapper.xml

@@ -101,4 +101,12 @@
        order by jar_loc_digit desc
    </select>

    <update id="updateStatus">
        update asr_bas_jar_mast
        set status = #{statusUpdate}
        where 1=1
        and jar_id = #{jarId}
        and status = #{status}
    </update>

</mapper>

 src/main/resources/mapper/WrkMastExecuteMapper.xml

@@ -22,8 +22,39 @@
        <result column="wrk_sts" property="wrkSts" />
        <result column="io_type" property="ioType" />
        <result column="type" property="type" />
        <result column="rgv_end_id" property="rgvEndId" />

    </resultMap>

    <sql id="batchSeq">
        <if test="type != null">
            and type = #{type}
        </if>
        <if test="ioType != null">
            and io_type = #{ioType}
        </if>
        <if test="wrkType != null">
            and wrk_type = #{wrkType}
        </if>
        <if test="steNo != null">
            and ste_id = #{steNo}
        </if>
        <if test="jarNo != null">
            and jar_id = #{jarNo}
        </if>
        <if test="rgvNo != null">
            and rgv_id = #{rgvNo}
        </if>
        <!--        <choose>-->
        <!--            <when test="type != null and type != ''">-->
        <!--                and type = #{type}-->
        <!--            </when>-->
        <!--            <otherwise>-->
        <!--                and (type IS NULL OR type = '')-->
        <!--            </otherwise>-->
        <!--        </choose>-->

    </sql>

    <select id="getWrkMastExecuteByWrkNo" resultMap="BaseResultMap">
        select top 1 * from jar_wrk_mast_execute
@@ -37,14 +68,25 @@
        and jar_id = #{jarId}
    </select>

    <select id="sselectWrkMastExecuteByType" resultMap="BaseResultMap">
    <select id="selectWrkMastExecuteByType" resultMap="BaseResultMap">
        select * from jar_wrk_mast_execute
        where 1=1
        and type = #{type}
        and io_type = #{iotype}
        and wrk_type = 0;
    </select>

    <select id="selectWrkMastExecuteByTypeAndIoTyperAndWrkType" resultMap="BaseResultMap">
        select * from jar_wrk_mast_execute
        where 1=1
        <include refid="batchSeq"></include>
    </select>

    <select id="selectWrkMastExecuteByWrk" resultMap="BaseResultMap">
        select * from jar_wrk_mast_execute
        where 1=1
        <include refid="batchSeq"></include>
    </select>

    <select id="getWrkMastExecuteByJarIdCount" resultType="Integer">
        select count(1) from jar_wrk_mast_execute
        where 1=1