#

lsh

2024-06-27 e47b30ba51de51df6210910e50d790614a9b30e1

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

@@ -23,6 +23,7 @@
import com.zy.common.utils.RgvUtils;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.Slave;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
@@ -54,6 +55,8 @@
public class MainServiceImpl {

    public static final long COMMAND_TIMEOUT = 5 * 1000;
//    private static final int[][] execute = new int[][]{{1,4},{2,4},{3,4},{4,4},{5,6},{6,6},{7,4},{8,4},{9,3},{10,4},{11,4}};
    private static final int[][] execute = new int[][]{{1,4},{2,4},{3,4},{4,4},{5,6},{6,6},{9,3},{10,4},{11,4}};

    @Autowired
    private CommonService commonService;
@@ -4544,35 +4547,35 @@
    }

    /**
     *  Jar任务完成   //未完成
     *  Jar任务完成   //完成
     */
    public synchronized boolean jarMastGenerateComplete(JarSlave jarSlave) {
    public synchronized boolean jarMastGenerateComplete() {
        try{
            // 获取堆垛机信息
            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getId());
            JarProtocol jarProtocol = jarThread.getJarProtocol();
            if (jarProtocol == null) {
                return false;
            }
            if (jarProtocol.modeType != JarModeType.AUTO){
                return false;
            }

            JarThread jarOtherThread = (JarThread) SlaveConnection.get(SlaveType.Jar, jarSlave.getJarOtherId());
            JarProtocol jarOtherProtocol = jarOtherThread.getJarProtocol();
            if (jarOtherProtocol == null) {
                return false;
            }
            if (jarOtherProtocol.modeType != JarModeType.AUTO){
                return false;
            }

            //自动、空闲、右门关闭、
            if (jarProtocol.isAutoing() && !jarProtocol.isRightDoor() && jarProtocol.jarErr==0 && !jarOtherProtocol.isLeftDoor() && jarOtherProtocol.jarErr==0){

            for (int[] ex : execute){
                try{
                    WrkMastExecute wrkMastExecuteSou = new WrkMastExecute();
                    wrkMastExecuteSou.setIoType(ex[0]);
                    wrkMastExecuteSou.setWrkSts(ex[1]);
                    wrkMastExecuteSou.setWrkType(1);
                    List<WrkMastExecute> wrkMastExecuteList = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecuteSou);
                    for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){
                        BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo());
                        jarMastByWrkNo.setStatus(jarMastByWrkNo.getStatusComplete());
                        if (!basJarMastService.updateById(jarMastByWrkNo)){
                            log.error("硫化区域分段任务完成异常,BasJarMast={},异常信息={}",JSON.toJSONString(jarMastByWrkNo),"更新basJarMast失败");
                        }
                        wrkMastExecute.setWrkSts(wrkMastExecute.getWrkStsComplete());
                        wrkMastExecute.setWrkType(2);
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化区域分段任务完成异常,wrkMastExecute={},异常信息={}",JSON.toJSONString(wrkMastExecute),"更新wrkMastExecute失败");
                        }
                    }
                }catch (Exception e){
                    log.error("硫化区域分段任务完成异常,execute={},异常信息={}",JSON.toJSONString(ex),e.getMessage());
                }
            }
        } catch (Exception e){
//            log.error("堆垛机工位二完成等待确认异常,堆垛机号={},异常信息={},工位号={}",crn.getId(),e.getMessage(),2);
            log.error("硫化区域分段任务完成异常,异常信息={}",e.getMessage());
        }
        return false;
    }
@@ -4594,10 +4597,13 @@
                default:
                    jarWrkMastExecuteGenerateSte(signExecute,sign);//小车移动
            }
            if (!signExecute[0] && !signExecute[1]){
                //Ste移动
                jarMastMove();
            }
        } catch (Exception e){

            log.error("硫化区域分段任务创建异常,异常信息={}",e.getMessage());
        }

    }

    public synchronized boolean[] jarWrkMastExecuteGenerateJar(boolean[] signExecute,Integer sign) {
@@ -4787,10 +4793,10 @@
                add(2);
            }});

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

            for (BasJarMast basJarMast : basJarMastList){
                JarSlave.StaStn staStn = null;
@@ -4899,10 +4905,10 @@
            if (Cools.isEmpty(basJarMastSign)){
                return false;
            }
            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1,SteStatusType.IDLE)){
                return false;
            }
//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),1,SteStatusType.IDLE)){
//                return false;
//            }

            JarSlave.RgvStn rgvStn = jarSlave.getJarInRgv().get(0);

@@ -4971,10 +4977,10 @@
            if (Cools.isEmpty(basJarMastSign)){
                return false;
            }
            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),2,SteStatusType.IDLE)){
                return false;
            }
//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarInSte().get(0).getSteNo(),2,SteStatusType.IDLE)){
//                return false;
//            }

            //判断RGV状态
            JarSlave.RgvStn rgvStn = jarSlave.getJarOutRgv().get(0);
@@ -5041,10 +5047,10 @@
            if (Cools.isEmpty(jarMastByJarIdMin)){
                return false;
            }
            //判断小车状态
            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),2,SteStatusType.IDLE)){
                return false;
            }
//            //判断小车状态
//            if (!jarWrkMastExecuteGenerateSteStatus(jarSlave.getJarOutSte().get(0).getSteNo(),2,SteStatusType.IDLE)){
//                return false;
//            }

            //判断RGV状态
            JarSlave.RgvStn rgvStn = jarSlave.getJarOutRgv().get(0);
@@ -5263,6 +5269,25 @@
        return false;
    }

    /**
     *  JarWrkMastExecute任务创建===>执行   //完成
     */
    public synchronized boolean jarWrkMastExecuteGenerateExecuteMove(BasJar basJar,BasJarMast basJarMast,Integer id,int[] digit) {
        try {
            WrkMastExecute wrkMastExecute = new WrkMastExecute(basJarMast);
            wrkMastExecute.setJarId(id);
            wrkMastExecute.setSteId(digit[0]);//穿梭板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);
        } catch (Exception e) {
            log.error("JarWrkMastExecute任务创建===>执行异常===》异常原因："+e.getMessage());
        }
        return false;
    }

    /*
    * JarWrkMastExecute任务创建==>下发
    * Action
@@ -5295,40 +5320,40 @@
                        if (jarWrkMastExecuteActionExecute1(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                        continue;
                    case 2:
                    case 4:
                        if (jarWrkMastExecuteActionExecute2(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                        continue;
                    case 5:
                        if (jarWrkMastExecuteActionExecute5(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                        continue;
                    case 6:
                        if (jarWrkMastExecuteActionExecute6(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                        continue;
                    case 7:
                    case 8:
                        if (jarWrkMastExecuteActionExecute7(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                        continue;
                    case 9:
                        if (jarWrkMastExecuteActionExecute9(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                        continue;
                    case 10:
                    case 11:
                        if (jarWrkMastExecuteActionExecute10(wrkMastExecute,sign)){
                            break;
                        }
                        return;
                        continue;
                }
            }
        } catch (Exception e){
@@ -5496,7 +5521,7 @@
            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -5509,26 +5534,26 @@
                    if (!jarProtocol.isLeftDoor() && !jarProtocol.isRightDoor()){
                        if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                            //移走  == > 2
                            if (jarRgvMoveTake(wrkMastExecute,2)){
                            if (!jarRgvMoveTake(wrkMastExecute,2)){
                                log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkType(1);
                            wrkMastExecute.setWrkSts(2);
                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            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)){
                            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)){
                            if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
@@ -5537,7 +5562,7 @@
                        //直接完成
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(4);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -5613,7 +5638,7 @@
            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -5626,27 +5651,27 @@
                    if (jarProtocol.isLeftDoor() && jarProtocol.isRightDoor()){
                        if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                            //移走  == > 2
                            if (jarRgvMoveTake(wrkMastExecute,2)){
                            if (!jarRgvMoveTake(wrkMastExecute,2)){
                                log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkType(1);
                            wrkMastExecute.setWrkSts(2);

                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            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)){
                            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)){
                            if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
@@ -5655,7 +5680,7 @@
                        //直接完成
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(4);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -5701,11 +5726,6 @@
                return false;
            }

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

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
@@ -5726,11 +5746,10 @@
            if (staProtocolRGVOther == null) {
                return false;
            }

            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -5740,14 +5759,14 @@
                //自动、空闲、  进料们打开需关闭
                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(),1,SteStatusType.IDLE)){
                        return false;
                    }
                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //判断小车状态
                        if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                            return false;
                        }

                        //调车  == > 取货
                        if (jarRgvGetTake(wrkMastExecute
                        if (!jarRgvGetTake(wrkMastExecute
                                ,SteAndJarUtil.getRgvStaRow(wrkMastExecute.getJarEnterStaNo())==1
                                ,SteAndJarUtil.getRgvStaRow(wrkMastExecute.getJarEnterStaNo())==3)){
                            log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
@@ -5756,19 +5775,19 @@
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(3);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        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()))){
                        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(2);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -5841,10 +5860,11 @@
                return false;
            }

            if (staProtocolRGV.rgvBoolean(2) && staProtocolRGVOther.rgvBoolean(1)){
//            if (staProtocolRGV.rgvBoolean(2) && staProtocolRGVOther.rgvBoolean(1)){
            if (staProtocolRGV.rgvBoolean(2)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -5861,19 +5881,19 @@
                            return false;
                        }
                        //调车  == > 取货
                        if (jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT22.id,SteTaskModeType.STE_WFFH_13,false)){
                        if (!jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT22.id,SteTaskModeType.STE_WFFH_13,false)){
                            log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
                        wrkMastExecute.setWrkType(1);
                        wrkMastExecute.setWrkSts(5);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        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()))){
                        if (!jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){
                            log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -5919,11 +5939,6 @@
                return false;
            }

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

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2);
            StaProtocol staProtocolRGV = devpThread.getStation().get(basJar.getEnterRgvNo());
            if (staProtocolRGV == null) {
@@ -5948,7 +5963,7 @@
            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -5958,32 +5973,33 @@
                //自动、空闲、
                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(),1,SteStatusType.IDLE)){
                        return false;
                    }

                    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)){
                        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)){
                        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()))){
                        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(2);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -6058,7 +6074,7 @@
            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -6075,25 +6091,25 @@
                            return false;
                        }
                        //调车  == > 取货
                        if (jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT21.id,SteTaskModeType.STE_WFQH_12,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)){
                        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()))){
                        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(2);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -6113,12 +6129,13 @@

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  7：穿梭车进冷却槽\8：穿梭车离开冷却槽
     *  7：穿梭车进冷却槽   7  B=>C
     *  8：穿梭车离开冷却槽  8 C=>B
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute7(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecute);
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }
@@ -6184,7 +6201,7 @@
            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -6199,7 +6216,7 @@

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

                    } else {
                        //调车  == > endRow
                        if (jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){
                        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(2);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -6359,13 +6376,13 @@
                    //判断小车状态
                    if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE)){
                        //调车  == > 取货
                        if (jarSteTake(wrkMastExecute,SteLocaType.POINT26.id,SteLocaType.POINT24.id,SteTaskModeType.STE_WFQH_12,false)){
                        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)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},冷却槽数据={},sign={}",
                                    wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(basJar),sign);
                        }
@@ -6419,7 +6436,7 @@
                }
                wrkMastExecute.setWrkType(1);
                wrkMastExecute.setWrkSts(3);
                if (wrkMastExecuteService.updateById(wrkMastExecute)){
                if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                    log.error("输送线出库目标站命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},放货站点数据={},sign={}",
                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocol),sign);
                }
@@ -6438,7 +6455,7 @@
     */
    public synchronized boolean jarWrkMastExecuteActionExecute10(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.getWrkMastExecuteByJarNo(wrkMastExecute.getJarId());
            List<WrkMastExecute> wrkMastExecuteByJarNo = wrkMastExecuteService.selectWrkMastExecuteByWrk(wrkMastExecute);
            if (wrkMastExecuteByJarNo.size()!=1 || !wrkMastExecuteByJarNo.get(0).getWrkNo().equals(wrkMastExecute.getWrkNo())){
                return false;
            }
@@ -6488,7 +6505,7 @@
            if (staProtocolRGV.rgvBoolean(1) && staProtocolRGVOther.rgvBoolean(1)){
                if (staProtocolRGV.getNowRow() != staProtocolRGVOther.getNowRow()){
                    //移走  == > 2
                    if (jarRgvMoveTake(wrkMastExecute,2)){
                    if (!jarRgvMoveTake(wrkMastExecute,2)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                    }
@@ -6502,44 +6519,44 @@

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

                    } else {
                        //调车  == > endRow
                        if (jarRgvMoveTake(wrkMastExecute,SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId()))){
                        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(2);
                        if (wrkMastExecuteService.updateById(wrkMastExecute)){
                        if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                            log.error("硫化罐Jar命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -6639,11 +6656,15 @@
    public synchronized boolean jarSteTake(WrkMastExecute wrkMastExecute,Integer startLoad,Integer endLoad,SteTaskModeType steTaskModeType,boolean complete){
        try {
            SteCommand steCommand = new SteCommand();
            steCommand.setTaskNo(wrkMastExecute.getWrkNo().intValue());
            steCommand.setSteNo(wrkMastExecute.getSteId());
            steCommand.setStartLoad(startLoad);
            steCommand.setEndLoad(endLoad);
            steCommand.setTaskModeType(steTaskModeType);
            steCommand.setComplete(complete);
            if (!complete){
                steCommand.setTaskMode(steTaskModeType.id.shortValue());
            }
            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);
@@ -6676,7 +6697,7 @@
    }

    /**
     *  JarWrkMastExecute任务完成   //未完成
     *  JarWrkMastExecute任务完成   //完成
     */
    public synchronized void jarWrkMastExecuteGenerateComplete(Integer sign) {
        try{
@@ -6728,9 +6749,9 @@
                    continue;
                }
                if (steProtocol.getMode()==(short)1 && steProtocol.taskNo!=0 && steProtocol.getChargeStatus()==0){
                    if (steProtocol.statusType.equals(SteStatusType.WAITING)){

                    }
//                    if (steProtocol.statusType.equals(SteStatusType.WAITING)){
//
//                    }
                    WrkMastExecute wrkMastExecute = wrkMastExecuteService.getWrkMastExecuteByWrkNo(steProtocol.getTaskNo().longValue());
                    if (!Cools.isEmpty(wrkMastExecute)){
                        switch (wrkMastExecute.getIoType()){
@@ -6742,10 +6763,11 @@
                                        //ste任务完成
                                        if (jarSteTake(wrkMastExecute,null,null,null,true)){
                                            wrkMastExecute.setWrkSts(4);
                                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                            if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                                                log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                            }
                                            return true;
                                        }
                                    }
                                    log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
@@ -6756,23 +6778,19 @@
                                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);
                                                }
                                    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);
                                            }
                                            return true;
                                        }
                                        log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                        return true;
                                    }
                                    log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                    return true;
                                }
                                return false;
@@ -6787,10 +6805,11 @@
                                        //ste任务完成
                                        if (jarSteTake(wrkMastExecute,null,null,null,true)){
                                            wrkMastExecute.setWrkSts(4);
                                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                            if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                                                log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                            }
                                            return true;
                                        }
                                    }
                                    log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
@@ -6806,10 +6825,11 @@
                                        //ste任务完成
                                        if (jarSteTake(wrkMastExecute,null,null,null,true)){
                                            wrkMastExecute.setWrkSts(2);
                                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                                            if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                                                log.error("穿梭车Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},穿梭车数据={},sign={}",
                                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(steProtocol),sign);
                                            }
                                            return true;
                                        }
                                    }
                                    log.error("穿梭车Ste命令下发失败===>下发异常，jar号={},任务数据={},穿梭车数据={},sign={}",
@@ -6879,7 +6899,7 @@
                        WrkMastExecute execute = new WrkMastExecute();
                        execute.setJarId(jarProtocol.getJarNo());
                        //直接关门
                        if (jarDoorTake(execute,JarTaskModeType.OPEN_THE_DOOR_COMPLETE)){
                        if (!jarDoorTake(execute,JarTaskModeType.OPEN_THE_DOOR_COMPLETE)){
                            log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    execute.getJarId(), JSON.toJSON(execute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -6888,12 +6908,12 @@
                    for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){
                        if (wrkMastExecute.getIoType() == 1 || wrkMastExecute.getIoType() == 3){
                            //直接关门
                            if (jarDoorTake(wrkMastExecute,JarTaskModeType.OPEN_THE_DOOR_COMPLETE)){
                            if (!jarDoorTake(wrkMastExecute,JarTaskModeType.OPEN_THE_DOOR_COMPLETE)){
                                log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkSts(4);
                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                return false;
@@ -6913,7 +6933,7 @@
                        WrkMastExecute execute = new WrkMastExecute();
                        execute.setJarId(jarProtocol.getJarNo());
                        //直接关门
                        if (jarDoorTake(execute,JarTaskModeType.CLOSE_THE_DOOR_COMPLETE)){
                        if (!jarDoorTake(execute,JarTaskModeType.CLOSE_THE_DOOR_COMPLETE)){
                            log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                    execute.getJarId(), JSON.toJSON(execute), JSON.toJSON(jarProtocol),sign);
                        }
@@ -6922,12 +6942,12 @@
                    for (WrkMastExecute wrkMastExecute : wrkMastExecuteList){
                        if (wrkMastExecute.getIoType() == 2 || wrkMastExecute.getIoType() == 4){
                            //直接关门
                            if (jarDoorTake(wrkMastExecute,JarTaskModeType.CLOSE_THE_DOOR_COMPLETE)){
                            if (!jarDoorTake(wrkMastExecute,JarTaskModeType.CLOSE_THE_DOOR_COMPLETE)){
                                log.error("硫化罐Jar命令下发失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                            }
                            wrkMastExecute.setWrkSts(4);
                            if (wrkMastExecuteService.updateById(wrkMastExecute)){
                            if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                                log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                        wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(jarProtocol),sign);
                                return false;
@@ -6979,7 +6999,7 @@
                if (staProtocolRGV.getNowRow() == staProtocolRGVEnd.getNowRow()
                        && staProtocolRGV.getNowRow() == SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId())){
                    wrkMastExecute.setWrkSts(2);
                    if (wrkMastExecuteService.updateById(wrkMastExecute)){
                    if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                        log.error("平衡车Rgv命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},平衡车Rgv数据={},sign={}",
                                wrkMastExecute.getSteId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocolRGV),sign);
                        return false;
@@ -7015,28 +7035,20 @@
                    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()

                if ( staProtocolRGV.rgvBoolean(2)
                        && staProtocolRGV.getNowRow() == SteAndJarUtil.getRgvJarNowRow(wrkMastExecute.getJarId())){
                    //调车  == > 取货完成复位
                    if (!jarRgvGetFuTake(wrkMastExecute,true)){
                        log.error("平衡车RGV命令下发失败，rgv号={},任务数据={},硫化罐数据={},sign={}",
                                wrkMastExecute.getJarId(), JSON.toJSON(wrkMastExecute), JSON.toJSON(staProtocolRGV),sign);
                        return false;
                        return true;
                    }
                    wrkMastExecute.setWrkSts(4);
                    if (wrkMastExecuteService.updateById(wrkMastExecute)){
                    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;
                }
@@ -7048,4 +7060,119 @@
        return false;
    }

    /**
     *  Jar任务  穿梭车移动任务   //完成
     */
    public synchronized boolean jarMastMove() {
        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 (wrkMastExecuteService.selectNoStart(steSlave.getId())!=0){
                    continue;
                }

                if (wrkMastExecuteService.selectMoveStart(steSlave.getId())!=0){
                    continue;
                }

                try{
                    if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),1,SteStatusType.IDLE)){
                        List<WrkMastExecute> wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 5, null);
                        if (wrkMastExecutes.isEmpty()){
                            List<WrkMastExecute> wrkMastExecutesB = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null);
                            List<WrkMastExecute> wrkMastExecutesC = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null);

                            if (!wrkMastExecutesB.isEmpty() || !wrkMastExecutesC.isEmpty()){
                                WrkMastExecute wrkMastExecute = !wrkMastExecutesB.isEmpty() ? wrkMastExecutesB.get(0) : wrkMastExecutesC.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
                                if (Cools.isEmpty(basJar)){
                                    log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId());
                                    return false;
                                }
                                BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo());
                                //A==>B
                                if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),10,1})){
                                    log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo));
                                }
                                continue;
                            }
                        }
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),2,SteStatusType.IDLE)){
                        List<WrkMastExecute> wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null);
                        if (wrkMastExecutes.isEmpty()){
                            List<WrkMastExecute> wrkMastExecutesA = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 5, null);
                            List<WrkMastExecute> wrkMastExecutesC = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null);
                            if (!wrkMastExecutesA.isEmpty()){
                                WrkMastExecute wrkMastExecute = wrkMastExecutesA.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
                                if (Cools.isEmpty(basJar)){
                                    log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId());
                                    return false;
                                }
                                BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo());
                                //B==>A
                                if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),11,1})){
                                    log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo));
                                }
                                continue;
                            }

                            if (!wrkMastExecutesC.isEmpty()){
                                WrkMastExecute wrkMastExecute = wrkMastExecutesC.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
                                if (Cools.isEmpty(basJar)){
                                    log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId());
                                    return false;
                                }
                                BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo());
                                //B==>C
                                if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),7,1})){
                                    log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo));
                                }
                                continue;
                            }
                        }
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),3,SteStatusType.IDLE)){
                        List<WrkMastExecute> wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null);
                        if (wrkMastExecutes.isEmpty()){
                            List<WrkMastExecute> wrkMastExecutesB = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null);
                            List<WrkMastExecute> wrkMastExecutesA = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null);
                            if (!wrkMastExecutesB.isEmpty() || !wrkMastExecutesA.isEmpty()){
                                WrkMastExecute wrkMastExecute = !wrkMastExecutesB.isEmpty() ? wrkMastExecutesB.get(0) : wrkMastExecutesA.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
                                if (Cools.isEmpty(basJar)){
                                    log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId());
                                    return false;
                                }
                                BasJarMast jarMastByWrkNo = basJarMastService.getJarMastByWrkNo(wrkMastExecute.getWrkNo());
                                //C==>B
                                if (!jarWrkMastExecuteGenerateExecute(basJar,jarMastByWrkNo,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),8,1})){
                                    log.error("JarWrkMastExecute任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(jarMastByWrkNo));
                                }
                                continue;
                            }
                        }
                    }
                }catch (Exception e){
                    log.error("硫化区域分段任务完成异常,steProtocol={},异常信息={}",JSON.toJSONString(steProtocol),e.getMessage());
                }

                WrkMastExecute wrkMastExecute = wrkMastExecuteService.selectStart(steSlave.getId());


            }
        } catch (Exception e){
            log.error("硫化区域分段任务完成异常,异常信息={}",e.getMessage());
        }
        return false;
    }

}