#

lsh

2024-07-17 675ed4fa602e79e220e76fcdbc56e4630c0fb21c

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

@@ -8,6 +8,7 @@
import com.core.common.DateUtils;
import com.core.common.R;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.WorkNoType;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
@@ -1232,7 +1233,7 @@
            } else {
                staProtocol = staProtocol.clone();
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
            if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == null || staProtocol.getWorkNo() == 0)) {

                // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn,crnNo);
@@ -1293,6 +1294,9 @@
                        }
                    }
                }else if (conStation==2){
                    if (crnProtocol.statusType != CrnStatusType.IDLE){
                        return false;
                    }
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep2345(staProtocol.getSiteId(),crnProtocol.getTaskNoTwo().intValue());
                    if (wrkMast == null) {
@@ -1900,6 +1904,145 @@
                }
            }

            StaProtocol staProtocolOther = devpThread.getStation().get(crnStn.getStaNoOther());
            if (staProtocolOther == null) {
                continue;
            } else {
                staProtocolOther = staProtocolOther.clone();
            }

            // 查询站点详细信息
            BasDevp staDetlOther = basDevpService.selectById(crnStn.getStaNoOther());
            if (staDetlOther == null) {
                log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNoOther());
                continue;
            }
            if (staProtocolOther.getWorkNo()!=0){
                WrkMast wrkMastOther = wrkMastMapper.selectPakInStep3(staProtocolOther.getWorkNo());
                if (Cools.isEmpty(wrkMastOther)){
                    log.error("Other查询工作档案无数据--工作号{},站点号：{}", staProtocolOther.getWorkNo(),staProtocolOther.getSiteId());
                    continue;
                }
                // 获取库位信息
                LocMast locMastOther = locMastService.selectById(wrkMastOther.getLocNo());
                if (locMastOther == null) {
                    log.error("查询库存无数据--库位号{}", locMastOther.getLocNo());
                    continue;
                }
                if (!locMastOther.getLocSts().equals("S") && !locMastOther.getLocSts().equals("Q")) {
                    log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMastOther.getLocNo(), locMastOther.getLocSts());
                    continue;
                }
                if (locMastOther.getBay1()!=81){
                    if (staProtocolOther.isAutoing() && staProtocolOther.isLoading()
                            && staProtocolOther.isInEnable() && staDetlOther.getCanining() != null && staDetlOther.getCanining().equals("Y")) {
                        // 命令下发区 --------------------------------------------------------------------------
                        CrnCommandParam crnCommandParam = new CrnCommandParam();
                        crnCommandParam.setCrnNo(slave.getId()); // 堆垛机编号

                        crnCommandParam.setTaskNo2(wrkMast.getWrkNo().shortValue()); // 工作号
                        crnCommandParam.setAckFinish2((short) 0);  // 任务完成确认位
                        crnCommandParam.setTaskMode2(CrnTaskModeType.SEPARATE_TAKE); // 任务模式:  单取货
                        crnCommandParam.setSourcePosX2(crnStn.getRow().shortValue());     // 源库位排
                        crnCommandParam.setSourcePosY2(crnStn.getBay().shortValue());     // 源库位列
                        crnCommandParam.setSourcePosZ2(crnStn.getLev().shortValue());     // 源库位层
                        crnCommandParam.setDestinationPosX2((short)0);     // 目标库位排
                        crnCommandParam.setDestinationPosY2((short)0);     // 目标库位列
                        crnCommandParam.setDestinationPosZ2((short)0);     // 目标库位层

                        crnCommandParam.setTaskNo(wrkMastOther.getWrkNo().shortValue()); // 工作号
                        crnCommandParam.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommandParam.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式:  单取货
                        crnCommandParam.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                        crnCommandParam.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
                        crnCommandParam.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
                        crnCommandParam.setDestinationPosX((short)0);     // 目标库位排
                        crnCommandParam.setDestinationPosY((short)0);     // 目标库位列
                        crnCommandParam.setDestinationPosZ((short)0);     // 目标库位层
                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(99, crnCommandParam.getCrnNo()-2))) {
                            log.error("输送线锁定命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), crnCommandParam.getCrnNo()-2);
                            continue;
                        }
                        if (!MessageQueue.offer(SlaveType.Crn, crnCommandParam.getCrnNo(), new Task(9, crnCommandParam))) {
                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(crnCommandParam));
                        } else {
                            // 修改工作档状态 2.设备上走 => 3.吊车入库中
                            Date now = new Date();
                            wrkMast.setWrkSts(3L);
                            wrkMast.setCrnStrTime(now);
                            wrkMast.setModiTime(now);
                            WrkMastSplitTwin wrkMastSplitTwin = new WrkMastSplitTwin(wrkMast,2,now);
                            wrkMastSplitTwin.setWrkSts(1);
                            wrkMastSplitTwin.setWrkStart(wrkMast.getStaNo().toString());
                            wrkMastSplitTwin.setWrkEnd(wrkMast.getLocNo());
                            wrkMastSplitTwin.setStartRow(crnStn.getRow());
                            wrkMastSplitTwin.setStartBay(crnStn.getBay());
                            wrkMastSplitTwin.setStartLev(crnStn.getLev());
                            wrkMastSplitTwin.setEndRow(locMast.getRow1());
                            wrkMastSplitTwin.setEndBay(locMast.getBay1());
                            wrkMastSplitTwin.setEndLev(locMast.getLev1());
                            wrkMastSplitTwin.setWrkType(1);
                            wrkMastSplitTwin.setIoType(1);

                            wrkMastOther.setWrkSts(3L);
                            wrkMastOther.setCrnStrTime(now);
                            wrkMastOther.setModiTime(now);
                            WrkMastSplitTwin wrkMastSplitTwinOther = new WrkMastSplitTwin(wrkMastOther,1,now);
                            wrkMastSplitTwinOther.setWrkSts(1);
                            wrkMastSplitTwinOther.setWrkStart(wrkMastOther.getStaNo().toString());
                            wrkMastSplitTwinOther.setWrkEnd(wrkMastOther.getLocNo());
                            wrkMastSplitTwinOther.setStartRow(crnStn.getRow());
                            wrkMastSplitTwinOther.setStartBay(crnStn.getBay());
                            wrkMastSplitTwinOther.setStartLev(crnStn.getLev());
                            wrkMastSplitTwinOther.setEndRow(locMastOther.getRow1());
                            wrkMastSplitTwinOther.setEndBay(locMastOther.getBay1());
                            wrkMastSplitTwinOther.setEndLev(locMastOther.getLev1());
                            wrkMastSplitTwinOther.setWrkType(1);
                            wrkMastSplitTwinOther.setIoType(1);

                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }

                            if (wrkMastSplitTwinMapper.insert(wrkMastSplitTwin)==0){
                                log.error("创建 堆垛机执行任务 失败！！，工作号={}，堆垛机号={}", wrkMast.getWrkNo(),wrkMast.getCrnNo());
                            }

                            if (wrkMastMapper.updateById(wrkMastOther) == 0) {
                                log.error("Other修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }

                            if (wrkMastSplitTwinMapper.insert(wrkMastSplitTwinOther)==0){
                                log.error("Other创建 堆垛机执行任务 失败！！，工作号={}，堆垛机号={}", wrkMast.getWrkNo(),wrkMast.getCrnNo());
                            }
                            return;
                        }
                    }
                }
                return;
            }
            StaProtocol staProtocolOther1 = devpThread.getStation().get(crnStn.getStaNoOther1());
            if (staProtocolOther1 == null) {
                continue;
            } else {
                staProtocolOther1 = staProtocolOther1.clone();
            }

            if (staProtocolOther1.isAutoing() && staProtocolOther1.getWorkNo()!=0){
                return;
            }


            StaProtocol staProtocolOther2 = devpThread.getStation().get(crnStn.getStaNoOther2());
            if (staProtocolOther2 == null) {
                continue;
            } else {
                staProtocolOther2 = staProtocolOther2.clone();
            }
            if (staProtocolOther2.isAutoing() && staProtocolOther2.getWorkNo()!=0){
                return;
            }
            crnStation = 2;
            // 命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
@@ -1912,7 +2055,17 @@
            crnCommand.setDestinationPosX((short)0);     // 目标库位排
            crnCommand.setDestinationPosY((short)0);     // 目标库位列
            crnCommand.setDestinationPosZ((short)0);     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) {

            staProtocol.setWorkNo(wrkMast.getWrkNo());
            staProtocol.setStaNo(wrkMast.getStaNo());

            devpThread.setPakMk(staProtocol.getSiteId(), false);

            if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(99, crnCommand.getCrnNo()-2))) {
                log.error("输送线锁定命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), crnCommand.getCrnNo()-2);
                continue;
            }
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(5, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSONString(crnCommand));
            } else {
                // 修改工作档状态 2.设备上走 => 3.吊车入库中
@@ -4360,6 +4513,39 @@
            int[] sign = new int[]{0,0};
            // 只有当堆垛机自动时才继续执行
            if (crnProtocol.getModeType() == CrnModeType.AUTO) {
                //双
                if (crnProtocol.getStatusType() == CrnStatusType.SEPARATE_IDLE
                        && crnProtocol.getTaskNo() == 0
                        && crnProtocol.getLoaded() == 1
                        && crnProtocol.getForkPos() == 0) {
                    if (crnProtocol.getStatusTypeTwo() == CrnStatusType.SEPARATE_IDLE
                            && crnProtocol.getTaskNoTwo() == 0
                            && crnProtocol.getLoadedTwo() == 1
                            && crnProtocol.getForkPosTwo() == 0){
                        List<WrkMastSplitTwin> wrkMastSplitTwinList1 = wrkMastSplitTwinService.getWrkMastSplitTwin(crn.getId(),1,2,2,0);
                        List<WrkMastSplitTwin> wrkMastSplitTwinList2 = wrkMastSplitTwinService.getWrkMastSplitTwin(crn.getId(),2,2,2,0);
                        if (!wrkMastSplitTwinList1.isEmpty() && !wrkMastSplitTwinList2.isEmpty() ){
                            if (wrkMastSplitTwinList1.size()>1 || wrkMastSplitTwinList2.size()>1 ){
                                log.error("Pair堆垛机出入库下发异常,堆垛机号={},异常信息={},工位号={},工作类型={}",crn.getId(),"存在多笔可执行作业，请删除无效作业！！！",sign[1],sign[0]);
                                return false;
                            }
                            WrkMastSplitTwin wrkMastSplitTwin1 = wrkMastSplitTwinList1.get(0);
                            WrkMastSplitTwin wrkMastSplitTwin2 = wrkMastSplitTwinList2.get(0);
                            boolean ack =  crnExecutePutFullPair(crn.getId(), wrkMastSplitTwin1,wrkMastSplitTwin2, sign[1]);
                            if (ack){
                                wrkMastSplitTwin1.setWrkSts(wrkMastSplitTwin1.getWrkType()==1? 1:3);
                                wrkMastSplitTwinService.updateById(wrkMastSplitTwin1);
                                wrkMastSplitTwin2.setWrkSts(wrkMastSplitTwin2.getWrkType()==1? 1:3);
                                wrkMastSplitTwinService.updateById(wrkMastSplitTwin2);
                            }else {
                                log.error("堆垛机出入库下发报错,堆垛机号={},异常信息={}",crn.getId(),"下发任务返回值为："+ack);
                            }

                            return false;
                        }

                    }
                }
                // 只有当堆垛机工位1取货或者有物 并且 工位2无任务时才继续执行
                switch (i){
                    case 1:
@@ -4473,6 +4659,84 @@
            crnCommand.setDestinationPosZ(wrkMastSplitTwin.getEndLev().shortValue());     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, wrkMastSplitTwin.getCrnNo(), new Task(crnStation==1? 2:5, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMastSplitTwin.getCrnNo(), JSON.toJSONString(crnCommand));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 堆垛机取货至工位任务
     * */
    public synchronized boolean crnExecuteTakeFullPair(Integer crnNo,WrkMastSplitTwin wrkMastSplitTwinOne,WrkMastSplitTwin wrkMastSplitTwinTwo, Integer crnStation){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            // 1.堆垛机开始移动
            CrnCommandParam crnCommandParam = new CrnCommandParam();
            crnCommandParam.setCrnNo(crnNo); // 堆垛机编号
            crnCommandParam.setTaskNo(wrkMastSplitTwinOne.getWrkNo().shortValue()); // 工作号
            crnCommandParam.setAckFinish((short) 0);  // 任务完成确认位
            crnCommandParam.setTaskMode(CrnTaskModeType.SEPARATE_TAKE); // 任务模式:  单取货
            crnCommandParam.setSourcePosX(wrkMastSplitTwinOne.getStartRow().shortValue());     // 源库位排
            crnCommandParam.setSourcePosY(wrkMastSplitTwinOne.getStartBay().shortValue());     // 源库位列
            crnCommandParam.setSourcePosZ(wrkMastSplitTwinOne.getStartLev().shortValue());     // 源库位层
            crnCommandParam.setDestinationPosX((short)0);     // 目标库位排
            crnCommandParam.setDestinationPosY((short)0);     // 目标库位列
            crnCommandParam.setDestinationPosZ((short)0);     // 目标库位层

            crnCommandParam.setTaskNo2(wrkMastSplitTwinTwo.getWrkNo().shortValue()); // 工作号
            crnCommandParam.setAckFinish2((short) 0);  // 任务完成确认位
            crnCommandParam.setTaskMode2(CrnTaskModeType.SEPARATE_TAKE); // 任务模式:  单取货
            crnCommandParam.setSourcePosX2(wrkMastSplitTwinTwo.getStartRow().shortValue());     // 源库位排
            crnCommandParam.setSourcePosY2(wrkMastSplitTwinTwo.getStartBay().shortValue());     // 源库位列
            crnCommandParam.setSourcePosZ2(wrkMastSplitTwinTwo.getStartLev().shortValue());     // 源库位层
            crnCommandParam.setDestinationPosX2((short)0);     // 目标库位排
            crnCommandParam.setDestinationPosY2((short)0);     // 目标库位列
            crnCommandParam.setDestinationPosZ2((short)0);     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, crnCommandParam.getCrnNo(), new Task(9, crnCommandParam))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnCommandParam.getCrnNo(), JSON.toJSONString(crnCommandParam));
                return false;
            } else {
                return true;
            }
        }catch (Exception e){
            return false;
        }
    }

    /*
     * 堆垛机放货货至出库站点任务
     * */
    public synchronized boolean crnExecutePutFullPair(Integer crnNo,WrkMastSplitTwin wrkMastSplitTwinOne,WrkMastSplitTwin wrkMastSplitTwinTwo, Integer crnStation){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            // 1.堆垛机开始移动
            CrnCommandParam crnCommandParam = new CrnCommandParam();
            crnCommandParam.setCrnNo(crnNo); // 堆垛机编号
            crnCommandParam.setTaskNo(wrkMastSplitTwinOne.getWrkNo().shortValue()); // 工作号
            crnCommandParam.setAckFinish((short) 0);  // 任务完成确认位
            crnCommandParam.setTaskMode(CrnTaskModeType.SEPARATE_PUT); // 任务模式:  单放货
            crnCommandParam.setSourcePosX((short)0);     // 源库位排
            crnCommandParam.setSourcePosY((short)0);     // 源库位列
            crnCommandParam.setSourcePosZ((short)0);     // 源库位层
            crnCommandParam.setDestinationPosX(wrkMastSplitTwinOne.getEndRow().shortValue());     // 目标库位排
            crnCommandParam.setDestinationPosY(wrkMastSplitTwinOne.getEndBay().shortValue());     // 目标库位列
            crnCommandParam.setDestinationPosZ(wrkMastSplitTwinOne.getEndLev().shortValue());     // 目标库位层

            crnCommandParam.setTaskNo2(wrkMastSplitTwinTwo.getWrkNo().shortValue()); // 工作号
            crnCommandParam.setAckFinish2((short) 0);  // 任务完成确认位
            crnCommandParam.setTaskMode2(CrnTaskModeType.SEPARATE_PUT); // 任务模式:  单放货
            crnCommandParam.setSourcePosX2((short)0);     // 源库位排
            crnCommandParam.setSourcePosY2((short)0);     // 源库位列
            crnCommandParam.setSourcePosZ2((short)0);     // 源库位层
            crnCommandParam.setDestinationPosX2(wrkMastSplitTwinTwo.getEndRow().shortValue());     // 目标库位排
            crnCommandParam.setDestinationPosY2(wrkMastSplitTwinTwo.getEndBay().shortValue());     // 目标库位列
            crnCommandParam.setDestinationPosZ2(wrkMastSplitTwinTwo.getEndLev().shortValue());     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, crnCommandParam.getCrnNo(), new Task(9, crnCommandParam))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", crnCommandParam.getCrnNo(), JSON.toJSONString(crnCommandParam));
                return false;
            } else {
                return true;
@@ -5295,7 +5559,7 @@
     *  2：B面 出料面
     *  3：冷却槽B面 上输送线
     */
    public synchronized boolean jarWrkMastExecuteGenerateSteStatus(Integer steNo,Integer type,SteStatusType steStatusType) {
    public synchronized boolean jarWrkMastExecuteGenerateSteStatus(Integer steNo,Integer type,SteStatusType steStatusType,boolean chargeSign) {
        try{
            //判断小车状态
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
@@ -5312,6 +5576,61 @@
            }
            if (steProtocol.getChargeStatus()!=0){
                log.error(steNo + "号小车在充电，等待....");
                return false;
            }
            if (steProtocol.getCharge()<31.0F && chargeSign){
                log.error(steNo + "号小车当前电量过低，准备充电...当前电量"+steProtocol.getCharge().toString());
                return false;
            }
            if (!steProtocol.getStatusType().equals(steStatusType)) {
                log.error(steNo + "号小车状态不是"+JSON.toJSONString(steStatusType)+"，等待....");
                return false;
            }
            switch (type){
                case 1:
                    if (!steProtocol.getLocaType().equals(SteLocaType.POINT20)) {
                        log.error(steNo + "号小车不在A面平移车，无法操作");
                        return false;
                    }
                    break;
                case 2:
                    if (!steProtocol.getLocaType().equals(SteLocaType.POINT23)) {
                        log.error(steNo + "号小车不在B面平移车，无法操作");
                        return false;
                    }
                    break;
                case 3:
                    if (!steProtocol.getLocaType().equals(SteLocaType.POINT26) && !steProtocol.getLocaType().equals(SteLocaType.POINT25)) {
                        log.error(steNo + "号小车不在水槽B端，无法操作");
                        return false;
                    }
                    break;
                default: return false;
            }
            return true;
        } catch (Exception e){
            log.error("{}号小车状态判断状态异常,异常原因={}",steNo,e.getMessage());
        }
        return false;
    }

    public synchronized boolean jarWrkMastExecuteGenerateSteStatusCharge(Integer steNo,Integer type,SteStatusType steStatusType,boolean chargeSign) {
        try{
            //判断小车状态
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
            if (steThread == null) {
                return false;
            }
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) {
                return false;
            }
            if (steProtocol.getMode() != (short)1) {
                log.error(steNo + "号小车离线，无法操作");
                return false;
            }
            if (steProtocol.getCharge()<31.0F && chargeSign){
                log.error(steNo + "号小车当前电量过低，准备充电...当前电量"+steProtocol.getCharge().toString());
                return false;
            }
            if (!steProtocol.getStatusType().equals(steStatusType)) {
@@ -5387,7 +5706,7 @@
            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.setIoType(digit[2]);//任务类型 0: 未知  1: 开进料门  2: 关进料门  3: 开出料门  4: 关出料门  5: 入硫化罐  6: 入冷却槽  7: 穿梭车进冷却槽  8: 穿梭车离开冷却槽  9: 出冷却槽 10：A=>B 11:B=>A  100:小车充电任务
            wrkMastExecute.setType(digit[3]);//设备  0: 未知  1: 硫化罐  2: 冷却槽  3: 硫化罐==>冷却槽
            return wrkMastExecuteService.insert(wrkMastExecute);
        } catch (Exception e) {
@@ -5443,6 +5762,7 @@
                * 7: 穿梭车进冷却槽  8: 穿梭车离开冷却槽
                * 9: 出冷却槽
                * 10：A=>B 11:B=>A
                * 100：充电任务
                * */
                log.error("JarWrkMastExecute任务创建==>下发===>行={}",5326);
                switch (wrkMastExecute.getIoType()){
@@ -5482,6 +5802,11 @@
                    case 10:
                    case 11:
                        if (jarWrkMastExecuteActionExecute10(wrkMastExecute,sign)){
                            break;
                        }
                        continue;
                    case 100:
                        if (jarWrkMastExecuteActionExecute100(wrkMastExecute,sign)){
                            break;
                        }
                        continue;
@@ -5923,7 +6248,7 @@
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){
                    log.error("5:入硫化罐==>任务下发===>行={}",5667);
                    //判断小车状态  //入硫化罐小车可临时屏蔽
                    if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                    if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,true)){
                        return false;
                    }
                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
@@ -6048,7 +6373,7 @@

                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //判断小车状态
                        if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                        if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,true)){
                            return false;
                        }
                        //调车  == > 取货
@@ -6157,7 +6482,7 @@
                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0){
                    log.error("6:入冷却槽==>任务下发===>行={}",6002);
                    //判断小车状态
                    if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                    if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,true)){
                        return false;
                    }

@@ -6280,7 +6605,7 @@

                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //判断小车状态
                        if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.WAITING2)){
                        if (!jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.WAITING2,false)){
                            return false;
                        }
                        //调车  == > 取货
@@ -6413,7 +6738,7 @@
                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocolOther.getJarNo())){
                        //判断小车状态
                        if (wrkMastExecute.getIoType()==7){  //7  B=>C
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,true)){
                                //调车  == > 移动
                                if (jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT26.id,SteTaskModeType.STE_MOVE_14,false,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
@@ -6425,7 +6750,7 @@
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign);
                                }
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE)){
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE,false)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (!wrkMastExecuteService.updateById(wrkMastExecute)){
@@ -6434,7 +6759,7 @@
                                }
                            }
                        } else { //8 C=>B
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE)){
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE,false)){
                                //调车  == > 移动
                                if (!jarSteTake(wrkMastExecute,SteLocaType.POINT26.id,SteLocaType.POINT23.id,SteTaskModeType.STE_MOVE_14,false,SteAndJarUtil.getBJarNo(wrkMastExecute.getJarId()))){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
@@ -6446,7 +6771,7 @@
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign);
                                }
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,false)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (!wrkMastExecuteService.updateById(wrkMastExecute)){
@@ -6576,7 +6901,7 @@
//                        && jarProtocol.leftDoorOpen==0  && jarProtocol.leftDoorClose==0 && jarProtocol.rightDoorOpen==0  && jarProtocol.rightDoorClose==0
//                ){
                    //判断小车状态
                    if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE)){
                    if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),3,SteStatusType.IDLE,true)){
                        log.error("9：出冷却槽==>任务下发===>行={}",6410);

                        //调车  == > 取货
@@ -6634,7 +6959,7 @@
            }

            //判断STE小车状态
            if (jarWrkMastExecuteGenerateSteStatus(wrkMastExecute.getSteId(),3,SteStatusType.IDLE)){
            if (jarWrkMastExecuteGenerateSteStatus(wrkMastExecute.getSteId(),3,SteStatusType.IDLE,false)){
                log.error("9：出冷却槽Two==>任务下发===>行={}",6468);
                // 下发站点信息
                staProtocol.setWorkNo(wrkMastExecute.getWrkNo().intValue());
@@ -6737,7 +7062,7 @@
                    if (SteAndJarUtil.steAndJarNowRow(staProtocolRGV.getNowRow() , jarProtocol.getJarNo())){
                        //判断小车状态
                        if (wrkMastExecute.getIoType()==10){//10：A=>B
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,true)){
                                //调车  == > 移动
                                if (!jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT23.id,SteTaskModeType.STE_MOVE_14,false,wrkMastExecute.getJarId())){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
@@ -6749,7 +7074,7 @@
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign);
                                }
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,false)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (!wrkMastExecuteService.updateById(wrkMastExecute)){
@@ -6758,7 +7083,7 @@
                                }
                            }
                        } else {//11:B=>A
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE)){
                            if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),2,SteStatusType.IDLE,false)){
                                //调车  == > 移动
                                if (!jarSteTake(wrkMastExecute,SteLocaType.POINT23.id,SteLocaType.POINT20.id,SteTaskModeType.STE_MOVE_14,false,wrkMastExecute.getJarId())){
                                    log.error("穿梭板Ste命令下发失败，ste号={},任务数据={},硫化罐数据={},sign={}",
@@ -6770,7 +7095,7 @@
                                    log.error("穿梭板Ste命令下发失败===>更新wrkMastExecute失败，jar号={},任务数据={},硫化罐数据={},sign={}",
                                            wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute), JSON.toJSONString(jarProtocol),sign);
                                }
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE)){
                            } else if (jarWrkMastExecuteGenerateSteStatus(basJar.getEnterSteNo(),1,SteStatusType.IDLE,false)){
                                wrkMastExecute.setWrkType(1);
                                wrkMastExecute.setWrkSts(4);
                                if (!wrkMastExecuteService.updateById(wrkMastExecute)){
@@ -6802,6 +7127,59 @@
            }
        } catch (Exception e){
            log.error("jarWrkMastExecuteActionExecute1任务执行下发异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }

    /**
     *  JarWrkMastExecute任务==>下发 //完成
     *  100：充电任务
     *  任务下发
     */
    public synchronized boolean jarWrkMastExecuteActionExecute100(WrkMastExecute wrkMastExecute,Integer sign) {
        try{
            // 获取硫化罐信息
            BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
            if (Cools.isEmpty(basJar)){
                log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId());
                return false;
            }

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

            if (staProtocolRGV.rgvBoolean(1) || staProtocolRGV.rgvBoolean(2)){
                //门作业  无
                //自动、空闲、
                    log.error("100:充电任务==>任务下发===>行={}",6899);
                    //判断小车状态
                    if (!jarWrkMastExecuteGenerateSteStatusCharge(basJar.getEnterSteNo(),1,SteStatusType.IDLE,false)){
                        return false;
                    }
                    //调车  == > 取货
                    if (!jarSteTake(wrkMastExecute,SteLocaType.POINT20.id,SteLocaType.POINT20.id,SteTaskModeType.START_CHARGE,false,wrkMastExecute.getJarId())){
                        log.error("穿梭板Ste充电命令下发失败，ste号={},任务数据={}",
                                wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute));
                    }
                    wrkMastExecute.setWrkType(1);
                    wrkMastExecute.setWrkSts(99);
                    if (!wrkMastExecuteService.updateById(wrkMastExecute)){
                        log.error("穿梭板Ste充电命令下发失败===>更新wrkMastExecute失败，ste号={},任务数据={}",
                                wrkMastExecute.getSteId(), JSON.toJSONString(wrkMastExecute));
                    }
                    return true;
                }
                return false;
        } catch (Exception e){
            log.error("穿梭板Ste充电命令下发失败,异常==》wrkMastExecute={},异常原因={}",wrkMastExecute,e.getMessage());
        }
        return false;
    }
@@ -7308,7 +7686,7 @@
                }

                try{
                    if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),1,SteStatusType.IDLE)){
                    if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),1,SteStatusType.IDLE,false)){
                        List<WrkMastExecute> wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 5, null);
                        if (wrkMastExecutes.isEmpty()){
                            List<WrkMastExecute> wrkMastExecutesB = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null);
@@ -7329,11 +7707,31 @@
                                continue;
                            }
                        }
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),2,SteStatusType.IDLE)){
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),2,SteStatusType.IDLE,false)){
                        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);
                            List<WrkMastExecute> wrkMastExecutes100 = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 100, null);
                            if (!wrkMastExecutes100.isEmpty()){
                                WrkMastExecute wrkMastExecute = wrkMastExecutes100.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
                                if (Cools.isEmpty(basJar)){
                                    log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId());
                                    return false;
                                }

                                BasJarMast jarMastByWrkNo = new BasJarMast(basJar);
                                jarMastByWrkNo.setWrkNo(Integer.toUnsignedLong(wrkMastExecute.getWrkNo().intValue()));//工作号
                                jarMastByWrkNo.setJarEnterStaNo(basJar.getEnterRgvNo());
                                jarMastByWrkNo.setEnterStaNo(basJar.getEnterRgvNo());
                                jarMastByWrkNo.setOutStaNo(basJar.getOutRgvNo());
                                //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 (!wrkMastExecutesA.isEmpty()){
                                WrkMastExecute wrkMastExecute = wrkMastExecutesA.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
@@ -7364,11 +7762,31 @@
                                continue;
                            }
                        }
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),3,SteStatusType.IDLE)){
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),3,SteStatusType.IDLE,false)){
                        List<WrkMastExecute> wrkMastExecutes = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 9, null);
                        if (wrkMastExecutes.isEmpty()){
                            List<WrkMastExecute> wrkMastExecutesB = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 6, null);
                            List<WrkMastExecute> wrkMastExecutesA = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 5, null);
                            List<WrkMastExecute> wrkMastExecutes100 = wrkMastExecuteService.selectWrkMastExecuteByTypeAndIoTyperAndWrkType(null, 100, null);
                            if (!wrkMastExecutes100.isEmpty()){
                                WrkMastExecute wrkMastExecute = wrkMastExecutes100.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
                                if (Cools.isEmpty(basJar)){
                                    log.error("{}号硫化罐查询设备档案无信息！！！",wrkMastExecute.getJarId());
                                    return false;
                                }

                                BasJarMast jarMastByWrkNo = new BasJarMast(basJar);
                                jarMastByWrkNo.setWrkNo(Integer.toUnsignedLong(wrkMastExecute.getWrkNo().intValue()));//工作号
                                jarMastByWrkNo.setJarEnterStaNo(basJar.getEnterRgvNo());
                                jarMastByWrkNo.setEnterStaNo(basJar.getEnterRgvNo());
                                jarMastByWrkNo.setOutStaNo(basJar.getOutRgvNo());
                                //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;
                            }
                            if (!wrkMastExecutesB.isEmpty() || !wrkMastExecutesA.isEmpty()){
                                WrkMastExecute wrkMastExecute = !wrkMastExecutesB.isEmpty() ? wrkMastExecutesB.get(0) : wrkMastExecutesA.get(0);
                                BasJar basJar = basJarMapper.selectById(wrkMastExecute.getJarId());
@@ -7398,5 +7816,189 @@
        }
        return false;
    }
    /**
     *  ste充电任务创建   //完成
     */
    public synchronized boolean jarChargeGenerate() {
        try{
            //80%电量 无任务  充电  >50电量  有任务  断电
            //30%电量  不接取任务  无进行中任务  充电     >50电量  有任务  断电
            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 || steProtocol.getChargeStatus()!=0) {
                    continue;
                }
                WrkMastExecute wrkMastExecuteByCharge = wrkMastExecuteService.getWrkMastExecuteByCharge(steSlave.getId());
                if (!Cools.isEmpty(wrkMastExecuteByCharge)){
                    continue;
                }

                if (steProtocol.getCharge()<30.0F){
                    if (wrkMastExecuteService.selectMoveStartCharge(steSlave.getId())!=0){
                        continue;
                    }
                } else if (steProtocol.getCharge()<80.0F){
                    List<BasJarMast> basJarMastList = basJarMastService.getJarMastByJarIdAndStatusListCharge(steSlave.getId(), new ArrayList<Integer>() {{
                        add(5);
                        add(11);
                        add(16);
                    }});
                    if(!basJarMastList.isEmpty()){
                        continue;
                    }
                    if (wrkMastExecuteService.selectNoStart(steSlave.getId())!=0){
                        continue;
                    }
                    if (wrkMastExecuteService.selectMoveStart(steSlave.getId())!=0){
                        continue;
                    }
                } else {
                    continue;
                }

                try{
                    boolean jarIDLESign = false;
                    if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),1,SteStatusType.IDLE,false)){
                        //生成充电任务
                        //A
                        BasJar basJar = basJarMapper.selectById(steSlave.getId()==1? 1:3);
                        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(7));//充电工作号
                        BasJarMast basJarMast = new BasJarMast(basJar);
                        basJarMast.setWrkNo(Integer.toUnsignedLong(workNo));//工作号
                        basJarMast.setJarEnterStaNo(basJar.getEnterRgvNo());
                        basJarMast.setEnterStaNo(basJar.getEnterRgvNo());
                        basJarMast.setOutStaNo(basJar.getOutRgvNo());
                        if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMast,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),100,1})){
                            log.error("JarWrkMastExecute充电任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMast));
                        }
                        continue;
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),2,SteStatusType.IDLE,false)){
                        jarIDLESign =true;
                    } else if (jarWrkMastExecuteGenerateSteStatus(steSlave.getId(),3,SteStatusType.IDLE,false)){
                        jarIDLESign =true;
                    }
                    if (jarIDLESign){
                        //生成充电任务
                        //C==>A
                        BasJar basJar = null;
                        List<BasJar> basJarList = basJarMapper.selectList(new EntityWrapper<BasJar>().eq("region", steSlave.getId()));
                        for (BasJar basJarNow : basJarList){
                            // 获取硫化罐信息0.0
                            JarThread jarThread = (JarThread) SlaveConnection.get(SlaveType.Jar, basJarNow.getJarNo());
                            JarProtocol jarProtocol = jarThread.getJarProtocol();
                            if (jarProtocol == null) {
                                continue;
                            }
                            if (jarProtocol.modeType != JarModeType.AUTO){
                                continue;
                            }
                            if (jarProtocol.statusType .equals(JarStatusType.SOS)){
                                continue;
                            }
                            if (jarProtocol.getJarTemperature()>50){
                                continue;
                            }
                            if (jarProtocol.leftDoorOpen != 0 || jarProtocol.rightDoorOpen != 0){
                                continue;
                            }
                            basJar = basJarNow;
                            break;
                        }
                        if (basJar == null){
                            continue;
                        }
                        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(7));//充电工作号
                        BasJarMast basJarMast = new BasJarMast(basJar);
                        basJarMast.setWrkNo(Integer.toUnsignedLong(workNo));//工作号
                        basJarMast.setJarEnterStaNo(basJar.getEnterRgvNo());
                        basJarMast.setEnterStaNo(basJar.getEnterRgvNo());
                        basJarMast.setOutStaNo(basJar.getOutRgvNo());
                        if (!jarWrkMastExecuteGenerateExecute(basJar,basJarMast,basJar.getJarNo(),new int[]{basJar.getOutSteNo(),basJar.getOutRgvNo(),100,1})){
                            log.error("JarWrkMastExecute充电任务创建===>执行异常===》异常数据：BasJar:"+ JSON.toJSONString(basJar)+";BasJarMast:"+JSON.toJSONString(basJarMast));
                        }
                    }
                }catch (Exception e){
                    log.error("充电任务创建异常,steProtocol={},异常信息={}",JSON.toJSONString(steProtocol),e.getMessage());
                }
            }
        } catch (Exception e){
            log.error("硫化区域分段任务完成异常,异常信息={}",e.getMessage());
        }
        return false;
    }
    /**
     *  Ste充电任务完成   //完成
     */
    public synchronized boolean jarChargeComplete() {
        try{
            //80%电量 无任务  充电  >50电量  有任务  断电
            //30%电量  不接取任务  无进行中任务  充电     >50电量  有任务  断电
            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 || steProtocol.getChargeStatus()!=1) {
                    continue;
                }

                if (steProtocol.getCharge()>95.0F || steProtocol.getFullCharge()){
                } else if (steProtocol.getCharge()>50.0F){
                    if (wrkMastExecuteService.selectNoStartCharge(steSlave.getId())==0){
                        if (wrkMastExecuteService.selectMoveStart(steSlave.getId())==0){
                            continue;
                        }
                    }
                } else {
                    continue;
                }

                WrkMastExecute wrkMastExecuteByCharge = wrkMastExecuteService.getWrkMastExecuteByCharge(steSlave.getId());
                if (Cools.isEmpty(wrkMastExecuteByCharge)){
                    BasJar basJar = basJarMapper.selectById(steSlave.getId()==1? 1:3);
                    int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(7));//充电工作号
                    BasJarMast basJarMast = new BasJarMast(basJar);
                    basJarMast.setWrkNo(Integer.toUnsignedLong(workNo));//工作号
                    basJarMast.setJarEnterStaNo(basJar.getEnterRgvNo());
                    basJarMast.setEnterStaNo(basJar.getEnterRgvNo());
                    basJarMast.setOutStaNo(basJar.getOutRgvNo());
                    wrkMastExecuteByCharge = new WrkMastExecute(basJarMast);
                    wrkMastExecuteByCharge.setJarId(basJar.getJarNo());
                    wrkMastExecuteByCharge.setSteId(steSlave.getId());//穿梭板ID
                    wrkMastExecuteByCharge.setRgvId(basJar.getEnterRgvNo());//RGV ID  enter
                    wrkMastExecuteByCharge.setRgvEndId(basJar.getOutRgvNo());//RGV ID  out
                    wrkMastExecuteByCharge.setIoType(100);//任务类型 0: 未知  1: 开进料门  2: 关进料门  3: 开出料门  4: 关出料门  5: 入硫化罐  6: 入冷却槽  7: 穿梭车进冷却槽  8: 穿梭车离开冷却槽  9: 出冷却槽 10：A=>B 11:B=>A  100:小车充电任务
                    wrkMastExecuteByCharge.setType(1);//设备  0: 未知  1: 硫化罐  2: 冷却槽  3: 硫化罐==>冷却槽
                }

                try{
                    if (jarWrkMastExecuteGenerateSteStatusCharge(steSlave.getId(),1,SteStatusType.CHARGE,true)){
                        //完成充电任务
                        //调车  == > 断开充电
                        if (!jarSteTake(wrkMastExecuteByCharge,SteLocaType.POINT20.id,SteLocaType.POINT20.id,SteTaskModeType.CLOSE_CHARGE,true,wrkMastExecuteByCharge.getJarId())){
                            log.error("穿梭板Ste命令下发失败，ste号={},任务数据={}",
                                    wrkMastExecuteByCharge.getSteId(), JSON.toJSONString(wrkMastExecuteByCharge));
                        }
                        wrkMastExecuteByCharge.setWrkType(2);
                        wrkMastExecuteByCharge.setWrkSts(100);
                        if (!wrkMastExecuteService.updateById(wrkMastExecuteByCharge)){
                            log.error("充电任务完成命令下发失败===>更新wrkMastExecute失败，ste号={},任务数据={}",
                                    wrkMastExecuteByCharge.getSteId(), JSON.toJSONString(wrkMastExecuteByCharge));
                        }
                    }
                }catch (Exception e){
                    log.error("充电任务完成异常,steProtocol={},异常信息={}",JSON.toJSONString(steProtocol),e.getMessage());
                }
            }
        } catch (Exception e){
            log.error("硫化区域分段任务完成异常,异常信息={}",e.getMessage());
        }
        return false;
    }

}